Variable globalsConst

Type declaration

• events: {
      ready: IEvent<{
          root: IResource<any, any, any, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      }>;
      unhandledError: IEvent<{
          error: any;
          kind:
              | "middleware"
              | "task"
              | "run"
              | "resourceInit"
              | "hook"
              | "process";
      }>;
  }

  • Readonlyready: IEvent<{
        root: IResource<any, any, any, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
    }>

    Emitted when the system is fully initialized and ready for work.

  • ReadonlyunhandledError: IEvent<{
        error: any;
        kind:
            | "middleware"
            | "task"
            | "run"
            | "resourceInit"
            | "hook"
            | "process";
    }>

    Central error boundary event for any thrown error across the runner.

• middleware: {
      requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;
      resource: {
          retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
          timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;
      };
      task: {
          cache: ITaskMiddleware<any, void, void, {
              cache: IResource<CacheResourceConfig, Promise<{
                  cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
                  defaultOptions: any;
                  map: Map<string, ICacheInstance>;
              }>, {
                  cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
              }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
          }>;
          requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;
          retry: ITaskMiddleware<RetryMiddlewareConfig, void, void, any>;
          timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any>;
      };
  }

  • requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>

  • resource: {
        retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>;
        timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>;
    }

    • retry: IResourceMiddleware<RetryMiddlewareConfig, void, void, any>

    • timeout: IResourceMiddleware<TimeoutMiddlewareConfig, void, void, any>

  • task: {
        cache: ITaskMiddleware<any, void, void, {
            cache: IResource<CacheResourceConfig, Promise<{
                cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
                defaultOptions: any;
                map: Map<string, ICacheInstance>;
            }>, {
                cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
            }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
        }>;
        requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>;
        retry: ITaskMiddleware<RetryMiddlewareConfig, void, void, any>;
        timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any>;
    }

    • cache: ITaskMiddleware<any, void, void, {
          cache: IResource<CacheResourceConfig, Promise<{
              cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
              defaultOptions: any;
              map: Map<string, ICacheInstance>;
          }>, {
              cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
          }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      }>

    • requireContext: ITaskMiddleware<RequireContextMiddlewareConfig, void, void, any>

    • retry: ITaskMiddleware<RetryMiddlewareConfig, void, void, any>

    • timeout: ITaskMiddleware<TimeoutMiddlewareConfig, void, void, any>

• resources: {
      cache: IResource<CacheResourceConfig, Promise<{
          cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
          defaultOptions: any;
          map: Map<string, ICacheInstance>;
      }>, {
          cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
      }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      logger: IResource<void, Promise<Logger>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      middlewareManager: IResource<void, Promise<MiddlewareManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      queue: IResource<void, Promise<{
          map: Map<string, Queue>;
          run: (<T>(id: string, task: ((signal: AbortSignal) => Promise<T>)) => Promise<T>);
      }>, {}, {
          map: Map<string, Queue>;
      }, {
          description: string;
          title: string;
      }, TagType[], ResourceMiddlewareAttachmentType[]>;
      store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
      taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>;
  }

  • cache: IResource<CacheResourceConfig, Promise<{
        cacheFactoryTask: TaskDependencyWithIntercept<any, Promise<ICacheInstance>>;
        defaultOptions: any;
        map: Map<string, ICacheInstance>;
    }>, {
        cacheFactoryTask: ITask<any, Promise<ICacheInstance>, any, any, TagType[], TaskMiddlewareAttachmentType[]>;
    }, any, any, TagType[], ResourceMiddlewareAttachmentType[]>

  • eventManager: IResource<void, Promise<EventManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>

  • logger: IResource<void, Promise<Logger>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>

  • middlewareManager: IResource<void, Promise<MiddlewareManager>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>

  • queue: IResource<void, Promise<{
        map: Map<string, Queue>;
        run: (<T>(id: string, task: ((signal: AbortSignal) => Promise<T>)) => Promise<T>);
    }>, {}, {
        map: Map<string, Queue>;
    }, {
        description: string;
        title: string;
    }, TagType[], ResourceMiddlewareAttachmentType[]>

  • store: IResource<void, Promise<Store>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>

  • taskRunner: IResource<void, Promise<TaskRunner>, {}, any, any, TagType[], ResourceMiddlewareAttachmentType[]>

• tags: {
      debug: ITag<DebugFriendlyConfig, void, void>;
      excludeFromGlobalHooks: ITag<{
          metadata?: Record<string, any>;
      }, void, void>;
      system: ITag<{
          metadata?: Record<string, any>;
      }, void, void>;
  }

  • debug: ITag<DebugFriendlyConfig, void, void>

  • excludeFromGlobalHooks: ITag<{
        metadata?: Record<string, any>;
    }, void, void>

  • system: ITag<{
        metadata?: Record<string, any>;
    }, void, void>