Variable rConst

r: Readonly<
    {
        asyncContext: <T = unknown>(id: string) => AsyncContextFluentBuilder<T>;
        error: <TData extends DefaultErrorType = DefaultErrorType>(
            id: string,
        ) => ErrorFluentBuilder<TData> & {
            is: {
                (error: unknown): error is RunnerError<DefaultErrorType>;
                (
                    error: unknown,
                    partialData: Partial<DefaultErrorType>,
                ): error is RunnerError<DefaultErrorType>;
            };
        };
        event: <TPayload = void>(id: string) => EventFluentBuilder<TPayload>;
        hook: (id: string) => HookFluentBuilder<{}, undefined, ITaskMeta>;
        middleware: Readonly<
            {
                resource: {
                    <C = void>(
                        id: string,
                    ): ResourceMiddlewareFluentBuilder<C, void, void, {}>;
                    <C, In, Out = void, D extends DependencyMapType = {}>(
                        id: string,
                    ): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
                };
                task: {
                    <In = void>(
                        id: string,
                    ): TaskMiddlewareFluentBuilder<void, In, void, {}>;
                    <C, In, Out = void, D extends DependencyMapType = {}>(
                        id: string,
                    ): TaskMiddlewareFluentBuilder<C, In, Out, D>;
                };
            },
        >;
        override: {
            <
                TInput,
                TOutput extends Promise<any>,
                TDeps extends DependencyMapType,
                TMeta extends ITaskMeta,
                TTags extends TagType[],
                TMiddleware extends TaskMiddlewareAttachmentType[],
            >(
                base: ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>,
            ): TaskFluentBuilder<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
            <
                TInput,
                TOutput extends Promise<any>,
                TDeps extends DependencyMapType,
                TMeta extends ITaskMeta,
                TTags extends TagType[],
                TMiddleware extends TaskMiddlewareAttachmentType[],
            >(
                base: ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>,
                run: (
                    input: HasInputContracts<[...TTags[], ...TMiddleware[]]> extends true
                        ? [TInput] extends [undefined]
                            ? InferInputOrViolationFromContracts<
                                [...TTags[], ...TMiddleware[]],
                            >
                            : EnsureInputSatisfiesContracts<
                                [...TTags[], ...TMiddleware[]],
                                TInput,
                            >
                        : TInput,
                    dependencies: DependencyValuesType<TDependencies>,
                    context?: { journal: ExecutionJournal },
                ) => HasOutputContracts<[...TTags[], ...TMiddleware[]]> extends true
                    ? EnsureOutputSatisfiesContracts<
                        [...TTags[], ...TMiddleware[]],
                        TOutput,
                    >
                    : TOutput,
            ): ITask<TInput, TOutput, TDeps, TMeta, TTags, TMiddleware>;
            <
                TConfig,
                TValue extends Promise<any>,
                TDeps extends DependencyMapType,
                TContext,
                TMeta extends IResourceMeta,
                TTags extends TagType[],
                TMiddleware extends ResourceMiddlewareAttachmentType[],
            >(
                base: IResource<
                    TConfig,
                    TValue,
                    TDeps,
                    TContext,
                    TMeta,
                    TTags,
                    TMiddleware,
                >,
            ): ResourceFluentBuilder<
                TConfig,
                TValue,
                TDeps,
                TContext,
                TMeta,
                TTags,
                TMiddleware,
            >;
            <
                TConfig,
                TValue extends Promise<any>,
                TDeps extends DependencyMapType,
                TContext,
                TMeta extends IResourceMeta,
                TTags extends TagType[],
                TMiddleware extends ResourceMiddlewareAttachmentType[],
            >(
                base: IResource<
                    TConfig,
                    TValue,
                    TDeps,
                    TContext,
                    TMeta,
                    TTags,
                    TMiddleware,
                >,
                init: (
                    config: HasInputContracts<[...TTags[], ...TMiddleware[]]> extends true
                        ? IsUnspecified<TConfig> extends true
                            ? InferInputOrViolationFromContracts<
                                [...TTags[], ...TMiddleware[]],
                            >
                            : EnsureInputSatisfiesContracts<
                                [...TTags[], ...TMiddleware[]],
                                TConfig,
                            >
                        : TConfig,
                    dependencies: ResourceDependencyValuesType<TDependencies>,
                    context: TContext,
                ) => HasOutputContracts<[...TTags[], ...TMiddleware[]]> extends true
                    ? EnsureOutputSatisfiesContracts<
                        [...TTags[], ...TMiddleware[]],
                        TValue,
                    >
                    : TValue,
            ): IResource<TConfig, TValue, TDeps, TContext, TMeta, TTags, TMiddleware>;
            <
                TDeps extends DependencyMapType,
                TOn extends HookOn,
                TMeta extends ITaskMeta,
            >(
                base: IHook<TDeps, TOn, TMeta>,
            ): HookOverrideBuilder<TDeps, TOn, TMeta>;
            <
                TDeps extends DependencyMapType,
                TOn extends HookOn,
                TMeta extends ITaskMeta,
            >(
                base: IHook<TDeps, TOn, TMeta>,
                run: (
                    event: IEventEmission<
                        TOn extends "*"
                            ? any
                            : TOn extends readonly IEventDefinition<any>[]
                                ? CommonPayload<TOn>
                                : ExtractEventPayload<TOn>,
                    >,
                    dependencies: DependencyValuesType<TDependencies>,
                ) => Promise<any>,
            ): IHook<TDeps, TOn, TMeta>;
            <C, In, Out, D extends DependencyMapType>(
                base: ITaskMiddleware<C, In, Out, D>,
            ): TaskMiddlewareFluentBuilder<C, In, Out, D>;
            <C, In, Out, D extends DependencyMapType>(
                base: ITaskMiddleware<C, In, Out, D>,
                run: (
                    input: ITaskMiddlewareExecutionInput<
                        In extends void ? any : In,
                        Out extends void ? any : Out,
                    >,
                    dependencies: DependencyValuesType<TDependencies>,
                    config: C,
                ) => Promise<any>,
            ): ITaskMiddleware<C, In, Out, D>;
            <C, In, Out, D extends DependencyMapType>(
                base: IResourceMiddleware<C, In, Out, D>,
            ): ResourceMiddlewareFluentBuilder<C, In, Out, D>;
            <C, In, Out, D extends DependencyMapType>(
                base: IResourceMiddleware<C, In, Out, D>,
                run: (
                    input: IResourceMiddlewareExecutionInput<
                        In extends void ? any : In,
                        Out extends void ? any : Out,
                    >,
                    dependencies: DependencyValuesType<TDependencies>,
                    config: C,
                ) => Promise<any>,
            ): IResourceMiddleware<C, In, Out, D>;
        };
        resource: <TConfig = void>(
            id: string,
        ) => ResourceFluentBuilder<
            TConfig,
            Promise<any>,
            {},
            any,
            IResourceMeta,
            TagType[],
            ResourceMiddlewareAttachmentType[],
        >;
        tag: <TConfig = void, TEnforceIn = void, TEnforceOut = void>(
            id: string,
        ) => TagFluentBuilder<TConfig, TEnforceIn, TEnforceOut>;
        task: TaskBuilderWithPhantom;
    },
> = ...

import { r, run } from "@bluelibs/runner";

const greet = r.task("app.tasks.greet")
  .inputSchema<{ name: string }>({ parse: (v) => v })
  .run(async (input) => `Hello, ${input.name}!`)
  .build();

const app = r.resource("app").register([greet]).build();
const runtime = await run(app);
const msg = await runtime.runTask(greet, { name: "Ada" });
await runtime.dispose();
Copy