@bluelibs/runner 2.2.4 → 3.1.0

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

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

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

@@ -0,0 +1,56 @@
+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/resources/queue.resource.ts

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

@@ -3,14 +3,18 @@ import {
   defineResource,
   defineEvent,
   defineMiddleware,
+  defineIndex,
 } from "./define";
-import { globalEvents } from "./globalEvents";
-import { globalResources } from "./globalResources";
+import { createContext } from "./context";
+import { globalEvents } from "./globals/globalEvents";
+import { globalResources } from "./globals/globalResources";
+import { globalMiddlewares } from "./globals/globalMiddleware";
 import { run } from "./run";
 
 const globals = {
   events: globalEvents,
   resources: globalResources,
+  middlewares: globalMiddlewares,
 };
 
 export { globals };
@@ -19,10 +23,10 @@ export {
   defineResource as resource,
   defineEvent as event,
   defineMiddleware as middleware,
+  defineIndex as index,
   run,
+  createContext,
 };
 
 export * as definitions from "./defs";
-export { Store } from "./models/Store";
-export { EventManager } from "./models/EventManager";
-export { TaskRunner } from "./models/TaskRunner";
+export { Semaphore, Store, EventManager, TaskRunner, Queue } from "./models";

package/src/models/DependencyProcessor.ts

@@ -3,11 +3,12 @@ import {
   DependencyValuesType,
   ITask,
   IResource,
-  IHookDefinition,
   IEventDefinition,
   IEvent,
+  IEventEmission,
 } from "../defs";
-import { ResourceStoreElementType, Store, TaskStoreElementType } from "./Store";
+import { Store } from "./Store";
+import { ResourceStoreElementType, TaskStoreElementType } from "./StoreTypes";
 import * as utils from "../define";
 import { EventManager } from "./EventManager";
 import { ResourceInitializer } from "./ResourceInitializer";
@@ -81,11 +82,14 @@ export class DependencyProcessor {
         resource.resource.id !== this.store.root.resource.id
       ) {
         await this.processResourceDependencies(resource);
-        resource.value = await this.resourceInitializer.initializeResource(
-          resource.resource,
-          resource.config,
-          resource.computedDependencies as DependencyValuesType<{}>
-        );
+        const { value, context } =
+          await this.resourceInitializer.initializeResource(
+            resource.resource,
+            resource.config,
+            resource.computedDependencies as DependencyValuesType<{}>
+          );
+        resource.context = context;
+        resource.value = value;
       }
     }
   }
