velocious 1.0.108 → 1.0.109

package/dist/src/database/initializer-from-require-context.d.ts

@@ -0,0 +1,26 @@
+export default class VelociousDatabaseInitializerFromRequireContext {
+    /**
+     * @param {object} args
+     * @param {ModelClassRequireContextType} args.requireContext
+     */
+    constructor({ requireContext, ...restArgs }: {
+        requireContext: ModelClassRequireContextType;
+    });
+    requireContext: ModelClassRequireContextType;
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @returns {Promise<void>}
+     */
+    initialize({ configuration, ...restArgs }: {
+        configuration: import("../configuration.js").default;
+    }): Promise<void>;
+}
+export type ModelClassRequireContextIDFunctionType = (id: string) => {
+    default: typeof import("./record/index.js").default;
+};
+export type ModelClassRequireContextType = ModelClassRequireContextIDFunctionType & {
+    keys: () => string[];
+    id: string;
+};
+//# sourceMappingURL=initializer-from-require-context.d.ts.map

package/dist/src/database/initializer-from-require-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"initializer-from-require-context.d.ts","sourceRoot":"","sources":["../../../src/database/initializer-from-require-context.js"],"names":[],"mappings":"AAYA;IACE;;;OAGG;IACH,6CAFG;QAA2C,cAAc,EAAjD,4BAA4B;KACtC,EAKA;IADC,6CAAoC;IAGtC;;;;OAIG;IACH,2CAHG;QAAoD,aAAa,EAAzD,OAAO,qBAAqB,EAAE,OAAO;KAC7C,GAAU,OAAO,CAAC,IAAI,CAAC,CAsBzB;CACF;qDA9CY,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,mBAAmB,EAAE,OAAO,CAAA;CAAC;2CACrE,sCAAsC,GAAG;IACjD,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX"}

package/dist/src/database/initializer-from-require-context.js

@@ -0,0 +1,40 @@
+// @ts-check
+/**
+ * @typedef {(id: string) => {default: typeof import("./record/index.js").default}} ModelClassRequireContextIDFunctionType
+ * @typedef {ModelClassRequireContextIDFunctionType & {
+ *   keys: () => string[],
+ *   id: string
+ * }} ModelClassRequireContextType
+ */
+import restArgsError from "../utils/rest-args-error.js";
+export default class VelociousDatabaseInitializerFromRequireContext {
+    /**
+     * @param {object} args
+     * @param {ModelClassRequireContextType} args.requireContext
+     */
+    constructor({ requireContext, ...restArgs }) {
+        restArgsError(restArgs);
+        this.requireContext = requireContext;
+    }
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     * @returns {Promise<void>}
+     */
+    async initialize({ configuration, ...restArgs }) {
+        restArgsError(restArgs);
+        for (const fileName of this.requireContext.keys()) {
+            const modelClassImport = this.requireContext(fileName);
+            if (!modelClassImport)
+                throw new Error(`Couldn't import model class from ${fileName}`);
+            const modelClass = modelClassImport.default;
+            if (!modelClass)
+                throw new Error(`Model wasn't exported from: ${fileName}`);
+            await modelClass.initializeRecord({ configuration });
+            if (await modelClass.hasTranslationsTable()) {
+                const translationClass = modelClass.getTranslationClass();
+                await translationClass.initializeRecord({ configuration });
+            }
+        }
+    }
+}

package/dist/src/database/migration/index.d.ts

