Process the schema

Author: phortx

dist/vuex-orm-graphql.esm.js

@@ -3565,6 +3565,19 @@ var Logger = /** @class */ (function () {
             console.log.apply(console, this.PREFIX.concat(messages));
         }
     };
+    /**
+     * Wrapper for console.warn.
+     * @param {Array<any>} messages
+     */
+    Logger.prototype.warn = function () {
+        var messages = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            messages[_i] = arguments[_i];
+        }
+        if (this.enabled) {
+            console.warn.apply(console, this.PREFIX.concat(messages));
+        }
+    };
     /**
      * Logs a graphql query in a readable format and with all information like fetch policy and variables.
      * @param {string | DocumentNode} query
@@ -9832,6 +9845,42 @@ var Apollo = /** @class */ (function () {
     return Apollo;
 }());
 
+var Schema = /** @class */ (function () {
+    function Schema(schema) {
+        var _this = this;
+        this.schema = schema;
+        this.types = new Map();
+        this.mutations = new Map();
+        this.queries = new Map();
+        this.schema.types.forEach(function (t) { return _this.types.set(t.name, t); });
+        this.getType('Query').fields.forEach(function (f) { return _this.queries.set(f.name, f); });
+        this.getType('Mutation').fields.forEach(function (f) { return _this.mutations.set(f.name, f); });
+    }
+    Schema.prototype.getType = function (name) {
+        name = upcaseFirstLetter(name);
+        var type = this.types.get(name);
+        if (!type)
+            throw new Error("Couldn't find Type of name " + name + " in the GraphQL Schema.");
+        return type;
+    };
+    Schema.prototype.getMutation = function (name) {
+        var mutation = this.mutations.get(name);
+        if (!mutation)
+            throw new Error("Couldn't find Mutation of name " + name + " in the GraphQL Schema.");
+        return mutation;
+    };
+    Schema.prototype.getQuery = function (name) {
+        var query = this.types.get(name);
+        if (!query)
+            throw new Error("Couldn't find Query of name " + name + " in the GraphQL Schema.");
+        return query;
+    };
+    Schema.prototype.returnsConnection = function (field) {
+        return field.type.name.endsWith('TypeConnection');
+    };
+    return Schema;
+}());
+
 var __awaiter$1 = (undefined && undefined.__awaiter) || function (thisArg, _arguments, P, generator) {
     return new (P || (P = Promise))(function (resolve, reject) {
         function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
@@ -9941,8 +9990,11 @@ var Context = /** @class */ (function () {
                         return [4 /*yield*/, this.apollo.simpleQuery(introspectionQuery, {}, true, context)];
                     case 1:
                         result = _a.sent();
-                        this.schema = result.data.__schema;
-                        this.logger.log('GraphQL Schema successful fetched', this.schema);
+                        this.schema = new Schema(result.data.__schema);
+                        this.logger.log('GraphQL Schema successful fetched', result);
+                        this.logger.log('Starting to process the schema ...');
+                        this.processSchema();
+                        this.logger.log('Schema procession done ...');
                         _a.label = 2;
                     case 2: return [2 /*return*/];
                 }
@@ -9978,6 +10030,29 @@ var Context = /** @class */ (function () {
             Model.augment(model);
         });
     };
+    Context.prototype.processSchema = function () {
+        var _this = this;
+        this.models.forEach(function (model) {
+            var type;
+            try {
+                type = _this.schema.getType(model.singularName);
+            }
+            catch (error) {
+                _this.logger.warn("Ignoring entity " + model.singularName + " because it's not in the schema.");
+                return;
+            }
+            model.fields.forEach(function (field, fieldName) {
+                if (!type.fields.find(function (f) { return f.name === fieldName; })) {
+                    _this.logger.warn("Ignoring field " + model.singularName + "." + fieldName + " because it's not in the schema.");
+                    // TODO: Move skipFields to the model
+                    model.baseModel.skipFields = model.baseModel.skipFields ? model.baseModel.skipFields : [];
+                    if (!model.baseModel.skipFields.includes(fieldName)) {
+                        model.baseModel.skipFields.push(fieldName);
+                    }
+                }
+            });
+        });
+    };
     return Context;
 }());
 

src/common/context.ts

@@ -5,7 +5,8 @@ import { Components } from '@vuex-orm/core/lib/plugins/use';
 import { downcaseFirstLetter } from '../support/utils';
 import Apollo from '../graphql/apollo';
 import Database from '@vuex-orm/core/lib/database/Database';
-import { Data, Options, Schema } from '../support/interfaces';
+import { Data, Field, GraphQLSchema, GraphQLType, Options } from '../support/interfaces';
+import Schema from '../graphql/schema';
 const inflection = require('inflection');
 
 const introspectionQuery = `
@@ -158,9 +159,12 @@ export default class Context {
       };
 
       const result = await this.apollo.simpleQuery(introspectionQuery, {}, true, context);
-      this.schema = result.data.__schema;
+      this.schema = new Schema(result.data.__schema);
 
-      this.logger.log('GraphQL Schema successful fetched', this.schema);
+      this.logger.log('GraphQL Schema successful fetched', result);
+      this.logger.log('Starting to process the schema ...');
+      this.processSchema();
+      this.logger.log('Schema procession done ...');
     }
   }
 
@@ -192,4 +196,29 @@ export default class Context {
       Model.augment(model);
     });
   }
+
+  private processSchema () {
+    this.models.forEach((model: Model) => {
+      let type: GraphQLType;
+
+      try {
+        type = this.schema!.getType(model.singularName);
+      } catch (error) {
+        this.logger.warn(`Ignoring entity ${model.singularName} because it's not in the schema.`);
+        return;
+      }
+
+      model.fields.forEach((field: Field, fieldName: string) => {
+        if (!type.fields!.find(f => f.name === fieldName)) {
+          this.logger.warn(`Ignoring field ${model.singularName}.${fieldName} because it's not in the schema.`);
+
+          // TODO: Move skipFields to the model
+          model.baseModel.skipFields = model.baseModel.skipFields ? model.baseModel.skipFields : [];
+          if (!model.baseModel.skipFields.includes(fieldName)) {
+            model.baseModel.skipFields.push(fieldName);
+          }
+        }
+      });
+    });
+  }
 }