@@ -107,13 +111,16 @@ export class DependencyProcessor {
   public async initializeRoot() {
     const storeResource = this.store.root;
 
-    storeResource.value = await this.resourceInitializer.initializeResource(
-      storeResource.resource,
-      storeResource.config,
-      // They are already computed
-      storeResource.computedDependencies as DependencyValuesType<{}>
-    );
+    const { value, context } =
+      await this.resourceInitializer.initializeResource(
+        storeResource.resource,
+        storeResource.config,
+        // They are already computed
+        storeResource.computedDependencies as DependencyValuesType<{}>
+      );
 
+    storeResource.context = context;
+    storeResource.value = value;
     storeResource.isInitialized = true;
   }
 
@@ -125,25 +132,13 @@ export class DependencyProcessor {
       if (task.task.on) {
         let eventDefinition = task.task.on;
 
-        const handler = async (receivedEvent: IEvent<any>) => {
+        const handler = async (receivedEvent: IEventEmission<any>) => {
           if (receivedEvent.source === task.task.id) {
             // we don't want to trigger the same task that emitted the event
             // process.exit(0);
             return;
           }
 
-          this.logger.debug(
-            {
-              message:
-                eventDefinition === "*"
-                  ? `Task ${task.task.id} being triggered by all events`
-                  : `Task ${task.task.id} being triggered by event: ${eventDefinition.id}`,
-
-              event: receivedEvent,
-            },
-            task.task.id
-          );
-
           return this.taskRunner.run(
             task.task,
             receivedEvent,
@@ -169,7 +164,7 @@ export class DependencyProcessor {
 
   async extractDependencies<T extends DependencyMapType>(
     map: T,
-    source: string
+    source: string | symbol
   ): Promise<DependencyValuesType<T>> {
     const object = {} as DependencyValuesType<T>;
 
@@ -180,7 +175,7 @@ export class DependencyProcessor {
     return object;
   }
 
-  async extractDependency(object, source: string) {
+  async extractDependency(object: any, source: string | symbol) {
     if (utils.isResource(object)) {
       return this.extractResourceDependency(object);
     } else if (utils.isTask(object)) {
@@ -197,19 +192,8 @@ export class DependencyProcessor {
    * @param object
    * @returns
    */
-  extractEventDependency(
-    object: IEventDefinition<Record<string, any>>,
-    source: string
-  ) {
-    return async (input) => {
-      // runs it in background.
-      this.logger.debug(
-        {
-          message: `Event ${object.id} was emitted from ${source}`,
-        },
-        source
-      );
-
+  extractEventDependency(object: IEvent<any>, source: string | symbol) {
+    return async (input: any) => {
       return this.eventManager.emit(object, input, source);
     };
   }
@@ -217,7 +201,7 @@ export class DependencyProcessor {
   async extractTaskDependency(object: ITask<any, any, {}>) {
     const storeTask = this.store.tasks.get(object.id);
     if (storeTask === undefined) {
-      throw Errors.dependencyNotFound(`Task ${object.id}`);
+      throw Errors.dependencyNotFound(`Task ${object.id.toString()}`);
     }
 
     if (!storeTask.isInitialized) {
@@ -232,7 +216,7 @@ export class DependencyProcessor {
       );
     }
 
-    return (input) => {
+    return (input: any) => {
       return this.taskRunner.run(
         storeTask.task,
         input,
@@ -245,7 +229,7 @@ export class DependencyProcessor {
     // check if it exists in the store with the value
     const storeResource = this.store.resources.get(object.id);
     if (storeResource === undefined) {
-      throw Errors.dependencyNotFound(`Resource ${object.id}`);
+      throw Errors.dependencyNotFound(`Resource ${object.id.toString()}`);
     }
 
     const { resource, config } = storeResource;
@@ -256,11 +240,20 @@ export class DependencyProcessor {
       storeResource.isInitialized = true;
 
       // check if it has an initialisation function that provides the value
-      storeResource.value = await this.resourceInitializer.initializeResource(
-        resource,
-        config,
-        await this.extractDependencies(resource.dependencies || {}, resource.id)
-      );
+      if (resource.init) {
+        const { value, context } =
+          await this.resourceInitializer.initializeResource(
+            resource,
+            config,
+            await this.extractDependencies(
+              resource.dependencies || {},
+              resource.id
+            )
+          );
+
+        storeResource.context = context;
+        storeResource.value = value;
+      }
     }
 
     return storeResource.value;

package/src/models/EventManager.ts

@@ -1,4 +1,9 @@
-import { EventHandlerType, IEvent, IEventDefinition } from "../defs";
+import {
+  EventHandlerType,
+  IEvent,
+  IEventDefinition,
+  IEventEmission,
+} from "../defs";
 import { Errors } from "../errors";
 import { Logger } from "./Logger";
 
@@ -6,13 +11,13 @@ const HandlerOptionsDefaults = { order: 0 };
 
 interface IListenerStorage {
   order: number;
-  filter?: (event: IEvent<any>) => boolean;
+  filter?: (event: IEventEmission<any>) => boolean;
   handler: EventHandlerType;
 }
 
 export interface IEventHandlerOptions<T = any> {
   order?: number;
-  filter?: (event: IEvent<T>) => boolean;
+  filter?: (event: IEventEmission<T>) => boolean;
   /**
    * Represents the listener ID. Use this to avoid a listener calling himself.
    */
@@ -20,8 +25,11 @@ export interface IEventHandlerOptions<T = any> {
 }
 
 export class EventManager {
-  private listeners: Map<string, IListenerStorage[]> = new Map();
+  private listeners: Map<string | symbol, IListenerStorage[]> = new Map();
   private globalListeners: IListenerStorage[] = [];
+  private cachedMergedListeners: Map<string | symbol, IListenerStorage[]> =
+    new Map();
+  private globalListenersCacheValid = true;
   #isLocked = false;
 
   get isLocked() {
@@ -57,18 +65,54 @@ export class EventManager {
     return result;
   }
 
+  private getCachedMergedListeners(
+    eventId: string | symbol
+  ): IListenerStorage[] {
+    if (!this.globalListenersCacheValid) {
+      this.cachedMergedListeners.clear();
+      this.globalListenersCacheValid = true;
+    }
+
+    let cached = this.cachedMergedListeners.get(eventId);
+    if (!cached) {
+      const eventListeners = this.listeners.get(eventId) || [];
+      if (eventListeners.length === 0 && this.globalListeners.length === 0) {
+        cached = [];
+      } else if (eventListeners.length === 0) {
+        cached = this.globalListeners;
+      } else if (this.globalListeners.length === 0) {
+        cached = eventListeners;
+      } else {
+        cached = this.mergeSortedListeners(
+          eventListeners,
+          this.globalListeners
+        );
+      }
+      this.cachedMergedListeners.set(eventId, cached);
+    }
+    return cached;
+  }
+
+  private invalidateCache(eventId?: string | symbol): void {
+    if (eventId) {
+      this.cachedMergedListeners.delete(eventId);
+    } else {
+      this.globalListenersCacheValid = false;
+    }
+  }
+
   async emit<TInput>(
-    eventDefinition: IEventDefinition<TInput>,
+    eventDefinition: IEvent<TInput>,
     data: TInput,
-    source: string
+    source: string | symbol
   ): Promise<void> {
-    const eventListeners = this.listeners.get(eventDefinition.id) || [];
-    const allListeners = this.mergeSortedListeners(
-      eventListeners,
-      this.globalListeners
-    );
+    const allListeners = this.getCachedMergedListeners(eventDefinition.id);
 
-    const event: IEvent = {
+    if (allListeners.length === 0) {
+      return;
+    }
+
+    const event: IEventEmission = {
       id: eventDefinition.id,
       data,
       timestamp: new Date(),
@@ -100,7 +144,7 @@ export class EventManager {
   }
 
   addListener<T>(
-    event: IEventDefinition | Array<IEventDefinition>,
+    event: IEvent<T> | Array<IEvent<T>>,
     handler: EventHandlerType<T>,
     options: IEventHandlerOptions<T> = HandlerOptionsDefaults
   ): void {
@@ -121,6 +165,7 @@ export class EventManager {
       } else {
         this.listeners.set(eventId, [newListener]);
       }
+      this.invalidateCache(eventId);
     }
   }
 
@@ -135,5 +180,11 @@ export class EventManager {
       filter: options.filter,
     };
     this.insertListener(this.globalListeners, newListener);
+    this.invalidateCache();
+  }
+
+  hasListeners<T>(eventDefinition: IEvent<T>): boolean {
+    const eventListeners = this.listeners.get(eventDefinition.id) || [];
+    return eventListeners.length > 0 || this.globalListeners.length > 0;
   }
 }