@bluelibs/runner 3.3.2 → 3.4.1

package/src/define.ts

@@ -33,8 +33,10 @@ import {
   symbolResourceWithConfig,
   symbolResource,
   symbolMiddleware,
+  ITaskMeta,
+  IResourceMeta,
 } from "./defs";
-import { Errors } from "./errors";
+import { MiddlewareAlreadyGlobalError, ValidationError } from "./errors";
 import { generateCallerIdFromFile, getCallerFile } from "./tools/getCallerFile";
 
 // Helper function to get the caller file
@@ -43,10 +45,11 @@ export function defineTask<
   Input = undefined,
   Output extends Promise<any> = any,
   Deps extends DependencyMapType = any,
-  TOn extends "*" | IEventDefinition | undefined = undefined
+  TOn extends "*" | IEventDefinition | undefined = undefined,
+  TMeta extends ITaskMeta = any
 >(
-  taskConfig: ITaskDefinition<Input, Output, Deps, TOn>
-): ITask<Input, Output, Deps, TOn> {
+  taskConfig: ITaskDefinition<Input, Output, Deps, TOn, TMeta>
+): ITask<Input, Output, Deps, TOn, TMeta> {
   /**
    * Creates a task definition.
    * - Generates an anonymous id based on file path when `id` is omitted
@@ -65,6 +68,7 @@ export function defineTask<
     run: taskConfig.run,
     on: taskConfig.on,
     listenerOrder: taskConfig.listenerOrder,
+    inputSchema: taskConfig.inputSchema,
     events: {
       beforeRun: {
         ...defineEvent({
@@ -91,19 +95,28 @@ export function defineTask<
         [symbolFilePath]: getCallerFile(),
       },
     },
-    meta: taskConfig.meta || {},
+    meta: taskConfig.meta || ({} as TMeta),
     // autorun,
   };
 }
 
 export function defineResource<
   TConfig = void,
-  TValue = any,
+  TValue extends Promise<any> = Promise<any>,
   TDeps extends DependencyMapType = {},
-  TPrivate = any
+  TPrivate = any,
+  TMeta extends IResourceMeta = any
 >(
-  constConfig: IResourceDefinition<TConfig, TValue, TDeps, TPrivate>
-): IResource<TConfig, TValue, TDeps, TPrivate> {
+  constConfig: IResourceDefinition<
+    TConfig,
+    TValue,
+    TDeps,
+    TPrivate,
+    any,
+    any,
+    TMeta
+  >
+): IResource<TConfig, TValue, TDeps, TPrivate, TMeta> {
   /**
    * Creates a resource definition.
    * - Generates anonymous id when omitted (resource or index flavor)
@@ -129,7 +142,17 @@ export function defineResource<
     overrides: constConfig.overrides || [],
     init: constConfig.init,
     context: constConfig.context,
+    configSchema: constConfig.configSchema,
     with: function (config: TConfig) {
+      // Validate config with schema if provided (fail fast)
+      if (this.configSchema) {
+        try {
+          config = this.configSchema.parse(config);
+        } catch (error) {
+          throw new ValidationError("Resource config", this.id, error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      
       return {
         [symbolResourceWithConfig]: true,
         id: this.id,
@@ -164,7 +187,7 @@ export function defineResource<
         [symbolFilePath]: filePath,
       },
     },
-    meta: constConfig.meta || {},
+    meta: (constConfig.meta || {}) as TMeta,
     middleware: constConfig.middleware || [],
   };
 }
@@ -182,7 +205,7 @@ export function defineIndex<
       ? T[K]["resource"]
       : T[K];
   } & DependencyMapType
->(items: T): IResource<void, DependencyValuesType<D>, D> {
+>(items: T): IResource<void, Promise<DependencyValuesType<D>>, D> {
   // Build dependency map from given items; unwrap `.with()` to the base resource
   const dependencies = {} as D;
   const register: RegisterableItems[] = [];
@@ -263,6 +286,15 @@ export function defineMiddleware<
   return {
     ...object,
     with: (config: TConfig) => {
+      // Validate config with schema if provided (fail fast)
+      if (object.configSchema) {
+        try {
+          config = object.configSchema.parse(config);
+        } catch (error) {
+          throw new ValidationError("Middleware config", object.id, error instanceof Error ? error : new Error(String(error)));
+        }
+      }
+      
       return {
         ...object,
         [symbolMiddlewareConfigured]: true,
@@ -280,7 +312,7 @@ export function defineMiddleware<
         [symbolMiddlewareEverywhereTasks]: tasks,
         [symbolMiddlewareEverywhereResources]: resources,
         everywhere() {
-          throw Errors.middlewareAlreadyGlobal(object.id);
+          throw new MiddlewareAlreadyGlobalError(object.id);
         },
       };
     },
@@ -343,9 +375,9 @@ export function defineOverride(
  * - `.with(config)` to create configured instances
  * - `.extract(tags)` to extract this tag from a list of tags
  */
-export function defineTag<TConfig = void>(
-  definition: ITagDefinition<TConfig>
-): ITag<TConfig> {
+export function defineTag<TConfig = void, TEnforceContract = void>(
+  definition: ITagDefinition<TConfig, TEnforceContract>
+): ITag<TConfig, TEnforceContract> {
   const id = definition.id;
 
   return {

package/src/defs.returnTag.ts

@@ -0,0 +1,91 @@
+// HasContracts<Meta> → true if contracts present, else false
+
+import { ITag, ITagWithConfig } from "./defs";
+import { IMeta } from "./defs";
+
+// Keep these param names aligned with your defs.ts: ITag<TConfig, TEnforceContract>
+type NonVoid<T> = [T] extends [void] ? never : T;
+
+type ExtractReturnFromTag<T> = T extends ITagWithConfig<any, infer R>
+  ? NonVoid<R>
+  : T extends ITag<any, infer R>
+  ? NonVoid<R>
+  : never;
+
+type IsTuple<T extends readonly unknown[]> = number extends T["length"]
+  ? false
+  : true;
+
+type FilterContracts<
+  TTags extends readonly unknown[],
+  Acc extends readonly unknown[] = []
+> = TTags extends readonly [infer H, ...infer R]
+  ? ExtractReturnFromTag<H> extends never
+    ? FilterContracts<R, Acc>
+    : FilterContracts<R, [...Acc, ExtractReturnFromTag<H>]>
+  : Acc;
+
+export type ExtractContractsFromTags<TTags extends readonly unknown[]> =
+  IsTuple<TTags> extends true
+    ? FilterContracts<TTags>
+    : Array<ExtractReturnFromTag<TTags[number]>>;
+
+export type ExtractTagsWithNonVoidReturnTypeFromMeta<TMeta extends IMeta> =
+  TMeta extends { tags?: infer TTags }
+    ? TTags extends readonly unknown[]
+      ? ExtractContractsFromTags<TTags>
+      : []
+    : [];
+
+type IsNeverTuple<T extends readonly unknown[]> = T extends [] ? true : false;
+
+export type HasContracts<T extends IMeta> =
+  ExtractTagsWithNonVoidReturnTypeFromMeta<T> extends never[] ? false : true; // HasContracts and enforcement
+
+// Ensure a response type satisfies ALL contracts (intersection)
+type UnionToIntersection<U> = (
+  U extends any ? (arg: U) => void : never
+) extends (arg: infer I) => void
+  ? I
+  : never;
+
+type ContractsUnion<TMeta extends IMeta> =
+  ExtractTagsWithNonVoidReturnTypeFromMeta<TMeta> extends readonly (infer U)[]
+    ? U
+    : never;
+
+type ContractsIntersection<TMeta extends IMeta> = UnionToIntersection<
+  ContractsUnion<TMeta>
+>;
+
+/**
+ * Pretty-print helper to expand intersections for better IDE display.
+ */
+type Simplify<T> = { [K in keyof T]: T[K] } & {};
+
+/**
+ * Verbose compile-time error surfaced when a value does not satisfy
+ * the intersection of all tag-enforced contracts.
+ *
+ * Intersected with `never` in call sites when desired to ensure assignment
+ * fails while still surfacing a readable shape in tooltips.
+ */
+export type ContractViolationError<TMeta extends IMeta, TActual> = {
+  message: "Value does not satisfy all tag contracts";
+  expected: Simplify<ContractsIntersection<TMeta>>;
+  received: TActual;
+};
+
+export type EnsureResponseSatisfiesContracts<TMeta extends IMeta, TResponse> = [
+  ContractsUnion<TMeta>
+] extends [never]
+  ? TResponse // no contracts, allow as-is
+  : TResponse extends Promise<infer U>
+  ? Promise<
+      U extends ContractsIntersection<TMeta>
+        ? U
+        : ContractViolationError<TMeta, U>
+    >
+  : TResponse extends ContractsIntersection<TMeta>
+  ? TResponse
+  : ContractViolationError<TMeta, TResponse>;

package/src/defs.ts

@@ -15,6 +15,23 @@
  */
 
 import { MiddlewareEverywhereOptions } from "./define";
+import {
+  EnsureResponseSatisfiesContracts,
+  HasContracts,
+} from "./defs.returnTag";
+
+/**
+ * Generic validation schema interface that can be implemented by any validation library.
+ * Compatible with Zod, Yup, Joi, and other validation libraries.
+ */
+export interface IValidationSchema<T = any> {
+  /**
+   * Parse and validate the input data.
+   * Should throw an error if validation fails.
+   * Can transform the data if the schema supports transformations.
+   */
+  parse(input: unknown): T;
+}
 
 // Re-export public cache type so consumers don’t import from internals.
 export { ICacheInstance } from "./globals/middleware/cache.middleware";
@@ -57,17 +74,17 @@ export const symbolIndexResource: unique symbol = Symbol(
   "runner.indexResource"
 );
 
-export interface ITagDefinition<TConfig = void> {
+export interface ITagDefinition<TConfig = void, TEnforceContract = void> {
   id: string | symbol;
 }
 
 /**
  * A configured instance of a tag as produced by `ITag.with()`.
  */
-export interface ITagWithConfig<TConfig = void> {
+export interface ITagWithConfig<TConfig = void, TEnforceContract = void> {
   id: string | symbol;
   /** The tag definition used to produce this configured instance. */
-  tag: ITag<TConfig>;
+  tag: ITag<TConfig, TEnforceContract>;
   /** The configuration captured for this tag instance. */
   config: TConfig;
 }
@@ -76,16 +93,19 @@ export interface ITagWithConfig<TConfig = void> {
  * A tag definition (builder). Use `.with(config)` to obtain configured instances,
  * and `.extract(tags)` to find either a configured instance or the bare tag in a list.
  */
-export interface ITag<TConfig = void> extends ITagDefinition<TConfig> {
+export interface ITag<TConfig = void, TEnforceContract = void>
+  extends ITagDefinition<TConfig, TEnforceContract> {
   /**
    * Creates a configured instance of the tag.
    */
-  with(config: TConfig): ITagWithConfig<TConfig>;
+  with(config: TConfig): ITagWithConfig<TConfig, TEnforceContract>;
   /**
    * Extracts either a configured instance or the bare tag from a list of tags
    * or from a taggable object (`{ meta: { tags?: [] } }`).
    */
-  extract(target: TagType[] | ITaggable): ExtractedTagResult<TConfig> | null;
+  extract(
+    target: TagType[] | ITaggable
+  ): ExtractedTagResult<TConfig, TEnforceContract> | null;
   [symbolFilePath]: string;
 }
 
@@ -96,9 +116,9 @@ export interface ITag<TConfig = void> extends ITagDefinition<TConfig> {
  */
 export type TagType =
   | string
-  | ITag<void>
-  | ITag<{ [K in any]?: any }>
-  | ITagWithConfig<any>;
+  | ITag<void, any>
+  | ITag<{ [K in any]?: any }, any>
+  | ITagWithConfig<any, any>;
 
 /**
  * Conditional result type for `ITag.extract`:
@@ -106,7 +126,7 @@ export type TagType =
  * - For optional object config → identifier with optional config
  * - For required config → identifier with required config
  */
-export type ExtractedTagResult<TConfig> = {} extends TConfig
+export type ExtractedTagResult<TConfig, TEnforceContract> = {} extends TConfig
   ? { id: string | symbol; config?: TConfig }
   : { id: string | symbol; config: TConfig };
 
@@ -119,7 +139,6 @@ export interface ITaggable {
     tags?: TagType[];
   };
 }
-
 /**
  * Common metadata you can attach to tasks/resources/events/middleware.
  * Useful for docs, filtering and middleware decisions.
@@ -149,7 +168,9 @@ export type DependencyMapType = Record<
 type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
 type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
 type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D>
-  ? V
+  ? V extends Promise<infer U>
+    ? U
+    : V
   : never;
 
 type ExtractEventParams<T> = T extends IEvent<infer P> ? P : never;
@@ -213,7 +234,8 @@ export interface ITaskDefinition<
   TInput = any,
   TOutput extends Promise<any> = any,
   TDependencies extends DependencyMapType = {},
-  TOn extends "*" | IEventDefinition<any> | undefined = undefined // Adding a generic to track 'on' type
+  TOn extends "*" | IEventDefinition<any> | undefined = undefined, // Adding a generic to track 'on' type,
+  TMeta extends ITaskMeta = any
 > {
   /**
    * Stable identifier. If omitted, an anonymous id is generated from file path
@@ -237,7 +259,12 @@ export interface ITaskDefinition<
    */
   listenerOrder?: number;
   /** Optional metadata used for docs, filtering and tooling. */
-  meta?: ITaskMeta;
+  meta?: TMeta;
+  /**
+   * Optional validation schema for runtime input validation.
+   * When provided, task input will be validated before execution.
+   */
+  inputSchema?: IValidationSchema<TInput>;
   /**
    * The task body. If `on` is set, the input is an `IEventEmission`. Otherwise,
    * it's the declared input type.
@@ -247,7 +274,9 @@ export interface ITaskDefinition<
       ? TInput
       : IEventEmission<TOn extends "*" ? any : ExtractEventParams<TOn>>,
     dependencies: DependencyValuesType<TDependencies>
-  ) => TOutput;
+  ) => HasContracts<TMeta> extends true
+    ? EnsureResponseSatisfiesContracts<TMeta, TOutput>
+    : TOutput;
 }
 
 export type BeforeRunEventPayload<TInput> = {
@@ -284,8 +313,9 @@ 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> {
+  TOn extends "*" | IEventDefinition<any> | undefined = undefined,
+  TMeta extends ITaskMeta = any
+> extends ITaskDefinition<TInput, TOutput, TDependencies, TOn, TMeta> {
   id: string | symbol;
   dependencies: TDependencies | (() => TDependencies);
   computedDependencies?: DependencyValuesType<TDependencies>;
@@ -304,11 +334,12 @@ export interface ITask<
 
 export interface IResourceDefinition<
   TConfig = any,
-  TValue = unknown,
+  TValue extends Promise<any> = Promise<any>,
   TDependencies extends DependencyMapType = {},
   TContext = any,
   THooks = any,
-  TRegisterableItems = any
+  TRegisterableItems = any,
+  TMeta extends IResourceMeta = any
 > {
   /** Stable identifier. Omit to get an anonymous id. */
   id?: string | symbol;
@@ -329,7 +360,9 @@ export interface IResourceDefinition<
     config: TConfig,
     dependencies: DependencyValuesType<TDependencies>,
     context: TContext
-  ) => Promise<TValue>;
+  ) => HasContracts<TMeta> extends true
+    ? EnsureResponseSatisfiesContracts<TMeta, TValue>
+    : TValue;
   /**
    * Clean-up function for the resource. This is called when the resource is no longer needed.
    *
@@ -340,12 +373,17 @@ export interface IResourceDefinition<
    */
   dispose?: (
     this: any,
-    value: TValue,
+    value: TValue extends Promise<infer U> ? U : TValue,
     config: TConfig,
     dependencies: DependencyValuesType<TDependencies>,
     context: TContext
   ) => Promise<void>;
-  meta?: IResourceMeta;
+  meta?: TMeta;
+  /**
+   * Optional validation schema for runtime config validation.
+   * When provided, resource config will be validated when .with() is called.
+   */
+  configSchema?: IValidationSchema<TConfig>;
   /**
    * Safe overrides to swap behavior while preserving identities. See
    * README: Overrides.
@@ -370,10 +408,19 @@ export interface IResourceDefinition<
 
 export interface IResource<
   TConfig = void,
-  TValue = any,
+  TValue extends Promise<any> = Promise<any>,
   TDependencies extends DependencyMapType = any,
-  TContext = any
-> extends IResourceDefinition<TConfig, TValue, TDependencies, TContext> {
+  TContext = any,
+  TMeta extends IResourceMeta = any
+> extends IResourceDefinition<
+    TConfig,
+    TValue,
+    TDependencies,
+    TContext,
+    any,
+    any,
+    TMeta
+  > {
   id: string | symbol;
   with(config: TConfig): IResourceWithConfig<TConfig, TValue, TDependencies>;
   register:
@@ -396,7 +443,7 @@ export interface IResource<
 
 export interface IResourceWithConfig<
   TConfig = any,
-  TValue = any,
+  TValue extends Promise<any> = Promise<any>,
   TDependencies extends DependencyMapType = any
 > {
   /** The id of the underlying resource. */
@@ -415,6 +462,11 @@ export interface IEventDefinition<TPayload = void> {
   /** Stable identifier. Omit to get an anonymous id. */
   id?: string | symbol;
   meta?: IEventMeta;
+  /**
+   * Optional validation schema for runtime payload validation.
+   * When provided, event payload will be validated when emitted.
+   */
+  payloadSchema?: IValidationSchema<TPayload>;
 }
 
 export interface IEvent<TPayload = any> extends IEventDefinition<TPayload> {
@@ -469,6 +521,11 @@ export interface IMiddlewareDefinition<
   id?: string | symbol;
   /** Static or lazy dependency map. */
   dependencies?: TDependencies | ((config: TConfig) => TDependencies);
+  /**
+   * Optional validation schema for runtime config validation.
+   * When provided, middleware config will be validated when .with() is called.
+   */
+  configSchema?: IValidationSchema<TConfig>;
   /**
    * The middleware body, called with task/resource execution input.
    */
@@ -530,7 +587,7 @@ export interface IMiddlewareExecutionInput<
   };
   /** Resource hook: present when wrapping init/dispose. */
   resource?: {
-    definition: IResource<TResourceConfig>;
+    definition: IResource<TResourceConfig, any, any, any, any>;
     config: TResourceConfig;
   };
   next: (

package/src/errors.ts

@@ -1,33 +1,105 @@
-import { ITask, IResource } from "./defs";
+/**
+ * Base error class for all BlueLibs Runner errors
+ */
+export class RuntimeError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RuntimeError";
+  }
+}
 
-export const Errors = {
-  duplicateRegistration: (type: string, id: string | symbol) =>
-    new Error(`${type} "${id.toString()}" already registered`),
+/**
+ * Error thrown when attempting to register a component with a duplicate ID
+ */
+export class DuplicateRegistrationError extends RuntimeError {
+  constructor(type: string, id: string | symbol) {
+    super(`${type} "${id.toString()}" already registered`);
+    this.name = "DuplicateRegistrationError";
+  }
+}
 
-  dependencyNotFound: (key: string | symbol) =>
-    new Error(
+/**
+ * Error thrown when a dependency is not found in the registry
+ */
+export class DependencyNotFoundError extends RuntimeError {
+  constructor(key: string | symbol) {
+    super(
       `Dependency ${key.toString()} not found. Did you forget to register it through a resource?`
-    ),
+    );
+    this.name = "DependencyNotFoundError";
+  }
+}
 
-  unknownItemType: (item: any) => new Error(`Unknown item type: ${item}`),
+/**
+ * Error thrown when an unknown item type is encountered
+ */
+export class UnknownItemTypeError extends RuntimeError {
+  constructor(item: any) {
+    super(`Unknown item type: ${item}`);
+    this.name = "UnknownItemTypeError";
+  }
+}
 
-  circularDependencies: (cycles: string[]) =>
-    new Error(`Circular dependencies detected: ${cycles.join(", ")}`),
+/**
+ * Error thrown when circular dependencies are detected
+ */
+export class CircularDependenciesError extends RuntimeError {
+  constructor(cycles: string[]) {
+    super(`Circular dependencies detected: ${cycles.join(", ")}`);
+    this.name = "CircularDependenciesError";
+  }
+}
 
-  eventNotFound: (id: string | symbol) =>
-    new Error(
-      `Event "${id.toString()}" not found. Did you forget to register it?`
-    ),
+/**
+ * Error thrown when an event is not found in the registry
+ */
+export class EventNotFoundError extends RuntimeError {
+  constructor(id: string | symbol) {
+    super(`Event "${id.toString()}" not found. Did you forget to register it?`);
+    this.name = "EventNotFoundError";
+  }
+}
 
-  middlewareAlreadyGlobal: (id: string | symbol) =>
-    new Error(
+/**
+ * Error thrown when attempting to make a middleware global when it's already global
+ */
+export class MiddlewareAlreadyGlobalError extends RuntimeError {
+  constructor(id: string | symbol) {
+    super(
       "Cannot call .everywhere() on an already global middleware: " +
-        id.toString
-    ),
+        id.toString()
+    );
+    this.name = "MiddlewareAlreadyGlobalError";
+  }
+}
 
-  locked: (what: string | symbol) =>
-    new Error(`Cannot modify the ${what.toString()} when it is locked.`),
+/**
+ * Error thrown when attempting to modify a locked component
+ */
+export class LockedError extends RuntimeError {
+  constructor(what: string | symbol) {
+    super(`Cannot modify the ${what.toString()} when it is locked.`);
+    this.name = "LockedError";
+  }
+}
 
-  storeAlreadyInitialized: () =>
-    new Error("Store already initialized. Cannot reinitialize."),
-};
+/**
+ * Error thrown when attempting to initialize a store that's already initialized
+ */
+export class StoreAlreadyInitializedError extends RuntimeError {
+  constructor() {
+    super("Store already initialized. Cannot reinitialize.");
+    this.name = "StoreAlreadyInitializedError";
+  }
+}
+
+/**
+ * Error thrown when validation fails for task input, resource config, middleware config, or event payload
+ */
+export class ValidationError extends RuntimeError {
+  constructor(type: string, id: string | symbol, originalError: Error | string) {
+    const errorMessage = originalError instanceof Error ? originalError.message : String(originalError);
+    super(`${type} validation failed for ${id.toString()}: ${errorMessage}`);
+    this.name = "ValidationError";
+  }
+}

package/src/index.ts

@@ -36,3 +36,4 @@ export {
 
 export * as definitions from "./defs";
 export { Semaphore, Store, EventManager, TaskRunner, Queue } from "./models";
+export * as Errors from "./errors";

package/src/models/DependencyProcessor.ts

@@ -13,7 +13,11 @@ import * as utils from "../define";
 import { EventManager } from "./EventManager";
 import { ResourceInitializer } from "./ResourceInitializer";
 import { TaskRunner } from "./TaskRunner";
-import { Errors } from "../errors";
+import {
+  DependencyNotFoundError,
+  EventNotFoundError,
+  UnknownItemTypeError,
+} from "../errors";
 import { Logger } from "./Logger";
 
 /**
@@ -148,7 +152,7 @@ export class DependencyProcessor {
           });
         } else {
           if (this.store.events.get(eventDefinition.id) === undefined) {
-            throw Errors.eventNotFound(eventDefinition.id);
+            throw new EventNotFoundError(eventDefinition.id);
           }
           this.eventManager.addListener(eventDefinition, handler, {
             order: task.task.listenerOrder || 0,
@@ -179,7 +183,7 @@ export class DependencyProcessor {
     } else if (utils.isEvent(object)) {
       return this.extractEventDependency(object, source);
     } else {
-      throw Errors.unknownItemType(object);
+      throw new UnknownItemTypeError(object);
     }
   }
 
@@ -197,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.toString()}`);
+      throw new DependencyNotFoundError(`Task ${object.id.toString()}`);
     }
 
     if (!storeTask.isInitialized) {
@@ -221,7 +225,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.toString()}`);
+      throw new DependencyNotFoundError(`Resource ${object.id.toString()}`);
     }
 
     const { resource, config } = storeResource;