@rainbow-o23/n1 1.0.58 → 1.0.60

package/index.cjs

@@ -399,7 +399,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
 function __decorate(decorators, target, key, desc) {
@@ -604,6 +604,115 @@ class AbstractPipelineExecution {
     }
 }
 
+class PipelineExecutionContext {
+    _authorization;
+    _traceId;
+    _scopedTraceIds;
+    _others = {};
+    constructor(authorization, traceId, scopedTraceIds) {
+        this._authorization = authorization;
+        this._traceId = traceId || nanoid.nanoid(16);
+        this._scopedTraceIds = scopedTraceIds || {};
+    }
+    get authorization() {
+        return this._authorization;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+    get scopedTraceIds() {
+        return Object.values(this._scopedTraceIds).reduce((acc, [name, value]) => {
+            if (value != null && value.trim().length !== 0) {
+                acc[name] = value;
+            }
+            return acc;
+        }, {});
+    }
+    findScopedTraceId(scopeKey) {
+        return this._scopedTraceIds[scopeKey];
+    }
+    setScopedTraceId(scopeKey, name, value) {
+        this._scopedTraceIds[scopeKey] = [name, value];
+    }
+    findOther(key) {
+        return this._others[key];
+    }
+    setOther(key, value) {
+        this._others[key] = value;
+    }
+    shallowClone(...omittedKeys) {
+        const cloned = new PipelineExecutionContext(this.authorization, this.traceId, this._scopedTraceIds);
+        Object.keys(this._others).forEach(key => {
+            if (omittedKeys.includes(key)) {
+                return;
+            }
+            cloned.setOther(key, this.findOther(key));
+        });
+        return cloned;
+    }
+    clone(...omittedKeys) {
+        const cloned = new PipelineExecutionContext(this.authorization, this.traceId);
+        Object.keys(this._others).forEach(key => {
+            if (omittedKeys.includes(key)) {
+                return;
+            }
+            cloned.setOther(key, this.findOther(key));
+        });
+        return cloned;
+    }
+    temporaryWith(temporaryContext) {
+        return new TemporaryExecutionContext(this, temporaryContext);
+    }
+}
+class TemporaryExecutionContext extends PipelineExecutionContext {
+    _parent;
+    _temporaryContext;
+    _temporaryKeys;
+    constructor(parent, temporaryContext) {
+        super();
+        this._parent = parent;
+        this._temporaryContext = temporaryContext ?? {};
+        this._temporaryKeys = Object.keys(this._temporaryContext);
+    }
+    get parent() {
+        return this._parent;
+    }
+    get authorization() {
+        return this.parent.authorization;
+    }
+    get traceId() {
+        return this.parent.traceId;
+    }
+    get scopedTraceIds() {
+        return this.parent.scopedTraceIds;
+    }
+    findScopedTraceId(scopeKey) {
+        return this.parent.findScopedTraceId(scopeKey);
+    }
+    setScopedTraceId(scopeKey, name, value) {
+        this.parent.setScopedTraceId(scopeKey, name, value);
+    }
+    get temporaryContext() {
+        return this._temporaryContext;
+    }
+    findOther(key) {
+        if (this._temporaryKeys.includes(key)) {
+            return this.temporaryContext[key];
+        }
+        else {
+            return super.findOther(key);
+        }
+    }
+    setOther(key, value) {
+        if (this._temporaryKeys.includes(key)) {
+            this.temporaryContext[key] = value;
+        }
+        else {
+            super.setOther(key, value);
+        }
+    }
+}
+
 class PipelineStepDateHelper {
     _dateTimeFormat;
     constructor(config) {
@@ -704,24 +813,28 @@ class AbstractPipeline extends AbstractPipelineExecution {
         const options = this.buildStepOptions();
         return await Promise.all(this.getStepBuilders().map(async (builder) => await builder.create(options)));
     }
+    defendPipelineRequest(request) {
+        if (request.$context == null) {
+            request.$context = new PipelineExecutionContext();
+        }
+        return request;
+    }
     convertRequestToPipelineData(request) {
-        return { content: request.payload };
+        return {
+            content: request.payload,
+            $context: request.$context
+        };
     }
     convertPipelineDataToResponse(result) {
-        return { payload: result.content };
-    }
-    createTraceId(request) {
-        const { traceId } = request;
-        if (traceId == null || traceId.trim().length === 0) {
-            return nanoid.nanoid(16);
-        }
-        else {
-            return traceId;
-        }
+        return {
+            payload: result.content,
+            $context: result.$context
+        };
     }
     async perform(request) {
-        const traceId = this.createTraceId(request);
-        const authorization = request.authorization;
+        request = this.defendPipelineRequest(request);
+        const $context = request.$context;
+        const traceId = $context.traceId;
         const response = await this.measurePerformance(traceId, 'PIPELINE')
             .execute(async () => {
             this.traceRequest(traceId, request);
@@ -731,9 +844,7 @@ class AbstractPipeline extends AbstractPipelineExecution {
                 return await this.measurePerformance(traceId, 'STEP', step.constructor.name)
                     .execute(async () => {
                     this.traceStepIn(traceId, step, request);
-                    const response = await step.perform({
-                        ...request, $context: { ...request.$context, authorization, traceId }
-                    });
+                    const response = await step.perform({ ...request, $context });
                     this.traceStepOut(traceId, step, response);
                     return this.returnOrContinueOrClear(request, response);
                 });
@@ -818,8 +929,10 @@ exports.LoggerUtils = LoggerUtils;
 exports.PIPELINE_STEP_FILE_SYMBOL = PIPELINE_STEP_FILE_SYMBOL;
 exports.PIPELINE_STEP_RETURN_NULL = PIPELINE_STEP_RETURN_NULL;
 exports.PerformanceExecution = PerformanceExecution;
+exports.PipelineExecutionContext = PipelineExecutionContext;
 exports.PipelineRepository = PipelineRepository;
 exports.PipelineStepDateHelper = PipelineStepDateHelper;
+exports.TemporaryExecutionContext = TemporaryExecutionContext;
 exports.UncatchableError = UncatchableError;
 exports.createConfig = createConfig;
 exports.createLogger = createLogger;

package/index.js

@@ -397,7 +397,7 @@ LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
 PERFORMANCE OF THIS SOFTWARE.
 ***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
 
 
 function __decorate(decorators, target, key, desc) {
@@ -602,6 +602,115 @@ class AbstractPipelineExecution {
     }
 }
 
+class PipelineExecutionContext {
+    _authorization;
+    _traceId;
+    _scopedTraceIds;
+    _others = {};
+    constructor(authorization, traceId, scopedTraceIds) {
+        this._authorization = authorization;
+        this._traceId = traceId || nanoid(16);
+        this._scopedTraceIds = scopedTraceIds || {};
+    }
+    get authorization() {
+        return this._authorization;
+    }
+    get traceId() {
+        return this._traceId;
+    }
+    get scopedTraceIds() {
+        return Object.values(this._scopedTraceIds).reduce((acc, [name, value]) => {
+            if (value != null && value.trim().length !== 0) {
+                acc[name] = value;
+            }
+            return acc;
+        }, {});
+    }
+    findScopedTraceId(scopeKey) {
+        return this._scopedTraceIds[scopeKey];
+    }
+    setScopedTraceId(scopeKey, name, value) {
+        this._scopedTraceIds[scopeKey] = [name, value];
+    }
+    findOther(key) {
+        return this._others[key];
+    }
+    setOther(key, value) {
+        this._others[key] = value;
+    }
+    shallowClone(...omittedKeys) {
+        const cloned = new PipelineExecutionContext(this.authorization, this.traceId, this._scopedTraceIds);
+        Object.keys(this._others).forEach(key => {
+            if (omittedKeys.includes(key)) {
+                return;
+            }
+            cloned.setOther(key, this.findOther(key));
+        });
+        return cloned;
+    }
+    clone(...omittedKeys) {
+        const cloned = new PipelineExecutionContext(this.authorization, this.traceId);
+        Object.keys(this._others).forEach(key => {
+            if (omittedKeys.includes(key)) {
+                return;
+            }
+            cloned.setOther(key, this.findOther(key));
+        });
+        return cloned;
+    }
+    temporaryWith(temporaryContext) {
+        return new TemporaryExecutionContext(this, temporaryContext);
+    }
+}
+class TemporaryExecutionContext extends PipelineExecutionContext {
+    _parent;
+    _temporaryContext;
+    _temporaryKeys;
+    constructor(parent, temporaryContext) {
+        super();
+        this._parent = parent;
+        this._temporaryContext = temporaryContext ?? {};
+        this._temporaryKeys = Object.keys(this._temporaryContext);
+    }
+    get parent() {
+        return this._parent;
+    }
+    get authorization() {
+        return this.parent.authorization;
+    }
+    get traceId() {
+        return this.parent.traceId;
+    }
+    get scopedTraceIds() {
+        return this.parent.scopedTraceIds;
+    }
+    findScopedTraceId(scopeKey) {
+        return this.parent.findScopedTraceId(scopeKey);
+    }
+    setScopedTraceId(scopeKey, name, value) {
+        this.parent.setScopedTraceId(scopeKey, name, value);
+    }
+    get temporaryContext() {
+        return this._temporaryContext;
+    }
+    findOther(key) {
+        if (this._temporaryKeys.includes(key)) {
+            return this.temporaryContext[key];
+        }
+        else {
+            return super.findOther(key);
+        }
+    }
+    setOther(key, value) {
+        if (this._temporaryKeys.includes(key)) {
+            this.temporaryContext[key] = value;
+        }
+        else {
+            super.setOther(key, value);
+        }
+    }
+}
+
 class PipelineStepDateHelper {
     _dateTimeFormat;
     constructor(config) {
@@ -702,24 +811,28 @@ class AbstractPipeline extends AbstractPipelineExecution {
         const options = this.buildStepOptions();
         return await Promise.all(this.getStepBuilders().map(async (builder) => await builder.create(options)));
     }
+    defendPipelineRequest(request) {
+        if (request.$context == null) {
+            request.$context = new PipelineExecutionContext();
+        }
+        return request;
+    }
     convertRequestToPipelineData(request) {
-        return { content: request.payload };
+        return {
+            content: request.payload,
+            $context: request.$context
+        };
     }
     convertPipelineDataToResponse(result) {
-        return { payload: result.content };
-    }
-    createTraceId(request) {
-        const { traceId } = request;
-        if (traceId == null || traceId.trim().length === 0) {
-            return nanoid(16);
-        }
-        else {
-            return traceId;
-        }
+        return {
+            payload: result.content,
+            $context: result.$context
+        };
     }
     async perform(request) {
-        const traceId = this.createTraceId(request);
-        const authorization = request.authorization;
+        request = this.defendPipelineRequest(request);
+        const $context = request.$context;
+        const traceId = $context.traceId;
         const response = await this.measurePerformance(traceId, 'PIPELINE')
             .execute(async () => {
             this.traceRequest(traceId, request);
@@ -729,9 +842,7 @@ class AbstractPipeline extends AbstractPipelineExecution {
                 return await this.measurePerformance(traceId, 'STEP', step.constructor.name)
                     .execute(async () => {
                     this.traceStepIn(traceId, step, request);
-                    const response = await step.perform({
-                        ...request, $context: { ...request.$context, authorization, traceId }
-                    });
+                    const response = await step.perform({ ...request, $context });
                     this.traceStepOut(traceId, step, response);
                     return this.returnOrContinueOrClear(request, response);
                 });
@@ -795,4 +906,4 @@ class PipelineRepository {
     }
 }
 
-export { AbstractPipeline, AbstractPipelineExecution, AbstractPipelineStep, AbstractStaticPipeline, CatchableError, Config, ConsoleLogger, DefaultPipelineBuilder, DefaultPipelineStepBuilder, ERR_DUPLICATED_ERROR_CODE, ERR_PIPELINE_NOT_FOUND, ERR_TRIM_NON_STRING, ERR_UNKNOWN, EnhancedLogger, ErrorCodes, ExposedUncatchableError, LoggerPerformanceSaver, LoggerUtils, PIPELINE_STEP_FILE_SYMBOL, PIPELINE_STEP_RETURN_NULL, PerformanceExecution, PipelineRepository, PipelineStepDateHelper, StepHelpersUtils, UncatchableError, createConfig, createLogger, createStepHelpers, registerToStepHelpers, saveLoggerPerformance };
+export { AbstractPipeline, AbstractPipelineExecution, AbstractPipelineStep, AbstractStaticPipeline, CatchableError, Config, ConsoleLogger, DefaultPipelineBuilder, DefaultPipelineStepBuilder, ERR_DUPLICATED_ERROR_CODE, ERR_PIPELINE_NOT_FOUND, ERR_TRIM_NON_STRING, ERR_UNKNOWN, EnhancedLogger, ErrorCodes, ExposedUncatchableError, LoggerPerformanceSaver, LoggerUtils, PIPELINE_STEP_FILE_SYMBOL, PIPELINE_STEP_RETURN_NULL, PerformanceExecution, PipelineExecutionContext, PipelineRepository, PipelineStepDateHelper, StepHelpersUtils, TemporaryExecutionContext, UncatchableError, createConfig, createLogger, createStepHelpers, registerToStepHelpers, saveLoggerPerformance };

package/lib/pipeline/index.d.ts

@@ -1,4 +1,5 @@
 export * from './pipeline-execution';
+export * from './pipeline-execution-context';
 export * from './pipeline-step';
 export * from './pipeline';
 export * from './step-helpers-utils';

package/lib/pipeline/pipeline-execution-context.d.ts

@@ -0,0 +1,42 @@
+export interface PipelineRequestAuthorizationRole {
+    code?: string;
+    [key: string]: any | undefined;
+}
+export interface PipelineRequestAuthorization<A = any> {
+    readonly authorized: boolean;
+    readonly authentication?: A;
+    readonly roles: Array<PipelineRequestAuthorizationRole>;
+    readonly headers?: Record<string, string>;
+}
+export declare class PipelineExecutionContext {
+    private readonly _authorization?;
+    private readonly _traceId;
+    private readonly _scopedTraceIds;
+    private readonly _others;
+    constructor(authorization?: PipelineRequestAuthorization, traceId?: string, scopedTraceIds?: Record<string, [string, string]>);
+    get authorization(): PipelineRequestAuthorization;
+    get traceId(): string;
+    get scopedTraceIds(): Record<string, string>;
+    findScopedTraceId(scopeKey: string): [string, string] | undefined;
+    setScopedTraceId(scopeKey: string, name: string, value: string): void;
+    findOther(key: string): any | undefined;
+    setOther(key: string, value: any): void;
+    shallowClone(...omittedKeys: Array<string>): PipelineExecutionContext;
+    clone(...omittedKeys: Array<string>): PipelineExecutionContext;
+    temporaryWith(temporaryContext: Record<string, any>): PipelineExecutionContext;
+}
+export declare class TemporaryExecutionContext extends PipelineExecutionContext {
+    private readonly _parent;
+    private readonly _temporaryContext;
+    private readonly _temporaryKeys;
+    constructor(parent: PipelineExecutionContext, temporaryContext: Record<string, any>);
+    protected get parent(): PipelineExecutionContext;
+    get authorization(): PipelineRequestAuthorization;
+    get traceId(): string;
+    get scopedTraceIds(): Record<string, string>;
+    findScopedTraceId(scopeKey: string): [string, string] | undefined;
+    setScopedTraceId(scopeKey: string, name: string, value: string): void;
+    get temporaryContext(): Record<string, any>;
+    findOther(key: string): any;
+    setOther(key: string, value: any): void;
+}

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

@@ -1,15 +1,11 @@
 import { Config, Logger } from '../utils';
-import { PipelineRequestAuthorization } from './pipeline';
 import { AbstractPipelineExecution, PipelineExecutionOptions } from './pipeline-execution';
+import { PipelineExecutionContext } from './pipeline-execution-context';
 import { PipelineStepHelpers } from './step-helpers';
 export type PipelineStepCode = string;
 export type PipelineStepPayload = any;
-export interface PipelineStepContext {
-    authorization?: PipelineRequestAuthorization;
-    traceId?: string;
-}
-export interface PipelineStepData<C = PipelineStepPayload, CTX = PipelineStepContext> {
-    $context?: CTX;
+export interface PipelineStepData<C = PipelineStepPayload, CTX = PipelineExecutionContext> {
+    $context: CTX;
     content: C;
 }
 export interface PipelineStep<In = any, Out = any> {

package/lib/pipeline/pipeline.d.ts

@@ -1,25 +1,16 @@
 import { Config, Logger } from '../utils';
 import { AbstractPipelineExecution, PipelineExecutionOptions } from './pipeline-execution';
+import { PipelineExecutionContext } from './pipeline-execution-context';
 import { PipelineStep, PipelineStepBuilder, PipelineStepData, PipelineStepOptions, PipelineStepType } from './pipeline-step';
 export type PipelineRequestPayload = any;
-export interface PipelineRequestAuthorizationRole {
-    code?: string;
-    [key: string]: any | undefined;
-}
-export interface PipelineRequestAuthorization<A = any> {
-    readonly authorized: boolean;
-    readonly authentication?: A;
-    readonly roles: Array<PipelineRequestAuthorizationRole>;
-    readonly headers?: Record<string, string>;
-}
 export interface PipelineRequest<C = PipelineRequestPayload> {
     payload: C;
-    authorization?: PipelineRequestAuthorization;
-    traceId?: string;
+    $context?: PipelineExecutionContext;
 }
 export type PipelineResponsePayload = any;
 export interface PipelineResponse<C = PipelineResponsePayload> {
     payload: C;
+    $context: PipelineExecutionContext;
 }
 export type PipelineCode = string;
 export interface Pipeline<In = any, Out = any> {
@@ -39,9 +30,9 @@ export declare abstract class AbstractPipeline<In = any, Out = any> extends Abst
     protected abstract getStepBuilders(): Array<PipelineStepBuilder>;
     protected buildStepOptions(): Pick<PipelineStepOptions, 'config' | 'logger'>;
     createSteps(): Promise<Array<PipelineStep>>;
+    protected defendPipelineRequest(request: PipelineRequest<In>): Required<PipelineRequest<In>>;
     convertRequestToPipelineData<I, FirstStepIn>(request: PipelineRequest<I>): PipelineStepData<FirstStepIn>;
     convertPipelineDataToResponse<LastStepOut, O>(result: PipelineStepData<LastStepOut>): PipelineResponse<O>;
-    protected createTraceId(request: PipelineRequest<In>): string;
     perform(request: PipelineRequest<In>): Promise<PipelineResponse<Out>>;
 }
 export declare abstract class AbstractStaticPipeline<In = any, Out = any> extends AbstractPipeline<In, Out> {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainbow-o23/n1",
-	"version": "1.0.58",
+	"version": "1.0.60",
 	"description": "o23 interfaces",
 	"main": "index.cjs",
 	"module": "index.js",

package/src/lib/pipeline/index.ts

@@ -1,4 +1,5 @@
 export * from './pipeline-execution';
+export * from './pipeline-execution-context';
 export * from './pipeline-step';
 export * from './pipeline';
 

package/src/lib/pipeline/pipeline-execution-context.ts

@@ -0,0 +1,166 @@
+import {nanoid} from 'nanoid';
+
+export interface PipelineRequestAuthorizationRole {
+	code?: string;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	[key: string]: any | undefined;
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export interface PipelineRequestAuthorization<A = any> {
+	readonly authorized: boolean;
+	/** undefined when authorized is false */
+	readonly authentication?: A;
+	/** empty array when authorized is false */
+	readonly roles: Array<PipelineRequestAuthorizationRole>;
+	/** headers should be added to response */
+	readonly headers?: Record<string, string>;
+}
+
+export class PipelineExecutionContext {
+	private readonly _authorization?: PipelineRequestAuthorization;
+	private readonly _traceId: string;
+	/*
+	 * typically, when calling a remote service, and which is from some microservices group,
+	 * there might be some trace ids brought in.
+	 * therefore, these trace ids should be collected and put into pipeline context.
+	 * the key is tracing group, and value is trace id of this tracing group.
+	 * Record<scope key, [name, value]>
+	 */
+	private readonly _scopedTraceIds: Record<string, [string, string]>;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	private readonly _others: Record<string, any> = {};
+
+	constructor(authorization?: PipelineRequestAuthorization, traceId?: string, scopedTraceIds?: Record<string, [string, string]>) {
+		this._authorization = authorization;
+		this._traceId = traceId || nanoid(16);
+		this._scopedTraceIds = scopedTraceIds || {};
+	}
+
+	get authorization(): PipelineRequestAuthorization {
+		return this._authorization;
+	}
+
+	get traceId(): string {
+		return this._traceId;
+	}
+
+	get scopedTraceIds(): Record<string, string> {
+		return Object.values(this._scopedTraceIds).reduce((acc, [name, value]) => {
+			if (value != null && value.trim().length !== 0) {
+				acc[name] = value;
+			}
+			return acc;
+		}, {});
+	}
+
+	findScopedTraceId(scopeKey: string): [string, string] | undefined {
+		return this._scopedTraceIds[scopeKey];
+	}
+
+	setScopedTraceId(scopeKey: string, name: string, value: string): void {
+		this._scopedTraceIds[scopeKey] = [name, value];
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	findOther(key: string): any | undefined {
+		return this._others[key];
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	setOther(key: string, value: any): void {
+		this._others[key] = value;
+	}
+
+	shallowClone(...omittedKeys: Array<string>): PipelineExecutionContext {
+		const cloned = new PipelineExecutionContext(this.authorization, this.traceId, this._scopedTraceIds);
+		Object.keys(this._others).forEach(key => {
+			if (omittedKeys.includes(key)) {
+				return;
+			}
+			cloned.setOther(key, this.findOther(key));
+		});
+		return cloned;
+	}
+
+	clone(...omittedKeys: Array<string>): PipelineExecutionContext {
+		const cloned = new PipelineExecutionContext(this.authorization, this.traceId);
+		Object.keys(this._others).forEach(key => {
+			if (omittedKeys.includes(key)) {
+				return;
+			}
+			cloned.setOther(key, this.findOther(key));
+		});
+		return cloned;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	temporaryWith(temporaryContext: Record<string, any>): PipelineExecutionContext {
+		return new TemporaryExecutionContext(this, temporaryContext);
+	}
+}
+
+/**
+ * everything same as parent context, except things in given temporary context
+ */
+export class TemporaryExecutionContext extends PipelineExecutionContext {
+	private readonly _parent: PipelineExecutionContext;
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	private readonly _temporaryContext: Record<string, any>;
+	private readonly _temporaryKeys: Array<string>;
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	constructor(parent: PipelineExecutionContext, temporaryContext: Record<string, any>) {
+		super();
+		this._parent = parent;
+		this._temporaryContext = temporaryContext ?? {};
+		this._temporaryKeys = Object.keys(this._temporaryContext);
+	}
+
+	protected get parent(): PipelineExecutionContext {
+		return this._parent;
+	}
+
+	get authorization(): PipelineRequestAuthorization {
+		return this.parent.authorization;
+	}
+
+	get traceId(): string {
+		return this.parent.traceId;
+	}
+
+	get scopedTraceIds(): Record<string, string> {
+		return this.parent.scopedTraceIds;
+	}
+
+	findScopedTraceId(scopeKey: string): [string, string] | undefined {
+		return this.parent.findScopedTraceId(scopeKey);
+	}
+
+	setScopedTraceId(scopeKey: string, name: string, value: string) {
+		this.parent.setScopedTraceId(scopeKey, name, value);
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	get temporaryContext(): Record<string, any> {
+		return this._temporaryContext;
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	findOther(key: string): any {
+		if (this._temporaryKeys.includes(key)) {
+			return this.temporaryContext[key];
+		} else {
+			return super.findOther(key);
+		}
+	}
+
+	// eslint-disable-next-line @typescript-eslint/no-explicit-any
+	setOther(key: string, value: any) {
+		if (this._temporaryKeys.includes(key)) {
+			this.temporaryContext[key] = value;
+		} else {
+			super.setOther(key, value);
+		}
+	}
+}

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

@@ -1,6 +1,6 @@
 import {Config, Logger} from '../utils';
-import {PipelineRequestAuthorization} from './pipeline';
 import {AbstractPipelineExecution, PipelineExecutionOptions} from './pipeline-execution';
+import {PipelineExecutionContext} from './pipeline-execution-context';
 import {createStepHelpers, PipelineStepHelpers} from './step-helpers';
 
 export type PipelineStepCode = string;
@@ -8,14 +8,9 @@ export type PipelineStepCode = string;
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type PipelineStepPayload = any;
 
-export interface PipelineStepContext {
-	authorization?: PipelineRequestAuthorization;
-	traceId?: string;
-}
-
-export interface PipelineStepData<C = PipelineStepPayload, CTX = PipelineStepContext> {
+export interface PipelineStepData<C = PipelineStepPayload, CTX = PipelineExecutionContext> {
 	/** this is runtime context */
-	$context?: CTX;
+	$context: CTX;
 	content: C;
 }
 

package/src/lib/pipeline/pipeline.ts

@@ -1,6 +1,6 @@
-import {nanoid} from 'nanoid';
 import {Config, Logger} from '../utils';
 import {AbstractPipelineExecution, PipelineExecutionOptions} from './pipeline-execution';
+import {PipelineExecutionContext} from './pipeline-execution-context';
 import {
 	DefaultPipelineStepBuilder,
 	PipelineStep,
@@ -13,27 +13,9 @@ import {
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type PipelineRequestPayload = any;
 
-export interface PipelineRequestAuthorizationRole {
-	code?: string;
-	// eslint-disable-next-line @typescript-eslint/no-explicit-any
-	[key: string]: any | undefined;
-}
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export interface PipelineRequestAuthorization<A = any> {
-	readonly authorized: boolean;
-	/** undefined when authorized is false */
-	readonly authentication?: A;
-	/** empty array when authorized is false */
-	readonly roles: Array<PipelineRequestAuthorizationRole>;
-	/** headers should be added to response */
-	readonly headers?: Record<string, string>;
-}
-
 export interface PipelineRequest<C = PipelineRequestPayload> {
 	payload: C;
-	authorization?: PipelineRequestAuthorization;
-	traceId?: string;
+	$context?: PipelineExecutionContext;
 }
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -41,6 +23,7 @@ export type PipelineResponsePayload = any;
 
 export interface PipelineResponse<C = PipelineResponsePayload> {
 	payload: C;
+	$context: PipelineExecutionContext;
 }
 
 export type PipelineCode = string;
@@ -94,21 +77,25 @@ export abstract class AbstractPipeline<In = any, Out = any> extends AbstractPipe
 		return await Promise.all(this.getStepBuilders().map(async builder => await builder.create(options)));
 	}
 
-	public convertRequestToPipelineData<I, FirstStepIn>(request: PipelineRequest<I>): PipelineStepData<FirstStepIn> {
-		return {content: request.payload as unknown as FirstStepIn};
+	protected defendPipelineRequest(request: PipelineRequest<In>): Required<PipelineRequest<In>> {
+		if (request.$context == null) {
+			request.$context = new PipelineExecutionContext();
+		}
+		return request as Required<PipelineRequest<In>>;
 	}
 
-	public convertPipelineDataToResponse<LastStepOut, O>(result: PipelineStepData<LastStepOut>): PipelineResponse<O> {
-		return {payload: result.content as unknown as O};
+	public convertRequestToPipelineData<I, FirstStepIn>(request: PipelineRequest<I>): PipelineStepData<FirstStepIn> {
+		return {
+			content: request.payload as unknown as FirstStepIn,
+			$context: request.$context
+		};
 	}
 
-	protected createTraceId(request: PipelineRequest<In>): string {
-		const {traceId} = request;
-		if (traceId == null || traceId.trim().length === 0) {
-			return nanoid(16);
-		} else {
-			return traceId;
-		}
+	public convertPipelineDataToResponse<LastStepOut, O>(result: PipelineStepData<LastStepOut>): PipelineResponse<O> {
+		return {
+			payload: result.content as unknown as O,
+			$context: result.$context
+		};
 	}
 
 	/**
@@ -118,8 +105,9 @@ export abstract class AbstractPipeline<In = any, Out = any> extends AbstractPipe
 	 * - use last step's result as response.
 	 */
 	public async perform(request: PipelineRequest<In>): Promise<PipelineResponse<Out>> {
-		const traceId = this.createTraceId(request);
-		const authorization = request.authorization;
+		request = this.defendPipelineRequest(request);
+		const $context = request.$context;
+		const traceId = $context.traceId;
 		const response = await this.measurePerformance(traceId, 'PIPELINE')
 			.execute(async () => {
 				this.traceRequest(traceId, request);
@@ -129,9 +117,7 @@ export abstract class AbstractPipeline<In = any, Out = any> extends AbstractPipe
 					return await this.measurePerformance(traceId, 'STEP', step.constructor.name)
 						.execute(async () => {
 							this.traceStepIn(traceId, step, request);
-							const response = await step.perform({
-								...request, $context: {...request.$context, authorization, traceId}
-							});
+							const response = await step.perform({...request, $context});
 							this.traceStepOut(traceId, step, response);
 							// if no response returned, keep using request for next
 							return this.returnOrContinueOrClear(request, response);