@rainbow-o23/n3 0.1.1

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

@@ -0,0 +1,109 @@
+import {
+	CatchableError,
+	O23ExternalErrorCode,
+	PipelineStepData,
+	PipelineStepPayload,
+	Undefinable
+} from '@rainbow-o23/n1';
+import {Snowflake} from '@theinternetfolks/snowflake';
+import {DeepPartial, ObjectLiteral} from 'typeorm';
+import {ScriptFuncOrBody, Utils} 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 };
+/**
+ * parameter names could be change {@link TypeOrmSaveEntityPipelineStep#generateUniquenessCheckVariableNames}
+ */
+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>>;
+}
+
+/**
+ * no transaction here
+ */
+export class TypeOrmSaveEntityPipelineStep<In = PipelineStepPayload, Out = PipelineStepPayload, InFragment = EntityToSave, OutFragment = EntityToSave>
+	extends AbstractTypeOrmPipelineStep<In, Out, InFragment, OutFragment> {
+	private readonly _entityName: TypeOrmEntityName;
+	private readonly _fillIdBySnowflake: boolean;
+	private readonly _uniquenessCheckSnippet?: ScriptFuncOrBody<UniquenessCheckFunc<InFragment>>;
+	private readonly _uniquenessCheckFunc?: UniquenessCheckFunc<InFragment>;
+
+	public constructor(options: TypeOrmSaveEntityPipelineStepOptions<In, Out, InFragment, OutFragment>) {
+		super(options);
+		this._entityName = options.entityName;
+		this._fillIdBySnowflake = options.fillIdBySnowflake ?? false;
+		this._uniquenessCheckSnippet = options.uniquenessCheckSnippet;
+		this._uniquenessCheckFunc = Utils.createSyncFunction(this.getUniquenessCheckSnippet(), {
+			createDefault: () => (void 0),
+			getVariableNames: () => this.generateUniquenessCheckVariableNames(),
+			error: (e: Error) => {
+				this.getLogger().error(`Failed on create function for uniqueness check, snippet is [${this.getUniquenessCheckSnippet()}].`);
+				throw e;
+			}
+		});
+	}
+
+	public getEntityName(): TypeOrmEntityName {
+		return this._entityName;
+	}
+
+	public isFillIdBySnowflake(): boolean {
+		return this._fillIdBySnowflake;
+	}
+
+	public getUniquenessCheckSnippet(): Undefinable<ScriptFuncOrBody<UniquenessCheckFunc<InFragment>>> {
+		return this._uniquenessCheckSnippet;
+	}
+
+	public needUniquenessCheck(): boolean {
+		return this._uniquenessCheckFunc != null;
+	}
+
+	protected generateUniquenessCheckVariableNames(): Array<string> {
+		return ['given', 'existing'];
+	}
+
+	/**
+	 * 1. check uniqueness of given entity,
+	 *   - only when need it, see {@link needUniquenessCheck}
+	 *   - load entity by id, which get from given entity,
+	 *   - compare given and existing by uniqueness check snippet (see {@link _uniquenessCheckFunc}), only when existing loaded from database,
+	 *   - throw catchable error if failed on uniqueness check,
+	 * 2. generate snowflake id and set into given entity,
+	 *   - only when need it, see {@link isFillIdBySnowflake}
+	 * 3. save it.
+	 */
+	// eslint-disable-next-line @typescript-eslint/no-unused-vars
+	protected async doPerform(entity: InFragment, request: PipelineStepData<In>): Promise<OutFragment> {
+		const [, column, repository] = await this.findMetadata(this.getEntityName(), request);
+		if (this.needUniquenessCheck()) {
+			const id = entity[column.propertyName];
+			if (`${id ?? ''}`.trim().length !== 0) {
+				const existing = await repository.findOneBy({[column.propertyName]: id}) as InFragment;
+				if (existing != null) {
+					const checked = this._uniquenessCheckFunc(entity, existing);
+					if (checked.pass !== true) {
+						throw new CatchableError(checked.code, checked.message);
+					}
+				}
+			}
+		}
+		if (this.isFillIdBySnowflake()) {
+			// fill id if not exists
+			const id = entity[column.propertyName];
+			if (id == null || `${id ?? ''}`.trim().length === 0) {
+				entity[column.propertyName] = Snowflake.generate() as unknown as number;
+			}
+		}
+
+		return await repository.save(entity) as OutFragment;
+	}
+}

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

@@ -0,0 +1,25 @@
+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 const DEFAULT_TRANSACTION_NAME: TypeOrmTransactionName = '$default-transaction';
+
+export interface TypeOrmTransactionalContext extends PipelineStepSetsContext {
+	$trans: Record<TypeOrmTransactionKey, [TypeOrmDataSource, QueryRunner]>;
+}

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

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

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

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

