@bluelibs/runner 3.3.2 → 3.4.1

package/src/models/EventManager.ts

@@ -4,7 +4,7 @@ import {
   IEventDefinition,
   IEventEmission,
 } from "../defs";
-import { Errors } from "../errors";
+import { LockedError, ValidationError } from "../errors";
 import { Logger } from "./Logger";
 
 const HandlerOptionsDefaults = { order: 0 };
@@ -42,7 +42,7 @@ export class EventManager {
 
   checkLock() {
     if (this.#isLocked) {
-      throw Errors.locked("EventManager");
+      throw new LockedError("EventManager");
     }
   }
 
@@ -106,6 +106,15 @@ export class EventManager {
     data: TInput,
     source: string | symbol
   ): Promise<void> {
+    // Validate payload with schema if provided
+    if (eventDefinition.payloadSchema) {
+      try {
+        data = eventDefinition.payloadSchema.parse(data);
+      } catch (error) {
+        throw new ValidationError("Event payload", eventDefinition.id, error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    
     const allListeners = this.getCachedMergedListeners(eventDefinition.id);
 
     if (allListeners.length === 0) {
@@ -130,7 +139,7 @@ export class EventManager {
       if (propagationStopped) {
         break;
       }
-      
+
       if (!listener.filter || listener.filter(event)) {
         await listener.handler(event);
       }

package/src/models/Logger.ts

@@ -48,6 +48,34 @@ export class Logger {
     boundContext: Record<string, any> = {}
   ) {
     this.boundContext = { ...boundContext };
+    this.printThreshold = this.getDefaultPrintThreshold();
+  }
+
+  /**
+   * Determines the default print threshold based on environment variables
+   */
+  private getDefaultPrintThreshold(): LogLevels | null {
+    // Check if logging is explicitly disabled
+    const disableLogs = process.env.RUNNER_DISABLE_LOGS;
+    if (disableLogs === "true" || disableLogs === "1") {
+      return null;
+    }
+
+    // Check for specific log level override
+    const logLevel = process.env.RUNNER_LOG_LEVEL;
+    if (logLevel && this.isValidLogLevel(logLevel)) {
+      return logLevel as LogLevels;
+    }
+
+    // Default to 'info' level for better developer experience
+    return "info";
+  }
+
+  /**
+   * Validates if a string is a valid log level
+   */
+  private isValidLogLevel(level: string): boolean {
+    return Object.keys(Logger.Severity).includes(level);
   }
 
   /**

package/src/models/OverrideManager.ts

@@ -6,12 +6,7 @@ import {
   RegisterableItems,
 } from "../defs";
 import * as utils from "../define";
-import { Errors } from "../errors";
-import {
-  TaskStoreElementType,
-  MiddlewareStoreElementType,
-  ResourceStoreElementType,
-} from "./StoreTypes";
+import { DependencyNotFoundError } from "../errors";
 import { StoreRegistry } from "./StoreRegistry";
 
 export class OverrideManager {
@@ -65,7 +60,7 @@ export class OverrideManager {
           ? override.resource.id
           : override.id;
 
-        throw Errors.dependencyNotFound(id);
+        throw new DependencyNotFoundError(id);
       }
     }
 

package/src/models/ResourceInitializer.ts

@@ -23,7 +23,7 @@ export class ResourceInitializer {
    */
   public async initializeResource<
     TConfig = null,
-    TValue = any,
+    TValue extends Promise<any> = Promise<any>,
     TDeps extends DependencyMapType = {},
     TContext = any
   >(
@@ -109,11 +109,16 @@ export class ResourceInitializer {
 
       if (!isSuppressed) throw e;
 
-      return { value: undefined as TValue, context: {} as TContext };
+      return { value: undefined as unknown as TValue, context: {} as TContext };
     }
   }
 
-  public async initWithMiddleware<C, V, D extends DependencyMapType, TContext>(
+  public async initWithMiddleware<
+    C,
+    V extends Promise<any>,
+    D extends DependencyMapType,
+    TContext
+  >(
     resource: IResource<C, V, D, TContext>,
     config: C,
     dependencies: DependencyValuesType<D>,

package/src/models/Store.ts

@@ -3,10 +3,11 @@ import {
   IResource,
   RegisterableItems,
   IMiddleware,
+  ITag,
 } from "../defs";
 import { IDependentNode } from "../tools/findCircularDependencies";
 import { globalEventsArray } from "../globals/globalEvents";
-import { Errors } from "../errors";
+import { StoreAlreadyInitializedError } from "../errors";
 import { EventManager } from "./EventManager";
 import { Logger } from "./Logger";
 import { StoreRegistry } from "./StoreRegistry";
@@ -125,9 +126,9 @@ export class Store {
     this.registry.resources.set(root.id, this.root);
   }
 
-  initializeStore(root: IResource<any>, config: any) {
+  initializeStore(root: IResource<any, any, any, any, any>, config: any) {
     if (this.#isInitialized) {
-      throw Errors.storeAlreadyInitialized();
+      throw new StoreAlreadyInitializedError();
     }
 
     this.registerGlobalComponents();
@@ -178,6 +179,14 @@ export class Store {
     this.registry.storeEventsForAllTasks();
   }
 
+  public getTasksWithTag(tag: string | ITag) {
+    return this.registry.getTasksWithTag(tag);
+  }
+
+  public getResourcesWithTag(tag: string | ITag) {
+    return this.registry.getResourcesWithTag(tag);
+  }
+
   getDependentNodes(): IDependentNode[] {
     return this.registry.getDependentNodes();
   }

package/src/models/StoreRegistry.ts

@@ -10,9 +10,10 @@ import {
   symbolMiddlewareEverywhereResources,
   symbolMiddlewareEverywhereTasks,
   IEvent,
+  ITag,
 } from "../defs";
 import * as utils from "../define";
-import { Errors } from "../errors";
+import { UnknownItemTypeError } from "../errors";
 import {
   TaskStoreElementType,
   MiddlewareStoreElementType,
@@ -55,7 +56,7 @@ export class StoreRegistry {
     } else if (utils.isResourceWithConfig(item)) {
       this.storeResourceWithConfig<C>(item);
     } else {
-      throw Errors.unknownItemType(item);
+      throw new UnknownItemTypeError(item);
     }
   }
 
@@ -225,4 +226,28 @@ export class StoreRegistry {
 
     return depenedants;
   }
+
+  getTasksWithTag(tag: string | ITag) {
+    if (typeof tag === "string") {
+      return Array.from(this.tasks.values()).filter((x) =>
+        x.task.meta?.tags?.includes(tag)
+      );
+    }
+
+    return Array.from(this.tasks.values())
+      .filter((x) => tag.extract(x.task.meta?.tags))
+      .map((x) => x.task);
+  }
+
+  getResourcesWithTag(tag: string | ITag) {
+    if (typeof tag === "string") {
+      return Array.from(this.resources.values()).filter((x) =>
+        x.resource.meta?.tags?.includes(tag)
+      );
+    }
+
+    return Array.from(this.resources.values())
+      .filter((x) => tag.extract(x.resource.meta?.tags))
+      .map((x) => x.resource);
+  }
 }

package/src/models/StoreTypes.ts

@@ -13,7 +13,7 @@ import {
 
 export type ResourceStoreElementType<
   C = any,
-  V = any,
+  V extends Promise<any> = any,
   D extends DependencyMapType = {},
   TContext = any
 > = {

package/src/models/StoreValidator.ts

@@ -1,4 +1,4 @@
-import { Errors } from "../errors";
+import { DependencyNotFoundError, DuplicateRegistrationError } from "../errors";
 import {
   TaskStoreElementType,
   MiddlewareStoreElementType,
@@ -16,16 +16,16 @@ export class StoreValidator {
 
   checkIfIDExists(id: string | symbol): void | never {
     if (this.tasks.has(id)) {
-      throw Errors.duplicateRegistration("Task", id);
+      throw new DuplicateRegistrationError("Task", id);
     }
     if (this.resources.has(id)) {
-      throw Errors.duplicateRegistration("Resource", id);
+      throw new DuplicateRegistrationError("Resource", id);
     }
     if (this.events.has(id)) {
-      throw Errors.duplicateRegistration("Event", id);
+      throw new DuplicateRegistrationError("Event", id);
     }
     if (this.middlewares.has(id)) {
-      throw Errors.duplicateRegistration("Middleware", id);
+      throw new DuplicateRegistrationError("Middleware", id);
     }
   }
 
@@ -33,7 +33,7 @@ export class StoreValidator {
     for (const task of this.tasks.values()) {
       task.task.middleware.forEach((middleware) => {
         if (!this.middlewares.has(middleware.id)) {
-          throw Errors.dependencyNotFound(
+          throw new DependencyNotFoundError(
             `Middleware ${middleware.id.toString()} in Task ${task.task.id.toString()}`
           );
         }

package/src/models/TaskRunner.ts

@@ -1,10 +1,10 @@
 import { DependencyMapType, DependencyValuesType, ITask } from "../defs";
-import { Errors } from "../errors";
 import { EventManager } from "./EventManager";
 import { globalEvents } from "../globals/globalEvents";
 import { Store } from "./Store";
 import { MiddlewareStoreElementType } from "./StoreTypes";
 import { Logger } from "./Logger";
+import { ValidationError } from "../errors";
 
 export class TaskRunner {
   protected readonly runnerStore = new Map<
@@ -150,6 +150,15 @@ export class TaskRunner {
 
     // this is the final next()
     let next = async (input: any) => {
+      // Validate input with schema if provided
+      if (task.inputSchema) {
+        try {
+          input = task.inputSchema.parse(input);
+        } catch (error) {
+          throw new ValidationError("Task input", task.id, error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      
       return task.run.call(null, input, storeTask?.computedDependencies as any);
     };
 

package/src/run.ts

@@ -13,13 +13,13 @@ import { EventManager } from "./models/EventManager";
 import { globalEvents } from "./globals/globalEvents";
 import { Store } from "./models/Store";
 import { findCircularDependencies } from "./tools/findCircularDependencies";
-import { Errors } from "./errors";
+import { CircularDependenciesError } from "./errors";
 import { globalResources } from "./globals/globalResources";
 import { Logger } from "./models/Logger";
 
 export type ResourcesStoreElementType<
   C = any,
-  V = any,
+  V extends Promise<any> = any,
   D extends DependencyMapType = {}
 > = {
   resource: IResourceDefinition<C, V, D>;
@@ -53,9 +53,12 @@ export type RunnerState = {
 };
 
 export async function run<C, V>(
-  resource: IResource<C, V>,
+  resource: IResource<C, V extends Promise<any> ? V : Promise<any>>,
   config?: C
-): Promise<{ value: V; dispose: () => Promise<void> }> {
+): Promise<{
+  value: V extends Promise<infer U> ? U : V;
+  dispose: () => Promise<void>;
+}> {
   const eventManager = new EventManager();
 
   // ensure for logger, that it can be used only after: computeAllDependencies() has executed
@@ -79,7 +82,7 @@ export async function run<C, V>(
   const dependentNodes = store.getDependentNodes();
   const circularDependencies = findCircularDependencies(dependentNodes);
   if (circularDependencies.cycles.length > 0) {
-    throw Errors.circularDependencies(circularDependencies.cycles);
+    throw new CircularDependenciesError(circularDependencies.cycles);
   }
 
   // the overrides that were registered now will override the other registered resources

package/src/testing.ts

@@ -25,7 +25,7 @@ export function createTestResource(
   options?: {
     overrides?: Array<IResource | ITask | IMiddleware | IResourceWithConfig>;
   }
-): IResource<void, ReturnType<typeof buildTestFacade>> {
+): IResource<void, Promise<ReturnType<typeof buildTestFacade>>> {
   return defineResource({
     id: `tests.createTestResource.${++testResourceCounter}`,
     register: [root],