@@ -0,0 +1,152 @@
+export default class VelociousDatabaseMigration {
+    /**
+     * @param {string[]} databaseIdentifiers
+     * @returns {void}
+     */
+    static onDatabases(databaseIdentifiers: string[]): void;
+    /** @returns {string[] | undefined} */
+    static getDatabaseIdentifiers(): string[] | undefined;
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {string} args.databaseIdentifier
+     * @param {import("../drivers/base.js").default} args.db
+     */
+    constructor({ configuration, databaseIdentifier, db }: {
+        configuration: import("../../configuration.js").default;
+        databaseIdentifier: string;
+        db: import("../drivers/base.js").default;
+    });
+    configuration: import("../../configuration.js").default;
+    _databaseIdentifier: string;
+    _db: import("../drivers/base.js").default;
+    _getDatabaseIdentifier(): string;
+    /** @returns {import("../drivers/base.js").default} */
+    getDriver(): import("../drivers/base.js").default;
+    connection(): import("../drivers/base.js").default;
+    change(): Promise<void>;
+    up(): Promise<void>;
+    down(): Promise<void>;
+    /**
+     * @param {string} sql
+     * @returns {Promise<import("../drivers/base.js").QueryResultType>}
+     */
+    execute(sql: string): Promise<import("../drivers/base.js").QueryResultType>;
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @param {string} columnType
+     * @param {AddColumnArgsType} [args]
+     * @returns {Promise<void>}
+     */
+    addColumn(tableName: string, columnName: string, columnType: string, args?: AddColumnArgsType): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @returns {Promise<void>}
+     */
+    removeColumn(tableName: string, columnName: string): Promise<void>;
+    /**
+     * @typedef {object} AddIndexArgsType
+     * @property {boolean} [ifNotExists]
+     * @property {string} [name]
+     * @property {boolean} [unique]
+     */
+    /**
+     * @param {string} tableName
+     * @param {Array<string | import("../table-data/table-column.js").default>} columns
+     * @param {AddIndexArgsType} [args]
+     * @returns {Promise<void>}
+     */
+    addIndex(tableName: string, columns: Array<string | import("../table-data/table-column.js").default>, args?: {
+        ifNotExists?: boolean;
+        name?: string;
+        unique?: boolean;
+    }): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} referenceName
+     * @returns {Promise<void>}
+     */
+    addForeignKey(tableName: string, referenceName: string): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} referenceName
+     * @param {object} args
+     * @param {boolean} args.foreignKey
+     * @param {string} args.type
+     * @param {boolean} args.unique
+     * @returns {Promise<void>}
+     */
+    addReference(tableName: string, referenceName: string, args: {
+        foreignKey: boolean;
+        type: string;
+        unique: boolean;
+    }): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} referenceName
+     * @returns {Promise<void>}
+     */
+    removeReference(tableName: string, referenceName: string): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @param {boolean} nullable
+     * @returns {Promise<void>}
+     */
+    changeColumnNull(tableName: string, columnName: string, nullable: boolean): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @returns {Promise<boolean>}
+     */
+    columnExists(tableName: string, columnName: string): Promise<boolean>;
+    /**
+     * @overload
+     * @param {string} tableName
+     * @param {CreateTableCallbackType} callback
+     * @returns {Promise<void>}
+     */
+    createTable(tableName: string, callback: (TableData: any) => void): Promise<void>;
+    /**
+     * @overload
+     * @param {string} tableName
+     * @param {CreateTableArgsType} args
+     * @param {CreateTableCallbackType} callback
+     * @returns {Promise<void>}
+     */
+    createTable(tableName: string, args: {
+        id?: {
+            default?: any;
+            type?: string;
+        } | false;
+    }, callback: (TableData: any) => void): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @returns {Promise<void>}
+     */
+    dropTable(tableName: string): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @param {string} oldColumnName
+     * @param {string} newColumnName
+     * @returns {Promise<void>}
+     */
+    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): Promise<void>;
+    /**
+     * @param {string} tableName
+     * @returns {Promise<boolean>}
+     */
+    tableExists(tableName: string): Promise<boolean>;
+}
+export type AddColumnArgsType = {
+    default: any;
+    foreignKey: object;
+    nullable: boolean;
+    primaryKey: boolean;
+    unique: boolean;
+};
+export class NotImplementedError extends Error {
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/src/database/migration/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/database/migration/index.js"],"names":[],"mappings":"AAkBA;IACE;;;OAGG;IACH,wCAHW,MAAM,EAAE,GACN,IAAI,CAIhB;IAED,sCAAsC;IACtC,iCADc,MAAM,EAAE,GAAG,SAAS,CAGjC;IAED;;;;;OAKG;IACH,uDAJG;QAAuD,aAAa,EAA5D,OAAO,wBAAwB,EAAE,OAAO;QAC3B,kBAAkB,EAA/B,MAAM;QACqC,EAAE,EAA7C,OAAO,oBAAoB,EAAE,OAAO;KAC9C,EAQA;IAHC,wDAAkC;IAClC,4BAA6C;IAC7C,0CAAa;IAGf,iCAIC;IAED,sDAAsD;IACtD,aADc,OAAO,oBAAoB,EAAE,OAAO,CACnB;IAC/B,mDAAwC;IAExC,wBAEC;IAED,oBAEC;IAED,sBAEC;IAED;;;OAGG;IACH,aAHW,MAAM,GACJ,OAAO,CAAC,OAAO,oBAAoB,EAAE,eAAe,CAAC,CAIjE;IAED;;;;;;OAMG;IACH,qBANW,MAAM,cACN,MAAM,cACN,MAAM,SACN,iBAAiB,GACf,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;OAIG;IACH,wBAJW,MAAM,cACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAazB;IAED;;;;;OAKG;IACH;;;;;OAKG;IACH,oBALW,MAAM,WACN,KAAK,CAAC,MAAM,GAAG,OAAO,+BAA+B,EAAE,OAAO,CAAC;sBAN5D,OAAO;eACP,MAAM;iBACN,OAAO;QAMR,OAAO,CAAC,IAAI,CAAC,CAezB;IAED;;;;OAIG;IACH,yBAJW,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAkBzB;IAED;;;;;;;;OAQG;IACH,wBARW,MAAM,iBACN,MAAM,QAEd;QAAsB,UAAU,EAAxB,OAAO;QACM,IAAI,EAAjB,MAAM;QACQ,MAAM,EAApB,OAAO;KACf,GAAU,OAAO,CAAC,IAAI,CAAC,CAczB;IAED;;;;OAIG;IACH,2BAJW,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAMzB;IAED;;;;;OAKG;IACH,4BALW,MAAM,cACN,MAAM,YACN,OAAO,GACL,OAAO,CAAC,IAAI,CAAC,CAYzB;IAED;;;;OAIG;IACH,wBAJW,MAAM,cACN,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAc5B;;;;;;;IAeE,uBACQ,MAAM,gCAJW,IAAI,GAMnB,OAAO,CAAC,IAAI,CAAC,CACzB;;;;;;;;IAEE,uBACQ,MAAM;aAbH;sBALA,GAAG;mBACH,MAAM;YAIkB,KAAK;qCAGf,IAAI,GAanB,OAAO,CAAC,IAAI,CAAC,CACzB;IAuDD;;;OAGG;IACH,qBAHW,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;;;OAKG;IACH,wBALW,MAAM,iBACN,MAAM,iBACN,MAAM,GACJ,OAAO,CAAC,IAAI,CAAC,CAIzB;IAED;;;OAGG;IACH,uBAHW,MAAM,GACJ,OAAO,CAAC,OAAO,CAAC,CAM5B;CACF;;aApVa,GAAG;gBACH,MAAM;cACN,OAAO;gBACP,OAAO;YACP,OAAO;;AAMrB;CAA0C"}

package/dist/src/database/migration/index.js

@@ -0,0 +1,286 @@
+// @ts-check
+/**
+ * @typedef {object} AddColumnArgsType
+ * @property {any} default
+ * @property {object} foreignKey
+ * @property {boolean} nullable
+ * @property {boolean} primaryKey
+ * @property {boolean} unique
+ */
+import * as inflection from "inflection";
+import restArgsError from "../../utils/rest-args-error.js";
+import TableData from "../table-data/index.js";
+class NotImplementedError extends Error {
+}
+export { NotImplementedError };
+export default class VelociousDatabaseMigration {
+    /**
+     * @param {string[]} databaseIdentifiers
+     * @returns {void}
+     */
+    static onDatabases(databaseIdentifiers) {
+        this._databaseIdentifiers = databaseIdentifiers;
+    }
+    /** @returns {string[] | undefined} */
+    static getDatabaseIdentifiers() {
+        return this._databaseIdentifiers;
+    }
+    /**
+     * @param {object} args
+     * @param {import("../../configuration.js").default} args.configuration
+     * @param {string} args.databaseIdentifier
+     * @param {import("../drivers/base.js").default} args.db
+     */
+    constructor({ configuration, databaseIdentifier = "default", db }) {
+        if (!databaseIdentifier)
+            throw new Error("No database identifier given");
+        if (!db)
+            throw new Error("No 'db' given");
+        this.configuration = configuration;
+        this._databaseIdentifier = databaseIdentifier;
+        this._db = db;
+    }
+    _getDatabaseIdentifier() {
+        if (!this._databaseIdentifier)
+            throw new Error("No database identifier set");
+        return this._databaseIdentifier;
+    }
+    /** @returns {import("../drivers/base.js").default} */
+    getDriver() { return this._db; }
+    connection() { return this.getDriver(); }
+    async change() {
+        throw new NotImplementedError("'change' not implemented");
+    }
+    async up() {
+        throw new NotImplementedError("'change' not implemented");
+    }
+    async down() {
+        throw new NotImplementedError("'change' not implemented");
+    }
+    /**
+     * @param {string} sql
+     * @returns {Promise<import("../drivers/base.js").QueryResultType>}
+     */
+    async execute(sql) {
+        return await this.connection().query(sql);
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @param {string} columnType
+     * @param {AddColumnArgsType} [args]
+     * @returns {Promise<void>}
+     */
+    async addColumn(tableName, columnName, columnType, args) {
+        if (!columnType)
+            throw new Error("No column type given");
+        const tableColumnArgs = Object.assign({ isNewColumn: true, type: columnType }, args);
+        const tableData = new TableData(tableName);
+        tableData.addColumn(columnName, tableColumnArgs);
+        const sqls = await this.getDriver().alterTableSQLs(tableData);
+        for (const sql of sqls) {
+            await this.getDriver().query(sql);
+        }
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @returns {Promise<void>}
+     */
+    async removeColumn(tableName, columnName) {
+        const tableColumnArgs = Object.assign({ dropColumn: true });
+        const tableData = new TableData(tableName);
+        tableData.addColumn(columnName, tableColumnArgs);
+        const sqls = await this.getDriver().alterTableSQLs(tableData);
+        for (const sql of sqls) {
+            await this.getDriver().query(sql);
+        }
+    }
+    /**
+     * @typedef {object} AddIndexArgsType
+     * @property {boolean} [ifNotExists]
+     * @property {string} [name]
+     * @property {boolean} [unique]
+     */
+    /**
+     * @param {string} tableName
+     * @param {Array<string | import("../table-data/table-column.js").default>} columns
+     * @param {AddIndexArgsType} [args]
+     * @returns {Promise<void>}
+     */
+    async addIndex(tableName, columns, args) {
+        const createIndexArgs = Object.assign({
+            columns,
+            tableName
+        }, args);
+        const sqls = await this.getDriver().createIndexSQLs(createIndexArgs);
+        for (const sql of sqls) {
+            await this.getDriver().query(sql);
+        }
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} referenceName
+     * @returns {Promise<void>}
+     */
+    async addForeignKey(tableName, referenceName) {
+        const referenceNameUnderscore = inflection.underscore(referenceName);
+        const tableNameUnderscore = inflection.underscore(tableName);
+        const columnName = `${referenceNameUnderscore}_id`;
+        const foreignKeyName = `fk_${tableName}_${referenceName}`;
+        await this.getDriver().addForeignKey(tableName, columnName, tableNameUnderscore, "id", {
+            isNewForeignKey: true,
+            name: foreignKeyName
+        });
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} referenceName
+     * @param {object} args
+     * @param {boolean} args.foreignKey
+     * @param {string} args.type
+     * @param {boolean} args.unique
+     * @returns {Promise<void>}
+     */
+    async addReference(tableName, referenceName, args) {
+        const { foreignKey, type, unique, ...restArgs } = args;
+        const columnName = `${inflection.underscore(referenceName)}_id`;
+        restArgsError(restArgs);
+        await this.addColumn(tableName, columnName, type || "integer");
+        await this.addIndex(tableName, [columnName], { unique: unique });
+        if (foreignKey) {
+            await this.addForeignKey(tableName, referenceName);
+        }
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} referenceName
+     * @returns {Promise<void>}
+     */
+    async removeReference(tableName, referenceName) {
+        const columnName = `${inflection.underscore(referenceName)}_id`;
+        this.removeColumn(tableName, columnName);
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @param {boolean} nullable
+     * @returns {Promise<void>}
+     */
+    async changeColumnNull(tableName, columnName, nullable) {
+        const table = await this.getDriver().getTableByName(tableName);
+        if (!table)
+            throw new Error(`Table ${tableName} does not exist`);
+        const column = await table.getColumnByName(columnName);
+        if (!column)
+            throw new Error(`Column ${columnName} does not exist in table ${tableName}`);
+        await column.changeNullable(nullable);
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} columnName
+     * @returns {Promise<boolean>}
+     */
+    async columnExists(tableName, columnName) {
+        const table = await this.getDriver().getTableByName(tableName);
+        if (table) {
+            const column = await table.getColumnByName(columnName);
+            if (column) {
+                return true;
+            }
+        }
+        return Boolean(false);
+    }
+    /**
+     * @typedef {object} CreateTableIdArgsType
+     * @property {any} [default]
+     * @property {string} [type]
+     */
+    /**
+     * @typedef {object} CreateTableArgsType
+     * @property {CreateTableIdArgsType | false} [id]
+     */
+    /**
+     * @typedef {(TableData) => void} CreateTableCallbackType
+     */
+    /**
+     * @overload
+     * @param {string} tableName
+     * @param {CreateTableCallbackType} callback
+     * @returns {Promise<void>}
+     */
+    /**
+     * @overload
+     * @param {string} tableName
+     * @param {CreateTableArgsType} args
+     * @param {CreateTableCallbackType} callback
+     * @returns {Promise<void>}
+     */
+    /**
+     * @param {string} tableName
+     * @param {CreateTableArgsType | CreateTableCallbackType} arg1
+     * @param {CreateTableCallbackType | undefined} [arg2]
+     * @returns {Promise<void>}
+     */
+    async createTable(tableName, arg1, arg2) {
+        let args;
+        let callback;
+        if (typeof arg1 == "function") {
+            args = {};
+            callback = arg1;
+        }
+        else {
+            args = arg1;
+            callback = arg2;
+        }
+        const { id = {}, ...restArgs } = args;
+        const databaseIdentifier = this._getDatabaseIdentifier();
+        const databasePool = this.configuration.getDatabasePool(databaseIdentifier);
+        let idDefault, idType, restArgsId;
+        if (id !== false) {
+            ({ default: idDefault, type: idType, ...restArgsId } = id);
+            restArgsError(restArgsId);
+        }
+        if (!idType) {
+            idType = databasePool.primaryKeyType();
+        }
+        const tableData = new TableData(tableName);
+        restArgsError(restArgs);
+        if (!(idType in tableData))
+            throw new Error(`Unsupported primary key type: ${idType}`);
+        if (id !== false) {
+            tableData.addColumn("id", { autoIncrement: true, default: idDefault, null: false, primaryKey: true, type: idType });
+        }
+        if (callback) {
+            callback(tableData);
+        }
+        const sqls = await this.getDriver().createTableSql(tableData);
+        for (const sql of sqls) {
+            await this._db.query(sql);
+        }
+    }
+    /**
+     * @param {string} tableName
+     * @returns {Promise<void>}
+     */
+    async dropTable(tableName) {
+        await this.getDriver().dropTable(tableName);
+    }
+    /**
+     * @param {string} tableName
+     * @param {string} oldColumnName
+     * @param {string} newColumnName
+     * @returns {Promise<void>}
+     */
+    async renameColumn(tableName, oldColumnName, newColumnName) {
+        await this.getDriver().renameColumn(tableName, oldColumnName, newColumnName);
+    }
+    /**
+     * @param {string} tableName
+     * @returns {Promise<boolean>}
+     */
+    async tableExists(tableName) {
+        const exists = await this.getDriver().tableExists(tableName);
+        return exists;
+    }
+}

package/dist/src/database/migrator/files-finder.d.ts

@@ -0,0 +1,15 @@
+export default class VelociousDatabaseMigratorFilesFinder {
+    /**
+     * @param {object} args
+     * @param {string} args.path
+     */
+    constructor({ path, ...restArgs }: {
+        path: string;
+    });
+    path: string;
+    /**
+     * @returns {Promise<Array<import("./types.js").MigrationObjectType>>}
+     */
+    findFiles(): Promise<Array<import("./types.js").MigrationObjectType>>;
+}
+//# sourceMappingURL=files-finder.d.ts.map

package/dist/src/database/migrator/files-finder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"files-finder.d.ts","sourceRoot":"","sources":["../../../../src/database/migrator/files-finder.js"],"names":[],"mappings":"AAOA;IACE;;;OAGG;IACH,mCAFG;QAAqB,IAAI,EAAjB,MAAM;KAChB,EAOA;IADC,aAAgB;IAGlB;;OAEG;IACH,aAFa,OAAO,CAAC,KAAK,CAAC,OAAO,YAAY,EAAE,mBAAmB,CAAC,CAAC,CA4BpE;CACF"}

package/dist/src/database/migrator/files-finder.js

@@ -0,0 +1,40 @@
+// @ts-check
+import fs from "fs/promises";
+import * as inflection from "inflection";
+import restArgsError from "../../utils/rest-args-error.js";
+export default class VelociousDatabaseMigratorFilesFinder {
+    /**
+     * @param {object} args
+     * @param {string} args.path
+     */
+    constructor({ path, ...restArgs }) {
+        restArgsError(restArgs);
+        if (!path)
+            throw new Error("No path given");
+        this.path = path;
+    }
+    /**
+     * @returns {Promise<Array<import("./types.js").MigrationObjectType>>}
+     */
+    async findFiles() {
+        let files = await fs.readdir(this.path);
+        /** @type {import("./types.js").MigrationObjectType[]} */
+        let result = [];
+        for (const file of files) {
+            const match = file.match(/^(\d{14})-(.+)\.js$/);
+            if (!match)
+                continue;
+            const date = parseInt(match[1]);
+            const migrationName = match[2];
+            const migrationClassName = inflection.camelize(migrationName.replaceAll("-", "_"));
+            result.push({
+                file,
+                fullPath: `${this.path}/${file}`,
+                date,
+                migrationClassName
+            });
+        }
+        result = result.sort((migration1, migration2) => migration1.date - migration2.date);
+        return result;
+    }
+}

package/dist/src/database/migrator/types.d.ts

@@ -0,0 +1,17 @@
+export type MigrationObjectType = {
+    date: number;
+    file: string;
+    fullPath?: string;
+    migrationClassName: string;
+};
+export type ImportCallbackType = () => typeof import("../migration/index.js").default;
+export type ImportFullpathCallbackType = (arg0: string) => Promise<typeof import("../migration/index.js").default>;
+export type RequireMigrationType = () => Promise<typeof import("../migration/index.js").default>;
+export type RequireMigrationContextRequireType = (id: string) => {
+    default: typeof import("../migration/index.js").default;
+};
+export type RequireMigrationContextType = RequireMigrationContextRequireType & {
+    keys: () => string[];
+    id: string;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/src/database/migrator/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/database/migrator/types.js"],"names":[],"mappings":";UAIc,MAAM;UACN,MAAM;eACN,MAAM;wBACN,MAAM;;iCAIP,MAAa,cAAc,uBAAuB,EAAE,OAAO;yCAI3D,CAAS,IAAM,EAAN,MAAM,KAAI,OAAO,CAAC,cAAc,uBAAuB,EAAE,OAAO,CAAC;mCAI1E,MAAM,OAAO,CAAC,cAAc,uBAAuB,EAAE,OAAO,CAAC;iDAI7D,CAAC,EAAE,EAAE,MAAM,KAAK;IAAC,OAAO,EAAE,cAAc,uBAAuB,EAAE,OAAO,CAAA;CAAC;0CACzE,kCAAkC,GAAG;IAC7C,IAAI,EAAE,MAAM,MAAM,EAAE,CAAC;IACrB,EAAE,EAAE,MAAM,CAAA;CACX"}

package/dist/src/database/migrator/types.js

@@ -0,0 +1,2 @@
+// @ts-check
+export {};

package/dist/src/database/migrator.d.ts

@@ -0,0 +1,79 @@
+export default class VelociousDatabaseMigrator {
+    /**
+     * @param {object} args
+     * @param {import("../configuration.js").default} args.configuration
+     */
+    constructor({ configuration, ...restArgs }: {
+        configuration: import("../configuration.js").default;
+    });
+    /** @type {Record<string, Record<string, boolean>>} */
+    migrationsVersions: Record<string, Record<string, boolean>>;
+    configuration: import("../configuration.js").default;
+    logger: Logger;
+    /**
+     * @returns {Promise<void>}
+     */
+    prepare(): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    createMigrationsTable(): Promise<void>;
+    dropDatabase(): Promise<void>;
+    /**
+     * @param {string} dbIdentifier
+     * @param {number} version
+     * @returns {boolean}
+     */
+    hasRunMigrationVersion(dbIdentifier: string, version: number): boolean;
+    /**
+     * @param {import("./migrator/types.js").MigrationObjectType[]} files
+     * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback
+     */
+    migrateFiles(files: import("./migrator/types.js").MigrationObjectType[], importCallback: import("./migrator/types.js").ImportFullpathCallbackType): Promise<void>;
+    /**
+     * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext
+     * @returns {Promise<void>}
+     */
+    migrateFilesFromRequireContext(requireContext: import("./migrator/types.js").RequireMigrationContextType): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    loadMigrationsVersions(): Promise<void>;
+    /**
+     * @param {import("./drivers/base.js").default} db
+     * @returns {Promise<boolean>}
+     */
+    migrationsTableExist(db: import("./drivers/base.js").default): Promise<boolean>;
+    /**
+     * @param {import("./migrator/types.js").RequireMigrationContextType} requireContext
+     * @returns {Promise<void>}
+     */
+    executeRequireContext(requireContext: import("./migrator/types.js").RequireMigrationContextType): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    reset(): Promise<void>;
+    /**
+     * @param {import("./migrator/types.js").MigrationObjectType[]} files
+     * @param {import("./migrator/types.js").ImportFullpathCallbackType} importCallback Function to import a file
+     * @returns {Promise<void>}
+     */
+    rollback(files: import("./migrator/types.js").MigrationObjectType[], importCallback: import("./migrator/types.js").ImportFullpathCallbackType): Promise<void>;
+    /**
+     * @returns {Promise<string | undefined>} The latest migration version
+     */
+    _latestMigrationVersion(): Promise<string | undefined>;
+    /**
+     * @param {object} args
+     * @param {import("./migrator/types.js").MigrationObjectType} args.migration
+     * @param {import("./migrator/types.js").RequireMigrationType} args.requireMigration
+     * @param {string} [args.direction]
+     */
+    runMigrationFile({ migration, requireMigration, direction }: {
+        migration: import("./migrator/types.js").MigrationObjectType;
+        requireMigration: import("./migrator/types.js").RequireMigrationType;
+        direction?: string;
+    }): Promise<void>;
+}
+import { Logger } from "../logger.js";
+//# sourceMappingURL=migrator.d.ts.map