@rainbow-o23/n3 0.1.1

package/src/lib/typeorm-step/abstract-typeorm-step.ts

@@ -0,0 +1,241 @@
+import {PipelineStepData, PipelineStepPayload, UncatchableError, Undefinable} from '@rainbow-o23/n1';
+import {DataSource, EntityMetadata, ObjectLiteral, QueryRunner, Repository} from 'typeorm';
+import {ColumnMetadata} from 'typeorm/metadata/ColumnMetadata.js';
+import {
+	ERR_TYPEORM_DATASOURCE_NOT_FOUND,
+	ERR_TYPEORM_ENTITY_NOT_FOUND,
+	ERR_TYPEORM_TRANSACTION_NOT_FOUND
+} from '../error-codes';
+import {AbstractFragmentaryPipelineStep, FragmentaryPipelineStepOptions} from '../step';
+import {DataSourceType, TypeOrmDataSource, TypeOrmDataSourceManager} from '../typeorm';
+import {
+	DEFAULT_TRANSACTION_NAME,
+	TypeOrmDataSourceName,
+	TypeOrmEntityName,
+	TypeOrmTransactionalContext,
+	TypeOrmTransactionKey,
+	TypeOrmTransactionName
+} from './types';
+
+export interface TypeOrmPipelineStepOptions<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
+	extends FragmentaryPipelineStepOptions<In, Out, InFragment, OutFragment> {
+	dataSourceName: TypeOrmDataSourceName;
+	/**
+	 * to identify the transaction should be used, or ignore it to use the default transaction.
+	 * transaction must be created by {@link TypeOrmTransactionalPipelineStepSets},
+	 * otherwise raise exception when autonomous is false.
+	 */
+	transactionName?: TypeOrmTransactionName;
+	/** when autonomous is true, transaction name should be ignored no matter what given */
+	autonomous?: boolean;
+}
+
+// noinspection JSUnusedGlobalSymbols
+export abstract class AbstractTypeOrmPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
+	extends AbstractFragmentaryPipelineStep<In, Out, InFragment, OutFragment> {
+	private readonly _dataSourceName: TypeOrmDataSourceName;
+	private readonly _transactionName: TypeOrmTransactionName;
+	private readonly _autonomous: boolean;
+
+	// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+	public constructor(options: TypeOrmPipelineStepOptions<In, Out, InFragment, OutFragment>) {
+		super(options);
+		this._dataSourceName = options.dataSourceName;
+		this._transactionName = options.transactionName || DEFAULT_TRANSACTION_NAME;
+		this._autonomous = options.autonomous ?? false;
+	}
+
+	public getDataSourceName(): TypeOrmDataSourceName {
+		return this._dataSourceName;
+	}
+
+	public getTransactionName(): TypeOrmTransactionName {
+		return this._transactionName;
+	}
+
+	public getTransactionKey(): TypeOrmTransactionKey {
+		return `${this.getDataSourceName()}.${this.getTransactionName()}`;
+	}
+
+	public isAutonomous(): boolean {
+		return this._autonomous;
+	}
+
+	protected isTransactional(request: PipelineStepData<In>): boolean {
+		if (this.isAutonomous()) {
+			// autonomous transaction
+			return false;
+		} else {
+			const {$context} = request as PipelineStepData<In, TypeOrmTransactionalContext>;
+			const transactionKey = this.getTransactionKey();
+			if ($context == null || $context.$trans == null || $context.$trans[transactionKey] == null) {
+				throw new UncatchableError(ERR_TYPEORM_TRANSACTION_NOT_FOUND, `Transaction[${transactionKey}] not found.`);
+			} else {
+				return true;
+			}
+		}
+	}
+
+	protected findTransactionalContext(request: PipelineStepData<In>): Undefinable<[TypeOrmDataSource, QueryRunner]> {
+		const {$context} = request as PipelineStepData<In, TypeOrmTransactionalContext>;
+		return $context?.$trans?.[this.getTransactionKey()];
+	}
+
+	protected findDataSourceType(): DataSourceType {
+		return TypeOrmDataSourceManager.findDataSourceType(this.getDataSourceName(), this.getConfig());
+	}
+
+	/**
+	 * returns undefined when data source not found
+	 */
+	protected async findDataSource(request: PipelineStepData<In>): Promise<Undefinable<TypeOrmDataSource>> {
+		if (this.isTransactional(request)) {
+			return this.findTransactionalContext(request)?.[0];
+		} else {
+			const typeOrmDataSource = await TypeOrmDataSourceManager.findDataSource(this.getDataSourceName(), this.getConfig());
+			if (typeOrmDataSource == null) {
+				return (void 0);
+			} else {
+				return typeOrmDataSource;
+			}
+		}
+	}
+
+	/**
+	 * throw error when data source not found
+	 */
+	protected async findDataSourceOrThrow(request: PipelineStepData<In>): Promise<Undefinable<TypeOrmDataSource>> {
+		let typeOrmDataSource: Undefinable<TypeOrmDataSource>;
+		if (this.isTransactional(request)) {
+			typeOrmDataSource = this.findTransactionalContext(request)?.[0];
+		} else {
+			typeOrmDataSource = await TypeOrmDataSourceManager.findDataSource(this.getDataSourceName(), this.getConfig());
+		}
+		if (typeOrmDataSource == null) {
+			throw new UncatchableError(ERR_TYPEORM_DATASOURCE_NOT_FOUND, `Data source[${this.getDataSourceName()}] not found.`);
+		} else {
+			return typeOrmDataSource;
+		}
+	}
+
+	protected async createRunner(request: PipelineStepData<In>): Promise<QueryRunner> {
+		if (this.isTransactional(request)) {
+			// use this to guard not found
+			await this.findDataSourceOrThrow(request);
+			return this.findTransactionalContext(request)?.[1];
+		} else {
+			const typeOrmDataSource = await this.findDataSourceOrThrow(request);
+			const dataSource = typeOrmDataSource.getDataSource();
+			const runner = dataSource.createQueryRunner();
+			await runner.connect();
+			return runner;
+		}
+	}
+
+	/**
+	 * 1. create runner,
+	 * 2. start transaction,
+	 * 3. run given function by created runner,
+	 * 4. commit or rollback transaction,
+	 * 4.1 handle rollback error when rolled back
+	 * 4.1.1 throw error if anything(should be an error) returned,
+	 * 4.1.2 do nothing if nothing returned,
+	 * 5. release runner.
+	 */
+	protected async trans<R>(
+		run: (runner: QueryRunner) => Promise<R>, handleRollbackError: (err: Error) => Undefinable<Error>,
+		request: PipelineStepData<In>): Promise<R> {
+		if (this.isTransactional(request)) {
+			// use this to guard not found
+			const runner = await this.createRunner(request);
+			try {
+				return await run(runner);
+			} catch (e) {
+				handleRollbackError(e);
+				// throw anyway
+				throw e;
+			}
+		} else {
+			let runner: QueryRunner = null;
+			try {
+				runner = await this.createRunner(request);
+				await runner.startTransaction();
+				const r = await run(runner);
+				await runner.commitTransaction();
+				return r;
+			} catch (err) {
+				// noinspection PointlessBooleanExpressionJS
+				if (runner != null) {
+					try {
+						// noinspection JSObjectNullOrUndefined
+						await runner.rollbackTransaction();
+					} catch (e) {
+						this.getLogger().error(`Failed to rollback typeorm transaction of data source[${this.getDataSourceName()}].`, e, this.constructor.name);
+					}
+				}
+				const error = handleRollbackError(err);
+				if (error != null) {
+					throw error;
+				}
+			} finally {
+				if (runner != null) {
+					try {
+						await runner.release();
+					} catch (e) {
+						this.getLogger().error(`Failed to release typeorm query runner of data source[${this.getDataSourceName()}].`, e, this.constructor.name);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * only when step is a sub step of {@link TypeOrmTransactionalPipelineStepSets}, and use the transaction which created by step sets,
+	 * it is transactional, otherwise it is not.
+	 *
+	 * No transaction control simply means that there is no explicit transaction control internally,
+	 * but it does not mean that write operations cannot be performed.
+	 * If a write operation is performed, the data will be immediately committed to the database.
+	 *
+	 * 1. create runner,
+	 * 2. run given function by created runner,
+	 * 3. release runner.
+	 */
+	protected async autoTrans<R>(run: (runner: QueryRunner) => Promise<R>, request: PipelineStepData<In>): Promise<R> {
+		if (this.isTransactional(request)) {
+			const runner = await this.createRunner(request);
+			return await run(runner);
+		} else {
+			let runner: QueryRunner = null;
+			try {
+				runner = await this.createRunner(request);
+				return await run(runner);
+			} finally {
+				if (runner != null) {
+					try {
+						await runner.release();
+					} catch (e) {
+						this.getLogger().error(`Failed to release typeorm query runner of data source[${this.getDataSourceName()}].`, e, this.constructor.name);
+						// ignore
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * find metadata by given name. throw error when data source or metadata not found.
+	 */
+	protected async findMetadata<E extends ObjectLiteral>(name: TypeOrmEntityName, request: PipelineStepData<In>): Promise<[EntityMetadata, ColumnMetadata, Repository<E>, DataSource]> {
+		const runner = await this.createRunner(request);
+		const dataSource = runner.connection;
+		const metadata = (dataSource.entityMetadatas || []).find(metadata => metadata.name == name);
+		if (metadata == null) {
+			throw new UncatchableError(ERR_TYPEORM_ENTITY_NOT_FOUND,
+				`Entity[${name}] in data source[${this.getDataSourceName()}] not found.`);
+		}
+		const column = metadata.columns.find(column => column.isPrimary);
+		const repository = runner.manager.getRepository(metadata.target);
+		return [metadata, column, repository as Repository<E>, dataSource];
+	}
+}

package/src/lib/typeorm-step/index.ts

@@ -0,0 +1,17 @@
+export * from './types';
+
+export * from './abstract-typeorm-step';
+export * from './typeorm-load-entity-by-id-step';
+export * from './typeorm-save-entity-step';
+
+export * from './typeorm-by-snippet-step';
+export * from './abstract-typeorm-by-sql-step';
+
+export * from './abstract-typeorm-load-by-sql-step';
+export * from './typeorm-load-one-by-sql-step';
+export * from './typeorm-load-many-by-sql-step';
+
+export * from './typeorm-save-by-sql-step';
+export * from './typeorm-bulk-save-by-sql-step';
+
+export * from './type-orm-transactional-step-sets';

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

@@ -0,0 +1,129 @@
+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 {TypeOrmDataSource, TypeOrmDataSourceManager} from '../typeorm';
+import {
+	DEFAULT_TRANSACTION_NAME,
+	TypeOrmDataSourceName,
+	TypeOrmTransactionalContext,
+	TypeOrmTransactionKey,
+	TypeOrmTransactionName
+} from './types';
+
+export interface TypeOrmTransactionalPipelineStepSetsOptions extends PipelineStepSetsOptions {
+	dataSourceName: TypeOrmDataSourceName;
+	transactionName?: TypeOrmTransactionName;
+}
+
+/**
+ * if given transaction is open (transaction key exists), will use it.
+ * so if there are multiple transactions need to be open, use different transaction name.
+ * for different data source,
+ */
+export class TypeOrmTransactionalPipelineStepSets<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
+	extends PipelineStepSets<In, Out, InFragment, OutFragment> {
+	private readonly _dataSourceName: TypeOrmDataSourceName;
+	private readonly _transactionName: TypeOrmTransactionName;
+
+	// noinspection TypeScriptAbstractClassConstructorCanBeMadeProtected
+	public constructor(options: TypeOrmTransactionalPipelineStepSetsOptions) {
+		super(options);
+		this._dataSourceName = options.dataSourceName;
+		this._transactionName = (options.transactionName ?? '').trim() || DEFAULT_TRANSACTION_NAME;
+	}
+
+	public getDataSourceName(): TypeOrmDataSourceName {
+		return this._dataSourceName;
+	}
+
+	public getTransactionName(): TypeOrmTransactionName {
+		return this._transactionName;
+	}
+
+	public getTransactionKey(): TypeOrmTransactionKey {
+		return `${this.getDataSourceName()}.${this.getTransactionName()}`;
+	}
+
+	/**
+	 * throw error when data source not found
+	 */
+	protected async findDataSourceOrThrow(): Promise<Undefinable<TypeOrmDataSource>> {
+		const typeOrmDataSource = await TypeOrmDataSourceManager.findDataSource(this.getDataSourceName(), this.getConfig());
+		if (typeOrmDataSource == null) {
+			throw new UncatchableError(ERR_TYPEORM_DATASOURCE_NOT_FOUND, `Data source[${this.getDataSourceName()}] not found.`);
+		} else {
+			return typeOrmDataSource;
+		}
+	}
+
+	protected async createRunner(): Promise<[TypeOrmDataSource, QueryRunner]> {
+		const typeOrmDataSource = await this.findDataSourceOrThrow();
+		const dataSource = typeOrmDataSource.getDataSource();
+		const runner = dataSource.createQueryRunner();
+		await runner.connect();
+		return [typeOrmDataSource, runner];
+	}
+
+	/**
+	 * 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> {
+		const context = inheritedContext as TypeOrmTransactionalContext;
+		if (context.$trans != null) {
+			if (context.$trans[this.getTransactionKey()] != null) {
+				// exists, do nothing
+			} else {
+				context.$trans[this.getTransactionKey()] = await this.createRunner();
+			}
+		} else {
+			context.$trans = {[this.getTransactionKey()]: await this.createRunner()};
+		}
+		return context;
+	}
+
+	private getRunner(context: TypeOrmTransactionalContext): QueryRunner {
+		return context.$trans[this.getTransactionKey()][1];
+	}
+
+	/**
+	 * 1. create runner, attach to internal context
+	 * 2. start transaction
+	 * 3. run steps
+	 * 4. commit or rollback transaction
+	 * 5. release runner
+	 */
+	protected async performWithContext(
+		request: PipelineStepData<In>,
+		run: (request: PipelineStepData<In>, context: PipelineStepSetsContext) => Promise<OutFragment>): Promise<OutFragment> {
+		let runner: QueryRunner = null;
+		try {
+			const context: TypeOrmTransactionalContext = await this.createInternalContext(request);
+			runner = this.getRunner(context);
+			await runner.startTransaction();
+			const r = await run(request, context);
+			await runner.commitTransaction();
+			return r;
+		} catch (e) {
+			// noinspection PointlessBooleanExpressionJS
+			if (runner != null) {
+				try {
+					// noinspection JSObjectNullOrUndefined
+					await runner.rollbackTransaction();
+				} catch (e) {
+					this.getLogger().error(`Failed to rollback typeorm transaction[${this.getTransactionName()}] of data source[${this.getDataSourceName()}].`, e, this.constructor.name);
+				}
+			}
+			throw e;
+		} finally {
+			if (runner != null) {
+				try {
+					await runner.release();
+				} catch (e) {
+					this.getLogger().error(`Failed to release typeorm query runner for transaction[${this.getTransactionName()}] of data source[${this.getDataSourceName()}].`, e, this.constructor.name);
+				}
+			}
+		}
+	}
+}

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

@@ -0,0 +1,29 @@
+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>;
+}
+
+/**
+ * ignore when values is not present or values is an empty array
+ */
+export class TypeOrmBulkSaveBySQLPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment extends TypeOrmBulkWrittenResult = TypeOrmBulkWrittenResult>
+	extends AbstractTypeOrmBySQLPipelineStep<In, Out, Undefinable<TypeOrmBulkSaveBasis>, OutFragment> {
+	protected async doPerform(basis: Undefinable<TypeOrmBulkSaveBasis>, request: PipelineStepData<In>): Promise<OutFragment> {
+		if (basis?.items == null || basis?.items.length === 0) {
+			return [] as OutFragment;
+		}
+
+		return await this.autoTrans<OutFragment>(async (runner) => {
+			const result: OutFragment = [] as OutFragment;
+			for (const item of basis.items) {
+				const {sql, params} = this.getSql(basis, item);
+				const ret = await runner.query(sql, params);
+				result.push(this.parseResult(ret));
+			}
+			return result;
+		}, request);
+	}
+}

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

@@ -0,0 +1,83 @@
+import {PipelineStepData, PipelineStepHelpers, PipelineStepPayload, UncatchableError} from '@rainbow-o23/n1';
+import {QueryRunner} from 'typeorm';
+import {ERR_TYPEORM_STEP_SNIPPET_NOT_EMPTY} from '../error-codes';
+import {ScriptFuncOrBody, Utils} from '../step';
+import {AbstractTypeOrmPipelineStep, TypeOrmPipelineStepOptions} from './abstract-typeorm-step';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type TypeOrmPerformWithInFragment<InFragment, OutFragment> = ($runner: QueryRunner, $factor: InFragment, $helpers: PipelineStepHelpers, $: PipelineStepHelpers) => Promise<OutFragment>;
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+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>>;
+}
+
+/**
+ * ignore when values is not present or values is an empty array
+ */
+export class TypeOrmBySnippetPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = In, OutFragment = Out>
+	extends AbstractTypeOrmPipelineStep<In, Out, InFragment, OutFragment> {
+	private readonly _snippet: ScriptFuncOrBody<TypeOrmPerformFunc<InFragment, OutFragment>>;
+	private readonly _func: TypeOrmPerformFunc<InFragment, OutFragment>;
+
+	public constructor(options: TypeOrmBySnippetPipelineStepOptions<In, Out, InFragment, OutFragment>) {
+		super(options);
+		this._snippet = options.snippet;
+		this._func = Utils.createAsyncFunction(this.getSnippet(), {
+			createDefault: () => {
+				throw new UncatchableError(ERR_TYPEORM_STEP_SNIPPET_NOT_EMPTY, 'Cannot create perform func on empty snippet.');
+			},
+			getVariableNames: () => this.generateVariableNames(),
+			error: (e: Error) => {
+				this.getLogger().error(`Failed on create function for typeorm snippet, snippet is [${this.getSnippet()}].`);
+				throw e;
+			}
+		});
+	}
+
+	public getSnippet(): ScriptFuncOrBody<TypeOrmPerformFunc<InFragment, OutFragment>> {
+		return this._snippet;
+	}
+
+	protected generateVariableNames(): Array<string> {
+		return [
+			this.getRunnerVariableName(),
+			this.isInFragmentIgnored() ? null : this.getInFragmentVariableName(),
+			...this.getHelpersVariableNames()
+		].filter(x => x != null);
+	}
+
+	protected async doPerform(basis: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
+		return await this.autoTrans<OutFragment>(async (runner) => {
+			const $helpers = this.getHelpers();
+			if (this.isInFragmentIgnored()) {
+				return await (this._func as TypeOrmPerformWithoutInFragment<OutFragment>)(runner, $helpers, $helpers);
+			} else {
+				return await (this._func as TypeOrmPerformWithInFragment<InFragment, OutFragment>)(runner, basis, $helpers, $helpers);
+			}
+		}, request);
+	}
+
+	/**
+	 * is request step data ignored to snippet function.
+	 * default returns false
+	 */
+	protected isInFragmentIgnored(): boolean {
+		return false;
+	}
+
+	protected getRunnerVariableName(): string {
+		return '$runner';
+	}
+
+	/**
+	 * override this method when want to use another variable name rather than "$factor"
+	 */
+	protected getInFragmentVariableName(): string {
+		return '$factor';
+	}
+}

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

@@ -0,0 +1,35 @@
+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;
+}
+
+/**
+ * no transaction here
+ */
+export class TypeOrmLoadEntityByIdPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment = TypeOrmEntityToLoad>
+	extends AbstractTypeOrmPipelineStep<In, Out, TypeOrmIdType, OutFragment> {
+	private readonly _entityName: TypeOrmEntityName;
+
+	public constructor(options: TypeOrmLoadEntityByIdPipelineStepOptions<In, Out, TypeOrmIdType, OutFragment>) {
+		super(options);
+		this._entityName = options.entityName;
+	}
+
+	public getEntityName(): TypeOrmEntityName {
+		return this._entityName;
+	}
+
+	protected async doPerform(id: TypeOrmIdType, request: PipelineStepData<In>): Promise<Undefinable<OutFragment>> {
+		const [, column, repository] = await this.findMetadata(this.getEntityName(), request);
+		const loaded = await repository.findOneBy({[column.propertyName]: id}) as OutFragment;
+		if (loaded == null) {
+			return (void 0);
+		} else {
+			return loaded;
+		}
+	}
+}

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

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

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

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

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

@@ -0,0 +1,24 @@
+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;
+}
+
+/**
+ * execute anyway, even values is not present.
+ *
+ * It is important to note that when executing the Update/Delete SQL through this step,
+ * the affected data rows may not be just one row. This depends on the given SQL and values.
+ */
+export class TypeOrmSaveBySQLPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, OutFragment = TypeOrmWrittenResult>
+	extends AbstractTypeOrmBySQLPipelineStep<In, Out, Undefinable<TypeOrmSaveBasis>, OutFragment> {
+	protected async doPerform(basis: Undefinable<TypeOrmSaveBasis>, request: PipelineStepData<In>): Promise<OutFragment> {
+		const {sql, params} = this.getSql(basis, basis?.values);
+		return await this.autoTrans<OutFragment>(async (runner) => {
+			const result = await runner.query(sql, params);
+			return this.parseResult(result);
+		}, request);
+	}
+}