@diia-inhouse/test 7.3.23 → 8.0.0

package/dist/dbUtilsBuilder.d.ts

@@ -0,0 +1,29 @@
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+//#region src/dbUtilsBuilder.d.ts
+type DatabaseAdapterType = "mongo" | "postgres";
+type DbUtils<TFactory extends Record<string, (data?: any) => any>, TEntitySchema extends { [K in keyof TFactory]: ReturnType<TFactory[K]> }, TEntityName extends keyof TEntitySchema & keyof TFactory & string, TDbReference extends Partial<Record<TEntityName, Partial<Record<DatabaseAdapterType, any>>>>, TSavableEntity extends keyof TDbReference> = { [K in TEntityName]: {
+  seed: {
+    make: (data?: Partial<TEntitySchema[K]>) => TEntitySchema[K];
+    many: (count: number) => {
+      make: (data?: Partial<TEntitySchema[K]>) => TEntitySchema[K][];
+    } & (K extends TSavableEntity ? {
+      save: (data?: Partial<TEntitySchema[K]>) => Promise<TEntitySchema[K][]>;
+    } : {});
+  } & (K extends TSavableEntity ? {
+    save: (data?: Partial<TEntitySchema[K]>) => Promise<TEntitySchema[K]>;
+  } : {});
+} & (K extends TSavableEntity ? {
+  cleanupBy: <P extends keyof TEntitySchema[K]>(by: P, values: TEntitySchema[K][P][]) => Promise<TEntitySchema[K][]>;
+  updateBy: <P extends keyof TEntitySchema[K]>(by: P, values: TEntitySchema[K][P][], data: Partial<TEntitySchema[K]>) => Promise<TEntitySchema[K][]>;
+} : {}) };
+type DbUtilsParams = {
+  databaseAdapter: DatabaseAdapterType;
+  db?: NodePgDatabase<Record<string, unknown>>;
+};
+declare function buildDbUtilsFn<TFactory extends Record<string, (data?: any) => any>, TEntitySchema extends { [K in keyof TFactory]: ReturnType<TFactory[K]> }, TEntityName extends keyof TEntitySchema & keyof TFactory & string, TDbReference extends Partial<Record<TEntityName, Partial<Record<DatabaseAdapterType, any>>>>, TSavableEntity extends keyof TDbReference>(factories: TFactory, references: TDbReference): ({
+  databaseAdapter,
+  db
+}: DbUtilsParams) => DbUtils<TFactory, TEntitySchema, TEntityName, TDbReference, TSavableEntity>;
+//#endregion
+export { buildDbUtilsFn };

package/dist/dbUtilsBuilder.js

