velocious 1.0.108 → 1.0.110

package/dist/src/database/table-data/table-column.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-column.d.ts","sourceRoot":"","sources":["../../../../src/database/table-data/table-column.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;GAaG;AAEH;IACE;;;OAGG;IACH,kBAHW,MAAM,SACN,mBAAmB,EAe7B;IAFC,0BAAsB;IACtB,aAAgB;IAGlB;;OAEG;IACH,WAFa,MAAM,CAEW;IAE9B;;OAEG;IACH,cAFa,MAAM,GAAG,SAAS,CAEM;IAErC;;;OAGG;IACH,oBAHW,MAAM,GACJ,IAAI,CAE8B;IAAzB,iBAAuB;IAE7C;;OAEG;IACH,iBAFa,MAAM,CAE2C;IAE9D;;OAEG;IACH,oBAFa,OAAO,CAE2C;IAE/D;;;OAGG;IACH,mCAHW,OAAO,GACL,IAAI,CAEgE;IAEjF;;OAEG;IACH,cAFa,GAAG,CAE0B;IAE1C;;;OAGG;IACH,uBAHW,GAAG,GACD,IAAI,CAEwC;IAEzD;;OAEG;IACH,iBAFa,OAAO,CAEqC;IAEzD;;OAEG;IACH,iBAFa,OAAO,GAAG,MAAM,GAAG,SAAS,CAEO;IAEhD;;;OAGG;IACH,6BAHW,OAAO,GAAG,MAAM,GAAG,SAAS,GAC1B,IAAI,CAEoD;IAErE;;OAEG;IACH,YAFa,OAAO,GAAC,YAAY,CAEc;IAE/C;;OAEG;IACH,gBAFa,YAAY,CAQxB;IAED,0BAMC;IAED;;;OAGG;IACH,mBAHW,OAAO,GAAC,YAAY,GAClB,IAAI,CAEgC;IAEjD;;OAEG;IACH,gBAFa,MAAM,GAAG,SAAS,CAEe;IAE9C;;;OAGG;IACH,2BAHW,MAAM,GAAG,SAAS,GAChB,IAAI,CAEgD;IAEjE;;OAEG;IACH,WAFa,OAAO,GAAG,SAAS,CAEI;IAEpC;;;OAGG;IACH,kBAHW,OAAO,GACL,IAAI,CAE8B;IAE/C;;OAEG;IACH,iBAFa,OAAO,CAEqC;IAEzD;;;OAGG;IACH,6BAHW,OAAO,GACL,IAAI,CAEoD;IAErE;;OAEG;IACH,WAFa,MAAM,GAAG,SAAS,CAEK;IAEpC;;;OAGG;IACH,iBAHW,MAAM,GAAG,SAAS,GAChB,IAAI,CAE4B;IAE7C;;OAEG;IACH,eAFa,OAAO,CAEoC;IAExD;;;;;OAKG;IACH,+CAJG;QAAsB,aAAa,EAA3B,OAAO;QACoC,MAAM,EAAjD,OAAO,oBAAoB,EAAE,OAAO;KAC5C,GAAU,MAAM,CA8FlB;CACF;2BAvRY;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC;;oBAShB,OAAO;cACP,GAAG;iBACH,OAAO;iBACP,OAAO,GAAC,MAAM;YACd,OAAO,GAAC,YAAY;kBACpB,OAAO;gBACP,MAAM;WACN,OAAO;kBACP,OAAO;iBACP,OAAO;WACP,MAAM"}

package/dist/src/database/table-data/table-column.js