src/common/logger.ts

@@ -67,6 +67,16 @@ export default class Logger {
     }
   }
 
+  /**
+   * Wrapper for console.warn.
+   * @param {Array<any>} messages
+   */
+  public warn (...messages: Array<any>): void {
+    if (this.enabled) {
+      console.warn(...this.PREFIX, ...messages);
+    }
+  }
+
   /**
    * Logs a graphql query in a readable format and with all information like fetch policy and variables.
    * @param {string | DocumentNode} query

src/graphql/schema.ts

@@ -0,0 +1,50 @@
+import { GraphQLField, GraphQLSchema, GraphQLType } from '../support/interfaces';
+import { upcaseFirstLetter } from '../support/utils';
+
+export default class Schema {
+  private schema: GraphQLSchema;
+  private types: Map<string, GraphQLType>;
+  private mutations: Map<string, GraphQLField>;
+  private queries: Map<string, GraphQLField>;
+
+  public constructor (schema: GraphQLSchema) {
+    this.schema = schema;
+    this.types = new Map<string, GraphQLType>();
+    this.mutations = new Map<string, GraphQLField>();
+    this.queries = new Map<string, GraphQLField>();
+
+    this.schema.types.forEach((t: GraphQLType) => this.types.set(t.name, t));
+
+    this.getType('Query').fields!.forEach(f => this.queries.set(f.name, f));
+    this.getType('Mutation').fields!.forEach(f => this.mutations.set(f.name, f));
+  }
+
+  public getType (name: string): GraphQLType {
+    name = upcaseFirstLetter(name);
+    const type = this.types.get(name);
+
+    if (!type) throw new Error(`Couldn't find Type of name ${name} in the GraphQL Schema.`);
+
+    return type;
+  }
+
+  public getMutation (name: string): GraphQLField {
+    const mutation = this.mutations.get(name);
+
+    if (!mutation) throw new Error(`Couldn't find Mutation of name ${name} in the GraphQL Schema.`);
+
+    return mutation;
+  }
+
+  public getQuery (name: string): GraphQLType {
+    const query = this.types.get(name);
+
+    if (!query) throw new Error(`Couldn't find Query of name ${name} in the GraphQL Schema.`);
+
+    return query;
+  }
+
+  public returnsConnection (field: GraphQLField) {
+    return field.type.name.endsWith('TypeConnection');
+  }
+}

src/support/interfaces.ts

@@ -35,16 +35,34 @@ export interface Data {
   [index: string]: any;
 }
 
-export interface Filter extends Object {
+export interface Filter {
   [index: string]: any;
 }
 
-export interface Arguments extends Object {
+export interface Arguments {
   [index: string]: any;
 }
 
-export interface Schema extends Object {
-  [index: string]: any;
+export interface GraphQLType {
+  description: string;
+  name: string;
+  fields?: Array<GraphQLField>;
+  inputFields?: Array<GraphQLField>;
+}
+
+export interface GraphQLField {
+  description: string;
+  name: string;
+  type: GraphQLTypeDefinition;
+}
+
+export interface GraphQLTypeDefinition {
+  kind: string;
+  name: string;
+}
+
+export interface GraphQLSchema {
+  types: Array<GraphQLType>;
 }
 
 export interface Field {

test/integration/VuexORMGraphQL.spec.js

@@ -50,7 +50,7 @@ describe('VuexORMGraphQL', () => {
 
     const context = Context.getInstance();
     expect(!!context.schema).not.toEqual(false);
-    expect(context.schema.types[0].name).toEqual('Boolean')
+    expect(context.schema.getType('Post').name).toEqual('Post')
   });
 
   describe('fetch', () => {

test/support/mock-data.js

@@ -17,7 +17,6 @@ export class User extends ORMModel {
 export class Video extends ORMModel {
   static entity = 'videos';
   static eagerLoad = ['comments'];
-  static skipFields = ['ignoreMe'];
 
   static fields () {
     return {