@coderich/autograph 0.13.106 → 0.13.108

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.106",
+  "version": "0.13.108",
   "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,17 +130,16 @@ 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));
-        case 'defer': return Promise.resolve(); // Used for embedded models (could be improved)
         default: throw new Error(`Unknown onDelete operator: '${onDelete}'`);
       }
     }));

package/src/schema/Schema.js

@@ -142,6 +142,7 @@ module.exports = class Schema {
             crud: 'crud', // For use when creating API Queries and Mutations
             scope: 'crud', // For use when defining types (how it's field.model reference can be used)
             pkField: 'id',
+            isEmbedded: true,
             isPersistable: true,
             source: this.#config.dataSources?.default,
             loader: this.#config.dataLoaders?.default,
@@ -156,6 +157,7 @@ module.exports = class Schema {
             },
             directives: {},
             ignorePaths: [],
+            referentialIntegrity: [],
             toString: () => name,
           };
         }
@@ -202,8 +204,12 @@ module.exports = class Schema {
         } else if (node.kind === Kind.DIRECTIVE) {
           target.directives[name] = target.directives[name] || {};
 
-          if (name === directives.model) model.isMarkedModel = true;
-          else if (name === directives.index) this.#schema.indexes.push({ model });
+          if (name === directives.model) {
+            model.isMarkedModel = true;
+            model.isEmbedded = false;
+          } else if (name === directives.index) {
+            this.#schema.indexes.push({ model });
+          }
 
           node.arguments.forEach((arg) => {
             const key = arg.name.value;
@@ -521,6 +527,9 @@ module.exports = class Schema {
             $field.isScalar = scalars.includes($field.type);
             $field.generator ??= $model.generator;
 
+            // Referential Integrity Setup
+            if ($field.onDelete) $field.model.referentialIntegrity.push(...this.#findModelPathsToField($model, $field));
+
             // Merge Enums and Scalar type definitions
             const enumer = this.#schema.enums[$field.type];
             const scalar = this.#schema.scalars[$field.type];
@@ -573,15 +582,6 @@ module.exports = class Schema {
       return { key, name, type, on };
     });
 
-    // Resolve referential integrity
-    const onDeleteFields = Array.from(new Set(Object.values(this.#schema.models).reduce((prev, curr) => {
-      return prev.concat(Object.values(curr.fields).filter(el => el.onDelete)).flat();
-    }, [])));
-
-    Object.values(this.#schema.models).forEach(($model) => {
-      $model.referentialIntegrity = Schema.#identifyOnDeletes(Object.values(this.#schema.models).filter(m => m.isEntity), onDeleteFields.filter(f => `${f.model}` === `${$model}`));
-    });
-
     // Helper methods
     const resolvePathCache = {};
     this.#schema.resolvePath = (path, prop = 'key') => {
@@ -611,6 +611,8 @@ module.exports = class Schema {
       },
     });
 
+    // console.log(this.#schema.models.Person.referentialIntegrity);
+
     // Return schema
     return this.#schema;
   }
@@ -639,6 +641,23 @@ module.exports = class Schema {
     return this.#config.makeExecutableSchema(this.toObject());
   }
 
+  #findModelPathsToField(model, field) {
+    if (!model.isEmbedded) return [{ model, field, path: [`${field}`], isArray: field.isArray }];
+
+    const arr = [];
+
+    Object.values(this.#schema.models).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, isArray: info.isArray || f.isArray } };
+        if (f.type === model.name) arr.push({ model: m, field, path: path.concat(`${field}`), isArray: info.isArray || field.isArray || f.isArray });
+        return null;
+      }, { path: [], isArray: false });
+    });
+
+    return arr;
+  }
+
   static #resolveNodeValue(node) {
     if (node == null) return node;
 
@@ -661,7 +680,7 @@ module.exports = class Schema {
 
       enum AutoGraphIndexEnum { unique }
       enum AutoGraphAuthzEnum { private protected public } # DELETE WHEN MIGRATED
-      enum AutoGraphOnDeleteEnum { cascade nullify restrict defer }
+      enum AutoGraphOnDeleteEnum { cascade nullify restrict }
       enum AutoGraphPipelineEnum { ${Object.keys(Pipeline).filter(k => !k.startsWith('$')).join(' ')} }
 
       directive @${model}(
@@ -961,26 +980,4 @@ module.exports = class Schema {
       before: String
     `;
   }
-
-  static #findPathToField(model, field, path = []) {
-    const { target, embeds } = Object.values(model.fields).reduce((prev, curr) => {
-      if (curr === field) prev.target = curr;
-      else if (curr.isEmbedded) prev.embeds.push(curr);
-      return prev;
-    }, { embeds: [] });
-
-    if (target) return path.concat(target.name);
-    if (embeds.length) return embeds.map(f => Schema.#findPathToField(f.model, field, path.concat(f.name))).filter(Boolean)[0];
-    return undefined;
-  }
-
-  static #identifyOnDeletes(models, fields) {
-    return models.map((model) => {
-      return fields.map((field) => {
-        const path = Schema.#findPathToField(model, field);
-        if (!path) return null;
-        return { model, field, path };
-      });
-    }).flat().filter(Boolean);
-  }
 };