@@ -0,0 +1,246 @@
+// @ts-check
+/**
+ * @typedef {{unique: boolean}} IndexArgType
+ */
+import * as inflection from "inflection";
+import restArgsError from "../../utils/rest-args-error.js";
+import TableForeignKey from "./table-foreign-key.js";
+/**
+ * @typedef {object} TableColumnArgsType
+ * @property {boolean} [autoIncrement]
+ * @property {any} [default]
+ * @property {boolean} [dropColumn]
+ * @property {boolean|object} [foreignKey]
+ * @property {boolean|IndexArgType} [index]
+ * @property {boolean} [isNewColumn]
+ * @property {number} [maxLength]
+ * @property {boolean} [null]
+ * @property {boolean} [polymorphic]
+ * @property {boolean} [primaryKey]
+ * @property {string} [type]
+ */
+export default class TableColumn {
+    /**
+     * @param {string} name
+     * @param {TableColumnArgsType} [args]
+     */
+    constructor(name, args) {
+        if (args) {
+            const { autoIncrement, default: columnDefault, dropColumn, foreignKey, index, isNewColumn, maxLength, null: argsNull, polymorphic, primaryKey, type, ...restArgs } = args; // eslint-disable-line no-unused-vars
+            if (Object.keys(args).length == 0) {
+                throw new Error("Empty args given");
+            }
+            restArgsError(restArgs);
+        }
+        this.args = args || {};
+        this.name = name;
+    }
+    /**
+     * @returns {string} name
+     */
+    getName() { return this.name; }
+    /**
+     * @returns {string | undefined}
+     */
+    getNewName() { return this._newName; }
+    /**
+     * @param {string} newName
+     * @returns {void}
+     */
+    setNewName(newName) { this._newName = newName; }
+    /**
+     * @returns {string}
+     */
+    getActualName() { return this.getNewName() || this.getName(); }
+    /**
+     * @returns {boolean}
+     */
+    getAutoIncrement() { return this.args?.autoIncrement || false; }
+    /**
+     * @param {boolean} newAutoIncrement
+     * @returns {void}
+     */
+    setAutoIncrement(newAutoIncrement) { this.args.autoIncrement = newAutoIncrement; }
+    /**
+     * @returns {any}
+     */
+    getDefault() { return this.args?.default; }
+    /**
+     * @param {any} newDefault
+     * @returns {void}
+     */
+    setDefault(newDefault) { this.args.default = newDefault; }
+    /**
+     * @returns {boolean}
+     */
+    getDropColumn() { return this.args?.dropColumn || false; }
+    /**
+     * @returns {boolean | object | undefined}
+     */
+    getForeignKey() { return this.args?.foreignKey; }
+    /**
+     * @param {boolean | object | undefined} newForeignKey
+     * @returns {void}
+     */
+    setForeignKey(newForeignKey) { this.args.foreignKey = newForeignKey; }
+    /**
+     * @returns {boolean|IndexArgType}
+     */
+    getIndex() { return this.args?.index || false; }
+    /**
+     * @returns {IndexArgType}
+     */
+    getIndexArgs() {
+        if (typeof this.args?.index == "object") {
+            return this.args.index;
+        }
+        else {
+            return { unique: false };
+        }
+    }
+    getIndexUnique() {
+        const index = this.args?.index;
+        if (typeof index == "object" && index.unique === true)
+            return true;
+        return false;
+    }
+    /**
+     * @param {boolean|IndexArgType} newIndex
+     * @returns {void}
+     */
+    setIndex(newIndex) { this.args.index = newIndex; }
+    /**
+     * @returns {number | undefined}
+     */
+    getMaxLength() { return this.args?.maxLength; }
+    /**
+     * @param {number | undefined} newMaxLength
+     * @returns {void}
+     */
+    setMaxLength(newMaxLength) { this.args.maxLength = newMaxLength; }
+    /**
+     * @returns {boolean | undefined}
+     */
+    getNull() { return this.args?.null; }
+    /**
+     * @param {boolean} nullable
+     * @returns {void}
+     */
+    setNull(nullable) { this.args.null = nullable; }
+    /**
+     * @returns {boolean}
+     */
+    getPrimaryKey() { return this.args?.primaryKey || false; }
+    /**
+     * @param {boolean} newPrimaryKey
+     * @returns {void}
+     */
+    setPrimaryKey(newPrimaryKey) { this.args.primaryKey = newPrimaryKey; }
+    /**
+     * @returns {string | undefined}
+     */
+    getType() { return this.args?.type; }
+    /**
+     * @param {string | undefined} newType
+     * @returns {void}
+     */
+    setType(newType) { this.args.type = newType; }
+    /**
+     * @returns {boolean}
+     */
+    isNewColumn() { return this.args?.isNewColumn || false; }
+    /**
+     * @param {object} args
+     * @param {boolean} args.forAlterTable
+     * @param {import("../drivers/base.js").default} args.driver
+     * @returns {string}
+     */
+    getSQL({ forAlterTable, driver, ...restArgs }) {
+        restArgsError(restArgs);
+        const databaseType = driver.getType();
+        const options = driver.options();
+        let maxlength = this.getMaxLength();
+        let type = this.getType()?.toUpperCase();
+        if (type == "DATETIME" && databaseType == "pgsql") {
+            type = "TIMESTAMP";
+        }
+        if (type == "STRING") {
+            type = "VARCHAR";
+            maxlength ||= 255;
+        }
+        if (databaseType == "mssql" && type == "BOOLEAN") {
+            type = "BIT";
+        }
+        else if (databaseType == "mssql" && type == "UUID") {
+            type = "VARCHAR";
+            maxlength ||= 36;
+        }
+        if (databaseType == "sqlite" && this.getAutoIncrement() && this.getPrimaryKey()) {
+            type = "INTEGER";
+        }
+        if (databaseType == "pgsql" && this.getAutoIncrement() && this.getPrimaryKey()) {
+            type = "SERIAL";
+        }
+        let sql = `${options.quoteColumnName(this.getActualName())} `;
+        if (databaseType == "pgsql" && forAlterTable)
+            sql += "TYPE ";
+        if (type)
+            sql += type;
+        if (type && maxlength !== undefined && maxlength !== null)
+            sql += `(${maxlength})`;
+        if (this.getAutoIncrement() && driver.shouldSetAutoIncrementWhenPrimaryKey()) {
+            if (databaseType == "mssql") {
+                sql += " IDENTITY";
+            }
+            else if (databaseType == "pgsql") {
+                if (this.getAutoIncrement() && this.getPrimaryKey()) {
+                    // Do nothing
+                }
+                else {
+                    throw new Error("pgsql auto increment must be primary key");
+                }
+            }
+            else {
+                sql += " AUTO_INCREMENT";
+            }
+        }
+        if (typeof this.getDefault() == "function") {
+            const defaultValue = this.getDefault()();
+            sql += ` DEFAULT (`;
+            if (databaseType == "pgsql" && defaultValue == "UUID()") {
+                sql += "gen_random_uuid()";
+            }
+            else if (databaseType == "mssql" && defaultValue == "UUID()") {
+                sql += "NEWID()";
+            }
+            else {
+                sql += defaultValue;
+            }
+            sql += ")";
+        }
+        else if (this.getDefault()) {
+            sql += ` DEFAULT ${options.quote(this.getDefault())}`;
+        }
+        if (this.getPrimaryKey())
+            sql += " PRIMARY KEY";
+        if (this.getNull() === false)
+            sql += " NOT NULL";
+        const foreignKey = this.getForeignKey();
+        if (foreignKey) {
+            let foreignKeyTable, foreignKeyColumn;
+            if (foreignKey === true) {
+                foreignKeyColumn = "id";
+                foreignKeyTable = inflection.pluralize(this.getActualName().replace(/_id$/, ""));
+            }
+            else if (foreignKey instanceof TableForeignKey) {
+                foreignKeyColumn = foreignKey.getReferencedColumnName();
+                foreignKeyTable = foreignKey.getReferencedTableName();
+            }
+            else {
+                throw new Error(`Unknown foreign key type given: ${foreignKey} (${typeof foreignKey})`);
+            }
+            sql += ` REFERENCES ${options.quoteTableName(foreignKeyTable)}(${options.quoteColumnName(foreignKeyColumn)})`;
+        }
+        return sql;
+    }
+}