package/test/step/typeorm-by-sql-autonomous.test.ts

@@ -0,0 +1,117 @@
+import {createConfig, createLogger} from '@rainbow-o23/n1';
+import {Column, Entity, PrimaryColumn} from 'typeorm';
+import {
+	TypeOrmBulkSaveBySQLPipelineStep,
+	TypeOrmDataSourceHelper,
+	TypeOrmDataSourceManager,
+	TypeOrmLoadManyBySQLPipelineStep,
+	TypeOrmLoadOneBySQLPipelineStep,
+	TypeOrmSaveBySQLPipelineStep
+} from '../../src';
+
+const logger = createLogger();
+const config = createConfig(logger);
+
+// decorators are leading syntax errors in ide, since the test folder is not included in tsconfig.json
+// but the tricky thing is, once test folder included into tsconfig.json, d.ts files will be created in src folder
+// which cause currently use ts-ignore to avoid this syntax errors
+// @ts-ignore
+@Entity({name: 'T_TEST_TABLE'})
+export class TestTable {
+	// @ts-ignore
+	@PrimaryColumn('bigint', {name: 'ID'})
+	id: number;
+	// @ts-ignore
+	@Column('varchar', {name: 'CONTENT'})
+	content: string;
+}
+
+describe('TypeORM SQL Autonomous Suite', () => {
+	beforeAll(async () => {
+		process.env.CFG_TYPEORM_TEST_TYPE = 'better-sqlite3';
+		process.env.CFG_TYPEORM_TEST_SYNCHRONIZE = 'true';
+		// in memory, kept in global cache, to make sure always use same one.
+		process.env.CFG_TYPEORM_TEST_KEPT_ON_GLOBAL = 'true';
+		// process.env.CFG_TYPEORM_TEST_LOGGING = 'true';
+		await new TypeOrmDataSourceHelper(config).create({
+			'TEST': [TestTable]
+		});
+		const repo = (await TypeOrmDataSourceManager.findDataSource('TEST')).getDataSource().getRepository(TestTable);
+		await repo.insert({id: 1, content: 'hello world!'});
+		await repo.insert({id: 2, content: 'good-bye world!'});
+	});
+
+	test('TypeORM load one by sql Pipeline Step Test #1', async () => {
+		// noinspection SqlResolve
+		const step = new TypeOrmLoadOneBySQLPipelineStep({
+			config, logger, dataSourceName: 'TEST', sql: 'SELECT ID id, CONTENT content FROM T_TEST_TABLE WHERE ID = ?',
+			autonomous: true
+		});
+		const request = {content: {params: [1]}};
+		const response = await step.perform(request);
+		expect(response.content).not.toBeNull();
+		expect(response.content.id).toBe(1);
+		expect(response.content.content).toBe('hello world!');
+	});
+
+	test('TypeORM insert one by sql Pipeline Step Test #1', async () => {
+		// noinspection SqlResolve
+		const step = new TypeOrmSaveBySQLPipelineStep({
+			config, logger, dataSourceName: 'TEST', sql: 'INSERT INTO T_TEST_TABLE(ID, CONTENT) VALUES (?, ?)',
+			autonomous: true, mergeRequest: 'id'
+		});
+		const request = {content: {values: [3, 'another world!']}};
+		const response = await step.perform(request);
+		expect(response.content).not.toBeNull();
+		expect(response.content.id).toBe(3);
+	});
+
+	test('TypeORM update one by sql Pipeline Step Test #1', async () => {
+		// noinspection SqlResolve
+		const step = new TypeOrmSaveBySQLPipelineStep({
+			config, logger, dataSourceName: 'TEST', sql: 'UPDATE T_TEST_TABLE SET CONTENT = ? WHERE ID = ?',
+			autonomous: true, mergeRequest: 'count'
+		});
+		const request = {content: {values: ['world #3!', 3]}};
+		const response = await step.perform(request);
+		expect(response.content).not.toBeNull();
+		// DON'T KNOW WHY THIS IS 3, SEEMS SHOULD BE 1 ACCORDING TO BETTER-SQLITE3 DOCUMENT
+		// BUT CURRENTLY IT RETURNS COUNT OF THIS TABLE, NOT IMPACTED ROW COUNT
+		expect(response.content.count).toBe(3);
+	});
+
+	test('TypeORM insert many by sql Pipeline Step Test #1', async () => {
+		// noinspection SqlResolve
+		const step = new TypeOrmBulkSaveBySQLPipelineStep({
+			config, logger, dataSourceName: 'TEST', sql: 'INSERT INTO T_TEST_TABLE(ID, CONTENT) VALUES (?, ?)',
+			autonomous: true, mergeRequest: 'ids'
+		});
+		const request = {
+			content: {
+				items: [[4, 'world #4!'], [5, 'world #5!']]
+			}
+		};
+		const response = await step.perform(request);
+		expect(response.content).not.toBeNull();
+		expect(response.content.ids.length).toBe(2);
+		expect(response.content.ids[0]).toBe(4);
+		expect(response.content.ids[1]).toBe(5);
+	});
+
+	test('TypeORM load many by sql Pipeline Step Test #1', async () => {
+		// noinspection SqlResolve
+		const step = new TypeOrmLoadManyBySQLPipelineStep<any, Array<TestTable>>({
+			config, logger, dataSourceName: 'TEST', sql: 'SELECT ID id, CONTENT content FROM T_TEST_TABLE',
+			autonomous: true
+		});
+		const request = {content: (void 0)};
+		const response = await step.perform(request);
+		expect(response.content).not.toBeNull();
+		expect(Array.isArray(response.content)).toBeTruthy();
+		expect(response.content[2].content).toBe('world #3!');
+	});
+
+	afterAll((done) => {
+		done();
+	});
+});

