@coderich/autograph 0.13.10 → 0.13.12

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@coderich/autograph",
   "main": "index.js",
-  "version": "0.13.10",
+  "version": "0.13.12",
   "publishConfig": {
     "access": "public"
   },
@@ -15,7 +15,7 @@
     "dev": "coderich-dev"
   },
   "dependencies": {
-    "@coderich/util": "0.1.4",
+    "@coderich/util": "0.1.11",
     "@graphql-tools/merge": "9.0.0",
     "@graphql-tools/resolvers-composition": "7.0.0",
     "@hapi/boom": "10.0.1",
@@ -36,7 +36,7 @@
     "@coderich/dev": "0.1.0",
     "@graphql-tools/schema": "10.0.0",
     "graphql": "16.6.0",
-    "mongodb": "5.7.0",
+    "mongodb": "5.9.2",
     "mongodb-memory-server": "8.13.0",
     "validator": "13.9.0"
   },

package/src/data/Emitter.js

@@ -78,8 +78,9 @@ class Emitter extends EventEmitter {
     } : (event, next) => {
       if (arr.includes(`${event.query[prop]}`)) {
         if (once) this.removeListener(eventName, wrapper);
-        next(listener(event, next));
+        return next(listener(event, next));
       }
+      return next();
     };
 
     return this.on(eventName, wrapper);

package/src/data/Resolver.js

@@ -76,12 +76,15 @@ module.exports = class Resolver {
     });
   }
 
