@bluelibs/runner 3.4.2 → 4.0.1

package/dist/types/middleware.d.ts

@@ -1,63 +0,0 @@
-import type { symbolMiddleware, symbolMiddlewareConfigured, symbolMiddlewareEverywhereTasks, symbolMiddlewareEverywhereResources } from './symbols';
-import type { IMiddlewareMeta } from './metadata';
-import type { DependencyMapType, DependencyValuesType } from './dependencies';
-export type MiddlewareEverywhereOptions = {
-    /**
-     * Enable this for tasks. Default is true.
-     */
-    tasks?: boolean;
-    /**
-     * Enable this for resources. Default is true.
-     */
-    resources?: boolean;
-};
-export interface IMiddlewareDefinition<TConfig = any, TDependencies extends DependencyMapType = any> {
-    /** Stable identifier. Omit to get an anonymous id. */
-    id?: string | symbol;
-    /** Static or lazy dependency map. */
-    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
-    /**
-     * The middleware body, called with task/resource execution input.
-     */
-    run: (input: IMiddlewareExecutionInput, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
-    meta?: IMiddlewareMeta;
-}
-export interface IMiddleware<TConfig = any, TDependencies extends DependencyMapType = any> extends IMiddlewareDefinition<TConfig, TDependencies> {
-    [symbolMiddleware]: true;
-    [symbolMiddlewareConfigured]?: boolean;
-    [symbolMiddlewareEverywhereTasks]?: boolean;
-    [symbolMiddlewareEverywhereResources]?: boolean;
-    id: string | symbol;
-    dependencies: TDependencies | (() => TDependencies);
-    /**
-     * Attach this middleware globally. Use options to scope to tasks/resources.
-     */
-    everywhere(config?: MiddlewareEverywhereOptions): IMiddleware<TConfig, TDependencies>;
-    /** Current configuration object (empty by default). */
-    config: TConfig;
-    /** Configure the middleware and return a marked, configured instance. */
-    with: (config: TConfig) => IMiddlewareConfigured<TConfig, TDependencies>;
-}
-export interface IMiddlewareConfigured<TConfig = any, TDependencies extends DependencyMapType = any> extends IMiddleware<TConfig, TDependencies> {
-    [symbolMiddlewareConfigured]: true;
-}
-export interface IMiddlewareDefinitionConfigured<C extends Record<string, any> = {}> {
-    middleware: IMiddleware<C>;
-    config?: C;
-}
-export interface IMiddlewareExecutionInput<TTaskInput = any, TResourceConfig = any> {
-    /** Task hook: present when wrapping a task run. */
-    task?: {
-        definition: any;
-        input: TTaskInput;
-    };
-    /** Resource hook: present when wrapping init/dispose. */
-    resource?: {
-        definition: any;
-        config: TResourceConfig;
-    };
-    next: (taskInputOrResourceConfig?: TTaskInput | TResourceConfig) => Promise<any>;
-}
-export type MiddlewareAttachments = IMiddleware<void> | IMiddleware<{
-    [K in any]?: any;
-}> | IMiddlewareConfigured<any>;

package/dist/types/middleware.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=middleware.js.map

package/dist/types/middleware.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"middleware.js","sourceRoot":"","sources":["../../src/types/middleware.ts"],"names":[],"mappings":""}

package/dist/types/registerable.d.ts

@@ -1,10 +0,0 @@
-import type { IsVoid, OnlyOptionalFields } from './utilities';
-import type { IResourceWithConfig } from './resources';
-import type { IResource } from './resources';
-import type { ITaskDefinition } from './tasks';
-import type { IMiddlewareDefinition } from './middleware';
-import type { IEventDefinition } from './events';
-export type RegisterableItems<T = any> = IResourceWithConfig<any> | IResource<void, any, any, any> | IResource<{
-    [K in any]?: any;
-}, any, any, any> | ITaskDefinition<any, any, any, any> | IMiddlewareDefinition<any> | IEventDefinition<any>;
-export type ValidateRegisterable<T> = T extends IResource<infer Config, any, any, any> ? IsVoid<Config> extends true ? T : OnlyOptionalFields<Config> extends true ? T : never : T;

package/dist/types/registerable.js

