@coderich/autograph 0.13.107 → 0.13.109

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.107",
+  "version": "0.13.109",
   "publishConfig": {
     "access": "public"
   },

package/src/query/QueryResolver.js

@@ -67,13 +67,11 @@ module.exports = class QueryResolver extends QueryBuilder {
       }
       case 'pullOne': {
         return this.#get(query).then((doc) => {
-          const [key] = Object.keys(input);
-          const $query = Object.assign(query.toObject(), { doc });
-          const args = { query: $query, resolver: this.#resolver, context: this.#context };
-          const values = get(this.#model.transformers.create.transform(input, args), key, []);
-          const $doc = Util.pathmap(key, doc, (arr) => {
-            if (arr == null) return arr;
-            return arr.filter(el => values.every(v => `${v}` !== `${el}`));
+          const [[path, inputs]] = Object.entries(input);
+          const [key] = path.split('.');
+          const $doc = Util.pathmap(path, doc, (mixed) => { // Pathmap because nested arrays
+            if (mixed == null) return mixed;
+            return mixed.filter(el => inputs.every(v => `${v}` !== `${el}`));
           });
           return this.#resolver.match(this.#model.name).id(doc.id).save({ [key]: get($doc, key) });
         });
@@ -86,12 +84,21 @@ module.exports = class QueryResolver extends QueryBuilder {
       }
       case 'spliceOne': {
         return this.#get(query).then((doc) => {
-          const [key] = Object.keys(input);
-          const $query = Object.assign(query.toObject(), { doc });
-          const args = { query: $query, resolver: this.#resolver, context: this.#context };
-          const [find, replace] = get(this.#model.transformers.create.transform(input, args), key);
-          const $input = { [key]: (get(doc, key) || []).map(el => (`${el}` === `${find}` ? replace : el)) };
-          return this.#resolver.match(this.#model.name).id(doc.id).save($input);
+          const [[path, [find, replace]]] = Object.entries(input);
+          const [key] = path.split('.');
+          const $doc = Util.pathmap(path, doc, (mixed) => { // Pathmap because nested arrays
+            if (mixed == null) return mixed;
+            if (Array.isArray(mixed)) return mixed.map(el => (`${el}` === `${find}` ? replace : el));
+            if (`${mixed}` === `${find}`) return replace;
+            return mixed;
+          });
+          return this.#resolver.match(this.#model.name).id(doc.id).save({ [key]: get($doc, key) });
+        });
+      }
+      case 'spliceMany': {
+        const [[key, values]] = Object.entries(input);
+        return this.#find(query).then((docs) => {
+          return Promise.all(docs.map(doc => this.#resolver.match(this.#model.name).id(doc.id).splice(key, ...values)));
         });
       }
       case 'deleteOne': {
@@ -123,15 +130,15 @@ module.exports = class QueryResolver extends QueryBuilder {
   #resolveReferentialIntegrity(doc) {
     const txn = this.#resolver;
 
-    return Util.promiseChain(this.#model.referentialIntegrity.map(({ model, field, path }) => () => {
-      const { onDelete, isArray, fkField } = field;
+    return Util.promiseChain(this.#model.referentialIntegrity.map(({ model, field, isArray, path }) => () => {
+      const { onDelete, fkField } = field;
       const id = doc[fkField];
       const $path = path.join('.');
       const where = field.isVirtual ? { [field.model.pkField]: get(doc, field.linkBy) } : { [$path]: id };
 
       switch (onDelete) {
         case 'cascade': return isArray ? txn.match(model).where(where).pull($path, id) : txn.match(model).where(where).remove();
-        case 'nullify': return txn.match(model).where(where).save({ [$path]: null });
+        case 'nullify': return isArray ? txn.match(model).where(where).splice($path, id, null) : txn.match(model).where(where).save({ [$path]: null });
         case 'restrict': return txn.match(model).where(where).count().then(count => (count ? Promise.reject(new Error('Restricted')) : count));
         default: throw new Error(`Unknown onDelete operator: '${onDelete}'`);
       }

package/src/schema/Schema.js

@@ -205,6 +205,7 @@ module.exports = class Schema {
           target.directives[name] = target.directives[name] || {};
 
           if (name === directives.model) {
+            model.isEntity = true;
             model.isMarkedModel = true;
             model.isEmbedded = false;
           } else if (name === directives.index) {
@@ -234,6 +235,7 @@ module.exports = class Schema {
               }
               case `${directives.model}-embed`: {
                 model.isEmbedded = value;
+                model.isEntity = !value;
                 break;
               }
               // Field specific directives
@@ -312,8 +314,6 @@ module.exports = class Schema {
 
           // Model resolution after field resolution (push)
           thunks.push(($schema) => {
-            $model.isEntity = Boolean($model.isMarkedModel && !$model.isEmbedded);
-
             $model.resolvePath = (path, prop = 'name') => this.#schema.resolvePath(`${$model[prop]}.${path}`, prop);
 
             $model.isJoinPath = (path, prop = 'name') => {
@@ -640,17 +640,17 @@ module.exports = class Schema {
   }
 
   #findModelPathsToField(model, field) {
-    if (!model.isEmbedded) return [{ model, field, path: [`${field}`] }];
+    if (!model.isEmbedded) return [{ model, field, path: [`${field}`], isArray: field.isArray }];
 
     const arr = [];
 
-    Object.values(this.#schema.models).forEach((m) => {
+    Object.values(this.#schema.models).filter(m => m.isEntity).forEach((m) => {
       Util.traverse(Object.values(m.fields), (f, info) => {
         const path = info.path.concat(f.name);
-        if (f.isEmbedded) return { value: Object.values(f.model.fields), info: { path } };
-        if (f.type === model.name) arr.push({ model: m, field, path: path.concat(`${field}`) });
+        if (f.type === model.name) arr.push({ model: m, field, path: path.concat(`${field}`), isArray: info.isArray || field.isArray || f.isArray });
+        else if (f.isEmbedded) return { value: Object.values(f.model.fields), info: { path, isArray: info.isArray || f.isArray } };
         return null;
-      }, { path: [] });
+      }, { path: [], isArray: false });
     });
 
     return arr;