sqlmorpheus 0.1.0

package/dist/lib/dialects/MsSqlDialect.d.ts

@@ -0,0 +1,18 @@
+import DefaultSql from "./DefaultSql";
+import { ForeignKeyInfo } from "../typings/ForeignKeyInfo";
+import { DatabaseAccess } from "../typings/DatabaseAccess";
+import { ColumnInfo } from "../typings/ColumnInfo";
+export default class MsSqlDialect extends DefaultSql {
+    canAlterForeignKeys: boolean;
+    canAlterPrimaryKey: boolean;
+    canInspectForeignKeys: boolean;
+    canInspectPrimaryKey: boolean;
+    changeForeignKeysState(enabled: boolean): string;
+    getForeignKeys(tableName: string, db: DatabaseAccess): Promise<ForeignKeyInfo[]>;
+    addForeignKey(fromTableName: string, foreignKey: string): string;
+    removeForeignKey(tableName: string, foreignKeyName: string): string;
+    addPrimaryKey(tableName: string, columnName: string): string;
+    removePrimaryKey(tableName: string, columnName: string): string;
+    getTableNames(db: DatabaseAccess): Promise<string[]>;
+    getColumnInformation(tableName: string, db: DatabaseAccess): Promise<ColumnInfo[]>;
+}

package/dist/lib/dialects/MsSqlDialect.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultSql_1 = __importDefault(require("./DefaultSql"));
+class MsSqlDialect extends DefaultSql_1.default {
+    canAlterForeignKeys = true;
+    canAlterPrimaryKey = true;
+    canInspectForeignKeys = true;
+    canInspectPrimaryKey = false;
+    changeForeignKeysState(enabled) {
+        return `EXEC sp_MSforeachtable "${enabled ? "ALTER TABLE ? WITH CHECK CHECK CONSTRAINT all" : "ALTER TABLE ? NOCHECK CONSTRAINT all"}"`;
+    }
+    async getForeignKeys(tableName, db) {
+        const data = await db.runGetStatement(`EXEC sp_fkeys @fktable_name = ${tableName};`);
+        return data.map(entry => {
+            return {
+                fromTable: entry[tableName],
+                fromColumn: entry["FKCOLUMN_NAME"],
+                toTable: entry["PKTABLE_NAME"],
+                toColumn: entry["PKCOLUMN_NAME"],
+            };
+        });
+    }
+    addForeignKey(fromTableName, foreignKey) {
+        return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
+    }
+    removeForeignKey(tableName, foreignKeyName) {
+        return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
+    }
+    addPrimaryKey(tableName, columnName) {
+        return `ALTER TABLE ${tableName} ADD CONSTRAINT ${tableName}_primary PRIMARY KEY (${columnName});`;
+    }
+    removePrimaryKey(tableName, columnName) {
+        return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName}_primary;`;
+    }
+    async getTableNames(db) {
+        return await db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
+    }
+    async getColumnInformation(tableName, db) {
+        const data = await db.runGetStatement(`SELECT COLUMN_NAME, DATA_TYPE, COLUMN_DEFAULT FROM INFORMATION_SCHEMA.COLUMNS WHERE TABLE_NAME = N'${tableName};'`);
+        return data.map(entry => {
+            return {
+                name: entry["COLUMN_NAME"],
+                type: entry["DATA_TYPE"],
+                defaultValue: entry["COLUMN_DEFAULT"],
+                isPrimaryKey: false,
+            };
+        });
+    }
+}
+exports.default = MsSqlDialect;

package/dist/lib/dialects/MySqlDialect.d.ts

@@ -0,0 +1,18 @@
+import DefaultSql from "./DefaultSql";
+import { ForeignKeyInfo } from "../typings/ForeignKeyInfo";
+import { DatabaseAccess } from "../typings/DatabaseAccess";
+import { ColumnInfo } from "../typings/ColumnInfo";
+export default class MySqlDialect extends DefaultSql {
+    canAlterForeignKeys: boolean;
+    canAlterPrimaryKey: boolean;
+    canInspectForeignKeys: boolean;
+    canInspectPrimaryKey: boolean;
+    changeForeignKeysState(enabled: boolean): string;
+    getForeignKeys(tableName: string, db: DatabaseAccess): Promise<ForeignKeyInfo[]>;
+    addForeignKey(fromTableName: string, foreignKey: string): string;
+    removeForeignKey(tableName: string, foreignKeyName: string): string;
+    addPrimaryKey(tableName: string, columnName: string): string;
+    removePrimaryKey(tableName: string, _columnName: string): string;
+    getTableNames(db: DatabaseAccess): Promise<string[]>;
+    getColumnInformation(tableName: string, db: DatabaseAccess): Promise<ColumnInfo[]>;
+}

package/dist/lib/dialects/MySqlDialect.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultSql_1 = __importDefault(require("./DefaultSql"));
+class MySqlDialect extends DefaultSql_1.default {
+    canAlterForeignKeys = true;
+    canAlterPrimaryKey = true;
+    canInspectForeignKeys = true;
+    canInspectPrimaryKey = true;
+    changeForeignKeysState(enabled) {
+        return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"}\n;`;
+    }
+    async getForeignKeys(tableName, db) {
+        const data = await db.runGetStatement(`SELECT TABLE_NAME,COLUMN_NAME,CONSTRAINT_NAME, REFERENCED_TABLE_NAME,REFERENCED_COLUMN_NAME FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE WHERE REFERENCED_TABLE_SCHEMA = (SELECT DATABASE()) AND REFERENCED_TABLE_NAME = '${tableName}';`);
+        return data.map(entry => {
+            return {
+                fromTable: tableName,
+                fromColumn: entry["COLUMN_NAME"],
+                toTable: entry["REFERENCED_TABLE_NAME"],
+                toColumn: entry["REFERENCED_COLUMN_NAME"]
+            };
+        });
+    }
+    addForeignKey(fromTableName, foreignKey) {
+        return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
+    }
+    removeForeignKey(tableName, foreignKeyName) {
+        return `ALTER TABLE ${tableName} DROP FOREIGN KEY ${foreignKeyName};`;
+    }
+    addPrimaryKey(tableName, columnName) {
+        return `ALTER TABLE ${tableName} PRIMARY KEY (${columnName});`;
+    }
+    removePrimaryKey(tableName, _columnName) {
+        return `ALTER TABLE ${tableName} PRIMARY KEY;`;
+    }
+    async getTableNames(db) {
+        return await db.runGetStatement("SHOW TABLES;");
+    }
+    async getColumnInformation(tableName, db) {
+        const data = await db.runGetStatement(`SHOW COLUMNS FROM ${tableName};`);
+        return data.map(entry => {
+            return {
+                name: entry["Field"],
+                type: entry["Type"],
+                defaultValue: entry["Default"],
+                isPrimaryKey: entry["Key"] == "PRI",
+            };
+        });
+    }
+}
+exports.default = MySqlDialect;

