@wo658/redpact 0.4.1 → 0.5.0

package/node_modules/umzug/lib/storage/json.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JSONStorage = void 0;
+const fs_1 = require("fs");
+const path = __importStar(require("path"));
+const filesystem = {
+    /** reads a file as a string or returns null if file doesn't exist */
+    async readAsync(filepath) {
+        return fs_1.promises.readFile(filepath).then(c => c.toString(), () => null);
+    },
+    /** writes a string as file contents, creating its parent directory if necessary */
+    async writeAsync(filepath, content) {
+        await fs_1.promises.mkdir(path.dirname(filepath), { recursive: true });
+        await fs_1.promises.writeFile(filepath, content);
+    },
+};
+class JSONStorage {
+    constructor(options) {
+        var _a;
+        this.path = (_a = options === null || options === void 0 ? void 0 : options.path) !== null && _a !== void 0 ? _a : path.join(process.cwd(), 'umzug.json');
+    }
+    async logMigration({ name: migrationName }) {
+        const loggedMigrations = await this.executed();
+        loggedMigrations.push(migrationName);
+        await filesystem.writeAsync(this.path, JSON.stringify(loggedMigrations, null, 2));
+    }
+    async unlogMigration({ name: migrationName }) {
+        const loggedMigrations = await this.executed();
+        const updatedMigrations = loggedMigrations.filter(name => name !== migrationName);
+        await filesystem.writeAsync(this.path, JSON.stringify(updatedMigrations, null, 2));
+    }
+    async executed() {
+        const content = await filesystem.readAsync(this.path);
+        return content ? JSON.parse(content) : [];
+    }
+}
+exports.JSONStorage = JSONStorage;
+//# sourceMappingURL=json.js.map

package/node_modules/umzug/lib/storage/json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"json.js","sourceRoot":"","sources":["../../src/storage/json.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2BAAiC;AACjC,2CAA4B;AAG5B,MAAM,UAAU,GAAG;IACjB,qEAAqE;IACrE,KAAK,CAAC,SAAS,CAAC,QAAgB;QAC9B,OAAO,aAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,IAAI,CAC/B,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,QAAQ,EAAE,EACjB,GAAG,EAAE,CAAC,IAAI,CACX,CAAA;IACH,CAAC;IACD,mFAAmF;IACnF,KAAK,CAAC,UAAU,CAAC,QAAgB,EAAE,OAAe;QAChD,MAAM,aAAE,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,EAAC,SAAS,EAAE,IAAI,EAAC,CAAC,CAAA;QACzD,MAAM,aAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAA;IACvC,CAAC;CACF,CAAA;AAWD,MAAa,WAAW;IAGtB,YAAY,OAAuC;;QACjD,IAAI,CAAC,IAAI,GAAG,MAAA,OAAO,aAAP,OAAO,uBAAP,OAAO,CAAE,IAAI,mCAAI,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,YAAY,CAAC,CAAA;IACrE,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,EAAC,IAAI,EAAE,aAAa,EAAiB;QACtD,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;QAC9C,gBAAgB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAA;QAEpC,MAAM,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,gBAAgB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;IACnF,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,aAAa,EAAiB;QACxD,MAAM,gBAAgB,GAAG,MAAM,IAAI,CAAC,QAAQ,EAAE,CAAA;QAC9C,MAAM,iBAAiB,GAAG,gBAAgB,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,aAAa,CAAC,CAAA;QAEjF,MAAM,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,iBAAiB,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,CAAA;IACpF,CAAC;IAED,KAAK,CAAC,QAAQ;QACZ,MAAM,OAAO,GAAG,MAAM,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACrD,OAAO,OAAO,CAAC,CAAC,CAAE,IAAI,CAAC,KAAK,CAAC,OAAO,CAAc,CAAC,CAAC,CAAC,EAAE,CAAA;IACzD,CAAC;CACF;AAzBD,kCAyBC"}

package/node_modules/umzug/lib/storage/memory.d.ts

