@bluelibs/runner 3.4.2 → 4.0.1

package/src/globals/globalEvents.ts

@@ -1,125 +0,0 @@
-import { defineEvent } from "../define";
-import { ITask, IResource, IEvent } from "../defs";
-import { ILog } from "../models/Logger";
-
-export const globalEvents = {
-  beforeInit: defineEvent({
-    id: "globals.events.beforeInit",
-    meta: {
-      title: "Before Initialization",
-      description:
-        "Triggered before any resource or system-wide initialization occurs.",
-      tags: ["system"],
-    },
-  }),
-  afterInit: defineEvent({
-    id: "globals.events.afterInit",
-    meta: {
-      title: "After Initialization",
-      description:
-        "Fired after the system or resource initialization is completed.",
-      tags: ["system"],
-    },
-  }),
-  log: defineEvent<ILog>({
-    id: "globals.events.log",
-    meta: {
-      title: "Log Event",
-      description: "Used to log events and messages across the system.",
-      tags: ["system"],
-    },
-  }),
-  tasks: {
-    beforeRun: defineEvent<{
-      task: ITask<any, any, any>;
-      input: any;
-    }>({
-      id: "globals.events.tasks.beforeRun",
-      meta: {
-        title: "Before Task Execution",
-        description:
-          "Triggered before a task starts running, providing access to the input data.",
-        tags: ["system"],
-      },
-    }),
-    afterRun: defineEvent<{
-      task: ITask<any, any, any>;
-      input: any;
-      output: any;
-      setOutput: (newOutput: any) => void;
-    }>({
-      id: "globals.events.tasks.afterRun",
-      meta: {
-        title: "After Task Execution",
-        description:
-          "Fired after a task has completed, providing both the input and output data.",
-        tags: ["system"],
-      },
-    }),
-    onError: defineEvent<{
-      error: any;
-      suppress: () => void;
-      task: ITask<any, any, any>;
-    }>({
-      id: "globals.events.tasks.onError",
-      meta: {
-        title: "Task Error",
-        description:
-          "Triggered when an error occurs during task execution. Allows error suppression.",
-        tags: ["system"],
-      },
-    }),
-  },
-  resources: {
-    beforeInit: defineEvent<{
-      resource: IResource<any, any, any>;
-      config: any;
-    }>({
-      id: "globals.events.resources.beforeInit",
-      meta: {
-        title: "Before Resource Initialization",
-        description:
-          "Fired before a resource is initialized, with access to the configuration.",
-        tags: ["system"],
-      },
-    }),
-    afterInit: defineEvent<{
-      resource: IResource<any, any, any>;
-      config: any;
-      value: any;
-    }>({
-      id: "globals.events.resources.afterInit",
-      meta: {
-        title: "After Resource Initialization",
-        description:
-          "Fired after a resource has been initialized, providing the final value.",
-        tags: ["system"],
-      },
-    }),
-    onError: defineEvent<{
-      error: Error;
-      suppress: () => void;
-      resource: IResource<any, any, any>;
-    }>({
-      id: "globals.events.resources.onError",
-      meta: {
-        title: "Resource Error",
-        description:
-          "Triggered when an error occurs during resource initialization. Allows error suppression.",
-        tags: ["system"],
-      },
-    }),
-  },
-};
-
-export const globalEventsArray = [
-  globalEvents.log,
-  globalEvents.beforeInit,
-  globalEvents.afterInit,
-  globalEvents.tasks.beforeRun,
-  globalEvents.tasks.afterRun,
-  globalEvents.tasks.onError,
-  globalEvents.resources.beforeInit,
-  globalEvents.resources.afterInit,
-  globalEvents.resources.onError,
-];

package/src/globals/globalMiddleware.ts