package/test/step/typeorm-by-sql-transactional.test.ts

@@ -0,0 +1,215 @@
+import {
+	AbstractStaticPipeline,
+	createConfig,
+	createLogger,
+	PipelineCode,
+	PipelineStepData,
+	PipelineStepType,
+	Undefinable
+} from '@rainbow-o23/n1';
+import * as fs from 'fs';
+import * as path from 'path';
+import {Column, Entity, PrimaryColumn} from 'typeorm';
+import {
+	TypeOrmBasis,
+	TypeOrmBulkSaveBySQLPipelineStep,
+	TypeOrmCountOfAffected,
+	TypeOrmDataSourceHelper,
+	TypeOrmDataSourceManager,
+	TypeOrmIdOfInserted,
+	TypeOrmIdsOfInserted,
+	TypeOrmLoadManyBySQLPipelineStep,
+	TypeOrmLoadOneBySQLPipelineStep,
+	TypeOrmSaveBySQLPipelineStep,
+	TypeOrmTransactionalPipelineStepSets,
+	TypeOrmTransactionalPipelineStepSetsOptions
+} from '../../src';
+
+const logger = createLogger();
+const config = createConfig(logger);
+
+// decorators are leading syntax errors in ide, since the test folder is not included in tsconfig.json
+// but the tricky thing is, once test folder included into tsconfig.json, d.ts files will be created in src folder
+// which cause currently use ts-ignore to avoid this syntax errors
+// @ts-ignore
+@Entity({name: 'T_TEST_TABLE'})
+export class TestTable {
+	// @ts-ignore
+	@PrimaryColumn('bigint', {name: 'ID'})
+	id: number;
+	// @ts-ignore
+	@Column('varchar', {name: 'CONTENT'})
+	content: string;
+}
+
+interface TransactionalRequest {
+	idToLoad: number,
+	item3: TestTable;
+	item3ChangeTo: TestTable;
+	item4: TestTable;
+	item5: TestTable;
+}
+
+interface TransactionalResponse extends TransactionalRequest {
+	loadedById: TestTable;
+	insertedId: TypeOrmIdOfInserted;
+	updatedCount: TypeOrmCountOfAffected;
+	insertedIds: TypeOrmIdsOfInserted;
+	all: Array<TestTable>;
+}
+
+class TransactionalTestStepSets extends TypeOrmTransactionalPipelineStepSets {
+	constructor(options: Omit<TypeOrmTransactionalPipelineStepSetsOptions, 'dataSourceName'>) {
+		// noinspection SqlResolve
+		super({
+			...options, dataSourceName: 'TEST',
+			steps: [
+				{
+					create: async ({config, logger}) => new TypeOrmLoadOneBySQLPipelineStep({
+						config,
+						logger,
+						dataSourceName: 'TEST',
+						sql: 'SELECT ID id, CONTENT content FROM T_TEST_TABLE WHERE ID = ?',
+						fromRequest: ($factor: TransactionalRequest, _$request: PipelineStepData<TransactionalRequest>) => {
+							return {params: [$factor.idToLoad]} as TypeOrmBasis;
+						},
+						toResponse: ($result: TestTable, _$request: PipelineStepData) => {
+							expect($result.id).toBe(1);
+							expect($result.content).toBe('hello world!');
+							return {loadedById: $result};
+						},
+						mergeRequest: true
+					})
+				},
+				{
+					create: async ({config, logger}) => new TypeOrmSaveBySQLPipelineStep({
+						config,
+						logger,
+						dataSourceName: 'TEST',
+						sql: 'INSERT INTO T_TEST_TABLE(ID, CONTENT) VALUES (?, ?)',
+						fromRequest: ($factor: TransactionalRequest, _$request: PipelineStepData<TransactionalRequest>) => {
+							return {values: [$factor.item3.id, $factor.item3.content]};
+						},
+						toResponse: ($result: TypeOrmIdOfInserted, _$request: PipelineStepData) => {
+							expect($result).toBe(3);
+							return {insertedId: $result};
+						},
+						mergeRequest: true
+					})
+				},
+				{
+					create: async ({config, logger}) => new TypeOrmLoadOneBySQLPipelineStep({
+						config,
+						logger,
+						dataSourceName: 'TEST',
+						autonomous: true,
+						sql: 'SELECT ID id, CONTENT content FROM T_TEST_TABLE WHERE ID = ?',
+						fromRequest: ($factor: TransactionalRequest, _$request: PipelineStepData<TransactionalRequest>) => {
+							return {params: [$factor.item3.id]};
+						},
+						toResponse: ($result: Undefinable<TestTable>, $request: PipelineStepData) => {
+							expect($result).toBeUndefined();
+							return $request.content;
+						}
+					})
+				},
+				{
+					create: async ({config, logger}) => new TypeOrmSaveBySQLPipelineStep({
+						config, logger, dataSourceName: 'TEST', sql: 'UPDATE T_TEST_TABLE SET CONTENT = ? WHERE ID = ?',
+						fromRequest: ($factor: TransactionalRequest, _$request: PipelineStepData<TransactionalRequest>) => {
+							return {values: [$factor.item3ChangeTo.content, $factor.item3ChangeTo.id]};
+						},
+						toResponse: ($result: TypeOrmCountOfAffected, _$request: PipelineStepData) => {
+							// DON'T KNOW WHY THIS IS 3, SEEMS SHOULD BE 1 ACCORDING TO BETTER-SQLITE3 DOCUMENT
+							// BUT CURRENTLY IT RETURNS COUNT OF THIS TABLE, NOT IMPACTED ROW COUNT
+							expect($result).toBe(3);
+							return {updatedCount: $result};
+						},
+						mergeRequest: true
+					})
+				},
+				{
+					create: async ({config, logger}) => new TypeOrmBulkSaveBySQLPipelineStep({
+						config,
+						logger,
+						dataSourceName: 'TEST',
+						sql: 'INSERT INTO T_TEST_TABLE(ID, CONTENT) VALUES (?, ?)',
+						fromRequest: ($factor: TransactionalRequest, _$request: PipelineStepData<TransactionalRequest>) => {
+							return {
+								items: [
+									[$factor.item4.id, $factor.item4.content], [$factor.item5.id, $factor.item5.content]
+								]
+							};
+						},
+						toResponse: ($result: TypeOrmIdsOfInserted, _$request: PipelineStepData) => {
+							return {insertedIds: $result};
+						},
+						mergeRequest: true
+					})
+				},
+				{
+					create: async ({config, logger}) => new TypeOrmLoadManyBySQLPipelineStep({
+						config, logger, dataSourceName: 'TEST', sql: 'SELECT ID id, CONTENT content FROM T_TEST_TABLE',
+						toResponse: ($result: Array<TestTable>, _$request: PipelineStepData) => {
+							return {all: $result};
+						},
+						mergeRequest: true
+					})
+				}
+			]
+		});
+	}
+}
+
+class TransactionalPipeline extends AbstractStaticPipeline<TransactionalRequest, TransactionalResponse> {
+	public getCode(): PipelineCode {
+		return 'TransactionalPipeline';
+	}
+
+	protected getStepTypes(): Array<PipelineStepType> {
+		return [TransactionalTestStepSets];
+	}
+}
+
+const filename = 'TypeORM SQL Transactional.db';
+describe('TypeORM SQL Transactional Suite', () => {
+	beforeAll(async () => {
+		if (fs.existsSync(path.resolve(filename))) {
+			fs.rmSync(path.resolve(filename));
+		}
+		process.env.CFG_TYPEORM_TEST_TYPE = 'better-sqlite3';
+		process.env.CFG_TYPEORM_TEST_SYNCHRONIZE = 'true';
+		// process.env.CFG_TYPEORM_TEST_LOGGING = 'true';
+		// cannot use in memory, since when cache it, only one connection exists,
+		// when don't cache it, doesn't share the same memory.
+		// therefore use file
+		process.env.CFG_TYPEORM_TEST_DATABASE = filename;
+		await new TypeOrmDataSourceHelper(config).create({
+			'TEST': [TestTable]
+		});
+		const repo = (await TypeOrmDataSourceManager.findDataSource('TEST')).getDataSource().getRepository(TestTable);
+		await repo.insert({id: 1, content: 'hello world!'});
+		await repo.insert({id: 2, content: 'good-bye world!'});
+	});
+
+	test('TypeORM transactional by sql Pipeline Step Test #1', async () => {
+		const pipeline = new TransactionalPipeline({config, logger});
+		const response = await pipeline.perform({
+			payload: {
+				idToLoad: 1,
+				item3: {id: 3, content: 'another world!'},
+				item3ChangeTo: {id: 3, content: 'world #3!'},
+				item4: {id: 4, content: 'world #4'},
+				item5: {id: 5, content: 'world #5'}
+			}
+		});
+		expect(response).not.toBeNull();
+	});
+
+	afterAll((done) => {
+		if (fs.existsSync(path.resolve(filename))) {
+			fs.rmSync(path.resolve(filename));
+		}
+		done();
+	});
+});

