47 replies

Dynamic type generation problem

My team has run into a typescript problem related to dynamic type generation and we need help.

I have to use decorators to generate models in an Object Graph Mapping(OGM) lib for Neo4J called Neogma. You can check out the docs here: (https://themetalfleece.github.io/neogma/)

As the docs show, the models are currently being built using a model factory method that takes in 4 type params which are used to define/constrain the types of the params the function accepts.

Properties

Properties

: this type describes the properties of the model that's being created.

RelatedNodesToAssociateI

RelatedNodesToAssociateI

: this type describes the relationships the model that's being defined has with other models.

Methods

Methods

: this type describes methods that are to be included on the defined model. Since the model class is being generated in the model factory, if we needed to define methods on it, we'd pass them here and they'd get defined in the factory.

Statics

Statics

: this type does pretty much the same as MethodsI but for static functions to be defined on the resulting model class.

I'm Implementing a set of decorators that generate/extract metadata from a facade class, which I use to generate the models. I use

reflect-metadata

reflect-metadata

to store this metadata when it's generated and I've successfully managed to abstract away the model creation logic.

We use decorators to describe a model:

const projectLabel = 'ProjectA';

@Model({ label: projectLabel })

class Project {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;

    @Property({
        schema: {
            type: 'number',
        },
    })
    teamSize: number;
}

const projectsRelationOptions = {
    model: Project,
    name: 'HAS_PROJECT',
    direction: 'out',
} as ModelRelationshipDecoratorOptions;

@Model()
class Worker {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;
    @Property({
        schema: {
            type: 'number',
        },
    })

    age: number;

    @Relationship(projectsRelationOptions)
    projects: Project[];
}

const projectLabel = 'ProjectA';

@Model({ label: projectLabel })

class Project {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;

    @Property({
        schema: {
            type: 'number',
        },
    })
    teamSize: number;
}

const projectsRelationOptions = {
    model: Project,
    name: 'HAS_PROJECT',
    direction: 'out',
} as ModelRelationshipDecoratorOptions;

@Model()
class Worker {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;
    @Property({
        schema: {
            type: 'number',
        },
    })

    age: number;

    @Relationship(projectsRelationOptions)
    projects: Project[];
}

These functions allow me to pass in a class signature as object and use it under the hood to retrieve the metadata the decorators have stored with

reflect-metadata

reflect-metadata

.
I use custom helper methods to parse the metadata into the format expected by the

ModelFactory

ModelFactory

function.

I need a way to generate dynamic types on the fly from the metadata to pass to the ModelFactory function type params so that I don't lose all typing and so the correct model props and members get generated.

public generateModelFromMetadata = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
metadata: NeogmaModelMetadata,
): NeogmaModel<P, R, M, S> => {
    const parsedMetadata = parseModelMetadata(metadata);
    const relationships = parsedMetadata.relationships ?? [];
    for (const relationship in relationships) {
        const relatedModel = metadata.relationships[relationship].model;
        if (relatedModel === 'self') {
            continue;
        }
        const relatedModelLabel = relatedModel['name'];
        if (this.models[relatedModelLabel]) {
            relationships[relationship].model = this.models[relatedModelLabel];
        } else {
            const relatedModelMetadata = getRelatedModelMetadata(relatedModel);
            relationships[relationship].model =
            this.generateModelFromMetadata(relatedModelMetadata);
        }
    }

    return ModelFactory(parsedMetadata, this) as unknown as NeogmaModel<
    P,
    R,
    M,
    S
    >;
};

public addModel = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
    model: Object,
    ): NeogmaModel<P, R, M, S> => {
        const metadata = getModelMetadata(model);
        return this.generateModelFromMetadata(metadata);
    };

public generateModelFromMetadata = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
metadata: NeogmaModelMetadata,
): NeogmaModel<P, R, M, S> => {
    const parsedMetadata = parseModelMetadata(metadata);
    const relationships = parsedMetadata.relationships ?? [];
    for (const relationship in relationships) {
        const relatedModel = metadata.relationships[relationship].model;
        if (relatedModel === 'self') {
            continue;
        }
        const relatedModelLabel = relatedModel['name'];
        if (this.models[relatedModelLabel]) {
            relationships[relationship].model = this.models[relatedModelLabel];
        } else {
            const relatedModelMetadata = getRelatedModelMetadata(relatedModel);
            relationships[relationship].model =
            this.generateModelFromMetadata(relatedModelMetadata);
        }
    }

    return ModelFactory(parsedMetadata, this) as unknown as NeogmaModel<
    P,
    R,
    M,
    S
    >;
};