@@ -1,16 +0,0 @@
-import { Context, ContextError } from "../context";
-import { defineMiddleware } from "../define";
-import { cacheMiddleware } from "./middleware/cache.middleware";
-import { requireContextMiddleware } from "./middleware/requireContext.middleware";
-import { retryMiddleware } from "./middleware/retry.middleware";
-import { timeoutMiddleware } from "./middleware/timeout.middleware";
-
-/**
- * Global middlewares
- */
-export const globalMiddlewares = {
-  requireContext: requireContextMiddleware,
-  retry: retryMiddleware,
-  cache: cacheMiddleware,
-  timeout: timeoutMiddleware,
-};

package/src/globals/globalResources.ts

@@ -1,53 +0,0 @@
-import { defineResource } from "../define";
-import { EventManager } from "../models/EventManager";
-import { Logger } from "../models/Logger";
-import { Store } from "../models/Store";
-import { TaskRunner } from "../models/TaskRunner";
-import { cacheResource } from "./middleware/cache.middleware";
-import { queueResource } from "./resources/queue.resource";
-
-const store = defineResource({
-  id: "globals.resources.store",
-  init: async (store: Store) => store,
-  meta: {
-    title: "Store",
-    description:
-      "A global store that can be used to store and retrieve tasks, resources, events and middleware",
-    tags: ["internal"],
-  },
-});
-
-export const globalResources = {
-  store,
-  eventManager: defineResource({
-    id: "globals.resources.eventManager",
-    init: async (em: EventManager) => em,
-    meta: {
-      title: "Event Manager",
-      description:
-        "Manages all events and event listeners. This is meant to be used internally for most use-cases.",
-      tags: ["internal"],
-    },
-  }),
-  taskRunner: defineResource({
-    id: "globals.resources.taskRunner",
-    init: async (runner: TaskRunner) => runner,
-    meta: {
-      title: "Task Runner",
-      description:
-        "Manages the execution of tasks and task dependencies. This is meant to be used internally for most use-cases.",
-      tags: ["internal"],
-    },
-  }),
-  logger: defineResource({
-    id: "globals.resources.logger",
-    init: async (logger: Logger) => logger,
-    meta: {
-      title: "Logger",
-      description:
-        "Logs all events and errors. This is meant to be used internally for most use-cases. Emits a globals.log event for each log.",
-    },
-  }),
-  cache: cacheResource,
-  queue: queueResource,
-};

package/src/globals/middleware/cache.middleware.ts

@@ -1,115 +0,0 @@
-import { defineMiddleware, defineResource, defineTask } from "../../define";
-import { LRUCache } from "lru-cache";
-import { IResource, ITask } from "../../defs";
-
-export interface ICacheInstance {
-  set(key: string, value: any): void;
-  get(key: string): any;
-  clear(): void;
-}
-
-// Default cache factory task that can be overridden
-export const cacheFactoryTask = defineTask({
-  id: "globals.tasks.cacheFactory",
-  run: async (options: any) => {
-    return new LRUCache(options) as ICacheInstance;
-  },
-});
-
-type CacheResourceConfig = {
-  defaultOptions?: any;
-  /**
-   * This specifies whether the cache handler is async or not (get, set, clear)
-   * This is for speed purposes.
-   */
-  async?: boolean;
-};
-
-type CacheMiddlewareConfig = {
-  keyBuilder?: (taskId: string, input: any) => string;
-} & any;
-
-export const cacheResource = defineResource({
-  id: "globals.resources.cache",
-  register: [cacheFactoryTask],
-  dependencies: {
-    cacheFactoryTask,
-  },
-  init: async (config: CacheResourceConfig, { cacheFactoryTask }) => {
-    return {
-      map: new Map<string | symbol, ICacheInstance>(),
-      cacheFactoryTask,
-      async: config.async,
-      defaultOptions: {
-        ttl: 10 * 1000,
-        max: 100, // Maximum number of items in cache
-        ttlAutopurge: true, // Automatically purge expired items
-        ...config.defaultOptions,
-      },
-    };
-  },
-  dispose: async (cache) => {
-    for (const cacheInstance of cache.map.values()) {
-      await cacheInstance.clear();
-    }
-  },
-});
-
-const defaultKeyBuilder = (taskId: string, input: any) =>
-  `${taskId}-${JSON.stringify(input)}`;
-
-export const cacheMiddleware = defineMiddleware({
-  id: "globals.middleware.cache",
-  dependencies: { cache: cacheResource },
-  async run({ task, resource, next }, deps, config: CacheMiddlewareConfig) {
-    const { cache } = deps;
-    config = {
-      keyBuilder: defaultKeyBuilder,
-      ttl: 10 * 1000,
-      max: 100, // Maximum number of items in cache
-      ttlAutopurge: true, // Automatically purge expired items
-      ...config,
-    };
-
-    if (!task) {
-      throw new Error("Cache middleware can only be used in tasks");
-    }
-
-    const taskId = task.definition.id;
-    const isAsync = cache.async;
-    let cacheHolderForTask = cache.map.get(taskId);
-    if (!cacheHolderForTask) {
-      // Extract only LRUCache options, excluding keyBuilder
-      const { keyBuilder, ...lruOptions } = config;
-      const cacheOptions = {
-        ...cache.defaultOptions,
-        ...lruOptions,
-      };
-
-      // Use the factory task to create the cache instance
-      cacheHolderForTask = await cache.cacheFactoryTask(cacheOptions);
-
-      cache.map.set(taskId, cacheHolderForTask);
-    }
-
-    const key = config.keyBuilder!(taskId, task.input);
-
-    const cachedValue = isAsync
-      ? await cacheHolderForTask.get(key)
-      : cacheHolderForTask.get(key);
-
-    if (cachedValue) {
-      return cachedValue;
-    }
-
-    const result = await next(task.input);
-
-    if (isAsync) {
-      await cacheHolderForTask.set(key, result);
-    } else {
-      cacheHolderForTask.set(key, result);
-    }
-
-    return result;
-  },
-});