@@ -1,5 +0,0 @@
-"use strict";
-// Layer 4: Integration Types - Registerable Items
-// Imports all component types to define what can be registered
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=registerable.js.map

package/dist/types/registerable.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"registerable.js","sourceRoot":"","sources":["../../src/types/registerable.ts"],"names":[],"mappings":";AAAA,kDAAkD;AAClD,+DAA+D"}

package/dist/types/resources.d.ts

@@ -1,44 +0,0 @@
-import type { IResourceMeta } from './meta';
-import type { DependencyMapType, DependencyValuesType } from './dependency-core';
-import type { IEventDefinition, BeforeInitEventPayload, AfterInitEventPayload, OnErrorEventPayload } from './events';
-import type { IMiddleware } from './middleware';
-import type { ITask } from './tasks';
-import type { MiddlewareAttachments } from './tasks';
-export interface IResourceDefinition<TConfig = any, TValue = unknown, TDependencies extends DependencyMapType = {}, TContext = any, THooks = any, TRegisterableItems = any> {
-    id: string;
-    dependencies?: TDependencies | ((config: TConfig) => TDependencies);
-    register?: Array<any> | ((config: TConfig) => Array<any>);
-    init?: (this: any, config: TConfig, dependencies: DependencyValuesType<TDependencies>, context: TContext) => Promise<TValue>;
-    /**
-     * Clean-up function for the resource. This is called when the resource is no longer needed.
-     *
-     * @param value The value of the resource (undefined if no init method)
-     * @param config The configuration it received
-     * @param dependencies The dependencies it needed
-     * @returns Promise<void>
-     */
-    dispose?: (this: any, value: TValue, config: TConfig, dependencies: DependencyValuesType<TDependencies>, context: TContext) => Promise<void>;
-    meta?: IResourceMeta;
-    overrides?: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
-    middleware?: MiddlewareAttachments[];
-    context?: () => TContext;
-}
-export interface IResource<TConfig = void, TValue = any, TDependencies extends DependencyMapType = any, TContext = any> extends IResourceDefinition<TConfig, TValue, TDependencies, TContext> {
-    with(config: TConfig): IResourceWithConfig<TConfig, TValue, TDependencies>;
-    register: Array<any> | ((config: TConfig) => Array<any>);
-    /**
-     * These events are automatically populated after the task has been defined.
-     */
-    events: {
-        beforeInit: IEventDefinition<BeforeInitEventPayload<TConfig>>;
-        afterInit: IEventDefinition<AfterInitEventPayload<TConfig, TValue>>;
-        onError: IEventDefinition<OnErrorEventPayload>;
-    };
-    overrides: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
-    middleware: MiddlewareAttachments[];
-}
-export interface IResourceWithConfig<TConfig = any, TValue = any, TDependencies extends DependencyMapType = any> {
-    id: string;
-    resource: IResource<TConfig, TValue, TDependencies>;
-    config: TConfig;
-}

package/dist/types/resources.js

@@ -1,5 +0,0 @@
-"use strict";
-// Layer 3: Component Definitions - Resources
-// Imports from Layer 1, 2 & other Layer 3 files
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=resources.js.map

package/dist/types/resources.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"resources.js","sourceRoot":"","sources":["../../src/types/resources.ts"],"names":[],"mappings":";AAAA,6CAA6C;AAC7C,gDAAgD"}

package/dist/types/tasks.d.ts

