@diia-inhouse/db 10.8.12 → 12.3.0

package/dist/cli/syncIndexes.js

@@ -1,78 +1,39 @@
-"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+import { existsSync } from "node:fs";
+import path from "node:path";
+import recursiveRead from "recursive-readdir";
+//#region src/cli/syncIndexes.ts
+var SyncIndexesCommand = class {
+	logger;
+	constructor(logger) {
+		this.logger = logger;
+	}
+	async run(modelsDir) {
+		const modelsPath = `./dist/${modelsDir}`;
+		if (!existsSync(modelsPath)) throw new Error(`Models dir is absent: ${modelsPath}`);
+		const t0 = Date.now();
+		this.logger.info("Start syncing indexes");
+		const files = await recursiveRead(modelsPath, [
+			"*.map",
+			"index.js",
+			"schemas",
+			"*.types.js"
+		]);
+		const tasks = [];
+		for (const fileName of files) {
+			const modelModule = await import(path.resolve(fileName));
+			if (modelModule.skipSyncIndexes) continue;
+			const task = modelModule.default;
+			tasks.push(this.syncModel(task));
+		}
+		await Promise.all(tasks);
+		this.logger.info(`Ended syncing indexes in ${Date.now() - t0} ms`);
+	}
+	async syncModel(model) {
+		const t0 = Date.now();
+		this.logger.info(`Start syncing indexes for the ${model.modelName} collection`);
+		await model.syncIndexes();
+		this.logger.info(`Ended syncing indexes for the ${model.modelName} collection in ${Date.now() - t0} ms`);
+	}
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SyncIndexesCommand = void 0;
-const node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const recursive_readdir_1 = __importDefault(require("recursive-readdir"));
-class SyncIndexesCommand {
-    logger;
-    constructor(logger) {
-        this.logger = logger;
-    }
-    async run(modelsDir) {
-        const modelsPath = `./dist/${modelsDir}`;
-        // eslint-disable-next-line security/detect-non-literal-fs-filename
-        const isExistsSync = (0, node_fs_1.existsSync)(modelsPath); // nosemgrep: eslint.detect-non-literal-fs-filename
-        if (!isExistsSync) {
-            throw new Error(`Models dir is absent: ${modelsPath}`);
-        }
-        const t0 = Date.now();
-        this.logger.info('Start syncing indexes');
-        const files = await (0, recursive_readdir_1.default)(modelsPath, ['*.map', 'index.js', 'schemas', '*.types.js']);
-        const tasks = [];
-        for (const fileName of files) {
-            const modelModule = await Promise.resolve(`${node_path_1.default.resolve(fileName)}`).then(s => __importStar(require(s)));
-            if (modelModule.skipSyncIndexes) {
-                continue;
-            }
-            const task = modelModule.default;
-            tasks.push(this.syncModel(task));
-        }
-        await Promise.all(tasks);
-        this.logger.info(`Ended syncing indexes in ${Date.now() - t0} ms`);
-    }
-    async syncModel(model) {
-        const t0 = Date.now();
-        this.logger.info(`Start syncing indexes for the ${model.modelName} collection`);
-        await model.syncIndexes();
-        this.logger.info(`Ended syncing indexes for the ${model.modelName} collection in ${Date.now() - t0} ms`);
-    }
-}
-exports.SyncIndexesCommand = SyncIndexesCommand;
-//# sourceMappingURL=syncIndexes.js.map
+//#endregion
+export { SyncIndexesCommand };

package/dist/index.d.ts

@@ -0,0 +1,28 @@
+import { counter } from "./tables/counter.js";
+import { encryptedStorage } from "./tables/encryptedStorage.js";
+import { DatabaseAdapter, DatabaseAdapterType, DerivedRepository, PostgresDatabase } from "./interfaces/database.js";
+import { AppDb, AppDbConfig, DbType, PostgresDbConfig, ReplicaSetNodeConfig } from "./interfaces/dbConfig.js";
+import { MongoDBErrorCode, PostgresErrorCode } from "./interfaces/errors.js";
+import { MigrateMongoConfig } from "./interfaces/migrateMongoConfig.js";
+import { DbConnectionStatus, DbStatusByType, MongoDbStatus } from "./interfaces/mongoStatus.js";
+import { DbOpLog, DbOpLogEntry, MongodbOperationResult, MongodbOperationsLabelsMap, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets } from "./interfaces/metrics.js";
+import { Counter } from "./interfaces/models/counter.js";
+import { EncryptedStorage } from "./interfaces/models/encryptedStorage.js";
+import { models, mongoose } from "./interfaces/index.js";
+import { DatabaseService } from "./services/database.js";
+import { PostgresDatabaseService } from "./services/postgresDatabase.js";
+import { EncryptedStorageService } from "./services/encryptedStorage.js";
+import { CounterService } from "./services/counter.js";
+import { MongoHelper } from "./mongo.js";
+import { counterSchema } from "./schemas/counter.js";
+import { encryptedStorageSchema } from "./schemas/encryptedStorage.js";
+import { createStatusHistoryItemSchema } from "./schemas/statusHistoryItem.js";
+import { expiringTimestamp, timestamps } from "./postgresUtils.js";
+export * from "mongoose";
+
+//#region src/index.d.ts
+declare namespace index_d_exports {
+  export { AppDb, AppDbConfig, Counter, CounterService, DatabaseAdapter, DatabaseAdapterType, DatabaseService, DbConnectionStatus, DbOpLog, DbOpLogEntry, DbStatusByType, DbType, DerivedRepository, EncryptedStorage, EncryptedStorageService, MigrateMongoConfig, MongoDBErrorCode, MongoDbStatus, MongoHelper, MongodbOperationResult, MongodbOperationsLabelsMap, PostgresDatabase, PostgresDatabaseService, PostgresDbConfig, PostgresErrorCode, ReplicaSetNodeConfig, counter, counterSchema, createStatusHistoryItemSchema, encryptedStorage, encryptedStorageSchema, expiringTimestamp, models, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets, mongoose, timestamps };
+}
+//#endregion
+export { AppDb, AppDbConfig, Counter, CounterService, DatabaseAdapter, DatabaseAdapterType, DatabaseService, DbConnectionStatus, DbOpLog, DbOpLogEntry, DbStatusByType, DbType, DerivedRepository, EncryptedStorage, EncryptedStorageService, MigrateMongoConfig, MongoDBErrorCode, MongoDbStatus, MongoHelper, MongodbOperationResult, MongodbOperationsLabelsMap, PostgresDatabase, PostgresDatabaseService, PostgresDbConfig, PostgresErrorCode, ReplicaSetNodeConfig, counter, counterSchema, createStatusHistoryItemSchema, encryptedStorage, encryptedStorageSchema, expiringTimestamp, models, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets, mongoose, timestamps };

package/dist/index.js

@@ -1,22 +1,23 @@
-"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("./interfaces"), exports);
-__exportStar(require("./services"), exports);
-__exportStar(require("./mongo"), exports);
-__exportStar(require("./schemas"), exports);
-__exportStar(require("./postgres"), exports);
-//# sourceMappingURL=index.js.map
+import "./_virtual/_rolldown/runtime.js";
+import { DbType } from "./interfaces/dbConfig.js";
+import { MongoDBErrorCode, PostgresErrorCode } from "./interfaces/errors.js";
+import { DbConnectionStatus } from "./interfaces/mongoStatus.js";
+import { MongodbOperationResult, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets } from "./interfaces/metrics.js";
+import { models, mongoose } from "./interfaces/index.js";
+import { DatabaseService } from "./services/database.js";
+import { PostgresDatabaseService } from "./services/postgresDatabase.js";
+import { expiringTimestamp, timestamps } from "./postgresUtils.js";
+import { encryptedStorage } from "./tables/encryptedStorage.js";
+import { EncryptedStorageService } from "./services/encryptedStorage.js";
+import { counter } from "./tables/counter.js";
+import { CounterService } from "./services/counter.js";
+import "./services/index.js";
+import { MongoHelper } from "./mongo.js";
+import { counterSchema } from "./schemas/counter.js";
+import { encryptedStorageSchema } from "./schemas/encryptedStorage.js";
+import { createStatusHistoryItemSchema } from "./schemas/statusHistoryItem.js";
+import "./schemas/index.js";
+import "./postgres.js";
+export * from "mongoose";
+//#endregion
+export { CounterService, DatabaseService, DbConnectionStatus, DbType, EncryptedStorageService, MongoDBErrorCode, MongoHelper, MongodbOperationResult, PostgresDatabaseService, PostgresErrorCode, counter, counterSchema, createStatusHistoryItemSchema, encryptedStorage, encryptedStorageSchema, expiringTimestamp, models, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets, mongoose, timestamps };

package/dist/interfaces/database.d.ts

@@ -0,0 +1,10 @@
+import { index_d_exports } from "../tables/index.js";
+import { NodePgDatabase } from "drizzle-orm/node-postgres";
+
+//#region src/interfaces/database.d.ts
+type DatabaseAdapterType = "mongo" | "postgres";
+type DerivedRepository<TRepository> = { [K in keyof TRepository]: TRepository[K] extends ((...args: any[]) => any) ? TRepository[K] : never };
+type PostgresDatabase = NodePgDatabase<typeof index_d_exports>;
+type DatabaseAdapter<T extends DatabaseAdapterType, Repositories extends Record<DatabaseAdapterType, unknown>> = Repositories[T];
+//#endregion
+export { DatabaseAdapter, DatabaseAdapterType, DerivedRepository, PostgresDatabase };

package/dist/interfaces/dbConfig.d.ts

@@ -0,0 +1,37 @@
+import mongoose, { mongo } from "mongoose";
+
+//#region src/interfaces/dbConfig.d.ts
+interface ReplicaSetNodeConfig {
+  replicaHost: string;
+}
+declare enum DbType {
+  Main = "main",
+  Cache = "cache"
+}
+interface AppDbConfig {
+  isEnabled?: boolean;
+  user?: string;
+  password?: string;
+  database: string;
+  authSource?: string;
+  host?: string;
+  port?: number;
+  replicaSet?: string;
+  replicaSetNodes?: ReplicaSetNodeConfig[];
+  readPreference?: string;
+  authMechanism?: mongo.AuthMechanism;
+  metrics: {
+    enabled: boolean;
+    buckets?: number[];
+  };
+}
+interface PostgresDbConfig {
+  url: string;
+}
+interface AppDb {
+  connection: mongoose.Connection;
+  connectionString: string;
+  connectionOptions: mongoose.ConnectOptions;
+}
+//#endregion
+export { AppDb, AppDbConfig, DbType, PostgresDbConfig, ReplicaSetNodeConfig };

package/dist/interfaces/dbConfig.js

@@ -1,9 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbType = void 0;
-var DbType;
-(function (DbType) {
-    DbType["Main"] = "main";
-    DbType["Cache"] = "cache";
-})(DbType || (exports.DbType = DbType = {}));
-//# sourceMappingURL=dbConfig.js.map
+//#region src/interfaces/dbConfig.ts
+let DbType = /* @__PURE__ */ function(DbType) {
+	DbType["Main"] = "main";
+	DbType["Cache"] = "cache";
+	return DbType;
+}({});
+//#endregion
+export { DbType };

package/dist/interfaces/errors.d.ts

@@ -0,0 +1,43 @@
+//#region src/interfaces/errors.d.ts
+declare enum MongoDBErrorCode {
+  AlreadyInitialized = 23,
+  AuthenticationFailed = 18,
+  BadValue = 2,
+  CannotMutateObject = 10,
+  CannotReuseObject = 19,
+  CollectionDoesNotExist = 26,
+  DuplicateKey = 11e3,
+  EmptyArrayOperation = 21,
+  FailedToParse = 9,
+  GraphContainsCycle = 5,
+  HostNotFound = 7,
+  HostUnreachable = 6,
+  IllegalOperation = 20,
+  IndexNotFound = 27,
+  InternalError = 1,
+  InvalidBson = 22,
+  InvalidLength = 16,
+  InvalidPath = 30,
+  LockTimeout = 24,
+  MaxTimeMSExpired = 50,
+  NonExistentPath = 29,
+  NoSuchKey = 4,
+  Overflow = 15,
+  PathNotViable = 28,
+  ProtocolError = 17,
+  QueryCommandNotFound = 59,
+  QueryNotTailable = 13051,
+  RemoteValidationError = 25,
+  TypeMismatch = 14,
+  Unauthorized = 13,
+  UnknownError = 8,
+  UnsupportedFormat = 12,
+  UserNotFound = 11,
+  WriteConcernError = 64,
+  WriteConflict = 112
+}
+declare const PostgresErrorCode: {
+  readonly InvalidCredentials: "28P01";
+};
+//#endregion
+export { MongoDBErrorCode, PostgresErrorCode };

package/dist/interfaces/errors.js

@@ -1,50 +1,42 @@
-"use strict";
-/*
-  Full list of mongo errors:
-    https://github.com/mongodb/mongo/blob/master/src/mongo/base/error_codes.yml
-    https://github.com/mongodb/mongo-c-driver/blob/master/src/libmongoc/src/mongoc/mongoc-error.h
-*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresErrorCode = exports.MongoDBErrorCode = void 0;
-var MongoDBErrorCode;
-(function (MongoDBErrorCode) {
-    MongoDBErrorCode[MongoDBErrorCode["AlreadyInitialized"] = 23] = "AlreadyInitialized";
-    MongoDBErrorCode[MongoDBErrorCode["AuthenticationFailed"] = 18] = "AuthenticationFailed";
-    MongoDBErrorCode[MongoDBErrorCode["BadValue"] = 2] = "BadValue";
-    MongoDBErrorCode[MongoDBErrorCode["CannotMutateObject"] = 10] = "CannotMutateObject";
-    MongoDBErrorCode[MongoDBErrorCode["CannotReuseObject"] = 19] = "CannotReuseObject";
-    MongoDBErrorCode[MongoDBErrorCode["CollectionDoesNotExist"] = 26] = "CollectionDoesNotExist";
-    MongoDBErrorCode[MongoDBErrorCode["DuplicateKey"] = 11000] = "DuplicateKey";
-    MongoDBErrorCode[MongoDBErrorCode["EmptyArrayOperation"] = 21] = "EmptyArrayOperation";
-    MongoDBErrorCode[MongoDBErrorCode["FailedToParse"] = 9] = "FailedToParse";
-    MongoDBErrorCode[MongoDBErrorCode["GraphContainsCycle"] = 5] = "GraphContainsCycle";
-    MongoDBErrorCode[MongoDBErrorCode["HostNotFound"] = 7] = "HostNotFound";
-    MongoDBErrorCode[MongoDBErrorCode["HostUnreachable"] = 6] = "HostUnreachable";
-    MongoDBErrorCode[MongoDBErrorCode["IllegalOperation"] = 20] = "IllegalOperation";
-    MongoDBErrorCode[MongoDBErrorCode["IndexNotFound"] = 27] = "IndexNotFound";
-    MongoDBErrorCode[MongoDBErrorCode["InternalError"] = 1] = "InternalError";
-    MongoDBErrorCode[MongoDBErrorCode["InvalidBson"] = 22] = "InvalidBson";
-    MongoDBErrorCode[MongoDBErrorCode["InvalidLength"] = 16] = "InvalidLength";
-    MongoDBErrorCode[MongoDBErrorCode["InvalidPath"] = 30] = "InvalidPath";
-    MongoDBErrorCode[MongoDBErrorCode["LockTimeout"] = 24] = "LockTimeout";
-    MongoDBErrorCode[MongoDBErrorCode["MaxTimeMSExpired"] = 50] = "MaxTimeMSExpired";
-    MongoDBErrorCode[MongoDBErrorCode["NonExistentPath"] = 29] = "NonExistentPath";
-    MongoDBErrorCode[MongoDBErrorCode["NoSuchKey"] = 4] = "NoSuchKey";
-    MongoDBErrorCode[MongoDBErrorCode["Overflow"] = 15] = "Overflow";
-    MongoDBErrorCode[MongoDBErrorCode["PathNotViable"] = 28] = "PathNotViable";
-    MongoDBErrorCode[MongoDBErrorCode["ProtocolError"] = 17] = "ProtocolError";
-    MongoDBErrorCode[MongoDBErrorCode["QueryCommandNotFound"] = 59] = "QueryCommandNotFound";
-    MongoDBErrorCode[MongoDBErrorCode["QueryNotTailable"] = 13051] = "QueryNotTailable";
-    MongoDBErrorCode[MongoDBErrorCode["RemoteValidationError"] = 25] = "RemoteValidationError";
-    MongoDBErrorCode[MongoDBErrorCode["TypeMismatch"] = 14] = "TypeMismatch";
-    MongoDBErrorCode[MongoDBErrorCode["Unauthorized"] = 13] = "Unauthorized";
-    MongoDBErrorCode[MongoDBErrorCode["UnknownError"] = 8] = "UnknownError";
-    MongoDBErrorCode[MongoDBErrorCode["UnsupportedFormat"] = 12] = "UnsupportedFormat";
-    MongoDBErrorCode[MongoDBErrorCode["UserNotFound"] = 11] = "UserNotFound";
-    MongoDBErrorCode[MongoDBErrorCode["WriteConcernError"] = 64] = "WriteConcernError";
-    MongoDBErrorCode[MongoDBErrorCode["WriteConflict"] = 112] = "WriteConflict";
-})(MongoDBErrorCode || (exports.MongoDBErrorCode = MongoDBErrorCode = {}));
-exports.PostgresErrorCode = {
-    InvalidCredentials: '28P01',
-};
-//# sourceMappingURL=errors.js.map
+//#region src/interfaces/errors.ts
+let MongoDBErrorCode = /* @__PURE__ */ function(MongoDBErrorCode) {
+	MongoDBErrorCode[MongoDBErrorCode["AlreadyInitialized"] = 23] = "AlreadyInitialized";
+	MongoDBErrorCode[MongoDBErrorCode["AuthenticationFailed"] = 18] = "AuthenticationFailed";
+	MongoDBErrorCode[MongoDBErrorCode["BadValue"] = 2] = "BadValue";
+	MongoDBErrorCode[MongoDBErrorCode["CannotMutateObject"] = 10] = "CannotMutateObject";
+	MongoDBErrorCode[MongoDBErrorCode["CannotReuseObject"] = 19] = "CannotReuseObject";
+	MongoDBErrorCode[MongoDBErrorCode["CollectionDoesNotExist"] = 26] = "CollectionDoesNotExist";
+	MongoDBErrorCode[MongoDBErrorCode["DuplicateKey"] = 11e3] = "DuplicateKey";
+	MongoDBErrorCode[MongoDBErrorCode["EmptyArrayOperation"] = 21] = "EmptyArrayOperation";
+	MongoDBErrorCode[MongoDBErrorCode["FailedToParse"] = 9] = "FailedToParse";
+	MongoDBErrorCode[MongoDBErrorCode["GraphContainsCycle"] = 5] = "GraphContainsCycle";
+	MongoDBErrorCode[MongoDBErrorCode["HostNotFound"] = 7] = "HostNotFound";
+	MongoDBErrorCode[MongoDBErrorCode["HostUnreachable"] = 6] = "HostUnreachable";
+	MongoDBErrorCode[MongoDBErrorCode["IllegalOperation"] = 20] = "IllegalOperation";
+	MongoDBErrorCode[MongoDBErrorCode["IndexNotFound"] = 27] = "IndexNotFound";
+	MongoDBErrorCode[MongoDBErrorCode["InternalError"] = 1] = "InternalError";
+	MongoDBErrorCode[MongoDBErrorCode["InvalidBson"] = 22] = "InvalidBson";
+	MongoDBErrorCode[MongoDBErrorCode["InvalidLength"] = 16] = "InvalidLength";
+	MongoDBErrorCode[MongoDBErrorCode["InvalidPath"] = 30] = "InvalidPath";
+	MongoDBErrorCode[MongoDBErrorCode["LockTimeout"] = 24] = "LockTimeout";
+	MongoDBErrorCode[MongoDBErrorCode["MaxTimeMSExpired"] = 50] = "MaxTimeMSExpired";
+	MongoDBErrorCode[MongoDBErrorCode["NonExistentPath"] = 29] = "NonExistentPath";
+	MongoDBErrorCode[MongoDBErrorCode["NoSuchKey"] = 4] = "NoSuchKey";
+	MongoDBErrorCode[MongoDBErrorCode["Overflow"] = 15] = "Overflow";
+	MongoDBErrorCode[MongoDBErrorCode["PathNotViable"] = 28] = "PathNotViable";
+	MongoDBErrorCode[MongoDBErrorCode["ProtocolError"] = 17] = "ProtocolError";
+	MongoDBErrorCode[MongoDBErrorCode["QueryCommandNotFound"] = 59] = "QueryCommandNotFound";
+	MongoDBErrorCode[MongoDBErrorCode["QueryNotTailable"] = 13051] = "QueryNotTailable";
+	MongoDBErrorCode[MongoDBErrorCode["RemoteValidationError"] = 25] = "RemoteValidationError";
+	MongoDBErrorCode[MongoDBErrorCode["TypeMismatch"] = 14] = "TypeMismatch";
+	MongoDBErrorCode[MongoDBErrorCode["Unauthorized"] = 13] = "Unauthorized";
+	MongoDBErrorCode[MongoDBErrorCode["UnknownError"] = 8] = "UnknownError";
+	MongoDBErrorCode[MongoDBErrorCode["UnsupportedFormat"] = 12] = "UnsupportedFormat";
+	MongoDBErrorCode[MongoDBErrorCode["UserNotFound"] = 11] = "UserNotFound";
+	MongoDBErrorCode[MongoDBErrorCode["WriteConcernError"] = 64] = "WriteConcernError";
+	MongoDBErrorCode[MongoDBErrorCode["WriteConflict"] = 112] = "WriteConflict";
+	return MongoDBErrorCode;
+}({});
+const PostgresErrorCode = { InvalidCredentials: "28P01" };
+//#endregion
+export { MongoDBErrorCode, PostgresErrorCode };

package/dist/interfaces/index.d.ts

@@ -0,0 +1,15 @@
+import { DatabaseAdapter, DatabaseAdapterType, DerivedRepository, PostgresDatabase } from "./database.js";
+import { AppDb, AppDbConfig, DbType, PostgresDbConfig, ReplicaSetNodeConfig } from "./dbConfig.js";
+import { MongoDBErrorCode, PostgresErrorCode } from "./errors.js";
+import { MigrateMongoConfig } from "./migrateMongoConfig.js";
+import { DbConnectionStatus, DbStatusByType, MongoDbStatus } from "./mongoStatus.js";
+import { DbOpLog, DbOpLogEntry, MongodbOperationResult, MongodbOperationsLabelsMap, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets } from "./metrics.js";
+import { Counter } from "./models/counter.js";
+import { EncryptedStorage } from "./models/encryptedStorage.js";
+import mongoose$1, { Models } from "mongoose";
+export * from "mongoose";
+
+//#region src/interfaces/index.d.ts
+declare const models: Models;
+//#endregion
+export { models, mongoose$1 as mongoose };

package/dist/interfaces/index.js

@@ -1,25 +1,11 @@
-"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("mongoose"), exports);
-__exportStar(require("./database"), exports);
-__exportStar(require("./dbConfig"), exports);
-__exportStar(require("./errors"), exports);
-__exportStar(require("./migrateMongoConfig"), exports);
-__exportStar(require("./mongoStatus"), exports);
-__exportStar(require("./metrics"), exports);
-__exportStar(require("./models"), exports);
-//# sourceMappingURL=index.js.map
+import "../_virtual/_rolldown/runtime.js";
+import "./dbConfig.js";
+import "./errors.js";
+import "./mongoStatus.js";
+import "./metrics.js";
+import mongoose$1 from "mongoose";
+export * from "mongoose";
+//#region src/interfaces/index.ts
+const models = mongoose$1.models;
+//#endregion
+export { models, mongoose$1 as mongoose };

package/dist/interfaces/metrics.d.ts

@@ -0,0 +1,22 @@
+//#region src/interfaces/metrics.d.ts
+declare enum MongodbOperationResult {
+  Successful = "successful",
+  Failed = "failed"
+}
+interface DbOpLogEntry {
+  database: string;
+  collection?: string;
+  opType: string;
+}
+type DbOpLog = Record<string, DbOpLogEntry>;
+declare class MongodbOperationsLabelsMapConcrete {
+  operation: string;
+  status: MongodbOperationResult;
+  database: string;
+  collection: string;
+}
+type MongodbOperationsLabelsMap = MongodbOperationsLabelsMapConcrete;
+declare const mongodbOperationsAllowedFields: (keyof MongodbOperationsLabelsMap)[];
+declare const mongodbOperationsDefaultBuckets: number[];
+//#endregion
+export { DbOpLog, DbOpLogEntry, MongodbOperationResult, MongodbOperationsLabelsMap, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets };

package/dist/interfaces/metrics.js

@@ -1,20 +1,39 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mongodbOperationsDefaultBuckets = exports.mongodbOperationsAllowedFields = exports.MongodbOperationResult = void 0;
-var MongodbOperationResult;
-(function (MongodbOperationResult) {
-    MongodbOperationResult["Successful"] = "successful";
-    MongodbOperationResult["Failed"] = "failed";
-})(MongodbOperationResult || (exports.MongodbOperationResult = MongodbOperationResult = {}));
-class MongodbOperationsLabelsMapConcrete {
-    operation = '';
-    status = MongodbOperationResult.Successful;
-    database = '';
-    collection = '';
-}
-exports.mongodbOperationsAllowedFields = Object.keys(new MongodbOperationsLabelsMapConcrete());
-// From 1ms up to 30s
-exports.mongodbOperationsDefaultBuckets = [
-    0.001, 0.003, 0.005, 0.01, 0.015, 0.03, 0.05, 0.07, 0.09, 0.1, 0.15, 0.3, 0.5, 0.7, 0.9, 1, 5, 10, 15, 20, 25, 30,
+//#region src/interfaces/metrics.ts
+let MongodbOperationResult = /* @__PURE__ */ function(MongodbOperationResult) {
+	MongodbOperationResult["Successful"] = "successful";
+	MongodbOperationResult["Failed"] = "failed";
+	return MongodbOperationResult;
+}({});
+var MongodbOperationsLabelsMapConcrete = class {
+	operation = "";
+	status = "successful";
+	database = "";
+	collection = "";
+};
+const mongodbOperationsAllowedFields = Object.keys(new MongodbOperationsLabelsMapConcrete());
+const mongodbOperationsDefaultBuckets = [
+	.001,
+	.003,
+	.005,
+	.01,
+	.015,
+	.03,
+	.05,
+	.07,
+	.09,
+	.1,
+	.15,
+	.3,
+	.5,
+	.7,
+	.9,
+	1,
+	5,
+	10,
+	15,
+	20,
+	25,
+	30
 ];
-//# sourceMappingURL=metrics.js.map
+//#endregion
+export { MongodbOperationResult, mongodbOperationsAllowedFields, mongodbOperationsDefaultBuckets };

package/dist/interfaces/migrateMongoConfig.d.ts

@@ -0,0 +1,17 @@
+import { mongo } from "mongoose";
+
+//#region src/interfaces/migrateMongoConfig.d.ts
+interface MigrateMongoConfig {
+  mongodb: {
+    url: Parameters<(typeof mongo.MongoClient)["connect"]>[0];
+    databaseName?: mongo.Db["databaseName"];
+    options?: mongo.MongoClientOptions;
+  };
+  migrationsDir?: string;
+  changelogCollectionName: string;
+  migrationFileExtension?: string;
+  useFileHash?: boolean;
+  moduleSystem: string;
+}
+//#endregion
+export { MigrateMongoConfig };

package/dist/interfaces/models/counter.d.ts

@@ -0,0 +1,8 @@
+//#region src/interfaces/models/counter.d.ts
+interface Counter {
+  code: string;
+  value: number;
+  date?: Date;
+}
+//#endregion
+export { Counter };

package/dist/interfaces/models/encryptedStorage.d.ts

@@ -0,0 +1,9 @@
+//#region src/interfaces/models/encryptedStorage.d.ts
+interface EncryptedStorage {
+  id?: string;
+  data: string;
+  expiresAt: Date;
+  source?: unknown;
+}
+//#endregion
+export { EncryptedStorage };

package/dist/interfaces/mongoStatus.d.ts

@@ -0,0 +1,16 @@
+import { DbType } from "./dbConfig.js";
+
+//#region src/interfaces/mongoStatus.d.ts
+declare enum DbConnectionStatus {
+  Disconnected = "disconnected",
+  Connected = "connected",
+  Connecting = "connecting",
+  Disconnecting = "disconnecting",
+  OpFailed = "op_failed"
+}
+type DbStatusByType = Partial<Record<DbType, DbConnectionStatus>>;
+type MongoDbStatus = {
+  mongodb: DbStatusByType;
+};
+//#endregion
+export { DbConnectionStatus, DbStatusByType, MongoDbStatus };

package/dist/interfaces/mongoStatus.js

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DbConnectionStatus = void 0;
-var DbConnectionStatus;
-(function (DbConnectionStatus) {
-    DbConnectionStatus["Disconnected"] = "disconnected";
-    DbConnectionStatus["Connected"] = "connected";
-    DbConnectionStatus["Connecting"] = "connecting";
-    DbConnectionStatus["Disconnecting"] = "disconnecting";
-    DbConnectionStatus["OpFailed"] = "op_failed";
-})(DbConnectionStatus || (exports.DbConnectionStatus = DbConnectionStatus = {}));
-//# sourceMappingURL=mongoStatus.js.map
+//#region src/interfaces/mongoStatus.ts
+let DbConnectionStatus = /* @__PURE__ */ function(DbConnectionStatus) {
+	DbConnectionStatus["Disconnected"] = "disconnected";
+	DbConnectionStatus["Connected"] = "connected";
+	DbConnectionStatus["Connecting"] = "connecting";
+	DbConnectionStatus["Disconnecting"] = "disconnecting";
+	DbConnectionStatus["OpFailed"] = "op_failed";
+	return DbConnectionStatus;
+}({});
+//#endregion
+export { DbConnectionStatus };