public addModel = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
    model: Object,
    ): NeogmaModel<P, R, M, S> => {
        const metadata = getModelMetadata(model);
        return this.generateModelFromMetadata(metadata);
    };

How do to this?

Dynamic type generation problem

Properties

Properties

: this type describes the properties of the model that's being created.

RelatedNodesToAssociateI

RelatedNodesToAssociateI

: this type describes the relationships the model that's being defined has with other models.

Methods

Methods

Statics

Statics

reflect-metadata

reflect-metadata

to store this metadata when it's generated and I've successfully managed to abstract away the model creation logic.

We use decorators to describe a model:

const projectLabel = 'ProjectA';

@Model({ label: projectLabel })

class Project {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;

    @Property({
        schema: {
            type: 'number',
        },
    })
    teamSize: number;
}

const projectsRelationOptions = {
    model: Project,
    name: 'HAS_PROJECT',
    direction: 'out',
} as ModelRelationshipDecoratorOptions;

@Model()
class Worker {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;
    @Property({
        schema: {
            type: 'number',
        },
    })

    age: number;

    @Relationship(projectsRelationOptions)
    projects: Project[];
}

const projectLabel = 'ProjectA';

@Model({ label: projectLabel })

class Project {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;

    @Property({
        schema: {
            type: 'number',
        },
    })
    teamSize: number;
}

const projectsRelationOptions = {
    model: Project,
    name: 'HAS_PROJECT',
    direction: 'out',
} as ModelRelationshipDecoratorOptions;

@Model()
class Worker {
    @Property({
        schema: {
            type: 'string',
        },
    })
    name: string;
    @Property({
        schema: {
            type: 'number',
        },
    })

    age: number;

    @Relationship(projectsRelationOptions)
    projects: Project[];
}

These functions allow me to pass in a class signature as object and use it under the hood to retrieve the metadata the decorators have stored with

reflect-metadata

reflect-metadata

.
I use custom helper methods to parse the metadata into the format expected by the

ModelFactory

ModelFactory

public generateModelFromMetadata = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
metadata: NeogmaModelMetadata,
): NeogmaModel<P, R, M, S> => {
    const parsedMetadata = parseModelMetadata(metadata);
    const relationships = parsedMetadata.relationships ?? [];
    for (const relationship in relationships) {
        const relatedModel = metadata.relationships[relationship].model;
        if (relatedModel === 'self') {
            continue;
        }
        const relatedModelLabel = relatedModel['name'];
        if (this.models[relatedModelLabel]) {
            relationships[relationship].model = this.models[relatedModelLabel];
        } else {
            const relatedModelMetadata = getRelatedModelMetadata(relatedModel);
            relationships[relationship].model =
            this.generateModelFromMetadata(relatedModelMetadata);
        }
    }

    return ModelFactory(parsedMetadata, this) as unknown as NeogmaModel<
    P,
    R,
    M,
    S
    >;
};

public addModel = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
    model: Object,
    ): NeogmaModel<P, R, M, S> => {
        const metadata = getModelMetadata(model);
        return this.generateModelFromMetadata(metadata);
    };

public generateModelFromMetadata = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
metadata: NeogmaModelMetadata,
): NeogmaModel<P, R, M, S> => {
    const parsedMetadata = parseModelMetadata(metadata);
    const relationships = parsedMetadata.relationships ?? [];
    for (const relationship in relationships) {
        const relatedModel = metadata.relationships[relationship].model;
        if (relatedModel === 'self') {
            continue;
        }
        const relatedModelLabel = relatedModel['name'];
        if (this.models[relatedModelLabel]) {
            relationships[relationship].model = this.models[relatedModelLabel];
        } else {
            const relatedModelMetadata = getRelatedModelMetadata(relatedModel);
            relationships[relationship].model =
            this.generateModelFromMetadata(relatedModelMetadata);
        }
    }

    return ModelFactory(parsedMetadata, this) as unknown as NeogmaModel<
    P,
    R,
    M,
    S
    >;
};

public addModel = <
P extends Neo4jSupportedProperties,
R extends AnyObject = object,
M extends AnyObject = object,
S extends AnyObject = object,
>(
    model: Object,
    ): NeogmaModel<P, R, M, S> => {
        const metadata = getModelMetadata(model);
        return this.generateModelFromMetadata(metadata);
    };

How do to this?

Dynamic type generation problem

Dynamic type generation problem

Similar Threads

Similar Threads

Similar Threads