@@ -1,41 +0,0 @@
-import type { ITaskMeta } from './meta';
-import type { DependencyMapType, DependencyValuesType } from './dependency-core';
-import type { IEventDefinition, IEvent, BeforeRunEventPayload, AfterRunEventPayload, OnErrorEventPayload } from './events';
-import type { IMiddleware, IMiddlewareConfigured } from './middleware';
-type ExtractEventParams<T> = T extends IEventDefinition<infer P> ? P : never;
-export type MiddlewareAttachments = IMiddleware<void> | IMiddleware<{
-    [K in any]?: any;
-}> | IMiddlewareConfigured<any>;
-export interface ITaskDefinition<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined> {
-    id: string;
-    dependencies?: TDependencies | (() => TDependencies);
-    middleware?: MiddlewareAttachments[];
-    /**
-     * Listen to events in a simple way
-     */
-    on?: TOn;
-    /**
-     * This makes sense only when `on` is specified to provide the order of the execution.
-     * The event with the lowest order will be executed first.
-     */
-    listenerOrder?: number;
-    meta?: ITaskMeta;
-    run: (input: TOn extends undefined ? TInput : IEvent<TOn extends "*" ? any : ExtractEventParams<TOn>>, dependencies: DependencyValuesType<TDependencies>) => TOutput;
-}
-/**
- * Task Interface (replaces forward declaration) - This is the response after the definition has been prepared. TODO: better naming?
- */
-export interface ITask<TInput = any, TOutput extends Promise<any> = any, TDependencies extends DependencyMapType = {}, TOn extends "*" | IEventDefinition<any> | undefined = undefined> extends ITaskDefinition<TInput, TOutput, TDependencies, TOn> {
-    dependencies: TDependencies | (() => TDependencies);
-    computedDependencies?: DependencyValuesType<TDependencies>;
-    middleware: MiddlewareAttachments[];
-    /**
-     * These events are automatically populated after the task has been defined.
-     */
-    events: {
-        beforeRun: IEventDefinition<BeforeRunEventPayload<TInput>>;
-        afterRun: IEventDefinition<AfterRunEventPayload<TInput, TOutput>>;
-        onError: IEventDefinition<OnErrorEventPayload>;
-    };
-}
-export {};

package/dist/types/tasks.js

@@ -1,5 +0,0 @@
-"use strict";
-// Layer 3: Component Definitions - Tasks
-// Imports from Layer 1, 2 & other Layer 3 files
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=tasks.js.map

package/dist/types/tasks.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tasks.js","sourceRoot":"","sources":["../../src/types/tasks.ts"],"names":[],"mappings":";AAAA,yCAAyC;AACzC,gDAAgD"}

package/src/__tests__/benchmark/benchmark.test.ts

@@ -1,148 +0,0 @@
-import * as Benchmark from "benchmark";
-import {
-  defineTask,
-  defineResource,
-  defineEvent,
-  defineMiddleware,
-} from "../../define";
-import { run } from "../../run";
-
-describe.skip("Benchmarks", () => {
-  let suite: Benchmark.Suite;
-
-  beforeEach(() => {
-    suite = new Benchmark.Suite();
-  });
-
-  it("should benchmark task execution", (done) => {
-    const testTask = defineTask({
-      id: "test.task",
-      run: async () => "Hello, World!",
-    });
-
-    const app = defineResource({
-      id: "app",
-      dependencies: { testTask },
-      register: [testTask],
-      async init(_, { testTask }) {
-        await testTask();
-      },
-    });
-
-    suite.add("Task Execution", {
-      defer: true,
-      fn: (deferred: { resolve: () => void }) => {
-        run(app).then(() => deferred.resolve());
-      },
-    });
-
-    suite.on("complete", function () {
-      console.log("Task Execution:", this[0].hz.toFixed(2), "ops/sec");
-      done();
-    });
-
-    suite.run({ async: true });
-  });
-
-  it("should benchmark resource initialization", (done) => {
-    const testResource = defineResource({
-      id: "test.resource",
-      init: async () => "Resource Value",
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [testResource],
-      dependencies: { testResource },
-      async init(_, { testResource }) {
-        expect(testResource).toBe("Resource Value");
-      },
-    });
-
-    suite.add("Resource Initialization", {
-      defer: true,
-      fn: (deferred: { resolve: () => void }) => {
-        run(app).then(() => deferred.resolve());
-      },
-    });
-
-    suite.on("complete", function () {
-      console.log("Resource Initialization:", this[0].hz.toFixed(2), "ops/sec");
-      done();
-    });
-
-    suite.run({ async: true });
-  });
-
-  it("should benchmark event emission", (done) => {
-    const testEvent = defineEvent<{ message: string }>({ id: "test.event" });
-    const eventHandler = jest.fn();
-
-    const handlerTask = defineTask({
-      id: "handler.task",
-      on: testEvent,
-      run: async ({ data }) => {
-        eventHandler(data.message);
-      },
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [testEvent, handlerTask],
-      dependencies: { testEvent },
-      async init(_, { testEvent }) {
-        await testEvent({ message: "Event emitted" });
-      },
-    });
-
-    suite.add("Event Emission", {
-      defer: true,
-      fn: (deferred: { resolve: () => void }) => {
-        run(app).then(() => deferred.resolve());
-      },
-    });
-
-    suite.on("complete", function () {
-      console.log("Event Emission:", this[0].hz.toFixed(2), "ops/sec");
-      done();
-    });
-
-    suite.run({ async: true });
-  });
-
-  it("should benchmark dependency resolution", (done) => {
-    const dep1 = defineResource({
-      id: "dep1",
-      init: async () => "Dep1 Value",
-    });
-
-    const dep2 = defineResource({
-      id: "dep2",
-      dependencies: { dep1 },
-      init: async (_, { dep1 }) => `Dep2 Value: ${dep1}`,
-    });
-
-    const app = defineResource({
-      id: "app",
-      register: [dep1, dep2],
-      dependencies: { dep2 },
-      async init(_, { dep2 }) {
-        expect(dep2).toBe("Dep2 Value: Dep1 Value");
-      },
-    });
-
-    suite.add("Dependency Resolution", {
-      defer: true,
-      fn: (deferred: { resolve: () => void }) => {
-        run(app).then(() => deferred.resolve());
-      },
-    });
-
-    suite.on("complete", function () {
-      console.log("Dependency Resolution:", this[0].hz.toFixed(2), "ops/sec");
-      done();
-    });
-
-    suite.run({ async: true });
-  });
-});

