@rainbow-o23/n3 0.1.1

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

@@ -0,0 +1,22 @@
+import { PipelineStepData, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { QueryRunner } from 'typeorm';
+import { PipelineStepSets, PipelineStepSetsContext, PipelineStepSetsOptions } from '../step';
+import { TypeOrmDataSource } from '../typeorm';
+import { TypeOrmDataSourceName, TypeOrmTransactionalContext, TypeOrmTransactionKey, TypeOrmTransactionName } from './types';
+export interface TypeOrmTransactionalPipelineStepSetsOptions extends PipelineStepSetsOptions {
+    dataSourceName: TypeOrmDataSourceName;
+    transactionName?: TypeOrmTransactionName;
+}
+export declare class TypeOrmTransactionalPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends PipelineStepSets<In, Out, InFragment, OutFragment> {
+    private readonly _dataSourceName;
+    private readonly _transactionName;
+    constructor(options: TypeOrmTransactionalPipelineStepSetsOptions);
+    getDataSourceName(): TypeOrmDataSourceName;
+    getTransactionName(): TypeOrmTransactionName;
+    getTransactionKey(): TypeOrmTransactionKey;
+    protected findDataSourceOrThrow(): Promise<Undefinable<TypeOrmDataSource>>;
+    protected createRunner(): Promise<[TypeOrmDataSource, QueryRunner]>;
+    protected attachMineToInternalContext(inheritedContext: PipelineStepSetsContext, _request: PipelineStepData<In>): Promise<TypeOrmTransactionalContext>;
+    private getRunner;
+    protected performWithContext(request: PipelineStepData<In>, run: (request: PipelineStepData<In>, context: PipelineStepSetsContext) => Promise<OutFragment>): Promise<OutFragment>;
+}

package/lib/typeorm-step/typeorm-bulk-save-by-sql-step.d.ts

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

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

@@ -0,0 +1,21 @@
+import { PipelineStepData, PipelineStepHelpers, PipelineStepPayload } from '@rainbow-o23/n1';
+import { QueryRunner } from 'typeorm';
+import { ScriptFuncOrBody } from '../step';
+import { AbstractTypeOrmPipelineStep, TypeOrmPipelineStepOptions } from './abstract-typeorm-step';
+export type TypeOrmPerformWithInFragment<InFragment, OutFragment> = ($runner: QueryRunner, $factor: InFragment, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment>;
+export type TypeOrmPerformWithoutInFragment<OutFragment> = ($runner: QueryRunner, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment>;
+export type TypeOrmPerformFunc<InFragment, OutFragment> = TypeOrmPerformWithInFragment<InFragment, OutFragment> | TypeOrmPerformWithoutInFragment<OutFragment>;
+export interface TypeOrmBySnippetPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends TypeOrmPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    snippet: ScriptFuncOrBody<TypeOrmPerformFunc<InFragment, OutFragment>>;
+}
+export declare class TypeOrmBySnippetPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out> extends AbstractTypeOrmPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _snippet;
+    private readonly _func;
+    constructor(options: TypeOrmBySnippetPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getSnippet(): ScriptFuncOrBody<TypeOrmPerformFunc<InFragment, OutFragment>>;
+    protected generateVariableNames(): Array<string>;
+    protected doPerform(basis: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+    protected isInFragmentIgnored(): boolean;
+    protected getRunnerVariableName(): string;
+    protected getInFragmentVariableName(): string;
+}

package/lib/typeorm-step/typeorm-load-entity-by-id-step.d.ts

@@ -0,0 +1,12 @@
+import { PipelineStepData, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { AbstractTypeOrmPipelineStep, TypeOrmPipelineStepOptions } from './abstract-typeorm-step';
+import { TypeOrmEntityName, TypeOrmEntityToLoad, TypeOrmIdType } from './types';
+export interface TypeOrmLoadEntityByIdPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = TypeOrmIdType, OutFragment = Out> extends TypeOrmPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    entityName: TypeOrmEntityName;
+}
+export declare class TypeOrmLoadEntityByIdPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment = TypeOrmEntityToLoad> extends AbstractTypeOrmPipelineStep<In, Out, TypeOrmIdType, OutFragment> {
+    private readonly _entityName;
+    constructor(options: TypeOrmLoadEntityByIdPipelineStepOptions<In, Out, TypeOrmIdType, OutFragment>);
+    getEntityName(): TypeOrmEntityName;
+    protected doPerform(id: TypeOrmIdType, request: PipelineStepData<In>): Promise<Undefinable<OutFragment>>;
+}

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

@@ -0,0 +1,6 @@
+import { PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractTypeOrmLoadBySQLPipelineStep } from './abstract-typeorm-load-by-sql-step';
+import { TypeOrmEntityToLoad } from './types';
+export declare class TypeOrmLoadManyBySQLPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment = Array<TypeOrmEntityToLoad>> extends AbstractTypeOrmLoadBySQLPipelineStep<In, Out, OutFragment> {
+    protected getDataFromResultSet(rst: Array<TypeOrmEntityToLoad>): Promise<OutFragment>;
+}

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

@@ -0,0 +1,6 @@
+import { PipelineStepPayload } from '@rainbow-o23/n1';
+import { AbstractTypeOrmLoadBySQLPipelineStep } from './abstract-typeorm-load-by-sql-step';
+import { TypeOrmEntityToLoad } from './types';
+export declare class TypeOrmLoadOneBySQLPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment = TypeOrmEntityToLoad> extends AbstractTypeOrmLoadBySQLPipelineStep<In, Out, OutFragment> {
+    protected getDataFromResultSet(rst: Array<TypeOrmEntityToLoad>): Promise<OutFragment>;
+}

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

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

package/lib/typeorm-step/typeorm-save-entity-step.d.ts

@@ -0,0 +1,32 @@
+import { O23ExternalErrorCode, PipelineStepData, PipelineStepPayload, Undefinable } from '@rainbow-o23/n1';
+import { DeepPartial, ObjectLiteral } from 'typeorm';
+import { ScriptFuncOrBody } from '../step';
+import { AbstractTypeOrmPipelineStep, TypeOrmPipelineStepOptions } from './abstract-typeorm-step';
+import { TypeOrmEntityName } from './types';
+export type EntityToSave = DeepPartial<ObjectLiteral>;
+export type UniquenessCheckResult = {
+    pass: true;
+} | {
+    pass: false;
+    code: O23ExternalErrorCode;
+    message: string;
+};
+export type UniquenessCheckFunc<EntityToSave> = (given: EntityToSave, existing: EntityToSave) => UniquenessCheckResult;
+export interface TypeOrmSaveEntityPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = EntityToSave, OutFragment = EntityToSave> extends TypeOrmPipelineStepOptions<In, Out, InFragment, OutFragment> {
+    entityName: TypeOrmEntityName;
+    fillIdBySnowflake?: boolean;
+    uniquenessCheckSnippet?: ScriptFuncOrBody<UniquenessCheckFunc<InFragment>>;
+}
+export declare class TypeOrmSaveEntityPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = EntityToSave, OutFragment = EntityToSave> extends AbstractTypeOrmPipelineStep<In, Out, InFragment, OutFragment> {
+    private readonly _entityName;
+    private readonly _fillIdBySnowflake;
+    private readonly _uniquenessCheckSnippet?;
+    private readonly _uniquenessCheckFunc?;
+    constructor(options: TypeOrmSaveEntityPipelineStepOptions<In, Out, InFragment, OutFragment>);
+    getEntityName(): TypeOrmEntityName;
+    isFillIdBySnowflake(): boolean;
+    getUniquenessCheckSnippet(): Undefinable<ScriptFuncOrBody<UniquenessCheckFunc<InFragment>>>;
+    needUniquenessCheck(): boolean;
+    protected generateUniquenessCheckVariableNames(): Array<string>;
+    protected doPerform(entity: InFragment, request: PipelineStepData<In>): Promise<OutFragment>;
+}

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

@@ -0,0 +1,22 @@
+import { DeepPartial, ObjectLiteral, QueryRunner } from 'typeorm';
+import { PipelineStepSetsContext } from '../step';
+import { TypeOrmDataSource } from '../typeorm';
+export type TypeOrmIdType = string | number | bigint;
+export type TypeOrmDataSourceName = string;
+export type TypeOrmTransactionName = string;
+export type TypeOrmTransactionKey = `${TypeOrmDataSourceName}.${TypeOrmTransactionName}`;
+export type TypeOrmEntityName = string;
+export type TypeOrmEntityValue = string | number | bigint | boolean | Date | null | undefined;
+export type TypeOrmEntityToLoad = DeepPartial<ObjectLiteral>;
+export type TypeOrmEntityToSave = DeepPartial<ObjectLiteral>;
+export type TypeOrmSql = string;
+export type TypeOrmIdOfInserted = TypeOrmIdType;
+export type TypeOrmIdsOfInserted = Array<TypeOrmIdOfInserted>;
+export type TypeOrmCountOfAffected = number;
+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 {
+    $trans: Record<TypeOrmTransactionKey, [TypeOrmDataSource, QueryRunner]>;
+}

package/package.json

@@ -0,0 +1,74 @@
+{
+	"name": "@rainbow-o23/n3",
+	"version": "0.1.1",
+	"description": "o23 pipelines",
+	"main": "index.cjs",
+	"module": "index.js",
+	"types": "index.d.ts",
+	"type": "module",
+	"scripts": {
+		"build": "rollup -c",
+		"build:ci": "rollup -c rollup.config.ci.js",
+		"test": "jest"
+	},
+	"license": "UNLICENSED",
+	"author": "Rainbow Team",
+	"dependencies": {
+		"@rainbow-o23/n1": "0.1.1",
+		"@theinternetfolks/snowflake": "^1.3.0",
+		"node-fetch": "2.6.1",
+		"typeorm": "^0.3.17"
+	},
+	"devDependencies": {
+		"@babel/core": "^7.20.5",
+		"@babel/preset-env": "^7.20.2",
+		"@babel/preset-typescript": "^7.18.6",
+		"@rollup/plugin-babel": "^6.0.4",
+		"@rollup/plugin-eslint": "^9.0.3",
+		"@types/better-sqlite3": "^7.6.6",
+		"@types/events": "^3.0.1",
+		"@types/node": "18.16.12",
+		"@types/node-fetch": "2.6.4",
+		"@typescript-eslint/eslint-plugin": "^5.46.0",
+		"@typescript-eslint/parser": "^5.46.0",
+		"better-sqlite3": "^9.0.0",
+		"eslint": "^8.29.0",
+		"mssql": "^10.0.1",
+		"mysql2": "^3.6.2",
+		"oracledb": "^6.2.0",
+		"pg": "^8.11.3",
+		"pg-query-stream": "^4.5.3",
+		"reflect-metadata": "^0.1.13",
+		"rollup": "^3.7.0",
+		"rollup-plugin-tslint": "^0.2.2",
+		"rollup-plugin-typescript2": "^0.34.1",
+		"tslib": "^2.4.1",
+		"typescript": "5.1.6"
+	},
+	"jest": {
+		"moduleFileExtensions": [
+			"js",
+			"json",
+			"ts"
+		],
+		"testRegex": "(/test/.*\\.(test|spec))\\.[tj]sx?$",
+		"testPathIgnorePatterns": [
+			"/node_modules/"
+		],
+		"transform": {
+			"^.+\\.(t|j)s$": "ts-jest"
+		},
+		"collectCoverageFrom": [
+			"src/**/*.(t|j)s"
+		],
+		"coverageDirectory": "./coverage",
+		"coverageReporters": [
+			"html"
+		],
+		"testEnvironment": "node"
+	},
+	"volta": {
+		"node": "18.19.0",
+		"yarn": "1.22.21"
+	}
+}

package/rollup.config.base.js

@@ -0,0 +1,33 @@
+import {babel} from '@rollup/plugin-babel';
+import eslint from '@rollup/plugin-eslint';
+import typescript from 'rollup-plugin-typescript2';
+
+export const buildConfig = (lint) => {
+	// ['./index.d.ts', './index.js', './index.cjs', './lib'].forEach(f => {
+	// 	const cwd = path.resolve(process.cwd(), f);
+	// 	if (fs.existsSync(cwd)) {
+	// 		fs.rmSync(cwd, {recursive: true, force: true});
+	// 	}
+	// });
+
+	return {
+		input: './src/index.ts',
+		output: [
+			{format: 'es', dir: '.'},
+			{format: 'cjs', file: './index.cjs'}
+		],
+		plugins: [
+			lint ? eslint({exclude: ['../node_modules/**', 'node_modules/**']}) : null,
+			// lint ? tslint({exclude: ['../node_modules/**', 'node_modules/**']}) : null,
+			typescript({clean: true}),
+			babel({babelHelpers: 'bundled'})
+		].filter(x => x != null),
+		external(id) {
+			return ["@rainbow-o23/", "typeorm/"].some(scope => id.startsWith(scope))
+				|| [
+					"typeorm", "reflect-metadata",
+					"@theinternetfolks/snowflake", "node-fetch"
+				].includes(id);
+		}
+	};
+};

package/rollup.config.ci.js

@@ -0,0 +1,3 @@
+import {buildConfig} from './rollup.config.base.js';
+
+export default [buildConfig(false)];

package/rollup.config.js

@@ -0,0 +1,3 @@
+import {buildConfig} from './rollup.config.base.js';
+
+export default [buildConfig(true)];

package/src/index.ts

@@ -0,0 +1,7 @@
+export * from './lib/error-codes';
+
+export * from './lib/typeorm';
+
+export * from './lib/step';
+export * from './lib/http';
+export * from './lib/typeorm-step';

package/src/lib/error-codes.ts

@@ -0,0 +1,18 @@
+import {O23ReservedErrorCode} from '@rainbow-o23/n1';
+
+export const ERR_PIPELINE_STEP_SNIPPET_NOT_EMPTY: O23ReservedErrorCode = 'O03-00001';
+export const ERR_PIPELINE_STEP_CONDITIONAL_SNIPPET_NOT_EMPTY: O23ReservedErrorCode = 'O03-00002';
+export const ERR_TYPEORM_DATASOURCE_TYPE_NOT_FOUND: O23ReservedErrorCode = 'O03-00003';
+export const ERR_TYPEORM_DATASOURCE_CREATOR_NOT_FOUND: O23ReservedErrorCode = 'O03-00004';
+export const ERR_TYPEORM_DATASOURCE_NOT_FOUND: O23ReservedErrorCode = 'O03-00005';
+export const ERR_TYPEORM_ENTITY_NOT_FOUND: O23ReservedErrorCode = 'O03-00006';
+export const ERR_TYPEORM_SQL_NOT_EMPTY: O23ReservedErrorCode = 'O03-00007';
+export const ERR_TYPEORM_TRANSACTION_NOT_FOUND: O23ReservedErrorCode = 'O03-00008';
+export const ERR_TYPEORM_STEP_SNIPPET_NOT_EMPTY: O23ReservedErrorCode = 'O03-00009';
+export const ERR_FETCH_ERROR: O23ReservedErrorCode = 'O03-00010';
+export const ERR_PIPELINE_STEP_METHOD_NOT_SUPPORTED: O23ReservedErrorCode = 'O03-00011';
+export const ERR_EACH_FRAGMENT_NOT_ANY_ARRAY: O23ReservedErrorCode = 'O03-00012';
+export const ERR_PIPELINE_STEP_REF_NOT_EMPTY: O23ReservedErrorCode = 'O03-00013';
+export const ERR_PIPELINE_STEP_REF_NOT_FOUND: O23ReservedErrorCode = 'O03-00014';
+export const ERR_PIPELINE_REF_NOT_EMPTY: O23ReservedErrorCode = 'O03-00015';
+export const ERR_PIPELINE_REF_NOT_FOUND: O23ReservedErrorCode = 'O03-00016';

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

@@ -0,0 +1,290 @@
+import {PipelineStepData, PipelineStepHelpers, PipelineStepPayload, UncatchableError} from '@rainbow-o23/n1';
+import fetch, {Response} from 'node-fetch';
+import {ERR_FETCH_ERROR} from '../error-codes';
+import {AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions, ScriptFuncOrBody, Utils} from '../step';
+import {
+	HttpAbortErrorCode,
+	HttpErrorCode,
+	HttpErrorHandleOptions,
+	HttpGenerateBody,
+	HttpGenerateHeaders,
+	HttpGenerateResponse,
+	HttpGenerateUrl,
+	HttpHandleError,
+	HttpUnknownErrorCode
+} from './types';
+
+export interface FetchPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
+	extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+	endpointSystemCode: string;
+	endpointName: string;
+	urlGenerate?: ScriptFuncOrBody<HttpGenerateUrl<In, InFragment>>;
+	headersGenerate?: ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>>;
+	bodyGenerate?: ScriptFuncOrBody<HttpGenerateBody<In, InFragment>>;
+	responseGenerate?: ScriptFuncOrBody<HttpGenerateResponse<In, InFragment>>;
+	responseErrorHandles?: {
+		[key: HttpErrorCode]: ScriptFuncOrBody<HttpHandleError<In, InFragment, OutFragment>>;
+	};
+}
+
+export class FetchPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
+	extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+	private readonly _endpointSystemCode: string;
+	private readonly _endpointName: string;
+	private readonly _endpointUrl: string;
+	private readonly _endpointMethod: string;
+	private readonly _endpointHeaders: Record<string, string>;
+	private readonly _endpointTimeout: number;
+	private readonly _urlGenerateSnippet: ScriptFuncOrBody<HttpGenerateUrl<In, InFragment>>;
+	private readonly _urlGenerateFunc: HttpGenerateUrl<In, InFragment>;
+	private readonly _headersGenerateSnippet: ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>>;
+	private readonly _headersGenerateFunc: HttpGenerateHeaders<In, InFragment>;
+	private readonly _bodyUsed: boolean;
+	private readonly _bodyGenerateSnippet: ScriptFuncOrBody<HttpGenerateBody<In, InFragment>>;
+	private readonly _bodyGenerateFunc: HttpGenerateBody<In, InFragment>;
+	private readonly _responseGenerateSnippet: ScriptFuncOrBody<HttpGenerateResponse<In, InFragment>>;
+	private readonly _responseGenerateFunc: HttpGenerateResponse<In, InFragment>;
+	private readonly _responseErrorHandleFunc: HttpHandleError<In, InFragment, OutFragment>;
+
+	public constructor(options: FetchPipelineStepOptions<In, Out, InFragment, OutFragment>) {
+		super(options);
+		const config = this.getConfig();
+		this._endpointSystemCode = options.endpointSystemCode;
+		this._endpointName = options.endpointName;
+		const endpointKey = this.getEndpointKey();
+		this._endpointUrl = config.getString(`endpoints.${endpointKey}.url`);
+		this._endpointMethod = config.getString(`endpoints.${endpointKey}.method`, 'POST').toLowerCase();
+		this._endpointHeaders = this.generateEndpointHeaders(
+			config.getString(`endpoints.${endpointKey}.headers`),
+			this.generateEndpointHeaders(config.getString(`endpoints.${this.getEndpointSystemCode()}.global.headers`)));
+		// in second
+		this._endpointTimeout = config.getNumber(`endpoints.${endpointKey}.timeout`)
+			?? config.getNumber(`endpoints.${this.getEndpointSystemCode()}.global.timeout`, -1);
+		// to millisecond
+		this._endpointTimeout = this._endpointTimeout > 0 ? this._endpointTimeout * 1000 : -1;
+		this._urlGenerateSnippet = options.urlGenerate;
+		this._urlGenerateFunc = Utils.createSyncFunction(this.getUrlGenerateSnippet(), {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			createDefault: () => ($endpointUrl: string, _$factor: InFragment, _$request: PipelineStepData<In>, _$helpers: PipelineStepHelpers, _$: PipelineStepHelpers) => $endpointUrl,
+			getVariableNames: () => this.getUrlGenerateVariableName(),
+			error: (e: Error) => {
+				this.getLogger().error(`Failed on create function for url generate, snippet is [${this.getUrlGenerateSnippet()}].`);
+				throw e;
+			}
+		});
+		this._headersGenerateSnippet = options.headersGenerate;
+		this._headersGenerateFunc = Utils.createSyncFunction(this.getHeadersGenerateSnippet(), {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			createDefault: () => (_$factor: InFragment, _$request: PipelineStepData<In>, _$helpers: PipelineStepHelpers, _$: PipelineStepHelpers) => (void 0),
+			getVariableNames: () => this.getHeadersGenerateVariableNames(),
+			error: (e: Error) => {
+				this.getLogger().error(`Failed on create function for request headers generate, snippet is [${this.getHeadersGenerateSnippet()}].`);
+				throw e;
+			}
+		});
+		this._bodyUsed = config.getBoolean(`endpoints.${endpointKey}.body.used`, true);
+		this._bodyGenerateSnippet = options.bodyGenerate;
+		this._bodyGenerateFunc = Utils.createSyncFunction(this.getBodyGenerateSnippet(), {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			createDefault: () => ($factor: InFragment, _$request: PipelineStepData<In>, _$helpers: PipelineStepHelpers, _$: PipelineStepHelpers) => {
+				return ($factor == null || (typeof $factor === 'string' && $factor.length === 0)) ? (void 0) : JSON.stringify($factor);
+			},
+			getVariableNames: () => this.getBodyGenerateVariableNames(),
+			error: (e: Error) => {
+				this.getLogger().error(`Failed on create function for request body generate, snippet is [${this.getBodyGenerateSnippet()}].`);
+				throw e;
+			}
+		});
+		this._responseGenerateSnippet = options.responseGenerate;
+		this._responseGenerateFunc = Utils.createAsyncFunction(this.getResponseGenerateSnippet(), {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			createDefault: () => async ($response: Response, _$factor: InFragment, _$request: PipelineStepData<In>, _$helpers: PipelineStepHelpers, _$: PipelineStepHelpers) => {
+				return await $response.json();
+			},
+			getVariableNames: () => this.getResponseGenerateVariableName(),
+			error: (e: Error) => {
+				this.getLogger().error(`Failed on create function for response generate, snippet is [${this.getResponseGenerateSnippet()}].`);
+				throw e;
+			}
+		});
+		if (options.responseErrorHandles) {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			const defaultHandler = async (options: HttpErrorHandleOptions<In, InFragment>, _$helpers: PipelineStepHelpers, _$: PipelineStepHelpers): Promise<OutFragment> | never => {
+				throw new UncatchableError(ERR_FETCH_ERROR, `Error[${options.$errorCode}] caught when fetch data from remote[${options.$url}].`);
+			};
+			const createDefaultHandler = () => defaultHandler;
+			const getVariableNames = () => this.getErrorHandlerVariableName();
+			const handlers: Record<HttpErrorCode, HttpHandleError<In, InFragment, OutFragment>> = Object.keys(options.responseErrorHandles).reduce((handlers, status) => {
+				handlers[status] = Utils.createAsyncFunction(options.responseErrorHandles[status], {
+					createDefault: createDefaultHandler, getVariableNames,
+					error: (e: Error) => {
+						this.getLogger().error(`Failed on create function for response error handler[${status}], snippet is [${options.responseErrorHandles[status]}].`);
+						throw e;
+					}
+				});
+				return handlers;
+			}, {});
+			this._responseErrorHandleFunc = async ($options: HttpErrorHandleOptions<In, InFragment>, $helpers: PipelineStepHelpers, $: PipelineStepHelpers): Promise<OutFragment> | never => {
+				const {$errorCode} = $options;
+				const givenErrorHandler = handlers[$errorCode];
+				if (givenErrorHandler == null) {
+					return await defaultHandler($options, $helpers, $);
+				} else {
+					return await givenErrorHandler($options, $helpers, $);
+				}
+			};
+		} else {
+			// eslint-disable-next-line @typescript-eslint/no-unused-vars
+			this._responseErrorHandleFunc = async ($options: HttpErrorHandleOptions<In, InFragment>, _$helpers: PipelineStepHelpers, _$: PipelineStepHelpers): Promise<OutFragment> | never => {
+				throw new UncatchableError(ERR_FETCH_ERROR, `Error[${$options.$errorCode}] caught when fetch data from remote[${$options.$url}].`);
+			};
+		}
+	}
+
+	public getEndpointSystemCode(): string {
+		return this._endpointSystemCode;
+	}
+
+	public getEndpointName(): string {
+		return this._endpointName;
+	}
+
+	public getEndpointKey(): string {
+		return `${this.getEndpointSystemCode()}.${this.getEndpointName()}`;
+	}
+
+	public getEndpointUrl(): string {
+		return this._endpointUrl;
+	}
+
+	public getEndpointMethod(): string {
+		return this._endpointMethod;
+	}
+
+	public getEndpointHeaders(): Record<string, string> {
+		return this._endpointHeaders;
+	}
+
+	protected generateEndpointHeaders(headers?: string, base?: Record<string, string>): Record<string, string> {
+		return `${headers || ''}`.split(';')
+			.map(x => x.trim())
+			.filter(x => x.length !== 0)
+			.map(x => x.split('='))
+			.map(([key, value]) => [key.trim(), value])
+			.filter(([key]) => key.length !== 0)
+			.reduce((map, [key, value]) => {
+				map[key] = value;
+				return map;
+			}, base ?? {});
+	}
+
+	public getEndpointTimeout(): number {
+		return this._endpointTimeout;
+	}
+
+	public needTimeout(): boolean {
+		return this._endpointTimeout > 0;
+	}
+
+	public getUrlGenerateSnippet(): ScriptFuncOrBody<HttpGenerateUrl<In, InFragment>> {
+		return this._urlGenerateSnippet;
+	}
+
+	/**
+	 * override this method when want to use another variable name rather than "$endpointUrl", "$factor", "$request"
+	 */
+	protected getUrlGenerateVariableName(): Array<string> {
+		return ['$endpointUrl', '$factor', '$request', ...this.getHelpersVariableNames()];
+	}
+
+	public getHeadersGenerateSnippet(): ScriptFuncOrBody<HttpGenerateHeaders<In, InFragment>> {
+		return this._headersGenerateSnippet;
+	}
+
+	/**
+	 * override this method when want to use another variable name rather than "$endpointUrl", "$factor", "$request"
+	 */
+	protected getHeadersGenerateVariableNames(): Array<string> {
+		return ['$factor', '$request', ...this.getHelpersVariableNames()];
+	}
+
+	protected isBodyUsed(): boolean {
+		return this._bodyUsed;
+	}
+
+	public getBodyGenerateSnippet(): ScriptFuncOrBody<HttpGenerateBody<In, InFragment>> {
+		return this._bodyGenerateSnippet;
+	}
+
+	/**
+	 * override this method when want to use another variable name rather than "$endpointUrl", "$factor", "$request"
+	 */
+	protected getBodyGenerateVariableNames(): Array<string> {
+		return ['$factor', '$request', ...this.getHelpersVariableNames()];
+	}
+
+	public getResponseGenerateSnippet(): ScriptFuncOrBody<HttpGenerateResponse<In, InFragment>> {
+		return this._responseGenerateSnippet;
+	}
+
+	protected getResponseGenerateVariableName(): Array<string> {
+		return ['$response', '$factor', '$request', ...this.getHelpersVariableNames()];
+	}
+
+	protected getErrorHandlerVariableName(): Array<string> {
+		return ['$options', ...this.getHelpersVariableNames()];
+	}
+
+	protected async doPerform(data: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
+		const $helpers = this.getHelpers();
+		let url = '';
+		try {
+			url = this._urlGenerateFunc(this.getEndpointUrl(), data, request, $helpers, $helpers);
+			const method = this.getEndpointMethod();
+			const staticHeaders = this.getEndpointHeaders() ?? {};
+			const headers = this._headersGenerateFunc(data, request, $helpers, $helpers) ?? {};
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			let body: any;
+			if (this.isBodyUsed()) {
+				body = this._bodyGenerateFunc(data, request, $helpers, $helpers);
+			} else {
+				body = (void 0);
+			}
+			if (body != null && typeof body !== 'string') {
+				body = JSON.stringify(body);
+			}
+			const response = await fetch(url, {
+				method, headers: {...staticHeaders, ...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);
+			} else {
+				return await this._responseGenerateFunc(response, data, request, $helpers, $helpers);
+			}
+		} catch (e) {
+			if (e instanceof DOMException || e.name === 'AbortError') {
+				return await this._responseErrorHandleFunc({
+					$url: url, $factor: data, $request: request, $errorCode: HttpAbortErrorCode
+				}, $helpers, $helpers);
+			} else if (e instanceof UncatchableError) {
+				// uncatchable error is thrown manually, do not handle it again.
+				throw e;
+			} else {
+				return await this._responseErrorHandleFunc({
+					$url: url, $factor: data, $request: request, $errorCode: HttpUnknownErrorCode
+				}, $helpers, $helpers);
+			}
+		}
+	}
+}

package/src/lib/http/index.ts

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

package/src/lib/http/types.ts

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