mythix-orm 1.13.2 → 1.14.0

package/README.md

@@ -99,7 +99,7 @@ class User extends Model {
 
 ## Notes
 
-1. The [WIKI](https://github.com/th317erd/mythix-orm/wiki) is still being worked on. Most of the documentation is complete, but there is still a lot more to write. Documentation is the main focus right now. If you have any questions, feel free to drop a line, or open an issue! We will be happy to answer any questions. We aren't "done" until our documentation is pristine.
+1. The [WIKI](https://github.com/th317erd/mythix-orm/wiki) is still being worked on. Most of the documentation is complete, but there is still a lot more to write. Documentation is the main focus right now. If you have any questions, feel free to drop a line, or open an issue! We will be happy to answer any questions. We aren't "done" until our documentation is pristine. Feel free to drop us a line in our [Discord](https://discord.gg/DZsAYvym9N) server if you need assistance.
 2. Right now there are only database drivers for [SQLite](https://www.npmjs.com/package/mythix-orm-sqlite) and [PostgreSQL](https://www.npmjs.com/package/mythix-orm-postgresql). More are planned, with a Mongo driver likely to land next, followed by MySQL. Help wanted!
 3. Check out the [Mythix](https://www.npmjs.com/package/mythix) web-app framework. It is also still in active development, and the documentation is poor (to say the least), but it is up and coming, and will soon have fantastic documentation, and even though still in active development is fully functional. To get started try `npx mythix-cli create 'Test App'`
 

package/lib/connection/connection-base.d.ts

@@ -74,8 +74,6 @@ declare class ConnectionBase extends EventEmitter {
   public constructor(options?: ConnectionBaseOptions);
   public getLockMode(options: string | LockModeOptions): LockMode;
   public getDefaultOrder(Model: ModelClass, options?: GenericObject): Array<string>;
-  public isLimitSupportedInContext(options?: GenericObject): boolean;
-  public isOrderSupportedInContext(options?: GenericObject): boolean | string;
   public _getFromModelCache(Model: ModelClass, key: string, defaultValue?: any): any;
   public _setToModelCache<T>(Model: ModelClass, key: string, value: T): T;
   public getOptions(): ConnectionBaseOptions;

package/lib/connection/connection-base.js

@@ -402,46 +402,6 @@ class ConnectionBase extends EventEmitter {
   getDefaultOrder(Model, options) {
   }
 
-  /// This method is called (and often provided)
-  /// by the underlying database driver to see
-  /// if a `LIMIT` clause is allowed to appear in
-  /// a given context/operation.
-  ///
-  /// Arguments:
-  ///   options: object
-  ///     Driver specific options for the context.
-  ///
-  /// Return: boolean
-  isLimitSupportedInContext(options) {
-    return true;
-  }
-
-  /// This method is called (and often provided)
-  /// by the underlying database driver to see
-  /// if an `ORDER BY` clause is allowed to appear in
-  /// a given context/operation.
-  ///
-  /// Arguments:
-  ///   options: object
-  ///     Driver specific options for the context.
-  ///
-  /// Return: boolean
-  isOrderSupportedInContext(_options) {
-    let options = _options || {};
-    if (options.isSubQuery) {
-      let subQueryOperator = options.subQueryOperator;
-      if (subQueryOperator === 'EXISTS' || subQueryOperator === 'NOT EXISTS')
-        return false;
-
-      if (subQueryOperator === 'ANY' || subQueryOperator === 'ALL')
-        return true;
-
-      return 'PROJECTION_ONLY';
-    }
-
-    return true;
-  }
-
   /// A convenience method to get from "model cache".
   ///
   /// Model Cache is a simple system to cache
@@ -2640,12 +2600,7 @@ class ConnectionBase extends EventEmitter {
   ///     This allows the caller of an operation such as `insert`, or `update` to
   ///     request that specific hooks not be called.
   async runSaveHooks(Model, models, operationHookName, saveHookName, _options) {
-    const throwError = (error) => {
-      throw error;
-    };
-
     let options   = _options || {};
-    let promises  = [];
     let context   = { connection: this, Model, options, self: null };
     let skipHooks = options.skipHooks;
 
@@ -2665,21 +2620,13 @@ class ConnectionBase extends EventEmitter {
     for (let i = 0, il = models.length; i < il; i++) {
       let model         = models[i];
       let modelContext  = { ...context, self: model };
+      let result        = (shouldSkipHook(operationHookName)) ? undefined : model[operationHookName](modelContext);
 
-      let promise = (shouldSkipHook(operationHookName)) ? undefined : model[operationHookName](modelContext);
-      if (!Nife.instanceOf(promise, 'promise'))
-        promise = Promise.resolve(promise);
+      await result;
 
-      if (!shouldSkipHook(saveHookName)) {
-        promise = promise.then(async () => await model[saveHookName](modelContext), throwError);
-        if (!Nife.instanceOf(promise, 'promise'))
-          promise = Promise.resolve(promise);
-      }
-
-      promises.push(promise);
+      if (!shouldSkipHook(saveHookName))
+        await model[saveHookName](modelContext);
     }
-
-    await Promise.all(promises);
   }
 
   /// Drop a table/bucket from the database.

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

@@ -1,5 +1,7 @@
 'use strict';
 
+const Nife = require('nife');
+
 /// The base query generator class.
 ///
 /// A "query generator" is an interface that will take
@@ -339,6 +341,69 @@ class QueryGeneratorBase {
   // eslint-disable-next-line no-unused-vars
   getFieldDefaultValue(field, fieldName, _options) {
   }
+
+  /// Take a <see>Field</see> instance, and generate
+  /// all index fields for this `field`.
+  ///
+  /// The `index` property on a <see>Field</see> is used
+  /// to generate indexes for the field. If a `true` value
+  /// is encountered in the `index`, it means "this field".
+  /// If another field name is encountered in the `index` property,
+  /// then that means "combine this field with the specified field"
+  /// (to create a combined index). Take the following example:
+  /// ```javascript
+  /// ...
+  /// firstName: {
+  ///   ...
+  ///   index: [
+  ///     true,
+  ///     'lastName',
+  ///     [ 'email', 'lastName' ],
+  ///   ]
+  /// }
+  /// ...
+  /// ```
+  /// This will create three indexes for this "firstName" column in the database:
+  /// 1) `true` = Index the `firstName` column by itself (`idx_users_firstName`)
+  /// 2) `lastName` = Combine `firstName` and `lastName` to create a combined index (`idx_users_firstName_lastName`)
+  /// 3) `[ 'email', 'lastName' ]` = Combine `firstName` with `email` and `lastName` to create a combined index involving three columns (`idx_users_firstName_email_lastName`)
+  /// Using the above example, this method would return the following:
+  /// ```javascript
+  /// [
+  ///   [ 'firstName' ],
+  ///   [ 'firstName', 'lastName' ],
+  ///   [ 'firstName', 'email', 'lastName' ],
+  /// ]
+  /// ```
+  /// Which is the list of indexes, and the fields to index for each index.
+  ///
+  /// Arguments:
+  ///   field: <see>Field</see>
+  ///     The field used to pull the `index` property from.
+  ///
+  /// Return: Array<Array<string>>
+  ///   Return an array of arrays, where the top-level array lists the
+  ///   indexes, and each sub-array lists the fields to combine into an
+  ///   index.
+  getIndexFieldsFromFieldIndex(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 [];
+
+    return indexes.map((indexNames) => {
+      let fieldIndexNames = [ field.fieldName ];
+      if (indexNames !== true)
+        fieldIndexNames = fieldIndexNames.concat(indexNames);
+
+      return fieldIndexNames;
+    });
+  }
 }
 
 module.exports = QueryGeneratorBase;

package/lib/model.js

@@ -7,6 +7,7 @@ const DefaultHelpers  = require('./types/helpers/default-helpers');
 const Field           = require('./field');
 const AsyncStore      = require('./utils/async-store');
 const ModelUtils      = require('./utils/model-utils');
+const { LiteralBase } = require('./connection/literals');
 
 /// Used as a unique key for cache.
 /// Caches will generally be stored in
@@ -2188,6 +2189,9 @@ class Model {
     if (!type)
       return value;
 
+    if (LiteralBase.isLiteral(value))
+      return value;
+
     return type.castToType({
       connection: this.getConnection(),
       Model:      this.getModel(),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mythix-orm",
-  "version": "1.13.2",
+  "version": "1.14.0",
   "description": "ORM for Mythix framework",
   "main": "lib/index",
   "type": "commonjs",
@@ -34,18 +34,18 @@
   "homepage": "https://github.com/th317erd/mythix-orm#readme",
   "devDependencies": {
     "@spothero/eslint-plugin-spothero": "github:spothero/eslint-plugin-spothero",
-    "@types/node": "^18.11.9",
-    "better-sqlite3": "^8.0.0",
+    "@types/node": "^18.11.18",
+    "better-sqlite3": "^8.0.1",
     "colors": "^1.4.0",
     "diff": "^5.1.0",
-    "eslint": "^8.28.0",
+    "eslint": "^8.31.0",
     "jasmine": "^4.5.0",
     "nyc": "^15.1.0"
   },
   "dependencies": {
     "events": "^3.3.0",
-    "inflection": "^2.0.0",
-    "luxon": "^3.1.0",
+    "inflection": "^2.0.1",
+    "luxon": "^3.2.1",
     "nife": "^1.12.1",
     "uuid": "^9.0.0",
     "xid-js": "^1.0.1"