Discovering the interface type of class properties in order to implement a factory method

Question

Discovering the interface type of class properties in order to implement a factory method

I am struggling with implementing a factory method in my code. I want to be able to pass not only a Class type to instantiate but also a set of default values for the properties within the class. My goal is to have the compiler notify me if I try to pass in properties that do not exist in the class type being instantiated. However, I can't seem to figure out how to achieve this.

Here is a basic example illustrating what I am trying to accomplish:

When attempting this, I encounter a compiler error stating: "An interface may only extend a class or another interface." for the interface ClassProps since it cannot extend from T.

class Base {
   myId: number;
}

class Klass1 extends Base {
   myString: string;
   myNumber: number;
}

interface IBaseCtr<T> {
   new (): T;
}

// Obtain an interface representing the properties of the passed class
interface ClassProps<T extends Base> extends T {}

function factory<T extends Base>(ctrFunc: IBaseCtr<T>, initialData?: ClassProps<T>): T {
   let new_obj = new ctrFunc();
   Object.assign(new_obj, initialData);
   return new_obj;
}

let v1 = factory(Klass1, {myId: 10, myString: 'foo'});
let v2 = factory(Klass1, {badVar: 10});

Do you have any suggestions on how to type initialData so that it will highlight badVar as not permissible in the second call?

typescript

Answer 1

Answer №1

This question is truly delightful.

My approach here is to eliminate that interface completely.

function createInstance<T extends V, V extends Base>(ctrFunc: IBaseCtr<T>,
                                 initialData?: V): T
{
   let new_obj = new ctrFunc();
   Object.assign(new_obj, initialData);
   return new_obj;
}

In this setup, Base represents a subset of properties in V, which in turn is a subset of properties in T (the final type). The assignment of v1 works smoothly. However, the statement assigning v2 triggers a compile-time error.

If you wish, you may remove the extends Base part to broaden the applicability of this function. It will still undergo the same type checking process.

Just for fun, here's an entirely separate factory function signature that passes the type checking:

function createInstance<T extends V, V>(ctrFunc: new () => T,
                                 initialData?: V): T

Answer 2

This question is truly delightful.

My approach here is to eliminate that interface completely.

function createInstance<T extends V, V extends Base>(ctrFunc: IBaseCtr<T>,
                                 initialData?: V): T
{
   let new_obj = new ctrFunc();
   Object.assign(new_obj, initialData);
   return new_obj;
}

In this setup, Base represents a subset of properties in V, which in turn is a subset of properties in T (the final type). The assignment of v1 works smoothly. However, the statement assigning v2 triggers a compile-time error.

If you wish, you may remove the extends Base part to broaden the applicability of this function. It will still undergo the same type checking process.

Just for fun, here's an entirely separate factory function signature that passes the type checking:

function createInstance<T extends V, V>(ctrFunc: new () => T,
                                 initialData?: V): T

Answer 3

Answer №2

My approach differs slightly from yours, but here is the code:

interface BasicProperties {
    id: number;
}

class BaseClass<T extends BasicProperties> {
    protected id: number;

    initialize(properties: T): void {
        this.id = properties.id;
    }
}

interface MyClassProperties extends BasicProperties {
    valueString: string;
    valueNumber: number
}

class MyClass extends BaseClass<MyClassProperties> {
    private valueString: string;
    private valueNumber: number;

    initialize(properties: MyClassProperties): void {
        super.initialize(properties);

        this.valueString = properties.valueString;
        this.valueNumber = properties.valueNumber;
    }
}

interface IBaseConstructor<T> {
    new (): T;
}

function createInstance<P extends BasicProperties, T extends BaseClass<P>>(constructorFunc: IBaseConstructor<T>, initialData?: P): T {
    let newObj = new constructorFun();
    newObj.initialize(initialData);
    return newObj;
}


let instance1 = createInstance(MyClass, {id: 10, valueString: 'bar'});

let instance2 = createInstance(MyClass, {badVar: 20});

This fulfills your requirements, where the second call to createInstance results in a compilation error.

I set the class members as private/protected and opted for an initialize method instead of using Object.assign for assigning values.
Why? because it aligns better with object-oriented principles. This way, you can leverage the class hierarchy when setting values by using super.initialize (or choosing not to call it in certain scenarios).
In essence, this provides more flexibility and control.

Check out the code on TypeScript Playground

Answer 4

My approach differs slightly from yours, but here is the code:

interface BasicProperties {
    id: number;
}

class BaseClass<T extends BasicProperties> {
    protected id: number;

    initialize(properties: T): void {
        this.id = properties.id;
    }
}

interface MyClassProperties extends BasicProperties {
    valueString: string;
    valueNumber: number
}

class MyClass extends BaseClass<MyClassProperties> {
    private valueString: string;
    private valueNumber: number;

    initialize(properties: MyClassProperties): void {
        super.initialize(properties);

        this.valueString = properties.valueString;
        this.valueNumber = properties.valueNumber;
    }
}

interface IBaseConstructor<T> {
    new (): T;
}

function createInstance<P extends BasicProperties, T extends BaseClass<P>>(constructorFunc: IBaseConstructor<T>, initialData?: P): T {
    let newObj = new constructorFun();
    newObj.initialize(initialData);
    return newObj;
}


let instance1 = createInstance(MyClass, {id: 10, valueString: 'bar'});

let instance2 = createInstance(MyClass, {badVar: 20});

This fulfills your requirements, where the second call to createInstance results in a compilation error.

I set the class members as private/protected and opted for an initialize method instead of using Object.assign for assigning values.
Why? because it aligns better with object-oriented principles. This way, you can leverage the class hierarchy when setting values by using super.initialize (or choosing not to call it in certain scenarios).
In essence, this provides more flexibility and control.

Check out the code on TypeScript Playground

Discovering the interface type of class properties in order to implement a factory method

Answer №1

Answer №2

Similar questions

Apply criteria to an array based on multiple attribute conditions

Tips for effectively transmitting data while utilizing a declarative/reactive data access method with RxJS in Angular?

Using NextJS's API routes to implement Spotify's authorization flow results in a CORS error

Execute supplementary build scripts during the angular build process

When incorporating an array as a type in Typescript, leverage the keyof keyword for improved

Using TypeScript with Next.js getStaticProps causes errors

What is the reason behind installing both Typescript and Javascript in Next.js?

Angular findIndex troubleshooting: solutions and tips

Issue with Material UI DateTimePicker not submitting default form value

Tips for sending a timestamp as input to a stored procedure in TypeScript with the mssql module

What is the correct way to import scss files in a Next.js project?

Generate a fresh array by filtering objects based on their unique IDs using Angular/Typescript

Simulating TypeDI service behavior in Jest

Retrieve the final variable in an Observable sequence

Discovering the import path of Node modules in ReactAlgorithm for determining the import path of

Utilizing Typescript's type inference within a universal "promisify" function

Angular 5 - Jasmine Tests explained: Encounter with the puzzling error message: "Error: Provider for the NgModule 'DynamicTestModule' is invalid, as only instances of Provider and Type are permitted"

Substitute all attributes of objects with a different designation

Error in Angular 2 after transition to @types: encountering "require" name not found issue

Passing a custom data type from a parent component to a child component in React