@@ -1,116 +1,83 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDbUtilsFn = buildDbUtilsFn;
-/* eslint-disable @typescript-eslint/explicit-function-return-type */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const drizzle_orm_1 = require("drizzle-orm");
+import { inArray } from "drizzle-orm";
+//#region src/dbUtilsBuilder.ts
 function buildDbUtilsFn(factories, references) {
-    return ({ databaseAdapter, db }) => {
-        function seedOne(entity) {
-            const generator = factories[entity];
-            return {
-                make: (data) => {
-                    return generator(data);
-                },
-                save: async (data) => {
-                    const value = generator(data);
-                    if (databaseAdapter === 'postgres') {
-                        if (!db) {
-                            throw new Error('Postgres database is not provided');
-                        }
-                        const pgTable = references[entity]?.postgres;
-                        if (!pgTable) {
-                            throw new Error(`No postgres reference for ${entity}`);
-                        }
-                        const saved = await db.insert(pgTable).values(value).returning();
-                        return saved[0];
-                    }
-                    const model = references[entity]?.mongo;
-                    if (!model?.create) {
-                        throw new Error(`No mongo reference for ${entity}`);
-                    }
-                    const saved = await model.create(value);
-                    return saved;
-                },
-            };
-        }
-        function seedMany(count, entity) {
-            const generator = factories[entity];
-            return {
-                make: (data) => {
-                    const values = Array.from({ length: count }).map(() => generator(data));
-                    return values;
-                },
-                save: async (data) => {
-                    const values = Array.from({ length: count }).map(() => generator(data));
-                    if (databaseAdapter === 'postgres') {
-                        if (!db) {
-                            throw new Error('Postgres database is not provided');
-                        }
-                        const pgTable = references[entity]?.postgres;
-                        if (!pgTable) {
-                            throw new Error(`No postgres reference for ${entity}`);
-                        }
-                        const saved = await db.insert(pgTable).values(values).returning();
-                        return saved;
-                    }
-                    const model = references[entity]?.mongo;
-                    if (!model?.create) {
-                        throw new Error(`No mongo reference for ${entity}`);
-                    }
-                    const saved = await model.create(values);
-                    return saved;
-                },
-            };
-        }
-        async function cleanupBy(entity, by, values) {
-            if (databaseAdapter === 'postgres') {
-                if (!db) {
-                    throw new Error('Postgres database is not provided');
-                }
-                const pgTable = references[entity]?.postgres;
-                if (!pgTable) {
-                    throw new Error(`No postgres reference for ${entity}`);
-                }
-                const column = pgTable[by];
-                const result = await db.delete(pgTable).where((0, drizzle_orm_1.inArray)(column, values)).returning();
-                return result;
-            }
-            const model = references[entity]?.mongo;
-            if (!model?.find || !model?.deleteMany) {
-                throw new Error(`No mongo reference for ${entity}`);
-            }
-            const deleted = await model.find({ [by === 'id' ? '_id' : by]: { $in: values } });
-            await model.deleteMany({ [by === 'id' ? '_id' : by]: { $in: values } });
-            return deleted;
-        }
-        async function updateBy(entity, by, values, data) {
-            if (databaseAdapter === 'postgres') {
-                if (!db) {
-                    throw new Error('Postgres database is not provided');
-                }
-                const pgTable = references[entity]?.postgres;
-                if (!pgTable) {
-                    throw new Error(`No postgres reference for ${entity}`);
-                }
-                const column = pgTable[by];
-                const result = await db.update(pgTable).set(data).where((0, drizzle_orm_1.inArray)(column, values)).returning();
-                return result;
-            }
-            const model = references[entity]?.mongo;
-            if (!model?.updateMany || !model?.find) {
-                throw new Error(`No mongo reference for ${entity}`);
-            }
-            await model.updateMany({ [by === 'id' ? '_id' : by]: { $in: values } }, { $set: data });
-            return await model.find({ [by === 'id' ? '_id' : by]: { $in: values } });
-        }
-        return new Proxy({}, {
-            get: (_, entity) => ({
-                seed: { ...seedOne(entity), many: (count) => seedMany(count, entity) },
-                cleanupBy: (by, values) => cleanupBy(entity, by, values),
-                updateBy: (by, values, data) => updateBy(entity, by, values, data),
-            }),
-        });
-    };
+	return ({ databaseAdapter, db }) => {
+		function seedOne(entity) {
+			const generator = factories[entity];
+			return {
+				make: (data) => {
+					return generator(data);
+				},
+				save: async (data) => {
+					const value = generator(data);
+					if (databaseAdapter === "postgres") {
+						if (!db) throw new Error("Postgres database is not provided");
+						const pgTable = references[entity]?.postgres;
+						if (!pgTable) throw new Error(`No postgres reference for ${entity}`);
+						return (await db.insert(pgTable).values(value).returning())[0];
+					}
+					const model = references[entity]?.mongo;
+					if (!model?.create) throw new Error(`No mongo reference for ${entity}`);
+					return await model.create(value);
+				}
+			};
+		}
+		function seedMany(count, entity) {
+			const generator = factories[entity];
+			return {
+				make: (data) => {
+					return Array.from({ length: count }).map(() => generator(data));
+				},
+				save: async (data) => {
+					const values = Array.from({ length: count }).map(() => generator(data));
+					if (databaseAdapter === "postgres") {
+						if (!db) throw new Error("Postgres database is not provided");
+						const pgTable = references[entity]?.postgres;
+						if (!pgTable) throw new Error(`No postgres reference for ${entity}`);
+						return await db.insert(pgTable).values(values).returning();
+					}
+					const model = references[entity]?.mongo;
+					if (!model?.create) throw new Error(`No mongo reference for ${entity}`);
+					return await model.create(values);
+				}
+			};
+		}
+		async function cleanupBy(entity, by, values) {
+			if (databaseAdapter === "postgres") {
+				if (!db) throw new Error("Postgres database is not provided");
+				const pgTable = references[entity]?.postgres;
+				if (!pgTable) throw new Error(`No postgres reference for ${entity}`);
+				const column = pgTable[by];
+				return await db.delete(pgTable).where(inArray(column, values)).returning();
+			}
+			const model = references[entity]?.mongo;
+			if (!model?.find || !model?.deleteMany) throw new Error(`No mongo reference for ${entity}`);
+			const deleted = await model.find({ [by === "id" ? "_id" : by]: { $in: values } });
+			await model.deleteMany({ [by === "id" ? "_id" : by]: { $in: values } });
+			return deleted;
+		}
+		async function updateBy(entity, by, values, data) {
+			if (databaseAdapter === "postgres") {
+				if (!db) throw new Error("Postgres database is not provided");
+				const pgTable = references[entity]?.postgres;
+				if (!pgTable) throw new Error(`No postgres reference for ${entity}`);
+				const column = pgTable[by];
+				return await db.update(pgTable).set(data).where(inArray(column, values)).returning();
+			}
+			const model = references[entity]?.mongo;
+			if (!model?.updateMany || !model?.find) throw new Error(`No mongo reference for ${entity}`);
+			await model.updateMany({ [by === "id" ? "_id" : by]: { $in: values } }, { $set: data });
+			return await model.find({ [by === "id" ? "_id" : by]: { $in: values } });
+		}
+		return new Proxy({}, { get: (_, entity) => ({
+			seed: {
+				...seedOne(entity),
+				many: (count) => seedMany(count, entity)
+			},
+			cleanupBy: (by, values) => cleanupBy(entity, by, values),
+			updateBy: (by, values, data) => updateBy(entity, by, values, data)
+		}) });
+	};
 }
