More tests, fixed transforms.

Author: tlivings

dist/index.d.ts

@@ -52,6 +52,11 @@ export interface IGraphQLComponent<TContextType extends ComponentContext = Compo
     readonly dataSourceOverrides?: IDataSource[];
     federation?: boolean;
 }
+/**
+ * GraphQLComponent class for building modular GraphQL schemas
+ * @template TContextType - The type of the context object
+ * @implements {IGraphQLComponent}
+ */
 export default class GraphQLComponent<TContextType extends ComponentContext = ComponentContext> implements IGraphQLComponent {
     _schema: GraphQLSchema;
     _types: TypeSource;
@@ -66,6 +71,7 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
     _federation: boolean;
     _dataSourceContextInject: DataSourceInjectionFunction;
     _transforms: SchemaMapper[];
+    private _transformedSchema;
     constructor({ types, resolvers, mocks, imports, context, dataSources, dataSourceOverrides, pruneSchema, pruneSchemaOptions, federation, transforms }: IGraphQLComponentOptions);
     get context(): IContextWrapper;
     get name(): string;
@@ -77,4 +83,7 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
     get dataSourceOverrides(): IDataSource[];
     set federation(flag: boolean);
     get federation(): boolean;
+    dispose(): void;
+    private transformSchema;
+    private validateConfig;
 }

dist/index.js

@@ -13,12 +13,15 @@
   "scripts": {
     "build": "tsc",
     "prepublish": "npm run build",
-    "test": "tape -r ts-node/register test/**.ts",
+    "test": "tape -r ts-node/register \"test/**/*.ts\"",
     "start-composition": "DEBUG=graphql-component ts-node examples/composition/server/index.ts",
     "start-federation": "DEBUG=graphql-component node examples/federation/run-federation-example.js",
     "lint": "npx eslint src/index.ts",
     "cover": "nyc npm test",
-    "update-deps": "ncu -u && npm install"
+    "update-deps": "ncu -u && npm install",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "precommit": "npm run lint && npm run test",
+    "prepare": "husky install"
   },
   "author": "Trevor Livingston <tlivings@gmail.com>",
   "repository": "https://github.com/ExpediaGroup/graphql-component",
@@ -31,15 +34,15 @@
     "@graphql-tools/schema": "^10.0.8",
     "@graphql-tools/stitch": "^9.4.0",
     "@graphql-tools/utils": "^10.5.6",
-    "@types/graphql": "^14.5.0",
-    "@types/node": "^22.9.1",
     "debug": "^4.3.7"
   },
   "peerDependencies": {
     "graphql": "^16.0.0"
   },
   "devDependencies": {
     "@apollo/gateway": "^2.9.3",
+    "@types/graphql": "^14.5.0",
+    "@types/node": "^22.9.1",
     "@typescript-eslint/eslint-plugin": "^8.22.0",
     "@typescript-eslint/parser": "^8.22.0",
     "apollo-server": "^3.13.0",
@@ -54,7 +57,9 @@
     "tape": "^5.9.0",
     "ts-node": "^10.9.2",
     "typescript": "^5.6.3",
-    "typescript-eslint": "^8.22.0"
+    "typescript-eslint": "^8.22.0",
+    "husky": "^8.0.0",
+    "prettier": "^2.8.8"
   },
   "nyc": {
     "include": [
@@ -73,5 +78,8 @@
     "sourceMap": true,
     "instrument": true,
     "all": true
+  },
+  "engines": {
+    "node": ">=18.0.0"
   }
 }

package.json

@@ -78,6 +78,11 @@ export interface IGraphQLComponent<TContextType extends ComponentContext = Compo
   federation?: boolean;
 }
 
