@coderich/autograph 0.13.45 → 0.13.47

package/package.json

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

package/src/data/Transformer.js

@@ -1,7 +1,13 @@
 const Util = require('@coderich/util');
 
 module.exports = class Transformer {
-  #config = { shape: {}, defaults: {}, args: {}, strictSchema: false, keepUndefined: false };
+  #config = {
+    args: {}, // Arguments passed to each thunk
+    shape: {}, // The final shape
+    defaults: {}, // Default values applied at beginning of transformation
+    strictSchema: false, // If true, will strip away unknown attributes
+    keepUndefined: false, // If true, will preserve undefined values
+  };
 
   #operation = {
     set: (target, prop, startValue, proxy) => {

package/src/query/QueryBuilder.js

@@ -221,6 +221,7 @@ module.exports = class QueryBuilder {
     const suffix = id || limit === 1 || (crud === 'create' && args.length < 2) ? 'One' : 'Many';
     let input = suffix === 'One' ? args[0] : args;
     if (input === undefined) input = {};
+    input.id = id;
     this.#query.args.input = input;
     return this.terminate(Object.assign(this.#query, {
       op: `${crud}${suffix}`,

package/src/query/QueryResolver.js

@@ -34,6 +34,10 @@ module.exports = class QueryResolver extends QueryBuilder {
       }
       case 'updateOne': {
         return this.#get(query).then((doc) => {
+          // const $input = this.#model.walk(doc, (node) => {
+          //   if (node.field.defaultValue !== undefined || ['instruct', 'restruct', 'serialize'].some(el => node.field.pipelines[el]?.length)) return node;
+          //   return false;
+          // });
           const merged = mergeDeep({}, doc, Util.unflatten(input, { safe: true }));
           return this.#resolver.resolve(query.clone({ doc, input: merged }));
         });
@@ -60,7 +64,7 @@ module.exports = class QueryResolver extends QueryBuilder {
       case 'pullOne': {
         return this.#get(query).then((doc) => {
           const [key] = Object.keys(input);
-          const values = get(this.#model.transformers.input.transform(input), key);
+          const values = get(this.#model.transformers.input.transform(input), key, []);
           const $input = { [key]: (get(doc, key) || []).filter(el => values.every(v => `${v}` !== `${el}`)) };
           return this.#resolver.match(this.#model.name).id(doc.id).save($input);
         });
@@ -81,7 +85,7 @@ module.exports = class QueryResolver extends QueryBuilder {
       }
       case 'deleteOne': {
         return this.#get(query).then((doc) => {
-          return this.#resolveReferentialIntegrity(query).then(() => {
+          return this.#resolveReferentialIntegrity(doc).then(() => {
             return this.#resolver.resolve(query.clone({ doc })).then(() => doc);
           });
         });
@@ -105,21 +109,21 @@ module.exports = class QueryResolver extends QueryBuilder {
     return this.#resolver.resolve(query.clone({ op: 'findMany', key: `find${this.#model.name}`, crud: 'read', isMutation: false }));
   }
 
-  #resolveReferentialIntegrity(query) {
-    const { id } = query.toObject();
+  #resolveReferentialIntegrity(doc) {
+    const { id } = doc;
     const txn = this.#resolver.transaction(false);
 
-    // if (this.#model.name === 'Person') console.log(this.#model.referentialIntegrity);
-    return txn.run(Util.promiseChain(this.#model.referentialIntegrity.map(({ model, field, fieldRef, isArray, op }) => () => {
-      const fieldStr = fieldRef ? `${field}.${fieldRef}` : `${field.name}`;
-      const $where = { [fieldStr]: id };
+    return txn.run(Util.promiseChain(this.#model.referentialIntegrity.map(({ model, field, path }) => () => {
+      const { onDelete, isArray } = field;
+      const $path = path.join('.');
+      const where = field.isVirtual ? { [field.model.pkField]: get(doc, field.linkBy) } : { [$path]: id };
 
-      switch (op) {
-        case 'cascade': return isArray ? txn.match(model).where($where).pull(fieldStr, id) : txn.match(model).where($where).remove();
-        case 'nullify': return txn.match(model).where($where).save({ [fieldStr]: null });
-        case 'restrict': return txn.match(model).where($where).count().then(count => (count ? Promise.reject(new Error('Restricted')) : count));
+      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 '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: '${op}'`);
+        default: throw new Error(`Unknown onDelete operator: '${onDelete}'`);
       }
     })));
   }

package/src/schema/Schema.js

@@ -129,6 +129,7 @@ module.exports = class Schema {
     visit(this.#typeDefs, {
       enter: (node) => {
         const name = node.name?.value;
+
         if (!allowedKinds.includes(node.kind) || operations.includes(name)) return false;
 
         if (modelKinds.includes(node.kind)) {
@@ -424,8 +425,9 @@ module.exports = class Schema {
                   curr.name, // Rename key
                   a => Pipeline.$deserialize({ ...a, ...args, path: a.path.concat(curr.name) }),
                 ];
+
                 if (curr.isArray) rules.unshift(({ value }) => (value == null ? value : Util.ensureArray(value)));
-                // if (curr.isEmbedded) rules.unshift(({ value }) => Util.map(value, v => curr.model.transformers.doc.transform(v)));
+
                 if (curr.isEmbedded) {
                   rules.unshift(a => Util.map(a.value, (value, i) => {
                     const path = a.path.concat(curr.name);
@@ -433,6 +435,7 @@ module.exports = class Schema {
                     return curr.model.transformers.doc.transform(value, { ...args, query: a.query, context: a.context, path });
                   }));
                 }
+
                 return Object.assign(prev, { [curr.key]: rules });
               }, {}),
               defaults: Object.values($model.fields).reduce((prev, curr) => {
@@ -450,6 +453,7 @@ module.exports = class Schema {
 
           // Field resolution comes first (unshift)
           thunks.unshift(($schema) => {
+            $field.parent = $model;
             $field.model = $schema.models[$field.type];
             $field.crud = Util.uvl($field.crud, $field.model?.scope, 'crud');
             $field.linkTo ??= $field.model;
@@ -514,8 +518,12 @@ module.exports = class Schema {
     });
 
     // 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), $model.name);
+      $model.referentialIntegrity = Schema.#identifyOnDeletes(Object.values(this.#schema.models).filter(m => m.isEntity), onDeleteFields.filter(f => `${f.model}` === `${$model}`));
     });
 
     // Helper methods
@@ -894,21 +902,25 @@ module.exports = class Schema {
     `;
   }
 
-  static #identifyOnDeletes(models, parentName) {
-    return models.reduce((prev, model) => {
-      Object.values(model.fields).filter(f => f.onDelete).forEach((field) => {
-        if (`${field.model.name}` === `${parentName}`) {
-          if (model.isEntity) {
-            prev.push({ model, field, isArray: field.isArray, op: field.onDelete });
-          }
-          // else {
-          //   prev.push(...Schema.#identifyOnDeletes(models, model.name).map(od => Object.assign(od, { fieldRef: field.name, isArray: field.isArray, op: field.onDelete })));
-          // }
-        }
-      });
+  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: [] });
 
-      // Assign model referential integrity
-      return Util.filterBy(prev, (a, b) => `${a.model.name}:${a.field.name}:${a.fieldRef}:${a.op}` === `${b.model.name}:${b.field.name}:${b.fieldRef}:${b.op}`);
-    }, []);
+    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);
   }
 };