@rainbow-o23/n3 0.1.1

package/lib/error-codes.d.ts

@@ -0,0 +1,17 @@
+import { O23ReservedErrorCode } from '@rainbow-o23/n1';
+export declare const ERR_PIPELINE_STEP_SNIPPET_NOT_EMPTY: O23ReservedErrorCode;
+export declare const ERR_PIPELINE_STEP_CONDITIONAL_SNIPPET_NOT_EMPTY: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_DATASOURCE_TYPE_NOT_FOUND: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_DATASOURCE_CREATOR_NOT_FOUND: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_DATASOURCE_NOT_FOUND: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_ENTITY_NOT_FOUND: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_SQL_NOT_EMPTY: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_TRANSACTION_NOT_FOUND: O23ReservedErrorCode;
+export declare const ERR_TYPEORM_STEP_SNIPPET_NOT_EMPTY: O23ReservedErrorCode;
+export declare const ERR_FETCH_ERROR: O23ReservedErrorCode;
+export declare const ERR_PIPELINE_STEP_METHOD_NOT_SUPPORTED: O23ReservedErrorCode;
+export declare const ERR_EACH_FRAGMENT_NOT_ANY_ARRAY: O23ReservedErrorCode;
+export declare const ERR_PIPELINE_STEP_REF_NOT_EMPTY: O23ReservedErrorCode;
+export declare const ERR_PIPELINE_STEP_REF_NOT_FOUND: O23ReservedErrorCode;
+export declare const ERR_PIPELINE_REF_NOT_EMPTY: O23ReservedErrorCode;
+export declare const ERR_PIPELINE_REF_NOT_FOUND: O23ReservedErrorCode;

package/lib/http/fetch-step.d.ts

@@ -0,0 +1,53 @@
+import { PipelineStepData, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions, ScriptFuncOrBody } from '../step';
+import { HttpErrorCode, HttpGenerateBody, HttpGenerateHeaders, HttpGenerateResponse, HttpGenerateUrl, HttpHandleError } from './types';
+export interface FetchPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    endpointSystemCode: string;
+    endpointName: string;
+    urlGenerate?: ScriptFuncOrBody<HttpGenerateUrl<In, InFragment>>;
+    headersGenerate?: ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>>;
+    bodyGenerate?: ScriptFuncOrBody<HttpGenerateBody<In, InFragment>>;
+    responseGenerate?: ScriptFuncOrBody<HttpGenerateResponse<In, InFragment>>;
+    responseErrorHandles?: {
+        [key: HttpErrorCode]: ScriptFuncOrBody<HttpHandleError<In, InFragment, OutFragment>>;
+    };
+}
+export declare class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _endpointSystemCode;
+    private readonly _endpointName;
+    private readonly _endpointUrl;
+    private readonly _endpointMethod;
+    private readonly _endpointHeaders;
+    private readonly _endpointTimeout;
+    private readonly _urlGenerateSnippet;
+    private readonly _urlGenerateFunc;
+    private readonly _headersGenerateSnippet;
+    private readonly _headersGenerateFunc;
+    private readonly _bodyUsed;
+    private readonly _bodyGenerateSnippet;
+    private readonly _bodyGenerateFunc;
+    private readonly _responseGenerateSnippet;
+    private readonly _responseGenerateFunc;
+    private readonly _responseErrorHandleFunc;
+    constructor(options: FetchPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getEndpointSystemCode(): string;
+    getEndpointName(): string;
+    getEndpointKey(): string;
+    getEndpointUrl(): string;
+    getEndpointMethod(): string;
+    getEndpointHeaders(): Record<string, string>;
+    protected generateEndpointHeaders(headers?: string, base?: Record<string, string>): Record<string, string>;
+    getEndpointTimeout(): number;
+    needTimeout(): boolean;
+    getUrlGenerateSnippet(): ScriptFuncOrBody<HttpGenerateUrl<In, InFragment>>;
+    protected getUrlGenerateVariableName(): Array<string>;
+    getHeadersGenerateSnippet(): ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>>;
+    protected getHeadersGenerateVariableNames(): Array<string>;
+    protected isBodyUsed(): boolean;
+    getBodyGenerateSnippet(): ScriptFuncOrBody<HttpGenerateBody<In, InFragment>>;
+    protected getBodyGenerateVariableNames(): Array<string>;
+    getResponseGenerateSnippet(): ScriptFuncOrBody<HttpGenerateResponse<In, InFragment>>;
+    protected getResponseGenerateVariableName(): Array<string>;
+    protected getErrorHandlerVariableName(): Array<string>;
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+}

