@coderich/autograph 0.13.44 → 0.13.46

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.44",
+  "version": "0.13.46",
   "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/QueryResolver.js

@@ -60,7 +60,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);
         });
@@ -109,17 +109,17 @@ module.exports = class QueryResolver extends QueryBuilder {
     const { id } = query.toObject();
     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 = { [$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 });
+      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,17 @@ 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);
+                    if (curr.isArray) path.push(i);
+                    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) => {
@@ -443,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;
@@ -507,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
@@ -887,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: [] });
+
+    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;
+  }
 
-      // 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}`);
-    }, []);
+  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);
   }
 };