package/src/globals/middleware/requireContext.middleware.ts

@@ -1,36 +0,0 @@
-import { Context, ContextError } from "../../context";
-import { defineMiddleware } from "../../define";
-
-type RequireContextMiddlewareConfig = {
-  context: Context<any>;
-};
-
-export const requireContextMiddleware = defineMiddleware({
-  id: "globals.middleware.requireContext",
-  async run(
-    { task, resource, next },
-    deps,
-    config: RequireContextMiddlewareConfig
-  ) {
-    if (!config.context) {
-      throw new Error(
-        "Context not available. Did you forget to pass 'context' to the middleware?"
-      );
-    }
-
-    const ctx = config.context.use();
-    if (!ctx) {
-      throw new ContextError(
-        "Context not available. Did you forget to provide the context via ContextName.provide()?"
-      );
-    }
-    if (task) {
-      return next(task.input);
-    }
-    if (resource) {
-      return next(resource.config);
-    }
-
-    return next();
-  },
-});

package/src/globals/middleware/retry.middleware.ts

@@ -1,56 +0,0 @@
-import { defineMiddleware } from "../../define";
-
-/**
- * Configuration options for the retry middleware
- */
-export interface RetryMiddlewareConfig {
-  /**
-   * Maximum number of retry attempts (default: 3)
-   */
-  retries?: number;
-  /**
-   * Callback to determine if retry should stop based on error
-   * @default () => false (retry all errors)
-   */
-  stopRetryIf?: (error: Error) => boolean;
-  /**
-   * Custom delay strategy function
-   * @default Exponential backoff starting at 100ms
-   */
-  delayStrategy?: (attempt: number, error: Error) => number;
-}
-
-export const retryMiddleware = defineMiddleware({
-  id: "globals.middleware.retry",
-  async run({ task, resource, next }, deps, config: RetryMiddlewareConfig) {
-    const input = task ? task.input : resource?.config;
-    let attempts = 0;
-
-    // Set defaults for required parameters
-    const maxRetries = config.retries ?? 3;
-    const shouldStop = config.stopRetryIf ?? (() => false);
-
-    while (true) {
-      try {
-        return await next(input);
-      } catch (error) {
-        const err = error as Error;
-
-        if (shouldStop(err) || attempts >= maxRetries) {
-          throw error;
-        }
-
-        // Calculate delay using custom strategy or default exponential backoff
-        const delay = config.delayStrategy
-          ? config.delayStrategy(attempts, err)
-          : 100 * Math.pow(2, attempts);
-
-        if (delay > 0) {
-          await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-
-        attempts++;
-      }
-    }
-  },
-});

package/src/globals/middleware/timeout.middleware.ts

@@ -1,46 +0,0 @@
-import { defineMiddleware } from "../../define";
-
-export interface TimeoutMiddlewareConfig {
-  /**
-   * Maximum time in milliseconds before the wrapped operation is aborted
-   * and a timeout error is thrown. Defaults to 5000ms.
-   */
-  ttl: number;
-}
-
-export const timeoutMiddleware = defineMiddleware({
-  id: "globals.middleware.timeout",
-  async run({ task, resource, next }, _deps, config: TimeoutMiddlewareConfig) {
-    const input = task ? task.input : resource?.config;
-
-    const ttl = Math.max(0, config.ttl);
-    const message = `Operation timed out after ${ttl}ms`;
-
-    // Fast-path: immediate timeout
-    if (ttl === 0) {
-      const error = new Error(message);
-      (error as any).name = "TimeoutError";
-      throw error;
-    }
-
-    const controller = new AbortController();
-
-    // Create a timeout promise that rejects when aborted
-    const timeoutPromise = new Promise((_, reject) => {
-      const timeoutId = setTimeout(() => {
-        controller.abort();
-        const error = new Error(message);
-        (error as any).name = "TimeoutError";
-        reject(error);
-      }, ttl);
-
-      // Clean up timeout if abort signal fires for other reasons
-      controller.signal.addEventListener("abort", () => {
-        clearTimeout(timeoutId);
-      });
-    });
-
-    // Race between the actual operation and the timeout
-    return Promise.race([next(input), timeoutPromise]);
-  },
-});

package/src/globals/resources/queue.resource.ts

@@ -1,34 +0,0 @@
-import { defineResource } from "../../define";
-import { Queue } from "../../models/Queue";
-
-export const queueResource = defineResource({
-  id: "globals.resources.queue",
-  context: () => ({
-    map: new Map<string | symbol, Queue>(),
-  }),
-  init: async (_, deps, context) => {
-    const map = context.map;
-
-    return {
-      map,
-      run: <T>(
-        id: string,
-        task: (signal: AbortSignal) => Promise<T>
-      ): Promise<T> => {
-        if (!map.has(id)) {
-          map.set(id, new Queue());
-        }
-
-        return map.get(id)!.run(task);
-      },
-    };
-  },
-  dispose: async (value, _, deps, context) => {
-    context.map.forEach((queue) => queue.dispose());
-  },
-  meta: {
-    title: "Queue Map",
-    description:
-      "A global map that can be used to store and retrieve queues. You can run exclusive tasks based on using an id. queue.run(id, task) will run the task in the queue with the given id. If the queue does not exist, it will be created.",
-  },
-});

package/src/index.ts

@@ -1,39 +0,0 @@
-import {
-  defineTask,
-  defineResource,
-  defineEvent,
-  defineMiddleware,
-  defineIndex,
-  defineTag,
-  defineOverride,
-} from "./define";
-import { createContext } from "./context";
-import { globalEvents } from "./globals/globalEvents";
-import { globalResources } from "./globals/globalResources";
-import { globalMiddlewares } from "./globals/globalMiddleware";
-import { run } from "./run";
-import { createTestResource } from "./testing";
-
-const globals = {
-  events: globalEvents,
-  resources: globalResources,
-  middlewares: globalMiddlewares,
-};
-
-export { globals };
-export {
-  defineTask as task,
-  defineResource as resource,
-  defineEvent as event,
-  defineMiddleware as middleware,
-  defineIndex as index,
-  defineTag as tag,
-  defineOverride as override,
-  run,
-  createContext,
-  createTestResource,
-};
-
-export * as definitions from "./defs";
-export { Semaphore, Store, EventManager, TaskRunner, Queue } from "./models";
-export * as Errors from "./errors";