@coderich/autograph 0.13.5 → 0.13.7

package/package.json

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

package/src/data/Resolver.js

@@ -23,7 +23,7 @@ module.exports = class Resolver {
     this.#dataLoaders = this.#createDataLoaders();
     this.driver = this.raw; // Alias
     this.model = this.match; // Alias
-    Util.set(this.#context, 'autograph.resolver', this);
+    Util.set(this.#context, `${this.#schema.namespace}.resolver`, this);
   }
 
   getContext() {

package/src/schema/Schema.js

@@ -23,17 +23,25 @@ module.exports = class Schema {
 
   constructor(config) {
     this.#config = config;
-    this.#typeDefs = Schema.#framework();
+    this.#config.namespace ??= 'autograph';
+    this.#config.directives ??= {};
+    this.#config.directives.model ??= 'model';
+    this.#config.directives.field ??= 'field';
+    this.#config.directives.link ??= 'link';
+    this.#config.directives.index ??= 'index';
+    this.#typeDefs = Schema.#framework(this.#config.directives);
   }
 
   /**
    * Decorate each marked @model with config-driven field decorators
    */
   decorate() {
+    const { directives } = this.#config;
+
     this.#typeDefs = visit(this.#typeDefs, {
       enter: (node) => {
         if (modelKinds.includes(node.kind) && !operations.includes(node.name.value)) {
-          const directive = node.directives.find(({ name }) => name.value === 'model');
+          const directive = node.directives.find(({ name }) => name.value === directives.model);
 
           if (directive) {
             const arg = directive.arguments.find(({ name }) => name.value === 'decorate');
@@ -66,7 +74,16 @@ module.exports = class Schema {
     else if (schema instanceof Schema) schema = schema.toObject();
 
     if (schema.typeDefs) {
-      const typeDefs = Util.ensureArray(schema.typeDefs).map(td => (typeof td === 'string' ? parse(td) : td));
+      const typeDefs = Util.ensureArray(schema.typeDefs).map((td) => {
+        try {
+          const $td = typeof td === 'string' ? parse(td) : td;
+          return $td;
+        } catch (e) {
+          console.log(`Unable to parse typeDef (being ignored):\n${td}`); // eslint-disable-line
+          return null;
+        }
+      }).filter(Boolean);
+
       this.#typeDefs = mergeTypeDefs([typeDefs, this.#typeDefs], { noLocation: true, reverseDirectives: true, onFieldTypeConflict: a => a });
     }
 
@@ -84,7 +101,8 @@ module.exports = class Schema {
     if (this.#schema) return this.#schema;
 
     // const schema = buildASTSchema(this.#typeDefs);
-    this.#schema = { types: {}, models: {}, indexes: [] };
+    const { directives, namespace } = this.#config;
+    this.#schema = { types: {}, models: {}, indexes: [], namespace };
     let model, field, isField, isList;
     const thunks = [];
 
@@ -131,8 +149,8 @@ module.exports = class Schema {
           const target = isField ? field : model;
           target.directives[name] = target.directives[name] || {};
 
-          if (name === 'model') model.isMarkedModel = true;
-          else if (name === 'index') this.#schema.indexes.push({ model });
+          if (name === directives.model) model.isMarkedModel = true;
+          else if (name === directives.index) this.#schema.indexes.push({ model });
 
           node.arguments.forEach((arg) => {
             const key = arg.name.value;
@@ -140,54 +158,54 @@ module.exports = class Schema {
             const value = values ? values.map(n => n.value) : val;
             target.directives[name][key] = value;
 
-            if (name === 'index') this.#schema.indexes[this.#schema.indexes.length - 1][key] = value;
+            if (name === directives.index) this.#schema.indexes[this.#schema.indexes.length - 1][key] = value;
 
             switch (`${name}-${key}`) {
               // Model specific directives
-              case 'model-id': {
+              case `${directives.model}-id`: {
                 model.idField = value;
                 break;
               }
-              case 'model-source': {
+              case `${directives.model}-source`: {
                 model.source = this.#config.dataSources?.[value];
                 break;
               }
-              case 'model-loader': {
+              case `${directives.model}-loader`: {
                 model.loader = this.#config.dataLoaders?.[value];
                 break;
               }
-              case 'model-embed': {
+              case `${directives.model}-embed`: {
                 model.isEmbedded = value;
                 break;
               }
               // Field specific directives
-              case 'field-default': {
+              case `${directives.field}-default`: {
                 field.defaultValue = value;
                 break;
               }
-              case 'field-connection': {
+              case `${directives.field}-connection`: {
                 field.isConnection = value;
                 break;
               }
-              case 'field-validate': { // Alias for finalize
+              case `${directives.field}-validate`: { // Alias for finalize
                 target.pipelines.finalize = target.pipelines.finalize.concat(value).filter(Boolean);
                 break;
               }
-              case 'link-by': {
+              case `${directives.link}-by`: {
                 field.linkBy = value;
                 field.isVirtual = true;
                 break;
               }
               // Generic by target directives
-              case 'model-persist': case 'field-persist': {
+              case `${directives.model}-persist`: case `${directives.field}-persist`: {
                 target.isPersistable = value;
                 break;
               }
-              case 'model-crud': case 'model-scope': case 'field-crud': {
+              case `${directives.model}-crud`: case `${directives.model}-scope`: case `${directives.field}-crud`: {
                 target[key] = Util.nvl(value, '');
                 break;
               }
-              case 'model-key': case 'model-meta': case 'field-key': case 'field-onDelete': {
+              case `${directives.model}-key`: case `${directives.model}-meta`: case `${directives.field}-key`: case `${directives.field}-onDelete`: {
                 target[key] = value;
                 break;
               }
@@ -344,7 +362,9 @@ module.exports = class Schema {
     return this.#config.makeExecutableSchema(this.toObject());
   }
 
-  static #framework() {
+  static #framework(directives) {
+    const { model, field, link, index } = directives;
+
     return parse(`
       scalar AutoGraphMixed
 
@@ -352,7 +372,7 @@ module.exports = class Schema {
       enum AutoGraphOnDeleteEnum { cascade nullify restrict defer }
       enum AutoGraphPipelineEnum { ${Object.keys(Pipeline).filter(k => !k.startsWith('$')).join(' ')} }
 
-      directive @model(
+      directive @${model}(
         id: String # Specify the ID/PK field (default "id")
         key: String # Specify db table/collection name
         crud: AutoGraphMixed # CRUD API
@@ -364,7 +384,7 @@ module.exports = class Schema {
         persist: Boolean # Persist this model (default true)
       ) on OBJECT | INTERFACE
 
-      directive @field(
+      directive @${field}(
         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)
@@ -382,13 +402,13 @@ module.exports = class Schema {
         validate: [AutoGraphPipelineEnum!] # Alias for finalize
       ) on FIELD_DEFINITION | INPUT_FIELD_DEFINITION | SCALAR
 
-      directive @link(
+      directive @${link}(
         to: AutoGraphMixed  # The MODEL to link to (default's to modelRef)
         by: AutoGraphMixed! # The FIELD to match yourself by
         use: AutoGraphMixed # The VALUE to use (default's to @link'd value); useful for many-to-many relationships
       ) on FIELD_DEFINITION
 
-      directive @index(
+      directive @${index}(
         name: String
         on: [AutoGraphMixed!]!
         type: AutoGraphIndexEnum!
@@ -535,12 +555,12 @@ module.exports = class Schema {
         }, {}),
         Query: queryModels.reduce((prev, model) => {
           return Object.assign(prev, {
-            [`get${model}`]: (doc, args, context, info) => context.autograph.resolver.match(model).args(args).info(info).one({ required: true }),
+            [`get${model}`]: (doc, args, context, info) => context[schema.namespace].resolver.match(model).args(args).info(info).one({ required: true }),
             [`find${model}`]: (doc, args, context, info) => {
               return {
-                edges: () => context.autograph.resolver.match(model).args(args).info(info).many(),
-                count: () => context.autograph.resolver.match(model).args(args).info(info).count(),
-                pageInfo: () => context.autograph.resolver.match(model).args(args).info(info).many(),
+                edges: () => context[schema.namespace].resolver.match(model).args(args).info(info).many(),
+                count: () => context[schema.namespace].resolver.match(model).args(args).info(info).count(),
+                pageInfo: () => context[schema.namespace].resolver.match(model).args(args).info(info).many(),
               };
             },
           });
@@ -549,7 +569,7 @@ module.exports = class Schema {
             const { id } = args;
             const [modelName] = fromGUID(id);
             const model = schema.models[modelName];
-            return context.autograph.resolver.match(model).id(id).info(info).one().then((result) => {
+            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
               return result;
@@ -558,9 +578,9 @@ module.exports = class Schema {
         }),
         ...(mutationModels.length ? {
           Mutation: mutationModels.reduce((prev, model) => {
-            if (model.crud?.includes('c')) prev[`create${model}`] = (doc, args, context, info) => context.autograph.resolver.match(model).args(args).info(info).save(args.input);
-            if (model.crud?.includes('u')) prev[`update${model}`] = (doc, args, context, info) => context.autograph.resolver.match(model).args(args).info(info).save(args.input);
-            if (model.crud?.includes('d')) prev[`delete${model}`] = (doc, args, context, info) => context.autograph.resolver.match(model).args(args).info(info).delete();
+            if (model.crud?.includes('c')) prev[`create${model}`] = (doc, args, context, info) => context[schema.namespace].resolver.match(model).args(args).info(info).save(args.input);
+            if (model.crud?.includes('u')) prev[`update${model}`] = (doc, args, context, info) => context[schema.namespace].resolver.match(model).args(args).info(info).save(args.input);
+            if (model.crud?.includes('d')) prev[`delete${model}`] = (doc, args, context, info) => context[schema.namespace].resolver.match(model).args(args).info(info).delete();
             return prev;
           }, {}),
         } : {}),
@@ -569,7 +589,7 @@ module.exports = class Schema {
             [model]: Object.values(model.fields).filter(field => field.model?.isEntity).reduce((prev2, field) => {
               return Object.assign(prev2, {
                 [field]: (doc, args, context, info) => {
-                  return context.autograph.resolver.match(field.model).where({ [field.linkBy]: doc[field.linkField.name] }).args(args).info(info).resolve(info);
+                  return context[schema.namespace].resolver.match(field.model).where({ [field.linkBy]: doc[field.linkField.name] }).args(args).info(info).resolve(info);
                 },
               });
             }, {}),