@coderich/autograph 0.13.6 → 0.13.8

package/package.json

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

package/src/schema/Schema.js

@@ -24,17 +24,24 @@ module.exports = class Schema {
   constructor(config) {
     this.#config = config;
     this.#config.namespace ??= 'autograph';
-    this.#typeDefs = Schema.#framework();
+    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');
@@ -94,7 +101,8 @@ module.exports = class Schema {
     if (this.#schema) return this.#schema;
 
     // const schema = buildASTSchema(this.#typeDefs);
-    this.#schema = { types: {}, models: {}, indexes: [], namespace: this.#config.namespace };
+    const { directives, namespace } = this.#config;
+    this.#schema = { types: {}, models: {}, indexes: [], namespace };
     let model, field, isField, isList;
     const thunks = [];
 
@@ -141,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;
@@ -150,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;
               }
@@ -354,15 +362,19 @@ 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
+      scalar AutoGraphDriver # DELETE WHEN MIGRATED
 
       enum AutoGraphIndexEnum { unique }
+      enum AutoGraphAuthzEnum { private protected public } # DELETE WHEN MIGRATED
       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
@@ -372,9 +384,19 @@ module.exports = class Schema {
         decorate: AutoGraphMixed # Decorator (default: "default")
         embed: Boolean # Mark this an embedded model (default false)
         persist: Boolean # Persist this model (default true)
+
+        # TEMP TO APPEASE TRANSITION
+        driver: AutoGraphDriver # External data driver
+        createdAt: String # Specify db key (default "createdAt")
+        updatedAt: String # Specify db key (default "updatedAt")
+        gqlScope: AutoGraphMixed # Dictate how GraphQL API behaves
+        dalScope: AutoGraphMixed # Dictate how the DAL behaves
+        fieldScope: AutoGraphMixed # Dictate how a FIELD may use me
+        authz: AutoGraphAuthzEnum # Access level used for authorization (default: private)
+        namespace: String # Logical grouping of models that can be globbed (useful for authz)
       ) 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)
@@ -390,15 +412,25 @@ module.exports = class Schema {
         serialize: [AutoGraphPipelineEnum!]
         finalize: [AutoGraphPipelineEnum!]
         validate: [AutoGraphPipelineEnum!] # Alias for finalize
+
+        # TEMP TO APPEASE TRANSITION
+        id: String # Specify the ModelRef this field FK References
+        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!]
       ) 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!