package/dist/src/database/table-data/table-foreign-key.d.ts

@@ -0,0 +1,55 @@
+export default class TableForeignKey {
+    /**
+     * @param {object} args
+     * @param {string} args.columnName
+     * @param {boolean} [args.isNewForeignKey]
+     * @param {string} [args.name]
+     * @param {string} args.tableName
+     * @param {string} args.referencedColumnName
+     * @param {string} args.referencedTableName
+     */
+    constructor({ columnName, isNewForeignKey, name, tableName, referencedColumnName, referencedTableName, ...restArgs }: {
+        columnName: string;
+        isNewForeignKey?: boolean;
+        name?: string;
+        tableName: string;
+        referencedColumnName: string;
+        referencedTableName: string;
+    });
+    _columnName: string;
+    _isNewForeignKey: boolean;
+    _name: string;
+    _tableName: string;
+    _referencedColumnName: string;
+    _referencedTableName: string;
+    /**
+     * @returns {string}
+     */
+    getColumnName(): string;
+    /**
+     * @returns {boolean}
+     */
+    getIsNewForeignKey(): boolean;
+    /**
+     * @returns {string}
+     */
+    getTableName(): string;
+    /**
+     * @returns {string}
+     */
+    getReferencedColumnName(): string;
+    /**
+     * @returns {string}
+     */
+    getReferencedTableName(): string;
+    /**
+     * @returns {string}
+     */
+    getName(): string;
+    /**
+     * @param {string} newName
+     * @returns {void}
+     */
+    setName(newName: string): void;
+}
+//# sourceMappingURL=table-foreign-key.d.ts.map

