mythix-orm 1.0.1

package/lib/connection/index.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const Literals            = require('./literals');
+const QueryGeneratorBase  = require('./query-generator-base');
+const ConnectionBase      = require('./connection-base');
+
+module.exports = {
+  ConnectionBase,
+  Literals,
+  QueryGeneratorBase,
+};

package/lib/connection/literals/average-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class AverageLiteral extends LiteralFieldBase {
+  toString(connection) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this);
+  }
+}
+
+module.exports = AverageLiteral;

package/lib/connection/literals/count-literal.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class CountLiteral extends LiteralFieldBase {
+  static isFieldRequired() {
+    return false;
+  }
+
+  toString(connection) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this);
+  }
+}
+
+module.exports = CountLiteral;

package/lib/connection/literals/distinct-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class DistinctLiteral extends LiteralFieldBase {
+  toString(connection) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this);
+  }
+}
+
+module.exports = DistinctLiteral;

package/lib/connection/literals/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const LiteralBase      = require('./literal-base');
+const LiteralFieldBase = require('./literal-field-base');
+const Literal          = require('./literal');
+const AverageLiteral   = require('./average-literal');
+const CountLiteral     = require('./count-literal');
+const MaxLiteral       = require('./max-literal');
+const MinLiteral       = require('./min-literal');
+const DistinctLiteral  = require('./distinct-literal');
+const SumLiteral       = require('./sum-literal');
+
+module.exports = {
+  LiteralBase,
+  LiteralFieldBase,
+  Literal,
+  AverageLiteral,
+  CountLiteral,
+  MaxLiteral,
+  MinLiteral,
+  DistinctLiteral,
+  SumLiteral,
+};

package/lib/connection/literals/literal-base.js

@@ -0,0 +1,62 @@
+'use strict';
+
+const ModelUtils = require('../../utils/model-utils');
+
+class LiteralBase {
+  constructor(literal, options) {
+    Object.defineProperties(this, {
+      'literal': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        literal,
+      },
+      'options': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        options || {},
+      },
+    });
+  }
+
+  fullyQualifiedNameToDefinition(fullyQualifiedName) {
+    if (fullyQualifiedName instanceof LiteralBase)
+      return fullyQualifiedName;
+
+    if (!fullyQualifiedName)
+      throw new TypeError(`${this.constructor.name}::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "${fullyQualifiedName}".`);
+
+    let definition;
+    if (fullyQualifiedName.Model && fullyQualifiedName.fieldName) {
+      definition = {
+        modelName:  fullyQualifiedName.Model.getModelName(),
+        fieldNames: [ fullyQualifiedName.fieldName ],
+      };
+    } else {
+      definition = ModelUtils.parseQualifiedName(fullyQualifiedName);
+    }
+
+    if (!definition || !definition.modelName || !definition.fieldNames.length)
+      throw new TypeError(`${this.constructor.name}::fullyQualifiedNameToDefinition: Unable to find field for fully qualified name "${fullyQualifiedName}".`);
+
+    return definition;
+  }
+
+  definitionToField(connection, definition) {
+    if (definition instanceof LiteralBase)
+      return definition;
+
+    let field = connection.getField(definition.fieldNames[0], definition.modelName);
+    if (!field)
+      throw new Error(`${this.constructor.name}::definitionToField: Unable to locate field "${definition.modelName}"."${definition.fieldNames[0]}".`);
+
+    return field;
+  }
+
+  toString() {
+    return this.literal;
+  }
+}
+
+module.exports = LiteralBase;

package/lib/connection/literals/literal-field-base.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const Nife        = require('nife');
+const LiteralBase = require('./literal-base');
+
+class LiteralFieldBase extends LiteralBase {
+  static isFieldRequired() {
+    return true;
+  }
+
+  constructor(fullyQualifiedName) {
+    super();
+
+    let isRequired = this.constructor.isFieldRequired();
+    let definition;
+
+    if (isRequired || fullyQualifiedName) {
+      try {
+        definition = this.fullyQualifiedNameToDefinition(fullyQualifiedName);
+      } catch (error) {
+        if (isRequired)
+          throw error;
+      }
+    }
+
+    Object.defineProperties(this, {
+      'definition': {
+        writable:     true,
+        enumberable:  false,
+        configurable: true,
+        value:        definition,
+      },
+    });
+  }
+
+  getFullyQualifiedFieldName() {
+    let definition = this.definition || {};
+    if (!definition.modelName || Nife.isEmpty(definition.fieldNames))
+      return;
+
+    return `${definition.modelName}:${definition.fieldNames[0]}`;
+  }
+}
+
+module.exports = LiteralFieldBase;

package/lib/connection/literals/literal.js

@@ -0,0 +1,11 @@
+'use strict';
+
+const LiteralBase  = require('./literal-base');
+
+class Literal extends LiteralBase {
+  constructor(literal, options) {
+    super(literal, options);
+  }
+}
+
+module.exports = Literal;

package/lib/connection/literals/max-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class MaxLiteral extends LiteralFieldBase {
+  toString(connection) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this);
+  }
+}
+
+module.exports = MaxLiteral;

package/lib/connection/literals/min-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class MinLiteral extends LiteralFieldBase {
+  toString(connection) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this);
+  }
+}
+
+module.exports = MinLiteral;

package/lib/connection/literals/sum-literal.js

@@ -0,0 +1,14 @@
+'use strict';
+
+const LiteralFieldBase = require('./literal-field-base');
+
+class SumLiteral extends LiteralFieldBase {
+  toString(connection) {
+    if (!connection)
+      return `${this.constructor.name} {}`;
+
+    return connection.literalToString(this);
+  }
+}
+
+module.exports = SumLiteral;