@rainbow-o23/n1 1.0.58-alpha.3 → 1.0.59

package/index.cjs

@@ -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) {
@@ -705,13 +814,19 @@ class AbstractPipeline extends AbstractPipelineExecution {
         return await Promise.all(this.getStepBuilders().map(async (builder) => await builder.create(options)));
     }
     convertRequestToPipelineData(request) {
-        return { content: request.payload };
+        return {
+            content: request.payload,
+            $context: request.$context
+        };
     }
     convertPipelineDataToResponse(result) {
-        return { payload: result.content };
+        return {
+            payload: result.content,
+            $context: result.$context
+        };
     }
     createTraceId(request) {
-        const { traceId } = request;
+        const { traceId } = request.$context ?? {};
         if (traceId == null || traceId.trim().length === 0) {
             return nanoid.nanoid(16);
         }
@@ -720,8 +835,8 @@ class AbstractPipeline extends AbstractPipelineExecution {
         }
     }
     async perform(request) {
-        const traceId = this.createTraceId(request);
-        const authorization = request.authorization;
+        const $context = request.$context;
+        const traceId = $context.traceId;
         const response = await this.measurePerformance(traceId, 'PIPELINE')
             .execute(async () => {
             this.traceRequest(traceId, request);
@@ -731,9 +846,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 +931,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

@@ -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) {
@@ -703,13 +812,19 @@ class AbstractPipeline extends AbstractPipelineExecution {
         return await Promise.all(this.getStepBuilders().map(async (builder) => await builder.create(options)));
     }
     convertRequestToPipelineData(request) {
-        return { content: request.payload };
+        return {
+            content: request.payload,
+            $context: request.$context
+        };
     }
     convertPipelineDataToResponse(result) {
-        return { payload: result.content };
+        return {
+            payload: result.content,
+            $context: result.$context
+        };
     }
     createTraceId(request) {
-        const { traceId } = request;
+        const { traceId } = request.$context ?? {};
         if (traceId == null || traceId.trim().length === 0) {
             return nanoid(16);
         }
@@ -718,8 +833,8 @@ class AbstractPipeline extends AbstractPipelineExecution {
         }
     }
     async perform(request) {
-        const traceId = this.createTraceId(request);
-        const authorization = request.authorization;
+        const $context = request.$context;
+        const traceId = $context.traceId;
         const response = await this.measurePerformance(traceId, 'PIPELINE')
             .execute(async () => {
             this.traceRequest(traceId, request);
@@ -729,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);
                 });
@@ -795,4 +908,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> {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@rainbow-o23/n1",
-	"version": "1.0.58-alpha.3",
+	"version": "1.0.59",
 	"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,7 @@
 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 +14,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 +24,7 @@ export type PipelineResponsePayload = any;
 
 export interface PipelineResponse<C = PipelineResponsePayload> {
 	payload: C;
+	$context: PipelineExecutionContext;
 }
 
 export type PipelineCode = string;
@@ -95,15 +79,21 @@ export abstract class AbstractPipeline<In = any, Out = any> extends AbstractPipe
 	}
 
 	public convertRequestToPipelineData<I, FirstStepIn>(request: PipelineRequest<I>): PipelineStepData<FirstStepIn> {
-		return {content: request.payload as unknown as FirstStepIn};
+		return {
+			content: request.payload as unknown as FirstStepIn,
+			$context: request.$context
+		};
 	}
 
 	public convertPipelineDataToResponse<LastStepOut, O>(result: PipelineStepData<LastStepOut>): PipelineResponse<O> {
-		return {payload: result.content as unknown as O};
+		return {
+			payload: result.content as unknown as O,
+			$context: result.$context
+		};
 	}
 
 	protected createTraceId(request: PipelineRequest<In>): string {
-		const {traceId} = request;
+		const {traceId} = request.$context ?? {};
 		if (traceId == null || traceId.trim().length === 0) {
 			return nanoid(16);
 		} else {
@@ -118,8 +108,8 @@ 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;
+		const $context = request.$context;
+		const traceId = $context.traceId;
 		const response = await this.measurePerformance(traceId, 'PIPELINE')
 			.execute(async () => {
 				this.traceRequest(traceId, request);
@@ -129,9 +119,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);