Explain the concept of a static async create method having identical parameters as the constructor

Question

Explain the concept of a static async create method having identical parameters as the constructor

I have a lot of existing classes that require refactoring to utilize an async constructor.

Here's an example:

class ClassA {
    constructor(a: number, b: string, c: string) {
        //...
    }
    //...
}

I've included an async create method:

class ClassA {

    // added async 
    static async create(...args: ConstructorParameters<typeof ClassA>){
        await loadSameResources()
        return new this(...args)
    }

    constructor(a: number, b: string, c: string) {
        //...
    }
}

It functions properly, users simply need to replace new ClassA(...) with (await ClassA.create(...)), which is straightforward and minimizes necessary changes.

My issue lies in how to avoid specifying 'ClassA' within the create function, similar to the example below so I can easily replicate this function in every class (without altering class inheritance).

    // added async 
    static async create(...args: ConstructorParameters<typeof this >){ // error here
        await loadSameResources()
        return new this(...args)
    }

typescript

Answer 1

Answer №1

One approach is to have the constructor invoke a hidden initializer function, which simplifies parameter extraction.

class MyClass {

    // include async keyword
    static async initialize(...args: Parameters<typeof this.prototype.setup>){
        await loadResources(() => {})
        return new this(...args)
    }

    constructor(...args: Parameters<typeof this.setup>) {
        this.setup(...args)
    }

    private setup(x: number, y: string, z: string) {}
}

By having all constructors call the private setup method, it becomes straightforward for them and the initialize function to deduce their respective parameter types from setup.

This implementation allows you to easily transfer both functions to multiple classes without modifications needed.

If there's no need to expose the constructor, consider making it private as suggested by other users.

Answer 2

One approach is to have the constructor invoke a hidden initializer function, which simplifies parameter extraction.

class MyClass {

    // include async keyword
    static async initialize(...args: Parameters<typeof this.prototype.setup>){
        await loadResources(() => {})
        return new this(...args)
    }

    constructor(...args: Parameters<typeof this.setup>) {
        this.setup(...args)
    }

    private setup(x: number, y: string, z: string) {}
}

By having all constructors call the private setup method, it becomes straightforward for them and the initialize function to deduce their respective parameter types from setup.

This implementation allows you to easily transfer both functions to multiple classes without modifications needed.

If there's no need to expose the constructor, consider making it private as suggested by other users.

Answer 3

Answer №2

When it comes to altering the target semantics, there's a simple solution that involves creating a generic function to construct your instances:

import { Constructor } from 'type-fest'

async function create<TInstance>(Class: Constructor<TInstance>, ...args: ConstructorParameters<typeof Class>) {
    await loadSameResources()
    return new Class(...args)
}

const a = await create(ClassA, 0, 'b', 'c')
//    ^? const a: ClassA

Playground Link

Benefits:

The create function is centralized in one place for easier maintenance
No modifications needed to your current classes

Alternatively, if you want to maintain your target semantics ((await ClassA.create(...))) while using a slightly more complicated method, you can utilize a Class Mixin:

function WithCreateMixin<TInstance extends object>(BaseClass: Constructor<TInstance>) {
    return class BaseClassWithCreate extends BaseClass {
        static async create(...args: ConstructorParameters<typeof BaseClass>) {
            await loadSameResources()
            return new BaseClass(...args)
        }
    }
}

class ClassA extends WithCreateMixin(class ClassA0 {
    constructor(a: number, b: string, c: string) {
        //...
    }
    //...
}) { }

const a = await ClassA.create(0, 'b', 'c')
//    ^? const a: ClassA0

Playground Link

The create static function continues to be centrally defined, but now requires wrapping existing classes (with

class ClassX extends WithCreateMixin(/* original class */) { }

).

Answer 4

When it comes to altering the target semantics, there's a simple solution that involves creating a generic function to construct your instances:

import { Constructor } from 'type-fest'

async function create<TInstance>(Class: Constructor<TInstance>, ...args: ConstructorParameters<typeof Class>) {
    await loadSameResources()
    return new Class(...args)
}

const a = await create(ClassA, 0, 'b', 'c')
//    ^? const a: ClassA

Playground Link

Benefits:

The create function is centralized in one place for easier maintenance
No modifications needed to your current classes

Alternatively, if you want to maintain your target semantics ((await ClassA.create(...))) while using a slightly more complicated method, you can utilize a Class Mixin:

function WithCreateMixin<TInstance extends object>(BaseClass: Constructor<TInstance>) {
    return class BaseClassWithCreate extends BaseClass {
        static async create(...args: ConstructorParameters<typeof BaseClass>) {
            await loadSameResources()
            return new BaseClass(...args)
        }
    }
}

class ClassA extends WithCreateMixin(class ClassA0 {
    constructor(a: number, b: string, c: string) {
        //...
    }
    //...
}) { }

const a = await ClassA.create(0, 'b', 'c')
//    ^? const a: ClassA0

Playground Link

The create static function continues to be centrally defined, but now requires wrapping existing classes (with

class ClassX extends WithCreateMixin(/* original class */) { }

).

Explain the concept of a static async create method having identical parameters as the constructor

Answer №1

Answer №2

Similar questions

Concise way to add or insert an element into an array, at a specific property of an object

Exploring methods to access specific values from an array containing multiple values using Lodash in Angular 4

Utilizing shared components across a Next.js application within a monorepo

Activate function on Ctrl + K in a React TypeScript project

Error in Visual Studio 2019 - TypeScript version discrepancy

Misunderstanding the concept of always being right

Unable to assign user roles in next-auth due to the absence of matching modifiers for user

Using *ngFor in TypeScript code

Adding attributes to parent DOM elements of a component in Angular2: A Step-by-Step Guide

Enhance your coding experience with TypeScript's autocomplete in Visual Studio Code

Module '@types/mongodb' could not be located

Generating an iFrame in Angular with real-time data from Observable sources

Increase the timestamp in Typescript by one hour

Tips for utilizing the "this" keyword in TypeScript

Find the object in the array that has a name that is a combination of

Unable to bind to property as it is not recognized as a valid attribute of the selector component

Include TypeScript in a single component within an already established Vue project

Storing application state using rxjs observables in an Angular application

Lazy-loading modules in SSR Angular 8 applications are currently unspecified

The type definition file for '@types' is not present in Ionic's code base