+/**
+ * GraphQLComponent class for building modular GraphQL schemas
+ * @template TContextType - The type of the context object
+ * @implements {IGraphQLComponent}
+ */
 export default class GraphQLComponent<TContextType extends ComponentContext = ComponentContext> implements IGraphQLComponent {
   _schema: GraphQLSchema;
   _types: TypeSource;
@@ -92,6 +97,7 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
   _federation: boolean;
   _dataSourceContextInject: DataSourceInjectionFunction;
   _transforms: SchemaMapper[]
+  private _transformedSchema: GraphQLSchema;
 
   constructor({
     types,
@@ -169,14 +175,18 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
       return ctx as TContextType;
     };
 
+    this.validateConfig({ types, imports, mocks, federation });
+
   }
 
   get context(): IContextWrapper {
 
-    const contextFn = async (context): Promise<ComponentContext> => {
+    const contextFn = async (context: Record<string, unknown>): Promise<ComponentContext> => {
       debug(`building root context`);
-
-      for (const { name, fn } of contextFn._middleware) {
+      
+      const middleware: MiddlewareEntry[] = (contextFn as any)._middleware || [];
+      
+      for (const { name, fn } of middleware) {
         debug(`applying ${name} middleware`);
         context = await fn(context);
       }
@@ -212,74 +222,76 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
   }
 
   get schema(): GraphQLSchema {
-    if (this._schema) {
-      return this._schema;
-    }
-
-    let makeSchema: (schemaConfig: any) => GraphQLSchema = undefined;
+    try {
+      if (this._schema) {
+        return this._schema;
+      }
 
-    if (this._federation) {
-      makeSchema = (schemaConfig): GraphQLSchema => {
-        return buildFederatedSchema(schemaConfig);
-      };
-    }
-    else {
-      makeSchema = makeExecutableSchema;
-    }
+      let makeSchema: (schemaConfig: any) => GraphQLSchema;
 
-    if (this._imports.length > 0) {
-      // iterate through the imports and construct subschema configuration objects
-      const subschemas = this._imports.map((imp) => {
-        const { component, configuration = {} } = imp;
+      if (this._federation) {
+        makeSchema = buildFederatedSchema;
+      } else {
+        makeSchema = makeExecutableSchema;
+      }
 
-        return {
-          schema: component.schema,
-          ...configuration
-        };
-      });
-
-      // construct an aggregate schema from the schemas of imported
-      // components and this component's types/resolvers (if present)
-      this._schema = stitchSchemas({
-        subschemas,
-        typeDefs: this._types,
-        resolvers: this._resolvers,
-        mergeDirectives: true
-      });
-    }
-    else {
-      const schemaConfig = {
-        typeDefs: mergeTypeDefs(this._types),
-        resolvers: this._resolvers
+      if (this._imports.length > 0) {
+        // iterate through the imports and construct subschema configuration objects
+        const subschemas = this._imports.map((imp) => {
+          const { component, configuration = {} } = imp;
+
+          return {
+            schema: component.schema,
+            ...configuration
+          };
+        });
+
+        // construct an aggregate schema from the schemas of imported
+        // components and this component's types/resolvers (if present)
+        this._schema = stitchSchemas({
+          subschemas,
+          typeDefs: this._types,
+          resolvers: this._resolvers,
+          mergeDirectives: true
+        });
       }
+      else {
+        const schemaConfig = {
+          typeDefs: mergeTypeDefs(this._types),
+          resolvers: this._resolvers
+        }
 
-      this._schema = makeSchema(schemaConfig);
-    }
+        this._schema = makeSchema(schemaConfig);
+      }
 
-    if (this._transforms) {
-      this._schema = transformSchema(this._schema, this._transforms);
-    }
+      if (this._transforms) {
+        this._schema = this.transformSchema(this._schema, this._transforms);
+      }
 
-    if (this._mocks !== undefined && typeof this._mocks === 'boolean' && this._mocks === true) {
-      debug(`adding default mocks to the schema for ${this.name}`);
-      // if mocks are a boolean support simply applying default mocks
-      this._schema = addMocksToSchema({ schema: this._schema, preserveResolvers: true });
-    }
-    else if (this._mocks !== undefined && typeof this._mocks === 'object') {
-      debug(`adding custom mocks to the schema for ${this.name}`);
-      // else if mocks is an object, that means the user provided
-      // custom mocks, with which we pass them to addMocksToSchema so they are applied
-      this._schema = addMocksToSchema({ schema: this._schema, mocks: this._mocks, preserveResolvers: true });
-    }
+      if (this._mocks !== undefined && typeof this._mocks === 'boolean' && this._mocks === true) {
+        debug(`adding default mocks to the schema for ${this.name}`);
+        // if mocks are a boolean support simply applying default mocks
+        this._schema = addMocksToSchema({ schema: this._schema, preserveResolvers: true });
+      }
+      else if (this._mocks !== undefined && typeof this._mocks === 'object') {
+        debug(`adding custom mocks to the schema for ${this.name}`);
+        // else if mocks is an object, that means the user provided
+        // custom mocks, with which we pass them to addMocksToSchema so they are applied
+        this._schema = addMocksToSchema({ schema: this._schema, mocks: this._mocks, preserveResolvers: true });
+      }
 
-    if (this._pruneSchema) {
-      debug(`pruning the schema for ${this.name}`);
-      this._schema = pruneSchema(this._schema, this._pruneSchemaOptions);
-    }
+      if (this._pruneSchema) {
+        debug(`pruning the schema for ${this.name}`);
+        this._schema = pruneSchema(this._schema, this._pruneSchemaOptions);
+      }
 
-    debug(`created schema for ${this.name}`);
+      debug(`created schema for ${this.name}`);
 
-    return this._schema;
+      return this._schema;
+    } catch (error) {
+      debug(`Error creating schema for ${this.name}: ${error}`);
+      throw new Error(`Failed to create schema for component ${this.name}: ${error.message}`);
+    }
   }
 
   get types(): TypeSource {
@@ -310,6 +322,57 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
     return this._federation;
   }
 
+  public dispose(): void {
+    this._schema = null;
+    this._types = null;
+    this._resolvers = null;
+    this._imports = null;
+    this._dataSources = null;
+    this._dataSourceOverrides = null;
+  }
+
+  private transformSchema(schema: GraphQLSchema, transforms: SchemaMapper[]): GraphQLSchema {
+    if (this._transformedSchema) {
+      return this._transformedSchema;
+    }
+
+    const functions = {};
+    const mapping = {};
+
+    for (const transform of transforms) {
+      for (const [key, fn] of Object.entries(transform)) {
+        if (!mapping[key]) {
+          functions[key] = [];
+          let result = undefined;
+          mapping[key] = function (...args) {
+            while (functions[key].length) {
+              const mapper = functions[key].shift();
+              result = mapper(...args);
+              if (!result) {
+                break;
+              }
+            }
+            return result;
+          }
+        }
+        functions[key].push(fn);
+      }
+    }
+
+    this._transformedSchema = mapSchema(schema, mapping);
+    return this._transformedSchema;
+  }
+
+  private validateConfig(options: IGraphQLComponentOptions): void {
+    if (options.federation && !options.types) {
+      throw new Error('Federation requires type definitions');
+    }
+
+    if (options.mocks && typeof options.mocks !== 'boolean' && typeof options.mocks !== 'object') {
+      throw new Error('mocks must be either boolean or object');
+    }
+  }
+
 }
 
 /**
@@ -442,34 +505,7 @@ const bindResolvers = function (bindContext: IGraphQLComponent, resolvers: IReso
   return boundResolvers;
 };
 
-/**
- * Transforms a schema using the provided transforms
- * @param {GraphQLSchema} schema The schema to transform
- * @param {SchemaMapper[]} transforms An array of schema transforms
- * @returns {GraphQLSchema} The transformed schema
- */
-const transformSchema = function (schema: GraphQLSchema, transforms: SchemaMapper[]) {
-  const functions = {};
-  const mapping = {};
-
-  for (const transform of transforms) {
-    for (const [key, fn] of Object.entries(transform)) {
-      if (!mapping[key]) {
-        functions[key] = [];
-        mapping[key] = function (arg) {
-          while (functions[key].length) {
-            const mapper = functions[key].shift();
-            arg = mapper(arg);
-            if (!arg) {
-              break;
-            }
-          }
-          return arg;
-        }
-      }
-      functions[key].push(fn);
-    }
-  }
-
-  return mapSchema(schema, mapping);
+interface MiddlewareEntry {
+  name: string;
+  fn: ContextFunction;
 }