@diia-inhouse/db 4.12.0 → 10.8.0

package/dist/types/schemas/counter.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'mongoose';
+import { Counter } from '../interfaces/models/counter';
+declare const counterSchema: Schema<Counter, import("mongoose").Model<Counter, any, any, any, import("mongoose").Document<unknown, any, Counter, any, {}> & Counter & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, Counter, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<Counter>, {}, import("mongoose").DefaultSchemaOptions> & import("mongoose").FlatRecord<Counter> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export { counterSchema };

package/dist/types/schemas/encryptedStorage.d.ts

@@ -0,0 +1,12 @@
+import { Schema } from 'mongoose';
+import { EncryptedStorage } from '../interfaces/models/encryptedStorage';
+declare const encryptedStorageSchema: Schema<EncryptedStorage, import("mongoose").Model<EncryptedStorage, any, any, any, import("mongoose").Document<unknown, any, EncryptedStorage, any, {}> & EncryptedStorage & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}, any>, {}, {}, {}, {}, import("mongoose").DefaultSchemaOptions, EncryptedStorage, import("mongoose").Document<unknown, {}, import("mongoose").FlatRecord<EncryptedStorage>, {}, import("mongoose").DefaultSchemaOptions> & import("mongoose").FlatRecord<EncryptedStorage> & {
+    _id: import("mongoose").Types.ObjectId;
+} & {
+    __v: number;
+}>;
+export { encryptedStorageSchema };

package/dist/types/schemas/index.d.ts

@@ -0,0 +1,3 @@
+export * from './counter';
+export * from './encryptedStorage';
+export * from './statusHistoryItem';

package/dist/types/schemas/statusHistoryItem.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from 'mongoose';
+import { StatusHistoryItem } from '@diia-inhouse/types';
+export declare function createStatusHistoryItemSchema(statuses: string[]): Schema<StatusHistoryItem<string>>;

package/dist/types/services/counter.d.ts

@@ -0,0 +1,15 @@
+import { Model } from 'mongoose';
+import { DatabaseAdapterType, PostgresDatabase } from '../interfaces';
+import { Counter } from '../interfaces/models/counter';
+export 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;
+}

package/dist/types/services/database.d.ts

@@ -1,43 +1,43 @@
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose/types/inferschematype" />
-import { ClientSession } from 'mongoose';
+import mongoose, { ClientSession } from 'mongoose';
+import { Histogram, Observer } from '@diia-inhouse/diia-metrics';
 import { EnvService } from '@diia-inhouse/env';
