Convert Schema to a Type

I would like to convert this schema object:

const userSchema = {
  name: { type: String },
  age: { type: Number },
};

To it's equivalent type, is it possible?

type userType = {
  name: string;
  age: number
}

My approach was to create an object based on the schema, and then use typeof to get a type, but the compiler doesn't recognize the props 😢

Current attempt:

type schemaType = {
  [key: string]: {
    type?: StringConstructor | DateConstructor | NumberConstructor;
  };
};

type resultType = {
  [key: string]: String | Date | Number;
};

const createPropsFromSchema = (schema: schemaType) => {
  const result = { id: "" } as resultType;

  Object.keys(schema).forEach((key) => {
    if (schema[key].type == String) {
      result[key] = "";
    } else if (schema[key].type == Date) {
      result[key] = new Date();
    } else if (schema[key].type == Number) {
      result[key] = 0;
    }
  });

  return result;
};

const userSchema = {
  name: { type: String },
  age: { type: Number },
};

const userProps = createPropsFromSchema(userSchema);

console.log(userProps.name); //why the compiler didn't suggest "name"?

The problem is not super trivial, but depending on the amount of functionality you need, how many different types etc can the properties be.. etc, can they be objects or other collection, it can be simplified a bit. And generally the solution can be extended fairly easily if more functionality is needed.

I don't know, is there a reason why to use string, number..etc constructors rather than just a string to represent the type like 'string', 'number'. Does not matter too much but can simplify things.

If we assume initially that the object will contain only string, number and date constructor we can first create a type that takes one of these and returns the corresponding type.

type PropertyType = [
  StringConstructor,
  NumberConstructor,
  DateConstructor
][number];

type ConstructorType<T extends PropertyType> = T extends StringConstructor
  ? string
  : T extends NumberConstructor
  ? number
  : T extends DateConstructor
  ? Date
  : never;

PropertyType just defined the allowed types for the properties. Then ConstructorType is a type defined to check if the passed type is one of these and return the corresponding type.

If using strings instead of constructors this could just be a type like

type PrimitiveTypeMap = {
  string: string;
  number: number;
  boolean: boolean;
  // ...etc
};

can easily add any primitives, but this is besides is besides the point.

Then you need a type that takes the object, here again we make the assumption that the object is of type record with string keys and values of the type {type:PropertyType }

type InferObjectSchema<T extends Record<string, { type: PropertyType }>> = {
  [K in keyof T]: ConstructorType<T[K]["type"]>;
};

This just creates a mapped type that applies the previously defined type to each value in the object.

Here's playground link