WIP: exposing module loader to plugins

packages/bagel/src/__tests__/modules/foo.js

@@ -0,0 +1 @@
+module.exports = 'foo';

packages/bagel/src/__tests__/plugins.spec.js

@@ -1,6 +1,6 @@
 // @flow
 
-import bagel from '../index';
+import bagel, {logger} from '../index';
 import createWebsocketServer from '../websocket_io';
 import wsRequest from '../utils/ws_request';
 import type {Resolver} from 'bagel-module-loader';
@@ -30,6 +30,8 @@ const startBagelWithPlugins = async (plugins = []) => {
     port,
     transport: createWebsocketServer
   });
+
+  logger.setGlobalLevel('info');
 };
 
 afterEach(() => {
@@ -325,3 +327,33 @@ it('attaches metadata in "pre job response" lifecycles', async () => {
   expect(meta.vegtable).toBe('squash');
   expect(batchResponseMetadata.foo).toBe('bar');
 });
+
+it('exposes module loader to plugins', async () => {
+  const testLoadModulePlugin = {
+    beforeBatch({batchResponseMetadata, loadModule}) {
+      expect(
+        loadModule({
+          //         jobRequest,
+          //         parentBatchRequest,
+          //         jobResponseMetadata,
+          //         batchResponseMetadata
+        }).default
+      ).toBe('foo');
+    }
+  };
+
+  await startBagelWithPlugins([testLoadModulePlugin]);
+  const requestData = {
+    ID_0: {
+      name: './__tests__/example_components/simple_react_component',
+      metadata: {
+        jobId: 'ID_0'
+      },
+      props: {}
+    }
+  };
+
+  await wsRequestToUrl(requestData);
+
+  expect.assertions(1);
+});

packages/bagel/src/index.js

@@ -78,7 +78,11 @@ const init = (
     withLoadModuleHooks,
     withRenderHooks,
     afterRequestComplete
-  } = withPluginHooks(config.plugins);
+  } = withPluginHooks({
+    plugins: config.plugins,
+    // eslint-disable-next-line no-use-before-define
+    loadModule: (...args) => loadModuleHandler({...args})
+  });
 
   /**
    * Here we wire together the various functions bagel needs. In order to

packages/bagel/src/types.js

@@ -103,15 +103,17 @@ type LoadModuleHandler = JobHandlerRequest => Promise<RenderHandlerRequest>;
 type LifeCycleMethod<T> = T => Promise<void> | void;
 
 type Plugin = {
-  beforeBatch?: LifeCycleMethod<BatchHandlerRequest>,
-  afterBatch?: LifeCycleMethod<BatchHandlerResponse>,
-  afterRequestComplete?: LifeCycleMethod<BatchHandlerRequest>,
-  beforeJob?: LifeCycleMethod<JobHandlerRequest>,
-  afterJob?: LifeCycleMethod<JobHandlerResponse>,
-  beforeLoadModule?: LifeCycleMethod<JobHandlerRequest>,
-  afterLoadModule?: LifeCycleMethod<RenderHandlerRequest>,
-  beforeRender?: LifeCycleMethod<RenderHandlerRequest>,
-  afterRender?: LifeCycleMethod<JobHandlerResponse>
+  beforeBatch?: LifeCycleMethod<BatchHandlerRequest & LoadModuleHandler>,
+  afterBatch?: LifeCycleMethod<BatchHandlerResponse & LoadModuleHandler>,
+  afterRequestComplete?: LifeCycleMethod<
+    BatchHandlerRequest & LoadModuleHandler
+  >,
+  beforeJob?: LifeCycleMethod<JobHandlerRequest & LoadModuleHandler>,
+  afterJob?: LifeCycleMethod<JobHandlerResponse & LoadModuleHandler>,
+  beforeLoadModule?: LifeCycleMethod<JobHandlerRequest & LoadModuleHandler>,
+  afterLoadModule?: LifeCycleMethod<RenderHandlerRequest & LoadModuleHandler>,
+  beforeRender?: LifeCycleMethod<RenderHandlerRequest & LoadModuleHandler>,
+  afterRender?: LifeCycleMethod<JobHandlerResponse & LoadModuleHandler>
 };
 
 type Config = {

packages/bagel/src/utils/plugin_utils.js

@@ -20,7 +20,7 @@ const makePromiseChain = <T: Object>(fns: Array<LifeCycleMethod<T>>) => (
        * Promise.resolve will slow us down only for one tick per wrapped function.
        */
       Promise.resolve(prev)
-        .then(next)
+        .then(() => next({...initialValue}))
         /**
          * We never care about the return value - it's always the initialValue
          * passed by reference.

packages/bagel/src/utils/with_plugin_hooks.js

@@ -22,7 +22,7 @@ import type {
   LoadModuleHandler
 } from '../types';
 
-const withPluginHooks = (plugins: Array<Plugin>) => {
+const withPluginHooks = ({plugins}: {plugins: Array<Plugin>}) => {
   // Group all of the life cycle hooks by name.
   const pluginLifeCycleHooks = groupObjectsByKeys(plugins);