package/dist/src/database/table-data/table-foreign-key.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-foreign-key.d.ts","sourceRoot":"","sources":["../../../../src/database/table-data/table-foreign-key.js"],"names":[],"mappings":"AAIA;IACE;;;;;;;;OAQG;IACH,sHAPG;QAAqB,UAAU,EAAvB,MAAM;QACS,eAAe,GAA9B,OAAO;QACO,IAAI,GAAlB,MAAM;QACO,SAAS,EAAtB,MAAM;QACO,oBAAoB,EAAjC,MAAM;QACO,mBAAmB,EAAhC,MAAM;KAChB,EAUA;IANC,oBAA6B;IAC7B,0BAAuC;IACvC,cAAiB;IACjB,mBAA2B;IAC3B,8BAAiD;IACjD,6BAA+C;IAGjD;;OAEG;IACH,iBAFa,MAAM,CAEwB;IAE3C;;OAEG;IACH,sBAFa,OAAO,CAE0C;IAE9D;;OAEG;IACH,gBAFa,MAAM,CAEsB;IAEzC;;OAEG;IACH,2BAFa,MAAM,CAE4C;IAE/D;;OAEG;IACH,0BAFa,MAAM,CAE0C;IAE7D;;OAEG;IACH,WAFa,MAAM,CAEY;IAE/B;;;OAGG;IACH,iBAHW,MAAM,GACJ,IAAI,CAEwB;CAC1C"}

package/dist/src/database/table-data/table-foreign-key.js

@@ -0,0 +1,51 @@
+// @ts-check
+import restArgsError from "../../utils/rest-args-error.js";
+export default class TableForeignKey {
+    /**
+     * @param {object} args
+     * @param {string} args.columnName
+     * @param {boolean} [args.isNewForeignKey]
+     * @param {string} [args.name]
+     * @param {string} args.tableName
+     * @param {string} args.referencedColumnName
+     * @param {string} args.referencedTableName
+     */
+    constructor({ columnName, isNewForeignKey, name, tableName, referencedColumnName, referencedTableName, ...restArgs }) {
+        restArgsError(restArgs);
+        this._columnName = columnName;
+        this._isNewForeignKey = isNewForeignKey;
+        this._name = name;
+        this._tableName = tableName;
+        this._referencedColumnName = referencedColumnName;
+        this._referencedTableName = referencedTableName;
+    }
+    /**
+     * @returns {string}
+     */
+    getColumnName() { return this._columnName; }
+    /**
+     * @returns {boolean}
+     */
+    getIsNewForeignKey() { return this._isNewForeignKey || false; }
+    /**
+     * @returns {string}
+     */
+    getTableName() { return this._tableName; }
+    /**
+     * @returns {string}
+     */
+    getReferencedColumnName() { return this._referencedColumnName; }
+    /**
+     * @returns {string}
+     */
+    getReferencedTableName() { return this._referencedTableName; }
+    /**
+     * @returns {string}
+     */
+    getName() { return this._name; }
+    /**
+     * @param {string} newName
+     * @returns {void}
+     */
+    setName(newName) { this._name = newName; }
+}

