@coderich/autograph 0.13.38 → 0.13.39

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.38",
+  "version": "0.13.39",
   "publishConfig": {
     "access": "public"
   },
@@ -15,7 +15,7 @@
     "dev": "coderich-dev"
   },
   "dependencies": {
-    "@coderich/util": "1.0.3",
+    "@coderich/util": "1.0.4",
     "@graphql-tools/merge": "9.0.0",
     "@graphql-tools/resolvers-composition": "7.0.0",
     "@hapi/boom": "10.0.1",
@@ -32,7 +32,7 @@
   },
   "devDependencies": {
     "@apollo/server": "4.9.5",
-    "@coderich/autograph-mongodb": "0.0.2",
+    "@coderich/autograph-mongodb": "0.0.4",
     "@coderich/dev": "0.2.1",
     "@graphql-tools/schema": "10.0.0",
     "graphql": "16.8.1",

package/src/data/DataLoader.js

@@ -24,16 +24,63 @@ module.exports = class Loader {
   }
 
   #resolve(queries) {
-    return Promise.all(queries.map((query) => {
-      const dquery = query.toDriver();
-      const $query = dquery.toObject();
+    /**
+     * Batch queries can save resources and network round-trip latency. However, we have to be careful to
+     * preserve the order and adhere to the DataLoader API. This step simply creates a map of batch
+     * queries to run; saving the order ("i") along with useful query information
+     */
+    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')));
+      prev[key] = prev[key] || [];
+      prev[key].push({ query, $query, values, $values, i });
+      return prev;
+    }, {});
 
-      return this.#model.source.client.resolve($query).then((data) => {
+    return Promise.all(Object.entries(batchesByKey).map(([key, batches]) => {
+      switch (key) {
+        case '__default__': {
+          return batches.map(batch => this.#model.source.client.resolve(batch.$query).then(data => ({ data, ...batch })));
+        }
+        default: {
+          const values = Array.from(new Set(batches.map(batch => batch.values).flat()));
+          const $query = { ...batches[0].$query, op: 'findMany', where: { [key]: values } };
+          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;
+                });
+                return match;
+              });
+              const data = batch.$query.op === 'findOne' ? matches[0] : matches;
+              return { data, ...batch };
+            });
+          });
+        }
+      }
+    }).flat()).then((results) => {
+      return results.flat().sort((a, b) => a.i - b.i).map(({ query, $query, data }) => {
         if (data == null) return null; // Explicit return null;
         if ($query.isCursorPaging && Array.isArray(data)) data = Loader.#paginateResults(data, query.toObject());
         return this.#resolver.toResultSet(this.#model, data);
       });
-    }));
+    });
+
+    // return Promise.all(queries.map((query, i) => {
+    //   const dquery = query.toDriver();
+    //   const $query = dquery.toObject();
+
+    //   return this.#model.source.client.resolve($query).then((data) => {
+    //     if (data == null) return null; // Explicit return null;
+    //     if ($query.isCursorPaging && Array.isArray(data)) data = Loader.#paginateResults(data, query.toObject());
+    //     return this.#resolver.toResultSet(this.#model, data);
+    //   });
+    // }));
   }
 
   static #paginateResults(rs, query) {

package/src/query/Query.js

@@ -1,5 +1,5 @@
 const Util = require('@coderich/util');
-const { isGlob, globToRegex, mergeDeep, finalizeWhereClause, JSONParse } = require('../service/AppService');
+const { isGlob, globToRegex, mergeDeep, JSONParse } = require('../service/AppService');
 
 module.exports = class Query {
   #config;
@@ -89,7 +89,7 @@ module.exports = class Query {
    * Finalize the query for the driver
    */
   #finalize(query) {
-    const { where = {}, sort = {} } = query;
+    const { where = {}, sort = {}, op } = query;
     const flatSort = Util.flatten(sort, { safe: true });
     const flatWhere = Util.flatten(where, { safe: true });
     const $sort = Util.unflatten(Object.keys(flatSort).reduce((prev, key) => Object.assign(prev, { [key]: {} }), {}), { safe: true });
@@ -101,11 +101,11 @@ module.exports = class Query {
     }, { key: 'key' });
 
     // Reconstruct the where clause by pulling out anything that requires a join
-    query.where = finalizeWhereClause(Util.unflatten(Object.entries(flatWhere).reduce((prev, [key, value]) => {
+    query.where = Object.entries(flatWhere).reduce((prev, [key, value]) => {
       if (this.#model.isJoinPath(key, 'key')) return prev;
       value = Util.map(value, el => (isGlob(el) ? globToRegex(el) : el));
       return Object.assign(prev, { [key]: value });
-    }, {}), { safe: true }));
+    }, {});
 
     // Determine what join data is needed (derived from where + sort)
     const joinData = mergeDeep($sort, Util.unflatten(Object.entries(flatWhere).reduce((prev, [key, value]) => {
@@ -113,6 +113,9 @@ module.exports = class Query {
       return prev;
     }, {}), { safe: true }));
 
+    // If we have 1 field in where clause this is a candidate for batching
+    query.batch = (op === 'findOne' || op === 'findMany') && Object.keys(query.where).length === 1 ? Object.keys(query.where)[0] : '__default__';
+
     // Construct joins
     query.joins = [];
 

package/src/service/AppService.js

@@ -17,14 +17,6 @@ exports.hashObject = obj => ObjectHash(obj, { respectType: false, respectFunctio
 exports.fromGUID = guid => Buffer.from(`${guid}`, 'base64').toString('ascii').split(',');
 exports.guidToId = (autograph, guid) => (autograph.legacyMode ? guid : exports.uvl(exports.fromGUID(guid)[1], guid));
 
-exports.finalizeWhereClause = (obj, arrayOp = '$in') => {
-  return Object.entries(Util.flatten(obj, { safe: true })).reduce((prev, [key, value]) => {
-    const isArray = Array.isArray(value);
-    if (isArray) return Object.assign(prev, { [key]: { [arrayOp]: value } });
-    return Object.assign(prev, { [key]: value });
-  }, {});
-};
-
 exports.getGQLReturnType = (info) => {
   const returnType = `${info.returnType}`;
   const typeMap = { array: /^\[.+\].?$/, connection: /.+Connection!?$/, number: /^(Int|Float)!?$/, scalar: /.*/ };