@@ -0,0 +1,2 @@
+import type { UmzugStorage } from './contract';
+export declare const memoryStorage: () => UmzugStorage;

package/node_modules/umzug/lib/storage/memory.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoryStorage = void 0;
+const memoryStorage = () => {
+    let executed = [];
+    return {
+        async logMigration({ name }) {
+            executed.push(name);
+        },
+        async unlogMigration({ name }) {
+            executed = executed.filter(n => n !== name);
+        },
+        executed: async () => [...executed],
+    };
+};
+exports.memoryStorage = memoryStorage;
+//# sourceMappingURL=memory.js.map

package/node_modules/umzug/lib/storage/memory.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.js","sourceRoot":"","sources":["../../src/storage/memory.ts"],"names":[],"mappings":";;;AAEO,MAAM,aAAa,GAAG,GAAiB,EAAE;IAC9C,IAAI,QAAQ,GAAa,EAAE,CAAA;IAC3B,OAAO;QACL,KAAK,CAAC,YAAY,CAAC,EAAC,IAAI,EAAC;YACvB,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACrB,CAAC;QACD,KAAK,CAAC,cAAc,CAAC,EAAC,IAAI,EAAC;YACzB,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,IAAI,CAAC,CAAA;QAC7C,CAAC;QACD,QAAQ,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,QAAQ,CAAC;KACpC,CAAA;AACH,CAAC,CAAA;AAXY,QAAA,aAAa,iBAWzB"}

package/node_modules/umzug/lib/storage/mongodb.d.ts

@@ -0,0 +1,35 @@
+import type { UmzugStorage } from './contract';
+type AnyObject = Record<string, any>;
+export type MongoDBConnectionOptions = {
+    /**
+      A connection to target database established with MongoDB Driver
+      */
+    readonly connection: AnyObject;
+    /**
+      The name of the migration collection in MongoDB
+  
+      @default 'migrations'
+      */
+    readonly collectionName?: string;
+};
+export type MongoDBCollectionOptions = {
+    /**
+      A reference to a MongoDB Driver collection
+      */
+    readonly collection: AnyObject;
+};
+export type MongoDBStorageConstructorOptions = MongoDBConnectionOptions | MongoDBCollectionOptions;
+export declare class MongoDBStorage implements UmzugStorage {
+    readonly collection: AnyObject;
+    readonly connection: any;
+    readonly collectionName: string;
+    constructor(options: MongoDBStorageConstructorOptions);
+    logMigration({ name: migrationName }: {
+        name: string;
+    }): Promise<void>;
+    unlogMigration({ name: migrationName }: {
+        name: string;
+    }): Promise<void>;
+    executed(): Promise<string[]>;
+}
+export {};

package/node_modules/umzug/lib/storage/mongodb.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MongoDBStorage = void 0;
+function isMongoDBCollectionOptions(arg) {
+    return Boolean(arg.collection);
+}
+class MongoDBStorage {
+    constructor(options) {
+        var _a, _b;
+        if (!options || (!options.collection && !options.connection)) {
+            throw new Error('MongoDB Connection or Collection required');
+        }
+        this.collection = isMongoDBCollectionOptions(options)
+            ? options.collection
+            : options.connection.collection((_a = options.collectionName) !== null && _a !== void 0 ? _a : 'migrations');
+        this.connection = options.connection; // TODO remove this
+        this.collectionName = (_b = options.collectionName) !== null && _b !== void 0 ? _b : 'migrations'; // TODO remove this
+    }
+    async logMigration({ name: migrationName }) {
+        await this.collection.insertOne({ migrationName });
+    }
+    async unlogMigration({ name: migrationName }) {
+        await this.collection.deleteOne({ migrationName });
+    }
+    async executed() {
+        const records = await this.collection.find({}).sort({ migrationName: 1 }).toArray();
+        return records.map(r => r.migrationName);
+    }
+}
+exports.MongoDBStorage = MongoDBStorage;
+//# sourceMappingURL=mongodb.js.map