-//# sourceMappingURL=dbUtilsBuilder.js.map
+//#endregion
+export { buildDbUtilsFn };

package/dist/documentsGenerator.d.ts

@@ -0,0 +1,8 @@
+import { PartialDeep } from "type-fest";
+
+//#region src/documentsGenerator.d.ts
+declare class DocumentsGenerator {
+  generateDocument<T>(type: string, data?: PartialDeep<T>): T;
+}
+//#endregion
+export { DocumentsGenerator };

package/dist/documentsGenerator.js

@@ -1,22 +1,15 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import documents from "./stubs/documents/index.js";
+import lodash from "lodash";
+//#region src/documentsGenerator.ts
+const { camelCase, cloneDeep, merge } = lodash;
+var DocumentsGenerator = class {
+	generateDocument(type, data) {
+		const document = documents[camelCase(type)];
+		if (!document) throw new Error(`Document ${type} is not supported at the moment. You can generate those documents [${Object.keys(documents).join(", ")}]`);
+		const clone = cloneDeep(document);
+		if (!data) return clone;
+		return merge(clone, data);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-const lodash_1 = require("lodash");
-const documents_1 = __importDefault(require("./stubs/documents"));
-class DocumentsGenerator {
-    generateDocument(type, data) {
-        const document = documents_1.default[(0, lodash_1.camelCase)(type)];
-        if (!document) {
-            throw new Error(`Document ${type} is not supported at the moment. You can generate those documents [${Object.keys(documents_1.default)}]`);
-        }
-        const clone = (0, lodash_1.cloneDeep)(document);
-        if (!data) {
-            return clone;
-        }
-        return (0, lodash_1.merge)(clone, data);
-    }
-}
-exports.default = DocumentsGenerator;
-//# sourceMappingURL=documentsGenerator.js.map
+//#endregion
+export { DocumentsGenerator as default };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import { DocumentsGenerator } from "./documentsGenerator.js";
+import { PublicServiceGenerator } from "./publicServiceGenerator.js";
+import { RandomGenerator } from "./randomGenerator.js";
+import { SessionGenerator } from "./sessionGenerator.js";
+import { buildDbUtilsFn } from "./dbUtilsBuilder.js";
+
+//#region src/index.d.ts
+declare class TestKit {
+  readonly session: SessionGenerator;
+  readonly random: RandomGenerator;
+  readonly docs: DocumentsGenerator;
+  readonly public: PublicServiceGenerator;
+  constructor();
+}
+//#endregion
+export { SessionGenerator, buildDbUtilsFn, TestKit as default };

package/dist/index.js

@@ -1,28 +1,20 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import DocumentsGenerator from "./documentsGenerator.js";
+import PublicServiceGenerator from "./publicServiceGenerator.js";
+import RandomGenerator from "./randomGenerator.js";
+import SessionGenerator from "./sessionGenerator.js";
+import { buildDbUtilsFn } from "./dbUtilsBuilder.js";
+//#region src/index.ts
+var TestKit = class {
+	session;
+	random;
+	docs;
+	public;
+	constructor() {
+		this.random = new RandomGenerator();
+		this.session = new SessionGenerator(this.random);
+		this.docs = new DocumentsGenerator();
+		this.public = new PublicServiceGenerator();
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.buildDbUtilsFn = exports.SessionGenerator = void 0;
-const documentsGenerator_1 = __importDefault(require("./documentsGenerator"));
-const publicServiceGenerator_1 = __importDefault(require("./publicServiceGenerator"));
-const randomGenerator_1 = __importDefault(require("./randomGenerator"));
-const sessionGenerator_1 = __importDefault(require("./sessionGenerator"));
-class TestKit {
-    session;
-    random;
-    docs;
-    public;
-    constructor() {
-        this.random = new randomGenerator_1.default();
-        this.session = new sessionGenerator_1.default(this.random);
-        this.docs = new documentsGenerator_1.default();
-        this.public = new publicServiceGenerator_1.default();
-    }
-}
-exports.default = TestKit;
-var sessionGenerator_2 = require("./sessionGenerator");
-Object.defineProperty(exports, "SessionGenerator", { enumerable: true, get: function () { return __importDefault(sessionGenerator_2).default; } });
-var dbUtilsBuilder_1 = require("./dbUtilsBuilder");
-Object.defineProperty(exports, "buildDbUtilsFn", { enumerable: true, get: function () { return dbUtilsBuilder_1.buildDbUtilsFn; } });
-//# sourceMappingURL=index.js.map
+//#endregion
+export { SessionGenerator, buildDbUtilsFn, TestKit as default };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,6 @@
+//#region src/interfaces/index.d.ts
+interface GetUserActionArgumentsOps {
+  validItn?: boolean;
+}
+//#endregion
+export { GetUserActionArgumentsOps };

package/dist/publicServiceGenerator.d.ts

@@ -0,0 +1,9 @@
+import { PublicServiceContextMenu, PublicServiceSettings } from "@diia-inhouse/design-system";
+
+//#region src/publicServiceGenerator.d.ts
+declare class PublicServiceGenerator {
+  getPublicServiceContextMenu(contextMenuItems?: PublicServiceContextMenu[]): PublicServiceContextMenu[];
+  getPublicServiceSettings(serviceSettings?: Partial<PublicServiceSettings>): PublicServiceSettings;
+}
+//#endregion
+export { PublicServiceGenerator };

package/dist/publicServiceGenerator.js

@@ -1,23 +1,25 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const design_system_1 = require("@diia-inhouse/design-system");
-class PublicServiceGenerator {
-    getPublicServiceContextMenu(contextMenuItems = []) {
-        return [{ type: design_system_1.PublicServiceContextMenuType.faqCategory, name: 'contextItemName' }, ...contextMenuItems];
-    }
-    getPublicServiceSettings(serviceSettings = {}) {
-        return {
-            id: '123',
-            code: 'penalties',
-            name: 'penalties',
-            status: design_system_1.PublicServiceStatus.active,
-            contextMenu: this.getPublicServiceContextMenu(),
-            categories: [],
-            sortOrder: 0,
-            locales: {},
-            ...serviceSettings,
-        };
-    }
-}
-exports.default = PublicServiceGenerator;
-//# sourceMappingURL=publicServiceGenerator.js.map
+import { PublicServiceContextMenuType, PublicServiceStatus } from "@diia-inhouse/design-system";
+//#region src/publicServiceGenerator.ts
+var PublicServiceGenerator = class {
+	getPublicServiceContextMenu(contextMenuItems = []) {
+		return [{
+			type: PublicServiceContextMenuType.faqCategory,
+			name: "contextItemName"
+		}, ...contextMenuItems];
+	}
+	getPublicServiceSettings(serviceSettings = {}) {
+		return {
+			id: "123",
+			code: "penalties",
+			name: "penalties",
+			status: PublicServiceStatus.active,
+			contextMenu: this.getPublicServiceContextMenu(),
+			categories: [],
+			sortOrder: 0,
+			locales: {},
+			...serviceSettings
+		};
+	}
+};
+//#endregion
+export { PublicServiceGenerator as default };

package/dist/randomGenerator.d.ts

@@ -0,0 +1,7 @@
+//#region src/randomGenerator.d.ts
+declare class RandomGenerator {
+  getRandomInt(minParam: number, maxParam: number): number;
+  getRandomIntByLength(length: number): number;
+}
+//#endregion
+export { RandomGenerator };

package/dist/randomGenerator.js

@@ -1,18 +1,14 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-class RandomGenerator {
-    getRandomInt(minParam, maxParam) {
-        const min = Math.ceil(minParam);
-        const max = Math.floor(maxParam);
-        return Math.floor(Math.random() * (max - min + 1) + min);
-    }
-    getRandomIntByLength(length) {
-        let randomNumber = '';
-        for (let i = 0; i < length; i++) {
-            randomNumber += Math.floor(Math.random() * 10);
-        }
-        return Number(randomNumber);
-    }
-}
-exports.default = RandomGenerator;
-//# sourceMappingURL=randomGenerator.js.map
+import { randomInt } from "node:crypto";
+//#region src/randomGenerator.ts
+var RandomGenerator = class {
+	getRandomInt(minParam, maxParam) {
+		return randomInt(Math.ceil(minParam), Math.floor(maxParam) + 1);
+	}
+	getRandomIntByLength(length) {
+		let randomNumber = "";
+		for (let i = 0; i < length; i++) randomNumber += randomInt(10);
+		return Number(randomNumber);
+	}
+};
+//#endregion
+export { RandomGenerator as default };

package/dist/sessionGenerator.d.ts

@@ -0,0 +1,37 @@
+import { RandomGenerator } from "./randomGenerator.js";
+import { GetUserActionArgumentsOps } from "./interfaces/index.js";
+import { AcquirerSession, AcquirerTokenData, ActionSession, AppUserActionHeaders, AuthEntryPoint, DiiaOfficeUserSession, EResidentApplicantSession, EResidentApplicantTokenData, EResidentSession, EResidentTokenData, Gender, PartnerSession, PartnerTokenData, PortalUserSession, PortalUserTokenData, ServiceEntranceSession, ServiceEntranceTokenData, ServiceUserSession, ServiceUserTokenData, SessionType, TemporarySession, TemporaryTokenData, UserActionArguments, UserSession, UserTokenData } from "@diia-inhouse/types";
+
+//#region src/sessionGenerator.d.ts
+declare class SessionGenerator {
+  private readonly random;
+  private readonly dateFormat;
+  constructor(random: RandomGenerator);
+  getUserActionArguments(user?: Partial<UserTokenData>, headers?: Partial<AppUserActionHeaders>, ops?: GetUserActionArgumentsOps): UserActionArguments;
+  getAuthEntryPoint(authEntryPoint?: Partial<AuthEntryPoint>): AuthEntryPoint;
+  getUserSession(tokenData?: Partial<UserTokenData>, validItn?: boolean): UserSession;
+  getDiiaOfficeUserSession(tokenData?: Partial<UserTokenData>, validItn?: boolean, features?: Record<string, unknown>): DiiaOfficeUserSession;
+  getEResidentSession(tokenData?: Partial<EResidentTokenData>, validItn?: boolean): EResidentSession;
+  getEResidentApplicantSession(tokenData?: Partial<EResidentApplicantTokenData>): EResidentApplicantSession;
+  /** @deprecated use getAcquirerSessionStringId after diia-app v15 */
+  getAcquirerSession(tokenData?: Partial<AcquirerTokenData>): AcquirerSession;
+  getAcquirerSessionStringId(tokenData?: Partial<AcquirerTokenData>): AcquirerSession;
+  /** @deprecated use getPartnerSessionStringId after diia-app v15 */
+  getPartnerSession(tokenData?: Partial<PartnerTokenData>): PartnerSession;
+  getPartnerSessionStringId(tokenData?: Partial<PartnerTokenData>): PartnerSession;
+  getTemporarySession(tokenData?: Partial<TemporaryTokenData>): TemporarySession;
+  getServiceEntranceSession(tokenData?: Partial<ServiceEntranceTokenData>): ServiceEntranceSession;
+  getPortalUserSession(tokenData?: Partial<PortalUserTokenData>, validItn?: boolean): PortalUserSession;
+  getServiceUserSession(tokenData?: Partial<ServiceUserTokenData>): ServiceUserSession;
+  getSessionBySessionType(sessionType: SessionType, tokenData?: {}, validItn?: boolean): ActionSession | undefined;
+  getHeaders(headers?: Partial<AppUserActionHeaders>): AppUserActionHeaders;
+  getBirthDate(): string;
+  getGender(): Gender;
+  generateItn(birthDate: string, gender: Gender, validItn: boolean): string;
+  private getUserData;
+  private getItnSeqNumber;
+  private isOdd;
+  private createIdentifier;
+}
+//#endregion
+export { SessionGenerator };