@diia-inhouse/db 10.8.12 → 12.3.0

package/dist/services/database.js

@@ -1,282 +1,256 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import "../interfaces/dbConfig.js";
+import "../interfaces/mongoStatus.js";
+import { mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets } from "../interfaces/metrics.js";
+import "../interfaces/index.js";
+import mongoose from "mongoose";
+import lodash from "lodash";
+import { Histogram, Observer } from "@diia-inhouse/diia-metrics";
+import { DatabaseError } from "@diia-inhouse/errors";
+import { HttpStatusCode } from "@diia-inhouse/types";
+//#region src/services/database.ts
+const { cloneDeep } = lodash;
+var DatabaseService = class {
+	databaseAdapter;
+	dbConfigs;
+	envService;
+	logger;
+	defaultModelsDir = "models";
+	db = {};
+	dbOperationsHistogram;
+	dbOplogObserver;
+	observerInterval;
+	dbOplog = {};
+	isMonitoringEnabled = false;
+	dbStateCodeToName = {
+		[mongoose.ConnectionStates.disconnected]: "disconnected",
+		[mongoose.ConnectionStates.connected]: "connected",
+		[mongoose.ConnectionStates.connecting]: "connecting",
+		[mongoose.ConnectionStates.disconnecting]: "disconnecting"
+	};
+	/**
+	* https://www.mongodb.com/docs/manual/core/transactions/#read-concern-write-concern-read-preference
+	*/
+	defaultTransactionOptions = { readPreference: "primary" };
+	constructor(databaseAdapter, dbConfigs, envService, logger) {
+		this.databaseAdapter = databaseAdapter;
+		this.dbConfigs = dbConfigs;
+		this.envService = envService;
+		this.logger = logger;
+		this.isMonitoringEnabled = this.dbConfigs.main?.metrics.enabled || false;
+		if (this.isMonitoringEnabled) {
+			this.dbOperationsHistogram = new Histogram("diia_mongodb_operation_seconds", mongodbOperationsAllowedFields, "Mongodb operation duration in seconds", this.dbConfigs.main?.metrics.buckets || mongodbOperationsDefaultBuckets);
+			this.dbOplogObserver = new Observer("diia_mongodb_oplog_cache_size", [], "Amount of operations stored in in-memory cache for monitoring");
+		}
+	}
+	async onInit() {
+		if (this.databaseAdapter !== "mongo") return;
+		const tasks = Object.entries(this.dbConfigs).map(async ([type, config]) => {
+			const dbType = type;
+			const connection = await this.createDbConnection(dbType, config);
+			if (connection) this.db[dbType] = connection;
+		});
+		await Promise.all(tasks);
+		if (this.isMonitoringEnabled) this.observerInterval = setInterval(() => {
+			this.oplogObserver();
+		}, 5e3);
+	}
+	async onDestroy() {
+		if (this.isMonitoringEnabled) clearInterval(this.observerInterval);
+		for (const db of Object.values(this.db)) await db.connection.close();
+	}
+	async onHealthCheck() {
+		const dbStatus = {};
+		for (const [type, db] of Object.entries(this.db)) {
+			const dbType = type;
+			try {
+				await db.connection.db?.listCollections({}, {
+					nameOnly: true,
+					authorizedCollections: true
+				}).toArray();
+			} catch (err) {
+				this.logger.error("Mongo list collections error", {
+					err,
+					dbType
+				});
+				dbStatus[dbType] = "op_failed";
+				continue;
+			}
+			dbStatus[dbType] = this.dbStateCodeToName[db.connection.readyState];
+		}
+		return {
+			status: Object.values(dbStatus).some((s) => s !== "connected") ? HttpStatusCode.SERVICE_UNAVAILABLE : HttpStatusCode.OK,
+			details: { mongodb: dbStatus }
+		};
+	}
+	async createDbConnection(type, config) {
+		const { isEnabled } = config;
+		if (typeof isEnabled === "boolean" && !isEnabled) {
+			this.logger.info(`Database is disabled: ${type}`);
+			return;
+		}
+		try {
+			const { host, port, database, authSource, user, password, replicaSet, replicaSetNodes, readPreference, authMechanism } = config;
+			const connectionOptions = {};
+			let hosts = [];
+			if (host) if (port) hosts.push(`${host}:${port}`);
+			else hosts.push(host);
+			if (user && password) connectionOptions.auth = {
+				username: user,
+				password
+			};
+			if (replicaSet) connectionOptions.replicaSet = replicaSet;
+			if (replicaSetNodes) {
+				if (host) {
+					const errMsg = "Must be only `host` and `port` or `replicaSetNodes` config";
+					this.logger.error("Wrong database configuration:", errMsg);
+					throw new Error(errMsg);
+				}
+				hosts = replicaSetNodes.map(({ replicaHost }) => `${replicaHost}:${port}`);
+			}
+			let connectionString = `mongodb://${hosts.join(",")}/`;
+			if (database) connectionOptions.dbName = database;
+			const query = [];
+			if (authSource) query.push(`authSource=${authSource}`);
+			if (readPreference) query.push(`readPreference=${readPreference}`);
+			if (authMechanism) query.push(`authMechanism=${authMechanism}`);
+			if (query.length > 0) connectionString += `?${query.join("&")}`;
+			const logOptions = cloneDeep(connectionOptions);
+			if (logOptions.auth) logOptions.auth = {
+				username: "********",
+				password: "********"
+			};
+			this.logger.info(`Connecting to DB ${connectionString} ${type}`, logOptions);
+			if (this.envService.isLocal() || this.envService.isTest()) {
+				this.logger.debug("Mongoose set to Debug");
+				mongoose.set("debug", (coll, method, dbQuery, doc, options) => {
+					this.logger.debug("Mongo: ", {
+						coll,
+						method,
+						query: dbQuery,
+						doc,
+						options
+					});
+				});
+			}
+			let connection;
+			if (type === "main") {
+				await mongoose.connect(connectionString, {
+					...connectionOptions,
+					monitorCommands: this.isMonitoringEnabled
+				});
+				connection = mongoose.connection;
+			} else connection = await mongoose.createConnection(connectionString, connectionOptions).asPromise();
+			if (this.isMonitoringEnabled) this.connectMonitor(connection);
+			connection.on("error", (err) => {
+				this.logger.error("Mongo connection error", {
+					err,
+					type
+				});
+			});
+			return {
+				connection,
+				connectionString,
+				connectionOptions
+			};
+		} catch (err) {
+			this.logger.error("Failed to connect to Database", {
+				type,
+				err
+			});
+			throw new DatabaseError("Failed to connect to Database");
+		}
+	}
+	/**
+	* Begins a new MongoDB transaction by starting a session and transaction
+	*
+	* @param options - Optional transaction options to override the default transaction settings
+	* @returns A ClientSession with an active transaction
+	* @throws {DatabaseError} If the database connection is undefined or transaction fails to start
+	*
+	* @remarks
+	* - Uses the main database connection to start the session
+	* - Applies default transaction options (readPreference: primary)
+	* - Will abort transaction and end session if any errors occur during setup
+	*/
+	async beginTransaction(options) {
+		const connection = this.db["main"]?.connection;
+		if (!connection) throw new DatabaseError("Connection is undefined");
+		const session = await connection.startSession();
+		try {
+			const transactionOptions = {
+				...this.defaultTransactionOptions,
+				...options
+			};
+			session.startTransaction(transactionOptions);
+			return session;
+		} catch (err) {
+			await session.abortTransaction();
+			await session.endSession();
+			throw new DatabaseError("Unable to begin transaction", { err });
+		}
+	}
+	connectMonitor(connection) {
+		try {
+			const client = connection.getClient();
+			client.on("commandStarted", (event) => {
+				const db = event.databaseName;
+				const opType = event.commandName;
+				const key = `${event.requestId}${event.connectionId}`;
+				const parsedCollection = Number.parseInt(event.command[opType] || "", 10);
+				const collection = Number.isNaN(parsedCollection) ? event.command[opType] : void 0;
+				this.dbOplog[key] = {
+					database: db,
+					collection,
+					opType
+				};
+				this.logger.debug("Mongodb commandStarted operation", {
+					database: db,
+					collection,
+					operation: opType,
+					command: event.command
+				});
+			});
+			client.on("commandSucceeded", (event) => {
+				const key = `${event.requestId}${event.connectionId}`;
+				const oplogEntry = this.dbOplog[key];
+				const durationMs = event.duration;
+				delete this.dbOplog[key];
+				this.logger.debug("Mongodb commandSucceeded operation", {
+					database: oplogEntry.database,
+					operation: oplogEntry.opType,
+					collection: oplogEntry.collection
+				});
+				this.dbOperationsHistogram?.observe({
+					operation: oplogEntry.opType,
+					status: "successful",
+					database: oplogEntry.database,
+					...oplogEntry.collection && { collection: oplogEntry.collection }
+				}, durationMs / 1e3);
+			});
+			client.on("commandFailed", (event) => {
+				const key = `${event.requestId}${event.connectionId}`;
+				const oplogEntry = this.dbOplog[key];
+				const durationMs = event.duration;
+				delete this.dbOplog[key];
+				this.logger.debug("Mongodb commandFailed operation", {
+					database: oplogEntry.database,
+					operation: oplogEntry.opType,
+					collection: oplogEntry.collection
+				});
+				this.dbOperationsHistogram?.observe({
+					operation: oplogEntry.opType,
+					status: "failed",
+					database: oplogEntry.database,
+					...oplogEntry.collection && { collection: oplogEntry.collection }
+				}, durationMs / 1e3);
+			});
+		} catch (err) {
+			this.logger.error("Couldn't attach commands monitor", { err });
+		}
+	}
+	oplogObserver() {
+		this.dbOplogObserver?.observe({}, Object.keys(this.dbOplog).length);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatabaseService = void 0;
-const lodash_1 = require("lodash");
-const mongoose_1 = __importDefault(require("mongoose"));
-const diia_metrics_1 = require("@diia-inhouse/diia-metrics");
-const errors_1 = require("@diia-inhouse/errors");
-const types_1 = require("@diia-inhouse/types");
-const interfaces_1 = require("../interfaces");
-class DatabaseService {
-    databaseAdapter;
-    dbConfigs;
-    envService;
-    logger;
-    defaultModelsDir = 'models';
-    db = {};
-    dbOperationsHistogram;
-    dbOplogObserver;
-    observerInterval;
-    dbOplog = {};
-    isMonitoringEnabled = false;
-    dbStateCodeToName = {
-        [mongoose_1.default.ConnectionStates.disconnected]: interfaces_1.DbConnectionStatus.Disconnected,
-        [mongoose_1.default.ConnectionStates.connected]: interfaces_1.DbConnectionStatus.Connected,
-        [mongoose_1.default.ConnectionStates.connecting]: interfaces_1.DbConnectionStatus.Connecting,
-        [mongoose_1.default.ConnectionStates.disconnecting]: interfaces_1.DbConnectionStatus.Disconnecting,
-    };
-    /**
-     * https://www.mongodb.com/docs/manual/core/transactions/#read-concern-write-concern-read-preference
-     */
-    defaultTransactionOptions = {
-        readPreference: 'primary',
-    };
-    constructor(databaseAdapter, dbConfigs, envService, logger) {
-        this.databaseAdapter = databaseAdapter;
-        this.dbConfigs = dbConfigs;
-        this.envService = envService;
-        this.logger = logger;
-        this.isMonitoringEnabled = this.dbConfigs.main?.metrics.enabled || false;
-        if (this.isMonitoringEnabled) {
-            this.dbOperationsHistogram = new diia_metrics_1.Histogram('diia_mongodb_operation_seconds', interfaces_1.mongodbOperationsAllowedFields, 'Mongodb operation duration in seconds', this.dbConfigs.main?.metrics.buckets || interfaces_1.mongodbOperationsDefaultBuckets);
-            this.dbOplogObserver = new diia_metrics_1.Observer('diia_mongodb_oplog_cache_size', [], 'Amount of operations stored in in-memory cache for monitoring');
-        }
-    }
-    async onInit() {
-        if (this.databaseAdapter !== 'mongo') {
-            return;
-        }
-        const tasks = Object.entries(this.dbConfigs).map(async ([type, config]) => {
-            const dbType = type;
-            const connection = await this.createDbConnection(dbType, config);
-            if (connection) {
-                this.db[dbType] = connection;
-            }
-        });
-        await Promise.all(tasks);
-        if (this.isMonitoringEnabled) {
-            this.observerInterval = setInterval(() => {
-                this.oplogObserver();
-            }, 5000);
-        }
-    }
-    async onDestroy() {
-        if (this.isMonitoringEnabled) {
-            clearInterval(this.observerInterval);
-        }
-        for (const db of Object.values(this.db)) {
-            await db.connection.close();
-        }
-    }
-    async onHealthCheck() {
-        const dbStatus = {};
-        for (const [type, db] of Object.entries(this.db)) {
-            const dbType = type;
-            try {
-                await db.connection.db
-                    ?.listCollections({}, {
-                    nameOnly: true,
-                    authorizedCollections: true,
-                })
-                    .toArray();
-            }
-            catch (err) {
-                this.logger.error('Mongo list collections error', { err, dbType });
-                dbStatus[dbType] = interfaces_1.DbConnectionStatus.OpFailed;
-                continue;
-            }
-            dbStatus[dbType] = this.dbStateCodeToName[db.connection.readyState];
-        }
-        const status = Object.values(dbStatus).some((s) => s !== interfaces_1.DbConnectionStatus.Connected)
-            ? types_1.HttpStatusCode.SERVICE_UNAVAILABLE
-            : types_1.HttpStatusCode.OK;
-        return {
-            status,
-            details: { mongodb: dbStatus },
-        };
-    }
-    async createDbConnection(type, config) {
-        const { isEnabled } = config;
-        if (typeof isEnabled === 'boolean' && !isEnabled) {
-            this.logger.info(`Database is disabled: ${type}`);
-            return;
-        }
-        try {
-            const { host, port, database, authSource, user, password, replicaSet, replicaSetNodes, readPreference, authMechanism } = config;
-            const connectionOptions = {};
-            let hosts = [];
-            if (host) {
-                if (port) {
-                    hosts.push(`${host}:${port}`);
-                }
-                else {
-                    hosts.push(`${host}`);
-                }
-            }
-            if (user && password) {
-                connectionOptions.auth = { username: user, password };
-            }
-            if (replicaSet) {
-                connectionOptions.replicaSet = replicaSet;
-            }
-            if (replicaSetNodes) {
-                if (host) {
-                    const errMsg = 'Must be only `host` and `port` or `replicaSetNodes` config';
-                    this.logger.error('Wrong database configuration:', errMsg);
-                    throw new Error(errMsg);
-                }
-                hosts = replicaSetNodes.map(({ replicaHost }) => `${replicaHost}:${port}`);
-            }
-            let connectionString = `mongodb://${hosts.join(',')}/`;
-            if (database) {
-                connectionOptions.dbName = database;
-            }
-            const query = [];
-            if (authSource) {
-                query.push(`authSource=${authSource}`);
-            }
-            if (readPreference) {
-                query.push(`readPreference=${readPreference}`);
-            }
-            if (authMechanism) {
-                query.push(`authMechanism=${authMechanism}`);
-            }
-            if (query.length > 0) {
-                connectionString += `?${query.join('&')}`;
-            }
-            const logOptions = (0, lodash_1.cloneDeep)(connectionOptions);
-            if (logOptions.auth) {
-                logOptions.auth = {
-                    username: '********',
-                    password: '********',
-                };
-            }
-            this.logger.info(`Connecting to DB ${connectionString} ${type}`, logOptions);
-            if (this.envService.isLocal() || this.envService.isTest()) {
-                this.logger.debug('Mongoose set to Debug');
-                mongoose_1.default.set('debug', (coll, method, dbQuery, doc, options) => {
-                    this.logger.debug('Mongo: ', { coll, method, query: dbQuery, doc, options });
-                });
-            }
-            let connection;
-            if (type === interfaces_1.DbType.Main) {
-                await mongoose_1.default.connect(connectionString, { ...connectionOptions, monitorCommands: this.isMonitoringEnabled });
-                connection = mongoose_1.default.connection;
-            }
-            else {
-                connection = await mongoose_1.default.createConnection(connectionString, connectionOptions).asPromise();
-            }
-            if (this.isMonitoringEnabled) {
-                this.connectMonitor(connection);
-            }
-            connection.on('error', (err) => {
-                this.logger.error('Mongo connection error', { err, type });
-            });
-            return { connection, connectionString, connectionOptions };
-        }
-        catch (err) {
-            this.logger.error('Failed to connect to Database', { type, err });
-            throw new errors_1.DatabaseError('Failed to connect to Database');
-        }
-    }
-    /**
-     * Begins a new MongoDB transaction by starting a session and transaction
-     *
-     * @param options - Optional transaction options to override the default transaction settings
-     * @returns A ClientSession with an active transaction
-     * @throws {DatabaseError} If the database connection is undefined or transaction fails to start
-     *
-     * @remarks
-     * - Uses the main database connection to start the session
-     * - Applies default transaction options (readPreference: primary)
-     * - Will abort transaction and end session if any errors occur during setup
-     */
-    async beginTransaction(options) {
-        const connection = this.db[interfaces_1.DbType.Main]?.connection;
-        if (!connection) {
-            throw new errors_1.DatabaseError('Connection is undefined');
-        }
-        const session = await connection.startSession();
-        try {
-            const transactionOptions = {
-                ...this.defaultTransactionOptions,
-                ...options,
-            };
-            session.startTransaction(transactionOptions);
-            return session;
-        }
-        catch (err) {
-            await session.abortTransaction();
-            await session.endSession();
-            throw new errors_1.DatabaseError('Unable to begin transaction', { err });
-        }
-    }
-    connectMonitor(connection) {
-        try {
-            const client = connection.getClient();
-            client.on('commandStarted', (event) => {
-                const db = event.databaseName;
-                const opType = event.commandName;
-                const key = `${event.requestId}${event.connectionId}`;
-                const parsedCollection = Number.parseInt(event.command[opType] || '', 10);
-                const collection = Number.isNaN(parsedCollection) ? event.command[opType] : undefined;
-                this.dbOplog[key] = {
-                    database: db,
-                    collection,
-                    opType,
-                };
-                this.logger.debug('Mongodb commandStarted operation', {
-                    database: db,
-                    collection,
-                    operation: opType,
-                    command: event.command,
-                });
-            });
-            client.on('commandSucceeded', (event) => {
-                const key = `${event.requestId}${event.connectionId}`;
-                const oplogEntry = this.dbOplog[key];
-                const durationMs = event.duration;
-                delete this.dbOplog[key];
-                this.logger.debug('Mongodb commandSucceeded operation', {
-                    database: oplogEntry.database,
-                    operation: oplogEntry.opType,
-                    collection: oplogEntry.collection,
-                });
-                this.dbOperationsHistogram?.observe({
-                    operation: oplogEntry.opType,
-                    status: interfaces_1.MongodbOperationResult.Successful,
-                    database: oplogEntry.database,
-                    ...(oplogEntry.collection && { collection: oplogEntry.collection }),
-                }, durationMs / 1000);
-            });
-            client.on('commandFailed', (event) => {
-                const key = `${event.requestId}${event.connectionId}`;
-                const oplogEntry = this.dbOplog[key];
-                const durationMs = event.duration;
-                delete this.dbOplog[key];
-                this.logger.debug('Mongodb commandFailed operation', {
-                    database: oplogEntry.database,
-                    operation: oplogEntry.opType,
-                    collection: oplogEntry.collection,
-                });
-                this.dbOperationsHistogram?.observe({
-                    operation: oplogEntry.opType,
-                    status: interfaces_1.MongodbOperationResult.Failed,
-                    database: oplogEntry.database,
-                    ...(oplogEntry.collection && { collection: oplogEntry.collection }),
-                }, durationMs / 1000);
-            });
-        }
-        catch (err) {
-            this.logger.error("Couldn't attach commands monitor", { err });
-        }
-    }
-    oplogObserver() {
-        this.dbOplogObserver?.observe({}, Object.keys(this.dbOplog).length);
-    }
-}
-exports.DatabaseService = DatabaseService;
-//# sourceMappingURL=database.js.map
+//#endregion
+export { DatabaseService };

package/dist/services/encryptedStorage.d.ts

@@ -0,0 +1,73 @@
+import { DatabaseAdapterType, PostgresDatabase } from "../interfaces/database.js";
+import { EncryptedStorage } from "../interfaces/models/encryptedStorage.js";
+import { Model, QueryOptions } from "mongoose";
+import { Logger } from "@diia-inhouse/types";
+import { EnvService } from "@diia-inhouse/env";
+import { AuthService } from "@diia-inhouse/crypto";
+
+//#region src/services/encryptedStorage.d.ts
+/**
+* EncryptedStorageService provides CRUD operations for managing encrypted storage entries
+* in both Postgres and MongoDB databases. The service abstracts database implementation details
+* using a strategy pattern depending on the configured database adapter type.
+*
+* Suitable for storing and managing sensitive data in an encrypted manner with specific expiration time.
+*
+* This service should be wrapped in a repository.
+*
+* Register this service in the DI container with the following (MongoDB) configuration (AuthService is located in @diia-inhouse/crypto):
+* ```typescript
+* // src/deps.ts
+* encryptedStorage: asClass(EncryptedStorageService, { injector: () => ({ encryptedStorageModel }) }).singleton(),
+* auth: asClass(AuthService, { injector: () => ({ authConfig: config.auth }) }).singleton()
+* ```
+*
+* ```typescript
+* // src/config.ts
+* auth: {
+*     jwk: await envService.getSecret('JWE_SECRET_DATA_JWK'),
+* }
+* ```
+*
+* ```typescript
+* // src/models/encryptedStorage.ts
+* import { EncryptedStorage, Model, encryptedStorageSchema, model, models } from '@diia-inhouse/db'
+*
+* export default (models.EncryptedStorage as Model<EncryptedStorage>) || model('EncryptedStorage', encryptedStorageSchema)
+* ```
+*
+* Use the following command to generate a JWE secret data JWK:
+* node -e "const crypto = require('crypto'); const { privateKey } = crypto.generateKeyPairSync('rsa', { modulusLength: 2048 }); const jwk = privateKey.export({ format: 'jwk' }); jwk.use = 'enc'; console.log(JSON.stringify(jwk));"
+* ```typescript
+* // .env.example
+* JWE_SECRET_DATA_JWK={your-jwk-here}
+* ```
+*/
+declare class EncryptedStorageService {
+  private readonly logger;
+  private readonly auth;
+  private readonly envService;
+  private readonly databaseAdapter;
+  private readonly encryptedStorageModel;
+  private readonly postgresDatabase;
+  private readonly saveEntityStrategy;
+  private readonly updateEntityStrategy;
+  private readonly findEntityStrategy;
+  private readonly deleteManyStrategy;
+  private readonly removeEntityStrategy;
+  private readonly findExpirationStrategy;
+  constructor(logger: Logger, auth: AuthService, envService: EnvService, databaseAdapter: DatabaseAdapterType, encryptedStorageModel?: Model<EncryptedStorage> | null, postgresDatabase?: PostgresDatabase | null);
+  save<T>(data: T, expiration: number): Promise<string>;
+  get<T>(id: string, options?: QueryOptions): Promise<T>;
+  getSafe<T>(id: string, options?: QueryOptions): Promise<T | undefined>;
+  update<T>(id: string, data: T): Promise<void>;
+  remove(id: string): Promise<void>;
+  deleteMany(ids: string[]): Promise<void>;
+  setExpiration(id: string, expiration: number): Promise<void>;
+  getExpiration(id: string): Promise<Date>;
+  private getStorageItemById;
+  private getModel;
+  private getPostgresDatabase;
+}
+//#endregion
+export { EncryptedStorageService };