swaf/src/db/Model.ts

import MysqlConnectionManager, {query} from "./MysqlConnectionManager";
import Validator from "./Validator";
import {Connection} from "mysql";
import ModelComponent from "./ModelComponent";
import {Type} from "../Utils";
import ModelFactory from "./ModelFactory";
import ModelRelation from "./ModelRelation";
import ModelQuery, {ModelQueryResult, SelectFields} from "./ModelQuery";
import {Request} from "express";
import Extendable from "../Extendable";

export default abstract class Model implements Extendable<ModelComponent<Model>> {
    public static get table(): string {
        return this.name
                .replace(/(?:^|\.?)([A-Z])/g, (x, y) => '_' + y.toLowerCase())
                .replace(/^_/, '')
            + 's';
    }

    public static getPrimaryKeyFields(): string[] {
        return ['id'];
    }

    public static create<T extends Model>(this: ModelType<T>, data: any): T {
        return ModelFactory.get(this).create(data, true);
    }

    public static select<T extends Model>(this: ModelType<T>, ...fields: SelectFields): ModelQuery<T> {
        return ModelFactory.get(this).select(...fields);
    }

    public static update<T extends Model>(this: ModelType<T>, data: { [key: string]: any }): ModelQuery<T> {
        return ModelFactory.get(this).update(data);
    }

    public static delete<T extends Model>(this: ModelType<T>): ModelQuery<T> {
        return ModelFactory.get(this).delete();
    }

    public static async getById<T extends Model>(this: ModelType<T>, ...id: any): Promise<T | null> {
        return ModelFactory.get(this).getById(...id);
    }

    public static async paginate<T extends Model>(this: ModelType<T>, request: Request, perPage: number = 20, query?: ModelQuery<T>): Promise<ModelQueryResult<T>> {
        return ModelFactory.get(this).paginate(request, perPage, query);
    }

    protected readonly _factory: ModelFactory<Model>;
    private readonly _components: ModelComponent<this>[] = [];
    private readonly _validators: { [key: string]: Validator<any> | undefined } = {};
    private _exists: boolean;

    [key: string]: any;

    public constructor(factory: ModelFactory<Model>, isNew: boolean) {
        if (!factory || !(factory instanceof ModelFactory)) throw new Error('Cannot instantiate model directly.');
        this._factory = factory;
        this.init();
        this._exists = !isNew;
    }

    protected abstract init(): void;

    protected setValidation<T>(propertyName: keyof this): Validator<T> {
        const validator = new Validator<T>();
        this._validators[propertyName as string] = validator;
        return validator;
    }

    public addComponent(modelComponent: ModelComponent<this>): void {
        modelComponent.applyToModel();
        this._components.push(modelComponent);
    }

    public as<C extends ModelComponent<Model>>(type: Type<C>): C {
        for (const component of this._components) {
            if (component instanceof type) {
                return this as unknown as C;
            }
        }

        throw new Error(`Component ${type.name} was not initialized for this ${this.constructor.name}.`);
    }

    public asOptional<C extends ModelComponent<Model>>(type: Type<C>): C | null {
        for (const component of this._components) {
            if (component instanceof type) {
                return this as unknown as C;
            }
        }

        return null;
    }

    public updateWithData(data: any) {
        for (const property of this._properties) {
            if (data[property] !== undefined) {
                this[property] = data[property];
            }
        }
    }

    /**
     * Override this to automatically fill obvious missing data i.e. from relation or default value that are fetched
     * asynchronously.
     */
    protected async autoFill?(): Promise<void>;

    protected async beforeSave?(connection: Connection): Promise<void>;

    protected async afterSave?(): Promise<void>;

    public async save(connection?: Connection, postHook?: (callback: () => Promise<void>) => void): Promise<void> {
        if (connection && !postHook) throw new Error('If connection is provided, postHook must be provided too.');

        await this.autoFill?.();
        await this.validate(false, connection);

        const needs_full_update = connection ?
            await this.saveTransaction(connection) :
            await MysqlConnectionManager.wrapTransaction(async connection => this.saveTransaction(connection));

        const callback = async () => {
            if (needs_full_update) {
                const result = await this._factory.select()
                    .where('id', this.id!)
                    .limit(1)
                    .execute(connection);
                this.updateWithData(result.results[0]);
            }

            await this.afterSave?.();
        };

        if (connection) {
            postHook!(callback);
        } else {
            await callback();
        }
    }

    private async saveTransaction(connection: Connection): Promise<boolean> {
        // Before save
        await this.beforeSave?.(connection);
        if (!this.exists() && this.hasOwnProperty('created_at')) {
            this.created_at = new Date();
        }
        if (this.exists() && this.hasOwnProperty('updated_at')) {
            this.updated_at = new Date();
        }

        const properties = [];
        const values = [];
        let needsFullUpdate = false;

        if (this.exists()) {
            const data: any = {};
            for (const property of this._properties) {
                const value = this[property];

                if (value === undefined) needsFullUpdate = true;
                else data[property] = value;
            }

            const query = this._factory.update(data);
            for (const indexField of this._factory.getPrimaryKeyFields()) {
                query.where(indexField, this[indexField]);
            }
            await query.execute(connection);
        } else {
            const props_holders = [];
            for (const property of this._properties) {
                const value = this[property];

                if (value === undefined) {
                    needsFullUpdate = true;
                } else {
                    properties.push(property);
                    props_holders.push('?');
                    values.push(value);
                }
            }

            const fieldNames = properties.map(f => `\`${f}\``).join(', ');
            const result = await query(`INSERT INTO ${this.table} (${fieldNames}) VALUES(${props_holders.join(', ')})`, values, connection);

            if (this.hasOwnProperty('id')) this.id = result.other.insertId;
            this._exists = true;
        }

        return needsFullUpdate;
    }

    public async delete(): Promise<void> {
        if (!(await this.exists())) throw new Error('This model instance doesn\'t exist in DB.');

        const query = this._factory.delete();
        for (const indexField of this._factory.getPrimaryKeyFields()) {
            query.where(indexField, this[indexField]);
        }
        await query.execute();
        this._exists = false;
    }

    public async validate(onlyFormat: boolean = false, connection?: Connection): Promise<void[]> {
        return await Promise.all(this._properties.map(
            prop => this._validators[prop]?.execute(prop, this[prop], onlyFormat, connection)
        ));
    }

    public exists(): boolean {
        return this._exists;
    }

    public equals(model: this): boolean {
        for (const field of this._factory.getPrimaryKeyFields()) {
            if (this[field] !== model[field]) return false;
        }
        return true;
    }

    public get table(): string {
        return this._factory.table;
    }

    private get _properties(): string[] {
        return Object.getOwnPropertyNames(this).filter(p => {
            return !p.startsWith('_') &&
                typeof this[p] !== 'function' &&
                !(this[p] instanceof ModelRelation);
        });
    }
}

export interface ModelType<T extends Model> extends Type<T> {
    table: string;

    new(factory: ModelFactory<any>, isNew: boolean): T;

    getPrimaryKeyFields(): string[];
}