@bluelibs/runner 2.2.3 → 3.0.0

package/dist/types/registerable.d.ts

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,5 @@
+"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

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

package/dist/types/resources.d.ts

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,5 @@
+"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

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

package/dist/types/symbols.d.ts

@@ -0,0 +1,24 @@
+export declare const symbolTask: unique symbol;
+export declare const symbolResource: unique symbol;
+export declare const symbolResourceWithConfig: unique symbol;
+export declare const symbolEvent: unique symbol;
+export declare const symbolMiddleware: unique symbol;
+export declare const symbolMiddlewareConfigured: unique symbol;
+export declare const symbolMiddlewareGlobal: unique symbol;
+export declare const symbolMiddlewareEverywhereTasks: unique symbol;
+export declare const symbolMiddlewareEverywhereResources: unique symbol;
+export declare const symbolFilePath: unique symbol;
+export declare const symbolDispose: unique symbol;
+export declare const symbolStore: unique symbol;
+export declare const symbols: {
+    task: symbol;
+    resource: symbol;
+    resourceWithConfig: symbol;
+    event: symbol;
+    middleware: symbol;
+    middlewareEverywhereTasks: symbol;
+    middlewareEverywhereResources: symbol;
+    filePath: symbol;
+    dispose: symbol;
+    store: symbol;
+};

package/dist/types/symbols.js

@@ -0,0 +1,30 @@
+"use strict";
+// Layer 1: Foundation - Symbols and Constants
+// No dependencies
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.symbols = exports.symbolStore = exports.symbolDispose = exports.symbolFilePath = exports.symbolMiddlewareEverywhereResources = exports.symbolMiddlewareEverywhereTasks = exports.symbolMiddlewareGlobal = exports.symbolMiddlewareConfigured = exports.symbolMiddleware = exports.symbolEvent = exports.symbolResourceWithConfig = exports.symbolResource = exports.symbolTask = void 0;
+exports.symbolTask = Symbol("runner.task");
+exports.symbolResource = Symbol("runner.resource");
+exports.symbolResourceWithConfig = Symbol("runner.resourceWithConfig");
+exports.symbolEvent = Symbol("runner.event");
+exports.symbolMiddleware = Symbol("runner.middleware");
+exports.symbolMiddlewareConfigured = Symbol("runner.middlewareConfigured");
+exports.symbolMiddlewareGlobal = Symbol("runner.middlewareGlobal");
+exports.symbolMiddlewareEverywhereTasks = Symbol("runner.middlewareGlobalTasks");
+exports.symbolMiddlewareEverywhereResources = Symbol("runner.middlewareGlobalResources");
+exports.symbolFilePath = Symbol("runner.filePath");
+exports.symbolDispose = Symbol("runner.dispose");
+exports.symbolStore = Symbol("runner.store");
+exports.symbols = {
+    task: exports.symbolTask,
+    resource: exports.symbolResource,
+    resourceWithConfig: exports.symbolResourceWithConfig,
+    event: exports.symbolEvent,
+    middleware: exports.symbolMiddleware,
+    middlewareEverywhereTasks: exports.symbolMiddlewareEverywhereTasks,
+    middlewareEverywhereResources: exports.symbolMiddlewareEverywhereResources,
+    filePath: exports.symbolFilePath,
+    dispose: exports.symbolDispose,
+    store: exports.symbolStore,
+};
+//# sourceMappingURL=symbols.js.map

package/dist/types/symbols.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"symbols.js","sourceRoot":"","sources":["../../src/types/symbols.ts"],"names":[],"mappings":";AAAA,8CAA8C;AAC9C,kBAAkB;;;AAEL,QAAA,UAAU,GAAkB,MAAM,CAAC,aAAa,CAAC,CAAC;AAClD,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,wBAAwB,GAAkB,MAAM,CAC3D,2BAA2B,CAC5B,CAAC;AACW,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AACpD,QAAA,gBAAgB,GAAkB,MAAM,CAAC,mBAAmB,CAAC,CAAC;AAC9D,QAAA,0BAA0B,GAAkB,MAAM,CAC7D,6BAA6B,CAC9B,CAAC;AACW,QAAA,sBAAsB,GAAkB,MAAM,CACzD,yBAAyB,CAC1B,CAAC;AACW,QAAA,+BAA+B,GAAkB,MAAM,CAClE,8BAA8B,CAC/B,CAAC;AACW,QAAA,mCAAmC,GAAkB,MAAM,CACtE,kCAAkC,CACnC,CAAC;AAEW,QAAA,cAAc,GAAkB,MAAM,CAAC,iBAAiB,CAAC,CAAC;AAC1D,QAAA,aAAa,GAAkB,MAAM,CAAC,gBAAgB,CAAC,CAAC;AACxD,QAAA,WAAW,GAAkB,MAAM,CAAC,cAAc,CAAC,CAAC;AAEpD,QAAA,OAAO,GAAG;IACrB,IAAI,EAAE,kBAAU;IAChB,QAAQ,EAAE,sBAAc;IACxB,kBAAkB,EAAE,gCAAwB;IAC5C,KAAK,EAAE,mBAAW;IAClB,UAAU,EAAE,wBAAgB;IAC5B,yBAAyB,EAAE,uCAA+B;IAC1D,6BAA6B,EAAE,2CAAmC;IAClE,QAAQ,EAAE,sBAAc;IACxB,OAAO,EAAE,qBAAa;IACtB,KAAK,EAAE,mBAAW;CACnB,CAAC"}