package/node_modules/umzug/lib/storage/mongodb.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mongodb.js","sourceRoot":"","sources":["../../src/storage/mongodb.ts"],"names":[],"mappings":";;;AA6BA,SAAS,0BAA0B,CAAC,GAAQ;IAC1C,OAAO,OAAO,CAAC,GAAG,CAAC,UAAU,CAAC,CAAA;AAChC,CAAC;AAED,MAAa,cAAc;IAKzB,YAAY,OAAyC;;QACnD,IAAI,CAAC,OAAO,IAAI,CAAC,CAAE,OAAe,CAAC,UAAU,IAAI,CAAE,OAAe,CAAC,UAAU,CAAC,EAAE;YAC9E,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAA;SAC7D;QAED,IAAI,CAAC,UAAU,GAAG,0BAA0B,CAAC,OAAO,CAAC;YACnD,CAAC,CAAC,OAAO,CAAC,UAAU;YACpB,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,UAAU,CAAC,MAAA,OAAO,CAAC,cAAc,mCAAI,YAAY,CAAC,CAAA;QAEzE,IAAI,CAAC,UAAU,GAAI,OAAe,CAAC,UAAU,CAAA,CAAC,mBAAmB;QACjE,IAAI,CAAC,cAAc,GAAG,MAAC,OAAe,CAAC,cAAc,mCAAI,YAAY,CAAA,CAAC,mBAAmB;IAC3F,CAAC;IAED,KAAK,CAAC,YAAY,CAAC,EAAC,IAAI,EAAE,aAAa,EAAiB;QACtD,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;IAClD,CAAC;IAED,KAAK,CAAC,cAAc,CAAC,EAAC,IAAI,EAAE,aAAa,EAAiB;QACxD,MAAM,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,EAAC,aAAa,EAAC,CAAC,CAAA;IAClD,CAAC;IAED,KAAK,CAAC,QAAQ;QAEZ,MAAM,OAAO,GAAa,MAAM,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,EAAC,aAAa,EAAE,CAAC,EAAC,CAAC,CAAC,OAAO,EAAE,CAAA;QAC3F,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,aAAa,CAAC,CAAA;IAC1C,CAAC;CACF;AA/BD,wCA+BC"}

package/node_modules/umzug/lib/storage/sequelize.d.ts

