@modern-js/plugin 1.0.0 → 1.1.2

package/src/waterfall/sync.ts

@@ -1,26 +1,22 @@
-import { createCounter } from '../counter';
 import {
-  Hooks,
-  runHooks,
-  fromContainer,
   Container,
-  createContainer,
   useContainer,
-} from '../context';
+  createPipeline,
+  Middleware,
+} from 'farrow-pipeline';
 
 const WATERFALL_SYMBOL = Symbol('WATERFALL_SYMBOL');
 
-// eslint-disable-next-line @typescript-eslint/no-invalid-void-type
-export type Brook<I = unknown> = (I: I) => I | void;
-export type BrookInput<I = unknown> = Brook<I> | { brook: Brook<I> };
+export type Brook<I = unknown> = (I: I) => I;
+export type BrookInput<I = unknown> = Brook<I> | { middleware: Brook<I> };
 export type Brooks<I = unknown> = Brook<I>[];
 export type BrookInputs<I = unknown> = BrookInput<I>[];
 
 export const getBrook = <I>(input: BrookInput<I>) => {
   if (typeof input === 'function') {
     return input;
-  } else if (input && typeof input.brook === 'function') {
-    return input.brook;
+  } else if (input && typeof input.middleware === 'function') {
+    return input.middleware;
   }
   // eslint-disable-next-line @typescript-eslint/no-base-to-string,@typescript-eslint/restrict-template-expressions
   throw new Error(`${input} is not a Brook or { brook: Brook }`);
@@ -35,7 +31,7 @@ export type RunWaterfallOptions<I = unknown> = {
 export type Waterfall<I = void> = {
   run: (input: I, options?: RunWaterfallOptions<I>) => I;
   use: (...I: BrookInputs<I>) => Waterfall<I>;
-  brook: Brook<I>;
+  middleware: Brook<I>;
   [WATERFALL_SYMBOL]: true;
 };
 
@@ -77,53 +73,38 @@ export type Waterfalls2Runners<PS extends WaterfallRecord | void> = {
 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export const createWaterfall = <I = void>(): Waterfall<I> => {
-  const middlewares: Brooks<I> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createCounter<I, I>((index, input, next) => {
-      if (index >= middlewares.length) {
-        return input;
-      }
-
-      return runHooks(() => next(middlewares[index](input) || input), hooks);
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createPipeline<I, I>();
 
-  const use: Waterfall<I>['use'] = (...input) => {
-    middlewares.push(...input.map(getBrook));
+  const use: Waterfall<I>['use'] = (...brooks) => {
+    pipeline.use(...brooks.map(getBrook).map(mapBrookToMiddleware));
     return waterfall;
   };
 
-  const run: Waterfall<I>['run'] = (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
+  const run: Waterfall<I>['run'] = (input, options) =>
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    pipeline.run(input, { ...options, onLast: input => input });
 
-    return runner.start(input);
-  };
-
-  const brook: Waterfall<I>['brook'] = input => {
+  const middleware: Waterfall<I>['middleware'] = input => {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     const container = useContainer();
-    return run(input, { container });
+    // eslint-disable-next-line @typescript-eslint/no-shadow
+    return pipeline.run(input, { container, onLast: input => input });
   };
 
-  const waterfall = {
+  const waterfall: Waterfall<I> = {
+    ...pipeline,
     use,
     run,
-    brook,
-    [WATERFALL_SYMBOL]: true as const,
+    middleware,
+    [WATERFALL_SYMBOL]: true,
   };
-
   return waterfall;
 };
 
 export const isWaterfall = (input: any): input is Waterfall<any> =>
   Boolean(input?.[WATERFALL_SYMBOL]);
+
+const mapBrookToMiddleware =
+  <I>(brook: Brook<I>): Middleware<I, I> =>
+  (input, next) =>
+    next(brook(input));

package/src/workflow/async.ts

@@ -1,14 +1,13 @@
-import { createAsyncCounter } from '../counter';
-import { Hooks, runHooks, fromContainer, createContainer } from '../context';
+import { MaybeAsync, createAsyncPipeline, Middleware } from 'farrow-pipeline';
 import type { RunWorkflowOptions } from './sync';
 
 const ASYNC_WORKFLOW_SYMBOL = Symbol('ASYNC_WORKFLOW_SYMBOL');
 
-export type AsyncWorker<I, O> = (I: I) => O | Promise<O>;
+export type AsyncWorker<I, O> = (I: I) => MaybeAsync<O>;
 export type AsyncWorkers<I, O> = AsyncWorker<I, O>[];
 
 export type AsyncWorkflow<I, O> = {
-  run: (input: I, options?: RunWorkflowOptions) => Promise<O[]>;
+  run: (input: I, options?: RunWorkflowOptions) => MaybeAsync<O[]>;
   use: (...I: AsyncWorkers<I, O>) => AsyncWorkflow<I, O>;
   [ASYNC_WORKFLOW_SYMBOL]: true;
 };
@@ -54,43 +53,25 @@ export const createAsyncWorkflow = <I = void, O = unknown>(): AsyncWorkflow<
   I,
   O
 > => {
-  const middlewares: AsyncWorkers<I, O> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createAsyncCounter<I, O[]>(async (index, input, next) => {
-      if (index >= middlewares.length) {
-        return [];
-      }
-
-      const middleware = middlewares[index];
-      return runHooks(async () => {
-        const result = await middleware(input);
-        const rest = await next(input);
-        return [result, ...rest];
-      }, hooks);
-    });
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createAsyncPipeline<I, O[]>();
 
   const use: AsyncWorkflow<I, O>['use'] = (...input) => {
-    middlewares.push(...input);
+    pipeline.use(...input.map(mapAsyncWorkerToAsyncMiddleware));
     return workflow;
   };
 
   const run: AsyncWorkflow<I, O>['run'] = async (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
-
-    return runner.start(input);
+    const result = pipeline.run(input, { ...options, onLast: () => [] });
+    if (isPromise(result)) {
+      // eslint-disable-next-line @typescript-eslint/no-shadow,promise/prefer-await-to-then
+      return result.then(result => result.filter(Boolean));
+    } else {
+      return result.filter(Boolean);
+    }
   };
 
-  const workflow = {
+  const workflow: AsyncWorkflow<I, O> = {
+    ...pipeline,
     use,
     run,
     [ASYNC_WORKFLOW_SYMBOL]: true as const,
@@ -98,3 +79,18 @@ export const createAsyncWorkflow = <I = void, O = unknown>(): AsyncWorkflow<
 
   return workflow;
 };
+
+const mapAsyncWorkerToAsyncMiddleware =
+  <I, O>(worker: AsyncWorker<I, O>): Middleware<I, MaybeAsync<O[]>> =>
+  async (input, next) =>
+    [await worker(input), ...(await next(input))];
+
+function isPromise(obj: any): obj is Promise<any> {
+  /* eslint-disable promise/prefer-await-to-then */
+  return (
+    Boolean(obj) &&
+    (typeof obj === 'object' || typeof obj === 'function') &&
+    typeof obj.then === 'function'
+  );
+  /* eslint-enable promise/prefer-await-to-then */
+}

package/src/workflow/parallel.ts

@@ -1,6 +1,5 @@
-import { createAsyncCounter } from '../counter';
-import { Hooks, runHooks, fromContainer, createContainer } from '../context';
-import { AsyncWorker, AsyncWorkers } from './async';
+import { MaybeAsync, createPipeline, Middleware } from 'farrow-pipeline';
+import type { AsyncWorker, AsyncWorkers } from './async';
 import type { RunWorkflowOptions } from './sync';
 
 const PARALLEL_WORKFLOW_SYMBOL = Symbol('PARALLEL_WORKFLOW_SYMBOL');
@@ -69,47 +68,30 @@ export const createParallelWorkflow = <
   I = void,
   O = unknown,
 >(): ParallelWorkflow<I, O> => {
-  const middlewares: AsyncWorkers<I, O> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createAsyncCounter<I, O[]>((index, input, next) => {
-      if (index >= middlewares.length) {
-        return Promise.resolve<any[]>([]);
-      }
-
-      const middleware = middlewares[index];
-      return runHooks(
-        async () => Promise.all([middleware(input), ...(await next(input))]),
-        hooks,
-      );
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createPipeline<I, MaybeAsync<O>[]>();
 
   const use: ParallelWorkflow<I, O>['use'] = (...input) => {
-    middlewares.push(...input);
+    pipeline.use(...input.map(mapParallelWorkerToAsyncMiddleware));
     return workflow;
   };
 
-  const run: ParallelWorkflow<I, O>['run'] = async (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
-
-    return runner.start(input);
-  };
+  const run: ParallelWorkflow<I, O>['run'] = async (input, options) =>
+    // eslint-disable-next-line promise/prefer-await-to-then
+    Promise.all(pipeline.run(input, { ...options, onLast: () => [] })).then(
+      result => result.filter(Boolean),
+    );
 
-  const workflow = {
-    use,
+  const workflow: ParallelWorkflow<I, O> = {
+    ...pipeline,
     run,
+    use,
     [PARALLEL_WORKFLOW_SYMBOL]: true as const,
   };
 
   return workflow;
 };
+
+const mapParallelWorkerToAsyncMiddleware =
+  <I, O>(worker: AsyncWorker<I, O>): Middleware<I, MaybeAsync<O>[]> =>
+  (input, next) =>
+    [worker(input), ...next(input)];

package/src/workflow/sync.ts

@@ -1,11 +1,4 @@
-import { createCounter } from '../counter';
-import {
-  Hooks,
-  runHooks,
-  fromContainer,
-  Container,
-  createContainer,
-} from '../context';
+import { Container, createPipeline, Middleware } from 'farrow-pipeline';
 
 const WORKFLOW_SYMBOL = Symbol('WORKFLOW_SYMBOL');
 
@@ -58,40 +51,20 @@ export type Workflows2Runners<PS extends WorkflowRecord | void> = {
 
 // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
 export const createWorkflow = <I = void, O = unknown>(): Workflow<I, O> => {
-  const middlewares: Workers<I, O> = [];
-
-  const createCurrentRunner = (hooks: Hooks) =>
-    createCounter<I, O[]>((index, input, next) => {
-      if (index >= middlewares.length) {
-        return [];
-      }
-
-      const middleware = middlewares[index];
-      return runHooks(() => [middleware(input), ...next(input)], hooks);
-    });
-
-  const currentContainer = createContainer();
-  const currentHooks = fromContainer(currentContainer);
-  const currentRunner = createCurrentRunner(currentHooks);
+  const pipeline = createPipeline<I, O[]>();
 
   const use: Workflow<I, O>['use'] = (...input) => {
-    middlewares.push(...input);
+    pipeline.use(...input.map(mapWorkerToMiddleware));
     return workflow;
   };
 
-  const run: Workflow<I, O>['run'] = (input, options) => {
-    const container = options?.container ?? currentContainer;
-    const hooks =
-      container === currentContainer ? currentHooks : fromContainer(container);
-    const runner =
-      container === currentContainer
-        ? currentRunner
-        : createCurrentRunner(hooks);
-
-    return runner.start(input);
+  const run: Workflow<I, O>['run'] = async (input, options) => {
+    const result = pipeline.run(input, { ...options, onLast: () => [] });
+    return result.filter(Boolean);
   };
 
-  const workflow = {
+  const workflow: Workflow<I, O> = {
+    ...pipeline,
     use,
     run,
     [WORKFLOW_SYMBOL]: true as const,
@@ -102,3 +75,8 @@ export const createWorkflow = <I = void, O = unknown>(): Workflow<I, O> => {
 
 export const isWorkflow = (input: any): input is Workflow<unknown, unknown> =>
   Boolean(input?.[WORKFLOW_SYMBOL]);
+
+const mapWorkerToMiddleware =
+  <I, O>(worker: Worker<I, O>): Middleware<I, O[]> =>
+  (input, next) =>
+    [worker(input), ...next(input)];

package/tests/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: ['@modern-js'],
+  parserOptions: {
+    project: require.resolve('./tsconfig.json'),
+  },
+};

package/tests/async.test.ts

@@ -1,16 +1,20 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import { enable, disable } from 'farrow-pipeline/asyncHooks.node';
+import {
+  createPipeline,
+  createAsyncPipeline,
+  createContext,
+  createContainer,
+} from 'farrow-pipeline';
 import { main } from './fixtures/async/core';
 import foo from './fixtures/async/base/foo';
 import bar, { getBar } from './fixtures/async/base/bar';
 import dFoo from './fixtures/async/dynamic/foo';
 import dBar, { getNumber } from './fixtures/async/dynamic/bar';
 import { sleep } from './helpers';
-import { createContext, createContainer } from '@/context';
 import { createManager, createAsyncManager, useRunner } from '@/manager';
-import { enable, disable } from '@/asyncHooksImpl';
 import { createWaterfall, createAsyncWaterfall } from '@/waterfall';
-import { createPipeline, createAsyncPipeline } from '@/pipeline';
 import {
   createWorkflow,
   createAsyncWorkflow,

package/tests/fixtures/async/base/foo.ts

@@ -2,7 +2,6 @@ import { createPlugin } from '../core';
 import { initFooPlugins } from './fooManager';
 
 const foo = createPlugin(
-  // eslint-disable-next-line @typescript-eslint/require-await
   async () => {
     const fooManage = initFooPlugins();
 

package/tests/fixtures/async/base/fooManager.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createManager,
-} from '../../../..';
+} from '../../../../src';
 
 // foo plugin
 // eslint-disable-next-line @typescript-eslint/ban-types

package/tests/fixtures/async/core/index.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createContext,
-} from '../../../..';
+} from '../../../../src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 export type CTX = {};

package/tests/fixtures/async/dynamic/bar.ts

@@ -8,7 +8,6 @@ const bar = createPlugin(() => {
   return {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     preDev: () => {},
-    // eslint-disable-next-line @typescript-eslint/require-await
     fooWaterfall: async input => {
       number = 2;
       return input;

package/tests/fixtures/async/dynamic/foo.ts

@@ -1,4 +1,4 @@
-import { createAsyncWaterfall } from '../../../..';
+import { createAsyncWaterfall } from '../../../../src';
 import { createPlugin, registeManager, useRunner } from '../core';
 
 // declare new lifecircle type

package/tests/fixtures/sync/base/foo.ts

@@ -6,11 +6,9 @@ const foo = createPlugin(
     const fooManage = initFooPlugins();
 
     return {
-      // eslint-disable-next-line @typescript-eslint/require-await
       preDev: async () => {
         fooManage.fooWaterfall();
       },
-      // eslint-disable-next-line @typescript-eslint/require-await
       postDev: async () => {
         fooManage.fooWorflow();
       },

package/tests/fixtures/sync/base/fooManager.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createManager,
-} from '../../../..';
+} from '../../../../src';
 
 // foo plugin
 // eslint-disable-next-line @typescript-eslint/ban-types

package/tests/fixtures/sync/core/index.ts

@@ -3,7 +3,7 @@ import {
   createWaterfall,
   createWorkflow,
   createContext,
-} from '../../../..';
+} from '../../../../src';
 
 // eslint-disable-next-line @typescript-eslint/ban-types
 export type CTX = {};

package/tests/fixtures/sync/dynamic/bar.ts

@@ -12,7 +12,6 @@ const bar = createPlugin(() => {
   return {
     // eslint-disable-next-line @typescript-eslint/no-empty-function
     preDev: async () => {},
-    // eslint-disable-next-line @typescript-eslint/require-await
     fooWaterfall: async input => {
       number = 2;
       return input;

package/tests/fixtures/sync/dynamic/foo.ts

@@ -1,4 +1,4 @@
-import { createAsyncWaterfall } from '../../../..';
+import { createAsyncWaterfall } from '../../../../src';
 import { createPlugin, registeManager, useRunner } from '../core';
 
 // declare new lifecircle type

package/tests/pipeline.test.ts

@@ -1,18 +1,16 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import * as asyncHooksImpl from 'farrow-pipeline/asyncHooks.node';
 import { sleep } from './helpers';
 import {
   createContext,
   createContainer,
   createPipeline,
   createAsyncPipeline,
-  useAsyncPipeline,
   usePipeline,
   useContainer,
   isPipeline,
-  isAsyncPipeline,
 } from '@/index';
-import * as asyncHooksImpl from '@/asyncHooksImpl';
 
 describe('createPipeline', () => {
   it('basic usage', async () => {
@@ -528,11 +526,10 @@ describe('createPipeline', () => {
       const pipeline0 = createAsyncPipeline<string, string>();
       const pipeline1 = createAsyncPipeline<string, string>();
 
-      // eslint-disable-next-line @typescript-eslint/require-await
       pipeline0.use(async input => `${input} from pipeline0`);
 
       pipeline1.use(async input => {
-        const runPipeline1 = useAsyncPipeline(pipeline0);
+        const runPipeline1 = usePipeline(pipeline0);
 
         const text = await runPipeline1(' pipeline1');
 
@@ -544,15 +541,6 @@ describe('createPipeline', () => {
       expect(result).toEqual(`run pipeline1 from pipeline0`);
     });
 
-    it('isAsyncPipeline', () => {
-      const pipeline = createAsyncPipeline();
-
-      expect(isAsyncPipeline(pipeline)).toBeTruthy();
-      expect(isAsyncPipeline({})).toBeFalsy();
-      expect(isAsyncPipeline('test')).toBeFalsy();
-      expect(isAsyncPipeline(null)).toBeFalsy();
-    });
-
     it('support hooks', async () => {
       const pipeline = createAsyncPipeline<number, number>();
 
@@ -600,7 +588,8 @@ describe('createPipeline', () => {
     it('should throw error when all middlewares calling next() and onLast is not exist', async () => {
       const pipeline = createAsyncPipeline<number, number>();
 
-      pipeline.use((input, next) => next(input));
+      // eslint-disable-next-line promise/prefer-await-to-then
+      pipeline.use((input, next) => Promise.resolve().then(() => next(input)));
 
       await expect(() => pipeline.run(0)).rejects.toThrowError();
     });

package/tests/sync.test.ts

@@ -1,14 +1,18 @@
 // eslint-disable-next-line eslint-comments/disable-enable-pair
 /* eslint-disable max-lines */
+import {
+  createPipeline,
+  createAsyncPipeline,
+  createContext,
+  createContainer,
+} from 'farrow-pipeline';
 import { main } from './fixtures/sync/core';
 import foo from './fixtures/sync/base/foo';
 import bar, { getBar } from './fixtures/sync/base/bar';
 import dFoo from './fixtures/sync/dynamic/foo';
 import dBar, { getNumber, setNumber } from './fixtures/sync/dynamic/bar';
-import { createContext, createContainer } from '@/context';
 import { createManager, createAsyncManager, useRunner } from '@/manager';
 import { createWaterfall, createAsyncWaterfall } from '@/waterfall';
-import { createPipeline, createAsyncPipeline } from '@/pipeline';
 import {
   createWorkflow,
   createAsyncWorkflow,

package/tests/waterfall.test.ts

@@ -1,3 +1,4 @@
+import { enable, disable } from 'farrow-pipeline/asyncHooks.node';
 import { sleep } from './helpers';
 import {
   createWaterfall,
@@ -7,7 +8,6 @@ import {
   isWaterfall,
   isAsyncWaterfall,
 } from '@/index';
-import { enable, disable } from '@/asyncHooksImpl';
 
 describe('waterfall', () => {
   it('base usage', () => {
@@ -25,7 +25,6 @@ describe('waterfall', () => {
   it('should support async waterfall', async () => {
     const waterfall = createAsyncWaterfall<{ count: number }>();
 
-    // eslint-disable-next-line @typescript-eslint/require-await
     waterfall.use(async ({ count }) => ({ count: count + 1 }));
 
     waterfall.use(a => a);

package/dist/js/modern/asyncHooksImpl.js

@@ -1,63 +0,0 @@
-/**
- * Copyright Lucifier129 and other contributors.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- */
-import NodeAsyncHooks from 'async_hooks';
-import * as asyncHooksInterface from "./asyncHooksInterface";
-
-const createAsyncHooks = () => {
-  const store = new Map(); // eslint-disable-next-line node/no-unsupported-features/node-builtins
-
-  const hooks = NodeAsyncHooks.createHook({
-    init: (asyncId, _, triggerAsyncId) => {
-      if (store.has(triggerAsyncId)) {
-        const value = store.get(triggerAsyncId);
-        store.set(asyncId, value);
-      }
-    },
-    destroy: asyncId => {
-      if (store.has(asyncId)) {
-        store.delete(asyncId);
-      }
-    }
-  });
-
-  const set = value => {
-    store.set(NodeAsyncHooks.executionAsyncId(), value);
-  };
-
-  const get = () => store.get(NodeAsyncHooks.executionAsyncId());
-
-  const enable = () => {
-    hooks.enable();
-  };
-
-  const disable = () => {
-    hooks.disable();
-    store.clear();
-  };
-
-  return {
-    enable,
-    disable,
-    set,
-    get
-  };
-};
-
-export const enable = () => {
-  const hooks = createAsyncHooks();
-  disable();
-  asyncHooksInterface.impl(hooks);
-  hooks.enable();
-};
-export const disable = () => {
-  var _asyncHooksInterface$;
-
-  (_asyncHooksInterface$ = asyncHooksInterface.asyncHooks) === null || _asyncHooksInterface$ === void 0 ? void 0 : _asyncHooksInterface$.disable();
-  asyncHooksInterface.reset();
-};

package/dist/js/modern/asyncHooksInterface.js

@@ -1,16 +0,0 @@
-/**
- * Copyright Lucifier129 and other contributors.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file at
- * https://github.com/farrow-js/farrow/blob/master/LICENSE
- *
- */
-// eslint-disable-next-line import/no-mutable-exports
-export let asyncHooks;
-export const impl = implimentations => {
-  asyncHooks = implimentations;
-};
-export const reset = () => {
-  asyncHooks = undefined;
-};