Curious Question: Can a class be created based on a specific prototype?

Question

Curious Question: Can a class be created based on a specific prototype?

Imagine you have an existing schema definition object like this:

const schema = { prop1: { type: String, maxLength: 8 }, prop2... };

Now, the challenge is to create a class that can generate documents using properties extracted from the schema without having to declare an interface for each schema object. Is it possible?

You might want something similar to the following in your application:

// schema definition:
const PersonSchema = { name: { type: String, maxLength: 8 } };

// class factory
const PersonClass = SchemaClassFactory(PersonSchema);

// instance with props defined in schema.
let person1 = new PersonClass();
person1.name = 'Jack'; 
let person2 = new PersonClass();
person2.name = 3; // This should be flagged as an error by tslint.

How can you achieve this functionality efficiently?

mongodb typescript

Answer 1

Answer №1

If you want to generate a class for the schema object by using mapped types and conditional types to extract the structure of the object from the schema, one approach is detailed below. It may not cover all possible ways of defining the schema in mongoose, but it serves as a good starting point:

const PersonSchema = { 
    name: { type: String, maxLength: 8 },
    age: { type: Number },
    title: String,
    id: ObjectID
};

type PrimitiveConstructor<T> = {
    new (...a: any[]): any; 
    (...a: any[]): T
}

type Constructor<T> = {
    new (...a: any[]): T; 
}
type ExtractType<T> = {
    [P in keyof T] : 
        T[P] extends PrimitiveConstructor<infer U>? U :
        T[P] extends { type: PrimitiveConstructor<infer U> } ? U:
        T[P] extends Constructor<infer U> ? U :
        T[P] extends { type: Constructor<infer U> } ? U:
        never
}
function createClass<T>(schema: T): new (data?: Partial<ExtractType<T>>) => ExtractType<T> {
    // The class will not have the fields explicitly defined since we don't know them but that is fine 
    return new class {
        // Optional constructor for assigning data to the fields, you can remove this if not needed
        constructor(data?: any){
            if(data) {
                Object.assign(this, data);
            }
        }
    } as any;
}


var PersonClass = createClass(PersonSchema);
type PersonClass = InstanceType<typeof PersonClass>

let p = new PersonClass();
p.name ="";
p.name = 2; // error
p.id = new ObjectID(10);
let p2 = new PersonClass({
    name: "",
});

Answer 2

If you want to generate a class for the schema object by using mapped types and conditional types to extract the structure of the object from the schema, one approach is detailed below. It may not cover all possible ways of defining the schema in mongoose, but it serves as a good starting point:

const PersonSchema = { 
    name: { type: String, maxLength: 8 },
    age: { type: Number },
    title: String,
    id: ObjectID
};

type PrimitiveConstructor<T> = {
    new (...a: any[]): any; 
    (...a: any[]): T
}

type Constructor<T> = {
    new (...a: any[]): T; 
}
type ExtractType<T> = {
    [P in keyof T] : 
        T[P] extends PrimitiveConstructor<infer U>? U :
        T[P] extends { type: PrimitiveConstructor<infer U> } ? U:
        T[P] extends Constructor<infer U> ? U :
        T[P] extends { type: Constructor<infer U> } ? U:
        never
}
function createClass<T>(schema: T): new (data?: Partial<ExtractType<T>>) => ExtractType<T> {
    // The class will not have the fields explicitly defined since we don't know them but that is fine 
    return new class {
        // Optional constructor for assigning data to the fields, you can remove this if not needed
        constructor(data?: any){
            if(data) {
                Object.assign(this, data);
            }
        }
    } as any;
}


var PersonClass = createClass(PersonSchema);
type PersonClass = InstanceType<typeof PersonClass>

let p = new PersonClass();
p.name ="";
p.name = 2; // error
p.id = new ObjectID(10);
let p2 = new PersonClass({
    name: "",
});

Curious Question: Can a class be created based on a specific prototype?

Answer №1

Similar questions

When using the Angular checkbox, remember to keep one box checked at all times

Is the transcluded content visible to the class as a whole?

Tips for accessing attributes within an array of objects using Handlebars

Is it possible to encounter a MongoDB error for the $or operator in a correctly formatted query?

Here's a way to resolve the issue: ReactDOM.render() - TS2345 error: Cannot assign type '() => Element' to type 'ReactElement' in the argument

When trying to upload a file with ng-upload in Angular, the error 'TypeError: Cannot read properties of undefined (reading 'memes')' is encountered

Is it feasible to invoke a method without any arguments on this basic subscription?

Unable to remove element from database using Mongoose $pull

Transforming the MongoDB project into a collection

Retrieving data from multiple collections using Mongoose

Efficient method for performing bulk delete operations in MongoDB aggregation with Python

How can you determine the data types of properties within a blank class object using Typescript and Angular?

Declaring module public type definitions for NPM in Typescript: A comprehensive guide

Guide to organizing a MongoDB query based on the ratio of two fields within each document

Incorrect deduction of the argument type for a higher-order function

Combine and transform two files using array structures

The connection between Mongoose and the nodejs app cannot be established

"Add a pre-hook in mongoose to update a field in findOneAndUpdate by retrieving data from a

What is the method for inserting an object into a jsonArray in TypeScript?

The maximum nested function level has been reached at tsc:1. Consider increasing the FUNCNEST limit