mythix-orm-sql-base 1.5.2 → 1.6.1

package/lib/sql-connection-base.js

@@ -720,6 +720,56 @@ class SQLConnectionBase extends ConnectionBase {
     let count = await this.count(queryEngine, null, options);
     return (count > 0);
   }
+
+  // Alter operations
+
+  async alterTable(Model, newModelAttributes, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStatements   = queryGenerator.generateAlterTableStatement(Model, newModelAttributes, options);
+
+    for (let i = 0, il = sqlStatements.length; i < il; i++) {
+      let sqlStr = sqlStatements[i];
+      await this.query(sqlStr, options);
+    }
+  }
+
+  async dropColumn(Field, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStr          = queryGenerator.generateDropColumnStatement(Field, options);
+    if (sqlStr)
+      await this.query(sqlStr, options);
+  }
+
+  async alterColumn(Field, newFieldAttributes, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStatements   = queryGenerator.generateAlterColumnStatement(Field, newFieldAttributes, options);
+
+    for (let i = 0, il = sqlStatements.length; i < il; i++) {
+      let sqlStr = sqlStatements[i];
+      await this.query(sqlStr, options);
+    }
+  }
+
+  async addColumn(Field, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStr          = queryGenerator.generateAddColumnStatement(Field, options);
+    if (sqlStr)
+      await this.query(sqlStr, options);
+  }
+
+  async addIndex(Model, indexFieldNames, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStr          = queryGenerator.generateCreateIndexStatement(Model, indexFieldNames, options);
+    if (sqlStr)
+      await this.query(sqlStr, options);
+  }
+
+  async dropIndex(Model, indexFieldNames, options) {
+    let queryGenerator  = this.getQueryGenerator();
+    let sqlStr          = queryGenerator.generateDropIndexStatement(Model, indexFieldNames, options);
+    if (sqlStr)
+      await this.query(sqlStr, options);
+  }
 }
 
 module.exports = SQLConnectionBase;

package/lib/sql-query-generator-base.d.ts

@@ -93,15 +93,13 @@ declare class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
   public generateIndexName(
     Model: ModelClass,
-    field: Field,
-    index: string | true,
+    indexFieldNames: Array<string>,
     options?: GenericObject
   ): string;
 
   public generateColumnIndexes(
     Model: ModelClass,
     field: Field,
-    indexes: string | boolean | Array<string | boolean | Array<string>>,
     options?: GenericObject,
   ): Array<string>;
 
@@ -162,6 +160,16 @@ declare class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
   public generateDeleteStatement(Model: ModelClass, queryEngine: QueryEngine, options?: GenericObject): string;
   public generateTruncateTableStatement(Model: ModelClass, options?: GenericObject): string;
+  public generateAlterTableStatement(Model: ModelClass, newModelAttributes, options?: GenericObject): string;
+  public generateDropColumnStatement(field: Field, options?: GenericObject): string;
+  public generateAlterColumnRenameStatement(field: Field, newField: Field, options?: GenericObject): string;
+  public generateAlterColumnSetOrDropNullConstraintStatement(field: Field, newField: Field, options?: GenericObject): string;
+  public generateAlterColumnSetDefaultStatement(field: Field, newField: Field, newDefaultValue: any, options?: GenericObject): string;
+  public generateAlterColumnChangeTypeStatement(field: Field, newField: Field, newFieldType: string, options?: GenericObject): string;
+  public generateAlterColumnChangePrimaryKeyConstraintStatement(field: Field, newField: Field, options?: GenericObject): string;
+  public generateAlterColumnChangeUniqueConstraintStatement(field: Field, newField: Field, options?: GenericObject): string;
+  public generateAlterColumnStatements(field: Field, newFieldAttributes: GenericObject, options?: GenericObject): Array<string>;
+  public generateAddColumnStatement(field: Field, options?: GenericObject): string;
 
   public _collectRemoteReturningFields(Model: ModelClass): Array<string>;
   public _collectReturningFields(

package/lib/sql-query-generator-base.js

@@ -7,6 +7,7 @@ const {
   Utils,
   Literals,
   Model: ModelBase,
+  Field,
   QueryGeneratorBase,
 } = require('mythix-orm');
 
@@ -216,7 +217,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       // If no values left in array, then
       // skip condition altogether
       if (Nife.isEmpty(arrayValues))
-        return '';
+        throw new Error(`${this.constructor.name}::generateSelectQueryCondition: Array value provided to "${field.fieldName}.${operator}" can not be empty.`);
 
       // Otherwise, fall-through
       value = arrayValues;
@@ -664,31 +665,36 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
   }
 
   // eslint-disable-next-line no-unused-vars
