@bluelibs/runner 4.8.5 → 4.9.0

package/dist/types/taskMiddleware.d.ts

@@ -1,48 +0,0 @@
-import { DependencyMapType, DependencyValuesType, IValidationSchema, ITask } from "../defs";
-import { TagType } from "./tag";
-import { IMiddlewareMeta } from "./meta";
-import { symbolFilePath, symbolMiddlewareConfigured, symbolTaskMiddleware } from "./symbols";
-import { IContractable } from "./contracts";
-export interface ITaskMiddlewareDefinition<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> {
-    id: string;
-    /** 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 execution input.
-     */
-    run: (input: ITaskMiddlewareExecutionInput<TEnforceInputContract extends void ? any : TEnforceInputContract, TEnforceOutputContract extends void ? any : TEnforceOutputContract>, dependencies: DependencyValuesType<TDependencies>, config: TConfig) => Promise<any>;
-    meta?: IMiddlewareMeta;
-    tags?: TagType[];
-    everywhere?: boolean | ((task: ITask<any, any, any, any>) => boolean);
-}
-export interface ITaskMiddleware<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends ITaskMiddlewareDefinition<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>, IContractable<TConfig, TEnforceInputContract, TEnforceOutputContract> {
-    [symbolTaskMiddleware]: true;
-    [symbolFilePath]: string;
-    id: string;
-    dependencies: TDependencies | (() => TDependencies);
-    /** Current configuration object (empty by default). */
-    config: TConfig;
-    /** Configure the middleware and return a marked, configured instance. */
-    with: (config: TConfig) => ITaskMiddlewareConfigured<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies>;
-    tags: TagType[];
-}
-export interface ITaskMiddlewareConfigured<TConfig = any, TEnforceInputContract = void, TEnforceOutputContract = void, TDependencies extends DependencyMapType = any> extends ITaskMiddleware<TConfig, TEnforceInputContract, TEnforceOutputContract, TDependencies> {
-    [symbolMiddlewareConfigured]: true;
-    config: TConfig;
-}
-export interface ITaskMiddlewareExecutionInput<TTaskInput = any, TTaskOutput = any> {
-    /** Task hook */
-    task: {
-        definition: ITask<TTaskInput, any, any, any>;
-        input: TTaskInput;
-    };
-    next: (taskInput?: TTaskInput) => Promise<TTaskOutput>;
-}
-export type TaskMiddlewareAttachmentType = ITaskMiddleware<void, any, any, any> | ITaskMiddleware<{
-    [K in any]?: any;
-}, any, any, any> | ITaskMiddlewareConfigured<any, any, any, any>;

package/dist/types/utilities.d.ts

