@coderich/autograph 0.13.109 → 0.14.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.109",
+  "version": "0.14.0",
   "publishConfig": {
     "access": "public"
   },
@@ -16,7 +16,7 @@
     "clinic": "clinic flame -- node ./test/server"
   },
   "dependencies": {
-    "@coderich/util": "1.2.1",
+    "@coderich/util": "2.2.0",
     "@graphql-tools/merge": "9.0.0",
     "@graphql-tools/resolvers-composition": "7.0.0",
     "@hapi/boom": "10.0.1",
@@ -38,7 +38,6 @@
     "@graphql-tools/schema": "10.0.0",
     "clinic": "13.0.0",
     "graphql": "16.8.1",
-    "mongodb": "5.9.2",
     "mongodb-memory-server": "8.13.0"
   },
   "peerDependencies": {

package/src/data/DataLoader.js

@@ -1,7 +1,6 @@
 const get = require('lodash.get');
 const Util = require('@coderich/util');
 const DataLoader = require('dataloader');
-const { hashObject } = require('../service/AppService');
 
 module.exports = class Loader {
   #model;
@@ -11,7 +10,7 @@ module.exports = class Loader {
   constructor(model, resolver) {
     this.#model = model;
     this.#resolver = resolver;
-    this.#model.loader.cacheKeyFn ??= query => hashObject(query.toCacheKey());
+    this.#model.loader.cacheKeyFn ??= query => query.toCacheKey();
     this.#loader = new DataLoader(keys => this.#resolve(keys), this.#model.loader);
   }
 
@@ -33,10 +32,9 @@ module.exports = class Loader {
       const $query = query.toDriver().toObject();
       const key = $query.batch ?? '__default__';
       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')));
+      values = Loader.#dedup(Util.ensureArray(values));
       prev[key] = prev[key] || [];
-      prev[key].push({ query, $query, values, $values, i });
+      prev[key].push({ query, $query, values, i });
       return prev;
     }, {});
 
@@ -47,36 +45,37 @@ module.exports = class Loader {
         }
         default: {
           // Collect all the values for the where clause
-          const values = Array.from(new Set(batches.map(batch => batch.values).flat()));
+          const values = Loader.#dedup(batches.map(batch => batch.values).flat());
           const $query = { ...batches[0].$query, op: 'findMany', where: { [key]: values } };
 
-          //
           if (values.length < 3) {
             return batches.map(batch => this.#model.source.client.resolve(batch.$query).then(data => ({ data, ...batch })));
           }
 
-          // 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) => {
-            // This one-time transformation keys all the docs by $value (regex) match
+            const docsByKey = new Map();
+
             docs.forEach((doc) => {
               Util.pathmap(key, doc, (value) => {
-                docsByRegExpKey.forEach((set, re) => {
-                  Util.map(value, (v) => {
-                    if (`${v}`.match(re)) {
-                      set.push(doc);
-                    }
-                  });
+                Util.ensureArray(value).forEach((v) => {
+                  const k = `${v}`;
+                  if (!docsByKey.has(k)) docsByKey.set(k, []);
+                  docsByKey.get(k).push(doc);
                 });
                 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 matches = Array.from(new Set(batch.values.flatMap((v) => {
+                if (v instanceof RegExp) {
+                  const result = [];
+                  docsByKey.forEach((d, k) => { if (v.test(k)) result.push(...d); });
+                  return result;
+                }
+                return docsByKey.get(`${v}`) || [];
+              })));
               const data = batch.$query.op === 'findOne' ? matches[0] : matches;
               return { data, ...batch };
             });
@@ -103,6 +102,16 @@ module.exports = class Loader {
     // }));
   }
 
+  // Deduplicate an array of values that may contain RegExp objects.
+  // new Set() compares by reference, so two RegExp literals with identical patterns
+  // are treated as distinct. Using toString() as the Map key handles this correctly
+  // while preserving the actual RegExp instance as the value.
+  static #dedup(arr) {
+    const seen = new Map();
+    arr.forEach(v => seen.set(v instanceof RegExp ? v.toString() : v, v));
+    return Array.from(seen.values());
+  }
+
   static #paginateResults(rs, query) {
     let hasNextPage = false;
     let hasPreviousPage = false;

package/src/data/Emitter.js

@@ -1,4 +1,4 @@
-const EventEmitter = require('events');
+const EventEmitter = require('node:events');
 const Util = require('@coderich/util');
 const { AbortEarlyError } = require('../service/ErrorService');
 
@@ -9,28 +9,36 @@ const { AbortEarlyError } = require('../service/ErrorService');
  * If it expects more than 1 we block and wait for it to finish.
  */
 class Emitter extends EventEmitter {
+  #cache = new Map();
+
+  #invalidate(event) {
+    this.#cache.delete(event);
+  }
+
+  #getListeners(event) {
+    if (!this.#cache.has(event)) {
+      const [basicFuncs, nextFuncs] = this.rawListeners(event).reduce((prev, wrapper) => {
+        const { listener = wrapper } = wrapper;
+        wrapper.priority = listener.priority ?? 0;
+        return prev[listener.length < 2 ? 0 : 1].push(wrapper) && prev;
+      }, [[], []]);
+      this.#cache.set(event, { basicFuncs: basicFuncs.sort(Emitter.sort), nextFuncs: nextFuncs.sort(Emitter.sort) });
+    }
+    return this.#cache.get(event);
+  }
+
   emit(event, data) {
-    // Here we pull out functions with "next" vs those without
-    const [basicFuncs, nextFuncs] = this.rawListeners(event).reduce((prev, wrapper) => {
-      const { listener = wrapper } = wrapper;
-      const isBasic = listener.length < 2;
-      wrapper.priority = listener.priority ?? 0;
-      return prev[isBasic ? 0 : 1].push(wrapper) && prev;
-    }, [[], []]);
-
-    // // Basic functions are not designed to be bound to the query execution so we need an isolated resolver from any transactions
-    // const resolver = data?.resolver?.clone();
-    // const basicData = { ...data, resolver };
+    const { basicFuncs, nextFuncs } = this.#getListeners(event);
 
     return new Promise((resolve, reject) => {
       // Basic functions run first; if they return a value they abort the flow of execution
-      basicFuncs.sort(Emitter.sort).forEach((fn) => {
+      basicFuncs.forEach((fn) => {
         const value = fn(data);
         if (value !== undefined && !(value instanceof Promise)) throw new AbortEarlyError(value);
       });
 
       // Next functions are async and control the timing of the next phase
-      Promise.all(nextFuncs.sort(Emitter.sort).map((fn) => {
+      Promise.all(nextFuncs.map((fn) => {
         return new Promise((next, err) => {
           Promise.resolve().then(() => fn(data, next)).catch(err);
         }).then((result) => {
@@ -45,14 +53,47 @@ class Emitter extends EventEmitter {
 
   on(event, listener, priority = 0) {
     listener.priority = priority;
+    this.#invalidate(event);
     return super.on(event, listener);
   }
 
+  addListener(event, listener, priority = 0) {
+    return this.on(event, listener, priority);
+  }
+
+  once(event, listener, priority = 0) {
+    listener.priority = priority;
+    this.#invalidate(event);
+    return super.once(event, listener);
+  }
+
   prependListener(event, listener, priority = 0) {
     listener.priority = priority;
+    this.#invalidate(event);
     return super.prependListener(event, listener);
   }
 
+  prependOnceListener(event, listener, priority = 0) {
+    listener.priority = priority;
+    this.#invalidate(event);
+    return super.prependOnceListener(event, listener);
+  }
+
+  removeListener(event, listener) {
+    this.#invalidate(event);
+    return super.removeListener(event, listener);
+  }
+
+  off(event, listener) {
+    return this.removeListener(event, listener);
+  }
+
+  removeAllListeners(event) {
+    if (event) this.#invalidate(event);
+    else this.#cache.clear();
+    return super.removeAllListeners(event);
+  }
+
   /**
    * Syntactic sugar to listen on query keys
    */

package/src/data/Pipeline.js

@@ -63,7 +63,6 @@ module.exports = class Pipeline {
     Pipeline.define('$construct', params => Pipeline.resolve(params, 'construct'), { ignoreNull: false });
     Pipeline.define('$restruct', params => Pipeline.resolve(params, 'restruct'), { ignoreNull: false });
     Pipeline.define('$serialize', params => Pipeline.resolve(params, 'serialize'), { ignoreNull: false });
-    Pipeline.define('$deserialize', params => Pipeline.resolve(params, 'deserialize'), { ignoreNull: false });
     Pipeline.define('$validate', params => Pipeline.resolve(params, 'validate'), { ignoreNull: false });
 
     //

package/src/data/Resolver.js

@@ -245,7 +245,7 @@ module.exports = class Resolver {
     model = this.#schema.models[model];
 
     return Object.defineProperties(Util.map(result, (doc) => {
-      const $doc = model.transformers.doc.transform(doc, { resolver: this, context: this.#context });
+      const $doc = model.docTransform(doc);
 
       // Assign useful/needed meta data
       return Object.defineProperties($doc, {
@@ -307,44 +307,26 @@ module.exports = class Resolver {
     const tquery = $query.transform(false);
     const query = tquery.toObject();
     const type = query.isMutation ? 'Mutation' : 'Query';
-    const event = this.#createEvent(query);
+    const event = { schema: this.#schema, context: this.#context, resolver: this, query };
 
     return Emitter.emit(`pre${type}`, event).then(async (resultEarly) => {
-      if (resultEarly !== undefined) return resultEarly; // Nothing to validate/transform
-      // if (query.crud === 'update' && Util.isEqual({ added: {}, updated: {}, deleted: {} }, Util.changeset(query.doc, query.input))) return query.doc;
+      if (resultEarly !== undefined) return resultEarly;
 
       if (['create', 'update'].includes(query.crud)) {
-        tquery.validate(); // Transformation sets $thunks
+        tquery.validate(); // sets async $thunks (e.g. ensureFK)
         await Promise.all([...query.input.$thunks]);
         await Emitter.emit('validate', event);
       }
 
       return thunk(tquery);
     }).then((result) => {
-      event.result = result; // backwards compat
       query.result = result;
       return Emitter.emit(`post${type}`, event);
     }).then((result = query.result) => result).catch((e) => {
       throw Boom.boomify(e);
-      // const { data = {} } = e;
-      // throw Boom.boomify(e, { data: { ...event, ...data } });
     });
   }
 
-  #createEvent(query) {
-    const event = { schema: this.#schema, context: this.#context, resolver: this, query };
-
-    // Backwards compat
-    Object.assign(event, query);
-    query.match = event.args.where;
-    query.toObject = () => query;
-    event.merged = event.input;
-    event.input = Util.unflatten(event.args?.input, { safe: true });
-    event.doc ??= {};
-
-    return event;
-  }
-
   static $loader(name, resolver, config) {
     if (!name) return loaders;
     if (!resolver) return loaders[name];

package/src/data/Transformer.js

@@ -9,6 +9,8 @@ module.exports = class Transformer {
     keepUndefined: false, // If true, will preserve undefined values
   };
 
+  #callArgs = {}; // Ephemeral per-call merge of #config.args + transform() args; never persisted
+
   #operation = {
     set: (target, prop, startValue, proxy) => {
       if (this.#config.shape[prop]) {
@@ -16,7 +18,7 @@ module.exports = class Transformer {
 
         const result = this.#config.shape[prop].reduce((value, t) => {
           previousValue = value;
-          if (typeof t === 'function') return Util.uvl(t({ startValue, value, ...this.#config.args }), value);
+          if (typeof t === 'function') return Util.uvl(t({ startValue, value, ...this.#callArgs }), value);
           prop = t; // rename key
           return value;
         }, startValue);
@@ -64,7 +66,7 @@ module.exports = class Transformer {
 
   transform(mixed, args = {}) {
     args.thunks ??= [];
-    this.args(args);
+    this.#callArgs = { ...this.#config.args, ...args };
 
     const transformed = Util.map(mixed, (data) => {
       const thunks = Object.defineProperty({}, '$thunks', { value: args.thunks });

package/src/query/Query.js

@@ -39,19 +39,18 @@ module.exports = class Query {
   }
 
   toCacheKey() {
-    return {
+    return JSON.stringify({
       op: this.#query.op,
       select: this.#query.select,
       where: this.#query.where,
       sort: this.#query.sort,
-      joins: this.#query.joins,
       skip: this.#query.skip,
       limit: this.#query.limit,
       before: this.#query.before,
       after: this.#query.after,
       first: this.#query.first,
       last: this.#query.last,
-    };
+    });
   }
 
   /**
@@ -134,14 +133,25 @@ module.exports = class Query {
     query.batch = (op === 'findOne' || op === 'findMany') && Object.keys(query.where).length === 1 ? Object.keys(query.where)[0] : '__default__';
 
     // Construct joins
+    const joinsByPath = {};
     query.joins = [];
 
+    // Recursively search a join tree for the first join matching a target model key
+    const findJoin = (joins, modelKey) => {
+      for (const j of joins) {
+        if (j.to === modelKey) return j;
+        const found = findJoin(j.children, modelKey);
+        if (found) return found;
+      }
+      return null;
+    };
+
     this.#model.walk(joinData, (node) => {
       const { model, field, key, value, isLeaf, path, run } = node;
 
       if (field.join) {
         let isArray;
-        const join = { ...field.join, where: {} };
+        const join = { ...field.join, where: {}, children: [] };
 
         if (run.length > 1) {
           join.from = path.reduce((prev, curr, i) => {
@@ -153,12 +163,21 @@ module.exports = class Query {
 
         join.isArray = isArray || model.resolvePath(join.from).isArray;
 
-        query.joins.push(join);
+        // Find the nearest ancestor FK join by scanning ancestor paths from closest to farthest.
+        // Joins reached through embedded fields have no FK ancestor and stay at the root level.
+        const parentJoin = path.slice(0, -1).reduceRight((found, _, i) => found || joinsByPath[path.slice(0, i + 1).join('.')], null);
+
+        if (parentJoin) {
+          parentJoin.children.push(join);
+        } else {
+          query.joins.push(join);
+        }
+        joinsByPath[path.join('.')] = join;
       }
 
       if (isLeaf) {
         const $model = field.model || model;
-        const join = query.joins.find(j => j.to === $model.key);
+        const join = findJoin(query.joins, $model.key);
         const $value = Util.map(value, el => (isGlob(el) ? globToRegex(el) : el));
         const $$value = Array.isArray($value) ? { $in: $value } : $value;
         const from = field.model ? join.from : key;

package/src/schema/Schema.js

@@ -16,7 +16,7 @@ const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
 const fieldKinds = [Kind.FIELD_DEFINITION];
 const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION].concat(interfaceKinds);
 const allowedKinds = modelKinds.concat(fieldKinds).concat(Kind.DOCUMENT, Kind.NON_NULL_TYPE, Kind.NAMED_TYPE, Kind.LIST_TYPE, Kind.DIRECTIVE).concat(scalarKinds).concat(enumKinds);
-const pipelines = ['validate', 'construct', 'restruct', 'instruct', 'normalize', 'serialize', 'deserialize'];
+const pipelines = ['validate', 'construct', 'restruct', 'instruct', 'normalize', 'serialize'];
 const createPipelines = ['validate', 'construct', 'instruct', 'normalize', 'serialize'];
 const updatePipelines = ['validate', 'restruct', 'instruct', 'normalize', 'serialize'];
 // const validatePipelines = ['validate', 'instruct', 'normalize', 'serialize'];
@@ -97,7 +97,7 @@ module.exports = class Schema {
         try {
           const $td = typeof td === 'string' ? parse(td) : td;
           return $td;
-        } catch (e) {
+        } catch {
           console.log(`Unable to parse typeDef (being ignored):\n${td}`); // eslint-disable-line
           return null;
         }
@@ -153,7 +153,6 @@ module.exports = class Schema {
               create: new Transformer({ args: { schema: this.#schema, path: [] } }),
               update: new Transformer({ args: { schema: this.#schema, path: [] } }),
               where: new Transformer({ args: { schema: this.#schema, path: [] } }),
-              doc: new Transformer({ args: { schema: this.#schema, path: [] } }),
             },
             directives: {},
             ignorePaths: [],
@@ -452,33 +451,6 @@ module.exports = class Schema {
 
             $model.transformers.sort = $model.transformers.where.clone({ defaults: {} });
 
-            $model.transformers.doc.config({
-              shape: Object.values($model.fields).reduce((prev, curr) => {
-                const args = { model: $model, field: curr };
-
-                const rules = [
-                  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(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) => {
-                if (curr.defaultValue === undefined) return prev;
-                return Object.assign(prev, { [curr.key]: curr.defaultValue });
-              }, {}),
-            });
-
             $model.transformers.validate.config({
               strictSchema: true,
               shape: Object.values($model.fields).reduce((prev, curr) => {
@@ -499,6 +471,21 @@ module.exports = class Schema {
               }, {}),
             });
 
+            // Deserialize/docs special case handling for performance
+            const docFields = Object.values($model.fields);
+            $model.docTransform = (doc) => {
+              if (doc == null) return doc;
+              const out = {};
+              for (const docField of docFields) {
+                let value = docField.key in doc ? doc[docField.key] : docField.defaultValue;
+                if (value === undefined) continue; // eslint-disable-line
+                if (docField.isArray) value = value == null ? value : Util.ensureArray(value);
+                if (docField.isEmbedded) value = Util.map(value, v => docField.model.docTransform(v));
+                out[docField.name] = value;
+              }
+              return out;
+            };
+
             Util.traverse(Object.values($model.fields), (f, info) => {
               const path = info.path.concat(f.name);
               if (f.isEmbedded) return { value: Object.values(f.model.fields), info: { path } };
@@ -720,7 +707,6 @@ module.exports = class Schema {
         construct: [AutoGraphPipelineEnum!]
         restruct: [AutoGraphPipelineEnum!]
         serialize: [AutoGraphPipelineEnum!]
-        deserialize: [AutoGraphPipelineEnum!]
         validate: [AutoGraphPipelineEnum!]
 
         # TEMP TO APPEASE TRANSITION
@@ -903,7 +889,7 @@ module.exports = class Schema {
       `,
       resolvers: {
         Node: {
-          __resolveType: (doc, args, context, info) => doc.__typename, // eslint-disable-line no-underscore-dangle
+          __resolveType: (doc, args, context, info) => doc.__typename,
         },
         ...queryModels.reduce((prev, model) => {
           return Object.assign(prev, {
@@ -926,7 +912,7 @@ module.exports = class Schema {
             const model = schema.models[modelName];
             return context[schema.namespace].resolver.match(model).id(id).info(info).one().then((result) => {
               if (result == null) return result;
-              result.__typename = modelName; // eslint-disable-line no-underscore-dangle
+              result.__typename = modelName;
               return result;
             });
           },

package/src/service/AppService.js

@@ -40,7 +40,7 @@ exports.JSONParse = (mixed) => {
   try {
     const json = JSON.parse(mixed);
     return json;
-  } catch (e) {
+  } catch {
     return undefined;
   }
 };

package/src/data/__mocks__/Emitter.js

@@ -1,11 +0,0 @@
-const API = jest.requireActual('../Emitter');
-const { mergeDeep } = require('../../service/AppService');
-
-const { emit } = API;
-
-API.emit = (eventName, data) => {
-  if (API.cloneData) data = { ...data, query: mergeDeep({}, data.query) };
-  return emit.call(API, eventName, data);
-};
-
-module.exports = API;

package/src/data/__mocks__/Pipeline.js

@@ -1,32 +0,0 @@
-/**
- * We need to export Pipeline as a POJO so jest can spy on it
- * This is because all the methods are defined using Object.defineProperty
- */
-const Pipeline = jest.requireActual('../Pipeline');
-const Util = require('@coderich/util');
-
-const API = {};
-
-Pipeline.resolve = (params, pipeline) => {
-  const transformers = params.field.pipelines[pipeline] || [];
-
-  return transformers.reduce((value, t) => {
-    return Util.uvl(API[t]({ ...params, value }), value);
-  }, params.value);
-
-  // return Util.pipeline(transformers.map(t => (value) => {
-  //   return API[t]({ ...params, value });
-  // }), params.value);
-};
-
-Object.getOwnPropertyNames(Pipeline).reduce((prev, key) => {
-  return Object.assign(prev, { [key]: Pipeline[key] });
-}, API);
-
-// For those defined outside of Pipeline.js itself
-API.define = (key, ...args) => {
-  Pipeline.define(key, ...args);
-  API[key] = Pipeline[key];
-};
-
-module.exports = API;