package/dist/types/tasks.d.ts

@@ -0,0 +1,41 @@
+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

@@ -0,0 +1,5 @@
+"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

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

package/dist/types/utilities.d.ts

@@ -0,0 +1,7 @@
+export type Optional<T> = {
+    [K in keyof T]?: T[K];
+};
+export type IsVoid<T> = [T] extends [void] ? true : false;
+export type IsOptional<T> = undefined extends T ? true : false;
+export type OptionalOrVoidOrAnything<T> = IsVoid<T> extends true ? void : IsOptional<T> extends true ? Optional<T> : T;
+export type OnlyOptionalFields<T> = {} extends T ? true : false;

package/dist/types/utilities.js

@@ -0,0 +1,5 @@
+"use strict";
+// Layer 1: Foundation - Utility Types
+// No dependencies
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=utilities.js.map

package/dist/types/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.js","sourceRoot":"","sources":["../../src/types/utilities.ts"],"names":[],"mappings":";AAAA,sCAAsC;AACtC,kBAAkB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bluelibs/runner",
-  "version": "2.2.3",
+  "version": "3.0.0",
   "description": "BlueLibs Runner",
   "main": "dist/index.js",
   "repository": {
@@ -10,10 +10,9 @@
   "scripts": {
     "build": "tsc",
     "watch": "tsc -w",
-    "pretest": "npm run build",
-    "test": "jest --verbose dist/__tests__/index.js",
-    "test:dev": "jest --verbose src/__tests__/index.ts --watch",
-    "coverage": "jest --verbose src/__tests__/index.ts --coverage",
+    "test": "jest --verbose --runInBand",
+    "test:dev": "jest --verbose --watch",
+    "coverage": "jest --verbose --coverage",
     "test:clean": "jest --clearCache",
     "testonly": "npm test",
     "test:ci": "npm run coverage -- --ci --maxWorkers=2  --reporters=default --reporters=jest-junit",
@@ -23,6 +22,7 @@
   },
   "devDependencies": {
     "@types/benchmark": "^2.1.5",
+    "@types/express": "^5.0.3",
     "@types/graphql": "^0.11.3",
     "@types/jest": "^27.0.0",
     "@types/node": "^20.0.0",
@@ -32,6 +32,7 @@
     "eslint": "^6.6.0",
     "eslint-config-prettier": "6.3.0",
     "eslint-plugin-prettier": "3.1.1",
+    "express": "^5.1.0",
     "jest": "^29.0.0",
     "jest-junit": "^10.0.0",
     "prettier": "^2.0.5",
@@ -46,5 +47,8 @@
   "typescript": {
     "definition": "dist/index.d.ts"
   },
-  "license": "MIT"
+  "license": "MIT",
+  "dependencies": {
+    "lru-cache": "^11.1.0"
+  }
 }

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

@@ -7,7 +7,7 @@ import {
 } from "../../define";
 import { run } from "../../run";
 
-describe("Benchmarks", () => {
+describe.skip("Benchmarks", () => {
   let suite: Benchmark.Suite;
 
   beforeEach(() => {

package/src/__tests__/context.test.ts

@@ -0,0 +1,91 @@
+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!
+    });
+  });
+});

package/src/__tests__/errors.test.ts

@@ -56,13 +56,13 @@ describe("Errors", () => {
   });
 
   it("should throw circularDependencies error", async () => {
-    const task1 = defineTask({
+    const task1: any = defineTask({
       id: "task1",
-      dependencies: () => ({ task2 }),
+      dependencies: (): any => ({ task2 }),
       run: async () => {},
     });
 
-    const task2 = defineTask({
+    const task2: any = defineTask({
       id: "task2",
       dependencies: { task1 },
       run: async () => {},
@@ -249,8 +249,11 @@ describe("Errors", () => {
   });
 
   it("should throw error, when a double global() is used on a middleware", async () => {
-    const first = defineMiddleware({ id: "x", run: async () => {} }).global();
-    expect(() => first.global()).toThrow(
+    const first = defineMiddleware({
+      id: "x",
+      run: async () => {},
+    }).everywhere();
+    expect(() => first.everywhere()).toThrow(
       Errors.middlewareAlreadyGlobal("x").message
     );
   });

package/src/__tests__/globalEvents.test.ts

@@ -1,4 +1,4 @@
-import { globalEvents } from "../globalEvents";
+import { globalEvents } from "../globals/globalEvents";
 import { defineTask, defineResource } from "../define";
 import { run } from "../run";