-import { HealthCheckResult, Logger, OnHealthCheck, OnInit } from '@diia-inhouse/types';
-import { AppDb, AppDbConfig, DbType, MongoDbStatus } from '../interfaces';
-export declare class DatabaseService implements OnInit, OnHealthCheck {
+import { HealthCheckResult, Logger, OnDestroy, OnHealthCheck, OnInit } from '@diia-inhouse/types';
+import { AppDb, AppDbConfig, DatabaseAdapterType, DbType, MongoDbStatus, MongodbOperationsLabelsMap } from '../interfaces';
+export declare class DatabaseService implements OnInit, OnHealthCheck, OnDestroy {
+    private readonly databaseAdapter;
     private readonly dbConfigs;
     private readonly envService;
     private readonly logger;
-    private readonly dbStateCodeToName;
     readonly defaultModelsDir = "models";
     db: Partial<Record<DbType, AppDb>>;
-    constructor(dbConfigs: Record<DbType, AppDbConfig>, envService: EnvService, logger: Logger);
+    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>;
-    syncIndexes(exitAfterSync?: boolean, modelsDir?: string): Promise<void>;
-    beginTransaction(dbType?: DbType): Promise<ClientSession>;
-    private syncModel;
+    /**
+     * 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;
 }

package/dist/types/services/encryptedStorage.d.ts

@@ -1,43 +1,69 @@
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose/types/inferschematype" />
-import { QueryOptions, Types } from 'mongoose';
+import { Model, QueryOptions } from 'mongoose';
 import { AuthService } from '@diia-inhouse/crypto';
 import { EnvService } from '@diia-inhouse/env';
 import { Logger } from '@diia-inhouse/types';
+import { DatabaseAdapterType, PostgresDatabase } from '../interfaces';
+import { EncryptedStorage } from '../interfaces/models/encryptedStorage';
+/**
+ * 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}
+ * ```
+ */
 export declare class EncryptedStorageService {
     private readonly logger;
     private readonly auth;
     private readonly envService;
-    constructor(logger: Logger, auth: AuthService, envService: EnvService);
-    save<T>(data: T, expiration: number): Promise<Types.ObjectId>;
-    get<T>(id: Types.ObjectId, options?: QueryOptions): Promise<T>;
-    getSafe<T>(id: Types.ObjectId, options?: QueryOptions): Promise<T | undefined>;
-    update<T>(id: Types.ObjectId, data: T): Promise<void>;
-    remove(id: Types.ObjectId): Promise<void>;
-    deleteMany(ids: Types.ObjectId[]): Promise<void>;
-    setExpiration(id: Types.ObjectId, expiration: number, options?: QueryOptions): Promise<void>;
-    getExpiration(id: Types.ObjectId): Promise<Date>;
+    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, options?: QueryOptions): Promise<void>;
+    getExpiration(id: string): Promise<Date>;
     private getStorageItemById;
+    private getModel;
+    private getPostgresDatabase;
 }

package/dist/types/services/index.d.ts

@@ -1,2 +1,4 @@
 export * from './database';
+export * from './postgresDatabase';
 export * from './encryptedStorage';
+export * from './counter';

package/dist/types/services/postgresDatabase.d.ts

@@ -0,0 +1,8 @@
+import { OnInit } from '@diia-inhouse/types';
+import { DatabaseAdapterType, PostgresDatabase } from '../interfaces';
+export declare class PostgresDatabaseService implements OnInit {
+    private readonly databaseAdapter;
+    private readonly postgresDatabase;
+    constructor(databaseAdapter: DatabaseAdapterType, postgresDatabase: PostgresDatabase);
+    onInit(): Promise<void>;
+}

package/dist/types/tables/counter.d.ts

@@ -0,0 +1,94 @@
+export declare const counter: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "counter";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "counter";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "counter";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        code: import("drizzle-orm/pg-core").PgColumn<{
+            name: "code";
+            tableName: "counter";
+            dataType: "string";
+            columnType: "PgVarchar";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        value: import("drizzle-orm/pg-core").PgColumn<{
+            name: "value";
+            tableName: "counter";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        date: import("drizzle-orm/pg-core").PgColumn<{
+            name: "date";
+            tableName: "counter";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/types/tables/encryptedStorage.d.ts

@@ -0,0 +1,111 @@
+export declare const encryptedStorage: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "encrypted_storage";
+    schema: undefined;
+    columns: {
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "created_at";
+            tableName: "encrypted_storage";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        updatedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "updated_at";
+            tableName: "encrypted_storage";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "encrypted_storage";
+            dataType: "string";
+            columnType: "PgUUID";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        data: import("drizzle-orm/pg-core").PgColumn<{
+            name: "data";
+            tableName: "encrypted_storage";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        expiresAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "expires_at";
+            tableName: "encrypted_storage";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: "PgCustomColumnBuilderBrand";
+        }>;
+        source: import("drizzle-orm/pg-core").PgColumn<{
+            name: "source";
+            tableName: "encrypted_storage";
+            dataType: "json";
+            columnType: "PgJsonb";
+            data: unknown;
+            driverParam: unknown;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: "pg";
+}>;

package/dist/types/tables/index.d.ts

@@ -0,0 +1,2 @@
+export * from './counter';
+export * from './encryptedStorage';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@diia-inhouse/db",
-    "version": "4.12.0",
+    "version": "10.8.0",
     "description": "Package with database connection",
     "main": "dist/index.js",
     "types": "dist/types/index.d.ts",
@@ -11,89 +11,91 @@
         "dist"
     ],
     "engines": {
-        "node": ">=18"
+        "node": ">=22"
+    },
+    "bin": {
+        "diia-db": "dist/cli/index.js"
+    },
+    "exports": {
+        ".": {
+            "types": "./dist/types/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.js"
+        },
+        "./postgres": {
+            "types": "./dist/types/postgres.d.ts",
+            "import": "./dist/postgres.js",
+            "require": "./dist/postgres.js"
+        }
     },
     "scripts": {
         "prebuild": "rimraf dist",
         "build": "tsc",
         "semantic-release": "semantic-release",
-        "start": "npm run build && node dist/index.js",
-        "lint": "eslint --ext .ts . && prettier --check .",
-        "lint-fix": "eslint '*/**/*.{js,ts}' --fix && prettier --write .",
-        "test": "jest",
-        "test:coverage": "jest --coverage",
-        "test:unit": "npm run test --selectProjects unit --",
-        "test:integration": "npm run test --selectProjects integration --",
+        "lint": "eslint . && prettier --check .",
+        "lint-fix": "eslint . --fix && prettier --write .",
+        "test": "vitest run",
+        "test:watch": "vitest watch",
         "prepare": "npm run build",
         "find-circulars": "madge --circular --extensions ts ./",
         "lint:lockfile": "lockfile-lint --path package-lock.json --allowed-hosts registry.npmjs.org --validate-https"
     },
     "dependencies": {
-        "@diia-inhouse/crypto": "1.11.0",
-        "@diia-inhouse/diia-logger": "3.0.0",
-        "@diia-inhouse/utils": "3.5.0",
-        "@diia-inhouse/validators": "1.17.0",
-        "@types/migrate-mongo": "10.0.4",
-        "bson": "6.4.0",
-        "lodash": "4.17.21",
-        "migrate-mongo": "11.0.0",
-        "mongoose": "8.3.5",
-        "recursive-readdir": "2.2.3"
+        "@diia-inhouse/crypto": "1.20.0",
+        "@diia-inhouse/diia-logger": "3.16.0",
+        "@diia-inhouse/diia-metrics": "6.4.0",
+        "@diia-inhouse/utils": "5.3.0",
+        "@diia-inhouse/validators": "1.28.0",
+        "@types/migrate-mongo": "10.0.6",
+        "bson": "6.10.4",
+        "drizzle-orm": "0.45.1",
+        "lodash": "4.17.23",
+        "luxon": "3.7.2",
+        "migrate-mongo": "12.1.3",
+        "mongoose": "8.23.0",
+        "pg": "8.19.0",
+        "recursive-readdir": "2.2.3",
+        "ts-node": "10.9.2",
+        "yargs": "17.7.2"
     },
     "peerDependencies": {
-        "@diia-inhouse/env": ">=1.9.1",
+        "@diia-inhouse/env": ">=2.0.0",
         "@diia-inhouse/errors": ">=1.6.1",
         "@diia-inhouse/types": ">=6.30.0"
     },
     "devDependencies": {
-        "@diia-inhouse/configs": "1.32.0",
-        "@diia-inhouse/env": "1.16.0",
-        "@diia-inhouse/errors": "1.10.0",
-        "@diia-inhouse/eslint-config": "5.1.0",
-        "@diia-inhouse/eslint-plugin": "1.6.0",
-        "@diia-inhouse/test": "6.3.1",
-        "@diia-inhouse/types": "6.30.0",
-        "@types/lodash": "4.17.5",
-        "@types/node": "20.14.5",
+        "@diia-inhouse/configs": "6.1.1",
+        "@diia-inhouse/env": "2.8.1",
+        "@diia-inhouse/errors": "1.17.0",
+        "@diia-inhouse/eslint-config": "8.3.0",
+        "@diia-inhouse/eslint-plugin": "1.9.5",
+        "@diia-inhouse/test": "7.2.0",
+        "@diia-inhouse/types": "11.3.0",
+        "@types/lodash": "4.17.24",
+        "@types/node": "25.3.3",
+        "@types/pg": "8.18.0",
         "@types/recursive-readdir": "2.2.4",
+        "@types/yargs": "17.0.35",
+        "@vitest/coverage-v8": "4.0.18",
+        "@vitest/ui": "4.0.18",
         "dotenv-flow": "4.1.0",
-        "eslint": "8.57.0",
-        "jest": "29.7.0",
-        "lockfile-lint": "4.13.2",
-        "madge": "7.0.0",
-        "protobufjs": "7.2.5",
-        "rimraf": "5.0.7",
-        "semantic-release": "21.1.2",
-        "typescript": "5.4.5"
-    },
-    "jest": {
-        "preset": "@diia-inhouse/configs/dist/jest"
+        "drizzle-kit": "0.31.9",
+        "eslint": "9.39.3",
+        "lockfile-lint": "4.14.1",
+        "madge": "8.0.0",
+        "rimraf": "6.1.3",
+        "semantic-release": "24.2.9",
+        "typescript": "5.9.3",
+        "vite-tsconfig-paths": "6.1.1",
+        "vitest": "4.0.18",
+        "vitest-mock-extended": "3.1.0"
     },
     "release": {
-        "extends": "@diia-inhouse/configs/dist/semantic-release/package",
-        "branches": [
-            "main"
-        ]
+        "extends": "@diia-inhouse/configs/dist/semantic-release/package"
     },
     "commitlint": {
         "extends": "@diia-inhouse/configs/dist/commitlint"
     },
-    "eslintConfig": {
-        "extends": "@diia-inhouse/eslint-config",
-        "overrides": [
-            {
-                "files": [
-                    "*.ts"
-                ],
-                "parserOptions": {
-                    "project": [
-                        "./tsconfig.json",
-                        "./tests/tsconfig.json"
-                    ]
-                }
-            }
-        ]
-    },
     "prettier": "@diia-inhouse/eslint-config/prettier",
     "madge": {
         "tsConfig": "./tsconfig.json"

package/dist/models/encryptedStorage.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"encryptedStorage.js","sourceRoot":"","sources":["../../src/models/encryptedStorage.ts"],"names":[],"mappings":";;AAAA,uCAAuD;AAMvD,MAAM,sBAAsB,GAAG,IAAI,iBAAM,CACrC;IACI,IAAI,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,IAAI,EAAE;IACtC,SAAS,EAAE,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE;IACzC,MAAM,EAAE,EAAE,IAAI,EAAE,EAAE,EAAE;CACvB,EACD;IACI,UAAU,EAAE,IAAI;CACnB,CACJ,CAAA;AAED,sBAAsB,CAAC,KAAK,CAAC,EAAE,SAAS,EAAE,CAAC,EAAE,EAAE,EAAE,kBAAkB,2BAAe,EAAE,CAAC,CAAA;AAErF,kBAAwC,iBAAM,CAAC,gBAAgB,IAAI,IAAA,gBAAK,EAAC,kBAAkB,EAAE,sBAAsB,CAAC,CAAA"}