package/src/__tests__/benchmark/task-benchmark.test.ts

@@ -1,132 +0,0 @@
-import { defineTask, defineResource, defineMiddleware } from "../../define";
-import { run } from "../../run";
-
-// Benchmarks are environment-sensitive; keep skipped by default.
-describe("Task benchmarks - sync vs async", () => {
-  const iterations = 500;
-
-  it("compares sync vs async task execution without middleware", async () => {
-    const syncTask = defineTask<number, any>({
-      id: "bench.syncTask",
-      // Intentionally synchronous
-      run: ((n: number) => {
-        let acc = 0;
-        for (let i = 0; i < 200; i++) acc += (n + i) % 7;
-        return acc;
-      }) as any,
-    } as any);
-
-    const asyncTask = defineTask<number, Promise<number>>({
-      id: "bench.asyncTask",
-      run: async (n: number) => {
-        let acc = 0;
-        for (let i = 0; i < 200; i++) acc += (n + i) % 7;
-        return acc;
-      },
-    });
-
-    const app = defineResource({
-      id: "bench.app",
-      register: [syncTask, asyncTask],
-      dependencies: { syncTask, asyncTask },
-      async init(_, { syncTask, asyncTask }) {
-        // Warm-up
-        await asyncTask(0);
-        await syncTask(0 as any);
-
-        const syncStart = performance.now();
-        for (let i = 0; i < iterations; i++) {
-          // Note: sync path still awaited at the TaskRunner boundary
-          await syncTask(i as any);
-        }
-        const syncTime = performance.now() - syncStart;
-
-        const asyncStart = performance.now();
-        for (let i = 0; i < iterations; i++) {
-          await asyncTask(i);
-        }
-        const asyncTime = performance.now() - asyncStart;
-
-        // Log metrics for manual inspection
-        // eslint-disable-next-line no-console
-        console.log(
-          `Task benchmark (iterations=${iterations}) -> sync: ${syncTime.toFixed(
-            2
-          )}ms, async: ${asyncTime.toFixed(2)}ms`
-        );
-      },
-    });
-
-    const { dispose } = await run(app);
-    await dispose();
-  });
-
-  it("compares with a chain of pass-through middlewares", async () => {
-    const chainLength = 10;
-
-    const middlewares = Array.from({ length: chainLength }, (_, idx) =>
-      defineMiddleware({
-        id: `mw.${idx}`,
-        // Return the result of next() directly; no extra async wrapper here
-        run: ({ next }: any) => next(),
-      })
-    );
-
-    const syncTask = defineTask<number, any>({
-      id: "bench.syncTask.withMw",
-      middleware: middlewares,
-      // Intentionally synchronous
-      run: ((n: number) => {
-        let acc = 0;
-        for (let i = 0; i < 200; i++) acc += (n + i) % 7;
-        return acc;
-      }) as any,
-    } as any);
-
-    const asyncTask = defineTask<number, Promise<number>>({
-      id: "bench.asyncTask.withMw",
-      middleware: middlewares,
-      run: async (n: number) => {
-        let acc = 0;
-        for (let i = 0; i < 200; i++) acc += (n + i) % 7;
-        return acc;
-      },
-    });
-
-    const app = defineResource({
-      id: "bench.app.mw",
-      register: [...middlewares, syncTask, asyncTask],
-      dependencies: { syncTask, asyncTask },
-      async init(_, { syncTask, asyncTask }) {
-        // Warm-up
-        await asyncTask(0);
-        await syncTask(0 as any);
-
-        const iters = 5000;
-        const t0 = process.hrtime.bigint();
-        for (let i = 0; i < iters; i++) {
-          await syncTask(i as any);
-        }
-        const t1 = process.hrtime.bigint();
-        const syncNs = Number(t1 - t0);
-
-        const t2 = process.hrtime.bigint();
-        for (let i = 0; i < iters; i++) {
-          await asyncTask(i);
-        }
-        const t3 = process.hrtime.bigint();
-        const asyncNs = Number(t3 - t2);
-
-        // eslint-disable-next-line no-console
-        console.log(
-          `Task benchmark with ${chainLength} middlewares (iterations=${iters}) -> sync: ${(
-            syncNs / 1e6
-          ).toFixed(2)}ms, async: ${(asyncNs / 1e6).toFixed(2)}ms`
-        );
-      },
-    });
-
-    const { dispose } = await run(app);
-    await dispose();
-  });
-});

