@coderich/autograph 0.13.23 → 0.13.25

package/package.json

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

package/src/data/Pipeline.js

@@ -19,16 +19,8 @@ module.exports = class Pipeline {
     const wrapper = Object.defineProperty((args) => {
       try {
         if (ignoreNull && args.value == null) return args.value;
-
-        if (ignoreNull && itemize) {
-          return Util.map(args.value, (value) => {
-            const v = factory({ ...args, value });
-            return v === undefined ? value : v;
-          });
-        }
-
-        const value = factory(args);
-        return value === undefined ? args.value : value;
+        if (ignoreNull && itemize) return Util.map(args.value, value => Util.uvl(factory({ ...args, value }), value));
+        return Util.uvl(factory(args), args.value);
       } catch (e) {
         const { data = {} } = e;
         throw Boom.boomify(e, { data: { ...args, ...data } });
@@ -74,12 +66,14 @@ module.exports = class Pipeline {
 
     //
     Pipeline.define('$pk', (params) => {
-      const value = get(params.query.doc, params.path) || params.value?.id || params.value;
+      const { pkField } = params.model;
+      const value = get(params.query.doc, params.path) || params.value?.[pkField] || params.value; // I "think" the get() is for embedded documents
       return Pipeline[params.field.id]({ ...params, value });
     }, { ignoreNull: false });
 
     Pipeline.define('$fk', (params) => {
-      const value = params.value?.id || params.value;
+      const { fkField } = params.field;
+      const value = params.value?.[fkField] || params.value;
       return Pipeline[params.field.id]({ ...params, value });
     });
 
@@ -116,10 +110,10 @@ module.exports = class Pipeline {
     });
 
     //
-    Pipeline.define('ensureId', ({ query, resolver, model, field, value }) => {
-      const { type } = field;
+    Pipeline.define('ensureFK', ({ query, resolver, field, value }) => {
+      const { type, fkField } = field;
       const ids = Util.filterBy(Util.ensureArray(value), (a, b) => `${a}` === `${b}`);
-      return resolver.match(type).flags(query.flags).where({ id: ids }).count().then((count) => {
+      return resolver.match(type).flags(query.flags).where({ [fkField]: ids }).count().then((count) => {
         if (count !== ids.length) throw Boom.notFound(`${type} Not Found`);
       });
     }, { itemize: false });
@@ -166,7 +160,7 @@ module.exports = class Pipeline {
   static resolve(params, pipeline) {
     const transformers = params.field.pipelines[pipeline] || [];
 
-    return Util.pipeline(transformers.map(t => async (value) => {
+    return Util.pipeline(transformers.map(t => (value) => {
       return Pipeline[t]({ ...params, value });
     }), params.value);
   }

package/src/data/Resolver.js

@@ -1,6 +1,7 @@
 const { graphql } = require('graphql');
 const Boom = require('@hapi/boom');
 const Util = require('@coderich/util');
+const Pipeline = require('./Pipeline');
 const Emitter = require('./Emitter');
 const Loader = require('./Loader');
 const DataLoader = require('./DataLoader');
@@ -220,7 +221,15 @@ module.exports = class Resolver {
     if (result == null) return result;
     if (typeof result !== 'object') return result;
     return Object.defineProperties(Util.map(result, (doc) => {
-      const $doc = this.#schema.models[model].walk(doc, node => node.value !== undefined && Object.assign(node, { key: node.field.name }), { key: 'key' });
+      // Transform result to domain model
+      const $doc = this.#schema.models[model].walk(doc, (node) => {
+        if (node.value === undefined) return undefined;
+        node.key = node.field.name;
+        node.value = Pipeline.$cast(node);
+        return node;
+      }, { key: 'key' });
+
+      // Assign useful/needed meta data
       return Object.defineProperties($doc, {
         $: {
           get: () => {
@@ -233,7 +242,7 @@ module.exports = class Resolver {
                     }
                     case 'lookup': {
                       const field = self.toModel(model).fields[args[0]];
-                      const where = { [field.linkBy]: $doc[field.linkField.name] };
+                      const where = field.isVirtual ? { [field.linkBy]: $doc[field.linkField] } : { [field.fkField]: $doc[field] };
                       return self.match(field.model).where(where);
                     }
                     default: {

package/src/schema/Schema.js

@@ -59,7 +59,7 @@ module.exports = class Schema {
 
           if (directive) {
             const arg = directive.arguments.find(({ name }) => name.value === 'decorate');
-            const value = arg?.value.value || 'default';
+            const value = Util.uvl(Schema.#resolveNodeValue(arg?.value), 'default');
             const decorator = this.#config.decorators?.[value];
 
             if (decorator) {
@@ -214,6 +214,10 @@ module.exports = class Schema {
                 break;
               }
               // Field specific directives
+              case `${directives.field}-fk`: {
+                target.fkField = value;
+                break;
+              }
               case `${directives.field}-default`: {
                 target.defaultValue = value;
                 break;
@@ -230,9 +234,14 @@ module.exports = class Schema {
                 target.pipelines.normalize = target.pipelines.normalize.concat(value).filter(Boolean);
                 break;
               }
+              case `${directives.link}-to`: {
+                target.linkTo = value;
+                target.isVirtual ??= true;
+                break;
+              }
               case `${directives.link}-by`: {
                 target.linkBy = value;
-                target.isVirtual = true;
+                target.isVirtual ??= true;
                 break;
               }
               // Generic by target directives
@@ -339,8 +348,10 @@ module.exports = class Schema {
           thunks.unshift(($schema) => {
             $field.id ??= $model.id;
             $field.model = $schema.models[$field.type];
-            $field.linkBy ??= $field.model?.pkField;
             $field.crud = Util.uvl($field.crud, $field.model?.scope, 'crud');
+            $field.linkTo ??= $field.model;
+            $field.linkBy ??= $field.linkTo?.pkField; // This defines join logic (below) for both straight+virtual references
+            $field.fkField ??= $field.model?.pkField; // This is the fkReference field for straight references
             $field.linkField = $field.isVirtual ? $model.fields[$model.pkField] : $field;
             $field.isFKReference = !$field.isPrimaryKey && $field.model?.isMarkedModel && !$field.model?.isEmbedded;
             $field.isEmbedded = Boolean($field.model && !$field.isFKReference && !$field.isPrimaryKey);
@@ -354,16 +365,16 @@ module.exports = class Schema {
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
             if ($field.isPrimaryKey) $field.pipelines.serialize.unshift('$pk'); // Will create/convert to FK type always
-            if ($field.isFKReference) $field.pipelines.serialize.unshift('$fk'); // Will convert to FK type IFF defined in payload
-
             if ($field.isRequired && $field.isPersistable && !$field.isVirtual) $field.pipelines.finalize.push('required');
+
             if ($field.isFKReference) {
               const to = $field.model.key;
               const on = $field.model.fields[$field.linkBy].key;
               const from = $field.linkField.key;
               const as = `join_${to}`;
               $field.join = { to, on, from, as };
-              $field.pipelines.finalize.push('ensureId'); // Absolute Last
+              $field.pipelines.serialize.unshift('$fk'); // Will convert to FK type IFF defined in payload
+              $field.pipelines.finalize.push('ensureFK'); // Absolute Last
             }
           });
 
@@ -446,6 +457,8 @@ module.exports = class Schema {
   }
 
   static #resolveNodeValue(node) {
+    if (node == null) return node;
+
     switch (node.kind) {
       case 'NullValue': return null;
       case 'ListValue': return node.values.map(Schema.#resolveNodeValue);
@@ -493,6 +506,7 @@ module.exports = class Schema {
 
       directive @${field}(
         id: String # Specify the ID strategy (eg. "toObjectId")
+        fk: String # Specify the FK field (default model.pk)
         key: String # Specify db key
         persist: Boolean # Persist this field (default true)
         connection: Boolean # Treat this field as a connection type (default false - rolling this out slowly)