@rainbow-o23/n3 1.0.58 → 1.0.59

package/index.js

@@ -649,23 +649,19 @@ class AbstractFragmentaryPipelineStep extends AbstractPipelineStep {
     }
     async setToOutput($result, $request) {
         const $helpers = this.getHelpers();
-        return { content: await this._toResponseFunc($result, $request, $helpers, $helpers) };
+        return {
+            content: await this._toResponseFunc($result, $request, $helpers, $helpers),
+            $context: $request.$context
+        };
     }
     buildStepOptions() {
         return { config: this.getConfig(), logger: this.getLogger() };
     }
     createErrorHandleContext(request) {
-        const context = request.$context;
-        if (context == null) {
-            return {};
-        }
-        else {
-            const { authorization, traceId, ...rest } = context;
-            return { authorization, traceId, ...Utils.clone(rest) };
-        }
+        return request.$context;
     }
     async handleErrorSteps(fragment, errorCode, error, request, builders) {
-        const { $context: { authorization, traceId } = {} } = request;
+        const traceId = request.$context.traceId;
         const errorContext = this.createErrorHandleContext(request);
         const options = this.buildStepOptions();
         const steps = await Promise.all(builders.map(async (builder) => await builder.create(options)));
@@ -675,7 +671,7 @@ class AbstractFragmentaryPipelineStep extends AbstractPipelineStep {
                 .execute(async () => {
                 this.traceStepIn(traceId, step, request);
                 const response = await step.perform({
-                    ...request, $context: { ...errorContext, authorization, traceId }
+                    ...request, $context: errorContext
                 });
                 this.traceStepOut(traceId, step, response);
                 return this.returnOrContinueOrClear(request, response);
@@ -771,14 +767,7 @@ class PipelineStepSets extends AbstractFragmentaryPipelineStep {
         return await Promise.all(this.getStepBuilders().map(async (builder) => await builder.create(options)));
     }
     inheritContext(request) {
-        const context = request.$context;
-        if (context == null) {
-            return {};
-        }
-        else {
-            const { authorization, traceId, ...rest } = context;
-            return { authorization, traceId, ...Utils.clone(rest) };
-        }
+        return request.$context;
     }
     async attachMineToInternalContext(inheritedContext, _request) {
         return inheritedContext;
@@ -792,7 +781,7 @@ class PipelineStepSets extends AbstractFragmentaryPipelineStep {
     }
     async doPerform(data, request) {
         return await this.performWithContext(request, async (request, context) => {
-            const { $context: { authorization, traceId } = {} } = request;
+            const traceId = context.traceId;
             const steps = await this.createSteps();
             const response = await steps.reduce(async (promise, step) => {
                 const request = await promise;
@@ -800,7 +789,7 @@ class PipelineStepSets extends AbstractFragmentaryPipelineStep {
                     .execute(async () => {
                     this.traceStepIn(traceId, step, request);
                     const response = await step.perform({
-                        ...request, $context: { ...context, authorization, traceId }
+                        ...request, $context: context
                     });
                     this.traceStepOut(traceId, step, response);
                     return this.returnOrContinueOrClear(request, response);
@@ -812,6 +801,9 @@ class PipelineStepSets extends AbstractFragmentaryPipelineStep {
 }
 
 class AsyncPipelineStepSets extends PipelineStepSets {
+    inheritContext(request) {
+        return request.$context.clone('$trans');
+    }
     async doPerform(data, request) {
         super.doPerform(data, request);
         return;
@@ -852,14 +844,14 @@ class ParallelPipelineStepSets extends PipelineStepSets {
     }
     async doPerform(data, request) {
         return await this.performWithContext(request, async (request, context) => {
-            const { $context: { authorization, traceId } = {} } = request;
+            const traceId = context.traceId;
             const steps = await this.createSteps();
             const execute = () => {
                 return steps.map(async (step) => {
                     return await this.measurePerformance(traceId, 'STEP', step.constructor.name)
                         .execute(async () => {
                         const eachData = await this.cloneDataForEach(data, request);
-                        const eachRequest = { content: eachData, $context: { ...context, authorization, traceId } };
+                        const eachRequest = { content: eachData, $context: context };
                         this.traceStepIn(traceId, step, request);
                         const response = await step.perform(eachRequest);
                         this.traceStepOut(traceId, step, response);
@@ -1224,9 +1216,8 @@ class RefPipelinePipelineStep extends AbstractFragmentaryPipelineStep {
         return { config: this.getConfig(), logger: this.getLogger() };
     }
     async doPerform(data, request) {
-        const { $context: { authorization, traceId } = {} } = request;
         const pipeline = await this.getPipelineBuilder().create(this.buildPipelineOptions());
-        const result = await pipeline.perform({ payload: data, authorization, traceId });
+        const result = await pipeline.perform({ payload: data, $context: request.$context });
         return result.payload;
     }
 }
@@ -1273,6 +1264,7 @@ const HttpAbortErrorCode = '600';
 class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
     _endpointSystemCode;
     _endpointName;
+    _endpointKey;
     _endpointUrl;
     _endpointMethod;
     _endpointHeaders;
@@ -1283,6 +1275,8 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
     _omittedTransparentHeaderNames;
     _headersGenerateSnippet;
     _headersGenerateFunc;
+    _endpointTraceIdHeaderName;
+    _endpointTraceIdScope;
     _bodyUsed;
     _bodyGenerateSnippet;
     _bodyGenerateFunc;
@@ -1294,13 +1288,13 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
         const config = this.getConfig();
         this._endpointSystemCode = options.endpointSystemCode;
         this._endpointName = options.endpointName;
-        const endpointKey = this.getEndpointKey();
-        this._endpointUrl = config.getString(`endpoints.${endpointKey}.url`);
+        this._endpointKey = `${this._endpointSystemCode}.${this._endpointName}`;
+        this._endpointUrl = config.getString(`endpoints.${this._endpointKey}.url`);
         this._endpointMethod = (options.method ?? 'POST').trim().toLowerCase();
-        this._endpointHeaders = this.generateEndpointHeaders(config.getString(`endpoints.${endpointKey}.headers`), this.generateEndpointHeaders(config.getString(`endpoints.${this.getEndpointSystemCode()}.global.headers`)));
+        this._endpointHeaders = this.generateEndpointHeaders(config.getString(`endpoints.${this._endpointKey}.headers`), this.generateEndpointHeaders(config.getString(`endpoints.${this._endpointSystemCode}.global.headers`)));
         this._endpointTimeout = options.timeout
-            ?? config.getNumber(`endpoints.${endpointKey}.timeout`)
-            ?? config.getNumber(`endpoints.${this.getEndpointSystemCode()}.global.timeout`, -1);
+            ?? config.getNumber(`endpoints.${this._endpointKey}.timeout`)
+            ?? config.getNumber(`endpoints.${this._endpointSystemCode}.global.timeout`, -1);
         this._endpointTimeout = this._endpointTimeout > 0 ? this._endpointTimeout * 1000 : -1;
         this._urlGenerateSnippet = options.urlGenerate;
         this._urlGenerateFunc = Utils.createAsyncFunction(this.getUrlGenerateSnippet(), {
@@ -1312,9 +1306,9 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
             }
         });
         this._transparentHeaderNames = options.transparentHeaderNames
-            ?? this.generateTransparentHeaderNames(config.getString(`endpoints.${endpointKey}.headers.transparent`), this.generateTransparentHeaderNames(config.getString(`endpoints.${this.getEndpointSystemCode()}.global.headers.transparent`)));
+            ?? this.generateTransparentHeaderNames(config.getString(`endpoints.${this._endpointKey}.headers.transparent`), this.generateTransparentHeaderNames(config.getString(`endpoints.${this._endpointSystemCode}.global.headers.transparent`)));
         this._omittedTransparentHeaderNames = options.omittedTransparentHeaderNames
-            ?? this.generateTransparentHeaderNames(config.getString(`endpoints.${endpointKey}.headers.transparent.omitted`), this.generateTransparentHeaderNames(config.getString(`endpoints.${this.getEndpointSystemCode()}.global.headers.transparent.omitted`)));
+            ?? this.generateTransparentHeaderNames(config.getString(`endpoints.${this._endpointKey}.headers.transparent.omitted`), this.generateTransparentHeaderNames(config.getString(`endpoints.${this._endpointSystemCode}.global.headers.transparent.omitted`)));
         this._headersGenerateSnippet = options.headersGenerate;
         this._headersGenerateFunc = Utils.createAsyncFunction(this.getHeadersGenerateSnippet(), {
             createDefault: () => async (_$factor, _$request, _$helpers, _$) => (void 0),
@@ -1324,6 +1318,22 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
                 throw e;
             }
         });
+        let traceIdHeaderName = config.getString(`endpoints.${this._endpointKey}.trace.header.name`)?.trim();
+        if (traceIdHeaderName != null) {
+            this._endpointTraceIdHeaderName = traceIdHeaderName.toLowerCase();
+            this._endpointTraceIdScope = 'endpoint';
+        }
+        else {
+            traceIdHeaderName = config.getString(`endpoints.${this._endpointSystemCode}.global.trace.header.name`)?.trim();
+            if (traceIdHeaderName != null) {
+                this._endpointTraceIdHeaderName = traceIdHeaderName.toLowerCase();
+                this._endpointTraceIdScope = 'system';
+            }
+            else {
+                this._endpointTraceIdHeaderName = (void 0);
+                this._endpointTraceIdScope = (void 0);
+            }
+        }
         this._bodyUsed = options.bodyUsed;
         this._bodyGenerateSnippet = options.bodyGenerate;
         this._bodyGenerateFunc = Utils.createAsyncFunction(this.getBodyGenerateSnippet(), {
@@ -1403,7 +1413,7 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
         return this._endpointName;
     }
     getEndpointKey() {
-        return `${this.getEndpointSystemCode()}.${this.getEndpointName()}`;
+        return this._endpointKey;
     }
     getEndpointUrl() {
         return this._endpointUrl;
@@ -1458,6 +1468,12 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
     getHeadersGenerateVariableNames() {
         return ['$factor', '$request', ...this.getHelpersVariableNames()];
     }
+    getEndpointTraceIdHeaderName() {
+        return this._endpointTraceIdHeaderName;
+    }
+    getEndpointTraceIdScope() {
+        return this._endpointTraceIdScope;
+    }
     isBodyUsed() {
         return this._bodyUsed;
     }
@@ -1476,79 +1492,141 @@ class FetchPipelineStep extends AbstractFragmentaryPipelineStep {
     getErrorHandlerVariableName() {
         return ['$options', ...this.getHelpersVariableNames()];
     }
-    async doPerform(data, request) {
-        const $helpers = this.getHelpers();
-        let url = '';
-        try {
-            url = await this._urlGenerateFunc(this.getEndpointUrl(), data, request, $helpers, $helpers);
-            const method = this.getEndpointMethod();
-            const staticHeaders = this.getEndpointHeaders() ?? {};
-            const transparentHeaders = (this.getTransparentHeaderNames() ?? []).reduce((headers, name) => {
-                const value = Utils.getValue(data, name);
-                if (value == null) {
-                }
-                else if (Array.isArray(value)) {
-                    const headerValue = value.filter(v => v != null && `${v}`.length !== 0).join(', ');
-                    if (headerValue.length !== 0) {
-                        headers[name] = headerValue;
-                    }
-                }
-                else if (typeof value === 'object') {
-                    Object.keys(value).forEach(key => {
-                        const headerValue = value[key];
-                        if (headerValue != null) {
-                            const s = `${headerValue}`;
-                            if (s.length !== 0) {
-                                headers[key] = s;
-                            }
-                        }
-                    });
-                }
-                else {
-                    const headerValue = `${value}`;
-                    if (headerValue.length !== 0) {
-                        headers[name] = headerValue;
-                    }
-                }
-                return headers;
-            }, {});
-            (this.getOmittedTransparentHeaderNames() ?? []).forEach(name => delete transparentHeaders[name]);
-            const generatedHeaders = await this._headersGenerateFunc(data, request, $helpers, $helpers) ?? {};
-            let body;
-            const bodyUsed = this.isBodyUsed();
-            if (bodyUsed === true || (bodyUsed == null && method !== 'get')) {
-                body = await this._bodyGenerateFunc(data, request, $helpers, $helpers);
+    syncEndpointTraceId(headers, request) {
+        const endpointTraceIdHeaderName = this.getEndpointTraceIdHeaderName();
+        if (endpointTraceIdHeaderName == null) {
+            return (void 0);
+        }
+        const headerName = Object.keys(headers).find(name => name.toLowerCase() === endpointTraceIdHeaderName);
+        if (headerName != null) {
+            return (void 0);
+        }
+        let endpointTraceId = headers[headerName];
+        const endpointTraceIdScope = this.getEndpointTraceIdScope();
+        if (endpointTraceId != null) {
+            if (endpointTraceIdScope === 'system') {
+                request.$context.setScopedTraceId(this.getEndpointSystemCode(), endpointTraceIdHeaderName, endpointTraceId);
             }
             else {
-                body = (void 0);
+                request.$context.setScopedTraceId(this.getEndpointKey(), endpointTraceIdHeaderName, endpointTraceId);
             }
-            if (body != null && typeof body !== 'string') {
-                body = JSON.stringify(body);
+        }
+        else {
+            if (endpointTraceIdScope === 'system') {
+                endpointTraceId = request.$context.findScopedTraceId(this.getEndpointSystemCode())?.[1];
             }
-            const headers = { ...staticHeaders, ...transparentHeaders, ...generatedHeaders };
-            Object.keys(headers).filter(name => {
-                return ['content-encoding', 'content-length'].includes(name.toLowerCase());
-            }).forEach(name => {
-                delete headers[name];
-            });
-            const response = await fetch(url, {
-                method, headers, body,
-                signal: this.needTimeout() ? (() => {
-                    const controller = new AbortController();
-                    setTimeout(() => controller.abort(), this.getEndpointTimeout());
-                    return controller.signal;
-                })() : (void 0)
-            });
-            const status = response.status;
-            if (status >= 400) {
-                return await this._responseErrorHandleFunc({
-                    $url: url, $factor: data, $request: request, $response: response,
-                    $errorCode: `${status}`
-                }, $helpers, $helpers);
+            else {
+                endpointTraceId = request.$context.findScopedTraceId(this.getEndpointKey())?.[1];
+            }
+            if (endpointTraceId != null) {
+                headers[endpointTraceIdHeaderName] = endpointTraceId;
+            }
+        }
+        return endpointTraceId;
+    }
+    async generateRequestHeaders(data, request, $helpers) {
+        const staticHeaders = this.getEndpointHeaders() ?? {};
+        const transparentHeaders = (this.getTransparentHeaderNames() ?? []).reduce((headers, name) => {
+            const value = Utils.getValue(data, name);
+            if (value == null) ;
+            else if (Array.isArray(value)) {
+                const headerValue = value.filter(v => v != null && `${v}`.length !== 0).join(', ');
+                if (headerValue.length !== 0) {
+                    headers[name] = headerValue;
+                }
+            }
+            else if (typeof value === 'object') {
+                Object.keys(value).forEach(key => {
+                    const headerValue = value[key];
+                    if (headerValue != null) {
+                        const s = `${headerValue}`;
+                        if (s.length !== 0) {
+                            headers[key] = s;
+                        }
+                    }
+                });
             }
             else {
-                return await this._responseGenerateFunc(response, data, request, $helpers, $helpers);
+                const headerValue = `${value}`;
+                if (headerValue.length !== 0) {
+                    headers[name] = headerValue;
+                }
             }
+            return headers;
+        }, {});
+        (this.getOmittedTransparentHeaderNames() ?? []).forEach(name => delete transparentHeaders[name]);
+        const generatedHeaders = await this._headersGenerateFunc(data, request, $helpers, $helpers) ?? {};
+        const headers = { ...staticHeaders, ...transparentHeaders, ...generatedHeaders };
+        Object.keys(headers).filter(name => {
+            return ['content-encoding', 'content-length'].includes(name.toLowerCase());
+        }).forEach(name => {
+            delete headers[name];
+        });
+        return headers;
+    }
+    async generateRequestBody(method, data, request, $helpers) {
+        let body;
+        const bodyUsed = this.isBodyUsed();
+        if (bodyUsed === true || (bodyUsed == null && method !== 'get')) {
+            body = await this._bodyGenerateFunc(data, request, $helpers, $helpers);
+        }
+        else {
+            body = (void 0);
+        }
+        if (body != null && typeof body !== 'string') {
+            body = JSON.stringify(body);
+        }
+        return body;
+    }
+    tryToRetrieveTraceIdFromResponse(request, response) {
+        const endpointTraceIdHeaderName = this.getEndpointTraceIdHeaderName();
+        if (endpointTraceIdHeaderName == null) {
+            return (void 0);
+        }
+        const endpointTraceId = response.headers.get(endpointTraceIdHeaderName);
+        if (endpointTraceId == null || endpointTraceId.length === 0) {
+            return (void 0);
+        }
+        const endpointTraceIdScope = this.getEndpointTraceIdScope();
+        if (endpointTraceIdScope === 'system') {
+            request.$context.setScopedTraceId(this.getEndpointSystemCode(), endpointTraceIdHeaderName, endpointTraceId);
+        }
+        else {
+            request.$context.setScopedTraceId(this.getEndpointKey(), endpointTraceIdHeaderName, endpointTraceId);
+        }
+        return endpointTraceId;
+    }
+    async sendRequest(url, method, headers, body, data, request, $helpers) {
+        const response = await fetch(url, {
+            method, headers, body,
+            signal: this.needTimeout() ? (() => {
+                const controller = new AbortController();
+                setTimeout(() => controller.abort(), this.getEndpointTimeout());
+                return controller.signal;
+            })() : (void 0)
+        });
+        this.tryToRetrieveTraceIdFromResponse(request, response);
+        const status = response.status;
+        if (status >= 400) {
+            return await this._responseErrorHandleFunc({
+                $url: url, $factor: data, $request: request, $response: response,
+                $errorCode: `${status}`
+            }, $helpers, $helpers);
+        }
+        else {
+            return await this._responseGenerateFunc(response, data, request, $helpers, $helpers);
+        }
+    }
+    async doPerform(data, request) {
+        const $helpers = this.getHelpers();
+        let url = '';
+        try {
+            url = await this._urlGenerateFunc(this.getEndpointUrl(), data, request, $helpers, $helpers);
+            const method = this.getEndpointMethod();
+            const headers = await this.generateRequestHeaders(data, request, $helpers);
+            this.syncEndpointTraceId(headers, request);
+            const body = await this.generateRequestBody(method, data, request, $helpers);
+            return await this.sendRequest(url, method, headers, body, data, request, $helpers);
         }
         catch (e) {
             if (e instanceof DOMException || e.name === 'AbortError') {
@@ -2338,7 +2416,9 @@ class TypeOrmLoadManyBySQLUseCursorPipelineStep extends AbstractTypeOrmBySQLPipe
                             ...this.buildStepOptions(), name: this.getName(), steps: this.getStepBuilders()
                         });
                         const { content: _, $context, ...rest } = request;
-                        const contextForSub = { ...$context, $typeOrmCursorRound: cursorRound, $typeOrmCursorEnd: end };
+                        const contextForSub = $context.temporaryWith({
+                            $typeOrmCursorRound: cursorRound, $typeOrmCursorEnd: end
+                        });
                         const requestForSub = { ...rest, $context: contextForSub, content: contentForSub };
                         const result = await sets.perform(requestForSub);
                         const { content } = result;

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

@@ -1,4 +1,5 @@
-import { PipelineStepData, PipelineStepPayload } from '@rainbow-o23/n1';
+import { PipelineStepData, PipelineStepHelpers, PipelineStepPayload } from '@rainbow-o23/n1';
+import { Response } from 'node-fetch';
 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, BodyData = any> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
@@ -20,6 +21,7 @@ export interface FetchPipelineStepOptions<In = PipelineStepPayload, Out = Pipeli
 export declare class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out, BodyData = any> extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
     private readonly _endpointSystemCode;
     private readonly _endpointName;
+    private readonly _endpointKey;
     private readonly _endpointUrl;
     private readonly _endpointMethod;
     private readonly _endpointHeaders;
@@ -30,6 +32,8 @@ export declare class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineS
     private readonly _omittedTransparentHeaderNames;
     private readonly _headersGenerateSnippet;
     private readonly _headersGenerateFunc;
+    private readonly _endpointTraceIdHeaderName?;
+    private readonly _endpointTraceIdScope?;
     private readonly _bodyUsed;
     private readonly _bodyGenerateSnippet;
     private readonly _bodyGenerateFunc;
@@ -53,11 +57,18 @@ export declare class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineS
     protected generateTransparentHeaderNames(headerNames?: string, base?: Array<string>): Array<string>;
     getHeadersGenerateSnippet(): ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>>;
     protected getHeadersGenerateVariableNames(): Array<string>;
+    getEndpointTraceIdHeaderName(): string | undefined;
+    getEndpointTraceIdScope(): 'system' | 'endpoint' | undefined;
     protected isBodyUsed(): boolean | undefined;
     getBodyGenerateSnippet(): ScriptFuncOrBody<HttpGenerateBody<In, InFragment, BodyData>>;
     protected getBodyGenerateVariableNames(): Array<string>;
     getResponseGenerateSnippet(): ScriptFuncOrBody<HttpGenerateResponse<In, InFragment, OutFragment>>;
     protected getResponseGenerateVariableName(): Array<string>;
     protected getErrorHandlerVariableName(): Array<string>;
+    protected syncEndpointTraceId(headers: Record<string, string>, request: PipelineStepData<In>): string | undefined;
+    protected generateRequestHeaders(data: InFragment, request: PipelineStepData<In>, $helpers: PipelineStepHelpers): Promise<Record<string, string>>;
+    protected generateRequestBody(method: string, data: InFragment, request: PipelineStepData<In>, $helpers: PipelineStepHelpers): Promise<any>;
+    protected tryToRetrieveTraceIdFromResponse(request: PipelineStepData<In>, response: Response): string | undefined;
+    protected sendRequest(url: string, method: string, headers: Record<string, string>, body: any, data: InFragment, request: PipelineStepData<In>, $helpers: PipelineStepHelpers): Promise<OutFragment>;
     protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
 }

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

@@ -1,5 +1,5 @@
 import { AbstractPipelineStep, PipelineStepBuilder, PipelineStepData, PipelineStepHelpers, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
-import { PipelineStepSetsContext } from './step-sets';
+import { PipelineStepSetsExecutionContext } 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>>;
@@ -36,7 +36,7 @@ export declare abstract class AbstractFragmentaryPipelineStep<In = PipelineStepP
     protected setToOutput($result: OutFragment, $request: PipelineStepData<In>): Promise<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 createErrorHandleContext(request: PipelineStepData<In>): PipelineStepSetsExecutionContext;
     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>>;

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

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

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

@@ -1,6 +1,6 @@
-import { PipelineStep, PipelineStepBuilder, PipelineStepData, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
+import { PipelineExecutionContext, PipelineStep, PipelineStepBuilder, PipelineStepData, PipelineStepOptions, PipelineStepPayload } from '@rainbow-o23/n1';
 import { AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions } from './abstract-fragmentary-pipeline-step';
-export interface PipelineStepSetsContext {
+export interface PipelineStepSetsExecutionContext extends PipelineExecutionContext {
 }
 export interface PipelineStepSetsOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
     steps: Array<PipelineStepBuilder>;
@@ -11,9 +11,9 @@ export declare class PipelineStepSets<In = PipelineStepPayload, Out = PipelineSt
     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 inheritContext(request: PipelineStepData<In>): PipelineStepSetsExecutionContext;
+    protected attachMineToInternalContext(inheritedContext: PipelineStepSetsExecutionContext, _request: PipelineStepData<In>): Promise<PipelineStepSetsExecutionContext>;
+    protected createInternalContext<Ctx extends PipelineStepSetsExecutionContext>(request: PipelineStepData<In>): Promise<Ctx>;
+    protected performWithContext(request: PipelineStepData<In>, run: (request: PipelineStepData<In>, context: PipelineStepSetsExecutionContext) => Promise<OutFragment>): Promise<OutFragment>;
     protected doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
 }

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

@@ -1,6 +1,6 @@
 import { PipelineStepData, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
 import { QueryRunner } from 'typeorm';
-import { PipelineStepSets, PipelineStepSetsContext, PipelineStepSetsOptions } from '../step';
+import { PipelineStepSets, PipelineStepSetsExecutionContext, PipelineStepSetsOptions } from '../step';
 import { TypeOrmDataSource } from '../typeorm';
 import { TypeOrmDataSourceName, TypeOrmTransactionalContext, TypeOrmTransactionKey, TypeOrmTransactionName } from './types';
 export interface TypeOrmTransactionalPipelineStepSetsOptions extends PipelineStepSetsOptions {
@@ -16,7 +16,7 @@ export declare class TypeOrmTransactionalPipelineStepSets<In = PipelineStepPaylo
     getTransactionKey(): TypeOrmTransactionKey;
     protected findDataSourceOrThrow(): Promise<Undefinable<TypeOrmDataSource>>;
     protected createRunner(): Promise<[TypeOrmDataSource, QueryRunner]>;
-    protected attachMineToInternalContext(inheritedContext: PipelineStepSetsContext, _request: PipelineStepData<In>): Promise<TypeOrmTransactionalContext>;
+    protected attachMineToInternalContext(inheritedContext: PipelineStepSetsExecutionContext, _request: PipelineStepData<In>): Promise<TypeOrmTransactionalContext>;
     private getRunner;
-    protected performWithContext(request: PipelineStepData<In>, run: (request: PipelineStepData<In>, context: PipelineStepSetsContext) => Promise<OutFragment>): Promise<OutFragment>;
+    protected performWithContext(request: PipelineStepData<In>, run: (request: PipelineStepData<In>, context: PipelineStepSetsExecutionContext) => Promise<OutFragment>): Promise<OutFragment>;
 }

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

@@ -1,5 +1,5 @@
 import { DeepPartial, ObjectLiteral, QueryRunner } from 'typeorm';
-import { PipelineStepSetsContext } from '../step';
+import { PipelineStepSetsExecutionContext } from '../step';
 import { TypeOrmDataSource } from '../typeorm';
 export type TypeOrmIdType = string | number | bigint;
 export type TypeOrmDataSourceName = string;
@@ -16,6 +16,6 @@ export type TypeOrmCountsOfAffected = Array<TypeOrmCountOfAffected>;
 export type TypeOrmWrittenResult = TypeOrmIdOfInserted | TypeOrmCountOfAffected;
 export type TypeOrmBulkWrittenResult = TypeOrmIdsOfInserted | TypeOrmCountsOfAffected;
 export declare const DEFAULT_TRANSACTION_NAME: TypeOrmTransactionName;
-export interface TypeOrmTransactionalContext extends PipelineStepSetsContext {
+export interface TypeOrmTransactionalContext extends PipelineStepSetsExecutionContext {
     $trans: Record<TypeOrmTransactionKey, [TypeOrmDataSource, QueryRunner]>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainbow-o23/n3",
-	"version": "1.0.58",
+	"version": "1.0.59",
 	"description": "o23 pipelines",
 	"main": "index.cjs",
 	"module": "index.js",
@@ -21,7 +21,7 @@
 		"url": "https://github.com/InsureMO/rainbow-o23/issues"
 	},
 	"dependencies": {
-		"@rainbow-o23/n1": "1.0.58",
+		"@rainbow-o23/n1": "1.0.59",
 		"node-fetch": "2.6.7",
 		"typeorm": "^0.3.20",
 		"typescript": "5.5.4"