@@ -1,113 +0,0 @@
-import { IResource, IResourceWithConfig } from "./resource";
-import { ITask } from "./task";
-import { ITaskMiddleware } from "./taskMiddleware";
-import { IResourceMiddleware } from "./resourceMiddleware";
-import { IHook } from "./hook";
-import { IEvent, IEventDefinition } from "./event";
-import { ITag } from "./tag";
-import { symbolOptionalDependency } from "./symbols";
-import { IErrorHelper } from "./error";
-import type { IAsyncContext } from "./asyncContext";
-export * from "./symbols";
-/**
- * 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;
-}
-/**
- * Core public TypeScript types for BlueLibs Runner.
- *
- * This file contains the strongly-typed contract for tasks, resources, events
- * and middleware. It mirrors the mental model described in the README:
- * - Tasks are functions
- * - Resources are singletons (with init/dispose hooks)
- * - Events are simple, strongly-typed emissions
- * - Middleware can target both tasks and resources
- *
- * DX goals:
- * - Crystal‑clear generics and helper types that infer dependency shapes
- * - Friendly JSDoc you can hover in editors to understand usage instantly
- * - Safe overrides and strong typing around config and register mechanics
- */
-export type RequiredKeys<T> = {
-    [K in keyof T]-?: {} extends Pick<T, K> ? never : K;
-}[keyof T];
-/**
- * The reason we accept null and undefined is because we want to be able to offer beautiful DX:
- * overrides: [
- *    process.env.NODE_ENV === 'production' ? prodEmailer : null,
- * ]
- */
-export type OverridableElements = IResource<any, any, any, any, any> | ITask<any, any, any, any> | ITaskMiddleware<any> | IResourceMiddleware<any, any> | IResourceWithConfig<any, any, any> | IHook<any, any> | undefined | null;
-/**
- * A mapping of dependency keys to Runner definitions. Used in `dependencies`
- * for tasks and resources. Values are later transformed into the actual
- * callable/value shape by `DependencyValuesType`.
- */
-export type DependencyMapType = Record<string, ITask<any, any, any, any, any, any> | IResource<any, any, any, any, any, any, any> | IEvent<any> | IErrorHelper<any> | IAsyncContext<any> | IOptionalDependency<ITask<any, any, any, any, any, any>> | IOptionalDependency<IResource<any, any, any, any, any, any, any>> | IOptionalDependency<IEvent<any>> | IOptionalDependency<IErrorHelper<any>> | IOptionalDependency<IAsyncContext<any>>>;
-/** Wrapper type marking a dependency as optional at wiring time */
-export interface IOptionalDependency<T> {
-    /** The wrapped dependency definition */
-    inner: T;
-    /** Brand symbol for optional dependency */
-    [symbolOptionalDependency]: true;
-}
-export type ExtractTaskInput<T> = T extends ITask<infer I, any, infer D> ? I : never;
-export type ExtractTaskOutput<T> = T extends ITask<any, infer O, infer D> ? O : never;
-export type ExtractResourceConfig<T> = T extends IResource<infer C, any, any> ? C : never;
-export type ExtractResourceValue<T> = T extends IResource<any, infer V, infer D> ? V extends Promise<infer U> ? U : V : never;
-export type ExtractEventPayload<T> = T extends IEventDefinition<infer P> ? P : T extends IEvent<infer P> ? P : never;
-export type UnionToIntersection<U> = (U extends any ? (x: U) => any : never) extends (x: infer I) => any ? I : never;
-export type CommonPayload<T extends readonly IEventDefinition<any>[] | IEventDefinition<any>> = T extends readonly IEventDefinition<any>[] ? {
-    [K in keyof ExtractEventPayload<T[number]>]: UnionToIntersection<ExtractEventPayload<T[number]> extends any ? ExtractEventPayload<T[number]>[K] : never>;
-} : ExtractEventPayload<T>;
-/**
- * Task dependencies transform into callable functions: call with the task input
- * and you receive the task output.
- */
-type TaskDependency<I, O> = (...args: I extends null | void ? [] : [I]) => O;
-/**
- * Resource dependencies resolve to the resource's value directly.
- */
-type ResourceDependency<V> = V;
-/**
- * Event dependencies resolve to an emitter function. If the payload type is
- * `void`, the function can be called with zero args (or an empty object).
- */
-type EventDependency<P> = P extends void ? (() => Promise<void>) & ((input?: Record<string, never>) => Promise<void>) : (input: P) => Promise<void>;
-/**
- * Transforms a dependency definition into the usable shape inside `run`/`init`:
- * - Task -> callable function
- * - Resource -> resolved value
- * - Event -> emit function
- */
-export type DependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependency<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IErrorHelper<any> ? T : T extends IAsyncContext<any> ? T : T extends IEventDefinition<any> ? EventDependency<ExtractEventPayload<T>> : T extends IOptionalDependency<infer U> ? DependencyValueType<U> | undefined : never;
-export type DependencyValuesType<T extends DependencyMapType> = {
-    [K in keyof T]: DependencyValueType<T[K]>;
-};
-export type TaskLocalInterceptor<TInput, TOutput> = (next: (input: TInput) => TOutput, input: TInput) => TOutput;
-export type TaskDependencyWithIntercept<TInput, TOutput> = TaskDependency<TInput, TOutput> & {
-    intercept: (middleware: TaskLocalInterceptor<TInput, TOutput>) => void;
-};
-/** Resource-context dependency typing where tasks expose intercept() */
-export type ResourceDependencyValueType<T> = T extends ITask<any, any, any> ? TaskDependencyWithIntercept<ExtractTaskInput<T>, ExtractTaskOutput<T>> : T extends IResource<any, any> ? ResourceDependency<ExtractResourceValue<T>> : T extends IErrorHelper<any> ? T : T extends IAsyncContext<any> ? T : T extends IEventDefinition<any> ? EventDependency<ExtractEventPayload<T>> : T extends IOptionalDependency<infer U> ? ResourceDependencyValueType<U> | undefined : never;
-export type ResourceDependencyValuesType<T extends DependencyMapType> = {
-    [K in keyof T]: ResourceDependencyValueType<T[K]>;
-};
-/**
- * Anything you can put inside a resource's `register: []`.
- * - Resources (with or without `.with()`)
- * - Tasks
- * - Middleware
- * - Events
- */
-export type RegisterableItems = IResourceWithConfig<any, any, any, any, any, any, any> | IResource<void, any, any, any, any, any, any> | IResource<{
-    [K in any]?: any;
-}, any, any, any, any, any, any> | ITask<any, any, any, any, any, any> | IHook<any, any> | ITaskMiddleware<any, any, any, any> | IResourceMiddleware<any, any, any, any> | IEvent<any> | IAsyncContext<any> | IErrorHelper<any> | ITag<any, any, any>;

package/dist/utils/detectRunnerMode.d.ts

@@ -1,9 +0,0 @@
-import { RunnerMode } from "../types/runner";
-/**
- * Detects the runner mode based on environment variables.
- * If no mode is explicitly provided, it will auto-detect from NODE_ENV.
- *
- * @param explicitMode - Optional mode to use if provided (takes precedence over environment)
- * @returns The detected runner mode
- */
-export declare function detectRunnerMode(explicitMode?: RunnerMode): RunnerMode;