@diia-inhouse/db 10.8.12 → 12.3.0

package/dist/mongo.d.ts

@@ -0,0 +1,12 @@
+import { MigrateMongoConfig } from "./interfaces/migrateMongoConfig.js";
+//#region src/mongo.d.ts
+declare const MongoHelper: {
+  getMigrateMongoConfig(): Promise<MigrateMongoConfig>;
+  buildMongoUrl(user: string | null, password: string | null): string;
+  getMongoErrorDupField(msg: string, fields: string[]): string | undefined;
+  handleMongoUniqError(err: Error & {
+    code?: number;
+  }, params: Record<string, unknown>, uniqFieldNames: string[], modelName: string): void;
+};
+//#endregion
+export { MongoHelper };

package/dist/mongo.js

@@ -1,90 +1,72 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import "./interfaces/errors.js";
+import "./interfaces/index.js";
+import { DatabaseError, UnprocessableEntityError } from "@diia-inhouse/errors";
+import { DiiaLogger } from "@diia-inhouse/diia-logger";
+import { EnvService } from "@diia-inhouse/env";
+//#region src/mongo.ts
+const MongoHelper = {
+	async getMigrateMongoConfig() {
+		const logger = new DiiaLogger();
+		const envService = new EnvService(logger);
+		await envService.init();
+		const originalExit = process.exit.bind(process);
+		process.exit = (code) => {
+			logger.info("Destroying the Env service on process exit...", { code });
+			return envService.onDestroy().then(() => {
+				logger.info("Env service destroyed, exiting the process...", { code });
+				return originalExit(code);
+			}).catch((err) => {
+				logger.error("Env service destroy error", { err });
+				originalExit(code);
+			});
+		};
+		const user = await envService.getSecret("MONGO_USER", {
+			accessor: "username",
+			nullable: true
+		});
+		const password = await envService.getSecret("MONGO_PASSWORD", {
+			accessor: "password",
+			nullable: true
+		});
+		return {
+			mongodb: {
+				url: this.buildMongoUrl(user, password),
+				databaseName: `${process.env.MONGO_DATABASE}`
+			},
+			migrationsDir: "migrations",
+			changelogCollectionName: "migrations",
+			migrationFileExtension: ".ts",
+			useFileHash: false,
+			moduleSystem: "commonjs"
+		};
+	},
+	buildMongoUrl(user, password) {
+		let mongoUrl = "mongodb://";
+		if (user && password) mongoUrl += `${user}:${password}@`;
+		mongoUrl += `${process.env.MONGO_HOST}:${process.env.MONGO_PORT}/`;
+		if (process.env.MONGO_AUTH_SOURCE) mongoUrl += process.env.MONGO_AUTH_SOURCE;
+		const query = [];
+		if (process.env.MONGO_REPLICA_SET) query.push(`replicaSet=${process.env.MONGO_REPLICA_SET}`);
+		if (process.env.MONGO_AUTH_MECHANISM) query.push(`authMechanism=${process.env.MONGO_AUTH_MECHANISM}`);
+		if (query.length > 0) mongoUrl += `?${query.join("&")}`;
+		return mongoUrl;
+	},
+	getMongoErrorDupField(msg, fields) {
+		for (const field of fields) if (new RegExp(`${field}_[0-9] dup key`).test(msg)) return field;
+	},
+	handleMongoUniqError(err, params, uniqFieldNames, modelName) {
+		if (err.name === "MongoError" && err.code === 11e3) {
+			const field = MongoHelper.getMongoErrorDupField(err.message, uniqFieldNames);
+			if (field) throw new UnprocessableEntityError(`${modelName} with ${field} '${String(params[field])}' already exists`, {
+				field,
+				message: `${field} field unique constraint`,
+				type: "unique",
+				value: params[field]
+			});
+			throw new Error(`Unexpected error while entity processing. ${err.message}`);
+		}
+		throw new DatabaseError(err.toString());
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MongoHelper = void 0;
-const diia_logger_1 = __importDefault(require("@diia-inhouse/diia-logger"));
-const env_1 = require("@diia-inhouse/env");
-const errors_1 = require("@diia-inhouse/errors");
-const interfaces_1 = require("./interfaces");
-exports.MongoHelper = {
-    async getMigrateMongoConfig() {
-        const logger = new diia_logger_1.default();
-        const envService = new env_1.EnvService(logger);
-        await envService.init();
-        const originalExit = process.exit;
-        process.exit = (code) => {
-            logger.info('Destroying the Env service on process exit...', { code });
-            return envService
-                .onDestroy()
-                .then(() => {
-                logger.info('Env service destroyed, exiting the process...', { code });
-                return originalExit(code);
-            })
-                .catch((err) => {
-                logger.error('Env service destroy error', { err });
-                originalExit(code);
-            });
-        };
-        const user = await envService.getSecret('MONGO_USER', { accessor: 'username', nullable: true });
-        const password = await envService.getSecret('MONGO_PASSWORD', { accessor: 'password', nullable: true });
-        return {
-            mongodb: {
-                url: this.buildMongoUrl(user, password),
-                databaseName: `${process.env.MONGO_DATABASE}`,
-            },
-            migrationsDir: 'migrations',
-            changelogCollectionName: 'migrations',
-            migrationFileExtension: '.ts',
-            useFileHash: false,
-            moduleSystem: 'commonjs',
-        };
-    },
-    buildMongoUrl(user, password) {
-        let mongoUrl = 'mongodb://';
-        if (user && password) {
-            mongoUrl += `${user}:${password}@`;
-        }
-        mongoUrl += `${process.env.MONGO_HOST}:${process.env.MONGO_PORT}/`;
-        if (process.env.MONGO_AUTH_SOURCE) {
-            mongoUrl += process.env.MONGO_AUTH_SOURCE;
-        }
-        const query = [];
-        if (process.env.MONGO_REPLICA_SET) {
-            query.push(`replicaSet=${process.env.MONGO_REPLICA_SET}`);
-        }
-        if (process.env.MONGO_AUTH_MECHANISM) {
-            query.push(`authMechanism=${process.env.MONGO_AUTH_MECHANISM}`);
-        }
-        if (query.length > 0) {
-            mongoUrl += `?${query.join('&')}`;
-        }
-        return mongoUrl;
-    },
-    getMongoErrorDupField(msg, fields) {
-        for (const field of fields) {
-            // eslint-disable-next-line security/detect-non-literal-regexp
-            const fieldRegExp = new RegExp(`${field}_[0-9] dup key`); // nosemgrep: eslint.detect-non-literal-regexp
-            if (fieldRegExp.test(msg)) {
-                return field;
-            }
-        }
-    },
-    handleMongoUniqError(err, params, uniqFieldNames, modelName) {
-        if (err.name === 'MongoError' && err.code === interfaces_1.MongoDBErrorCode.DuplicateKey) {
-            const field = exports.MongoHelper.getMongoErrorDupField(err.message, uniqFieldNames);
-            if (field) {
-                throw new errors_1.UnprocessableEntityError(`${modelName} with ${field} '${params[field]}' already exists`, {
-                    field,
-                    message: `${field} field unique constraint`,
-                    type: 'unique',
-                    value: params[field],
-                });
-            }
-            throw new Error(`Unexpected error while entity processing. ${err.message}`);
-        }
-        throw new errors_1.DatabaseError(err.toString());
-    },
-};
-//# sourceMappingURL=mongo.js.map
+//#endregion
+export { MongoHelper };

package/dist/postgres.d.ts

@@ -0,0 +1,4 @@
+import { counter } from "./tables/counter.js";
+import { encryptedStorage } from "./tables/encryptedStorage.js";
+import { expiringTimestamp, timestamps } from "./postgresUtils.js";
+export { counter, encryptedStorage, expiringTimestamp, timestamps };

package/dist/postgres.js

@@ -1,19 +1,5 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./tables"), exports);
-__exportStar(require("./postgresUtils"), exports);
-//# sourceMappingURL=postgres.js.map
+import { expiringTimestamp, timestamps } from "./postgresUtils.js";
+import { encryptedStorage } from "./tables/encryptedStorage.js";
+import { counter } from "./tables/counter.js";
+import "./tables/index.js";
+export { counter, encryptedStorage, expiringTimestamp, timestamps };

package/dist/postgresUtils.d.ts

@@ -0,0 +1,8 @@
+//#region src/postgresUtils.d.ts
+declare const timestamps: {
+  createdAt: any;
+  updatedAt: any;
+};
+declare const expiringTimestamp: any;
+//#endregion
+export { expiringTimestamp, timestamps };

package/dist/postgresUtils.js

@@ -1,20 +1,16 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.expiringTimestamp = exports.timestamps = void 0;
-const pg_core_1 = require("drizzle-orm/pg-core");
-exports.timestamps = {
-    createdAt: (0, pg_core_1.timestamp)('created_at').defaultNow().notNull(),
-    updatedAt: (0, pg_core_1.timestamp)('updated_at')
-        .defaultNow()
-        .$onUpdate(() => new Date())
-        .notNull(),
+import { customType, timestamp } from "drizzle-orm/pg-core";
+//#region src/postgresUtils.ts
+const timestamps = {
+	createdAt: timestamp("created_at").defaultNow().notNull(),
+	updatedAt: timestamp("updated_at").defaultNow().$onUpdate(() => /* @__PURE__ */ new Date()).notNull()
 };
-exports.expiringTimestamp = (0, pg_core_1.customType)({
-    dataType() {
-        return `timestamp`;
-    },
-    fromDriver(value) {
-        return new Date(value);
-    },
+const expiringTimestamp = customType({
+	dataType() {
+		return `timestamp`;
+	},
+	fromDriver(value) {
+		return new Date(value);
+	}
 });
-//# sourceMappingURL=postgresUtils.js.map
+//#endregion
+export { expiringTimestamp, timestamps };

package/dist/schemas/counter.d.ts

@@ -0,0 +1,7 @@
+import { Counter } from "../interfaces/models/counter.js";
+import { Schema } from "mongoose";
+
+//#region src/schemas/counter.d.ts
+declare const counterSchema: Schema<Counter>;
+//#endregion
+export { counterSchema };

package/dist/schemas/counter.js

@@ -1,14 +1,19 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.counterSchema = void 0;
-const mongoose_1 = require("mongoose");
-const counterSchema = new mongoose_1.Schema({
-    code: { type: String, required: true },
-    value: { type: Number, required: true },
-    date: { type: Date },
-}, {
-    timestamps: true,
-});
-exports.counterSchema = counterSchema;
-counterSchema.index({ code: 1, date: -1 }, { unique: true });
-//# sourceMappingURL=counter.js.map
+import { Schema } from "mongoose";
+//#region src/schemas/counter.ts
+const counterSchema = new Schema({
+	code: {
+		type: String,
+		required: true
+	},
+	value: {
+		type: Number,
+		required: true
+	},
+	date: { type: Date }
+}, { timestamps: true });
+counterSchema.index({
+	code: 1,
+	date: -1
+}, { unique: true });
+//#endregion
+export { counterSchema };

package/dist/schemas/encryptedStorage.d.ts

@@ -0,0 +1,7 @@
+import { EncryptedStorage } from "../interfaces/models/encryptedStorage.js";
+import { Schema } from "mongoose";
+
+//#region src/schemas/encryptedStorage.d.ts
+declare const encryptedStorageSchema: Schema<EncryptedStorage>;
+//#endregion
+export { encryptedStorageSchema };

package/dist/schemas/encryptedStorage.js

@@ -1,15 +1,17 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encryptedStorageSchema = void 0;
-const mongoose_1 = require("mongoose");
-const types_1 = require("@diia-inhouse/types");
-const encryptedStorageSchema = new mongoose_1.Schema({
-    data: { type: String, required: true },
-    expiresAt: { type: Date, required: true },
-    source: { type: {} },
-}, {
-    timestamps: true,
-});
-exports.encryptedStorageSchema = encryptedStorageSchema;
-encryptedStorageSchema.index({ expiresAt: 1 }, { expireAfterSeconds: types_1.DurationS.Day });
-//# sourceMappingURL=encryptedStorage.js.map
+import { Schema } from "mongoose";
+import { DurationS } from "@diia-inhouse/types";
+//#region src/schemas/encryptedStorage.ts
+const encryptedStorageSchema = new Schema({
+	data: {
+		type: String,
+		required: true
+	},
+	expiresAt: {
+		type: Date,
+		required: true
+	},
+	source: { type: {} }
+}, { timestamps: true });
+encryptedStorageSchema.index({ expiresAt: 1 }, { expireAfterSeconds: DurationS.Day });
+//#endregion
+export { encryptedStorageSchema };

package/dist/schemas/index.d.ts

@@ -0,0 +1,3 @@
+import { counterSchema } from "./counter.js";
+import { encryptedStorageSchema } from "./encryptedStorage.js";
+import { createStatusHistoryItemSchema } from "./statusHistoryItem.js";

package/dist/schemas/index.js

@@ -1,20 +1,4 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./counter"), exports);
-__exportStar(require("./encryptedStorage"), exports);
-__exportStar(require("./statusHistoryItem"), exports);
-//# sourceMappingURL=index.js.map
+import "./counter.js";
+import "./encryptedStorage.js";
+import "./statusHistoryItem.js";
+export {};

package/dist/schemas/statusHistoryItem.d.ts

@@ -0,0 +1,7 @@
+import { Schema } from "mongoose";
+import { StatusHistoryItem } from "@diia-inhouse/types";
+
+//#region src/schemas/statusHistoryItem.d.ts
+declare function createStatusHistoryItemSchema(statuses: string[]): Schema<StatusHistoryItem<string>>;
+//#endregion
+export { createStatusHistoryItemSchema };

package/dist/schemas/statusHistoryItem.js

@@ -1,12 +1,18 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStatusHistoryItemSchema = createStatusHistoryItemSchema;
-const mongoose_1 = require("mongoose");
+import { Schema } from "mongoose";
+//#region src/schemas/statusHistoryItem.ts
 function createStatusHistoryItemSchema(statuses) {
-    return new mongoose_1.Schema({
-        traceId: { type: String },
-        date: { type: Date, required: true },
-        status: { type: String, enum: statuses, required: true },
-    }, { _id: false });
+	return new Schema({
+		traceId: { type: String },
+		date: {
+			type: Date,
+			required: true
+		},
+		status: {
+			type: String,
+			enum: statuses,
+			required: true
+		}
+	}, { _id: false });
 }
-//# sourceMappingURL=statusHistoryItem.js.map
+//#endregion
+export { createStatusHistoryItemSchema };

package/dist/services/counter.d.ts

@@ -0,0 +1,19 @@
+import { DatabaseAdapterType, PostgresDatabase } from "../interfaces/database.js";
+import { Counter } from "../interfaces/models/counter.js";
+import { Model } from "mongoose";
+
+//#region src/services/counter.d.ts
+declare class CounterService {
+  private readonly databaseAdapter;
+  private readonly counterModel;
+  private readonly postgresDatabase;
+  private readonly getNextValueStrategy;
+  private readonly getNextDailyValueStrategy;
+  constructor(databaseAdapter: DatabaseAdapterType, counterModel?: Model<Counter> | null, postgresDatabase?: PostgresDatabase | null);
+  getNextValue(code: string): Promise<number>;
+  getNextDailyValue(code: string): Promise<number>;
+  private getModel;
+  private getPostgresDatabase;
+}
+//#endregion
+export { CounterService };

package/dist/services/counter.js

@@ -1,72 +1,70 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CounterService = void 0;
-const drizzle_orm_1 = require("drizzle-orm");
-const luxon_1 = require("luxon");
-const tables_1 = require("../tables");
-class CounterService {
-    databaseAdapter;
-    counterModel;
-    postgresDatabase;
-    getNextValueStrategy = {
-        postgres: async (code) => {
-            const result = await this.getPostgresDatabase()
-                .insert(tables_1.counter)
-                .values({ code, value: 1, date: luxon_1.DateTime.now().startOf('day').toJSDate() })
-                .onConflictDoUpdate({
-                target: [tables_1.counter.code, tables_1.counter.date],
-                set: { value: (0, drizzle_orm_1.sql) `${tables_1.counter.value} + 1` },
-            })
-                .returning()
-                .then((rows) => rows[0]);
-            return result.value;
-        },
-        mongo: async (code) => {
-            const result = await this.getModel().findOneAndUpdate({ code }, { $inc: { value: 1 } }, { new: true, upsert: true });
-            return result.value;
-        },
-    };
-    getNextDailyValueStrategy = {
-        postgres: async (code) => {
-            const result = await this.getPostgresDatabase()
-                .insert(tables_1.counter)
-                .values({ code, value: 1, date: luxon_1.DateTime.now().startOf('day').toJSDate() })
-                .onConflictDoUpdate({
-                target: [tables_1.counter.code, tables_1.counter.date],
-                set: { value: (0, drizzle_orm_1.sql) `${tables_1.counter.value} + 1` },
-            })
-                .returning()
-                .then((rows) => rows[0]);
-            return result.value;
-        },
-        mongo: async (code) => {
-            const result = await this.getModel().findOneAndUpdate({ code, date: luxon_1.DateTime.now().startOf('day').toJSDate() }, { $inc: { value: 1 } }, { new: true, upsert: true });
-            return result.value;
-        },
-    };
-    constructor(databaseAdapter, counterModel = null, postgresDatabase = null) {
-        this.databaseAdapter = databaseAdapter;
-        this.counterModel = counterModel;
-        this.postgresDatabase = postgresDatabase;
-    }
-    async getNextValue(code) {
-        return await this.getNextValueStrategy[this.databaseAdapter](code);
-    }
-    async getNextDailyValue(code) {
-        return await this.getNextDailyValueStrategy[this.databaseAdapter](code);
-    }
-    getModel() {
-        if (!this.counterModel) {
-            throw new Error('Counter model is not provided');
-        }
-        return this.counterModel;
-    }
-    getPostgresDatabase() {
-        if (!this.postgresDatabase) {
-            throw new Error('Postgres database is not provided');
-        }
-        return this.postgresDatabase;
-    }
-}
-exports.CounterService = CounterService;
-//# sourceMappingURL=counter.js.map
+import { counter } from "../tables/counter.js";
+import "../tables/index.js";
+import { sql } from "drizzle-orm";
+import { DateTime } from "luxon";
+//#region src/services/counter.ts
+var CounterService = class {
+	databaseAdapter;
+	counterModel;
+	postgresDatabase;
+	getNextValueStrategy = {
+		postgres: async (code) => {
+			return (await this.getPostgresDatabase().insert(counter).values({
+				code,
+				value: 1,
+				date: DateTime.now().startOf("day").toJSDate()
+			}).onConflictDoUpdate({
+				target: [counter.code, counter.date],
+				set: { value: sql`${counter.value} + 1` }
+			}).returning().then((rows) => rows[0])).value;
+		},
+		mongo: async (code) => {
+			return (await this.getModel().findOneAndUpdate({ code }, { $inc: { value: 1 } }, {
+				returnDocument: "after",
+				upsert: true
+			})).value;
+		}
+	};
+	getNextDailyValueStrategy = {
+		postgres: async (code) => {
+			return (await this.getPostgresDatabase().insert(counter).values({
+				code,
+				value: 1,
+				date: DateTime.now().startOf("day").toJSDate()
+			}).onConflictDoUpdate({
+				target: [counter.code, counter.date],
+				set: { value: sql`${counter.value} + 1` }
+			}).returning().then((rows) => rows[0])).value;
+		},
+		mongo: async (code) => {
+			return (await this.getModel().findOneAndUpdate({
+				code,
+				date: DateTime.now().startOf("day").toJSDate()
+			}, { $inc: { value: 1 } }, {
+				returnDocument: "after",
+				upsert: true
+			})).value;
+		}
+	};
+	constructor(databaseAdapter, counterModel = null, postgresDatabase = null) {
+		this.databaseAdapter = databaseAdapter;
+		this.counterModel = counterModel;
+		this.postgresDatabase = postgresDatabase;
+	}
+	async getNextValue(code) {
+		return await this.getNextValueStrategy[this.databaseAdapter](code);
+	}
+	async getNextDailyValue(code) {
+		return await this.getNextDailyValueStrategy[this.databaseAdapter](code);
+	}
+	getModel() {
+		if (!this.counterModel) throw new Error("Counter model is not provided");
+		return this.counterModel;
+	}
+	getPostgresDatabase() {
+		if (!this.postgresDatabase) throw new Error("Postgres database is not provided");
+		return this.postgresDatabase;
+	}
+};
+//#endregion
+export { CounterService };

package/dist/services/database.d.ts

@@ -0,0 +1,50 @@
+import { DatabaseAdapterType } from "../interfaces/database.js";
+import { AppDb, AppDbConfig, DbType } from "../interfaces/dbConfig.js";
+import { MongoDbStatus } from "../interfaces/mongoStatus.js";
+import { MongodbOperationsLabelsMap } from "../interfaces/metrics.js";
+import mongoose, { ClientSession } from "mongoose";
+import { Histogram, Observer } from "@diia-inhouse/diia-metrics";
+import { HealthCheckResult, Logger, OnDestroy, OnHealthCheck, OnInit } from "@diia-inhouse/types";
+import { EnvService } from "@diia-inhouse/env";
+
+//#region src/services/database.d.ts
+declare class DatabaseService implements OnInit, OnHealthCheck, OnDestroy {
+  private readonly databaseAdapter;
+  private readonly dbConfigs;
+  private readonly envService;
+  private readonly logger;
+  readonly defaultModelsDir = "models";
+  db: Partial<Record<DbType, AppDb>>;
+  dbOperationsHistogram?: Histogram<MongodbOperationsLabelsMap>;
+  dbOplogObserver?: Observer<object>;
+  observerInterval: NodeJS.Timeout | undefined;
+  private dbOplog;
+  private readonly isMonitoringEnabled;
+  private readonly dbStateCodeToName;
+  /**
+  * https://www.mongodb.com/docs/manual/core/transactions/#read-concern-write-concern-read-preference
+  */
+  private readonly defaultTransactionOptions;
+  constructor(databaseAdapter: DatabaseAdapterType, dbConfigs: Partial<Record<DbType, AppDbConfig>>, envService: EnvService, logger: Logger);
+  onInit(): Promise<void>;
+  onDestroy(): Promise<void>;
+  onHealthCheck(): Promise<HealthCheckResult<MongoDbStatus>>;
+  createDbConnection(type: DbType, config: AppDbConfig): Promise<AppDb | undefined>;
+  /**
+  * 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
+  */
+  beginTransaction(options?: mongoose.mongo.TransactionOptions): Promise<ClientSession>;
+  private connectMonitor;
+  private oplogObserver;
+}
+//#endregion
+export { DatabaseService };