@rainbow-o23/n3 1.0.58 → 1.0.60

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

@@ -38,6 +38,7 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 	extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
 	private readonly _endpointSystemCode: string;
 	private readonly _endpointName: string;
+	private readonly _endpointKey: string;
 	private readonly _endpointUrl: string;
 	private readonly _endpointMethod: string;
 	private readonly _endpointHeaders: Record<string, string>;
@@ -48,6 +49,8 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 	private readonly _omittedTransparentHeaderNames: Array<string>;
 	private readonly _headersGenerateSnippet: ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>>;
 	private readonly _headersGenerateFunc: HttpGenerateHeaders<In, InFragment>;
+	private readonly _endpointTraceIdHeaderName?: string;
+	private readonly _endpointTraceIdScope?: 'system' | 'endpoint';
 	private readonly _bodyUsed: boolean;
 	private readonly _bodyGenerateSnippet: ScriptFuncOrBody<HttpGenerateBody<In, InFragment, BodyData>>;
 	private readonly _bodyGenerateFunc: HttpGenerateBody<In, InFragment, BodyData>;
@@ -60,16 +63,16 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 		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`)));
+			config.getString(`endpoints.${this._endpointKey}.headers`),
+			this.generateEndpointHeaders(config.getString(`endpoints.${this._endpointSystemCode}.global.headers`)));
 		// in second
 		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);
 		// to millisecond
 		this._endpointTimeout = this._endpointTimeout > 0 ? this._endpointTimeout * 1000 : -1;
 		this._urlGenerateSnippet = options.urlGenerate;
@@ -84,12 +87,12 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 		});
 		this._transparentHeaderNames = options.transparentHeaderNames
 			?? this.generateTransparentHeaderNames(
-				config.getString(`endpoints.${endpointKey}.headers.transparent`),
-				this.generateTransparentHeaderNames(config.getString(`endpoints.${this.getEndpointSystemCode()}.global.headers.transparent`)));
+				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`)));
+				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(), {
 			// eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -100,6 +103,20 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 				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(), {
@@ -182,7 +199,7 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 	}
 
 	public getEndpointKey(): string {
-		return `${this.getEndpointSystemCode()}.${this.getEndpointName()}`;
+		return this._endpointKey;
 	}
 
 	public getEndpointUrl(): string {
@@ -257,6 +274,14 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 		return ['$factor', '$request', ...this.getHelpersVariableNames()];
 	}
 
+	public getEndpointTraceIdHeaderName(): string | undefined {
+		return this._endpointTraceIdHeaderName;
+	}
+
+	public getEndpointTraceIdScope(): 'system' | 'endpoint' | undefined {
+		return this._endpointTraceIdScope;
+	}
+
 	protected isBodyUsed(): boolean | undefined {
 		return this._bodyUsed;
 	}
@@ -284,81 +309,159 @@ export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPaylo
 		return ['$options', ...this.getHelpersVariableNames()];
 	}
 
