Wondering what’s next for npm?Check out our public roadmap! »

    ts-generic-builder
    TypeScript icon, indicating that this package has built-in type declarations

    1.0.3 • Public • Published

    Type-safe and generic implementation of the build pattern in Typescript

    How to use it

    Simple usage

    • Conditions:
      • No methods in class
      • No need to keep properties private and controlling object manipulation
    // Usage of the Builder
    const person: Person = new Builder(Person)
        .with({ firstname: 'Magne' })
        .with({ surname: 'Thor' })
        .with({ birthday: new Date('2000-01-11') })
        .build();
     
     
    // Optional implementation of the Validatable interface. Builder calls validate() *BEFORE* an object is build.
    class Person implements Validatable {
        public readonly title?: string;
        public readonly firstname: string;
        public readonly surname: string;
        public readonly birthday?: Date;
     
        constructor(builder: Builder<Person> & Person) {
            this.title = builder.title;
            this.firstname = builder.firstname;
            this.surname = builder.surname;
            this.birthday = builder.birthday;
        }
     
        validate(): boolean {
            // Do your validation here
            return true;
        }
    }

    Usage in the context of Domain Driven Design

    • Use cases:
      • Model is implemented in domain driven fassion, that is class contains methods which are encapsulating business logic
      • Property access is kept private to enforce object manipulation through business logic methods
    // Usage of the DomainBuilder
    const correctVo: PersonVo = new DomainBuilder(PersonVo)
        .with({ firstname: 'Magne' })
        .with({ surname: 'Thor' })
        .with({ birthday: new Date('2000-01-11') })
        .build();
     
    // Model definition
    interface PersonProps extends Validatable {
        readonly title?: string;
        readonly firstname: string;
        readonly surname: string;
        readonly birthday?: Date;
    }
     
    export class PersonVo implements PersonProps {
        private _title?: string;
        private _firstname: string;
        private _surname: string;
        private _birthday?: Date;
     
        constructor(builder: DomainBuilder<PersonProps, PersonVo> & PersonProps) {
            this._title = builder.title;
            this._firstname = builder.firstname;
            this._surname = builder.surname;
            this._birthday = builder.birthday;
        }
     
        get title(): string | undefined {
            return this._title;
        }
        get firstname(): string {
            return this._firstname;
        }
        get surname(): string {
            return this._surname;
        }
        get birthday(): Date | undefined {
            return this._birthday;
        }
     
        validate(): boolean {
            // Do your validation here
            return true;
        }
     
        public changeSurname(newName: string): void {
            this._surname = newName;
        }
    }

    Implementation of Validatable interface

    Implement the Validatable interface if you want to run validations before the builder creates the object.

    Install

    npm i ts-generic-builder

    DownloadsWeekly Downloads

    16

    Version

    1.0.3

    License

    MIT

    Unpacked Size

    18.4 kB

    Total Files

    14

    Last publish

    Collaborators

    • avatar