Put umzug in server/libs and remove unneeded dependencies from it

server/libs/umzug/storage/contract.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyUmzugStorage = exports.isUmzugStorage = void 0;
+function isUmzugStorage(arg) {
+    return (arg &&
+        typeof arg.logMigration === 'function' &&
+        typeof arg.unlogMigration === 'function' &&
+        typeof arg.executed === 'function');
+}
+exports.isUmzugStorage = isUmzugStorage;
+const verifyUmzugStorage = (arg) => {
+    if (!isUmzugStorage(arg)) {
+        throw new Error(`Invalid umzug storage`);
+    }
+    return arg;
+};
+exports.verifyUmzugStorage = verifyUmzugStorage;
+//# sourceMappingURL=contract.js.map

server/libs/umzug/storage/index.js

@@ -0,0 +1,24 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// codegen:start {preset: barrel}
+__exportStar(require("./contract"), exports);
+__exportStar(require("./json"), exports);
+__exportStar(require("./memory"), exports);
+__exportStar(require("./mongodb"), exports);
+__exportStar(require("./sequelize"), exports);
+// codegen:end
+//# sourceMappingURL=index.js.map

server/libs/umzug/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

server/libs/umzug/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

server/libs/umzug/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

server/libs/umzug/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