@@ -0,0 +1,106 @@
+import type { SetRequired } from 'type-fest';
+import type { UmzugStorage } from './contract';
+type ModelTempInterface = {} & ModelClass & Record<string, any>;
+/**
+ * Minimal structure of a sequelize model, defined here to avoid a hard dependency.
+ * The type expected is `import { Model } from 'sequelize'`
+ */
+export type ModelClass = {
+    tableName: string;
+    sequelize?: SequelizeType;
+    getTableName(): string;
+    sync(): Promise<void>;
+    findAll(options?: {}): Promise<any[]>;
+    create(options: {}): Promise<void>;
+    destroy(options: {}): Promise<void>;
+};
+/**
+ * Minimal structure of a sequelize model, defined here to avoid a hard dependency.
+ * The type expected is `import { Sequelize } from 'sequelize'`
+ */
+export type SequelizeType = {
+    getQueryInterface(): any;
+    isDefined(modelName: string): boolean;
+    model(modelName: string): any;
+    define(modelName: string, columns: {}, options: {}): {};
+    dialect?: {
+        name?: string;
+    };
+};
+type ModelClassType = ModelClass & (new (values?: object, options?: any) => ModelTempInterface);
+type _SequelizeStorageConstructorOptions = {
+    /**
+      The configured instance of Sequelize. If omitted, it is inferred from the `model` option.
+      */
+    readonly sequelize?: SequelizeType;
+    /**
+      The model representing the SequelizeMeta table. Must have a column that matches the `columnName` option. If omitted, it is created automatically.
+      */
+    readonly model?: any;
+    /**
+      The name of the model.
+  
+      @default 'SequelizeMeta'
+      */
+    readonly modelName?: string;
+    /**
+      The name of the table. If omitted, defaults to the model name.
+      */
+    readonly tableName?: string;
+    /**
+      Name of the schema under which the table is to be created.
+  
+      @default undefined
+      */
+    readonly schema?: any;
+    /**
+      Name of the table column holding the executed migration names.
+  
+      @default 'name'
+      */
+    readonly columnName?: string;
+    /**
+      The type of the column holding the executed migration names.
+  
+      For `utf8mb4` charsets under InnoDB, you may need to set this to less than 190
+  
+      @default Sequelize.DataTypes.STRING
+      */
+    readonly columnType?: any;
+    /**
+      Option to add timestamps to the table
+  
+      @default false
+      */
+    readonly timestamps?: boolean;
+};
+export type SequelizeStorageConstructorOptions = SetRequired<_SequelizeStorageConstructorOptions, 'sequelize'> | SetRequired<_SequelizeStorageConstructorOptions, 'model'>;
+export declare class SequelizeStorage implements UmzugStorage {
+    readonly sequelize: SequelizeType;
+    readonly columnType: string;
+    readonly columnName: string;
+    readonly timestamps: boolean;
+    readonly modelName: string;
+    readonly tableName?: string;
+    readonly schema: any;
+    readonly model: ModelClassType;
+    /**
+      Constructs Sequelize based storage. Migrations will be stored in a SequelizeMeta table using the given instance of Sequelize.
+  
+      If a model is given, it will be used directly as the model for the SequelizeMeta table. Otherwise, it will be created automatically according to the given options.
+  
+      If the table does not exist it will be created automatically upon the logging of the first migration.
+      */
+    constructor(options: SequelizeStorageConstructorOptions);
+    getModel(): ModelClassType;
+    protected syncModel(): Promise<void>;
+    logMigration({ name: migrationName }: {
+        name: string;
+    }): Promise<void>;
+    unlogMigration({ name: migrationName }: {
+        name: string;
+    }): Promise<void>;
+    executed(): Promise<string[]>;
+    _model(): ModelClassType;
+}
+export {};

package/node_modules/umzug/lib/storage/sequelize.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeStorage = void 0;
+const DIALECTS_WITH_CHARSET_AND_COLLATE = new Set(['mysql', 'mariadb']);
+class SequelizeStorage {
+    /**
+      Constructs Sequelize based storage. Migrations will be stored in a SequelizeMeta table using the given instance of Sequelize.
+  
+      If a model is given, it will be used directly as the model for the SequelizeMeta table. Otherwise, it will be created automatically according to the given options.
+  
+      If the table does not exist it will be created automatically upon the logging of the first migration.
+      */
+    constructor(options) {
+        var _a, _b, _c, _d, _e, _f;
+        if (!options || (!options.model && !options.sequelize)) {
+            throw new Error('One of "sequelize" or "model" storage option is required');
+        }
+        this.sequelize = (_a = options.sequelize) !== null && _a !== void 0 ? _a : options.model.sequelize;
+        this.columnType = (_b = options.columnType) !== null && _b !== void 0 ? _b : this.sequelize.constructor.DataTypes.STRING;
+        this.columnName = (_c = options.columnName) !== null && _c !== void 0 ? _c : 'name';
+        this.timestamps = (_d = options.timestamps) !== null && _d !== void 0 ? _d : false;
+        this.modelName = (_e = options.modelName) !== null && _e !== void 0 ? _e : 'SequelizeMeta';
+        this.tableName = options.tableName;
+        this.schema = options.schema;
+        this.model = (_f = options.model) !== null && _f !== void 0 ? _f : this.getModel();
+    }
+    getModel() {
+        var _a;
+        if (this.sequelize.isDefined(this.modelName)) {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+            return this.sequelize.model(this.modelName);
+        }
+        const dialectName = (_a = this.sequelize.dialect) === null || _a === void 0 ? void 0 : _a.name;
+        const hasCharsetAndCollate = dialectName && DIALECTS_WITH_CHARSET_AND_COLLATE.has(dialectName);
+        return this.sequelize.define(this.modelName, {
+            [this.columnName]: {
+                type: this.columnType,
+                allowNull: false,
+                unique: true,
+                primaryKey: true,
+                autoIncrement: false,
+            },
+        }, {
+            tableName: this.tableName,
+            schema: this.schema,
+            timestamps: this.timestamps,
+            charset: hasCharsetAndCollate ? 'utf8' : undefined,
+            collate: hasCharsetAndCollate ? 'utf8_unicode_ci' : undefined,
+        });
+    }
+    async syncModel() {
+        await this.model.sync();
+    }
+    async logMigration({ name: migrationName }) {
+        await this.syncModel();
+        await this.model.create({
+            [this.columnName]: migrationName,
+        });
+    }
+    async unlogMigration({ name: migrationName }) {
+        await this.syncModel();
+        await this.model.destroy({
+            where: {
+                [this.columnName]: migrationName,
+            },
+        });
+    }
+    async executed() {
+        await this.syncModel();
+        const migrations = await this.model.findAll({ order: [[this.columnName, 'ASC']] });
+        return migrations.map(migration => {
+            const name = migration[this.columnName];
+            if (typeof name !== 'string') {
+                throw new TypeError(`Unexpected migration name type: expected string, got ${typeof name}`);
+            }
+            return name;
+        });
+    }
+    // TODO remove this
+    _model() {
+        return this.model;
+    }
+}
+exports.SequelizeStorage = SequelizeStorage;
+//# sourceMappingURL=sequelize.js.map

