sqlmorpheus 0.1.2 → 0.1.3

package/dist/index.mjs

@@ -218,7 +218,7 @@ var MigrationHistoryManager = class {
   lastVersion = 0;
   constructor(configPath) {
     this.configPath = configPath;
-    this.migrationsPath = `${configPath}/migrations/`;
+    this.migrationsPath = `${configPath}/migrations`;
     mkdirSync(this.configPath, { recursive: true });
     mkdirSync(this.migrationsPath, { recursive: true });
   }
@@ -240,6 +240,7 @@ var MigrationHistoryManager = class {
       throw new Error(`Migration ${upPath} already exists!`);
     else if (existsSync(downPath) && !overwriteExisting)
       throw new Error(`Migration ${downPath} already exists!`);
+    Logger.log(`Save migrations to ${this.migrationsPath}`);
     writeFileSync(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, `-- From: Version ${fromVersion}
 -- To:   Version ${toVersion}
 ${changes.up}`, { encoding: "utf-8" });
@@ -840,6 +841,7 @@ ${foreignKeyOnQuery}`;
 };
 
 // src/lib/tableInfo/decorators/DbTable.ts
+import "polyfill-symbol-metadata";
 function DbTable(tableName, primaryKey) {
   return (table, context) => {
     Object.defineProperty(table, "name", { value: tableName, writable: false });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlmorpheus",
-  "version": "0.1.2",
+  "version": "0.1.3",
   "author": "JodliDev",
   "keywords": [],
   "license": "MIT",
@@ -23,7 +23,7 @@
     "dev": "tsup --watch",
     "test": "vitest run",
     "test:watch": "vitest",
-    "publish": "tsc && npm publish"
+    "publish": "npm publish"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",

package/dist/lib/Logger.d.ts

@@ -1,10 +0,0 @@
-export type LoggerMode = "silent" | "noLog" | "normal" | "debug";
-declare class LoggerClass {
-    mode: LoggerMode;
-    setMode(mode?: LoggerMode): void;
-    debug(text: string): void;
-    log(text: string): void;
-    warn(text: string): void;
-}
-export declare const Logger: LoggerClass;
-export {};

package/dist/lib/Logger.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logger = void 0;
-class LoggerClass {
-    mode = "normal";
-    setMode(mode) {
-        this.mode = mode ?? "normal";
-    }
-    debug(text) {
-        if (this.mode == "debug")
-            console.log(text);
-    }
-    log(text) {
-        if (this.mode == "silent" || this.mode == "noLog")
-            return;
-        console.log(text);
-    }
-    warn(text) {
-        if (this.mode == "silent")
-            return;
-        console.warn(text);
-    }
-}
-exports.Logger = new LoggerClass();

package/dist/lib/MigrationHistoryManager.d.ts

@@ -1,12 +0,0 @@
-import { SqlChanges } from "./typings/SqlChanges";
-export default class MigrationHistoryManager {
-    private readonly configPath;
-    private readonly migrationsPath;
-    private lastVersion;
-    constructor(configPath: string);
-    getLastHistoryVersion(): number;
-    setLastHistoryVersion(version: number): void;
-    createMigrationHistory(toVersion: number, changes: SqlChanges, overwriteExisting?: boolean): void;
-    getUpMigration(toVersion?: number): string;
-    getDownMigration(version: number): string;
-}

package/dist/lib/MigrationHistoryManager.js

@@ -1,47 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_fs_1 = require("node:fs");
-const fs_1 = require("fs");
-const FILENAME_UP_PREFIX = "up_to_";
-const FILENAME_DOWN_PREFIX = "down_to_";
-class MigrationHistoryManager {
-    configPath;
-    migrationsPath;
-    lastVersion = 0;
-    constructor(configPath) {
-        this.configPath = configPath;
-        this.migrationsPath = `${configPath}/migrations/`;
-        (0, node_fs_1.mkdirSync)(this.configPath, { recursive: true });
-        (0, node_fs_1.mkdirSync)(this.migrationsPath, { recursive: true });
-    }
-    getLastHistoryVersion() {
-        if (this.lastVersion)
-            return this.lastVersion;
-        const path = `${this.configPath}/last_version.txt`;
-        this.lastVersion = (0, node_fs_1.existsSync)(path)
-            ? parseInt((0, fs_1.readFileSync)(`${this.configPath}/last_version.txt`, { encoding: 'utf-8' })) ?? 0
-            : 0;
-        return this.lastVersion;
-    }
-    setLastHistoryVersion(version) {
-        (0, node_fs_1.writeFileSync)(`${this.configPath}/last_version.txt`, version.toString(), { encoding: 'utf-8' });
-    }
-    createMigrationHistory(toVersion, changes, overwriteExisting) {
-        const fromVersion = this.getLastHistoryVersion();
-        const upPath = `${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`;
-        const downPath = `${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${fromVersion}.sql`;
-        if ((0, node_fs_1.existsSync)(upPath) && !overwriteExisting)
-            throw new Error(`Migration ${upPath} already exists!`);
-        else if ((0, node_fs_1.existsSync)(downPath) && !overwriteExisting)
-            throw new Error(`Migration ${downPath} already exists!`);
-        (0, node_fs_1.writeFileSync)(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion}.sql`, `-- From: Version ${fromVersion}\n-- To:   Version ${toVersion}\n${changes.up}`, { encoding: 'utf-8' });
-        (0, node_fs_1.writeFileSync)(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${fromVersion}.sql`, `-- From: Version ${toVersion}\n-- To:   Version ${fromVersion}\n${changes.down}`, { encoding: 'utf-8' });
-    }
-    getUpMigration(toVersion) {
-        return (0, fs_1.readFileSync)(`${this.migrationsPath}/${FILENAME_UP_PREFIX}${toVersion ?? this.getLastHistoryVersion()}.sql`, { encoding: 'utf-8' });
-    }
-    getDownMigration(version) {
-        return (0, fs_1.readFileSync)(`${this.migrationsPath}/${FILENAME_DOWN_PREFIX}${version}.sql`, { encoding: 'utf-8' });
-    }
-}
-exports.default = MigrationHistoryManager;

package/dist/lib/MigrationManager.d.ts

@@ -1,27 +0,0 @@
-import DatabaseInstructions from "./typings/DatabaseInstructions";
-import { DatabaseAccess } from "./typings/DatabaseAccess";
-import { SqlChanges } from "./typings/SqlChanges";
-export declare class MigrationManager {
-    private migrations;
-    private readonly tableStructureGenerator;
-    private existingTables;
-    private readonly db;
-    private readonly dbInstructions;
-    private readonly migrationHistoryManager;
-    private readonly dialect;
-    constructor(db: DatabaseAccess, dbInstructions: DatabaseInstructions);
-    getMigrateSql(): Promise<SqlChanges | null>;
-    prepareMigration(overwriteExisting?: boolean): Promise<void>;
-    private createAndDropTables;
-    private createTableSql;
-    private tableDoesNotExists;
-    private recreateTables;
-    private migrateForeignKeys;
-    /**
-     * Checks all columns of all tables, creates them if they do not exist in the database and modifies them if needed.
-     * If types, default values or primary key change, the table is recreated
-     */
-    private migrateColumns;
-    private getPrimaryKeyColumn;
-    private renameColumns;
-}

package/dist/lib/MigrationManager.js

@@ -1,331 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MigrationManager = void 0;
-const TableStructureGenerator_1 = __importDefault(require("./TableStructureGenerator"));
-const Migrations_1 = require("./typings/Migrations");
-const MigrationHistoryManager_1 = __importDefault(require("./MigrationHistoryManager"));
-const SqliteDialect_1 = __importDefault(require("./dialects/SqliteDialect"));
-const PostgresDialect_1 = __importDefault(require("./dialects/PostgresDialect"));
-const MsSqlDialect_1 = __importDefault(require("./dialects/MsSqlDialect"));
-const MySqlDialect_1 = __importDefault(require("./dialects/MySqlDialect"));
-const Logger_1 = require("./Logger");
-class MigrationManager {
-    migrations = new Migrations_1.Migrations();
-    tableStructureGenerator;
-    existingTables = [];
-    db;
-    dbInstructions;
-    migrationHistoryManager;
-    dialect;
-    constructor(db, dbInstructions) {
-        switch (dbInstructions.dialect) {
-            case "Sqlite":
-                this.dialect = new SqliteDialect_1.default();
-                break;
-            case "Postgres":
-                this.dialect = new PostgresDialect_1.default();
-                break;
-            case "MsSql":
-                this.dialect = new MsSqlDialect_1.default();
-                break;
-            case "MySql":
-                this.dialect = new MySqlDialect_1.default();
-                break;
-            default:
-                throw new Error(`Unknown dialect ${dbInstructions.dialect}`);
-        }
-        this.db = db;
-        this.dbInstructions = dbInstructions;
-        this.tableStructureGenerator = new TableStructureGenerator_1.default(dbInstructions, this.dialect);
-        this.migrationHistoryManager = new MigrationHistoryManager_1.default(this.dbInstructions.configPath);
-    }
-    async getMigrateSql() {
-        if (this.dbInstructions.version <= 0)
-            throw new Error("Cannot migrate to version 0 or lower");
-        const fromVersion = this.migrationHistoryManager.getLastHistoryVersion();
-        if (fromVersion == 0) {
-            Logger_1.Logger.log(`Creating initial migration to version ${this.dbInstructions.version}`);
-            return this.createAndDropTables();
-        }
-        if (fromVersion == this.dbInstructions.version) {
-            Logger_1.Logger.log("Version has not changed. No migrations needed.");
-            return null;
-        }
-        if (fromVersion > this.dbInstructions.version)
-            throw new Error(`You cannot create new migrations with a lower version (from ${fromVersion} to ${this.dbInstructions.version})`);
-        Logger_1.Logger.log(`Creating migration SQL from version ${fromVersion} to ${this.dbInstructions.version}`);
-        const db = this.db;
-        await db.createBackup?.(`from_${fromVersion}_to_${this.dbInstructions.version}`);
-        this.existingTables = await this.dialect.getTableNames(this.db);
-        const foreignKeyOffQuery = this.dialect.changeForeignKeysState(false);
-        const changes = {
-            up: foreignKeyOffQuery,
-            down: foreignKeyOffQuery
-        };
-        //Run pre-migrations:
-        const preSQL = this.dbInstructions.preMigration?.(this.migrations, fromVersion, this.dbInstructions.version);
-        if (preSQL) {
-            changes.up += `\n\n-- Custom SQL from preMigration()\n${preSQL.up}`;
-            changes.down += `\n\n-- Custom SQL from preMigration()\n${preSQL.down}`;
-        }
-        [
-            await this.createAndDropTables(),
-            await this.migrateForeignKeys(),
-            await this.migrateColumns(),
-            this.renameColumns(),
-            await this.recreateTables()
-        ].forEach(entry => {
-            changes.up += entry.up;
-            changes.down += entry.down;
-        });
-        //Run post-migrations:
-        const postSql = this.dbInstructions.postMigration?.(fromVersion, this.dbInstructions.version);
-        if (postSql) {
-            changes.up += `\n\n-- Custom SQL from postMigration()\n${postSql.up}`;
-            changes.down += `\n\n-- Custom SQL from postMigration()\n${postSql.down}`;
-        }
-        //Enable foreign key constraints again:
-        const foreignKeyOnQuery = this.dialect.changeForeignKeysState(true);
-        changes.up += `\n\n${foreignKeyOnQuery}`;
-        changes.down += `\n\n${foreignKeyOnQuery}`;
-        return changes;
-    }
-    async prepareMigration(overwriteExisting) {
-        const changes = await this.getMigrateSql();
-        if (!changes)
-            return;
-        this.migrationHistoryManager.createMigrationHistory(this.dbInstructions.version, changes, overwriteExisting);
-    }
-    async createAndDropTables() {
-        let changes = {
-            up: "\n\n-- Create tables\n",
-            down: "\n\n-- Create tables\n"
-        };
-        for (const tableName in this.tableStructureGenerator.tables) {
-            if (this.tableDoesNotExists(tableName)) {
-                const structure = this.tableStructureGenerator.tables[tableName];
-                changes.up += `${this.createTableSql(tableName, structure.columns, structure.foreignKeys)}\n`;
-                changes.down += `${this.dialect.dropTable(tableName)}\n`;
-            }
-        }
-        for (const tableName of this.existingTables) {
-            if (!this.tableStructureGenerator.tables[tableName]) {
-                this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "dropTable");
-                if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-                    this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "continueWithoutRollback");
-                changes.up += `${this.dialect.dropTable(tableName)}\n`;
-                changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey
-                    ? this.createTableSql(tableName, await this.dialect.getColumnInformation(tableName, this.db), await this.dialect.getForeignKeys(tableName, this.db))
-                    : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
-            }
-        }
-        return changes;
-    }
-    createTableSql(tableName, columns, foreignKeys) {
-        //columns:
-        const queryLines = [];
-        for (const columnInfo of columns) {
-            queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.defaultValue, columnInfo.isPrimaryKey));
-        }
-        //foreign keys:
-        if (foreignKeys) {
-            for (const foreignKeyInfo of foreignKeys) {
-                queryLines.push(this.dialect.foreignKey(foreignKeyInfo.fromColumn, foreignKeyInfo.toTable, foreignKeyInfo.toColumn.toString(), foreignKeyInfo.onUpdate, foreignKeyInfo.onDelete));
-            }
-        }
-        return this.dialect.createTable(tableName, queryLines);
-    }
-    tableDoesNotExists(tableName) {
-        return this.existingTables.indexOf(tableName) == -1;
-    }
-    async recreateTables() {
-        const changes = {
-            up: "\n\n-- Recreate tables\n",
-            down: "\n\n-- Recreate tables\n"
-        };
-        const migrationData = this.migrations.getMigrationData();
-        for (const tableName in migrationData) {
-            const migrationEntry = migrationData[tableName];
-            if (!migrationEntry.recreate)
-                continue;
-            this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "recreateTable");
-            if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
-                this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "continueWithoutRollback");
-            const oldColumnList = await this.dialect.getColumnInformation(tableName, this.db);
-            const newColumnList = this.tableStructureGenerator.tables[tableName].columns;
-            const moveableColumns = newColumnList
-                .filter(entry => oldColumnList.find(oldEntry => oldEntry.name == entry.name) != undefined)
-                .map(entry => entry.name);
-            const backupTableName = `${tableName}__backup`;
-            const insertQuery = this.dialect.insert(backupTableName, this.dialect.insertValues(moveableColumns, this.dialect.select(tableName, moveableColumns)));
-            const moveDataQuery = insertQuery
-                + "\n"
-                + this.dialect.dropTable(tableName)
-                + "\n"
-                + this.dialect.renameTable(backupTableName, tableName);
-            const structure = this.tableStructureGenerator.tables[tableName];
-            changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys)
-                + "\n"
-                + moveDataQuery;
-            changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey
-                ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(tableName, this.db), await this.dialect.getForeignKeys(tableName, this.db))
-                    + "\n"
-                    + moveDataQuery
-                : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
-        }
-        return changes;
-    }
-    async migrateForeignKeys() {
-        if (!this.dialect.canAlterForeignKeys)
-            return { up: "", down: "" };
-        let changes = {
-            up: "\n\n-- Foreign keys\n",
-            down: "\n\n-- Foreign keys\n"
-        };
-        for (const tableName in this.tableStructureGenerator.tables) {
-            if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
-                continue;
-            const structure = this.tableStructureGenerator.tables[tableName];
-            const newForeignKeys = structure.foreignKeys ?? [];
-            const oldForeignKeys = await this.dialect.getForeignKeys(tableName, this.db);
-            let checkForNewForeignKeys = true;
-            for (const oldForeignKey of oldForeignKeys) {
-                const newForeignKey = newForeignKeys.find(entry => entry.fromColumn == oldForeignKey.fromColumn);
-                //Check for removed foreign key:
-                if (!newForeignKey) {
-                    Logger_1.Logger.log(`Foreign key ${oldForeignKey.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was removed!`);
-                    this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "removeForeignKey");
-                    if (this.dialect.canAlterForeignKeys) {
-                        changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn);
-                        changes.down += this.dialect.addForeignKey(oldForeignKey.fromTable, this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete));
-                    }
-                    else {
-                        this.migrations.recreateTable(structure.table);
-                        checkForNewForeignKeys = false;
-                    }
-                }
-                //Check for altered foreign key:
-                else {
-                    if (!newForeignKey
-                        || oldForeignKey.toColumn != newForeignKey.toColumn
-                        || ((oldForeignKey.onUpdate ?? "NO ACTION") != (newForeignKey.onUpdate ?? "NO ACTION"))
-                        || ((oldForeignKey.onDelete ?? "NO ACTION") != (newForeignKey.onDelete ?? "NO ACTION"))) {
-                        Logger_1.Logger.log(`Foreign key ${oldForeignKey.toTable}.${oldForeignKey.toColumn} to ${oldForeignKey.toTable}.${oldForeignKey.toColumn} was changed!`);
-                        this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "alterForeignKey");
-                        if (this.dialect.canAlterForeignKeys) {
-                            changes.up += this.dialect.removeForeignKey(oldForeignKey.fromTable, oldForeignKey.fromColumn)
-                                + this.dialect.addForeignKey(newForeignKey.fromTable, this.dialect.foreignKey(newForeignKey.fromColumn, newForeignKey.toTable, newForeignKey.toColumn, newForeignKey.onUpdate, newForeignKey.onDelete));
-                            changes.down += this.dialect.addForeignKey(oldForeignKey.fromTable, this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)) + this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
-                        }
-                        else {
-                            this.migrations.recreateTable(structure.table);
-                            checkForNewForeignKeys = false;
-                        }
-                    }
-                }
-            }
-            //Check for new foreign keys:
-            if (checkForNewForeignKeys) {
-                for (const newForeignKey of newForeignKeys) {
-                    const oldForeignKey = oldForeignKeys.find(entry => entry.fromColumn == newForeignKey.fromColumn);
-                    if (oldForeignKey)
-                        continue;
-                    Logger_1.Logger.log(`Foreign key ${newForeignKey.toTable}.${newForeignKey.toColumn} to ${newForeignKey.toTable}.${newForeignKey.toColumn} is new!`);
-                    if (this.dialect.canAlterForeignKeys) {
-                        changes.up += this.dialect.addForeignKey(newForeignKey.toTable, this.dialect.foreignKey(newForeignKey.fromColumn, newForeignKey.toTable, newForeignKey.toColumn, newForeignKey.onUpdate, newForeignKey.onDelete));
-                        changes.down += this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
-                    }
-                    else {
-                        this.migrations.recreateTable(structure.table);
-                        break;
-                    }
-                }
-            }
-        }
-        return changes;
-    }
-    /**
-     * Checks all columns of all tables, creates them if they do not exist in the database and modifies them if needed.
-     * If types, default values or primary key change, the table is recreated
-     */
-    async migrateColumns() {
-        const changes = {
-            up: "\n\n-- Migrate columns\n",
-            down: "\n\n-- Migrate columns\n"
-        };
-        for (const tableName in this.tableStructureGenerator.tables) {
-            if (this.migrations.willBeRecreated(tableName) || this.tableDoesNotExists(tableName))
-                continue;
-            const newTableDefinition = this.tableStructureGenerator.tables[tableName];
-            const oldColumnList = await this.dialect.getColumnInformation(tableName, this.db);
-            const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
-            const newColumnList = newTableDefinition.columns;
-            const newPrimaryKey = newTableDefinition.primaryKey;
-            //Search for changed primary key:
-            if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
-                Logger_1.Logger.log(`Primary key in ${tableName} was changed from ${oldPrimaryKey} to ${newPrimaryKey}!`);
-                this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "alterPrimaryKey");
-                if (this.dialect.canAlterPrimaryKey) {
-                    if (oldPrimaryKey) {
-                        changes.up += this.dialect.removePrimaryKey(tableName, oldPrimaryKey);
-                        changes.down += this.dialect.addPrimaryKey(tableName, oldPrimaryKey);
-                    }
-                    if (newPrimaryKey) {
-                        changes.up += this.dialect.addPrimaryKey(tableName, newPrimaryKey.toString());
-                        changes.down += this.dialect.removePrimaryKey(tableName, newPrimaryKey.toString());
-                    }
-                }
-                else
-                    this.migrations.recreateTable(newTableDefinition.table);
-                continue;
-            }
-            //Search for added or changed columns:
-            for (const newColumn of newColumnList) {
-                const oldColumn = oldColumnList.find(entry => entry.name == newColumn.name);
-                if (oldColumn == undefined) {
-                    changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.defaultValue, newColumn.isPrimaryKey)) + "\n";
-                    changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
-                }
-                else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
-                    this.migrations.recreateTable(newTableDefinition.table);
-                }
-            }
-            //Search for removed columns:
-            for (const oldColumn of oldColumnList) {
-                const newColumn = newColumnList.find(entry => entry.name == oldColumn.name);
-                if (newColumn == undefined) {
-                    this.migrations.throwIfNotAllowed(this.dbInstructions.version, tableName, "dropColumn");
-                    changes.up += this.dialect.dropColumn(tableName, oldColumn.name) + "\n";
-                    changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.defaultValue, oldColumn.isPrimaryKey)) + "\n";
-                }
-            }
-        }
-        return changes;
-    }
-    getPrimaryKeyColumn(columnInfoList) {
-        for (const columnInfo of columnInfoList) {
-            if (columnInfo.isPrimaryKey)
-                return columnInfo.name;
-        }
-    }
-    renameColumns() {
-        const changes = {
-            up: "\n\n-- Rename columns\n",
-            down: "\n\n-- Rename columns\n"
-        };
-        const migrationData = this.migrations.getMigrationData();
-        for (const tableName in migrationData) {
-            if (migrationData[tableName].recreate)
-                continue;
-            this.migrations.loopRenamedColumns(tableName, (oldColumnName, newColumnName) => {
-                changes.up += this.dialect.renameColumn(tableName, oldColumnName, newColumnName);
-                changes.down += this.dialect.renameColumn(tableName, newColumnName, oldColumnName);
-            });
-        }
-        return changes;
-    }
-}
-exports.MigrationManager = MigrationManager;

package/dist/lib/TableStructureGenerator.d.ts

@@ -1,10 +0,0 @@
-import DatabaseInstructions from "./typings/DatabaseInstructions";
-import { TableStructure } from "./typings/TableStructure";
-import DefaultSql from "./dialects/DefaultSql";
-export default class TableStructureGenerator {
-    private readonly dialect;
-    readonly tables: Record<string, TableStructure>;
-    constructor(dbContext: DatabaseInstructions, dialect: DefaultSql);
-    private getExpectedStructure;
-    private getColumns;
-}

package/dist/lib/TableStructureGenerator.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const Logger_1 = require("./Logger");
-const TableInfo_1 = require("./tableInfo/TableInfo");
-class TableStructureGenerator {
-    dialect;
-    tables = {};
-    constructor(dbContext, dialect) {
-        this.dialect = dialect;
-        if (dbContext.tables.length) {
-            const tableObjects = {};
-            for (const table of dbContext.tables) {
-                tableObjects[table.name] = { columns: new table, tableInfo: (0, TableInfo_1.getTableInfo)(table) };
-            }
-            this.getExpectedStructure(tableObjects);
-        }
-        else {
-            const tableObjects = dbContext.tables;
-            this.getExpectedStructure(tableObjects);
-        }
-    }
-    getExpectedStructure(tableObjects) {
-        for (const tableName in tableObjects) {
-            const obj = tableObjects[tableName];
-            const tableInfo = obj.tableInfo;
-            this.tables[tableName] = {
-                table: tableName,
-                primaryKey: tableInfo?.primaryKey,
-                columns: this.getColumns(obj.columns, tableInfo?.primaryKey),
-                foreignKeys: tableInfo?.foreignKeys
-            };
-        }
-    }
-    getColumns(obj, primaryKey) {
-        const columns = [];
-        for (const property in obj) {
-            const propertyKey = property;
-            const value = obj[propertyKey];
-            const columnData = {
-                name: property,
-                isPrimaryKey: property == primaryKey,
-                type: "TEXT",
-                defaultValue: this.dialect.typeNull
-            };
-            switch (typeof value) {
-                case "string":
-                    columnData.type = this.dialect.typeString;
-                    columnData.defaultValue = value === null ? this.dialect.typeNull : `"${this.dialect.formatValueToSql(value)}"`;
-                    break;
-                case "number":
-                    columnData.type = this.dialect.typeNumber;
-                    columnData.defaultValue = value === null ? this.dialect.typeNull : this.dialect.formatValueToSql(value);
-                    break;
-                case "boolean":
-                    columnData.type = this.dialect.typeBoolean;
-                    columnData.defaultValue = value === null ? this.dialect.typeNull : this.dialect.formatValueToSql(value);
-                    break;
-                case "function":
-                    continue;
-                default:
-                    Logger_1.Logger.warn(`${obj.constructor.name}.${property} was skipped because its type is not supported (${typeof value})`);
-                    continue;
-            }
-            columns.push(columnData);
-        }
-        return columns;
-    }
-}
-exports.default = TableStructureGenerator;

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

@@ -1,34 +0,0 @@
-import { ForeignKeyInfo } from "../typings/ForeignKeyInfo";
-import { DatabaseAccess } from "../typings/DatabaseAccess";
-import { ColumnInfo } from "../typings/ColumnInfo";
-export default abstract class DefaultSql {
-    canAlterForeignKeys: boolean;
-    canAlterPrimaryKey: boolean;
-    canInspectForeignKeys: boolean;
-    canInspectPrimaryKey: boolean;
-    typeString: string;
-    typeNumber: string;
-    typeBoolean: string;
-    typeNull: string;
-    formatValueToSql(value: string | number | boolean): string;
-    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;
-    foreignKey(column: string, foreignTable: string, foreignColumn: string, onUpdate?: string, onDelete?: string): string;
-    createTable(tableName: string, entries: string[]): string;
-    renameTable(tableName: string, newTableName: string): string;
-    dropTable(tableName: string): string;
-    abstract getColumnInformation(tableName: string, db: DatabaseAccess): Promise<ColumnInfo[]>;
-    abstract getTableNames(db: DatabaseAccess): Promise<string[]>;
-    columnDefinition(tableName: string, type: string, defaultValue: string, isPrimaryKey: boolean): string;
-    createColumn(columnTable: string, entry: string): string;
-    renameColumn(tableName: string, oldColumnName: string, newColumnName: string): string;
-    copyColumn(tableName: string, oldColumnName: string, newColumnName: string): string;
-    dropColumn(tableName: string, columnName: string): string;
-    select(tableName: string, select: string[], where?: string): string;
-    insert(tableName: string, content: string): string;
-    insertValues(keys: string[], valueString?: string): string;
-}