@coderich/autograph 0.13.23 → 0.13.24

package/package.json

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

package/src/data/Pipeline.js

@@ -74,12 +74,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 +118,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 });

package/src/data/Resolver.js

@@ -233,7 +233,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)