sqlmorpheus 0.2.1 → 0.2.3

package/dist/index.mjs

@@ -21,42 +21,67 @@ var LoggerClass = class {
 };
 var Logger = new LoggerClass();
 
-// src/lib/tableInfo/TableInfo.ts
-var TABLE_INFO_PROPERTY_NAME = Symbol("tableInfo");
-function getTableInfo(table) {
-  let metadata = table[Symbol.metadata] ?? table.prototype?.[Symbol.metadata];
-  if (!metadata) {
-    metadata = {};
-    table[Symbol.metadata] = metadata;
-  }
-  return getTableInfoFromMetadata(metadata);
-}
-function getTableInfoFromMetadata(metadata) {
-  if (!metadata[TABLE_INFO_PROPERTY_NAME])
-    metadata[TABLE_INFO_PROPERTY_NAME] = { primaryKey: "", foreignKeys: [] };
-  return metadata[TABLE_INFO_PROPERTY_NAME];
-}
-
 // src/lib/tableInfo/TableObj.ts
 var TableObj = class _TableObj {
   IS_TABLE_OBJ = true;
   tableName;
-  columns;
-  tableInfo = {
+  tableStructure = {
+    table: "",
     primaryKey: void 0,
-    foreignKeys: [],
-    dataTypes: {}
+    columns: {},
+    foreignKeys: []
   };
-  constructor(tableName, columns) {
+  static getEmptyColumnEntry(key) {
+    return {
+      name: key,
+      type: "",
+      defaultValue: "",
+      isPrimaryKey: false
+    };
+  }
+  static getColumnEntry(key, value) {
+    let dataType = typeof value;
+    switch (typeof value) {
+      case "function":
+        return null;
+      case "object":
+        if (value instanceof Date) {
+          dataType = "date";
+          break;
+        } else if (value !== null) {
+          Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
+          return null;
+        }
+        dataType = "string";
+        break;
+      case "undefined":
+      case "symbol":
+        Logger.warn(`${key} was skipped because its type (${typeof value}) is not supported`);
+        return null;
+    }
+    return {
+      ..._TableObj.getEmptyColumnEntry(key),
+      inputType: dataType,
+      inputDefaultValue: value
+    };
+  }
+  constructor(tableName, defaultValues) {
     this.tableName = tableName;
-    this.columns = columns;
+    for (const key in defaultValues) {
+      const value = defaultValues[key];
+      const columnEntry = _TableObj.getColumnEntry(key, value);
+      if (!columnEntry)
+        continue;
+      this.tableStructure.columns[key] = columnEntry;
+    }
   }
   primaryKey(key) {
-    this.tableInfo.primaryKey = key.toString();
+    this.tableStructure.primaryKey = key.toString();
+    this.tableStructure.columns[key.toString()].isPrimaryKey = true;
     return this;
   }
   foreignKey(fromColumn, toTable, toColumn, options) {
-    this.tableInfo.foreignKeys.push({
+    this.tableStructure.foreignKeys.push({
       fromTable: this.tableName,
       fromColumn: fromColumn.toString(),
       toTable: toTable.tableName,
@@ -67,17 +92,44 @@ var TableObj = class _TableObj {
     return this;
   }
   dataType(column, type) {
-    this.tableInfo.dataTypes[column.toString()] = type;
+    this.tableStructure.columns[column.toString()].inputType = type;
+    return this;
+  }
+  maxCharacterLength(column, max) {
+    this.tableStructure.columns[column.toString()].maxLength = max;
     return this;
   }
   static create(tableName, columns) {
     return new _TableObj(tableName, columns);
   }
-  static isDbTable(obj) {
+  static isTableObj(obj) {
     return !!obj?.IS_TABLE_OBJ;
   }
 };
 
+// src/lib/tableInfo/getTableStructure.ts
+var TABLE_INFO_PROPERTY_NAME = Symbol("tableInfo");
+function getInputColumnInfo(table, context) {
+  const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
+  const key = context.name ?? context;
+  if (!metadata.columns.hasOwnProperty(key))
+    metadata.columns[key] = TableObj.getEmptyColumnEntry(key);
+  return metadata.columns[key];
+}
+function getTableStructure(table) {
+  let metadata = table[Symbol.metadata] ?? table.prototype?.[Symbol.metadata];
+  if (!metadata) {
+    metadata = {};
+    table[Symbol.metadata] = metadata;
+  }
+  return getTableStructureFromMetadata(metadata);
+}
+function getTableStructureFromMetadata(metadata) {
+  if (!metadata[TABLE_INFO_PROPERTY_NAME])
+    metadata[TABLE_INFO_PROPERTY_NAME] = { table: "", primaryKey: "", foreignKeys: [], columns: {} };
+  return metadata[TABLE_INFO_PROPERTY_NAME];
+}
+
 // src/lib/TableStructureGenerator.ts
 var TableStructureGenerator = class {
   dialect;
@@ -92,75 +144,31 @@ var TableStructureGenerator = class {
    * @return An object where keys are table names, and values are their corresponding table structures.
    */
   generateTableStructure() {
-    const tableObjects = {};
+    const tables = {};
     for (const table of this.dbInstructions.tables) {
-      if (TableObj.isDbTable(table))
-        tableObjects[table.tableName] = table;
-      else {
+      let structure;
+      if (TableObj.isTableObj(table)) {
+        structure = table.tableStructure;
+        tables[table.tableName] = table.tableStructure;
+      } else {
         const classTable = table;
-        tableObjects[classTable.name] = { columns: new classTable(), tableInfo: getTableInfo(classTable) };
+        structure = getTableStructure(classTable);
+        tables[classTable.name] = getTableStructure(classTable);
       }
-    }
-    const tables = {};
-    for (const tableName in tableObjects) {
-      const obj = tableObjects[tableName];
-      const tableInfo = obj.tableInfo;
-      tables[tableName] = {
-        table: tableName,
-        primaryKey: tableInfo?.primaryKey,
-        columns: this.getColumns(obj.columns, tableInfo),
-        foreignKeys: tableInfo?.foreignKeys
-      };
-    }
-    return tables;
-  }
-  /**
-   * Retrieves the columns for a table
-   *
-   * @param obj - The table class interface object containing  properties that represent the table's fields.
-   * @param tableInfo - Optional metadata about the table. Can be undefined.
-   * @return An array of {@link ColumnInfo} representing the detailed column information.
-   */
-  getColumns(obj, tableInfo) {
-    const columns = [];
-    for (const property in obj) {
-      const propertyKey = property;
-      const value = obj[propertyKey];
-      const columnData = {
-        name: property,
-        isPrimaryKey: property == tableInfo?.primaryKey,
-        type: this.dialect.types.string,
-        defaultValue: this.dialect.types.null
-      };
-      let dataType = tableInfo?.dataTypes?.[property] ?? typeof value;
-      switch (dataType) {
-        case "function":
-          continue;
-        case "object":
-          if (value instanceof Date) {
-            dataType = "date";
-            break;
-          } else {
-            Logger.warn(`${property} was skipped because its type (${typeof value}) is not supported`);
-            continue;
-          }
-        case "undefined":
-        case "symbol":
-          Logger.warn(`${property} was skipped because its type (${typeof value}) is not supported`);
-          continue;
+      for (const key in structure.columns) {
+        const entry = structure.columns[key];
+        entry.defaultValue = entry.inputDefaultValue === null ? this.dialect.types.null : this.dialect.formatValueToSql(entry.inputDefaultValue, entry.inputType);
+        entry.type = this.dialect.getSqlType(entry.inputType, entry);
       }
-      columnData.defaultValue = value === null ? this.dialect.types.null : this.dialect.formatValueToSql(value, dataType);
-      columnData.type = this.dialect.types[dataType];
-      columns.push(columnData);
     }
-    return columns;
+    return tables;
   }
 };
 
 // src/lib/exceptions/NotAllowedException.ts
 var NotAllowedException = class extends Error {
   constructor(entries) {
-    let message = "Some destructive changes need to be confirmed. In preMigration() run:\n";
+    let message = "Some destructive changes need to be confirmed. To confirm, add to preMigration():\n";
     for (const entry of entries) {
       message += `		migrations.allowMigration(${entry.version}, ${entry.tableName}, "${entry.type}");
 `;
@@ -178,6 +186,13 @@ var Migrations = class {
   migrationDataForOldTableNames = {};
   alwaysAllowed = {};
   notAllowedChanges = [];
+  /**
+   * Resets the migration state to its initial values.
+   * Only used internally.
+   *
+   * @param dbInstructions - The instructions containing database metadata and migration details.
+   * @param fromVersion - The version of the actual database.
+   */
   reset(dbInstructions, fromVersion) {
     this.fromVersion = fromVersion;
     this.toVersion = dbInstructions.version;
@@ -186,10 +201,23 @@ var Migrations = class {
     this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? {};
     this.notAllowedChanges = [];
   }
+  /**
+   * Retrieves the migration instructions for the specified table.
+   * @see getEntryFromTableName
+   *
+   * @param table - The {@link TableInput} object from which the table name will be retrieved.
+   * @return The migration instructions corresponding to the given table input.
+   */
   getEntry(table) {
     const tableName = this.getTableName(table);
     return this.getEntryFromTableName(tableName);
   }
+  /**
+   * Retrieves the migration instructions for the specified table.
+   *
+   * @param tableName - The name of the table for which the entry is to be retrieved or created.
+   * @return The migration instructions corresponding to the given table input.
+   */
   getEntryFromTableName(tableName) {
     if (!this.migrationData.hasOwnProperty(tableName)) {
       this.migrationData[tableName] = {
@@ -201,17 +229,39 @@ var Migrations = class {
     }
     return this.migrationData[tableName];
   }
+  /**
+   * Retrieves the table name from the given table input.
+   *
+   * @param table - The {@link TableInput} object.
+   * @return The name of the table derived from either {@link TableObj} or a class.
+   */
   getTableName(table) {
-    return TableObj.isDbTable(table) ? table.tableName : table.name;
+    return TableObj.isTableObj(table) ? table.tableName : table.name;
   }
+  /**
+   * Checks whether a provided version is relevant based on database version ({@link fromVersion}) and target version ({@link toVersion}).
+   * Also makes sure that version checks happen in order.
+   *
+   * @param version - The version to check for relevance.
+   * @return Returns true if the version is relevant, otherwise false.
+   * @throws Error if versions are not properly ordered
+   */
   versionIsRelevant(version) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (version <= this.fromVersion || version > this.toVersion)
       return false;
     if (version < this.lastUsedVersion)
       throw new Error("Migrations in preMigration() have to be ordered by version (beginning with the lowest version).");
     this.lastUsedVersion = version;
     return true;
   }
+  /**
+   * Verifies the renaming tasks specified in {@link DatabaseInstructions.preMigration} that were considered are valid.
+   * Called after all SQL queries have been generated.
+   * Only used internally.
+   *
+   * @param newTables - The table structures extracted from {@link DatabaseInstructions.tables}.
+   * @throws Error if a renaming task is invalid.
+   */
   verifyRenamingTasks(newTables) {
     for (const tableName in this.migrationData) {
       const migrationEntry = this.migrationData[tableName];
@@ -228,11 +278,18 @@ var Migrations = class {
         const newColumnName = renamingData.newName;
         if (oldColumnName == newColumnName)
           return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to itself!`);
-        else if (!newTables[tableName]?.columns.find((column) => column.name == newColumnName))
+        else if (!newTables[tableName]?.columns[newColumnName])
           return new Error(`You set column ${tableName}.${oldColumnName} to be renamed to ${tableName}.${newColumnName}. But ${tableName}.${newColumnName} does not exist in your structure.`);
       }
     }
   }
+  /**
+   * Making sure all considered calls to {@link allowMigration()} where necessary to prevent input mistakes.
+   * Called after all SQL queries have been generated.
+   * Only used internally.
+   *
+   * @throws Error if unnecessary calls were discovered. All discovered calls are collected and thrown as one Error.
+   */
   verifyAllowedMigrations() {
     if (this.notAllowedChanges.length)
       return new NotAllowedException(this.notAllowedChanges);
@@ -248,6 +305,14 @@ var Migrations = class {
     if (errorMsg)
       return new Error(errorMsg);
   }
+  /**
+   * Called by {@link MigrationManager} to check if a specific destructive query is allowed.
+   * Only used internally.
+   *
+   * @see allowMigration()
+   * @param tableName - The name of the table to check the migration against.
+   * @param type - The type of destructive migration being checked.
+   */
   compareWithAllowedMigration(tableName, type) {
     const migrationEntry = this.migrationData[tableName];
     if (!migrationEntry?.allowedMigrations[type]) {
@@ -256,41 +321,114 @@ var Migrations = class {
     } else if (migrationEntry)
       migrationEntry.usedMigrations[type] = true;
   }
+  /**
+   * Retrieves the migration data containing instructions for data migration.
+   * Only used internally.
+   *
+   * @return An object where each key corresponds to the table name,
+   * and the value is the associated migration instructions.
+   */
   getMigrationData() {
     return this.migrationData;
   }
+  /**
+   * Iterates over renamed columns for the specified table and executes a callback for each pair of old and new column names.
+   * Only used internally.
+   *
+   * @param tableName - Name of the table whose renamed columns should be processed.
+   * @param callback - A function to execute for each renamed column, receiving the old and new column names as arguments.
+   */
   loopRenamedColumns(tableName, callback) {
     const migrationEntry = this.migrationData[tableName];
     for (const renamingData of migrationEntry.renamedColumns) {
       callback(renamingData.oldName, renamingData.newName);
     }
   }
+  /**
+   * Considers the renaming of a table and returns its (newest) name after the migration or
+   * the original name if no renaming is queued.
+   * Only used internally.
+   *
+   * @see getOldTableName()
+   * @param tableName - The current table name in the database.
+   * @return The newest table name if available, otherwise the current table name.
+   */
   getNewestTableName(tableName) {
     return this.migrationDataForOldTableNames[tableName]?.tableRenaming?.newName ?? tableName;
   }
+  /**
+   * Retrieves the current table name in the database.
+   * Only used internally.
+   *
+   * @see getNewestTableName()
+   * @param tableName - The name of the newest table name.
+   * @return The current table name in the database.
+   */
   getOldTableName(tableName) {
     return this.migrationData[tableName]?.tableRenaming?.oldName ?? tableName;
   }
+  /**
+   * Considers the renaming of a column in a table and returns its (newest) name after the migration or
+   * the original name if no renaming is queued.
+   * Only used internally.
+   *
+   * @param tableName - The name of the table containing the column.
+   * @param oldColumnName - The current name of the column in the database.
+   * @return The newest column name if available, otherwise the original column name.
+   */
   getNewestColumnName(tableName, oldColumnName) {
     const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns.oldName == oldColumnName);
     return columnNames ? columnNames.newName : oldColumnName;
   }
+  /**
+   * Determines if the specified table is marked to be recreated.
+   * Only used internally.
+   *
+   * @param tableName The name of the table to check.
+   * @return Returns true if the table will be recreated, false otherwise.
+   */
   willBeRecreated(tableName) {
     return this.migrationData[tableName]?.recreate;
   }
+  /**
+   * Marks a table to be recreated and logs the recreation reason for the user.
+   * Only used internally.
+   *
+   * @param tableName - The name of the table to be marked for recreation.
+   * @param reason - The reason why the table is being marked for recreation.
+   */
   internalRecreate(tableName, reason) {
     const entry = this.getEntryFromTableName(tableName);
     entry.recreate = true;
     Logger.log(`Table ${tableName} will be recreated(${reason})!`);
   }
+  /**
+   * SqlMorpheus only allows destructive statements if it was specifically allowed in {@link DatabaseInstructions.preMigration()}.
+   * Use this method to allow a destructive statement for a specific version.
+   * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
+   *
+   * @param version - The target version for which the specific migration is allowed. Must be provided to make sure this method will only have an effect when specified.
+   * @param table - Either a {@link TableObj} or a class decorated with @TableClass.
+   * @param allowedMigrations - The keys representing the migrations to be allowed. Multiple migrations can be provided
+   */
   allowMigration(version, table, ...allowedMigrations) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const entry = this.getEntry(table);
     for (const key of allowedMigrations) {
       entry.allowedMigrations[key] = true;
     }
   }
+  /**
+   * When you change the name of a table, SqlMorpheus will assume the original table was meant to be dropped
+   * and the new table was meant to be added, which would lead to data loss.
+   * Use this method to mark a table to be renamed instead.
+   * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
+   *
+   * @param version - The target version for which the table should be renamed. Must be provided to make sure this method will only have an effect when specified.
+   * @param oldTableName - The current name in the database at the time of the migration.
+   * @param newTableName - The new table name or its equivalent input format.
+   */
   renameTable(version, oldTableName, newTableName) {
     if (!this.versionIsRelevant(version))
       return;
@@ -302,6 +440,17 @@ var Migrations = class {
     else
       entry.tableRenaming.newName = newTableNameString;
   }
+  /**
+   * When you change the name of a column, SqlMorpheus will assume the original column was meant to be removed
+   * and the new column was meant to be added, which would lead to data loss.
+   * Use this method to mark a column to be renamed instead.
+   * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
+   *
+   * @param version - The target version for which the table should be renamed. Must be provided to make sure this method will only have an effect when specified.
+   * @param table Either a {@link TableObj} or a class decorated with @TableClass containing the column to be renamed.
+   * @param oldColumn The current name in the database at the time of the migration.
+   * @param newColumn The new name to assign to the column.
+   */
   renameColumn(version, table, oldColumn, newColumn) {
     if (!this.versionIsRelevant(version))
       return;
@@ -312,6 +461,15 @@ var Migrations = class {
     else
       entry.renamedColumns.push({ oldName: oldColumn, newName: newColumn });
   }
+  /**
+   * Should not be needed most of the time.
+   * Marks a table to be recreated
+   * (a copy of the table will be created, all data will be moved over, the original table will be dropped and the new table will be renamed to the original name).
+   * This method will be ignored if {@link version} is smaller than the current database version or higher than the target version of {@link DatabaseInstructions}.
+   *
+   * @param version - The target version for which the table should be renamed. Must be provided to make sure this method will only have an effect when specified.
+   * @param table Either a {@link TableObj} or a class decorated with @TableClass.
+   */
   recreateTable(version, table) {
     if (!this.versionIsRelevant(version))
       return;
@@ -500,8 +658,9 @@ ${changes.up}
    */
   createTableSql(tableName, columns, foreignKeys) {
     const queryLines = [];
-    for (const columnInfo of columns) {
-      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.defaultValue, columnInfo.isPrimaryKey));
+    for (const key in columns) {
+      const columnInfo = columns[key];
+      queryLines.push(this.dialect.columnDefinition(columnInfo.name, columnInfo.type, columnInfo.isPrimaryKey, columnInfo.defaultValue));
     }
     if (foreignKeys) {
       for (const foreignKeyInfo of foreignKeys) {
@@ -539,7 +698,11 @@ ${changes.up}
         this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
       const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
       const newColumnList = this.newTables[tableName].columns;
-      const moveableColumns = newColumnList.filter((entry) => oldColumnList.find((oldEntry) => oldEntry.name == entry.name) != void 0).map((entry) => entry.name);
+      const moveableColumns = [];
+      for (const key in newColumnList) {
+        if (oldColumnList.hasOwnProperty(key))
+          moveableColumns.push(newColumnList[key].name);
+      }
       const backupTableName = `${tableName}__backup`;
       const insertQuery = this.dialect.insert(
         backupTableName,
@@ -547,7 +710,7 @@ ${changes.up}
       );
       const moveDataQuery = insertQuery + "\n" + this.dialect.dropTable(tableName) + "\n" + this.dialect.renameTable(backupTableName, tableName);
       const structure = this.newTables[tableName];
-      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery + "\n";
+      changes.up += this.createTableSql(backupTableName, structure.columns, structure.foreignKeys) + "\n" + moveDataQuery + "\n\n";
       const dbTableName = this.migrations.getOldTableName(tableName);
       changes.down += this.dialect.canInspectForeignKeys && this.dialect.canInspectPrimaryKey ? this.createTableSql(backupTableName, await this.dialect.getColumnInformation(dbTableName), await this.dialect.getForeignKeys(dbTableName)) + "\n" + moveDataQuery : "\n\n-- Cannot recreate foreign keys or load primary keys with this database! Table will not be recreated!\n";
     }
@@ -639,6 +802,10 @@ ${changes.up}
       const newTableDefinition = this.newTables[tableName];
       const oldColumnList = await this.dialect.getColumnInformation(this.migrations.getOldTableName(tableName));
       const oldPrimaryKey = this.dialect.canInspectPrimaryKey ? this.getPrimaryKeyColumn(oldColumnList) : false;
+      const oldColumnNewNameIndex = {};
+      for (const key in oldColumnList) {
+        oldColumnNewNameIndex[this.migrations.getNewestColumnName(tableName, key)] = oldColumnList[key];
+      }
       const newColumnList = newTableDefinition.columns;
       const newPrimaryKey = newTableDefinition.primaryKey;
       if (this.dialect.canInspectPrimaryKey && oldPrimaryKey != newPrimaryKey) {
@@ -657,25 +824,23 @@ ${changes.up}
           this.migrations.internalRecreate(newTableDefinition.table, "Dialect does not support altering primary keys");
         continue;
       }
-      for (const newColumn of newColumnList) {
-        const oldColumn = oldColumnList.find(
-          (entry) => this.migrations.getNewestColumnName(tableName, entry.name) == newColumn.name
-        );
+      for (const key in newColumnList) {
+        const newColumn = newColumnList[key];
+        const oldColumn = oldColumnNewNameIndex[newColumn.name];
         if (oldColumn == void 0) {
-          changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.defaultValue, newColumn.isPrimaryKey)) + "\n";
+          changes.up += this.dialect.createColumn(tableName, this.dialect.columnDefinition(newColumn.name, newColumn.type, newColumn.isPrimaryKey, newColumn.defaultValue)) + "\n";
           changes.down += this.dialect.dropColumn(tableName, newColumn.name) + "\n";
         } else if (newColumn.type != oldColumn.type || newColumn.defaultValue != oldColumn.defaultValue) {
           this.migrations.internalRecreate(newTableDefinition.table, "Table structure was changed");
         }
       }
-      for (const oldColumn of oldColumnList) {
-        const newColumn = newColumnList.find(
-          (entry) => entry.name == this.migrations.getNewestColumnName(tableName, oldColumn.name)
-        );
+      for (const key in oldColumnList) {
+        const oldColumn = oldColumnList[key];
+        const newColumn = newColumnList[this.migrations.getNewestColumnName(tableName, oldColumn.name)];
         if (newColumn == void 0) {
           this.migrations.compareWithAllowedMigration(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";
+          changes.down += this.dialect.createColumn(tableName, this.dialect.columnDefinition(oldColumn.name, oldColumn.type, oldColumn.isPrimaryKey, oldColumn.defaultValue)) + "\n";
         }
       }
     }
@@ -684,11 +849,12 @@ ${changes.up}
   /**
    * Retrieves the name of the primary key column from a list of column information.
    *
-   * @param columnInfoList - An array of ColumnInfo objects containing details about each column.
+   * @param columnInfoEntries - An array of ColumnInfo objects containing details about each column.
    * @return The name of the primary key column if found; otherwise, undefined.
    */
-  getPrimaryKeyColumn(columnInfoList) {
-    for (const columnInfo of columnInfoList) {
+  getPrimaryKeyColumn(columnInfoEntries) {
+    for (const key in columnInfoEntries) {
+      const columnInfo = columnInfoEntries[key];
       if (columnInfo.isPrimaryKey)
         return columnInfo.name;
     }
@@ -778,15 +944,27 @@ ${changes.down}`, { encoding: "utf-8" });
 import "polyfill-symbol-metadata";
 function TableClass(tableName, primaryKey) {
   return (table, context) => {
-    const tableInfo = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
-    tableInfo.primaryKey = primaryKey?.toString();
-    if (tableInfo.foreignKeys) {
-      for (const foreignKey of tableInfo.foreignKeys) {
+    const tableStructure = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
+    tableStructure.primaryKey = primaryKey?.toString();
+    tableStructure.table = tableName;
+    if (tableStructure.foreignKeys) {
+      for (const foreignKey of tableStructure.foreignKeys) {
         foreignKey.fromTable = tableName;
         if (foreignKey.toTable == table.name)
           foreignKey.toTable = tableName;
       }
     }
+    for (const key in table) {
+      const value = table[key];
+      const existingEntry = tableStructure.columns[key];
+      const defaultEntry = TableObj.getColumnEntry(key, value);
+      if (!defaultEntry)
+        continue;
+      tableStructure.columns[key] = {
+        ...defaultEntry,
+        ...existingEntry
+      };
+    }
     Object.defineProperty(table, "name", { value: tableName, writable: false });
   };
 }
@@ -795,10 +973,8 @@ function TableClass(tableName, primaryKey) {
 import "polyfill-symbol-metadata";
 function DataType(type) {
   return (table, context) => {
-    const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
-    if (!metadata.dataTypes)
-      metadata.dataTypes = {};
-    metadata.dataTypes[context.name ?? context] = type;
+    const entry = getInputColumnInfo(table, context);
+    entry.inputType = type;
   };
 }
 
@@ -806,7 +982,7 @@ function DataType(type) {
 import "polyfill-symbol-metadata";
 function ForeignKey(toTable, toColumn, options) {
   return (table, context) => {
-    const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
+    const metadata = context?.metadata ? getTableStructureFromMetadata(context.metadata) : getTableStructure(table);
     if (!metadata.foreignKeys)
       metadata.foreignKeys = [];
     metadata.foreignKeys.push({
@@ -846,7 +1022,7 @@ var DefaultSql = class {
    * Formats a given value to a SQL-equivalent string based on the provided data type.
    *
    * @param value - The value to be formatted.
-   * @param type - The data type of the value. Either determined through typeof or {@link TableInfo} setting
+   * @param type - The data type of the value. Either determined through typeof or {@link TableStructure} setting
    * @return A string representation of the value formatted for SQL.
    */
   formatValueToSql(value, type) {
@@ -857,65 +1033,68 @@ var DefaultSql = class {
       case "string":
         return `"${value}"`;
       case "time":
-        return toDate(value).toISOString().slice(11, 19);
+        return `"${toDate(value).toISOString().slice(11, 19)}"`;
       case "date":
-        return toDate(value).toISOString().slice(0, 10);
+        return `"${toDate(value).toISOString().slice(0, 10)}"`;
       case "dateTime":
-        return toDate(value).toISOString().slice(0, 19).replace("T", " ");
+        return `"${toDate(value).toISOString().slice(0, 19).replace("T", " ")}"`;
       default:
         return value.toString();
     }
   }
+  getSqlType(dataType, _) {
+    return this.types[dataType];
+  }
   /**
-   * Query to enable / disable foreign keys in the database.
+   * Statement to enable / disable foreign keys in the database.
    * Is dialect specific.
    *
    * @param enabled - A boolean indicating whether to enable or disable foreign key constraints.
-   * @return The query
+   * @return The SQL statement as a string.
    */
   changeForeignKeysState(enabled) {
     return "";
   }
   /**
-   * Query to add a foreign key to a specified table.
+   * Statement to add a foreign key to a specified table.
    * Is only used if {@link canAlterForeignKeys} is true.
    *
    * @param fromTableName - The name of the table to which the foreign key will be added.
    * @param foreignKey - The foreign key definition to be added, see {@link foreignKey()}.
-   * @return The SQL statement that adds the foreign key to the specified table.
+   * @return The SQL statement as a string.
    */
   addForeignKey(fromTableName, foreignKey) {
     throw new Error("Adding foreign keys is not supported!");
   }
   /**
-   * Query to remove a foreign key from a specified table.
+   * Statement to remove a foreign key from a specified table.
    * Is only used if {@link canAlterForeignKeys} is true.
    *
    * @param tableName - The name of the table to which the foreign key will be added.
    * @param foreignKeyName - The name of the foreign key definition.
-   * @return The SQL statement that removes the foreign key from the specified table.
+   * @return The SQL statement as a string.
    */
   removeForeignKey(tableName, foreignKeyName) {
     throw new Error("Foreign key removal is not supported!");
   }
   /**
-   * Query to add a primary key to the specified table.
+   * Statement to add a primary key to the specified table.
    * Is only used if {@link canAlterPrimaryKey} is true.
    *
    * @param tableName - The name of the table to which the primary key will be added.
    * @param columnName - The name of the column that will be set as the primary key.
-   * @return A SQL statement to add a primary key to the specified table and column.
+   * @return The SQL statement as a string.
    */
   addPrimaryKey(tableName, columnName) {
     throw new Error("Adding foreign keys is not supported!");
   }
   /**
-   * Query to remove a primary key from the specified table.
+   * Statement to remove a primary key from the specified table.
    * Is only used if {@link canAlterPrimaryKey} is true.
    *
    * @param tableName - The name of the table to which the primary key will be added.
    * @param columnName - The name of the column that will be set as the primary key.
-   * @return A SQL statement to remove a primary key from the specified table and column.
+   * @return The SQL statement as a string.
    */
   removePrimaryKey(tableName, columnName) {
     throw new Error("Foreign key removal is not supported!");
@@ -939,64 +1118,164 @@ var DefaultSql = class {
       query += ` ON DELETE ${onDelete}`;
     return query;
   }
+  /**
+   * Statement to create a table if it does not already exist.
+   *
+   * @param tableName - The name of the table to be created.
+   * @param entries - An array containing the column definitions for the table.
+   * @return The SQL statement as a string.
+   */
   createTable(tableName, entries) {
     return `CREATE TABLE IF NOT EXISTS ${tableName}  (
 	${entries.join(",\n	")}
 );`;
   }
+  /**
+   * Statement to rename a table.
+   *
+   * @param tableName - The name of the existing table to be renamed.
+   * @param newTableName - The new name for the table.
+   * @return The SQL statement as a string.
+   */
   renameTable(tableName, newTableName) {
     return `ALTER TABLE ${tableName} RENAME TO ${newTableName};`;
   }
+  /**
+   * Statement to drop a table if it exists.
+   *
+   * @param tableName - The name of the table to be dropped.
+   * @return The SQL statement as a string.
+   */
   dropTable(tableName) {
     return `DROP TABLE IF EXISTS ${tableName};`;
   }
-  columnDefinition(columnName, type, defaultValue, isPrimaryKey) {
-    const query = `${columnName} ${type} DEFAULT ${defaultValue}`;
+  /**
+   * Constructs a SQL column definition based on the provided parameters.
+   *
+   * @param columnName - The name of the column.
+   * @param type - The data type of the column.
+   * @param defaultValue - The default value for the column.
+   * @param isPrimaryKey - Indicates whether the column is a primary key.
+   * @return The constructed SQL column definition string.
+   */
+  columnDefinition(columnName, type, isPrimaryKey, defaultValue) {
+    const query = `${columnName} ${type}${defaultValue ? ` DEFAULT ${defaultValue}` : ""}`;
     return isPrimaryKey ? `${query} PRIMARY KEY` : query;
   }
+  /**
+   * Statement to add a new column to a specified table.
+   *
+   * @param columnTable - The name of the table to which the column will be added.
+   * @param entry - The column definition including the column name and its data type. See {@link columnDefinition()}
+   * @return The SQL statement as a string.
+   */
   createColumn(columnTable, entry) {
     return `ALTER TABLE ${columnTable} ADD ${entry};`;
   }
+  /**
+   * Statement to rename a column in an existing table.
+   *
+   * @param tableName - The name of the table containing the column to rename.
+   * @param oldColumnName - The current name of the column to be renamed.
+   * @param newColumnName - The new name for the column.
+   * @return The SQL statement as a string.
+   */
   renameColumn(tableName, oldColumnName, newColumnName) {
     return `ALTER TABLE ${tableName} RENAME COLUMN ${oldColumnName} TO ${newColumnName};`;
   }
-  copyColumn(tableName, oldColumnName, newColumnName) {
-    return `UPDATE ${tableName} SET ${newColumnName} = ${oldColumnName};`;
-  }
+  /**
+   * Statement to drop a column from a specified table.
+   *
+   * @param tableName - The name of the table from which the column will be dropped.
+   * @param columnName - The name of the column to be dropped.
+   * @return The SQL statement as a string.
+   */
   dropColumn(tableName, columnName) {
     return `ALTER TABLE ${tableName} DROP COLUMN ${columnName};`;
   }
+  /**
+   * Statement to return data from a table.
+   *
+   * @param tableName - The name of the database table to select data from.
+   * @param select - An array of column names to include in the SELECT clause.
+   * @param where - An optional condition.
+   * @return The SQL statement as a string.
+   */
   select(tableName, select, where) {
     let query = `SELECT ${select.join(",")} FROM ${tableName}`;
     if (where)
       query += ` WHERE ${where}`;
     return `${query};`;
   }
+  /**
+   * Statement to insert data into a table.
+   *
+   * @param tableName - The name of the table where the data will be inserted.
+   * @param content - The value query. See {@link insertValues()}.
+   * @return The SQL statement as a string.
+   */
   insert(tableName, content) {
     return `INSERT INTO ${tableName} ${content};`;
   }
+  /**
+   * A SQL insert query string. See {@link insert()}.
+   *
+   * @param keys - An array of column names to be used in the query.
+   * @param [valueString] - An optional preformatted value string to be included in the query.
+   * If not provided, the method generates a default placeholder string with "?" for each key.
+   * @return The SQL statement as a string.
+   */
   insertValues(keys, valueString) {
     return `(${keys}) ${valueString ?? `VALUES (${keys.map(() => "?").join(",")})`}`;
   }
+  /**
+   * Returns a SQL query string to create a migration table.
+   * The table is used to store migration data, specifically the version of the migration.
+   *
+   * @return The SQL query string for creating the migration table.
+   */
   migrationTableQuery() {
     return this.createTable(MIGRATION_DATA_TABLE_NAME, [
-      this.columnDefinition("version", this.types.number, "0", false)
+      this.columnDefinition("version", this.types.number, false, "0")
     ]);
   }
+  /**
+   * Fetches the foreign keys for the specified table.
+   * This method is only used if {@link canInspectForeignKeys} is true
+   *
+   * @param tableName - The name of the table for which to retrieve foreign key information.
+   * @return {Promise<ForeignKeyInfo[]>} A promise that resolves to an array of {@link ForeignKeyInfo}.
+   */
   async getForeignKeys(tableName) {
     throw new Error("Inspecting foreign keys is not supported!");
   }
+  /**
+   * Ensures that the migration table exists in the database.
+   * If the table does not exist, it creates the table using the defined migration table query.
+   *
+   * @return A promise that resolves when the migration table is created successfully.
+   */
   async createMigrationTableIfNeeded() {
     await this.db.runMultipleWriteStatements(this.migrationTableQuery());
   }
-  //TODO: untested
+  /**
+   * Retrieves the current version from the migration data table.
+   *
+   * @return A promise that resolves to the current version number. Returns 0 if no version is found.
+   */
   async getVersion() {
     await this.createMigrationTableIfNeeded();
     const query = this.select(MIGRATION_DATA_TABLE_NAME, ["version"]);
     const data = await this.db.runGetStatement(query);
     return data.length ? data[0].version : 0;
   }
-  //TODO: untested
+  /**
+   * Updates the migration version in the database. If the version entry does not exist, it inserts a new one;
+   * if it exists, it updates the version to the specified value.
+   *
+   * @param newVersion - The new migration version to set in the database.
+   * @return A promise that resolves when the operation is complete.
+   */
   async setVersion(newVersion) {
     const query = `${this.migrationTableQuery()};
 INSERT INTO ${MIGRATION_DATA_TABLE_NAME} (version) VALUES ${newVersion} WHERE NOT EXISTS (SELECT 1 FROM ${MIGRATION_DATA_TABLE_NAME})
@@ -1014,9 +1293,9 @@ var SqliteDialect = class extends DefaultSql {
     number: "INTEGER",
     bigint: "INTEGER",
     boolean: "INTEGER",
-    date: "DATE",
-    time: "TIME",
-    dateTime: "DATETIME",
+    date: "INTEGER",
+    time: "INTEGER",
+    dateTime: "INTEGER",
     null: "NULL"
   };
   canAlterForeignKeys = false;
@@ -1031,14 +1310,16 @@ var SqliteDialect = class extends DefaultSql {
   }
   async getColumnInformation(tableName) {
     const data = await this.db.runGetStatement(`PRAGMA table_info(${tableName})`);
-    return data.map((entry) => {
-      return {
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
         name: entry["name"],
         type: entry["type"],
         defaultValue: entry["dflt_value"],
         isPrimaryKey: entry["pk"] == "1"
       };
-    });
+    }
+    return output;
   }
   formatValueToSql(value, type) {
     function toDate(value2) {
@@ -1063,8 +1344,8 @@ var SqliteDialect = class extends DefaultSql {
         fromColumn: entry["from"],
         toTable: entry["table"],
         toColumn: entry["to"],
-        on_update: entry["on_update"],
-        on_delete: entry["on_delete"]
+        onUpdate: entry["on_update"] ?? "NO ACTION",
+        onDelete: entry["on_delete"] ?? "NO ACTION"
       };
     });
   }
@@ -1097,14 +1378,17 @@ var PostgresDialect = class extends DefaultSql {
   }
   async getColumnInformation(tableName) {
     const data = await this.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 {
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
         name: entry["column_name"],
         type: entry["data_type"],
+        maxLength: 0,
         defaultValue: entry["column_default"],
         isPrimaryKey: false
       };
-    });
+    }
+    return output;
   }
   addPrimaryKey(tableName, columnName) {
     return `ALTER TABLE ${tableName} ADD PRIMARY KEY (${columnName});
@@ -1149,18 +1433,21 @@ var MsSqlDialect = class extends DefaultSql {
     });
   }
   async getTableNames() {
-    return await this.db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'");
+    return (await this.db.runGetStatement("SELECT TABLE_NAME FROM INFORMATION_SCHEMA.TABLES WHERE TABLE_TYPE = 'BASE TABLE'")).map((entry) => entry.name);
   }
   async getColumnInformation(tableName) {
     const data = await this.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"],
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
+        name: entry["name"],
         type: entry["DATA_TYPE"],
+        maxLength: 0,
         defaultValue: entry["COLUMN_DEFAULT"],
-        isPrimaryKey: false
+        isPrimaryKey: entry["pk"] == "1"
       };
-    });
+    }
+    return output;
   }
 };
 
@@ -1170,9 +1457,26 @@ var MySqlDialect = class extends DefaultSql {
   canAlterPrimaryKey = true;
   canInspectForeignKeys = true;
   canInspectPrimaryKey = true;
+  types = {
+    string: "VARCHAR",
+    number: "INT",
+    bigint: "BIGINT",
+    boolean: "BOOLEAN",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME",
+    null: "NULL"
+  };
+  getSqlType(dataType, columnInfo) {
+    switch (dataType) {
+      case "string":
+        return this.types[dataType] + `(${columnInfo?.maxLength})`;
+      default:
+        return super.getSqlType(dataType, columnInfo);
+    }
+  }
   changeForeignKeysState(enabled) {
-    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"}
-;`;
+    return `SET FOREIGN_KEY_CHECKS ${enabled ? "1" : "0"};`;
   }
   addForeignKey(fromTableName, foreignKey) {
     return `ALTER TABLE ${fromTableName} ADD ${foreignKey};`;
@@ -1198,18 +1502,22 @@ var MySqlDialect = class extends DefaultSql {
     });
   }
   async getTableNames() {
-    return await this.db.runGetStatement("SHOW TABLES;");
+    const t = await this.db.runGetStatement("SELECT table_name FROM information_schema.tables;");
+    return (await this.db.runGetStatement("SELECT table_name FROM information_schema.tables;")).map((entry) => entry.name);
   }
   async getColumnInformation(tableName) {
     const data = await this.db.runGetStatement(`SHOW COLUMNS FROM ${tableName};`);
-    return data.map((entry) => {
-      return {
-        name: entry["Field"],
-        type: entry["Type"],
-        defaultValue: entry["Default"],
-        isPrimaryKey: entry["Key"] == "PRI"
+    const output = {};
+    for (const entry of data) {
+      output[entry["name"]] = {
+        name: entry["name"],
+        type: entry["type"],
+        maxLength: 0,
+        defaultValue: entry["dflt_value"],
+        isPrimaryKey: entry["pk"] == "1"
       };
-    });
+    }
+    return output;
   }
 };