@abedmurrar/objection 4.0.0-beta.4 → 4.0.0-beta.6

package/lib/queryBuilder/graph/patch/GraphPatchAction.js

@@ -1,10 +1,45 @@
-'use strict';
-const { getModel } = require('../../../model/getModel');
-const { GraphAction } = require('../GraphAction');
-const { isInternalProp } = require('../../../utils/internalPropUtils');
-const { difference, isObject, jsonEquals } = require('../../../utils/objectUtils');
-const promiseUtils = require('../../../utils/promiseUtils');
-class GraphPatchAction extends GraphAction {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphPatchAction = void 0;
+const getModel_1 = require("../../../model/getModel");
+const GraphAction_1 = require("../GraphAction");
+const internalPropUtils_1 = require("../../../utils/internalPropUtils");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
+class GraphPatchAction extends GraphAction_1.GraphAction {
     constructor(graphData, { nodes }) {
         super(graphData);
         // Nodes to patch.
@@ -27,7 +62,7 @@ class GraphPatchAction extends GraphAction {
         const handleUpdate = () => {
             const { changedProps, unchangedProps } = this._findChanges(node);
             const allProps = [...changedProps, ...unchangedProps];
-            const propsToUpdate = difference(shouldPatch || shouldUpdate
+            const propsToUpdate = (0, objectUtils_1.difference)(shouldPatch || shouldUpdate
                 ? changedProps
                 : [...changedPropsBecauseOfBelongsToOneInsert, ...changePropsBecauseOfBelongsToOneDelete], 
             // Remove id properties from the props to update. With upsertGraph
@@ -36,12 +71,12 @@ class GraphPatchAction extends GraphAction {
             const update = propsToUpdate.length > 0;
             if (update) {
                 // Don't update the fields that we know not to change.
-                node.obj.$omitFromDatabaseJson(difference(allProps, propsToUpdate));
+                node.obj.$omitFromDatabaseJson((0, objectUtils_1.difference)(allProps, propsToUpdate));
                 node.userData.updated = true;
             }
             return update;
         };
-        const Model = getModel();
+        const Model = (0, getModel_1.getModel)();
         // See if the model defines a beforeUpdate or $beforeUpdate hook. If it does
         // not, we can check for updated properties now and drop out immediately if
         // there is nothing to update. Otherwise, we need to wait for the hook to be
@@ -62,7 +97,7 @@ class GraphPatchAction extends GraphAction {
         });
         const updateBuilder = this._createBuilder(node)
             .childQueryOf(builder, childQueryOptions())
-            .copyFrom(builder, GraphAction.ReturningAllSelector);
+            .copyFrom(builder, GraphAction_1.GraphAction.ReturningAllSelector);
         if (hasBeforeUpdate) {
             updateBuilder.internalContext().runBefore.push((result, builder) => {
                 // Call handleUpdate in the runBefore hook which runs after the
@@ -81,7 +116,7 @@ class GraphPatchAction extends GraphAction {
             updateBuilder.update(node.obj);
         }
         return updateBuilder.execute().then((result) => {
-            if (isObject(result) && result.$isObjectionModel) {
+            if ((0, objectUtils_1.isObject)(result) && result.$isObjectionModel) {
                 // Handle returning('*').
                 node.obj.$set(result);
             }
@@ -140,7 +175,7 @@ class GraphPatchAction extends GraphAction {
         const unchangedProps = [];
         const changedProps = [];
         for (const prop of Object.keys(obj)) {
-            if (isInternalProp(prop) || relationNames.includes(prop)) {
+            if ((0, internalPropUtils_1.isInternalProp)(prop) || relationNames.includes(prop)) {
                 continue;
             }
             const value = obj[prop];
@@ -178,8 +213,8 @@ class GraphPatchAction extends GraphAction {
         }
     }
     _createRelatedBuilder(node) {
-        return node.parentNode.obj
-            .$relatedQuery(node.parentEdge.relation.name)
+        return node
+            .parentNode.obj.$relatedQuery(node.parentEdge.relation.name)
             .findById(node.obj.$id());
     }
     _createRootBuilder(node) {
@@ -188,6 +223,7 @@ class GraphPatchAction extends GraphAction {
         return currentObj ? currentObj.$query() : node.obj.$query();
     }
 }
+exports.GraphPatchAction = GraphPatchAction;
 function childQueryOptions() {
     return {
         fork: true,
@@ -198,8 +234,5 @@ function nonStrictEquals(val1, val2) {
     if (val1 == val2) {
         return true;
     }
-    return jsonEquals(val1, val2);
+    return (0, objectUtils_1.jsonEquals)(val1, val2);
 }
-module.exports = {
-    GraphPatchAction,
-};

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsert.js

@@ -1,10 +1,12 @@
-'use strict';
-const { GraphOperation } = require('../GraphOperation');
-const { GraphRecursiveUpsertAction } = require('./GraphRecursiveUpsertAction');
-class GraphRecursiveUpsert extends GraphOperation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRecursiveUpsert = void 0;
+const GraphOperation_1 = require("../GraphOperation");
+const GraphRecursiveUpsertAction_1 = require("./GraphRecursiveUpsertAction");
+class GraphRecursiveUpsert extends GraphOperation_1.GraphOperation {
     createActions() {
         return [
-            new GraphRecursiveUpsertAction(this.graphData, {
+            new GraphRecursiveUpsertAction_1.GraphRecursiveUpsertAction(this.graphData, {
                 nodes: this.graph.nodes.filter((node) => {
                     const shouldRelate = this.graphOptions.shouldRelate(node, this.graphData);
                     return shouldRelate && hasRelations(node.obj);
@@ -13,6 +15,7 @@ class GraphRecursiveUpsert extends GraphOperation {
         ];
     }
 }
+exports.GraphRecursiveUpsert = GraphRecursiveUpsert;
 function hasRelations(obj) {
     for (const relationName of obj.constructor.getRelationNames()) {
         if (obj[relationName] !== undefined) {
@@ -21,6 +24,3 @@ function hasRelations(obj) {
     }
     return false;
 }
-module.exports = {
-    GraphRecursiveUpsert,
-};

package/lib/queryBuilder/graph/recursiveUpsert/GraphRecursiveUpsertAction.js

@@ -1,9 +1,44 @@
-'use strict';
-const { GraphAction } = require('../GraphAction');
-const { groupBy, get, set } = require('../../../utils/objectUtils');
-const { forEachPropertyReference } = require('../../../model/graph/ModelGraphBuilder');
-const promiseUtils = require('../../../utils/promiseUtils');
-class GraphRecursiveUpsertAction extends GraphAction {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GraphRecursiveUpsertAction = void 0;
+const GraphAction_1 = require("../GraphAction");
+const objectUtils_1 = require("../../../utils/objectUtils");
+const ModelGraphBuilder_1 = require("../../../model/graph/ModelGraphBuilder");
+const promiseUtils = __importStar(require("../../../utils/promiseUtils"));
+class GraphRecursiveUpsertAction extends GraphAction_1.GraphAction {
     constructor(graphData, { nodes }) {
         super(graphData);
         // Nodes to upsert.
@@ -16,10 +51,10 @@ class GraphRecursiveUpsertAction extends GraphAction {
         });
     }
     _createUpsertBuilders(parentBuilder, nodesToUpsert) {
-        const nodesByRelation = groupBy(nodesToUpsert, getRelation);
+        const nodesByRelation = (0, objectUtils_1.groupBy)(nodesToUpsert, getRelation);
         const builders = [];
         nodesByRelation.forEach((nodes) => {
-            const nodesByParent = groupBy(nodes, getParent);
+            const nodesByParent = (0, objectUtils_1.groupBy)(nodes, getParent);
             nodesByParent.forEach((nodes) => {
                 for (const node of nodes) {
                     this._resolveReferences(node);
@@ -28,8 +63,10 @@ class GraphRecursiveUpsertAction extends GraphAction {
                 builders.push(nodes[0].modelClass
                     .query()
                     .childQueryOf(parentBuilder)
-                    .copyFrom(parentBuilder, GraphAction.ReturningAllSelector)
-                    .upsertGraph(nodes.map((node) => node.obj), this.graphOptions.rebasedOptions(nodes[0])));
+                    .copyFrom(parentBuilder, GraphAction_1.GraphAction.ReturningAllSelector)
+                    .upsertGraph(nodes.map((node) => node.obj), 
+                // `GraphOptions` also takes a `GraphOptions` as its options.
+                this.graphOptions.rebasedOptions(nodes[0])));
             });
         });
         return builders;
@@ -69,28 +106,27 @@ class GraphRecursiveUpsertAction extends GraphAction {
         delete obj[modelClass.uidRefProp];
     }
     _resolvePropertyReferences(obj) {
-        forEachPropertyReference(obj, ({ path, refMatch, ref, refPath }) => {
+        (0, ModelGraphBuilder_1.forEachPropertyReference)(obj, ({ path, refMatch, ref, refPath, }) => {
             const referencedNode = this.graph.nodes.find((it) => it.uid === ref);
             if (!referencedNode) {
                 return;
             }
-            const referencedValue = get(referencedNode.obj, refPath);
-            const value = get(obj, path);
+            const referencedValue = (0, objectUtils_1.get)(referencedNode.obj, refPath);
+            const value = (0, objectUtils_1.get)(obj, path);
             if (value === refMatch) {
-                set(obj, path, referencedValue);
+                (0, objectUtils_1.set)(obj, path, referencedValue);
             }
             else {
-                set(obj, path, value.replace(refMatch, referencedValue));
+                // The reference is a part of a string: `replace()` converts the value to a string.
+                (0, objectUtils_1.set)(obj, path, value.replace(refMatch, referencedValue));
             }
         });
     }
 }
+exports.GraphRecursiveUpsertAction = GraphRecursiveUpsertAction;
 function getRelation(node) {
     return node.parentEdge.relation;
 }
 function getParent(node) {
     return node.parentNode;
 }
-module.exports = {
-    GraphRecursiveUpsertAction,
-};

package/lib/queryBuilder/operations/types.js

@@ -1,8 +1,8 @@
 "use strict";
 // Internal types for the query builder operations.
 //
-// The query builder and the model classes are still JavaScript, so these
-// interfaces only describe the parts of them that the operations use. The
+// The model classes are still JavaScript, so these interfaces only describe
+// the parts of them that the operations use. The query builder and the
 // relations are TypeScript, and their types are used here. The public types
 // are the hand-written ones in `typings/`.
 Object.defineProperty(exports, "__esModule", { value: true });

package/lib/queryBuilder/transformations/CompositeQueryTransformation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryTransformation } = require('./QueryTransformation');
-class CompositeQueryTransformation extends QueryTransformation {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CompositeQueryTransformation = void 0;
+const QueryTransformation_1 = require("./QueryTransformation");
+class CompositeQueryTransformation extends QueryTransformation_1.QueryTransformation {
     constructor(transformations) {
         super();
         this.transformations = transformations;
@@ -12,6 +14,4 @@ class CompositeQueryTransformation extends QueryTransformation {
         return item;
     }
 }
-module.exports = {
-    CompositeQueryTransformation,
-};
+exports.CompositeQueryTransformation = CompositeQueryTransformation;

package/lib/queryBuilder/transformations/QueryTransformation.js

@@ -1,9 +1,9 @@
-'use strict';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryTransformation = void 0;
 class QueryTransformation {
     onConvertQueryBuilderBase(item, builder) {
         return item;
     }
 }
-module.exports = {
-    QueryTransformation,
-};
+exports.QueryTransformation = QueryTransformation;

package/lib/queryBuilder/transformations/WrapMysqlModifySubqueryTransformation.js

@@ -1,6 +1,8 @@
-'use strict';
-const { QueryTransformation } = require('./QueryTransformation');
-const { isMySql } = require('../../utils/knexUtils');
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrapMysqlModifySubqueryTransformation = void 0;
+const QueryTransformation_1 = require("./QueryTransformation");
+const knexUtils_1 = require("../../utils/knexUtils");
 /**
  * Mysql doesn't allow queries like this:
  *
@@ -13,7 +15,8 @@ const { isMySql } = require('../../utils/knexUtils');
  *
  *   update foo set bar = 1 where id in (select * from (select id from foo))
  */
-class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
+class WrapMysqlModifySubqueryTransformation extends QueryTransformation_1.QueryTransformation {
+    // In a join callback `parentQuery` is a `JoinBuilder`, which the loop below walks past.
     onConvertQueryBuilderBase(query, parentQuery) {
         const knex = parentQuery.unsafeKnex();
         // Cannot detect anything if, for whatever reason, a knex instance
@@ -22,11 +25,12 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
             return query;
         }
         // This transformation only applies to MySQL.
-        if (!isMySql(knex)) {
+        if (!(0, knexUtils_1.isMySql)(knex)) {
             return query;
         }
         // A subquery in a join callback belongs to the query of the join.
         while (parentQuery && typeof parentQuery.isUpdate !== 'function') {
+            // The loop stops at the first parent query that is a `QueryBuilder`.
             parentQuery = parentQuery.parentQuery();
         }
         // This transformation only applies to update and delete queries.
@@ -42,9 +46,11 @@ class WrapMysqlModifySubqueryTransformation extends QueryTransformation {
         return query.modelClass().query().from(query.as('mysql_subquery_fix'));
     }
 }
+exports.WrapMysqlModifySubqueryTransformation = WrapMysqlModifySubqueryTransformation;
 function hasJoinsToTable(query, tableName) {
     let found = false;
     query.forEachOperation(query.constructor.JoinSelector, (op) => {
+        // The join operations are `KnexOperation`s, which have `args`.
         if (op.args[0] === tableName) {
             found = true;
             return false;
@@ -52,6 +58,3 @@ function hasJoinsToTable(query, tableName) {
     });
     return found;
 }
-module.exports = {
-    WrapMysqlModifySubqueryTransformation,
-};

package/lib/queryBuilder/transformations/index.js

@@ -1,9 +1,9 @@
-'use strict';
-const { CompositeQueryTransformation } = require('./CompositeQueryTransformation');
-const { WrapMysqlModifySubqueryTransformation, } = require('./WrapMysqlModifySubqueryTransformation');
-const transformation = new CompositeQueryTransformation([
-    new WrapMysqlModifySubqueryTransformation(),
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformation = void 0;
+const CompositeQueryTransformation_1 = require("./CompositeQueryTransformation");
+const WrapMysqlModifySubqueryTransformation_1 = require("./WrapMysqlModifySubqueryTransformation");
+const transformation = new CompositeQueryTransformation_1.CompositeQueryTransformation([
+    new WrapMysqlModifySubqueryTransformation_1.WrapMysqlModifySubqueryTransformation(),
 ]);
-module.exports = {
-    transformation,
-};
+exports.transformation = transformation;

package/lib/queryBuilder/whereScopes.js

@@ -1,15 +1,10 @@
-'use strict';
-const { isObject, isFunction } = require('../utils/objectUtils');
-const { isKnexRaw } = require('../utils/knexUtils');
-// Where clauses objection adds on its own, like the owner condition of a relation
-// query or the id condition of `$query()`, are tagged with a "where scope". When
-// a query has where clauses from more than one scope, the clauses of each scope
-// are wrapped in parentheses so that an `orWhere` in one scope can't escape the
-// conditions of the others. Without this, `$relatedQuery('pets').where(a).orWhere(b)`
-// would produce `owner and a or b` and match other owners' pets.
-//
-// The scopes are only used when the knex query is built. The operation tree is
-// never modified.
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withWhereScope = withWhereScope;
+exports.effectiveWhereScope = effectiveWhereScope;
+exports.createWhereGrouping = createWhereGrouping;
+const objectUtils_1 = require("../utils/objectUtils");
+const knexUtils_1 = require("../utils/knexUtils");
 const WhereSelector = /^(where|orWhere|andWhere|find\w+)/;
 // Where operations that only ever produce a single predicate or predicates
 // joined with `and`. A scope that only contains these (and no raw arguments)
@@ -63,6 +58,7 @@ function withWhereScope(builder, callback) {
         builder._whereScope = previous;
     }
 }
+// Returns the where scope token, or null.
 function effectiveWhereScope(op) {
     while (op) {
         if (op.whereScope !== null) {
@@ -139,6 +135,7 @@ function buildOperationTree(builder, op, knexBuilder) {
 }
 function hasWhereAncestor(op) {
     for (let parent = op.parentOperation; parent; parent = parent.parentOperation) {
+        // A null name is tested as 'null', as `test()` converts it to a string.
         if (WhereSelector.test(parent.name)) {
             return true;
         }
@@ -159,13 +156,15 @@ function isAndOnlyTree(op) {
     return andOnly;
 }
 function isAndOnly(op) {
-    return AND_ONLY_OPERATIONS.has(op.name) && !containsRaw(op.args);
+    // The operations that convert their arguments for knex have `args`.
+    return (AND_ONLY_OPERATIONS.has(op.name) && !containsRaw(op.args));
 }
+// `value` is a user value of any shape: operation arguments.
 function containsRaw(value) {
     if (Array.isArray(value)) {
         return value.some(containsRaw);
     }
-    else if (!isObject(value)) {
+    else if (!(0, objectUtils_1.isObject)(value)) {
         return false;
     }
     else if (value.isObjectionReferenceBuilder) {
@@ -177,11 +176,11 @@ function containsRaw(value) {
         // so only their arguments can contain anything.
         return containsRaw(value._args);
     }
-    else if (isKnexRaw(value) || isFunction(value.toKnexRaw)) {
+    else if ((0, knexUtils_1.isKnexRaw)(value) || (0, objectUtils_1.isFunction)(value.toKnexRaw)) {
         // Raw sql (and anything that is converted into it) can contain anything.
         return true;
     }
-    else if (value.isObjectionQueryBuilderBase || isFunction(value.toSQL)) {
+    else if (value.isObjectionQueryBuilderBase || (0, objectUtils_1.isFunction)(value.toSQL)) {
         // Subqueries are always wrapped in parentheses.
         return false;
     }
@@ -192,8 +191,3 @@ function containsRaw(value) {
         return false;
     }
 }
-module.exports = {
-    withWhereScope,
-    effectiveWhereScope,
-    createWhereGrouping,
-};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abedmurrar/objection",
-  "version": "4.0.0-beta.4",
+  "version": "4.0.0-beta.6",
   "description": "An SQL-friendly ORM for Node.js. A fork of objection.js with strict TypeScript types and MySQL support.",
   "main": "lib/objection.js",
   "type": "commonjs",