package/dist/src/database/table-data/table-index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @typedef {object} TableIndexArgsType
+ * @property {string} name
+ * @property {boolean} unique
+ */
+export default class TableIndex {
+    /**
+     * @param {Array<string | import("./table-column.js").default>} columns
+     * @param {TableIndexArgsType} [args]
+     */
+    constructor(columns: Array<string | import("./table-column.js").default>, args?: TableIndexArgsType);
+    args: TableIndexArgsType;
+    columns: (string | import("./table-column.js").default)[];
+    /**
+     * @returns {Array<string | import("./table-column.js").default>}
+     */
+    getColumns(): Array<string | import("./table-column.js").default>;
+    /**
+     * @returns {string | undefined}
+     */
+    getName(): string | undefined;
+    /**
+     * @returns {boolean}
+     */
+    getUnique(): boolean;
+}
+export type TableIndexArgsType = {
+    name: string;
+    unique: boolean;
+};
+//# sourceMappingURL=table-index.d.ts.map

package/dist/src/database/table-data/table-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-index.d.ts","sourceRoot":"","sources":["../../../../src/database/table-data/table-index.js"],"names":[],"mappings":"AAIA;;;;GAIG;AAEH;IACE;;;OAGG;IACH,qBAHW,KAAK,CAAC,MAAM,GAAG,OAAO,mBAAmB,EAAE,OAAO,CAAC,SACnD,kBAAkB,EAW5B;IAFC,yBAAgB;IAChB,0DAAsB;IAGxB;;OAEG;IACH,cAFa,KAAK,CAAC,MAAM,GAAG,OAAO,mBAAmB,EAAE,OAAO,CAAC,CAE5B;IAEpC;;OAEG;IACH,WAFa,MAAM,GAAG,SAAS,CAEK;IAEpC;;OAEG;IACH,aAFa,OAAO,CAE6B;CAClD;;UAlCa,MAAM;YACN,OAAO"}

package/dist/src/database/table-data/table-index.js

@@ -0,0 +1,33 @@
+// @ts-check
+import restArgsError from "../../utils/rest-args-error.js";
+/**
+ * @typedef {object} TableIndexArgsType
+ * @property {string} name
+ * @property {boolean} unique
+ */
+export default class TableIndex {
+    /**
+     * @param {Array<string | import("./table-column.js").default>} columns
+     * @param {TableIndexArgsType} [args]
+     */
+    constructor(columns, args) {
+        if (args) {
+            const { name, unique, ...restArgs } = args; // eslint-disable-line no-unused-vars
+            restArgsError(restArgs);
+        }
+        this.args = args;
+        this.columns = columns;
+    }
+    /**
+     * @returns {Array<string | import("./table-column.js").default>}
+     */
+    getColumns() { return this.columns; }
+    /**
+     * @returns {string | undefined}
+     */
+    getName() { return this.args?.name; }
+    /**
+     * @returns {boolean}
+     */
+    getUnique() { return Boolean(this.args?.unique); }
+}

package/dist/src/database/table-data/table-reference.d.ts

@@ -0,0 +1,10 @@
+export default class TableReference {
+    /**
+     * @param {string} name
+     * @param {object} args
+     */
+    constructor(name: string, args: object);
+    args: any;
+    name: string;
+}
+//# sourceMappingURL=table-reference.d.ts.map

package/dist/src/database/table-data/table-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-reference.d.ts","sourceRoot":"","sources":["../../../../src/database/table-data/table-reference.js"],"names":[],"mappings":"AAEA;IACE;;;OAGG;IACH,kBAHW,MAAM,QACN,MAAM,EAKhB;IAFC,UAAgB;IAChB,aAAgB;CAEnB"}

package/dist/src/database/table-data/table-reference.js

@@ -0,0 +1,11 @@
+// @ts-check
+export default class TableReference {
+    /**
+     * @param {string} name
+     * @param {object} args
+     */
+    constructor(name, args) {
+        this.args = args;
+        this.name = name;
+    }
+}