package/node_modules/umzug/lib/storage/sequelize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequelize.js","sourceRoot":"","sources":["../../src/storage/sequelize.ts"],"names":[],"mappings":"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"}

package/node_modules/umzug/lib/templates.d.ts

@@ -0,0 +1,5 @@
+export declare const js: string;
+export declare const ts: string;
+export declare const mjs: string;
+export declare const sqlUp: string;
+export declare const sqlDown: string;

package/node_modules/umzug/lib/templates.js

@@ -0,0 +1,32 @@
+"use strict";
+/* eslint-disable unicorn/template-indent */
+// templates for migration file creation
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sqlDown = exports.sqlUp = exports.mjs = exports.ts = exports.js = void 0;
+exports.js = `
+/** @type {import('umzug').MigrationFn<any>} */
+exports.up = async params => {};
+
+/** @type {import('umzug').MigrationFn<any>} */
+exports.down = async params => {};
+`.trimStart();
+exports.ts = `
+import type { MigrationFn } from 'umzug';
+
+export const up: MigrationFn = async params => {};
+export const down: MigrationFn = async params => {};
+`.trimStart();
+exports.mjs = `
+/** @type {import('umzug').MigrationFn<any>} */
+export const up = async params => {};
+
+/** @type {import('umzug').MigrationFn<any>} */
+export const down = async params => {};
+`.trimStart();
+exports.sqlUp = `
+-- up migration
+`.trimStart();
+exports.sqlDown = `
+-- down migration
+`.trimStart();
+//# sourceMappingURL=templates.js.map

package/node_modules/umzug/lib/templates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"templates.js","sourceRoot":"","sources":["../src/templates.ts"],"names":[],"mappings":";AAAA,4CAA4C;AAC5C,wCAAwC;;;AAE3B,QAAA,EAAE,GAAG;;;;;;CAMjB,CAAC,SAAS,EAAE,CAAA;AAEA,QAAA,EAAE,GAAG;;;;;CAKjB,CAAC,SAAS,EAAE,CAAA;AAEA,QAAA,GAAG,GAAG;;;;;;CAMlB,CAAC,SAAS,EAAE,CAAA;AAEA,QAAA,KAAK,GAAG;;CAEpB,CAAC,SAAS,EAAE,CAAA;AAEA,QAAA,OAAO,GAAG;;CAEtB,CAAC,SAAS,EAAE,CAAA"}