package/src/__tests__/context.test.ts

@@ -1,91 +0,0 @@
-import { createContext, task, run, resource } from "../index";
-import { ContextError } from "../context";
-
-describe("Context System", () => {
-  const TestContext = createContext<{ id: string }>();
-
-  test("useContext throws when missing", async () => {
-    const r = resource({
-      id: "test.context.use",
-      init: async () => TestContext.use(),
-    });
-
-    await expect(run(r)).rejects.toThrow(ContextError);
-
-    await TestContext.provide({ id: "1" }, async () => {
-      await expect(run(r)).resolves.toEqual({
-        value: { id: "1" },
-        dispose: expect.any(Function),
-      });
-    });
-  });
-
-  test("require middleware blocks missing context", async () => {
-    const t = task({
-      id: "task",
-      middleware: [TestContext.require()],
-      run: async () => "ok",
-    });
-
-    const r = resource({
-      id: "resource",
-      register: [t],
-      dependencies: { t },
-      init: async (_, deps) => deps.t(),
-    });
-    await expect(run(r)).rejects.toThrow(ContextError);
-
-    await TestContext.provide({ id: "1" }, async () => {
-      await expect(run(r)).resolves.toEqual({
-        value: "ok",
-        dispose: expect.any(Function),
-      });
-    });
-  });
-
-  test("concurrent provide calls are isolated", async () => {
-    const results: string[] = [];
-
-    const promises = [
-      TestContext.provide({ id: "user-1" }, async () => {
-        await new Promise((resolve) => setTimeout(resolve, 10)); // small delay
-        const context = TestContext.use();
-        results.push(context.id);
-        return context.id;
-      }),
-      TestContext.provide({ id: "user-2" }, async () => {
-        await new Promise((resolve) => setTimeout(resolve, 5)); // smaller delay
-        const context = TestContext.use();
-        results.push(context.id);
-        return context.id;
-      }),
-    ];
-
-    const values = await Promise.all(promises);
-
-    // Each context should maintain its own value
-    expect(values).toEqual(["user-1", "user-2"]);
-    expect(results).toEqual(["user-2", "user-1"]); // user-2 finishes first due to shorter delay
-  });
-
-  test("nested provide calls work correctly", async () => {
-    const result = await TestContext.provide({ id: "outer" }, async () => {
-      const outer = TestContext.use();
-
-      const inner = await TestContext.provide({ id: "inner" }, async () => {
-        return TestContext.use();
-      });
-
-      const afterInner = TestContext.use();
-
-      return { outer: outer.id, inner: inner.id, afterInner: afterInner.id };
-    });
-
-    // Outer context should be restored after inner provide completes
-    expect(result).toEqual({
-      outer: "outer",
-      inner: "inner",
-      afterInner: "outer", // This should be restored!
-    });
-  });
-});