package/dist/lib/dialects/PostgresDialect.d.ts

@@ -0,0 +1,16 @@
+import DefaultSql from "./DefaultSql";
+import { DatabaseAccess } from "../typings/DatabaseAccess";
+import { ColumnInfo } from "../typings/ColumnInfo";
+export default class PostgresDialect extends DefaultSql {
+    canAlterForeignKeys: boolean;
+    canAlterPrimaryKey: boolean;
+    canInspectForeignKeys: boolean;
+    canInspectPrimaryKey: boolean;
+    changeForeignKeysState(enabled: boolean): string;
+    addForeignKey(fromTableName: string, foreignKey: string): string;
+    removeForeignKey(tableName: string, foreignKeyName: string): string;
+    getTableNames(db: DatabaseAccess): Promise<string[]>;
+    getColumnInformation(tableName: string, db: DatabaseAccess): Promise<ColumnInfo[]>;
+    addPrimaryKey(tableName: string, columnName: string): string;
+    removePrimaryKey(tableName: string, columnName: string): string;
+}

package/dist/lib/dialects/PostgresDialect.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultSql_1 = __importDefault(require("./DefaultSql"));
+class PostgresDialect extends DefaultSql_1.default {
+    canAlterForeignKeys = true;
+    canAlterPrimaryKey = true;
+    canInspectForeignKeys = false;
+    canInspectPrimaryKey = false;
+    changeForeignKeysState(enabled) {
+        return `SET session_replication_role = '${enabled ? "replica" : "origin"}';`;
+    }
+    addForeignKey(fromTableName, foreignKey) {
+        return `ALTER TABLE ${fromTableName} ADD CONSTRAINT ${fromTableName} ${foreignKey};`;
+    }
+    removeForeignKey(tableName, foreignKeyName) {
+        return `ALTER TABLE ${tableName} DROP CONSTRAINT ${foreignKeyName};`;
+    }
+    async getTableNames(db) {
+        return await db.runGetStatement("SELECT table_name FROM information_schema.tables WHERE table_schema='public' AND table_type='BASE TABLE';");
+    }
+    async getColumnInformation(tableName, db) {
+        const data = await db.runGetStatement(`SELECT column_name, data_type, column_default FROM information_schema.columns WHERE table_schema = 'public' AND table_name = '${tableName}';`);
+        return data.map(entry => {
+            return {
+                name: entry["column_name"],
+                type: entry["data_type"],
+                defaultValue: entry["column_default"],
+                isPrimaryKey: false,
+            };
+        });
+    }
+    addPrimaryKey(tableName, columnName) {
+        return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});\n`;
+    }
+    removePrimaryKey(tableName, columnName) {
+        return `ALTER TABLE ${tableName} DROP CONSTRAINT ${columnName};\n`;
+    }
+}
+exports.default = PostgresDialect;

package/dist/lib/dialects/SqliteDialect.d.ts

@@ -0,0 +1,16 @@
+import DefaultSql from "./DefaultSql";
+import { ForeignKeyInfo } from "../typings/ForeignKeyInfo";
+import { DatabaseAccess } from "../typings/DatabaseAccess";
+import { ColumnInfo } from "../typings/ColumnInfo";
+export default class SqliteDialect extends DefaultSql {
+    typeBoolean: string;
+    canAlterForeignKeys: boolean;
+    canAlterPrimaryKey: boolean;
+    canInspectForeignKeys: boolean;
+    canInspectPrimaryKey: boolean;
+    changeForeignKeysState(enabled: boolean): string;
+    getForeignKeys(tableName: string, db: DatabaseAccess): Promise<ForeignKeyInfo[]>;
+    getTableNames(db: DatabaseAccess): Promise<string[]>;
+    getColumnInformation(tableName: string, db: DatabaseAccess): Promise<ColumnInfo[]>;
+    formatValueToSql(value: string | number | boolean): string;
+}

package/dist/lib/dialects/SqliteDialect.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const DefaultSql_1 = __importDefault(require("./DefaultSql"));
+class SqliteDialect extends DefaultSql_1.default {
+    typeBoolean = "INTEGER";
+    canAlterForeignKeys = false;
+    canAlterPrimaryKey = false;
+    canInspectForeignKeys = true;
+    canInspectPrimaryKey = true;
+    changeForeignKeysState(enabled) {
+        return `PRAGMA foreign_keys = ${enabled ? "ON" : "OFF"};`;
+    }
+    async getForeignKeys(tableName, db) {
+        const data = await db.runGetStatement(`PRAGMA foreign_key_list(${tableName});`);
+        return data.map(entry => {
+            return {
+                fromTable: tableName,
+                fromColumn: entry["from"],
+                toTable: entry["table"],
+                toColumn: entry["to"],
+                on_update: entry["on_update"],
+                on_delete: entry["on_delete"],
+            };
+        });
+    }
+    async getTableNames(db) {
+        return (await db.runGetStatement("SELECT name FROM sqlite_master WHERE type = 'table'"))
+            .map((obj) => obj.name);
+    }
+    async getColumnInformation(tableName, db) {
+        const data = await db.runGetStatement(`PRAGMA table_info(${tableName})`);
+        return data.map(entry => {
+            return {
+                name: entry["name"],
+                type: entry["type"],
+                defaultValue: entry["dflt_value"],
+                isPrimaryKey: entry["pk"] == "1",
+            };
+        });
+    }
+    formatValueToSql(value) {
+        switch (typeof value) {
+            case "boolean":
+                return value ? "1" : "0";
+            default:
+                return value.toString();
+        }
+    }
+}
+exports.default = SqliteDialect;

package/dist/lib/exceptions/NotAllowedException.d.ts

@@ -0,0 +1,4 @@
+import AllowedMigrations from "../typings/AllowedMigrations";
+export default class NotAllowedException extends Error {
+    constructor(version: number, tableName: string, type: keyof AllowedMigrations);
+}

package/dist/lib/exceptions/NotAllowedException.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class NotAllowedException extends Error {
+    constructor(version, tableName, type) {
+        const information = `You have to enable "${type}" for version "${version}" and table "${tableName}"`;
+        switch (type) {
+            case "continueWithoutRollback":
+                super(`Some changes can not be rolled back automatically. ${information}`);
+                break;
+            case "dropColumn":
+                super(`Not allowed to drop column. ${information}`);
+                break;
+            case "dropTable":
+                super(`Not allowed to drop table. ${information}`);
+                break;
+            case "recreateTable":
+                super(`Not allowed to recreate table. ${information}`);
+                break;
+            case "alterForeignKey":
+                super(`Not allowed to alter existing foreign key. ${information}`);
+                break;
+            case "alterPrimaryKey":
+                super(`Not allowed to alter primary key. ${information}`);
+                break;
+            case "removeForeignKey":
+                super(`Not allowed to remove existing foreign key. ${information}`);
+                break;
+        }
+    }
+}
+exports.default = NotAllowedException;

package/dist/lib/tableInfo/TableInfo.d.ts

@@ -0,0 +1,9 @@
+import { ForeignKeyInfo } from "../typings/ForeignKeyInfo";
+import { BackendTable, Class } from "../typings/BackendTable";
+export declare const TABLE_INFO_PROPERTY_NAME: unique symbol;
+export default interface TableInfo {
+    primaryKey?: string;
+    foreignKeys?: ForeignKeyInfo[];
+}
+export declare function getTableInfo<T extends BackendTable>(table: Class<T>): TableInfo;
+export declare function getTableInfoFromMetadata(metadata: Record<PropertyKey, unknown>): TableInfo;

package/dist/lib/tableInfo/TableInfo.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TABLE_INFO_PROPERTY_NAME = void 0;
+exports.getTableInfo = getTableInfo;
+exports.getTableInfoFromMetadata = getTableInfoFromMetadata;
+exports.TABLE_INFO_PROPERTY_NAME = Symbol("tableInfo");
+function getTableInfo(table) {
+    if (!table.hasOwnProperty(Symbol.metadata))
+        table[Symbol.metadata] = {};
+    return getTableInfoFromMetadata(table[Symbol.metadata]);
+}
+function getTableInfoFromMetadata(metadata) {
+    if (!metadata[exports.TABLE_INFO_PROPERTY_NAME])
+        metadata[exports.TABLE_INFO_PROPERTY_NAME] = { primaryKey: "", foreignKeys: [] };
+    return metadata[exports.TABLE_INFO_PROPERTY_NAME];
+}

package/dist/lib/tableInfo/TableObjects.d.ts

@@ -0,0 +1,6 @@
+import { BackendTable } from "../typings/BackendTable";
+import TableInfo from "./TableInfo";
+export type TableObjects = Record<string, {
+    columns: BackendTable;
+    tableInfo?: TableInfo;
+}>;

package/dist/lib/tableInfo/TableObjects.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/tableInfo/decorators/DbTable.d.ts

@@ -0,0 +1,2 @@
+import { BackendTable, Class } from "../../typings/BackendTable";
+export default function DbTable<T extends BackendTable>(tableName: string, primaryKey?: keyof T): (table: Class<T>, context: any) => void;

package/dist/lib/tableInfo/decorators/DbTable.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = DbTable;
+const TableInfo_1 = require("../TableInfo");
+function DbTable(tableName, primaryKey) {
+    return (table, context) => {
+        Object.defineProperty(table, "name", { value: tableName, writable: false });
+        const tableInfo = (0, TableInfo_1.getTableInfoFromMetadata)(context.metadata);
+        tableInfo.primaryKey = primaryKey?.toString();
+        if (tableInfo.foreignKeys) {
+            for (const foreignKey of tableInfo.foreignKeys) {
+                foreignKey.fromTable = tableName;
+            }
+        }
+    };
+}

package/dist/lib/tableInfo/decorators/ForeignKey.d.ts

@@ -0,0 +1,4 @@
+import { BackendTable, Class } from "../../typings/BackendTable";
+import "polyfill-symbol-metadata";
+import { ForeignKeyActions } from "../../typings/ForeignKeyInfo";
+export default function ForeignKey<TOther extends BackendTable>(toTable: Class<TOther>, toColumn: keyof TOther, onDelete?: ForeignKeyActions, onUpdate?: ForeignKeyActions): (_: undefined, context: any) => void;

package/dist/lib/tableInfo/decorators/ForeignKey.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = ForeignKey;
+const TableInfo_1 = require("../TableInfo");
+require("polyfill-symbol-metadata");
+function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
+    return (_, context) => {
+        const metadata = (0, TableInfo_1.getTableInfoFromMetadata)(context.metadata);
+        if (!metadata.foreignKeys)
+            metadata.foreignKeys = [];
+        metadata.foreignKeys.push({
+            fromTable: "",
+            fromColumn: context.name,
+            toTable: toTable.name,
+            toColumn: toColumn.toString(),
+            onDelete: onDelete,
+            onUpdate: onUpdate,
+        });
+    };
+}

package/dist/lib/typings/AllowedMigrations.d.ts

@@ -0,0 +1,9 @@
+export default interface AllowedMigrations {
+    recreateTable?: boolean;
+    dropTable?: boolean;
+    dropColumn?: boolean;
+    alterPrimaryKey?: boolean;
+    removeForeignKey?: boolean;
+    alterForeignKey?: boolean;
+    continueWithoutRollback?: boolean;
+}

package/dist/lib/typings/AllowedMigrations.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/BackendTable.d.ts

@@ -0,0 +1,7 @@
+export type Class<T> = new (...args: never[]) => T;
+/**
+ * This does nothing. It mainly exists in case we want to filter class types in the future
+ */
+export type BackendTable = {
+    [key: string]: any;
+};

package/dist/lib/typings/BackendTable.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/ColumnInfo.d.ts

@@ -0,0 +1,6 @@
+export interface ColumnInfo {
+    name: string;
+    type: string;
+    defaultValue: string;
+    isPrimaryKey: boolean;
+}

package/dist/lib/typings/ColumnInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/DatabaseAccess.d.ts

@@ -0,0 +1,5 @@
+export interface DatabaseAccess {
+    createBackup?(name: string): Promise<void>;
+    runGetStatement(query: string): Promise<unknown>;
+    runMultipleWriteStatements(query: string): Promise<void>;
+}

package/dist/lib/typings/DatabaseAccess.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/DatabaseInstructions.d.ts

@@ -0,0 +1,26 @@
+import { BackendTable, Class } from "./BackendTable";
+import { PublicMigrations } from "./Migrations";
+import { SqlChanges } from "./SqlChanges";
+import { TableObjects } from "../tableInfo/TableObjects";
+export default interface DatabaseInstructions {
+    dialect: "Sqlite" | "MsSql" | "MySql" | "Postgres";
+    tables: Class<BackendTable>[] | TableObjects;
+    version: number;
+    configPath: string;
+    loggerMode?: "silent" | "noLog" | "normal" | "debug";
+    /**
+     * Custom migrations that will run before any database changes are applied.
+     * @param migrations The migration object that will be validated after this.
+     * @param fromVersion Version of the current database.
+     * @param toVersion Version of the database after update.
+     * @return custom SQL that should be executed before migrations are executed.
+     */
+    preMigration?(migrations: PublicMigrations, fromVersion: number, toVersion: number): SqlChanges | void;
+    /**
+     * Custom migrations that will run after database changes have been applied (but before the transaction is finished)
+     * @param fromVersion Version of the current database.
+     * @param toVersion Version of the database after update.
+     * @return custom SQL that should be executed before migrations are executed.
+     */
+    postMigration?(fromVersion: number, toVersion: number): SqlChanges;
+}

package/dist/lib/typings/DatabaseInstructions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/ForeignKeyInfo.d.ts

@@ -0,0 +1,9 @@
+export type ForeignKeyActions = "SET NULL" | "SET DEFAULT" | "RESTRICT" | "NO ACTION" | "CASCADE";
+export interface ForeignKeyInfo {
+    fromTable: string;
+    fromColumn: string;
+    toTable: string;
+    toColumn: string;
+    onUpdate?: ForeignKeyActions;
+    onDelete?: ForeignKeyActions;
+}

package/dist/lib/typings/ForeignKeyInfo.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/MigrationHistory.d.ts

@@ -0,0 +1,7 @@
+export default class MigrationHistory {
+    fromVersion: number;
+    toVersion: number;
+    upSql: string;
+    downSql: string;
+    constructor(fromVersion: number, toVersion: number, upSql: string, downSql: string);
+}

package/dist/lib/typings/MigrationHistory.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class MigrationHistory {
+    fromVersion = 0;
+    toVersion = 1;
+    upSql = "";
+    downSql = "";
+    constructor(fromVersion, toVersion, upSql, downSql) {
+        this.fromVersion = fromVersion;
+        this.toVersion = toVersion;
+        this.upSql = upSql;
+        this.downSql = downSql;
+    }
+}
+exports.default = MigrationHistory;

package/dist/lib/typings/MigrationInstructions.d.ts

@@ -0,0 +1,10 @@
+import AllowedMigrations from "./AllowedMigrations";
+export default interface MigrationInstructions {
+    oldTableName?: string;
+    recreate: boolean;
+    /**
+     * Stores changes to column (0: name in the database, last: current name in code)
+     */
+    renamedColumns: string[][];
+    allowedMigrations: Record<number, AllowedMigrations>;
+}

package/dist/lib/typings/MigrationInstructions.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/lib/typings/Migrations.d.ts

@@ -0,0 +1,20 @@
+import { Class, BackendTable } from "./BackendTable";
+import AllowedMigrations from "./AllowedMigrations";
+import MigrationInstructions from "./MigrationInstructions";
+export declare class Migrations {
+    private readonly migrationData;
+    private alwaysAllowed;
+    private getEntry;
+    private getTableName;
+    alwaysAllow(...allowedMigrations: (keyof AllowedMigrations)[]): void;
+    allowMigration(version: number, table: string | Class<BackendTable>, ...allowedMigrations: (keyof AllowedMigrations)[]): void;
+    throwIfNotAllowed(version: number, tableName: string, type: keyof AllowedMigrations): void;
+    renameTable(oldTableName: string, newTable: string | Class<BackendTable>): void;
+    renameColumn(table: string | Class<BackendTable>, oldColumn: string, newColumn: string): void;
+    recreateTable(table: Class<BackendTable> | string): void;
+    getMigrationData(): Record<string, MigrationInstructions>;
+    loopRenamedColumns(tableName: string, callback: (oldColumnName: string, newColumnName: string) => void): void;
+    getUpdatedColumnName(tableName: string, oldColumnName: string): string;
+    willBeRecreated(tableName: string): boolean;
+}
+export type PublicMigrations = Pick<Migrations, "recreateTable" | "renameTable" | "renameColumn" | "allowMigration" | "alwaysAllow">;

package/dist/lib/typings/Migrations.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Migrations = void 0;
+const NotAllowedException_1 = __importDefault(require("../exceptions/NotAllowedException"));
+class Migrations {
+    migrationData = {};
+    alwaysAllowed = {};
+    getEntry(table) {
+        const tableName = this.getTableName(table);
+        if (!this.migrationData.hasOwnProperty(tableName)) {
+            this.migrationData[tableName] = {
+                recreate: false,
+                renamedColumns: [],
+                allowedMigrations: {}
+            };
+        }
+        return this.migrationData[tableName];
+    }
+    getTableName(table) {
+        return typeof table == "string" ? table : table.name;
+    }
+    alwaysAllow(...allowedMigrations) {
+        for (const key of allowedMigrations) {
+            this.alwaysAllowed[key] = true;
+        }
+    }
+    allowMigration(version, table, ...allowedMigrations) {
+        const entry = this.getEntry(table);
+        if (!entry.allowedMigrations.hasOwnProperty(version))
+            entry.allowedMigrations[version] = {};
+        for (const key of allowedMigrations) {
+            this.alwaysAllowed[key] = true;
+        }
+    }
+    throwIfNotAllowed(version, tableName, type) {
+        if (!(this.migrationData[tableName]?.allowedMigrations[version] ?? this.alwaysAllowed)[type])
+            throw new NotAllowedException_1.default(version, tableName, type);
+    }
+    renameTable(oldTableName, newTable) {
+        const entry = this.getEntry(newTable);
+        entry.recreate = true;
+        if (!entry.oldTableName) //entry might have already existed
+            entry.oldTableName = oldTableName;
+    }
+    renameColumn(table, oldColumn, newColumn) {
+        const entry = this.getEntry(table);
+        const existingColumnEntry = entry.renamedColumns.find((entry) => entry[entry.length - 1] == oldColumn);
+        if (existingColumnEntry)
+            existingColumnEntry.push(newColumn);
+        else
+            entry.renamedColumns.push([oldColumn, newColumn]);
+    }
+    recreateTable(table) {
+        const entry = this.getEntry(table);
+        entry.recreate = true;
+    }
+    getMigrationData() {
+        return this.migrationData;
+    }
+    loopRenamedColumns(tableName, callback) {
+        const migrationEntry = this.migrationData[tableName];
+        //We have to assume that there were multiple version changes in which the column name was changed multiple times.
+        //So we only rename from the original name (index 0) to the newest (last index)
+        for (const renamingArray of migrationEntry.renamedColumns) {
+            if (renamingArray.length <= 1)
+                continue;
+            const oldColumnName = renamingArray[0];
+            const newColumnName = renamingArray[renamingArray.length - 1];
+            callback(oldColumnName, newColumnName);
+        }
+    }
+    getUpdatedColumnName(tableName, oldColumnName) {
+        const columnNames = this.migrationData[tableName].renamedColumns.find((columns) => columns[0] == oldColumnName);
+        return columnNames ? columnNames[columnNames.length - 1] : oldColumnName;
+    }
+    willBeRecreated(tableName) {
+        return this.migrationData[tableName]?.recreate;
+    }
+}
+exports.Migrations = Migrations;