Made datasources available on middleware.

Author: tlivings

CHANGELOG.md

@@ -1,5 +1,7 @@
 ### v6.0.2
 
+- [FIX] DataSources are now available in middleware context, enabling middleware to access component dataSources for authentication and other operations
+- [TESTS] Added test to verify dataSources availability in middleware
 - [PERFORMANCE] Enhanced context building with parallel import processing, and middleware optimization
 - [TESTS] Added comprehensive performance regression tests to validate optimization correctness and prevent breaking changes
 

src/index.ts

@@ -184,9 +184,14 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
     this._context = async (globalContext: Record<string, unknown>): Promise<TContextType> => {
       //BREAKING: The context injected into data sources won't have data sources on it
       const ctx = {
-        dataSources: this._dataSourceContextInject(globalContext)
+        dataSources: globalContext.dataSources || {}
       };
 
+      // Add this component's dataSources if not already present or if empty
+      if (!globalContext.dataSources || Object.keys(globalContext.dataSources).length === 0) {
+        Object.assign(ctx.dataSources, this._dataSourceContextInject(globalContext));
+      }
+
       // Only process imports if they exist
       if (this._imports.length > 0) {
         // Process imports in parallel if they're independent
@@ -228,7 +233,25 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
     const contextFn = async (context: Record<string, unknown>): Promise<ComponentContext> => {
       debug(`building root context`);
 
-      let processedContext = context;
+      // Inject dataSources early so middleware can access them
+      const dataSources = this._dataSourceContextInject(context);
+      
+      // Also gather data sources from imported components for middleware
+      const importedDataSources = {};
+      if (this._imports.length > 0) {
+        for (const { component } of this._imports) {
+          // Use the public dataSources getter and manually inject them
+          const componentDataSourcesArray = component.dataSources;
+          const componentDataSourceOverrides = component.dataSourceOverrides;
+          const componentInjector = createDataSourceContextInjector(componentDataSourcesArray, componentDataSourceOverrides);
+          const componentDataSources = componentInjector(context);
+          Object.assign(importedDataSources, componentDataSources);
+        }
+      }
+      
+      // Combine all data sources for middleware
+      const allDataSources = Object.assign({}, dataSources, importedDataSources);
+      let processedContext = Object.assign({}, context, { dataSources: allDataSources });
 
       // Apply middleware more efficiently
       if (this._middleware.length > 0) {
@@ -258,8 +281,6 @@ export default class GraphQLComponent<TContextType extends ComponentContext = Co
     return contextFn;
   }
 
-
-
   get name(): string {
     return this.constructor.name;
   }

test/context.ts

@@ -38,5 +38,81 @@ test('GraphQLComponent Context Tests', (t) => {
     assert.end();
   });
 
+  t.test('should have dataSources available in middleware', async (assert) => {
+    class TestDataSource {
+      name = 'TestDataSource';
+      
+      getData(context: any, id: string) {
+        return { id, fromDataSource: true };
+      }
+    }
+
+    const component = new GraphQLComponent({
+      types: `type Query { test: String }`,
+      dataSources: [new TestDataSource()]
+    });
+
+    let middlewareDataSources: any = null;
+    const contextFn = component.context;
+    contextFn.use('dataSourceTest', async (ctx) => {
+      middlewareDataSources = ctx.dataSources;
+      return {
+        ...ctx,
+        middlewareRan: true
+      };
+    });
+
+    const context = await contextFn({});
+    
+    assert.ok(middlewareDataSources, 'dataSources available in middleware');
+    assert.ok(middlewareDataSources.TestDataSource, 'TestDataSource available in middleware');
+    assert.equal(typeof middlewareDataSources.TestDataSource.getData, 'function', 'dataSource method available');
+    assert.ok(context.middlewareRan, 'middleware executed');
+    assert.end();
+  });
+
+  t.test('should preserve imported dataSources in context', async (assert) => {
+    class ImportedDataSource {
+      name = 'ImportedDataSource';
+      
+      getImportedData(context: any, id: string) {
+        return { id, fromImportedDataSource: true };
+      }
+    }
+
+    class LocalDataSource {
+      name = 'LocalDataSource';
+      
+      getLocalData(context: any, id: string) {
+        return { id, fromLocalDataSource: true };
+      }
+    }
+
+    const importedComponent = new GraphQLComponent({
+      types: `type ImportedQuery { imported: String }`,
+      dataSources: [new ImportedDataSource()]
+    });
+
+    const mainComponent = new GraphQLComponent({
+      types: `type Query { local: String }`,
+      dataSources: [new LocalDataSource()],
+      imports: [importedComponent]
+    });
+
+    const context = await mainComponent.context({});
+    
+    assert.ok(context.dataSources, 'dataSources available in context');
+    
+    // Check that imported dataSource is available
+    assert.ok(context.dataSources.ImportedDataSource, 'ImportedDataSource available in context');
+    assert.equal(typeof context.dataSources.ImportedDataSource.getImportedData, 'function', 'imported dataSource method available');
+    
+    // Check that local dataSource is also available
+    assert.ok(context.dataSources.LocalDataSource, 'LocalDataSource available in context');
+    assert.equal(typeof context.dataSources.LocalDataSource.getLocalData, 'function', 'local dataSource method available');
+    
+    assert.end();
+  });
+
   t.end();
 });