velocious 1.0.108 → 1.0.110

package/dist/src/configuration.js

@@ -0,0 +1,335 @@
+// @ts-check
+/**
+ * @typedef {function(Record<string, import("./database/drivers/base.js").default>) : Promise<void>} WithConnectionsCallbackType
+ */
+import { digg } from "diggerize";
+import restArgsError from "./utils/rest-args-error.js";
+import { withTrackedStack } from "./utils/with-tracked-stack.js";
+/** @type {{currentConfiguration: VelociousConfiguration | null}} */
+const shared = {
+    currentConfiguration: null
+};
+class CurrentConfigurationNotSetError extends Error {
+}
+export { CurrentConfigurationNotSetError };
+export default class VelociousConfiguration {
+    /**
+     * @returns {VelociousConfiguration}
+     */
+    static current() {
+        if (!shared.currentConfiguration)
+            throw new CurrentConfigurationNotSetError("A current configuration hasn't been set");
+        return shared.currentConfiguration;
+    }
+    /**
+     * @param {import("./configuration-types.js").ConfigurationArgsType} args
+     */
+    constructor({ cors, database, debug = false, directory, environment, environmentHandler, initializeModels, initializers, locale, localeFallbacks, locales, testing, ...restArgs }) {
+        restArgsError(restArgs);
+        this.cors = cors;
+        this.database = database;
+        this.debug = debug;
+        this._environment = environment || process.env.VELOCIOUS_ENV || process.env.NODE_ENV || "development";
+        this._environmentHandler = environmentHandler;
+        this._directory = directory;
+        this._initializeModels = initializeModels;
+        this._isInitialized = false;
+        this.locale = locale;
+        this.localeFallbacks = localeFallbacks;
+        this.locales = locales;
+        this._initializers = initializers;
+        this._testing = testing;
+        /** @type {{[key: string]: import("./database/pool/base.js").default}} */
+        this.databasePools = {};
+        /** @type {{[key: string]: typeof import("./database/record/index.js").default}} */
+        this.modelClasses = {};
+        this.getEnvironmentHandler().setConfiguration(this);
+    }
+    /**
+     * @returns {import("./configuration-types.js").CorsType | undefined}
+     */
+    getCors() {
+        return this.cors;
+    }
+    /**
+     * @returns {Record<string, any>}
+     */
+    getDatabaseConfiguration() {
+        if (!this.database)
+            throw new Error("No database configuration");
+        if (!this.database[this.getEnvironment()]) {
+            throw new Error(`No database configuration for environment: ${this.getEnvironment()} - ${Object.keys(this.database).join(", ")}`);
+        }
+        return digg(this, "database", this.getEnvironment());
+    }
+    /**
+     * @returns {Array<string>}
+     */
+    getDatabaseIdentifiers() {
+        return Object.keys(this.getDatabaseConfiguration());
+    }
+    /**
+     * @param {string} identifier
+     * @returns {import("./database/pool/base.js").default}
+     */
+    getDatabasePool(identifier = "default") {
+        if (!this.isDatabasePoolInitialized(identifier)) {
+            this.initializeDatabasePool(identifier);
+        }
+        return digg(this, "databasePools", identifier);
+    }
+    /**
+     * @param {string} identifier
+     * @returns {import("./configuration-types.js").DatabaseConfigurationType})
+     */
+    getDatabaseIdentifier(identifier) {
+        if (!this.getDatabaseConfiguration()[identifier])
+            throw new Error(`No such database identifier configured: ${identifier}`);
+        return this.getDatabaseConfiguration()[identifier];
+    }
+    /**
+     * @param {string} identifier
+     * @returns {typeof import("./database/pool/base.js").default}
+     */
+    getDatabasePoolType(identifier = "default") {
+        const poolTypeClass = digg(this.getDatabaseIdentifier(identifier), "poolType");
+        if (!poolTypeClass) {
+            throw new Error("No poolType given in database configuration");
+        }
+        return poolTypeClass;
+    }
+    /**
+     * @returns {string} The database type.
+     */
+    getDatabaseType(identifier = "default") {
+        const databaseType = digg(this.getDatabaseIdentifier(identifier), "type");
+        if (!databaseType)
+            throw new Error("No database type given in database configuration");
+        return databaseType;
+    }
+    /**
+     * @returns {string}
+     */
+    getDirectory() {
+        if (!this._directory) {
+            this._directory = process.cwd();
+        }
+        return this._directory;
+    }
+    /**
+     * @returns {string}
+     */
+    getEnvironment() { return digg(this, "_environment"); }
+    /**
+     * @param {string} newEnvironment
+     * @returns {void}
+     */
+    setEnvironment(newEnvironment) { this._environment = newEnvironment; }
+    /**
+     * @returns {import("./environment-handlers/base.js").default}
+     */
+    getEnvironmentHandler() {
+        if (!this._environmentHandler)
+            throw new Error("No environment handler set");
+        return this._environmentHandler;
+    }
+    /**
+     * @returns {import("./configuration-types.js").LocaleFallbacksType | undefined}
+     */
+    getLocaleFallbacks() { return this.localeFallbacks; }
+    /**
+     * @param {import("./configuration-types.js").LocaleFallbacksType} newLocaleFallbacks
+     * @returns {void}
+     */
+    setLocaleFallbacks(newLocaleFallbacks) { this.localeFallbacks = newLocaleFallbacks; }
+    /**
+     * @returns {string}
+     */
+    getLocale() {
+        if (typeof this.locale == "function") {
+            return this.locale();
+        }
+        else if (this.locale) {
+            return this.locale;
+        }
+        else {
+            return this.getLocales()[0];
+        }
+    }
+    /**
+     * @returns {Array<string>}
+     */
+    getLocales() { return digg(this, "locales"); }
+    /**
+     * @param {string} name
+     * @returns {typeof import("./database/record/index.js").default}
+     */
+    getModelClass(name) {
+        const modelClass = this.modelClasses[name];
+        if (!modelClass)
+            throw new Error(`No such model class ${name} in ${Object.keys(this.modelClasses).join(", ")}}`);
+        return modelClass;
+    }
+    /**
+     * @returns {Record<string, typeof import("./database/record/index.js").default>} A hash of all model classes, keyed by model name, as they were defined in the configuration. This is a direct reference to the model classes, not a copy.
+     */
+    getModelClasses() {
+        return this.modelClasses;
+    }
+    /**
+     * @returns {string} The path to a config file that should be used for testing.
+     */
+    getTesting() { return this._testing; }
+    /**
+     * @returns {void}
+     */
+    initializeDatabasePool(identifier = "default") {
+        if (!this.database)
+            throw new Error("No 'database' was given");
+        if (this.databasePools[identifier])
+            throw new Error("DatabasePool has already been initialized");
+        const PoolType = this.getDatabasePoolType(identifier);
+        this.databasePools[identifier] = new PoolType({ configuration: this, identifier });
+        this.databasePools[identifier].setCurrent();
+    }
+    isDatabasePoolInitialized(identifier = "default") { return Boolean(this.databasePools[identifier]); }
+    /**
+     * @returns {boolean}
+     */
+    isInitialized() { return this._isInitialized; }
+    /**
+     * @param {object} args
+     * @param {string} args.type
+     * @returns {Promise<void>}
+     */
+    async initializeModels(args = { type: "server" }) {
+        if (!this._modelsInitialized) {
+            this._modelsInitialized = true;
+            if (this._initializeModels) {
+                await this._initializeModels({ configuration: this, type: args.type });
+            }
+        }
+    }
+    /**
+     * @param {object} args
+     * @param {string} args.type
+     * @returns {Promise<void>}
+     */
+    async initialize({ type } = { type: "undefined" }) {
+        if (!this.isInitialized()) {
+            this._isInitialized = true;
+            await this.initializeModels({ type });
+            if (this._initializers) {
+                const initializers = await this._initializers({ configuration: this });
+                const { requireContext, ...restArgs } = initializers;
+                restArgsError(restArgs);
+                if (requireContext) {
+                    for (const initializerKey of requireContext.keys()) {
+                        const InitializerClass = requireContext(initializerKey).default;
+                        const initializerInstance = new InitializerClass({ configuration: this, type });
+                        await initializerInstance.run();
+                    }
+                }
+            }
+        }
+    }
+    /**
+     * @param {typeof import("./database/record/index.js").default} modelClass
+     * @returns {void}
+     */
+    registerModelClass(modelClass) {
+        this.modelClasses[modelClass.name] = modelClass;
+    }
+    /**
+     * @returns {void}
+     */
+    setCurrent() {
+        shared.currentConfiguration = this;
+    }
+    /**
+     * @param {import("./routes/index.js").default} newRoutes
+     * @returns {void}
+     */
+    setRoutes(newRoutes) { this.routes = newRoutes; }
+    /**
+     * @param {Function} callback
+     * @returns {void}
+     */
+    setTranslator(callback) { this._translator = callback; }
+    /**
+     * @param {string} msgID
+     * @param {undefined | {defaultValue: string}} args
+     * @returns {string}
+     */
+    _defaultTranslator(msgID, args) {
+        if (args?.defaultValue)
+            return args.defaultValue;
+        return msgID;
+    }
+    /**
+     * @returns {Function}
+     */
+    getTranslator() {
+        return this._translator || this._defaultTranslator;
+    }
+    /**
+     * @param {WithConnectionsCallbackType} callback
+     * @returns {Promise<void>}
+     */
+    async withConnections(callback) {
+        /** @type {{[key: string]: import("./database/drivers/base.js").default}} */
+        const dbs = {};
+        const stack = Error().stack;
+        const actualCallback = async () => {
+            await withTrackedStack(stack, async () => {
+                return await callback(dbs);
+            });
+        };
+        let runRequest = actualCallback;
+        for (const identifier of this.getDatabaseIdentifiers()) {
+            let actualRunRequest = runRequest;
+            const nextRunRequest = async () => {
+                return await this.getDatabasePool(identifier).withConnection(async (db) => {
+                    dbs[identifier] = db;
+                    await actualRunRequest();
+                });
+            };
+            runRequest = nextRunRequest;
+        }
+        await runRequest();
+    }
+    /**
+     * @returns {Record<string, import("./database/drivers/base.js").default>} A map of database connections with identifier as key
+     */
+    getCurrentConnections() {
+        /** @type {{[key: string]: import("./database/drivers/base.js").default}} */
+        const dbs = {};
+        for (const identifier of this.getDatabaseIdentifiers()) {
+            try {
+                dbs[identifier] = this.getDatabasePool(identifier).getCurrentConnection();
+            }
+            catch (error) {
+                if (error instanceof Error && (error.message == "ID hasn't been set for this async context" || error.message == "A connection hasn't been made yet")) {
+                    // Ignore
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        return dbs;
+    }
+    /**
+     * @param {WithConnectionsCallbackType} callback
+     * @returns {Promise<void>}
+     */
+    async ensureConnections(callback) {
+        let dbs = this.getCurrentConnections();
+        if (Object.keys(dbs).length > 0) {
+            await callback(dbs);
+        }
+        else {
+            await this.withConnections(callback);
+        }
+    }
+}

package/dist/src/controller.d.ts

@@ -0,0 +1,73 @@
+export default class VelociousController {
+    /**
+     * @param {string} methodName
+     * @returns {void}
+     */
+    static beforeAction(methodName: string): void;
+    /**
+     * @param {object} args
+     * @param {string} args.action
+     * @param {import("./configuration.js").default} args.configuration
+     * @param {string} args.controller
+     * @param {object} args.params
+     * @param {import("./http-server/client/request.js").default} args.request
+     * @param {import("./http-server/client/response.js").default} args.response
+     * @param {string} args.viewPath
+     */
+    constructor({ action, configuration, controller, params, request, response, viewPath }: {
+        action: string;
+        configuration: import("./configuration.js").default;
+        controller: string;
+        params: object;
+        request: import("./http-server/client/request.js").default;
+        response: import("./http-server/client/response.js").default;
+        viewPath: string;
+    });
+    _action: string;
+    _controller: string;
+    _configuration: import("./configuration.js").default;
+    logger: Logger;
+    _params: any;
+    _request: import("./http-server/client/request.js").default;
+    _response: import("./http-server/client/response.js").default;
+    viewParams: {};
+    _viewPath: string;
+    /** @returns {string} */
+    getAction(): string;
+    /** @returns {import("./configuration.js").default} */
+    getConfiguration(): import("./configuration.js").default;
+    /** @returns {object} */
+    getParams(): object;
+    /** @returns {import("./http-server/client/request.js").default} */
+    getRequest(): import("./http-server/client/request.js").default;
+    /**
+     * @private
+     * @returns {typeof VelociousController}
+     */
+    private _getControllerClass;
+    _runBeforeCallbacks(): Promise<void>;
+    /**
+     * @returns {object}
+     */
+    params(): object;
+    /**
+     * @param {object} [args]
+     * @param {object} [args.json]
+     * @param {number | string} [args.status]
+     * @returns {Promise<void>}
+     */
+    render({ json, status, ...restArgs }?: {
+        json?: object;
+        status?: number | string;
+    }): Promise<void>;
+    /** @param {object} json */
+    renderJsonArg(json: object): void;
+    renderView(): Promise<any>;
+    renderText(): void;
+    /** @returns {import("./http-server/client/request.js").default} */
+    request(): import("./http-server/client/request.js").default;
+    /** @returns {import("./http-server/client/response.js").default} */
+    response(): import("./http-server/client/response.js").default;
+}
+import { Logger } from "./logger.js";
+//# sourceMappingURL=controller.d.ts.map

package/dist/src/controller.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../src/controller.js"],"names":[],"mappings":"AAQA;IACE;;;OAGG;IACH,gCAHW,MAAM,GACJ,IAAI,CAShB;IAED;;;;;;;;;OASG;IACH,wFARG;QAAqB,MAAM,EAAnB,MAAM;QACqC,aAAa,EAAxD,OAAO,oBAAoB,EAAE,OAAO;QACvB,UAAU,EAAvB,MAAM;QACO,MAAM,EAAnB,MAAM;QACkD,OAAO,EAA/D,OAAO,iCAAiC,EAAE,OAAO;QACQ,QAAQ,EAAjE,OAAO,kCAAkC,EAAE,OAAO;QACrC,QAAQ,EAArB,MAAM;KAChB,EAmBA;IATC,gBAAqB;IACrB,oBAA6B;IAC7B,qDAAmC;IACnC,eAA8B;IAC9B,aAAqB;IACrB,4DAAuB;IACvB,8DAAyB;IACzB,eAAoB;IACpB,kBAAyB;IAG3B,wBAAwB;IACxB,aADc,MAAM,CACe;IAEnC,sDAAsD;IACtD,oBADc,OAAO,oBAAoB,EAAE,OAAO,CACD;IAEjD,wBAAwB;IACxB,aADc,MAAM,CACe;IAEnC,mEAAmE;IACnE,cADc,OAAO,iCAAiC,EAAE,OAAO,CAC1B;IAErC;;;OAGG;IACH,4BAIC;IAED,qCA4BC;IAED;;OAEG;IACH,UAFa,MAAM,CAEa;IAEhC;;;;;OAKG;IACH,uCAJG;QAAsB,IAAI,GAAlB,MAAM;QACiB,MAAM,GAA7B,MAAM,GAAG,MAAM;KACvB,GAAU,OAAO,CAAC,IAAI,CAAC,CAczB;IAED,2BAA2B;IAC3B,oBADY,MAAM,QAMjB;IAED,2BAiBC;IAED,mBAEC;IAED,mEAAmE;IACnE,WADc,OAAO,iCAAiC,EAAE,OAAO,CAC7B;IAElC,oEAAoE;IACpE,YADc,OAAO,kCAAkC,EAAE,OAAO,CAC5B;CACrC;uBAhKoB,aAAa"}

package/dist/src/controller.js

@@ -0,0 +1,141 @@
+// @ts-check
+import ejs from "ejs";
+import { incorporate } from "incorporator";
+import * as inflection from "inflection";
+import { Logger } from "./logger.js";
+import restArgsError from "./utils/rest-args-error.js";
+export default class VelociousController {
+    /**
+     * @param {string} methodName
+     * @returns {void}
+     */
+    static beforeAction(methodName) {
+        if (!this._beforeActions) {
+            /** @type {Array<string>}  */
+            this._beforeActions = [];
+        }
+        this._beforeActions.push(methodName);
+    }
+    /**
+     * @param {object} args
+     * @param {string} args.action
+     * @param {import("./configuration.js").default} args.configuration
+     * @param {string} args.controller
+     * @param {object} args.params
+     * @param {import("./http-server/client/request.js").default} args.request
+     * @param {import("./http-server/client/response.js").default} args.response
+     * @param {string} args.viewPath
+     */
+    constructor({ action, configuration, controller, params, request, response, viewPath }) {
+        if (!action)
+            throw new Error("No action given");
+        if (!configuration)
+            throw new Error("No configuration given");
+        if (!controller)
+            throw new Error("No controller given");
+        if (!params)
+            throw new Error("No params given");
+        if (!request)
+            throw new Error("No request given");
+        if (!response)
+            throw new Error("No response given");
+        if (!viewPath)
+            throw new Error("No viewPath given");
+        this._action = action;
+        this._controller = controller;
+        this._configuration = configuration;
+        this.logger = new Logger(this);
+        this._params = params;
+        this._request = request;
+        this._response = response;
+        this.viewParams = {};
+        this._viewPath = viewPath;
+    }
+    /** @returns {string} */
+    getAction() { return this._action; }
+    /** @returns {import("./configuration.js").default} */
+    getConfiguration() { return this._configuration; }
+    /** @returns {object} */
+    getParams() { return this._params; }
+    /** @returns {import("./http-server/client/request.js").default} */
+    getRequest() { return this._request; }
+    /**
+     * @private
+     * @returns {typeof VelociousController}
+     */
+    _getControllerClass() {
+        const controllerClass = /** @type {typeof VelociousController} */ (this.constructor);
+        return controllerClass;
+    }
+    async _runBeforeCallbacks() {
+        await this.logger.debug("_runBeforeCallbacks");
+        let currentControllerClass = this._getControllerClass();
+        while (currentControllerClass) {
+            await this.logger.debug(`Running callbacks for ${currentControllerClass.name}`);
+            const beforeActions = currentControllerClass._beforeActions;
+            if (beforeActions) {
+                for (const beforeActionName of beforeActions) {
+                    const beforeAction = currentControllerClass.prototype[beforeActionName];
+                    if (!beforeAction)
+                        throw new Error(`No such before action: ${beforeActionName}`);
+                    const boundBeforeAction = beforeAction.bind(this);
+                    await boundBeforeAction();
+                }
+            }
+            currentControllerClass = Object.getPrototypeOf(currentControllerClass);
+            if (!currentControllerClass?.name?.endsWith("Controller"))
+                break;
+        }
+        await this.logger.debug("After runBeforeCallbacks");
+    }
+    /**
+     * @returns {object}
+     */
+    params() { return this._params; }
+    /**
+     * @param {object} [args]
+     * @param {object} [args.json]
+     * @param {number | string} [args.status]
+     * @returns {Promise<void>}
+     */
+    async render({ json, status, ...restArgs } = {}) {
+        restArgsError(restArgs);
+        if (json) {
+            return this.renderJsonArg(json);
+        }
+        if (status) {
+            this._response.setStatus(status);
+        }
+        return await this.renderView();
+    }
+    /** @param {object} json */
+    renderJsonArg(json) {
+        const body = JSON.stringify(json);
+        this._response.setHeader("Content-Type", "application/json; charset=UTF-8");
+        this._response.setBody(body);
+    }
+    renderView() {
+        return new Promise((resolve, reject) => {
+            const viewPath = `${this._viewPath}/${inflection.dasherize(inflection.underscore(this._action))}.ejs`;
+            const { viewParams } = this;
+            const actualViewParams = incorporate({ controller: this }, viewParams);
+            ejs.renderFile(viewPath, actualViewParams, {}, (err, str) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    this._response.setHeader("Content-Type", "text/html; charset=UTF-8");
+                    this._response.setBody(str);
+                    resolve(null);
+                }
+            });
+        });
+    }
+    renderText() {
+        throw new Error("renderText stub");
+    }
+    /** @returns {import("./http-server/client/request.js").default} */
+    request() { return this._request; }
+    /** @returns {import("./http-server/client/response.js").default} */
+    response() { return this._response; }
+}

package/dist/src/database/drivers/base-column.d.ts

@@ -0,0 +1,72 @@
+export default class VelociousDatabaseDriversBaseColumn {
+    /** @type {import("./base-table.js").default | undefined} */
+    table: import("./base-table.js").default | undefined;
+    /**
+     * @abstract
+     * @returns {boolean}
+     */
+    getAutoIncrement(): boolean;
+    /**
+     * @abstract
+     * @returns {any}
+     */
+    getDefault(): any;
+    /**
+     * @param {string} indexName
+     * @returns {Promise<import("./base-columns-index.js").default | undefined>}
+     */
+    getIndexByName(indexName: string): Promise<import("./base-columns-index.js").default | undefined>;
+    /**
+     * @param {boolean} nullable Whether the column should be nullable or not.
+     * @returns {Promise<void>}
+     */
+    changeNullable(nullable: boolean): Promise<void>;
+    /**
+     * @returns {import("./base.js").default}
+     */
+    getDriver(): import("./base.js").default;
+    /**
+     * @abstract
+     * @returns {Promise<Array<import("./base-columns-index.js").default>>}
+     */
+    getIndexes(): Promise<Array<import("./base-columns-index.js").default>>;
+    /**
+     * @abstract
+     * @returns {number | undefined}
+     */
+    getMaxLength(): number | undefined;
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    getName(): string;
+    /**
+     * @abstract
+     * @returns {boolean}
+     */
+    getNull(): boolean;
+    /**
+     * @returns {import("../query-parser/options.js").default}
+     */
+    getOptions(): import("../query-parser/options.js").default;
+    /**
+     * @abstract
+     * @returns {boolean}
+     */
+    getPrimaryKey(): boolean;
+    /**
+     * @returns {import("./base-table.js").default}
+     */
+    getTable(): import("./base-table.js").default;
+    /**
+     * @returns {TableColumn} The table column data for this column. This is used for altering tables and such.
+     */
+    getTableDataColumn(): TableColumn;
+    /**
+     * @abstract
+     * @returns {string}
+     */
+    getType(): string;
+}
+import TableColumn from "../table-data/table-column.js";
+//# sourceMappingURL=base-column.d.ts.map

package/dist/src/database/drivers/base-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-column.d.ts","sourceRoot":"","sources":["../../../../src/database/drivers/base-column.js"],"names":[],"mappings":"AAKA;IACE,4DAA4D;IAC5D,OADW,OAAO,iBAAiB,EAAE,OAAO,GAAG,SAAS,CACvC;IAEjB;;;OAGG;IACH,oBAFa,OAAO,CAInB;IAED;;;OAGG;IACH,cAFa,GAAG,CAIf;IAED;;;OAGG;IACH,0BAHW,MAAM,GACJ,OAAO,CAAC,OAAO,yBAAyB,EAAE,OAAO,GAAG,SAAS,CAAC,CAO1E;IAED;;;OAGG;IACH,yBAHW,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;OAEG;IACH,aAFa,OAAO,WAAW,EAAE,OAAO,CAIvC;IAED;;;OAGG;IACH,cAFa,OAAO,CAAC,KAAK,CAAC,OAAO,yBAAyB,EAAE,OAAO,CAAC,CAAC,CAIrE;IAED;;;OAGG;IACH,gBAFa,MAAM,GAAG,SAAS,CAI9B;IAED;;;OAGG;IACH,WAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,WAFa,OAAO,CAInB;IAED;;OAEG;IACH,cAFa,OAAO,4BAA4B,EAAE,OAAO,CAIxD;IAED;;;OAGG;IACH,iBAFa,OAAO,CAInB;IAED;;OAEG;IACH,YAFa,OAAO,iBAAiB,EAAE,OAAO,CAM7C;IAED;;OAEG;IACH,sBAFa,WAAW,CAYvB;IAED;;;OAGG;IACH,WAFa,MAAM,CAIlB;CACF;wBA1IuB,+BAA+B"}