package/node_modules/umzug/lib/types.d.ts

@@ -0,0 +1,129 @@
+import type * as typeFest from 'type-fest';
+import type { UmzugStorage } from './storage';
+/**
+ * Create a type that has mutually exclusive keys.
+ * Wrapper for @see `import('type-fest').MergeExclusive` that works for three types
+ */
+export type MergeExclusive<A, B, C> = typeFest.MergeExclusive<A, typeFest.MergeExclusive<B, C>>;
+export type Promisable<T> = T | PromiseLike<T>;
+export type LogFn = (message: Record<string, unknown>) => void;
+/** Constructor options for the Umzug class */
+export type UmzugOptions<Ctx extends {} = Record<string, unknown>> = {
+    /** The migrations that the Umzug instance should perform */
+    migrations: InputMigrations<Ctx>;
+    /** A logging function. Pass `console` to use stdout, or pass in your own logger. Pass `undefined` explicitly to disable logging. */
+    logger: Record<'info' | 'warn' | 'error' | 'debug', LogFn> | undefined;
+    /** The storage implementation. By default, `JSONStorage` will be used */
+    storage?: UmzugStorage<Ctx>;
+    /** An optional context object, which will be passed to each migration function, if defined */
+    context?: Ctx | (() => Promise<Ctx> | Ctx);
+    /** Options for file creation */
+    create?: {
+        /**
+         * A function for generating placeholder migration files. Specify to make sure files generated via CLI or using `.create` follow team conventions.
+         * Should return an array of [filepath, content] pairs. Usually, only one pair is needed, but to put `down` migrations in a separate
+         * file, more than one can be returned.
+         */
+        template?: (filepath: string) => Promisable<Array<[string, string]>>;
+        /**
+         * The default folder that new migration files should be generated in. If this is not specified, the new migration file will be created
+         * in the same folder as the last existing migration. The value here can be overriden by passing `folder` when calling `create`.
+         */
+        folder?: string;
+    };
+};
+/** Serializeable metadata for a migration. The structure returned by the external-facing `pending()` and `executed()` methods. */
+export type MigrationMeta = {
+    /** Name - this is used as the migration unique identifier within storage */
+    name: string;
+    /** An optional filepath for the migration. Note: this may be undefined, since not all migrations correspond to files on the filesystem */
+    path?: string;
+};
+export type MigrationParams<T> = {
+    name: string;
+    path?: string;
+    context: T;
+};
+/** A callable function for applying or reverting a migration  */
+export type MigrationFn<T = unknown> = (params: MigrationParams<T>) => Promise<unknown>;
+/**
+ * A runnable migration. Represents a migration object with an `up` function which can be called directly, with no arguments, and an optional `down` function to revert it.
+ */
+export type RunnableMigration<T> = {
+    /** The effect of applying the migration */
+    up: MigrationFn<T>;
+    /** The effect of reverting the migration */
+    down?: MigrationFn<T>;
+} & MigrationMeta;
+/** Glob instructions for migration files */
+export type GlobInputMigrations<T> = {
+    /**
+     * A glob string for migration files. Can also be in the format `[path/to/migrations/*.js', {cwd: 'some/base/dir', ignore: '**ignoreme.js' }]`
+     * See https://npmjs.com/package/glob for more details on the glob format - this package is used internally.
+     */
+    glob: string | [string, {
+        cwd?: string;
+        ignore?: string | string[];
+    }];
+    /** Will be supplied to every migration function. Can be a database client, for example */
+    /** A function which takes a migration name, path and context, and returns an object with `up` and `down` functions. */
+    resolve?: Resolver<T>;
+};
+/**
+ * Allowable inputs for migrations. Can be either glob instructions for migration files, a list of runnable migrations, or a
+ * function which receives a context and returns a list of migrations.
+ */
+export type InputMigrations<T> = GlobInputMigrations<T> | Array<RunnableMigration<T>> | ((context: T) => Promisable<InputMigrations<T>>);
+/** A function which takes a migration name, path and context, and returns an object with `up` and `down` functions. */
+export type Resolver<T> = (params: MigrationParams<T>) => RunnableMigration<T>;
+export declare const RerunBehavior: {
+    /** Hard error if an up migration that has already been run, or a down migration that hasn't, is encountered */
+    readonly THROW: "THROW";
+    /** Silently skip up migrations that have already been run, or down migrations that haven't */
+    readonly SKIP: "SKIP";
+    /** Re-run up migrations that have already been run, or down migrations that haven't */
+    readonly ALLOW: "ALLOW";
+};
+export type RerunBehavior = keyof typeof RerunBehavior;
+export type MigrateUpOptions = MergeExclusive<{
+    /** If specified, migrations up to and including this name will be run. Otherwise, all pending migrations will be run */
+    to?: string;
+}, {
+    /** Only run this many migrations. If not specified, all pending migrations will be run */
+    step: number;
+}, {
+    /** If specified, only the migrations with these names migrations will be run. An error will be thrown if any of the names are not found in the list of available migrations */
+    migrations: string[];
+    /** What to do if a migration that has already been run is explicitly specified. Default is `THROW`. */
+    rerun?: RerunBehavior;
+}>;
+export type MigrateDownOptions = MergeExclusive<{
+    /** If specified, migrations down to and including this name will be revert. Otherwise, only the last executed will be reverted */
+    to?: string | 0;
+}, {
+    /** Revert this many migrations. If not specified, only the most recent migration will be reverted */
+    step: number;
+}, {
+    /**
+     * If specified, only the migrations with these names migrations will be reverted. An error will be thrown if any of the names are not found in the list of executed migrations.
+     * Note, migrations will be run in the order specified.
+     */
+    migrations: string[];
+    /** What to do if a migration that has not been run is explicitly specified. Default is `THROW`. */
+    rerun?: RerunBehavior;
+}>;
+/** Map of eventName -> eventData type, where the keys are the string events that are emitted by an umzug instances, and the values are the payload emitted with the corresponding event. */
+export type UmzugEvents<Ctx> = {
+    migrating: MigrationParams<Ctx>;
+    migrated: MigrationParams<Ctx>;
+    reverting: MigrationParams<Ctx>;
+    reverted: MigrationParams<Ctx>;
+    beforeCommand: {
+        command: string;
+        context: Ctx;
+    };
+    afterCommand: {
+        command: string;
+        context: Ctx;
+    };
+};