package/dist/src/database/use-database.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @param {object} args
+ * @param {() => Promise<import("./migrator/types.js").RequireMigrationContextType>} args.migrationsRequireContextCallback
+ * @returns {{loaded: boolean}}
+ */
+export default function loadMigrations({ migrationsRequireContextCallback, ...restArgs }: {
+    migrationsRequireContextCallback: () => Promise<import("./migrator/types.js").RequireMigrationContextType>;
+}): {
+    loaded: boolean;
+};
+//# sourceMappingURL=use-database.d.ts.map

package/dist/src/database/use-database.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-database.d.ts","sourceRoot":"","sources":["../../../src/database/use-database.js"],"names":[],"mappings":"AAUA;;;;GAIG;AACH,0FAHG;IAAuF,gCAAgC,EAA/G,MAAM,OAAO,CAAC,OAAO,qBAAqB,EAAE,2BAA2B,CAAC;CAChF,GAAU;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAkC7B"}

package/dist/src/database/use-database.js

@@ -0,0 +1,39 @@
+// @ts-check
+// @ts-expect-error
+import React from "react";
+import useEnvSense from "env-sense/src/use-env-sense.js";
+import Configuration from "../configuration.js";
+import Migrator from "./migrator.js";
+import restArgsError from "../utils/rest-args-error.js";
+/**
+ * @param {object} args
+ * @param {() => Promise<import("./migrator/types.js").RequireMigrationContextType>} args.migrationsRequireContextCallback
+ * @returns {{loaded: boolean}}
+ */
+export default function loadMigrations({ migrationsRequireContextCallback, ...restArgs }) {
+    const instance = React.useMemo(() => ({ running: false }), []);
+    const { isServer } = useEnvSense();
+    const [loaded, setLoaded] = React.useState(false);
+    const loadDatabase = React.useCallback(async () => {
+        instance.running = true;
+        try {
+            await Configuration.current().ensureConnections(async () => {
+                const migrator = new Migrator({ configuration: Configuration.current() });
+                await migrator.prepare();
+                await migrator.migrateFilesFromRequireContext(await migrationsRequireContextCallback());
+            });
+            await Configuration.current().initialize();
+            setLoaded(true);
+        }
+        finally {
+            instance.running = false;
+        }
+    }, []);
+    React.useMemo(() => {
+        if (!loaded && !isServer && !instance.running) {
+            loadDatabase();
+        }
+    }, [loaded]);
+    restArgsError(restArgs);
+    return { loaded };
+}

package/dist/src/environment-handlers/base.d.ts