package/test/step/typeorm-entity.test.ts

@@ -0,0 +1,50 @@
+import {createConfig, createLogger} from '@rainbow-o23/n1';
+import {Column, Entity, PrimaryColumn} from 'typeorm';
+import {TypeOrmDataSourceHelper, TypeOrmDataSourceManager, TypeOrmLoadEntityByIdPipelineStep} from '../../src';
+
+const logger = createLogger();
+const config = createConfig(logger);
+
+// decorators are leading syntax errors in ide, since the test folder is not included in tsconfig.json
+// but the tricky thing is, once test folder included into tsconfig.json, d.ts files will be created in src folder
+// which cause currently use ts-ignore to avoid this syntax errors
+// @ts-ignore
+@Entity({name: 'T_TEST_TABLE'})
+export class TestTable {
+	// @ts-ignore
+	@PrimaryColumn('bigint', {name: 'ID'})
+	id: number;
+	// @ts-ignore
+	@Column('varchar', {name: 'CONTENT'})
+	content: string;
+}
+
+describe('TypeORM Entity Suite', () => {
+	beforeAll(async () => {
+		process.env.CFG_TYPEORM_TEST_TYPE = 'better-sqlite3';
+		process.env.CFG_TYPEORM_TEST_SYNCHRONIZE = 'true';
+		// in memory, kept in global cache, to make sure always use same one.
+		process.env.CFG_TYPEORM_TEST_KEPT_ON_GLOBAL = 'true';
+		await new TypeOrmDataSourceHelper(config).create({
+			'TEST': [TestTable]
+		});
+		const repo = (await TypeOrmDataSourceManager.findDataSource('TEST')).getDataSource().getRepository(TestTable);
+		await repo.insert({id: 1, content: 'hello world!'});
+	});
+
+	test('TypeORM load entity by id Pipeline Step Test #1', async () => {
+		const step = new TypeOrmLoadEntityByIdPipelineStep({
+			config, logger, dataSourceName: 'TEST', entityName: 'TestTable',
+			autonomous: true
+		});
+		const request = {content: 1};
+		const response = await step.perform(request);
+		expect(response.content).not.toBeNull();
+		expect(response.content.id).toBe(1);
+		expect(response.content.content).toBe('hello world!');
+	});
+
+	afterAll((done) => {
+		done();
+	});
+});

package/tsconfig.json

@@ -0,0 +1,36 @@
+{
+	"compilerOptions": {
+		"baseUrl": ".",
+		"outDir": "./dist",
+		"declarationDir": "./lib",
+		"module": "ES2020",
+		"target": "ESNext",
+		"moduleResolution": "node",
+		"sourceMap": true,
+		// create d.ts file
+		"declaration": true,
+		"removeComments": true,
+		"noImplicitAny": false,
+		"allowSyntheticDefaultImports": true,
+		"allowUnreachableCode": true,
+		"allowUnusedLabels": false,
+		"alwaysStrict": true,
+		"allowJs": true,
+		"experimentalDecorators": true,
+		"lib": [
+			"es5",
+			"es2015",
+			"es2016",
+			"es2017",
+			"es2018",
+			"dom"
+		]
+	},
+	"include": [
+		"src/**/*"
+	],
+	"exclude": [
+		"node_modules",
+		"dist"
+	]
+}