package/node_modules/umzug/lib/types.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RerunBehavior = void 0;
+exports.RerunBehavior = {
+    /** Hard error if an up migration that has already been run, or a down migration that hasn't, is encountered */
+    THROW: 'THROW',
+    /** Silently skip up migrations that have already been run, or down migrations that haven't */
+    SKIP: 'SKIP',
+    /** Re-run up migrations that have already been run, or down migrations that haven't */
+    ALLOW: 'ALLOW',
+};
+//# sourceMappingURL=types.js.map

package/node_modules/umzug/lib/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":";;;AA0Fa,QAAA,aAAa,GAAG;IAC3B,+GAA+G;IAC/G,KAAK,EAAE,OAAO;IACd,8FAA8F;IAC9F,IAAI,EAAE,MAAM;IACZ,uFAAuF;IACvF,KAAK,EAAE,OAAO;CACN,CAAA"}

package/node_modules/umzug/lib/umzug.d.ts

@@ -0,0 +1,105 @@
+import emittery from 'emittery';
+import * as errorCause from 'pony-cause';
+import type { CommandLineParserOptions } from './cli';
+import { UmzugCLI } from './cli';
+import type { MigrateDownOptions, MigrateUpOptions, MigrationMeta, MigrationParams, Resolver, RunnableMigration, UmzugEvents, UmzugOptions } from './types';
+type MigrationErrorParams = {
+    direction: 'up' | 'down';
+} & MigrationParams<unknown>;
+export declare class MigrationError extends errorCause.ErrorWithCause<unknown> {
+    name: string;
+    migration: MigrationErrorParams;
+    jse_cause: unknown;
+    constructor(migration: MigrationErrorParams, original: unknown);
+    get info(): MigrationErrorParams;
+    private static errorString;
+}
+export declare class Umzug<Ctx extends object = object> extends emittery<UmzugEvents<Ctx>> {
+    readonly options: UmzugOptions<Ctx>;
+    private readonly storage;
+    readonly migrations: (ctx: Ctx) => Promise<ReadonlyArray<RunnableMigration<Ctx>>>;
+    /**
+     * Compile-time only property for type inference. After creating an Umzug instance, it can be used as type alias for
+     * a user-defined migration. The function receives a migration name, path and the context for an umzug instance
+     * @example
+     * ```
+     * // migrator.ts
+     * import { Umzug } from 'umzug'
+     *
+     * const umzug = new Umzug({...})
+     * export type Migration = typeof umzug._types.migration;
+     *
+     * umzug.up();
+     * ```
+     * ___
+     *
+     * ```
+     * // migration-1.ts
+     * import type { Migration } from '../migrator'
+     *
+     * // name and context will now be strongly-typed
+     * export const up: Migration = ({name, context}) => context.query(...)
+     * export const down: Migration = ({name, context}) => context.query(...)
+     * ```
+     */
+    readonly _types: {
+        migration: (params: MigrationParams<Ctx>) => Promise<unknown>;
+        context: Ctx;
+    };
+    /** creates a new Umzug instance */
+    constructor(options: UmzugOptions<Ctx>);
+    private logging;
+    static defaultResolver: Resolver<unknown>;
+    /**
+     * Get an UmzugCLI instance. This can be overriden in a subclass to add/remove commands - only use if you really know you need this,
+     * and are OK to learn about/interact with the API of @rushstack/ts-command-line.
+     */
+    protected getCli(options?: CommandLineParserOptions): UmzugCLI;
+    /**
+     * 'Run' an umzug instance as a CLI. This will read `process.argv`, execute commands based on that, and call
+     * `process.exit` after running. If that isn't what you want, stick to the programmatic API.
+     * You probably want to run only if a file is executed as the process's 'main' module with something like:
+     * @example
+     * if (require.main === module) {
+     *   myUmzugInstance.runAsCLI()
+     * }
+     */
+    runAsCLI(argv?: string[]): Promise<boolean>;
+    /** Get the list of migrations which have already been applied */
+    executed(): Promise<MigrationMeta[]>;
+    /** Get the list of migrations which have already been applied */
+    private _executed;
+    /** Get the list of migrations which are yet to be applied */
+    pending(): Promise<MigrationMeta[]>;
+    private _pending;
+    protected runCommand<T>(command: string, cb: (commandParams: {
+        context: Ctx;
+    }) => Promise<T>): Promise<T>;
+    /**
+     * Apply migrations. By default, runs all pending migrations.
+     * @see MigrateUpOptions for other use cases using `to`, `migrations` and `rerun`.
+     */
+    up(options?: MigrateUpOptions): Promise<MigrationMeta[]>;
+    /**
+     * Revert migrations. By default, the last executed migration is reverted.
+     * @see MigrateDownOptions for other use cases using `to`, `migrations` and `rerun`.
+     */
+    down(options?: MigrateDownOptions): Promise<MigrationMeta[]>;
+    create(options: {
+        name: string;
+        folder?: string;
+        prefix?: 'TIMESTAMP' | 'DATE' | 'NONE';
+        allowExtension?: string;
+        allowConfusingOrdering?: boolean;
+        skipVerify?: boolean;
+        /** Optionally define the content for the new file. If not set, the configured template will be used. */
+        content?: string;
+    }): Promise<void>;
+    private static defaultCreationTemplate;
+    private findNameIndex;
+    private findMigrations;
+    private getContext;
+    /** helper for parsing input migrations into a callback returning a list of ready-to-run migrations */
+    private getMigrationsResolver;
+}
+export {};