-	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
-		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) {
-					// no value of given header name, ignored
-				} 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) ?? {};
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			let body: any;
-			const bodyUsed = this.isBodyUsed();
-			if (bodyUsed === true || (bodyUsed == null && method !== 'get')) {
-				body = await this._bodyGenerateFunc(data, request, $helpers, $helpers);
+	protected syncEndpointTraceId(headers: Record<string, string>, request: PipelineStepData<In>): string | undefined {
+		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) {
+			// trace id found in headers, put into context
+			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 {
+			// trace if not in headers, find in context, and put into header if found
+			if (endpointTraceIdScope === 'system') {
+				endpointTraceId = request.$context.findScopedTraceId(this.getEndpointSystemCode())?.[1];
+			} else {
+				endpointTraceId = request.$context.findScopedTraceId(this.getEndpointKey())?.[1];
 			}
-			const headers = {...staticHeaders, ...transparentHeaders, ...generatedHeaders};
-			// remove some headers, leave them to fetch to calculate automatically.
-			Object.keys(headers).filter(name => {
-				return ['content-encoding', 'content-length'].includes(name.toLowerCase());
-			}).forEach(name => {
-				delete headers[name];
-			});
+			if (endpointTraceId != null) {
+				headers[endpointTraceIdHeaderName] = endpointTraceId;
+			}
+		}
 
-			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,
-					// eslint-disable-next-line @typescript-eslint/ban-ts-comment
-					// @ts-ignore
-					$errorCode: `${status}`
-				}, $helpers, $helpers);
+		return endpointTraceId;
+	}
+
+	protected async generateRequestHeaders(data: InFragment, request: PipelineStepData<In>, $helpers: PipelineStepHelpers): Promise<Record<string, string>> {
+		const staticHeaders = this.getEndpointHeaders() ?? {};
+		const transparentHeaders = (this.getTransparentHeaderNames() ?? []).reduce((headers, name) => {
+			const value = Utils.getValue(data, name);
+			if (value == null) {
+				// no value of given header name, ignored
+			} 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};
+		// remove some headers, leave them to fetch to calculate automatically.
+		// and get trace id when existing
+		Object.keys(headers).filter(name => {
+			return ['content-encoding', 'content-length'].includes(name.toLowerCase());
+		}).forEach(name => {
+			delete headers[name];
+		});
+
+		return headers;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	protected async generateRequestBody(method: string, data: InFragment, request: PipelineStepData<In>, $helpers: PipelineStepHelpers): Promise<any> {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
+		let body: any;
+		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;
+	}
+
+	protected tryToRetrieveTraceIdFromResponse(request: PipelineStepData<In>, response: Response): string | undefined {
+		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;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	protected async sendRequest(url: string, method: string, headers: Record<string, string>, body: any,
+	                            data: InFragment, request: PipelineStepData<In>,
+	                            $helpers: PipelineStepHelpers): Promise<OutFragment> {
+		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)
+		});
+		// retrieve trace id from response anyway
+		this.tryToRetrieveTraceIdFromResponse(request, response);
+		const status = response.status;
+		if (status >= 400) {
+			return await this._responseErrorHandleFunc({
+				$url: url, $factor: data, $request: request, $response: response,
+				// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+				// @ts-ignore
+				$errorCode: `${status}`
+			}, $helpers, $helpers);
+		} else {
+			return await this._responseGenerateFunc(response, data, request, $helpers, $helpers);
+		}
+	}
+
+	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
+		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') {
 				return await this._responseErrorHandleFunc({

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

@@ -11,7 +11,7 @@ import {
 	UncatchableError
 } from '@rainbow-o23/n1';
 import {ERR_PIPELINE_STEP_SNIPPET_NOT_EMPTY} from '../error-codes';
-import {PipelineStepSetsContext} from './step-sets';
+import {PipelineStepSetsExecutionContext} from './step-sets';
 import {
 	HandleAnyError,
 	HandleCatchableError,
@@ -264,7 +264,10 @@ export abstract class AbstractFragmentaryPipelineStep<In = PipelineStepPayload,
 	 */
 	protected async setToOutput($result: OutFragment, $request: PipelineStepData<In>): Promise<PipelineStepData<Out>> {
 		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
+		};
 	}
 
 	/**
@@ -278,14 +281,8 @@ export abstract class AbstractFragmentaryPipelineStep<In = PipelineStepPayload,
 		return {config: this.getConfig(), logger: this.getLogger()};
 	}
 
-	protected createErrorHandleContext(request: PipelineStepData<In>): PipelineStepSetsContext {
-		const context = request.$context;
-		if (context == null) {
-			return {};
-		} else {
-			const {authorization, traceId, ...rest} = context;
-			return {authorization, traceId, ...Utils.clone(rest)};
-		}
+	protected createErrorHandleContext(request: PipelineStepData<In>): PipelineStepSetsExecutionContext {
+		return request.$context;
 	}
 
 	/**
@@ -293,7 +290,7 @@ export abstract class AbstractFragmentaryPipelineStep<In = PipelineStepPayload,
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-explicit-any
 	protected async handleErrorSteps(fragment: InFragment, errorCode: string, error: any, request: PipelineStepData<In>, builders: Array<PipelineStepBuilder>): Promise<OutFragment> {
-		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)));
@@ -303,7 +300,7 @@ export abstract class AbstractFragmentaryPipelineStep<In = PipelineStepPayload,
 				.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);
 					// if no response returned, keep using request for next

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

@@ -1,11 +1,20 @@
 import {PipelineStepData, PipelineStepPayload} from '@rainbow-o23/n1';
-import {PipelineStepSets} from './step-sets';
+import {PipelineStepSets, PipelineStepSetsExecutionContext} from './step-sets';
 
 /**
  * pipeline steps to execute sets of steps asynchronous.
+ *
+ * Execution context will be copied and will not be retrieved back to the main thread.
+ * The transaction context will not be passed to asynchronous sub - steps.
  */
 export class AsyncPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In>
 	extends PipelineStepSets<In, Out, InFragment, void> {
+
+	protected inheritContext(request: PipelineStepData<In>): PipelineStepSetsExecutionContext {
+		// $trans does not inherit by sub step
+		return request.$context.clone('$trans');
+	}
+
 	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<void> {
 		// noinspection ES6MissingAwait
 		super.doPerform(data, request);

package/src/lib/step/parallel-step-sets.ts

@@ -1,5 +1,5 @@
 import {PipelineStepData, PipelineStepHelpers, PipelineStepPayload} from '@rainbow-o23/n1';
-import {PipelineStepSets, PipelineStepSetsContext, PipelineStepSetsOptions} from './step-sets';
+import {PipelineStepSets, PipelineStepSetsExecutionContext, PipelineStepSetsOptions} from './step-sets';
 import {ScriptFuncOrBody} from './types';
 import {Utils} from './utils';
 
@@ -61,15 +61,15 @@ export class ParallelPipelineStepSets<In = PipelineStepPayload, Out = PipelineSt
 
 	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
 		return await this.performWithContext(
-			request, async (request: PipelineStepData<In>, context: PipelineStepSetsContext): Promise<OutFragment> => {
-				const {$context: {authorization, traceId} = {}} = request;
+			request, async (request: PipelineStepData<In>, context: PipelineStepSetsExecutionContext): Promise<OutFragment> => {
+				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);

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

@@ -56,9 +56,8 @@ export class RefPipelinePipelineStep<In = PipelineStepPayload, Out = PipelineSte
 	}
 
 	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
-		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;
 	}
 }

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

@@ -1,4 +1,5 @@
 import {
+	PipelineExecutionContext,
 	PipelineStep,
 	PipelineStepBuilder,
 	PipelineStepData,
@@ -6,10 +7,9 @@ import {
 	PipelineStepPayload
 } from '@rainbow-o23/n1';
 import {AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions} from './abstract-fragmentary-pipeline-step';
-import {Utils} from './utils';
 
 // eslint-disable-next-line @typescript-eslint/no-empty-object-type
-export interface PipelineStepSetsContext {
+export interface PipelineStepSetsExecutionContext extends PipelineExecutionContext {
 }
 
 export interface PipelineStepSetsOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
@@ -46,25 +46,19 @@ export class PipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayloa
 		return await Promise.all(this.getStepBuilders().map(async builder => await builder.create(options)));
 	}
 
-	protected inheritContext(request: PipelineStepData<In>): PipelineStepSetsContext {
-		const context = request.$context;
-		if (context == null) {
-			return {};
-		} else {
-			const {authorization, traceId, ...rest} = context;
-			return {authorization, traceId, ...Utils.clone(rest)};
-		}
+	protected inheritContext(request: PipelineStepData<In>): PipelineStepSetsExecutionContext {
+		return request.$context;
 	}
 
 	/**
 	 * default do nothing, return given inherited context directly
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	protected async attachMineToInternalContext(inheritedContext: PipelineStepSetsContext, _request: PipelineStepData<In>): Promise<PipelineStepSetsContext> {
+	protected async attachMineToInternalContext(inheritedContext: PipelineStepSetsExecutionContext, _request: PipelineStepData<In>): Promise<PipelineStepSetsExecutionContext> {
 		return inheritedContext;
 	}
 
-	protected async createInternalContext<Ctx extends PipelineStepSetsContext>(request: PipelineStepData<In>): Promise<Ctx> {
+	protected async createInternalContext<Ctx extends PipelineStepSetsExecutionContext>(request: PipelineStepData<In>): Promise<Ctx> {
 		return await this.attachMineToInternalContext(this.inheritContext(request), request) as Ctx;
 	}
 
@@ -73,15 +67,15 @@ export class PipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayloa
 	 */
 	protected async performWithContext(
 		request: PipelineStepData<In>,
-		run: (request: PipelineStepData<In>, context: PipelineStepSetsContext) => Promise<OutFragment>): Promise<OutFragment> {
+		run: (request: PipelineStepData<In>, context: PipelineStepSetsExecutionContext) => Promise<OutFragment>): Promise<OutFragment> {
 		const context = await this.createInternalContext(request);
 		return await run(request, context);
 	}
 
 	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
 		return await this.performWithContext(
-			request, async (request: PipelineStepData<In>, context: PipelineStepSetsContext): Promise<OutFragment> => {
-				const {$context: {authorization, traceId} = {}} = request;
+			request, async (request: PipelineStepData<In>, context: PipelineStepSetsExecutionContext): Promise<OutFragment> => {
+				const traceId = context.traceId;
 				const steps = await this.createSteps();
 				const response = await steps.reduce(async (promise, step) => {
 					const request = await promise;
@@ -89,7 +83,7 @@ export class PipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayloa
 						.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);
 							// if no response returned, keep using request for next

package/src/lib/typeorm-step/typeorm-load-many-by-sql-use-cursor-step.ts

@@ -105,7 +105,9 @@ export class TypeOrmLoadManyBySQLUseCursorPipelineStep<In = PipelineStepPayload,
 						// eslint-disable-next-line @typescript-eslint/no-unused-vars
 						const {content: _, $context, ...rest} = request;
 						// pass a cursor end indicator to sub steps
-						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/src/lib/typeorm-step/typeorm-transactional-step-sets.ts

@@ -1,7 +1,7 @@
 import {PipelineStepData, PipelineStepPayload, UncatchableError, Undefinable} from '@rainbow-o23/n1';
 import {QueryRunner} from 'typeorm';
 import {ERR_TYPEORM_DATASOURCE_NOT_FOUND} from '../error-codes';
-import {PipelineStepSets, PipelineStepSetsContext, PipelineStepSetsOptions} from '../step';
+import {PipelineStepSets, PipelineStepSetsExecutionContext, PipelineStepSetsOptions} from '../step';
 import {TypeOrmDataSource, TypeOrmDataSourceManager} from '../typeorm';
 import {
 	DEFAULT_TRANSACTION_NAME,
@@ -69,7 +69,7 @@ export class TypeOrmTransactionalPipelineStepSets<In = PipelineStepPayload, Out
 	 * inherit transaction (use runner in context) if exists, otherwise create new runner
 	 */
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	protected async attachMineToInternalContext(inheritedContext: PipelineStepSetsContext, _request: PipelineStepData<In>): Promise<TypeOrmTransactionalContext> {
+	protected async attachMineToInternalContext(inheritedContext: PipelineStepSetsExecutionContext, _request: PipelineStepData<In>): Promise<TypeOrmTransactionalContext> {
 		const context = inheritedContext as TypeOrmTransactionalContext;
 		if (context.$trans != null) {
 			if (context.$trans[this.getTransactionKey()] != null) {
@@ -96,7 +96,7 @@ export class TypeOrmTransactionalPipelineStepSets<In = PipelineStepPayload, Out
 	 */
 	protected async performWithContext(
 		request: PipelineStepData<In>,
-		run: (request: PipelineStepData<In>, context: PipelineStepSetsContext) => Promise<OutFragment>): Promise<OutFragment> {
+		run: (request: PipelineStepData<In>, context: PipelineStepSetsExecutionContext) => Promise<OutFragment>): Promise<OutFragment> {
 		let runner: QueryRunner = null;
 		try {
 			const context: TypeOrmTransactionalContext = await this.createInternalContext(request);

package/src/lib/typeorm-step/types.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;
@@ -19,6 +19,6 @@ export type TypeOrmBulkWrittenResult = TypeOrmIdsOfInserted | TypeOrmCountsOfAff
 
 export const DEFAULT_TRANSACTION_NAME: TypeOrmTransactionName = '$default-transaction';
 
-export interface TypeOrmTransactionalContext extends PipelineStepSetsContext {
+export interface TypeOrmTransactionalContext extends PipelineStepSetsExecutionContext {
 	$trans: Record<TypeOrmTransactionKey, [TypeOrmDataSource, QueryRunner]>;
 }

package/test/step/parallel-step.test.ts

@@ -1,4 +1,11 @@
-import {createConfig, createLogger, PipelineStep, PipelineStepBuilder, PipelineStepOptions} from '@rainbow-o23/n1';
+import {
+	createConfig,
+	createLogger,
+	PipelineExecutionContext,
+	PipelineStep,
+	PipelineStepBuilder,
+	PipelineStepOptions
+} from '@rainbow-o23/n1';
 import {ParallelPipelineStepSets, SnippetPipelineStep} from '../../src';
 
 const logger = createLogger();
@@ -19,7 +26,7 @@ test('Parallel Pipeline Step Test #1, + 100', async () => {
 			}
 		]
 	});
-	const request = {content: {base: 1}};
+	const request = {content: {base: 1}, $context: new PipelineExecutionContext()};
 	const response = await step.perform(request);
 	expect(response.content).toEqual([100, 200]);
 });

package/test/step/snippet-step.test.ts

@@ -1,4 +1,4 @@
-import {createConfig, createLogger} from '@rainbow-o23/n1';
+import {createConfig, createLogger, PipelineExecutionContext} from '@rainbow-o23/n1';
 import {SnippetPipelineStep} from '../../src';
 
 const logger = createLogger();
@@ -7,7 +7,7 @@ const config = createConfig(logger);
 test('Snippet Pipeline Step Test #1, + 100', async () => {
 	const snippet = 'return $factor.base + 100;';
 	const step = new SnippetPipelineStep({config, logger, snippet});
-	const request = {content: {base: 1}};
+	const request = {content: {base: 1}, $context: new PipelineExecutionContext()};
 	const response = await step.perform(request);
 	expect(response.content).toEqual(101);
 });
@@ -15,7 +15,7 @@ test('Snippet Pipeline Step Test #1, + 100', async () => {
 test('Snippet Pipeline Step Test #2, async + 100', async () => {
 	const snippet = 'return await new Promise(resolve => resolve($factor.base + 100));';
 	const step = new SnippetPipelineStep({config, logger, snippet});
-	const request = {content: {base: 1}};
+	const request = {content: {base: 1}, $context: new PipelineExecutionContext()};
 	const response = await step.perform(request);
 	expect(response.content).toEqual(101);
 });

package/test/step/snowflake-step.test.ts

@@ -1,4 +1,4 @@
-import {createConfig, createLogger} from '@rainbow-o23/n1';
+import {createConfig, createLogger, PipelineExecutionContext} from '@rainbow-o23/n1';
 import {SnowflakePipelineStep} from '../../src';
 
 const logger = createLogger();
@@ -6,7 +6,7 @@ const config = createConfig(logger);
 
 test('Snowflake Pipeline Step Test #1, replace content', async () => {
 	const step = new SnowflakePipelineStep({config, logger, mergeRequest: '$id'});
-	const request = {content: (void 0)};
+	const request = {content: (void 0), $context: new PipelineExecutionContext()};
 	const response = await step.perform(request);
 	expect(response.content).not.toBeNull();
 	expect(response.content.$id).not.toBeNull();
@@ -14,7 +14,7 @@ test('Snowflake Pipeline Step Test #1, replace content', async () => {
 
 test('Snowflake Pipeline Step Test #2, merge content', async () => {
 	const step = new SnowflakePipelineStep({config, logger, mergeRequest: '$id'});
-	const request = {content: {base: 1}};
+	const request = {content: {base: 1}, $context: new PipelineExecutionContext()};
 	const response = await step.perform(request);
 	expect(response.content).not.toBeNull();
 	expect(response.content.base).toEqual(1);