+  /**
+   * Execute a user-defined loader (curry in context)
+   */
   loader(name) {
     const context = this.#context;
 
     return new Proxy(loaders[name], {
       get(loader, fn, proxy) {
-        if (fn === 'load') return args => loader.load(args, context);
+        if (fn.startsWith('load')) return args => loader[fn](args, context);
         return Reflect.get(loader, fn, proxy);
       },
     });
@@ -276,6 +279,10 @@ module.exports = class Resolver {
     const type = query.isMutation ? 'Mutation' : 'Query';
     const event = { schema: this.#schema, context: this.#context, resolver: this, query };
 
+    // Backwards compat
+    query.match = { ...query.where };
+    query.toObject = () => query;
+
     return Emitter.emit(`pre${type}`, event).then(async (resultEarly) => {
       if (resultEarly !== undefined) return resultEarly;
       if (Util.isEqual(query.changeset, { added: {}, updated: {}, deleted: {} })) return query.doc;

package/src/schema/Schema.js

@@ -9,11 +9,13 @@ const Emitter = require('../data/Emitter');
 
 const operations = ['Query', 'Mutation', 'Subscription'];
 // const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION];
 const modelKinds = [Kind.OBJECT_TYPE_DEFINITION, Kind.OBJECT_TYPE_EXTENSION, Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
-const allowedKinds = modelKinds.concat(Kind.DOCUMENT, Kind.FIELD_DEFINITION, Kind.NON_NULL_TYPE, Kind.NAMED_TYPE, Kind.LIST_TYPE, Kind.DIRECTIVE);
+const fieldKinds = [Kind.FIELD_DEFINITION].concat(scalarKinds);
+const allowedKinds = modelKinds.concat(fieldKinds).concat(Kind.DOCUMENT, Kind.NON_NULL_TYPE, Kind.NAMED_TYPE, Kind.LIST_TYPE, Kind.DIRECTIVE);
 const pipelines = ['finalize', 'construct', 'restruct', 'instruct', 'normalize', 'serialize'];
 const inputPipelines = ['finalize', 'construct', 'instruct', 'normalize', 'serialize'];
-const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
+// const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
 
 module.exports = class Schema {
   #config;
@@ -29,9 +31,19 @@ module.exports = class Schema {
     this.#config.directives.field ??= 'field';
     this.#config.directives.link ??= 'link';
     this.#config.directives.index ??= 'index';
-    // this.#typeDefs = Schema.#framework(this.#config.directives);
+    this.#typeDefs = Schema.#framework(this.#config.directives);
+  }
+
+  /* ****** DEPRECATE! ****** */
+  getModels() {
+    return this.#schema.models;
   }
 
+  getModel(name) {
+    return this.#schema.models[`${name}`];
+  }
+  /* ***************** */
+
   /**
    * Decorate each marked @model with config-driven field decorators
    */
@@ -106,38 +118,41 @@ module.exports = class Schema {
     let model, field, isField, isList;
     const thunks = [];
 
+    // Deprecate
+    this.#schema.getModel = name => this.#schema.models[`${name}`];
+
     // Parse AST
     visit(this.#typeDefs, {
       enter: (node) => {
         const name = node.name?.value;
-        if (!allowedKinds.includes(node.kind)) return false;
+        if (!allowedKinds.includes(node.kind) || operations.includes(name)) return false;
 
-        if (modelKinds.includes(node.kind) && !operations.includes(name)) {
+        if (modelKinds.includes(node.kind)) {
           // this.#schema.types[name] = schema.getType(name);
 
           model = this.#schema.models[name] = {
             name,
             key: name,
             fields: {},
+            crud: 'crud', // For use when creating API Queries and Mutations
+            scope: 'crud', // For use when defining types (how it's field.model reference can be used)
             idField: 'id',
-            crud: 'crud',
-            scope: 'crud',
             isPersistable: true,
             source: this.#config.dataSources?.default,
             loader: this.#config.dataLoaders?.default,
             directives: {},
             toString: () => name,
           };
-        } else if (node.kind === Kind.FIELD_DEFINITION) {
+        } else if (fieldKinds.includes(node.kind)) {
           isField = true;
-          field = model.fields[name] = {
+          field = {
             name,
             key: name,
-            crud: 'crud',
             pipelines: pipelines.reduce((prev, key) => Object.assign(prev, { [key]: [] }), {}),
             directives: {},
             toString: () => name,
           };
+          if (model) model.fields[name] = field;
         } else if (node.kind === Kind.NON_NULL_TYPE) {
           field[isList ? 'isArrayRequired' : 'isRequired'] = true;
         } else if (node.kind === Kind.NAMED_TYPE) {
@@ -154,8 +169,8 @@ module.exports = class Schema {
 
           node.arguments.forEach((arg) => {
             const key = arg.name.value;
-            const { value: val, values } = arg.value;
-            const value = values ? values.map(n => n.value) : val;
+            const { value: val, values = { value: val }, kind } = arg.value;
+            const value = kind === 'NullValue' ? null : Util.map(values, n => n.value);
             target.directives[name][key] = value;
 
             if (name === directives.index) this.#schema.indexes[this.#schema.indexes.length - 1][key] = value;
@@ -214,7 +229,6 @@ module.exports = class Schema {
               case 'model-gqlScope': { model.crud = value; break; }
               case 'model-fieldScope': { model.scope = value; break; }
               case 'field-gqlScope': { field.crud = value; break; }
-              case 'field-fieldScope': { field.scope = value; break; }
 
               // Pipelines
               default: {
@@ -230,7 +244,7 @@ module.exports = class Schema {
         return undefined; // Continue
       },
       leave: (node) => {
-        if (modelKinds.includes(node.kind) && !operations.includes(node.name.value)) {
+        if (modelKinds.includes(node.kind)) {
           const $model = model;
           // const idField = $model.fields[$model.idField];
           // $model.primaryKey = Util.nvl(idField?.key, idField?.name, 'id');
@@ -295,11 +309,12 @@ module.exports = class Schema {
           // Field resolution comes first (unshift)
           thunks.unshift(($schema) => {
             $field.model = $schema.models[$field.type];
-            $field.linkBy = $field.linkBy || $field.model?.idField;
+            $field.crud = Util.uvl($field.crud, $field.model?.scope, 'crud');
+            $field.linkBy ??= $field.model?.idField;
             $field.linkField = $field.isVirtual ? $model.fields[$model.idField] : $field;
             $field.isFKReference = !$field.isPrimaryKey && $field.model?.isMarkedModel && !$field.model?.isEmbedded;
+            // $field.isScalar = Boolean(!$field.model || scalars.includes($field.type));
             $field.isEmbedded = Boolean($field.model && !$field.isFKReference && !$field.isPrimaryKey);
-            $field.isScalar = Boolean(!$field.model || scalars.includes($field.type));
 
             if ($field.isArray) $field.pipelines.normalize.unshift('toArray');
             if ($field.isPrimaryKey) $field.pipelines.serialize.unshift('$pk'); // Will create/convert to FK type always
@@ -431,7 +446,6 @@ module.exports = class Schema {
         ref: AutoGraphMixed # Specify the modelRef field's name (overrides isEmbedded)
         gqlScope: AutoGraphMixed # Dictate how GraphQL API behaves
         dalScope: AutoGraphMixed # Dictate how the DAL behaves
-        fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
         destruct: [AutoGraphPipelineEnum!]
         transform: [AutoGraphPipelineEnum!]
         deserialize: [AutoGraphPipelineEnum!]
@@ -453,9 +467,9 @@ module.exports = class Schema {
 
   static #api(schema) {
     // These models are for creating types
-    const readModels = Object.values(schema.models).filter(model => model.crud?.includes('r'));
-    const createModels = Object.values(schema.models).filter(model => model.crud?.includes('c'));
-    const updateModels = Object.values(schema.models).filter(model => model.crud?.includes('u'));
+    const readModels = Object.values(schema.models).filter(model => [model.crud, model.scope].join()?.includes('r'));
+    const createModels = Object.values(schema.models).filter(model => [model.crud, model.scope].join()?.includes('c'));
+    const updateModels = Object.values(schema.models).filter(model => [model.crud, model.scope].join()?.includes('u'));
 
     // These are for defining schema queries/mutations
     const entityModels = Object.values(schema.models).filter(model => model.isEntity);
@@ -573,6 +587,47 @@ module.exports = class Schema {
               ): ${model}SubscriptionPayload!
             `)}
           }
+
+          ${subscriptionModels.map((model) => {
+            const fields = Object.values(model.fields).filter(field => field.crud?.includes('r'));
+
+            return `
+              input ${model}SubscriptionInputFilter {
+                when: [SubscriptionWhenEnum!]! = [preEvent, postEvent]
+                where: ${model}SubscriptionInputWhere! = {}
+              }
+
+              input ${model}SubscriptionInputWhere {
+                ${fields.map(field => `${field}: ${field.model?.isEntity ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
+              }
+
+              type ${model}SubscriptionPayload {
+                event: ${model}SubscriptionPayloadEvent
+                query: ${model}SubscriptionQuery
+              }
+
+              type ${model}SubscriptionPayloadEvent {
+                crud: SubscriptionCrudEnum!
+                data: ${model}SubscriptionPayloadEventData!
+              }
+
+              type ${model}SubscriptionPayloadEventData {
+                ${fields.map(field => `${field}: ${Schema.#getGQLType(field)}`)}
+              }
+
+              interface ${model}SubscriptionQuery {
+                ${fields.map(field => `${field}: ${Schema.#getGQLType(field)}`)}
+              }
+
+              type ${model}Create implements ${model}SubscriptionQuery {
+                ${fields.map(field => `${field}: ${Schema.#getGQLType(field)}`)}
+              }
+
+              type ${model}Update implements ${model}SubscriptionQuery {
+                ${fields.map(field => `${field}: ${Schema.#getGQLType(field)}`)}
+              }
+            `;
+          })}
         ` : ''}
       `,
       resolvers: {