@@ -0,0 +1,128 @@
+/**
+ * @typedef {object} CommandFileObjectType
+ * @property {string} name
+ * @property {string} file
+ */
+/**
+ * @typedef {object} MigrationObjectType
+ * @property {number} date
+ * @property {string} [fullPath]
+ * @property {string} migrationClassName
+ * @property {string} file
+ */
+export default class VelociousEnvironmentHandlerBase {
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    cliCommandsGenerateBaseModels(_command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @returns {Promise<void>}
+     */
+    cliCommandsInit(command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    cliCommandsMigrationGenerate(_command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    cliCommandsMigrationDestroy(_command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    cliCommandsGenerateModel(_command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    cliCommandsServer(_command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @param {import("../cli/base-command.js").default} _command
+     * @returns {Promise<void>}
+     */
+    cliCommandsTest(_command: import("../cli/base-command.js").default): Promise<void>;
+    /**
+     * @abstract
+     * @returns {Promise<CommandFileObjectType[]>}
+     */
+    findCommands(): Promise<CommandFileObjectType[]>;
+    /**
+     * @abstract
+     * @returns {Promise<Array<MigrationObjectType>>}
+     */
+    findMigrations(): Promise<Array<MigrationObjectType>>;
+    /**
+     * @param {import("../cli/base-command.js").default} command
+     * @param {typeof import("../cli/base-command.js").default} CommandClass
+     * @returns {Promise<any>}
+     */
+    forwardCommand(command: import("../cli/base-command.js").default, CommandClass: typeof import("../cli/base-command.js").default): Promise<any>;
+    /**
+     * @abstract
+     * @returns {Promise<string>}
+     */
+    getVelociousPath(): Promise<string>;
+    /**
+     * @abstract
+     * @returns {Promise<import("../routes/index.js").default>}
+     */
+    importApplicationRoutes(): Promise<import("../routes/index.js").default>;
+    /**
+     * @abstract
+     * @param {string[]} _testFiles
+     * @returns {Promise<void>}
+     */
+    importTestFiles(_testFiles: string[]): Promise<void>;
+    /**
+     * @abstract
+     * @returns {Promise<void>}
+     */
+    importTestingConfigPath(): Promise<void>;
+    /**
+     * @abstract
+     * @param {object} args
+     * @param {string[]} args.commandParts
+     * @returns {Promise<typeof import ("../cli/base-command.js").default>}
+     */
+    requireCommand({ commandParts }: {
+        commandParts: string[];
+    }): Promise<typeof import("../cli/base-command.js").default>;
+    /**
+     * @param {object} newArgs
+     * @returns {void}
+     */
+    setArgs(newArgs: object): void;
+    args: any;
+    /**
+     * @param {import("../configuration.js").default} newConfiguration
+     * @returns {void}
+     */
+    setConfiguration(newConfiguration: import("../configuration.js").default): void;
+    configuration: import("../configuration.js").default;
+    /**
+     * @returns {import("../configuration.js").default}
+     */
+    getConfiguration(): import("../configuration.js").default;
+    /**
+     * @param {string[]} newProcessArgs
+     * @returns {void}
+     */
+    setProcessArgs(newProcessArgs: string[]): void;
+    processArgs: string[];
+}
+export type CommandFileObjectType = {
+    name: string;
+    file: string;
+};
+export type MigrationObjectType = {
+    date: number;
+    fullPath?: string;
+    migrationClassName: string;
+    file: string;
+};
+//# sourceMappingURL=base.d.ts.map

package/dist/src/environment-handlers/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/environment-handlers/base.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;;;;;;GAMG;AAEH;IACE;;;OAGG;IACH,wCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,yBAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,uCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,sCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,mCAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,4BAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,0BAHW,OAAO,wBAAwB,EAAE,OAAO,GACtC,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAE2B;IAExE;;;OAGG;IACH,kBAFa,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,CAAC,CAE4B;IAE5E;;;;OAIG;IACH,wBAJW,OAAO,wBAAwB,EAAE,OAAO,gBACxC,cAAc,wBAAwB,EAAE,OAAO,GAC7C,OAAO,CAAC,GAAG,CAAC,CAQxB;IAED;;;OAGG;IACH,oBAFa,OAAO,CAAC,MAAM,CAAC,CAE8C;IAE1E;;;OAGG;IACH,2BAFa,OAAO,CAAC,OAAO,oBAAoB,EAAE,OAAO,CAAC,CAEoC;IAE9F;;;;OAIG;IACH,4BAHW,MAAM,EAAE,GACN,OAAO,CAAC,IAAI,CAAC,CAE0D;IAEpF;;;OAGG;IACH,2BAFa,OAAO,CAAC,IAAI,CAAC,CAEgE;IAE1F;;;;;OAKG;IACH,iCAHG;QAAuB,YAAY,EAA3B,MAAM,EAAE;KAChB,GAAU,OAAO,CAAC,cAAe,wBAAwB,EAAE,OAAO,CAAC,CAEsB;IAE5F;;;OAGG;IACH,iBAHW,MAAM,GACJ,IAAI,CAEuB;IAArB,UAAmB;IAEtC;;;OAGG;IACH,mCAHW,OAAO,qBAAqB,EAAE,OAAO,GACnC,IAAI,CAE2D;IAAvC,qDAAqC;IAE1E;;OAEG;IACH,oBAFa,OAAO,qBAAqB,EAAE,OAAO,CAMjD;IAED;;;OAGG;IACH,+BAHW,MAAM,EAAE,GACN,IAAI,CAEmD;IAAnC,sBAAiC;CACnE;;UAzJa,MAAM;UACN,MAAM;;;UAKN,MAAM;eACN,MAAM;wBACN,MAAM;UACN,MAAM"}