How to convert a JSON object to a type, converting strings to types, in TypeScript?

I have this TS playground:

const base = {
  user: {
    id: { type: 'string' },
    name: { type: 'string' }
  },
  post: {
    id: { type: 'string' },
    title: { type: 'string' },
    published: { type: 'boolean', defaultsTo: false },
    likes: { type: 'number', defaultsTo: 0 }
  }
}

type GoalType = {
  user: {
    id: string
    name: string
  }
  post: {
    id: string
    title: string
    published: boolean
  }
}

type InterpolateType<T> = {
  [K1 in T]: {
    [K2 in T[K1]]: T[K1]['type'] extends 'string' ? string : boolean
  }
}

type FoundType = InterpolateType<typeof base>

How can I convert the base object through typeof base to the GoalType, as I tried to do with type FoundType = InterpolateType<typeof base>?

We first need to use const assertion to prevent the compiler from widening the type:

const base = {
  user: {
    id: { type: "string" },
    name: { type: "string" },
  },
  post: {
    id: { type: "string" },
    title: { type: "string" },
    published: { type: "boolean", defaultsTo: false },
    likes: { type: "number", defaultsTo: 0 },
    likesArr: { list: "true", type: ["string", "boolean"] },
  },
} as const;

We will also need a string to type map type:

type StringToType = {
  string: string;
  boolean: boolean;
  number: number;
};

To interpolate, we will map through the type and check if the type of its property is in the StringToType. If it is there, we just return the StringToType[type], otherwise, we check whether the property is a list with {list: "true", type: readonly unknown[]}. If the condition is true we pass the elements of type to StringToType by using number as the index to retrieve all the elements in the type: StringToType[T[K][K2]["type"][number] & keyof StringToType]. We need to intersect with keyof StringToType to make sure that we only pass the values that exist in the StringToType. Finally, we make the array out of that by appending [] at the end. If none of the above conditions are true we just return the type itself without any modification.

type InterpolateType<T> = {
  [K in keyof T]: {
    [K2 in keyof T[K]]: "type" extends keyof T[K][K2]
      ? T[K][K2]["type"] extends keyof StringToType
        ? StringToType[T[K][K2]["type"]]
        : T[K][K2] extends { list: "true"; type: readonly unknown[] }
        ? StringToType[T[K][K2]["type"][number] & keyof StringToType][]
        : T[K][K2]["type"]
      : T[K][K2];
  };
};

Usage:

// type Result = {
//     readonly user: {
//         readonly id: string;
//         readonly name: string;
//     };
//     readonly post: {
//         readonly id: string;
//         readonly title: string;
//         readonly published: boolean;
//         readonly likes: number;
//         readonly likesArr: (string | boolean)[];
//     };
// }
type Result = InterpolateType<typeof base>;

playground