@coderich/autograph 0.13.11 → 0.13.13

package/package.json

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

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

@@ -279,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

@@ -8,9 +8,12 @@ const Pipeline = require('../data/Pipeline');
 const Emitter = require('../data/Emitter');
 
 const operations = ['Query', 'Mutation', 'Subscription'];
-// const interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_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 interfaceKinds = [Kind.INTERFACE_TYPE_DEFINITION, Kind.INTERFACE_TYPE_EXTENSION];
+// const unionKinds = [Kind.UNION_TYPE_DEFINITION, Kind.UNION_TYPE_EXTENSION];
+const scalarKinds = [Kind.SCALAR_TYPE_DEFINITION, Kind.SCALAR_TYPE_EXTENSION, Kind.ENUM_TYPE_DEFINITION, Kind.ENUM_TYPE_EXTENSION];
+const fieldKinds = [Kind.FIELD_DEFINITION].concat(scalarKinds);
+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);
 const pipelines = ['finalize', 'construct', 'restruct', 'instruct', 'normalize', 'serialize'];
 const inputPipelines = ['finalize', 'construct', 'instruct', 'normalize', 'serialize'];
 const scalars = ['ID', 'String', 'Float', 'Int', 'Boolean'];
@@ -110,7 +113,6 @@ module.exports = class Schema {
   parse() {
     if (this.#schema) return this.#schema;
 
-    // const schema = buildASTSchema(this.#typeDefs);
     const { directives, namespace } = this.#config;
     this.#schema = { types: {}, models: {}, indexes: [], namespace };
     let model, field, isField, isList;
@@ -119,21 +121,21 @@ module.exports = class Schema {
     // Deprecate
     this.#schema.getModel = name => this.#schema.models[`${name}`];
 
-    // Parse AST
+    // Parse AST (build/defined this.#schema)
     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',
-            scope: 'crud',
+            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',
             isPersistable: true,
             source: this.#config.dataSources?.default,
@@ -141,16 +143,20 @@ module.exports = class Schema {
             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;
+        }
+
+        if (scalarKinds.includes(node.kind)) {
+          scalars.push(node.name.value);
         } else if (node.kind === Kind.NON_NULL_TYPE) {
           field[isList ? 'isArrayRequired' : 'isRequired'] = true;
         } else if (node.kind === Kind.NAMED_TYPE) {
@@ -167,8 +173,7 @@ 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 = Schema.#resolveNodeValue(arg.value);
             target.directives[name][key] = value;
 
             if (name === directives.index) this.#schema.indexes[this.#schema.indexes.length - 1][key] = value;
@@ -227,7 +232,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: {
@@ -243,7 +247,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');
@@ -308,11 +312,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.isEmbedded = Boolean($field.model && !$field.isFKReference && !$field.isPrimaryKey);
-            $field.isScalar = Boolean(!$field.model || scalars.includes($field.type));
+            $field.isScalar = 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
@@ -360,6 +365,23 @@ module.exports = class Schema {
       return fieldKeys.reduce((parent, key) => Object.values(parent.fields || parent.model.fields).find(el => el[prop] === key) || parent, $model);
     };
 
+    // Mutate typeDefs
+    let $model;
+    this.#typeDefs = visit(this.#typeDefs, {
+      enter: (node) => {
+        const name = node.name?.value;
+        if (!allowedKinds.includes(node.kind) || operations.includes(name)) return false;
+
+        if (modelKinds.includes(node.kind)) {
+          $model = this.#schema.models[name];
+        } else if (fieldKinds.includes(node.kind)) {
+          if (!Util.uvl($model?.fields[name]?.crud, 'crud')?.includes('r')) return null;
+        }
+
+        return undefined;
+      },
+    });
+
     // Return schema
     return this.#schema;
   }
@@ -388,6 +410,15 @@ module.exports = class Schema {
     return this.#config.makeExecutableSchema(this.toObject());
   }
 
+  static #resolveNodeValue(node) {
+    switch (node.kind) {
+      case 'NullValue': return null;
+      case 'ListValue': return node.values.map(Schema.#resolveNodeValue);
+      case 'ObjectValue': return node.fields.reduce((prev, field) => Object.assign(prev, { [field.name.value]: Schema.#resolveNodeValue(field.value) }), {});
+      default: return node.value ?? node;
+    }
+  }
+
   static #framework(directives) {
     const { model, field, link, index } = directives;
 
@@ -444,7 +475,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!]
@@ -466,9 +496,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);
@@ -479,6 +509,7 @@ module.exports = class Schema {
     return {
       typeDefs: `
         scalar AutoGraphMixed
+        scalar AutoGraphDateTime
 
         interface Node { id: ID! }
 
@@ -505,10 +536,10 @@ module.exports = class Schema {
 
           return `
             input ${model}InputWhere {
-              ${fields.map(field => `${field}: ${field.model?.isEntity ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
+              ${fields.map(field => `${field}: ${field.model ? `${field.model}InputWhere` : 'AutoGraphMixed'}`)}
             }
             input ${model}InputSort {
-              ${fields.map(field => `${field}: ${field.model?.isEntity ? `${field.model}InputSort` : 'SortOrderEnum'}`)}
+              ${fields.map(field => `${field}: ${field.model ? `${field.model}InputSort` : 'SortOrderEnum'}`)}
             }
             type ${model}Connection {
               count: Int!
@@ -586,6 +617,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 ? `${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: {
@@ -649,12 +721,12 @@ module.exports = class Schema {
 
   static #getGQLType(field, suffix) {
     let { type } = field;
-    const { isEmbedded, isRequired, isScalar, isArray, isArrayRequired, defaultValue } = field;
+    const { isEmbedded, isRequired, isScalar, isArray, isArrayRequired, isPrimaryKey, defaultValue } = field;
     const modelType = `${type}${suffix}`;
     if (suffix && !isScalar) type = isEmbedded ? modelType : 'ID';
     type = isArray ? `[${type}${isArrayRequired ? '!' : ''}]` : type;
     if (!suffix && isRequired) type += '!';
-    if (suffix === 'InputCreate' && isRequired && defaultValue != null) type += '!';
+    if (suffix === 'InputCreate' && !isPrimaryKey && isRequired && defaultValue == null) type += '!';
     return type;
   }