package/lib/http/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './fetch-step';

package/lib/http/types.d.ts

@@ -0,0 +1,21 @@
+import { PipelineStepData, PipelineStepHelpers, Undefinable } from '@rainbow-o23/n1';
+import { Response } from 'node-fetch';
+export type HttpGenerateUrl<In, InFragment> = ($endpointUrl: string, $factor: InFragment, $request: PipelineStepData<In>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => string;
+export type HttpGenerateHeaders<In, InFragment> = ($factor: InFragment, $request: PipelineStepData<In>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Undefinable<Record<string, string>>;
+export type HttpGenerateBody<In, InFragment> = ($factor: InFragment, $request: PipelineStepData<In>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => any;
+export type HttpGenerateResponse<In, InFragment> = ($response: Response, $factor: InFragment, $request: PipelineStepData<In>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<any>;
+export type HttpUnpredictedErrorCode = `0${number}`;
+export declare const HttpUnknownErrorCode: HttpUnpredictedErrorCode;
+export type HttpClientErrorCode = `4${number}`;
+export type HttpServerErrorCode = `5${number}`;
+export type HttpCustomizedErrorCode = `6${number}`;
+export declare const HttpAbortErrorCode: HttpCustomizedErrorCode;
+export type HttpErrorCode = HttpUnpredictedErrorCode | HttpClientErrorCode | HttpServerErrorCode | HttpCustomizedErrorCode;
+export interface HttpErrorHandleOptions<In, InFragment> {
+    $errorCode: HttpErrorCode;
+    $url: string;
+    $response?: Response;
+    $factor: InFragment;
+    $request: PipelineStepData<In>;
+}
+export type HttpHandleError<In, InFragment, OutFragment> = (options: HttpErrorHandleOptions<In, InFragment>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment> | never;

package/lib/step/abstract-fragmentary-pipeline-step.d.ts

@@ -0,0 +1,44 @@
+import { AbstractPipelineStep, PipelineStepBuilder, PipelineStepData, PipelineStepHelpers, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
+import { PipelineStepSetsContext } from './step-sets';
+import { HandleAnyError, HandleCatchableError, HandleExposedUncatchableError, HandleUncatchableError, ScriptFuncOrBody } from './types';
+export interface FragmentaryPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends PipelineStepOptions {
+    fromRequest?: ScriptFuncOrBody<GetInFragmentFromRequestFunc<In, InFragment>>;
+    toResponse?: ScriptFuncOrBody<SetOutFragmentToResponseFunc<In, Out, OutFragment>>;
+    mergeRequest?: boolean | string;
+    errorHandles?: {
+        catchable?: ScriptFuncOrBody<HandleCatchableError<In, InFragment, OutFragment>> | Array<PipelineStepBuilder>;
+        uncatchable?: ScriptFuncOrBody<HandleUncatchableError<In, InFragment, OutFragment>> | Array<PipelineStepBuilder>;
+        exposed?: ScriptFuncOrBody<HandleExposedUncatchableError<In, InFragment, OutFragment>> | Array<PipelineStepBuilder>;
+        any?: ScriptFuncOrBody<HandleAnyError<In, InFragment, OutFragment>> | Array<PipelineStepBuilder>;
+    };
+}
+export type GetInFragmentFromRequestFunc<In, InFragment> = ($factor: In, $request: PipelineStepData<In>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => InFragment;
+export type SetOutFragmentToResponseFunc<In, Out, OutFragment> = ($result: OutFragment, $request: PipelineStepData<In>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Out;
+export declare abstract class AbstractFragmentaryPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractPipelineStep<In, Out> {
+    private readonly _fromRequestSnippet;
+    private readonly _toResponseSnippet;
+    private readonly _mergeRequest;
+    private readonly _fromRequestFunc;
+    private readonly _toResponseFunc;
+    private readonly _errorsSnippets?;
+    private readonly _errorsFuncs;
+    constructor(options: FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getFromRequestSnippet(): ScriptFuncOrBody<GetInFragmentFromRequestFunc<In, InFragment>>;
+    getToResponseSnippet(): ScriptFuncOrBody<SetOutFragmentToResponseFunc<In, Out, OutFragment>>;
+    isMergeRequest(): boolean;
+    useUnboxMerging(): boolean;
+    hasMergeKey(): boolean;
+    getMergeKey(): string;
+    protected generateFromRequestVariableNames(): Array<string>;
+    protected generateToResponseVariableNames(): Array<string>;
+    protected createToResponseFunc(): SetOutFragmentToResponseFunc<In, Out, OutFragment>;
+    protected getFromInput($factor: In, $request: PipelineStepData<In>): InFragment;
+    protected setToOutput($result: OutFragment, $request: PipelineStepData<In>): PipelineStepData<Out>;
+    protected abstract doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+    protected buildStepOptions(): Pick<PipelineStepOptions, 'config' | 'logger'>;
+    protected createErrorHandleContext(request: PipelineStepData<In>): PipelineStepSetsContext;
+    protected handleErrorSteps(fragment: InFragment, errorCode: string, error: any, request: PipelineStepData<In>, builders: Array<PipelineStepBuilder>): Promise<OutFragment>;
+    protected handleError(fragment: InFragment, request: PipelineStepData<In>, error: any): Promise<OutFragment>;
+    performAndCatch(request: PipelineStepData<In>, perform: (data: InFragment) => Promise<PipelineStepData<Out>>): Promise<PipelineStepData<Out>>;
+    perform(request: PipelineStepData<In>): Promise<PipelineStepData<Out>>;
+}

package/lib/step/async-step-sets.d.ts

@@ -0,0 +1,5 @@
+import { PipelineStepData, PipelineStepPayload } from '@rainbow-o23/n1';
+import { PipelineStepSets } from './step-sets';
+export declare class AsyncPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In> extends PipelineStepSets<In, Out, InFragment, void> {
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<void>;
+}

package/lib/step/conditional-step-sets.d.ts

@@ -0,0 +1,23 @@
+import { PipelineStepBuilder, PipelineStepData, PipelineStepHelpers, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { PipelineStepSets, PipelineStepSetsOptions } from './step-sets';
+import { ScriptFuncOrBody } from './types';
+export type ConditionCheckWithInFragment<InFragment> = ($factor: InFragment, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<boolean>;
+export type ConditionCheckWithoutInFragment = ($helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<boolean>;
+export type ConditionCheckFunc<InFragment> = ConditionCheckWithInFragment<InFragment> | ConditionCheckWithoutInFragment;
+export interface ConditionalPipelineStepSetsOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends PipelineStepSetsOptions<In, Out, InFragment, OutFragment> {
+    check: ScriptFuncOrBody<ConditionCheckFunc<InFragment>>;
+    otherwiseSteps: Array<PipelineStepBuilder>;
+}
+export declare class ConditionalPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends PipelineStepSets<In, Out, InFragment, OutFragment> {
+    private readonly _checkSnippet;
+    private readonly _func;
+    private readonly _otherwiseStepBuilders;
+    constructor(options: ConditionalPipelineStepSetsOptions<In, Out, InFragment, OutFragment>);
+    getCheckSnippet(): ScriptFuncOrBody<ConditionCheckFunc<InFragment>>;
+    protected getOtherwiseStepBuilders(): Undefinable<Array<PipelineStepBuilder>>;
+    protected generateVariableNames(): Array<string>;
+    protected check(data: InFragment, _request: PipelineStepData<In>): Promise<boolean>;
+    perform(request: PipelineStepData<In>): Promise<PipelineStepData<Out>>;
+    protected isInFragmentIgnored(): boolean;
+    protected getInFragmentVariableName(): string;
+}

package/lib/step/delete-property-step.d.ts

@@ -0,0 +1,11 @@
+import { PipelineStepData, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep } from './abstract-fragmentary-pipeline-step';
+export interface DeletePropertyPipelineStepOptions extends PipelineStepOptions {
+    propertyNames: string | Array<string>;
+}
+export declare class DeletePropertyPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _propertyNames;
+    constructor(options: DeletePropertyPipelineStepOptions);
+    getPropertyNames(): Array<string>;
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+}

package/lib/step/each-step-sets.d.ts

@@ -0,0 +1,14 @@
+import { PipelineStepData, PipelineStepPayload } from '@rainbow-o23/n1';
+import { PipelineStepSets, PipelineStepSetsOptions } from './step-sets';
+export interface EachPipelineStepSetsOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends PipelineStepSetsOptions<In, Out, InFragment, OutFragment> {
+    originalContentName?: string;
+    itemName?: string;
+}
+export declare class EachPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends PipelineStepSets<In, Out, InFragment, OutFragment> {
+    private readonly _originalContentPropertyName;
+    private readonly _itemPropertyName;
+    constructor(options: EachPipelineStepSetsOptions<In, Out, InFragment, OutFragment>);
+    protected getOriginalContentPropertyName(): string;
+    protected getItemPropertyName(): string;
+    perform(request: PipelineStepData<In>): Promise<PipelineStepData<Out>>;
+}

package/lib/step/get-property-step.d.ts

@@ -0,0 +1,11 @@
+import { PipelineStepData, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
+export interface GetPropertyPipelineStepOptions extends FragmentaryPipelineStepOptions {
+    propertyName: string;
+}
+export declare class GetPropertyPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _propertyName;
+    constructor(options: GetPropertyPipelineStepOptions);
+    getPropertyName(): string;
+    protected doPerform(data: InFragment, _request: PipelineStepData<In>): Promise<OutFragment>;
+}

package/lib/step/index.d.ts

@@ -0,0 +1,14 @@
+export * from './types';
+export * from './utils';
+export * from './abstract-fragmentary-pipeline-step';
+export * from './step-sets';
+export * from './async-step-sets';
+export * from './each-step-sets';
+export * from './conditional-step-sets';
+export * from './routes-step-sets';
+export * from './snippet-step';
+export * from './snowflake-step';
+export * from './get-property-step';
+export * from './delete-property-step';
+export * from './ref-pipeline-step';
+export * from './ref-step-step';

package/lib/step/ref-pipeline-step.d.ts

@@ -0,0 +1,15 @@
+import { PipelineBuilder, PipelineCode, PipelineOptions, PipelineStepData, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
+export interface RefPipelinePipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    code: PipelineCode;
+}
+export declare class RefPipelinePipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _code;
+    private readonly _pipelineBuilder;
+    constructor(options: RefPipelinePipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getCode(): PipelineCode;
+    protected getPipelineBuilder(): PipelineBuilder;
+    protected buildPipelineOptions(): PipelineOptions;
+    protected buildStepOptions(): Pick<PipelineStepOptions, 'config' | 'logger'>;
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+}

package/lib/step/ref-step-step.d.ts

@@ -0,0 +1,14 @@
+import { PipelineStepBuilder, PipelineStepCode, PipelineStepData, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
+export interface RefStepPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    code: PipelineStepCode;
+}
+export declare class RefStepPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _code;
+    private readonly _stepBuilder;
+    constructor(options: RefStepPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getCode(): PipelineStepCode;
+    protected getStepBuilder(): PipelineStepBuilder;
+    protected buildStepOptions(): Pick<PipelineStepOptions, 'config' | 'logger'>;
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+}

package/lib/step/routes-step-sets.d.ts

@@ -0,0 +1,30 @@
+import { PipelineStepBuilder, PipelineStepData, PipelineStepOptions, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
+import { ConditionCheckFunc } from './conditional-step-sets';
+import { ScriptFuncOrBody } from './types';
+export interface RoutesConditionalStepOptions<InFragment> {
+    check: ScriptFuncOrBody<ConditionCheckFunc<InFragment>>;
+    steps?: Array<PipelineStepBuilder>;
+}
+export interface RoutesPipelineStepSetsOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    conditionalSteps: Array<RoutesConditionalStepOptions<InFragment>>;
+    otherwiseSteps?: Array<PipelineStepBuilder>;
+}
+export interface RoutesConditionalStep<InFragment> {
+    check: ConditionCheckFunc<InFragment>;
+    steps: Array<PipelineStepBuilder>;
+}
+export declare class RoutesPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _conditionalStepBuilders;
+    private readonly _otherwiseStepBuilders;
+    constructor(options: RoutesPipelineStepSetsOptions<In, Out, InFragment, OutFragment>);
+    protected getConditionalStepBuilders(): Array<RoutesConditionalStep<InFragment>>;
+    protected getOtherwiseStepBuilders(): Undefinable<Array<PipelineStepBuilder>>;
+    protected buildStepOptions(): Pick<PipelineStepOptions, 'config' | 'logger'>;
+    protected generateVariableNames(): Array<string>;
+    protected check(func: ConditionCheckFunc<InFragment>, data: InFragment, _request: PipelineStepData<In>): Promise<boolean>;
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+    perform(request: PipelineStepData<In>): Promise<PipelineStepData<Out>>;
+    protected isInFragmentIgnored(): boolean;
+    protected getInFragmentVariableName(): string;
+}

package/lib/step/snippet-step.d.ts

@@ -0,0 +1,19 @@
+import { PipelineStepData, PipelineStepHelpers, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
+import { ScriptFuncOrBody } from './types';
+export type PerformWithInFragment<InFragment, OutFragment> = ($factor: InFragment, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment>;
+export type PerformWithoutInFragment<OutFragment> = ($helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment>;
+export type PerformFunc<InFragment, OutFragment> = PerformWithInFragment<InFragment, OutFragment> | PerformWithoutInFragment<OutFragment>;
+export interface SnippetPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    snippet: ScriptFuncOrBody<PerformFunc<InFragment, OutFragment>>;
+}
+export declare class SnippetPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _snippet;
+    private readonly _func;
+    constructor(options: SnippetPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getSnippet(): ScriptFuncOrBody<PerformFunc<InFragment, OutFragment>>;
+    protected generateVariableNames(): Array<string>;
+    protected doPerform(data: InFragment, _request: PipelineStepData<In>): Promise<OutFragment>;
+    protected isInFragmentIgnored(): boolean;
+    protected getInFragmentVariableName(): string;
+}

package/lib/step/snowflake-step.d.ts

@@ -0,0 +1,6 @@
+import { PipelineStepData, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep } from './abstract-fragmentary-pipeline-step';
+export type SnowflakeId = string;
+export declare class SnowflakePipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, SnowflakeId> {
+    protected doPerform(_data: InFragment, _request: PipelineStepData<In>): Promise<SnowflakeId>;
+}

package/lib/step/step-sets.d.ts

@@ -0,0 +1,19 @@
+import { PipelineStep, PipelineStepBuilder, PipelineStepData, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
+export interface PipelineStepSetsContext {
+}
+export interface PipelineStepSetsOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    steps: Array<PipelineStepBuilder>;
+}
+export declare class PipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _stepBuilders;
+    constructor(options: PipelineStepSetsOptions<In, Out, InFragment, OutFragment>);
+    protected getStepBuilders(): Array<PipelineStepBuilder>;
+    protected buildStepOptions(): Pick<PipelineStepOptions, 'config' | 'logger'>;
+    createSteps(): Promise<Array<PipelineStep>>;
+    protected inheritContext(request: PipelineStepData<In>): PipelineStepSetsContext;
+    protected attachMineToInternalContext(inheritedContext: PipelineStepSetsContext, _request: PipelineStepData<In>): Promise<PipelineStepSetsContext>;
+    protected createInternalContext<Ctx extends PipelineStepSetsContext>(request: PipelineStepData<In>): Promise<Ctx>;
+    protected performWithContext(request: PipelineStepData<In>, run: (request: PipelineStepData<In>, context: PipelineStepSetsContext) => Promise<OutFragment>): Promise<OutFragment>;
+    protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+}

package/lib/step/types.d.ts

@@ -0,0 +1,13 @@
+import { CatchableError, ExposedUncatchableError, PipelineStepData, PipelineStepHelpers, UncatchableError } from '@rainbow-o23/n1';
+export type ScriptFunctionBody = string;
+export type ScriptFuncOrBody<F = Function> = F | ScriptFunctionBody;
+export interface ErrorHandleOptions<In, InFragment, E extends Error = Error> {
+    $code: string;
+    $error: E;
+    $factor: InFragment;
+    $request: PipelineStepData<In>;
+}
+export type HandleCatchableError<In, InFragment, OutFragment> = ($options: ErrorHandleOptions<In, InFragment, CatchableError>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment> | never;
+export type HandleUncatchableError<In, InFragment, OutFragment> = ($options: ErrorHandleOptions<In, InFragment, UncatchableError>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment> | never;
+export type HandleExposedUncatchableError<In, InFragment, OutFragment> = ($options: ErrorHandleOptions<In, InFragment, ExposedUncatchableError>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment> | never;
+export type HandleAnyError<In, InFragment, OutFragment> = ($options: ErrorHandleOptions<In, InFragment>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment> | never;

package/lib/step/utils.d.ts

@@ -0,0 +1,23 @@
+import { Nullable, Undefinable } from '@rainbow-o23/n1';
+import { ScriptFuncOrBody } from './types';
+export declare class Utils {
+    static createFunction<F = Function>(snippet: ScriptFuncOrBody<F>, creators: {
+        createDefault: () => Undefinable<F> | never;
+        getVariableNames: () => Array<string>;
+        async?: true;
+        error: (e: Error) => never;
+    }): F;
+    static createSyncFunction<F = Function>(snippet: ScriptFuncOrBody<F>, creators: {
+        createDefault: () => Undefinable<F> | never;
+        getVariableNames: () => Array<string>;
+        error: (e: Error) => never;
+    }): F;
+    static createAsyncFunction<F = Function>(snippet: ScriptFuncOrBody<F>, creators: {
+        createDefault: () => Undefinable<F> | never;
+        getVariableNames: () => Array<string>;
+        error: (e: Error) => never;
+    }): F;
+    static isPrimitive(value: any): value is string | number | boolean | symbol | bigint;
+    static getValue<V>(model: any, propertyPath: string): Nullable<V>;
+    static clone(obj: any): any;
+}

package/lib/typeorm/abstract-datasource.d.ts

@@ -0,0 +1,22 @@
+import { Config } from '@rainbow-o23/n1';
+import { DataSource, DataSourceOptions } from 'typeorm';
+export interface TypeOrmDataSource {
+    getName(): string;
+    shouldKeptOnGlobal(): boolean;
+    getDataSource(): DataSource;
+    initialize(config: Config, entities: DataSourceOptions['entities']): Promise<DataSource>;
+    destroy(): Promise<void>;
+}
+export declare abstract class AbstractTypeOrmDataSource<O extends DataSourceOptions> implements TypeOrmDataSource {
+    private readonly _name;
+    private _initialized;
+    private _dataSource;
+    constructor(_name: string);
+    getName(): string;
+    isInitialized(): boolean;
+    getDataSource(): DataSource;
+    shouldKeptOnGlobal(): boolean;
+    protected abstract createOptions(config: Config): O;
+    initialize(config: Config, entities: DataSourceOptions['entities']): Promise<DataSource>;
+    destroy(): Promise<void>;
+}

package/lib/typeorm/better-sqlite3-datasource.d.ts

@@ -0,0 +1,7 @@
+import { Config } from '@rainbow-o23/n1';
+import { BetterSqlite3ConnectionOptions } from 'typeorm/driver/better-sqlite3/BetterSqlite3ConnectionOptions.js';
+import { AbstractTypeOrmDataSource } from './abstract-datasource';
+export declare class BetterSqlite3TypeOrmDatasource extends AbstractTypeOrmDataSource<BetterSqlite3ConnectionOptions> {
+    shouldKeptOnGlobal(): boolean;
+    protected createOptions(config: Config): BetterSqlite3ConnectionOptions;
+}

package/lib/typeorm/datasource-manager.d.ts

@@ -0,0 +1,25 @@
+import { Config, Undefinable } from '@rainbow-o23/n1';
+import { DataSourceOptions } from 'typeorm';
+import { TypeOrmDataSource } from './abstract-datasource';
+export type DataSourceCreate = (name: string) => Promise<TypeOrmDataSource>;
+export type DataSourceType = string;
+export declare enum SupportedDataSourceTypes {
+    MYSQL = "mysql",
+    POSTGRES = "pgsql",
+    MSSQL = "mssql",
+    ORACLE = "oracle",
+    BETTER_SQLITE3 = "better-sqlite3"
+}
+export declare class TypeOrmDataSourceManager {
+    private constructor();
+    static registerCreator(type: DataSourceType, create: DataSourceCreate): Undefinable<DataSourceCreate>;
+    static createDataSource(name: string, config: Config, entities: DataSourceOptions['entities']): Promise<TypeOrmDataSource>;
+    static findDataSource(name: string, config: Config): Promise<Undefinable<TypeOrmDataSource>>;
+    static findDataSourceType(name: string, config: Config): DataSourceType;
+}
+export declare class TypeOrmDataSourceHelper {
+    private readonly config;
+    constructor(config: Config);
+    registerCreator(type: DataSourceType, create: DataSourceCreate): Undefinable<DataSourceCreate>;
+    create(dataSources: Record<string, DataSourceOptions['entities']>): Promise<void>;
+}

package/lib/typeorm/index.d.ts

@@ -0,0 +1,7 @@
+export * from './abstract-datasource';
+export * from './better-sqlite3-datasource';
+export * from './mysql-datasource';
+export * from './pgsql-datasource';
+export * from './mssql-datasource';
+export * from './oracle-datasource';
+export * from './datasource-manager';

package/lib/typeorm/mssql-datasource.d.ts

@@ -0,0 +1,6 @@
+import { Config } from '@rainbow-o23/n1';
+import { SqlServerConnectionOptions } from 'typeorm/driver/sqlserver/SqlServerConnectionOptions.js';
+import { AbstractTypeOrmDataSource } from './abstract-datasource';
+export declare class MssqlTypeOrmDatasource extends AbstractTypeOrmDataSource<SqlServerConnectionOptions> {
+    protected createOptions(config: Config): SqlServerConnectionOptions;
+}

package/lib/typeorm/mysql-datasource.d.ts

@@ -0,0 +1,6 @@
+import { Config } from '@rainbow-o23/n1';
+import { MysqlConnectionOptions } from 'typeorm/driver/mysql/MysqlConnectionOptions.js';
+import { AbstractTypeOrmDataSource } from './abstract-datasource';
+export declare class MysqlTypeOrmDatasource extends AbstractTypeOrmDataSource<MysqlConnectionOptions> {
+    protected createOptions(config: Config): MysqlConnectionOptions;
+}

package/lib/typeorm/oracle-datasource.d.ts

@@ -0,0 +1,6 @@
+import { Config } from '@rainbow-o23/n1';
+import { OracleConnectionOptions } from 'typeorm/driver/oracle/OracleConnectionOptions';
+import { AbstractTypeOrmDataSource } from './abstract-datasource';
+export declare class OracleTypeOrmDatasource extends AbstractTypeOrmDataSource<OracleConnectionOptions> {
+    protected createOptions(config: Config): OracleConnectionOptions;
+}

package/lib/typeorm/pgsql-datasource.d.ts

@@ -0,0 +1,6 @@
+import { Config } from '@rainbow-o23/n1';
+import { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions.js';
+import { AbstractTypeOrmDataSource } from './abstract-datasource';
+export declare class PgsqlTypeOrmDatasource extends AbstractTypeOrmDataSource<PostgresConnectionOptions> {
+    protected createOptions(config: Config): PostgresConnectionOptions;
+}

package/lib/typeorm-step/abstract-typeorm-by-sql-step.d.ts

@@ -0,0 +1,62 @@
+import { PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { DataSourceType } from '../typeorm';
+import { AbstractTypeOrmPipelineStep, TypeOrmPipelineStepOptions } from './abstract-typeorm-step';
+import { TypeOrmEntityToSave, TypeOrmEntityValue, TypeOrmSql } from './types';
+export interface TypeOrmBasis {
+    sql?: TypeOrmSql;
+}
+export interface TypeOrmBySQLPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = TypeOrmBasis, OutFragment = Out> extends TypeOrmPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    sql?: TypeOrmSql;
+}
+export interface ParsedTypeOrmSql {
+    sql: TypeOrmSql;
+    params: Array<any>;
+}
+export declare enum ParsedSqlSegmentType {
+    NONE = "none",
+    SINGLE = "single",
+    ONE_OF = "one-of",
+    CONTAINS = "contains",
+    ENDS_WITH = "ends-with",
+    STARTS_WITH = "starts-with"
+}
+export interface ParsedSqlSegment {
+    statement: string;
+    type: ParsedSqlSegmentType;
+    variable?: string;
+}
+export declare class TypeOrmParsedSQLCache {
+    [key: TypeOrmSql]: Array<ParsedSqlSegment>;
+}
+export declare abstract class AbstractTypeOrmBySQLPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = Undefinable<TypeOrmBasis>, OutFragment = Out> extends AbstractTypeOrmPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _timestampWriteFormat;
+    private readonly _timestampReadFormat;
+    private readonly _sql;
+    private _parsedSqlSegments;
+    constructor(options: TypeOrmBySQLPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    protected getDefaultTimestampFormats(): {
+        write: string;
+        read: string;
+    };
+    protected getTimestampWriteFormat(): string;
+    protected getTimestampReadFormat(): string;
+    protected getParsedSqlSegments(): Undefinable<Array<ParsedSqlSegment>>;
+    protected parseSql(sql: TypeOrmSql): void;
+    protected replaceSqlPagination(sql: TypeOrmSql, type: DataSourceType): TypeOrmSql;
+    protected computeSqlPlaceholder(options: {
+        segment: ParsedSqlSegment;
+        placeholderIndex: number;
+        datasourceType: DataSourceType;
+    }): string;
+    protected getBindingValue(options: {
+        params: TypeOrmEntityToSave;
+        segment: ParsedSqlSegment;
+        datasourceType: DataSourceType;
+    }): any;
+    protected getSql(basis: Undefinable<TypeOrmBasis>, params: Array<TypeOrmEntityValue> | TypeOrmEntityToSave): ParsedTypeOrmSql;
+    protected beautify<T>(options: {
+        data: T;
+        datasourceType: DataSourceType;
+    }): T;
+    protected parseResult(result: any): any;
+}

package/lib/typeorm-step/abstract-typeorm-load-by-sql-step.d.ts

@@ -0,0 +1,10 @@
+import { PipelineStepData, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { AbstractTypeOrmBySQLPipelineStep, TypeOrmBasis } from './abstract-typeorm-by-sql-step';
+import { TypeOrmEntityToLoad, TypeOrmEntityToSave, TypeOrmEntityValue } from './types';
+export interface TypeOrmLoadBasis extends TypeOrmBasis {
+    params?: Array<TypeOrmEntityValue> | TypeOrmEntityToSave;
+}
+export declare abstract class AbstractTypeOrmLoadBySQLPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment = Out> extends AbstractTypeOrmBySQLPipelineStep<In, Out, Undefinable<TypeOrmLoadBasis>, OutFragment> {
+    protected abstract getDataFromResultSet(rst: Array<TypeOrmEntityToLoad>): Promise<OutFragment>;
+    protected doPerform(basis: Undefinable<TypeOrmLoadBasis>, request: PipelineStepData<In>): Promise<Undefinable<OutFragment>>;
+}

package/lib/typeorm-step/abstract-typeorm-step.d.ts

@@ -0,0 +1,30 @@
+import { PipelineStepData, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { DataSource, EntityMetadata, ObjectLiteral, QueryRunner, Repository } from 'typeorm';
+import { ColumnMetadata } from 'typeorm/metadata/ColumnMetadata.js';
+import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from '../step';
+import { DataSourceType, TypeOrmDataSource } from '../typeorm';
+import { TypeOrmDataSourceName, TypeOrmEntityName, TypeOrmTransactionKey, TypeOrmTransactionName } from './types';
+export interface TypeOrmPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    dataSourceName: TypeOrmDataSourceName;
+    transactionName?: TypeOrmTransactionName;
+    autonomous?: boolean;
+}
+export declare abstract class AbstractTypeOrmPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _dataSourceName;
+    private readonly _transactionName;
+    private readonly _autonomous;
+    constructor(options: TypeOrmPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getDataSourceName(): TypeOrmDataSourceName;
+    getTransactionName(): TypeOrmTransactionName;
+    getTransactionKey(): TypeOrmTransactionKey;
+    isAutonomous(): boolean;
+    protected isTransactional(request: PipelineStepData<In>): boolean;
+    protected findTransactionalContext(request: PipelineStepData<In>): Undefinable<[TypeOrmDataSource, QueryRunner]>;
+    protected findDataSourceType(): DataSourceType;
+    protected findDataSource(request: PipelineStepData<In>): Promise<Undefinable<TypeOrmDataSource>>;
+    protected findDataSourceOrThrow(request: PipelineStepData<In>): Promise<Undefinable<TypeOrmDataSource>>;
+    protected createRunner(request: PipelineStepData<In>): Promise<QueryRunner>;
+    protected trans<R>(run: (runner: QueryRunner) => Promise<R>, handleRollbackError: (err: Error) => Undefinable<Error>, request: PipelineStepData<In>): Promise<R>;
+    protected autoTrans<R>(run: (runner: QueryRunner) => Promise<R>, request: PipelineStepData<In>): Promise<R>;
+    protected findMetadata<E extends ObjectLiteral>(name: TypeOrmEntityName, request: PipelineStepData<In>): Promise<[EntityMetadata, ColumnMetadata, Repository<E>, DataSource]>;
+}

package/lib/typeorm-step/index.d.ts

@@ -0,0 +1,12 @@
+export * from './types';
+export * from './abstract-typeorm-step';
+export * from './typeorm-load-entity-by-id-step';
+export * from './typeorm-save-entity-step';
+export * from './typeorm-by-snippet-step';
+export * from './abstract-typeorm-by-sql-step';
+export * from './abstract-typeorm-load-by-sql-step';
+export * from './typeorm-load-one-by-sql-step';
+export * from './typeorm-load-many-by-sql-step';
+export * from './typeorm-save-by-sql-step';
+export * from './typeorm-bulk-save-by-sql-step';
+export * from './type-orm-transactional-step-sets';