-  generateIndexName(Model, field, index, options) {
-    if (!index)
-      return '';
+  generateIndexName(Model, _indexFieldNames, options) {
+    let indexFieldNames = Nife.toArray(_indexFieldNames).filter((index) => {
+      return (Nife.instanceOf(index, 'string') && Nife.isNotEmpty(index));
+    });
 
-    let tableName = Model.getTableName(this.connection);
-    if (index === true)
-      return this.escapeID(`idx_${tableName}_${field.columnName}`.replace(/\W+/g, '_'));
+    if (indexFieldNames.length === 0)
+      return '';
 
-    let fieldNames = [];
-    for (let i = 0, il = index.length; i < il; i++) {
-      let indexFieldName  = index[i];
-      let indexField      = Model.getField(indexFieldName);
-      if (!indexField)
-        throw new Error(`${this.constructor.name}::generateIndexName: Unable to find field named "${indexFieldName}".`);
+    let tableName   = Model.getTableName(this.connection);
+    let columnNames = indexFieldNames.map((fieldName) => {
+      let field = Model.getField(fieldName);
+      if (!field)
+        throw new Error(`${this.constructor.name}::generateIndexName: Unable to find field named "${fieldName}".`);
 
-      fieldNames.push(indexField.columnName);
-    }
+      return field.columnName;
+    });
 
-    return this.escapeID(`idx_${tableName}_${fieldNames.sort().join('_')}`);
+    return this.escapeID(`idx_${tableName}_${columnNames.sort().join('_')}`);
   }
 
-  generateColumnIndexes(Model, field, _indexes, _options) {
-    let indexes = Nife.toArray(_indexes).filter(Boolean);
-    if (Nife.isEmpty(indexes))
-      return [];
+  generateCreateIndexStatement(Model, _indexFieldNames, _options) {
+    let indexFieldNames = Nife.toArray(_indexFieldNames).filter((fieldName) => {
+      if (Nife.isEmpty(fieldName))
+        return false;
+
+      return Nife.instanceOf(fieldName, 'string');
+    });
+
+    if (Nife.isEmpty(indexFieldNames))
+      return '';
 
     let options           = _options || {};
     let escapedTableName  = this.getEscapedTableName(Model, options);
@@ -702,20 +708,69 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     flags = flags.join(' ');
 
-    return indexes.map((indexNames) => {
-      let indexName = this.generateIndexName(Model, field, indexNames, options);
-      if (indexNames === true)
-        return `CREATE INDEX ${flags} ${indexName} ON ${escapedTableName} (${this.escapeID(field.columnName)});`;
+    let indexName           = this.generateIndexName(Model, indexFieldNames, options);
+    let escapedColumnNames  = indexFieldNames.map((fieldName) => {
+      let thisField = Model.getField(fieldName);
+      if (!thisField)
+        throw new Error(`${this.constructor.name}::generateCreateIndexStatement: Unable to find field named "${fieldName}".`);
 
-      let escapedColumnNames = [field.fieldName].concat(indexNames).filter(Boolean).map((fieldName) => {
-        let thisField = Model.getField(fieldName);
-        if (!thisField)
-          throw new Error(`${this.constructor.name}::generateColumnIndexes: Unable to find field named "${fieldName}".`);
+      return this.getEscapedColumnName(Model, thisField, { ...options, columnNameOnly: true });
+    });
 
-        return this.getEscapedColumnName(Model, thisField, options);
-      });
+    return `CREATE INDEX${(flags) ? ` ${flags}` : ''} ${indexName} ON ${escapedTableName} (${escapedColumnNames.join(',')})`;
+  }
 
-      return `CREATE INDEX ${indexName} ON ${escapedTableName} (${escapedColumnNames.join(',')});`;
+  generateDropIndexStatement(Model, _indexFieldNames, _options) {
+    let indexFieldNames = Nife.toArray(_indexFieldNames).filter((fieldName) => {
+      if (Nife.isEmpty(fieldName))
+        return false;
+
+      return Nife.instanceOf(fieldName, 'string');
+    });
+
+    if (Nife.isEmpty(indexFieldNames))
+      return '';
+
+    let options   = _options || {};
+    let flags     = [];
+    let postFlags = [];
+
+    if (options.concurrently)
+      flags.push('CONCURRENTLY');
+
+    if (options.ifExists)
+      flags.push('IF EXISTS');
+
+    if (options.cascade !== false)
+      postFlags.push('CASCADE');
+    else
+      postFlags.push('RESTRICT');
+
+    flags = flags.join(' ');
+    postFlags = postFlags.join(' ');
+
+    let indexName = this.generateIndexName(Model, indexFieldNames, options);
+    return `DROP INDEX${(flags) ? ` ${flags}` : ''} ${indexName}${(postFlags) ? ` ${postFlags}` : ''}`;
+  }
+
+  generateColumnIndexes(Model, field, _options) {
+    let indexes = Nife.toArray(field.index).filter((index) => {
+      if (index === true)
+        return true;
+
+      return (Nife.instanceOf(index, 'string', 'array') && Nife.isNotEmpty(index));
+    });
+
+    if (indexes.length === 0)
+      return [];
+
+    let options = _options || {};
+    return indexes.map((indexNames) => {
+      let fieldIndexNames = [ field.fieldName ];
+      if (indexNames !== true)
+        fieldIndexNames = fieldIndexNames.concat(indexNames);
+
+      return this.generateCreateIndexStatement(Model, fieldIndexNames, options);
     });
   }
 
@@ -729,7 +784,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
 
     flags = flags.join(' ');
 
-    return `DROP TABLE ${flags} ${escapedTableName}${(options.cascade === true) ? ' CASCADE' : ''}`;
+    return `DROP TABLE ${flags} ${escapedTableName}${(options.cascade !== false) ? ' CASCADE' : ''}`;
   }
 
   generateForeignKeyConstraint(field, type, options) {
@@ -799,58 +854,57 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
       if (!field.index)
         return;
 
-      let Model   = field.Model;
-      let indexes = Nife.toArray(field.index).filter(Boolean);
-      for (let i = 0, il = indexes.length; i < il; i++) {
-        let index   = indexes[i];
-        let result  = this.generateColumnIndexes(Model, field, index, options);
-        if (Nife.isNotEmpty(result))
-          fieldParts.push(result.join('\n\n'));
-      }
+      let result = this.generateColumnIndexes(Model, field, { ...options, ifNotExists: true });
+      fieldParts = fieldParts.concat(result);
     });
 
-    return fieldParts;
+    return Nife.uniq(fieldParts);
   }
 
-  generateCreateTableStatement(Model, _options) {
-    let options = _options || {};
-    let fieldParts = [];
-
-    Model.iterateFields(({ field, fieldName }) => {
-      if (field.type.isVirtual())
-        return;
+  generateColumnDeclarationStatement(Model, field, _options) {
+    let options         = _options || {};
+    let constraintParts = [];
+    let defaultValue    = this.getFieldDefaultValue(field, field.fieldName, { remoteOnly: true });
 
-      let constraintParts = [];
-      let defaultValue    = this.getFieldDefaultValue(field, fieldName, { remoteOnly: true });
+    if (field.primaryKey) {
+      if (LiteralBase.isLiteral(field.primaryKey))
+        constraintParts.push(field.primaryKey.toString(this.connection));
+      else
+        constraintParts.push('PRIMARY KEY');
 
-      if (field.primaryKey) {
-        if (LiteralBase.isLiteral(field.primaryKey))
-          constraintParts.push(field.primaryKey.toString(this.connection));
+      if (defaultValue !== 'AUTOINCREMENT')
+        constraintParts.push('NOT NULL');
+    } else {
+      if (field.unique) {
+        if (LiteralBase.isLiteral(field.unique))
+          constraintParts.push(field.unique.toString(this.connection));
         else
-          constraintParts.push('PRIMARY KEY');
+          constraintParts.push('UNIQUE');
+      }
 
-        if (defaultValue !== 'AUTOINCREMENT')
-          constraintParts.push('NOT NULL');
-      } else {
-        if (field.unique) {
-          if (LiteralBase.isLiteral(field.unique))
-            constraintParts.push(field.unique.toString(this.connection));
-          else
-            constraintParts.push('UNIQUE');
-        }
+      if (field.allowNull === false)
+        constraintParts.push('NOT NULL');
+    }
 
-        if (field.allowNull === false)
-          constraintParts.push('NOT NULL');
-      }
+    if (defaultValue != null && defaultValue !== '' && !(defaultValue === 'AUTOINCREMENT' && options.noAutoIncrementDefault === true))
+      constraintParts.push(defaultValue);
 
-      if (defaultValue != null && defaultValue !== '')
-        constraintParts.push(defaultValue);
+    constraintParts = constraintParts.join(' ');
+    if (Nife.isNotEmpty(constraintParts))
+      constraintParts = ` ${constraintParts}`;
+
+    return `${this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true })} ${field.type.toConnectionType(this.connection, { ...options, createTable: true, defaultValue })}${constraintParts}`;
+  }
+
+  generateCreateTableStatement(Model, _options) {
+    let options = _options || {};
+    let fieldParts = [];
 
-      constraintParts = constraintParts.join(' ');
-      if (Nife.isNotEmpty(constraintParts))
-        constraintParts = ` ${constraintParts}`;
+    Model.iterateFields(({ field }) => {
+      if (field.type.isVirtual())
+        return;
 
-      fieldParts.push(`  ${this.getEscapedColumnName(Model, field, { columnNameOnly: true })} ${field.type.toConnectionType(this.connection, { createTable: true, defaultValue })}${constraintParts}`);
+      fieldParts.push(`  ${this.generateColumnDeclarationStatement(Model, field, options)}`);
     });
 
     let ifNotExists = '';
@@ -861,7 +915,7 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     if (Nife.isNotEmpty(trailingParts))
       fieldParts = fieldParts.concat(trailingParts.map((part) => `  ${part.trim()}`));
 
-    let finalStatement = `CREATE TABLE ${ifNotExists}${this.getEscapedTableName(Model)} (${fieldParts.join(',\n')}\n);`;
+    let finalStatement = `CREATE TABLE ${ifNotExists}${this.getEscapedTableName(Model)} (\n${fieldParts.join(',\n')}\n)`;
     return finalStatement;
   }
 
@@ -1192,6 +1246,194 @@ class SQLQueryGeneratorBase extends QueryGeneratorBase {
     return `TRUNCATE TABLE ${escapedTableName}`;
   }
 
+  generateAlterTableStatement(Model, newModelAttributes, options) {
+    if (Nife.isEmpty(newModelAttributes))
+      return [];
+
+    let statements = [];
+
+    if (Nife.isNotEmpty(newModelAttributes.tableName)) {
+      let currentTableName = Model.getTableName();
+      if (currentTableName !== newModelAttributes.tableName)
+        statements.push(`ALTER TABLE ${this.getEscapedTableName(Model, options)} RENAME TO ${this.escapeID(newModelAttributes.tableName)}`);
+    }
+
+    return statements;
+  }
+
+  generateDropColumnStatement(field, _options) {
+    let Model   = field.Model;
+    let options = _options || {};
+
+    return `ALTER TABLE ${this.getEscapedTableName(Model, options)} DROP COLUMN${(options.ifExists) ? ' IF EXISTS' : ''} ${this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true })} ${(options.cascade !== false) ? 'CASCADE' : 'RESTRICT'}`;
+  }
+
+  generateAlterColumnRenameStatement(field, newField, _options) {
+    let Model             = field.Model;
+    let options           = _options || {};
+    let prefix            = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+    let escapedColumnName = this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true });
+
+    return `${prefix} RENAME COLUMN ${escapedColumnName} TO ${this.escapeID(newField.columnName)}`;
+  }
+
+  generateAlterColumnSetOrDropNullConstraintStatement(field, newField, _options) {
+    let Model             = field.Model;
+    let options           = _options || {};
+    let prefix            = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+    let escapedColumnName = this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true });
+
+    return `${prefix} ALTER COLUMN ${escapedColumnName} ${(newField.allowNull) ? 'DROP' : 'SET'} NOT NULL`;
+  }
+
+  generateAlterColumnSetDefaultStatement(field, newField, newDefaultValue, _options) {
+    let Model             = field.Model;
+    let options           = _options || {};
+    let prefix            = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+    let escapedColumnName = this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true });
+
+    if (newDefaultValue === undefined)
+      return `${prefix} ALTER COLUMN ${escapedColumnName} DROP DEFAULT`;
+    else
+      return `${prefix} ALTER COLUMN ${escapedColumnName} SET DEFAULT ${newDefaultValue}`;
+  }
+
+  generateAlterColumnChangeTypeStatement(field, newField, newFieldType, _options) {
+    let Model             = field.Model;
+    let options           = _options || {};
+    let prefix            = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+    let escapedColumnName = this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true });
+
+    return `${prefix} ALTER COLUMN ${escapedColumnName} SET DATA TYPE ${newFieldType}`;
+  }
+
+  generateAlterColumnChangePrimaryKeyConstraintStatement(field, newField, _options) {
+    let Model             = field.Model;
+    let options           = _options || {};
+    let prefix            = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+    let escapedColumnName = this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true });
+
+    if (newField.primaryKey)
+      return `${prefix} ALTER COLUMN ${escapedColumnName} ADD CONSTRAINT PRIMARY KEY`;
+    else
+      return `${prefix} ALTER COLUMN ${escapedColumnName} DROP CONSTRAINT PRIMARY KEY`;
+  }
+
+  generateAlterColumnChangeUniqueConstraintStatement(field, newField, _options) {
+    let Model             = field.Model;
+    let options           = _options || {};
+    let prefix            = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+    let escapedColumnName = this.getEscapedColumnName(Model, field, { ...options, columnNameOnly: true });
+
+    if (newField.unique)
+      return `${prefix} ALTER COLUMN ${escapedColumnName} ADD CONSTRAINT UNIQUE`;
+    else
+      return `${prefix} ALTER COLUMN ${escapedColumnName} DROP CONSTRAINT UNIQUE`;
+  }
+
+  generateAlterColumnStatements(field, _newFieldAttributes, _options) {
+    if (Nife.isEmpty(_newFieldAttributes))
+      return [];
+
+    const generateIndexFieldNames = (field) => {
+      let indexes = Nife.toArray(field.index).filter((index) => {
+        if (index === true)
+          return true;
+
+        return (Nife.instanceOf(index, 'string', 'array') && Nife.isNotEmpty(index));
+      });
+
+      if (indexes.length === 0)
+        return {};
+
+      let indexMap = {};
+
+      for (let i = 0, il = indexes.length; i < il; i++) {
+        let indexFieldName  = indexes[i];
+        let fieldNames      = [ field.fieldName ];
+
+        if (indexFieldName !== true)
+          fieldNames = fieldNames.concat(indexFieldName);
+
+        let indexName = this.generateIndexName(Model, fieldNames, options);
+        indexMap[indexName] = fieldNames;
+      }
+
+      return indexMap;
+    };
+
+    const calculateIndexDifferences = () => {
+      let currentColumnIndexes  = generateIndexFieldNames(field);
+      let currentIndexNames     = Object.keys(currentColumnIndexes);
+      let newColumnIndexes      = generateIndexFieldNames(newField);
+      let newIndexNames         = Object.keys(newColumnIndexes);
+
+      let dropIndexes = Nife.arraySubtract(currentIndexNames, newIndexNames);
+      let addIndexes  = Nife.arraySubtract(newIndexNames, currentIndexNames);
+
+      if (addIndexes.length) {
+        for (let i = 0, il = addIndexes.length; i < il; i++) {
+          let indexName       = addIndexes[i];
+          let indexFieldNames = newColumnIndexes[indexName];
+
+          statements.push(this.generateCreateIndexStatement(Model, indexFieldNames, options));
+        }
+      }
+
+      if (dropIndexes.length) {
+        for (let i = 0, il = dropIndexes.length; i < il; i++) {
+          let indexName       = dropIndexes[i];
+          let indexFieldNames = currentColumnIndexes[indexName];
+
+          statements.push(this.generateDropIndexStatement(Model, indexFieldNames, options));
+        }
+      }
+    };
+
+    let newField = (Field.isField(_newFieldAttributes)) ? _newFieldAttributes : new Field({ ...field, ..._newFieldAttributes });
+    newField.setModel(field.Model);
+
+    let Model       = field.Model;
+    let options     = _options || {};
+    let statements  = [];
+
+    if (newField.allowNull !== field.allowNull)
+      statements.push(this.generateAlterColumnSetOrDropNullConstraintStatement(field, newField, options));
+
+    let currentDefaultValue  = this.getFieldDefaultValue(field, field.fieldName, { useDefaultKeyword: false, escape: true, remoteOnly: true });
+    let newDefaultValue      = this.getFieldDefaultValue(newField, newField.fieldName, { useDefaultKeyword: false, escape: true, remoteOnly: true });
+
+    let currentFieldType  = field.type.toConnectionType(this.connection, { createTable: true, defaultValue: currentDefaultValue });
+    let newFieldType      = field.type.toConnectionType(this.connection, { createTable: true, defaultValue: newDefaultValue });
+    if (newFieldType !== currentFieldType)
+      statements.push(this.generateAlterColumnChangeTypeStatement(field, newField, newFieldType, _options));
+
+    if (newDefaultValue !== currentDefaultValue)
+      statements.push(this.generateAlterColumnSetDefaultStatement(field, newField, newDefaultValue, options));
+
+    if (newField.primaryKey !== field.primaryKey)
+      statements.push(this.generateAlterColumnChangePrimaryKeyConstraintStatement(field, newField, options));
+
+    if (newField.unique !== field.unique)
+      statements.push(this.generateAlterColumnChangeUniqueConstraintStatement(field, newField, options));
+
+    if (field.index !== newField.index)
+      calculateIndexDifferences();
+
+    if (newField.columnName !== field.columnName)
+      statements.push(this.generateAlterColumnRenameStatement(field, newField, options));
+
+    return statements.filter(Boolean);
+  }
+
+  generateAddColumnStatement(field, _options) {
+    let Model   = field.Model;
+    let options = _options || {};
+    let prefix  = `ALTER TABLE ${this.getEscapedTableName(Model, options)}`;
+
+    return `${prefix} ADD COLUMN ${this.generateColumnDeclarationStatement(Model, field, options)}`;
+  }
+
   toConnectionString(queryEngine, options) {
     return this.generateSelectStatement(queryEngine, options);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm-sql-base",
-  "version": "1.5.2",
+  "version": "1.6.1",
   "description": "SQL base support for Mythix ORM",
   "main": "lib/index",
   "type": "commonjs",
@@ -33,9 +33,10 @@
   },
   "homepage": "https://github.com/th317erd/mythix-orm-sql-base#readme",
   "peerDependencies": {
-    "mythix-orm": "^1.6.3"
+    "mythix-orm": "^1.7.1"
   },
   "dependencies": {
+    "luxon": "^3.0.4",
     "nife": "^1.12.1",
     "uuid": "^9.0.0"
   },
@@ -44,7 +45,6 @@
     "better-sqlite3": "^7.6.2",
     "eslint": "^8.23.1",
     "jasmine": "^4.4.0",
-    "moment": "^2.29.4",
     "nyc": "^15.1.0"
   },
   "nyc": {