sqlmorpheus 0.2.0 → 0.2.1

package/dist/index.mjs

@@ -37,6 +37,47 @@ function getTableInfoFromMetadata(metadata) {
   return metadata[TABLE_INFO_PROPERTY_NAME];
 }
 
+// src/lib/tableInfo/TableObj.ts
+var TableObj = class _TableObj {
+  IS_TABLE_OBJ = true;
+  tableName;
+  columns;
+  tableInfo = {
+    primaryKey: void 0,
+    foreignKeys: [],
+    dataTypes: {}
+  };
+  constructor(tableName, columns) {
+    this.tableName = tableName;
+    this.columns = columns;
+  }
+  primaryKey(key) {
+    this.tableInfo.primaryKey = key.toString();
+    return this;
+  }
+  foreignKey(fromColumn, toTable, toColumn, options) {
+    this.tableInfo.foreignKeys.push({
+      fromTable: this.tableName,
+      fromColumn: fromColumn.toString(),
+      toTable: toTable.tableName,
+      toColumn: toColumn.toString(),
+      onUpdate: options?.onUpdate,
+      onDelete: options?.onDelete
+    });
+    return this;
+  }
+  dataType(column, type) {
+    this.tableInfo.dataTypes[column.toString()] = type;
+    return this;
+  }
+  static create(tableName, columns) {
+    return new _TableObj(tableName, columns);
+  }
+  static isDbTable(obj) {
+    return !!obj?.IS_TABLE_OBJ;
+  }
+};
+
 // src/lib/TableStructureGenerator.ts
 var TableStructureGenerator = class {
   dialect;
@@ -45,19 +86,21 @@ var TableStructureGenerator = class {
     this.dialect = dialect;
     this.dbInstructions = dbInstructions;
   }
+  /**
+   * Generates the structure of tables based on database instructions.
+   *
+   * @return An object where keys are table names, and values are their corresponding table structures.
+   */
   generateTableStructure() {
-    if (this.dbInstructions.tables.length) {
-      const tableObjects = {};
-      for (const table of this.dbInstructions.tables) {
-        tableObjects[table.name] = { columns: new table(), tableInfo: getTableInfo(table) };
+    const tableObjects = {};
+    for (const table of this.dbInstructions.tables) {
+      if (TableObj.isDbTable(table))
+        tableObjects[table.tableName] = table;
+      else {
+        const classTable = table;
+        tableObjects[classTable.name] = { columns: new classTable(), tableInfo: getTableInfo(classTable) };
       }
-      return this.getExpectedStructure(tableObjects);
-    } else {
-      const tableObjects = this.dbInstructions.tables;
-      return this.getExpectedStructure(tableObjects);
     }
-  }
-  getExpectedStructure(tableObjects) {
     const tables = {};
     for (const tableName in tableObjects) {
       const obj = tableObjects[tableName];
@@ -65,46 +108,49 @@ var TableStructureGenerator = class {
       tables[tableName] = {
         table: tableName,
         primaryKey: tableInfo?.primaryKey,
-        columns: this.getColumns(obj.columns, tableInfo?.primaryKey),
+        columns: this.getColumns(obj.columns, tableInfo),
         foreignKeys: tableInfo?.foreignKeys
       };
     }
     return tables;
   }
-  getColumns(obj, primaryKey) {
+  /**
+   * 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 == primaryKey,
-        type: "TEXT",
-        defaultValue: this.dialect.typeNull
+        isPrimaryKey: property == tableInfo?.primaryKey,
+        type: this.dialect.types.string,
+        defaultValue: this.dialect.types.null
       };
-      switch (typeof value) {
-        case "string":
-          columnData.type = this.dialect.typeString;
-          columnData.defaultValue = value === null ? this.dialect.typeNull : `"${this.dialect.formatValueToSql(value)}"`;
-          break;
-        case "bigint":
-          columnData.type = this.dialect.typeBigInt;
-          columnData.defaultValue = value === null ? this.dialect.typeNull : this.dialect.formatValueToSql(value);
-          break;
-        case "number":
-          columnData.type = this.dialect.typeInt;
-          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;
+      let dataType = tableInfo?.dataTypes?.[property] ?? typeof value;
+      switch (dataType) {
         case "function":
           continue;
-        default:
-          Logger.warn(`${obj.constructor.name}.${property} was skipped because its type is not supported (${typeof value})`);
+        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;
       }
+      columnData.defaultValue = value === null ? this.dialect.types.null : this.dialect.formatValueToSql(value, dataType);
+      columnData.type = this.dialect.types[dataType];
       columns.push(columnData);
     }
     return columns;
@@ -114,32 +160,37 @@ var TableStructureGenerator = class {
 // src/lib/exceptions/NotAllowedException.ts
 var NotAllowedException = class extends Error {
   constructor(entries) {
-    let message = "Some destructive changes need to be confirmed.\n	In preMigration() run:\n";
+    let message = "Some destructive changes need to be confirmed. In preMigration() run:\n";
     for (const entry of entries) {
-      message += `		migrations.allowMigration(${entry.version}, "${entry.tableName}", "${entry.type}");
+      message += `		migrations.allowMigration(${entry.version}, ${entry.tableName}, "${entry.type}");
 `;
     }
     super(message);
   }
 };
 
-// src/lib/typings/Migrations.ts
+// src/lib/Migrations.ts
 var Migrations = class {
-  toVersion = 0;
-  alwaysAllowed = {};
   fromVersion = 0;
+  toVersion = 0;
+  lastUsedVersion = 0;
   migrationData = {};
   migrationDataForOldTableNames = {};
+  alwaysAllowed = {};
   notAllowedChanges = [];
   reset(dbInstructions, fromVersion) {
     this.fromVersion = fromVersion;
-    this.migrationData = {};
     this.toVersion = dbInstructions.version;
+    this.migrationData = {};
+    this.migrationDataForOldTableNames = {};
     this.alwaysAllowed = dbInstructions.alwaysAllowedMigrations ?? {};
     this.notAllowedChanges = [];
   }
   getEntry(table) {
     const tableName = this.getTableName(table);
+    return this.getEntryFromTableName(tableName);
+  }
+  getEntryFromTableName(tableName) {
     if (!this.migrationData.hasOwnProperty(tableName)) {
       this.migrationData[tableName] = {
         recreate: false,
@@ -151,17 +202,27 @@ var Migrations = class {
     return this.migrationData[tableName];
   }
   getTableName(table) {
-    return typeof table == "string" ? table : table.name;
+    return TableObj.isDbTable(table) ? table.tableName : table.name;
+  }
+  versionIsRelevant(version) {
+    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;
   }
   verifyRenamingTasks(newTables) {
     for (const tableName in this.migrationData) {
       const migrationEntry = this.migrationData[tableName];
-      if (migrationEntry.tableRenaming?.oldName == tableName)
-        return new Error(`You set table "${tableName}" to be renamed to itself!`);
-      if (migrationEntry.tableRenaming && migrationEntry.tableRenaming.newName != tableName)
-        return new Error(`You set table "${tableName}" to be renamed to a different name than the one in your structure (${migrationEntry.tableRenaming.newName})!`);
-      else if (!newTables[tableName])
-        return new Error(`You set table "${migrationEntry.tableRenaming}" migrations for "${tableName}". But "${tableName}" does not exist in your structure.`);
+      if (migrationEntry.tableRenaming) {
+        if (migrationEntry.tableRenaming.oldName == tableName)
+          return new Error(`You set table "${tableName}" to be renamed to itself!`);
+        if (migrationEntry.tableRenaming.newName != tableName)
+          return new Error(`You set table "${tableName}" to be renamed to a different name than the one in your structure (${migrationEntry.tableRenaming.newName})!`);
+        else if (!newTables[tableName])
+          return new Error(`You set table "${migrationEntry.tableRenaming}" migrations for "${tableName}". But "${tableName}" does not exist in your structure.`);
+      }
       for (const renamingData of migrationEntry.renamedColumns) {
         const oldColumnName = renamingData.oldName;
         const newColumnName = renamingData.newName;
@@ -195,6 +256,33 @@ var Migrations = class {
     } else if (migrationEntry)
       migrationEntry.usedMigrations[type] = true;
   }
+  getMigrationData() {
+    return this.migrationData;
+  }
+  loopRenamedColumns(tableName, callback) {
+    const migrationEntry = this.migrationData[tableName];
+    for (const renamingData of migrationEntry.renamedColumns) {
+      callback(renamingData.oldName, renamingData.newName);
+    }
+  }
+  getNewestTableName(tableName) {
+    return this.migrationDataForOldTableNames[tableName]?.tableRenaming?.newName ?? tableName;
+  }
+  getOldTableName(tableName) {
+    return this.migrationData[tableName]?.tableRenaming?.oldName ?? tableName;
+  }
+  getNewestColumnName(tableName, oldColumnName) {
+    const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns.oldName == oldColumnName);
+    return columnNames ? columnNames.newName : oldColumnName;
+  }
+  willBeRecreated(tableName) {
+    return this.migrationData[tableName]?.recreate;
+  }
+  internalRecreate(tableName, reason) {
+    const entry = this.getEntryFromTableName(tableName);
+    entry.recreate = true;
+    Logger.log(`Table ${tableName} will be recreated(${reason})!`);
+  }
   allowMigration(version, table, ...allowedMigrations) {
     if (version < this.fromVersion || version > this.toVersion)
       return;
@@ -204,13 +292,9 @@ var Migrations = class {
     }
   }
   renameTable(version, oldTableName, newTableName) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const newTableNameString = this.getTableName(newTableName);
-    if (this.migrationData.hasOwnProperty(oldTableName)) {
-      this.migrationData[newTableNameString] = this.getEntry(oldTableName);
-      delete this.migrationData[oldTableName];
-    }
     const entry = this.getEntry(newTableName);
     this.migrationDataForOldTableNames[oldTableName] = entry;
     if (!entry.tableRenaming)
@@ -219,7 +303,7 @@ var Migrations = class {
       entry.tableRenaming.newName = newTableNameString;
   }
   renameColumn(version, table, oldColumn, newColumn) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
     const entry = this.getEntry(table);
     const existingColumnEntry = entry.renamedColumns.find((entry2) => entry2.newName == oldColumn);
@@ -228,36 +312,12 @@ var Migrations = class {
     else
       entry.renamedColumns.push({ oldName: oldColumn, newName: newColumn });
   }
-  recreateTableImp(table) {
-    const entry = this.getEntry(table);
-    entry.recreate = true;
-  }
   recreateTable(version, table) {
-    if (version < this.fromVersion || version > this.toVersion)
+    if (!this.versionIsRelevant(version))
       return;
-    this.recreateTableImp(table);
-  }
-  getMigrationData() {
-    return this.migrationData;
-  }
-  loopRenamedColumns(tableName, callback) {
-    const migrationEntry = this.migrationData[tableName];
-    for (const renamingData of migrationEntry.renamedColumns) {
-      callback(renamingData.oldName, renamingData.newName);
-    }
-  }
-  getNewestTableName(tableName) {
-    return this.migrationDataForOldTableNames[tableName]?.tableRenaming?.newName ?? tableName;
-  }
-  getOldTableName(tableName) {
-    return this.migrationData[tableName]?.tableRenaming?.oldName ?? tableName;
-  }
-  getNewestColumnName(tableName, oldColumnName) {
-    const columnNames = this.migrationData[tableName]?.renamedColumns.find((columns) => columns.oldName == oldColumnName);
-    return columnNames ? columnNames.newName : oldColumnName;
-  }
-  willBeRecreated(tableName) {
-    return this.migrationData[tableName]?.recreate;
+    const entry = this.getEntry(table);
+    entry.recreate = true;
+    Logger.log(`Table ${this.getTableName(table)} will be recreated!`);
   }
 };
 
@@ -474,7 +534,6 @@ ${changes.up}
       const migrationEntry = migrationData[tableName];
       if (!migrationEntry.recreate)
         continue;
-      Logger.log(`Table ${tableName} will be recreated!`);
       this.migrations.compareWithAllowedMigration(tableName, "recreateTable");
       if (!this.dialect.canInspectForeignKeys || !this.dialect.canInspectPrimaryKey)
         this.migrations.compareWithAllowedMigration(tableName, "continueWithoutRollback");
@@ -521,7 +580,7 @@ ${changes.up}
               this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
             );
           } else {
-            this.migrations.recreateTableImp(structure.table);
+            this.migrations.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
             checkForNewForeignKeys = false;
           }
         } else {
@@ -538,7 +597,7 @@ ${changes.up}
                 this.dialect.foreignKey(oldForeignKey.fromColumn, oldForeignKey.toTable, oldForeignKey.toColumn, oldForeignKey.onUpdate, oldForeignKey.onDelete)
               ) + this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
             } else {
-              this.migrations.recreateTableImp(structure.table);
+              this.migrations.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
               checkForNewForeignKeys = false;
             }
           }
@@ -557,7 +616,7 @@ ${changes.up}
             );
             changes.down += this.dialect.removeForeignKey(newForeignKey.fromTable, newForeignKey.fromColumn);
           } else {
-            this.migrations.recreateTableImp(structure.table);
+            this.migrations.internalRecreate(structure.table, "Dialect does not support altering foreign keys");
             break;
           }
         }
@@ -595,7 +654,7 @@ ${changes.up}
             changes.down += this.dialect.removePrimaryKey(tableName, newPrimaryKey.toString());
           }
         } else
-          this.migrations.recreateTableImp(newTableDefinition.table);
+          this.migrations.internalRecreate(newTableDefinition.table, "Dialect does not support altering primary keys");
         continue;
       }
       for (const newColumn of newColumnList) {
@@ -606,7 +665,7 @@ ${changes.up}
           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.recreateTableImp(newTableDefinition.table);
+          this.migrations.internalRecreate(newTableDefinition.table, "Table structure was changed");
         }
       }
       for (const oldColumn of oldColumnList) {
@@ -715,24 +774,37 @@ ${changes.down}`, { encoding: "utf-8" });
   }
 };
 
-// src/lib/tableInfo/decorators/DbTable.ts
+// src/lib/tableInfo/decorators/TableClass.ts
 import "polyfill-symbol-metadata";
-function DbTable(tableName, primaryKey) {
+function TableClass(tableName, primaryKey) {
   return (table, context) => {
-    Object.defineProperty(table, "name", { value: tableName, writable: false });
     const tableInfo = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
     tableInfo.primaryKey = primaryKey?.toString();
     if (tableInfo.foreignKeys) {
       for (const foreignKey of tableInfo.foreignKeys) {
         foreignKey.fromTable = tableName;
+        if (foreignKey.toTable == table.name)
+          foreignKey.toTable = tableName;
       }
     }
+    Object.defineProperty(table, "name", { value: tableName, writable: false });
+  };
+}
+
+// src/lib/tableInfo/decorators/DataType.ts
+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;
   };
 }
 
 // src/lib/tableInfo/decorators/ForeignKey.ts
 import "polyfill-symbol-metadata";
-function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
+function ForeignKey(toTable, toColumn, options) {
   return (table, context) => {
     const metadata = context?.metadata ? getTableInfoFromMetadata(context.metadata) : getTableInfo(table);
     if (!metadata.foreignKeys)
@@ -743,8 +815,8 @@ function ForeignKey(toTable, toColumn, onDelete, onUpdate) {
       //to stay compatible with old decorator structure (see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-5-2.html#decorator-metadata)
       toTable: toTable.name,
       toColumn: toColumn.toString(),
-      onDelete,
-      onUpdate
+      onDelete: options?.onDelete,
+      onUpdate: options?.onUpdate
     });
   };
 }
@@ -757,32 +829,108 @@ var DefaultSql = class {
   canAlterPrimaryKey = false;
   canInspectForeignKeys = false;
   canInspectPrimaryKey = false;
-  typeString = "TEXT";
-  typeInt = "INTEGER";
-  typeBigInt = "BIGINT";
-  typeBoolean = "BOOLEAN";
-  typeNull = "NULL";
+  types = {
+    string: "TEXT",
+    number: "INTEGER",
+    bigint: "BIGINT",
+    boolean: "BOOLEAN",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME",
+    null: "NULL"
+  };
   constructor(db) {
     this.db = db;
   }
-  formatValueToSql(value) {
-    return value.toString();
+  /**
+   * 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
+   * @return A string representation of the value formatted for SQL.
+   */
+  formatValueToSql(value, type) {
+    function toDate(value2) {
+      return value2 instanceof Date ? value2 : new Date(value2);
+    }
+    switch (type) {
+      case "string":
+        return `"${value}"`;
+      case "time":
+        return toDate(value).toISOString().slice(11, 19);
+      case "date":
+        return toDate(value).toISOString().slice(0, 10);
+      case "dateTime":
+        return toDate(value).toISOString().slice(0, 19).replace("T", " ");
+      default:
+        return value.toString();
+    }
   }
+  /**
+   * Query 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
+   */
   changeForeignKeysState(enabled) {
     return "";
   }
+  /**
+   * Query 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.
+   */
   addForeignKey(fromTableName, foreignKey) {
     throw new Error("Adding foreign keys is not supported!");
   }
+  /**
+   * Query 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.
+   */
   removeForeignKey(tableName, foreignKeyName) {
     throw new Error("Foreign key removal is not supported!");
   }
+  /**
+   * Query 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.
+   */
   addPrimaryKey(tableName, columnName) {
     throw new Error("Adding foreign keys is not supported!");
   }
+  /**
+   * Query 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.
+   */
   removePrimaryKey(tableName, columnName) {
     throw new Error("Foreign key removal is not supported!");
   }
+  /**
+   * Constructs a SQL FOREIGN KEY constraint clause.
+   * Used in combination with {@link addForeignKey} or {@link createTable}
+   *
+   * @param column - The name of the column in the current table to apply the foreign key constraint.
+   * @param foreignTable - The name of the referenced table.
+   * @param foreignColumn - The name of the referenced column in the foreign table.
+   * @param onUpdate - Optional action to specify the behavior on update (e.g., CASCADE, SET NULL).
+   * @param onDelete - Optional action to specify the behavior on delete (e.g., CASCADE, SET NULL).
+   * @return The SQL string representing the foreign key constraint.
+   */
   foreignKey(column, foreignTable, foreignColumn, onUpdate, onDelete) {
     let query = `FOREIGN KEY (${column}) REFERENCES ${foreignTable} (${foreignColumn})`;
     if (onUpdate)
@@ -832,7 +980,7 @@ var DefaultSql = class {
   }
   migrationTableQuery() {
     return this.createTable(MIGRATION_DATA_TABLE_NAME, [
-      this.columnDefinition("version", this.typeInt, "0", false)
+      this.columnDefinition("version", this.types.number, "0", false)
     ]);
   }
   async getForeignKeys(tableName) {
@@ -861,8 +1009,16 @@ UPDATE ${MIGRATION_DATA_TABLE_NAME} SET version = ${newVersion} WHERE EXISTS (SE
 
 // src/lib/dialects/SqliteDialect.ts
 var SqliteDialect = class extends DefaultSql {
-  typeBoolean = "INTEGER";
-  typeBigInt = "INTEGER";
+  types = {
+    string: "TEXT",
+    number: "INTEGER",
+    bigint: "INTEGER",
+    boolean: "INTEGER",
+    date: "DATE",
+    time: "TIME",
+    dateTime: "DATETIME",
+    null: "NULL"
+  };
   canAlterForeignKeys = false;
   canAlterPrimaryKey = false;
   canInspectForeignKeys = true;
@@ -884,12 +1040,19 @@ var SqliteDialect = class extends DefaultSql {
       };
     });
   }
-  formatValueToSql(value) {
-    switch (typeof value) {
+  formatValueToSql(value, type) {
+    function toDate(value2) {
+      return value2 instanceof Date ? value2 : new Date(value2);
+    }
+    switch (type) {
       case "boolean":
         return value ? "1" : "0";
+      case "date":
+      case "time":
+      case "dateTime":
+        return toDate(value).getTime().toString();
       default:
-        return value.toString();
+        return super.formatValueToSql(value, type);
     }
   }
   async getForeignKeys(tableName) {
@@ -1126,8 +1289,10 @@ async function rollback(db, dbInstructions, toVersion) {
   await dialect.setVersion(toVersion);
 }
 export {
-  DbTable,
+  DataType,
   ForeignKey,
+  TableClass,
+  TableObj,
   prepareAndRunMigration,
   prepareMigration,
   rollback,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sqlmorpheus",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "author": "JodliDev",
   "keywords": [],
   "license": "MIT",