@coderich/autograph 0.13.39 → 0.13.41

package/package.json

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

package/src/data/DataLoader.js

@@ -32,8 +32,9 @@ module.exports = class Loader {
     const batchesByKey = queries.reduce((prev, query, i) => {
       const $query = query.toDriver().toObject();
       const key = $query.batch ?? '__default__';
-      const [values] = key === '__default__' ? [] : Object.values(Util.flatten($query.where, { safe: true }));
-      const $values = Util.ensureArray(values).map(value => (value instanceof RegExp ? value : new RegExp(`${value}`, 'i')));
+      let [values] = key === '__default__' ? [] : Object.values(Util.flatten($query.where, { safe: true }));
+      values = Array.from(new Set(Util.ensureArray(values)));
+      const $values = values.map(value => (value instanceof RegExp ? value : new RegExp(`${value}`, 'i')));
       prev[key] = prev[key] || [];
       prev[key].push({ query, $query, values, $values, i });
       return prev;
@@ -45,18 +46,32 @@ module.exports = class Loader {
           return batches.map(batch => this.#model.source.client.resolve(batch.$query).then(data => ({ data, ...batch })));
         }
         default: {
+          // Collect all the values for the where clause
           const values = Array.from(new Set(batches.map(batch => batch.values).flat()));
           const $query = { ...batches[0].$query, op: 'findMany', where: { [key]: values } };
+
+          // Collect all the $values (Regular Expressions) to match doc (result) data by
+          const $values = Array.from(new Set(batches.map(batch => batch.$values).flat()));
+          const docsByRegExpKey = $values.reduce((map, re) => map.set(re, []), new Map());
+
+          // Now we perform 1 query, instead of many smaller ones
           return this.#model.source.client.resolve($query).then((docs) => {
-            return batches.map((batch) => {
-              const matches = docs.filter((doc) => {
-                let match = false;
-                Util.pathmap(key, doc, (mixed) => {
-                  match = match || Util.ensureArray(mixed).some(value => batch.$values.some($value => `${value}`.match($value)));
-                  return mixed;
+            // This one-time transformation keys all the docs by $value (regex) match
+            docs.forEach((doc) => {
+              Util.pathmap(key, doc, (value) => {
+                docsByRegExpKey.forEach((set, re) => {
+                  Util.map(value, (v) => {
+                    if (`${v}`.match(re)) {
+                      set.push(doc);
+                    }
+                  });
                 });
-                return match;
+                return value;
               });
+            });
+
+            return batches.map((batch) => {
+              const matches = Array.from(new Set(batch.$values.map(re => docsByRegExpKey.get(re)).flat().filter(v => v !== undefined)));
               const data = batch.$query.op === 'findOne' ? matches[0] : matches;
               return { data, ...batch };
             });

package/src/data/Pipeline.js

@@ -73,17 +73,19 @@ module.exports = class Pipeline {
     }, { ignoreNull: false });
 
     Pipeline.define('$fk', (params) => {
-      const { fkField } = params.field;
-      const v = params.value?.[fkField] || params.value;
+      const { fkField, isPrimaryKey } = params.field;
+      const lookupField = isPrimaryKey ? params.field : fkField;
+      const v = params.value?.[lookupField] || params.value;
       return Util.map(v, value => params.field.generator({ ...params, value }));
     });
 
     //
-    Pipeline.define('$cast', ({ field, value }) => {
-      const { type, isEmbedded } = field;
-      if (isEmbedded) return value;
+    Pipeline.define('$cast', (params) => {
+      const { field, value } = params;
 
-      switch (type.toLowerCase()) {
+      if (field.isEmbedded) return value;
+
+      switch (field.type.toLowerCase()) {
         case 'string': {
           return `${value}`;
         }

package/src/data/Resolver.js

@@ -173,7 +173,7 @@ module.exports = class Resolver {
 
     // All transactions bound to this resolver are to be rolled back
     return Util.promiseChain(session.map(transaction => () => {
-      transaction.rollback().catch(e => errors.push(e));
+      return transaction.rollback().catch(e => errors.push(e));
     })).then(() => {
       return errors.length ? Promise.reject(errors) : Promise.all(session.thunks.map(thunk => thunk()));
     });

package/src/schema/Schema.js

@@ -459,7 +459,16 @@ module.exports = class Schema {
             if (scalar) Object.entries(scalar.pipelines).forEach(([key, values]) => $field.pipelines[key].push(...values));
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
-            if ($field.isPrimaryKey) $field.pipelines.serialize.unshift('$pk'); // Will create/convert to FK type always
+
+            // Will create/convert to ID type always
+            if ($field.isPrimaryKey) {
+              $field.pipelines.construct.unshift('$pk');
+              $field.pipelines.restruct.unshift('$pk');
+            }
+
+            // Will convert to ID type IFF defined in payload
+            if ($field.isFKReference || $field.isPrimaryKey) $field.pipelines.serialize.unshift('$fk');
+
             if ($field.isRequired && $field.isPersistable && !$field.isVirtual) $field.pipelines.validate.push('required');
 
             if ($field.isFKReference) {
@@ -468,7 +477,6 @@ module.exports = class Schema {
               const from = $field.linkField.key;
               const as = `join_${to}`;
               $field.join = { to, on, from, as };
-              $field.pipelines.serialize.unshift('$fk'); // Will convert to FK type IFF defined in payload
               $field.pipelines.validate.push('ensureFK'); // Absolute Last
             }
           });