@diia-inhouse/db 10.8.14 → 12.3.1

package/dist/services/encryptedStorage.js

@@ -1,215 +1,179 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncryptedStorageService = void 0;
-const drizzle_orm_1 = require("drizzle-orm");
-const errors_1 = require("@diia-inhouse/errors");
-const utils_1 = require("@diia-inhouse/utils");
-const encryptedStorage_1 = require("../tables/encryptedStorage");
+import { encryptedStorage } from "../tables/encryptedStorage.js";
+import { NotFoundError } from "@diia-inhouse/errors";
+import { eq, inArray } from "drizzle-orm";
+import { utils } from "@diia-inhouse/utils";
+//#region src/services/encryptedStorage.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}
- * ```
- */
-class EncryptedStorageService {
-    logger;
-    auth;
-    envService;
-    databaseAdapter;
-    encryptedStorageModel;
-    postgresDatabase;
-    saveEntityStrategy = {
-        postgres: async (storageItem) => {
-            const result = await this.getPostgresDatabase()
-                .insert(encryptedStorage_1.encryptedStorage)
-                .values(storageItem)
-                .returning()
-                .then((rows) => rows[0]);
-            return result.id;
-        },
-        mongo: async (storageItem) => {
-            const result = await this.getModel().create(storageItem);
-            return result._id.toString();
-        },
-    };
-    updateEntityStrategy = {
-        postgres: async (id, updateData) => {
-            await this.getPostgresDatabase().update(encryptedStorage_1.encryptedStorage).set(updateData).where((0, drizzle_orm_1.eq)(encryptedStorage_1.encryptedStorage.id, id));
-        },
-        mongo: async (id, updateData) => {
-            await this.getModel().findByIdAndUpdate(id, updateData);
-        },
-    };
-    findEntityStrategy = {
-        postgres: async (id) => {
-            return await this.getPostgresDatabase()
-                .select()
-                .from(encryptedStorage_1.encryptedStorage)
-                .where((0, drizzle_orm_1.eq)(encryptedStorage_1.encryptedStorage.id, id))
-                .then((rows) => rows[0]);
-        },
-        mongo: async (id, options) => {
-            return await this.getModel().findById(id, undefined, options);
-        },
-    };
-    deleteManyStrategy = {
-        postgres: async (ids) => {
-            const result = await this.getPostgresDatabase().delete(encryptedStorage_1.encryptedStorage).where((0, drizzle_orm_1.inArray)(encryptedStorage_1.encryptedStorage.id, ids));
-            return result.rowCount;
-        },
-        mongo: async (ids) => {
-            const result = await this.getModel().deleteMany({ _id: { $in: ids } });
-            return result.deletedCount;
-        },
-    };
-    removeEntityStrategy = {
-        postgres: async (id) => {
-            return await this.getPostgresDatabase()
-                .delete(encryptedStorage_1.encryptedStorage)
-                .where((0, drizzle_orm_1.eq)(encryptedStorage_1.encryptedStorage.id, id))
-                .returning()
-                .then((rows) => rows[0]);
-        },
-        mongo: async (id) => {
-            return await this.getModel().findOneAndDelete({ _id: id });
-        },
-    };
-    findExpirationStrategy = {
-        postgres: async (id) => {
-            return await this.getPostgresDatabase()
-                .select({ expiresAt: encryptedStorage_1.encryptedStorage.expiresAt })
-                .from(encryptedStorage_1.encryptedStorage)
-                .where((0, drizzle_orm_1.eq)(encryptedStorage_1.encryptedStorage.id, id))
-                .then((rows) => rows[0].expiresAt);
-        },
-        mongo: async (id) => {
-            const result = await this.getModel().findById(id, { expiresAt: 1 });
-            return result?.expiresAt;
-        },
-    };
-    constructor(logger, auth, envService, databaseAdapter, encryptedStorageModel = null, postgresDatabase = null) {
-        this.logger = logger;
-        this.auth = auth;
-        this.envService = envService;
-        this.databaseAdapter = databaseAdapter;
-        this.encryptedStorageModel = encryptedStorageModel;
-        this.postgresDatabase = postgresDatabase;
-    }
-    async save(data, expiration) {
-        const encryptedData = await this.auth.encryptJWE(utils_1.utils.encodeObjectToBase64(data));
-        const storageItem = {
-            data: encryptedData,
-            expiresAt: new Date(Date.now() + expiration),
-        };
-        if (!this.envService.isProd()) {
-            storageItem.source = data;
-        }
-        return await this.saveEntityStrategy[this.databaseAdapter](storageItem);
-    }
-    async get(id, options = {}) {
-        const storageItem = await this.getStorageItemById(id, options);
-        const decryptedData = await this.auth.decryptJWE(storageItem.data);
-        return await utils_1.utils.decodeObjectFromBase64(decryptedData);
-    }
-    async getSafe(id, options = {}) {
-        try {
-            return await this.get(id, options);
-        }
-        catch (err) {
-            this.logger.log('Unable to retrieve data from encrypted storage', { err });
-            return undefined;
-        }
-    }
-    async update(id, data) {
-        const storageItem = await this.getStorageItemById(id);
-        const encryptedData = await this.auth.encryptJWE(utils_1.utils.encodeObjectToBase64(data));
-        storageItem.data = encryptedData;
-        if (!this.envService.isProd()) {
-            storageItem.source = data;
-        }
-        await this.updateEntityStrategy[this.databaseAdapter](id, storageItem);
-    }
-    async remove(id) {
-        const storageItem = await this.removeEntityStrategy[this.databaseAdapter](id);
-        if (!storageItem) {
-            this.logger.info('Encrypted data is not removed from storage: data not found', { id });
-            return;
-        }
-        this.logger.info('Encrypted data removed from storage', { id });
-    }
-    async deleteMany(ids) {
-        const deletedCount = await this.deleteManyStrategy[this.databaseAdapter](ids);
-        this.logger.info(`Encrypted data removed from storage: ${deletedCount}`);
-    }
-    async setExpiration(id, expiration) {
-        const expiresAt = await this.findExpirationStrategy[this.databaseAdapter](id);
-        if (!expiresAt) {
-            this.logger.error('Encrypted data is not found in storage', { id });
-            throw new errors_1.NotFoundError('Missing data');
-        }
-        const newExpiresAt = new Date(Date.now() + expiration);
-        await this.updateEntityStrategy[this.databaseAdapter](id, { expiresAt: newExpiresAt });
-        this.logger.info('Updated encrypted data expiration date', { id });
-    }
-    async getExpiration(id) {
-        const expiresAt = await this.findExpirationStrategy[this.databaseAdapter](id);
-        if (!expiresAt) {
-            this.logger.error('Encrypted data is not found in storage', { id });
-            throw new errors_1.NotFoundError('Missing data');
-        }
-        return expiresAt;
-    }
-    async getStorageItemById(id, options = {}) {
-        const storageItem = await this.findEntityStrategy[this.databaseAdapter](id, options);
-        if (!storageItem) {
-            this.logger.error('Encrypted data is not found in storage', { id });
-            throw new errors_1.NotFoundError('Missing data');
-        }
-        return storageItem;
-    }
-    getModel() {
-        if (!this.encryptedStorageModel) {
-            throw new Error('Encrypted storage model is not provided');
-        }
-        return this.encryptedStorageModel;
-    }
-    getPostgresDatabase() {
-        if (!this.postgresDatabase) {
-            throw new Error('Postgres database is not provided');
-        }
-        return this.postgresDatabase;
-    }
-}
-exports.EncryptedStorageService = EncryptedStorageService;
-//# sourceMappingURL=encryptedStorage.js.map
+* 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}
+* ```
+*/
+var EncryptedStorageService = class {
+	logger;
+	auth;
+	envService;
+	databaseAdapter;
+	encryptedStorageModel;
+	postgresDatabase;
+	saveEntityStrategy = {
+		postgres: async (storageItem) => {
+			return (await this.getPostgresDatabase().insert(encryptedStorage).values(storageItem).returning().then((rows) => rows[0])).id;
+		},
+		mongo: async (storageItem) => {
+			return (await this.getModel().create(storageItem))._id.toString();
+		}
+	};
+	updateEntityStrategy = {
+		postgres: async (id, updateData) => {
+			await this.getPostgresDatabase().update(encryptedStorage).set(updateData).where(eq(encryptedStorage.id, id));
+		},
+		mongo: async (id, updateData) => {
+			await this.getModel().findByIdAndUpdate(id, updateData);
+		}
+	};
+	findEntityStrategy = {
+		postgres: async (id) => {
+			return await this.getPostgresDatabase().select().from(encryptedStorage).where(eq(encryptedStorage.id, id)).then((rows) => rows[0]);
+		},
+		mongo: async (id, options) => {
+			return await this.getModel().findById(id, void 0, options);
+		}
+	};
+	deleteManyStrategy = {
+		postgres: async (ids) => {
+			return (await this.getPostgresDatabase().delete(encryptedStorage).where(inArray(encryptedStorage.id, ids))).rowCount;
+		},
+		mongo: async (ids) => {
+			return (await this.getModel().deleteMany({ _id: { $in: ids } })).deletedCount;
+		}
+	};
+	removeEntityStrategy = {
+		postgres: async (id) => {
+			return await this.getPostgresDatabase().delete(encryptedStorage).where(eq(encryptedStorage.id, id)).returning().then((rows) => rows[0]);
+		},
+		mongo: async (id) => {
+			return await this.getModel().findOneAndDelete({ _id: id });
+		}
+	};
+	findExpirationStrategy = {
+		postgres: async (id) => {
+			return await this.getPostgresDatabase().select({ expiresAt: encryptedStorage.expiresAt }).from(encryptedStorage).where(eq(encryptedStorage.id, id)).then((rows) => rows[0].expiresAt);
+		},
+		mongo: async (id) => {
+			return (await this.getModel().findById(id, { expiresAt: 1 }))?.expiresAt;
+		}
+	};
+	constructor(logger, auth, envService, databaseAdapter, encryptedStorageModel = null, postgresDatabase = null) {
+		this.logger = logger;
+		this.auth = auth;
+		this.envService = envService;
+		this.databaseAdapter = databaseAdapter;
+		this.encryptedStorageModel = encryptedStorageModel;
+		this.postgresDatabase = postgresDatabase;
+	}
+	async save(data, expiration) {
+		const storageItem = {
+			data: await this.auth.encryptJWE(utils.encodeObjectToBase64(data)),
+			expiresAt: new Date(Date.now() + expiration)
+		};
+		if (!this.envService.isProd()) storageItem.source = data;
+		return await this.saveEntityStrategy[this.databaseAdapter](storageItem);
+	}
+	async get(id, options = {}) {
+		const storageItem = await this.getStorageItemById(id, options);
+		const decryptedData = await this.auth.decryptJWE(storageItem.data);
+		return await utils.decodeObjectFromBase64(decryptedData);
+	}
+	async getSafe(id, options = {}) {
+		try {
+			return await this.get(id, options);
+		} catch (err) {
+			this.logger.log("Unable to retrieve data from encrypted storage", { err });
+			return;
+		}
+	}
+	async update(id, data) {
+		const storageItem = await this.getStorageItemById(id);
+		storageItem.data = await this.auth.encryptJWE(utils.encodeObjectToBase64(data));
+		if (!this.envService.isProd()) storageItem.source = data;
+		await this.updateEntityStrategy[this.databaseAdapter](id, storageItem);
+	}
+	async remove(id) {
+		if (!await this.removeEntityStrategy[this.databaseAdapter](id)) {
+			this.logger.info("Encrypted data is not removed from storage: data not found", { id });
+			return;
+		}
+		this.logger.info("Encrypted data removed from storage", { id });
+	}
+	async deleteMany(ids) {
+		const deletedCount = await this.deleteManyStrategy[this.databaseAdapter](ids);
+		this.logger.info(`Encrypted data removed from storage: ${deletedCount}`);
+	}
+	async setExpiration(id, expiration) {
+		if (!await this.findExpirationStrategy[this.databaseAdapter](id)) {
+			this.logger.error("Encrypted data is not found in storage", { id });
+			throw new NotFoundError("Missing data");
+		}
+		const newExpiresAt = new Date(Date.now() + expiration);
+		await this.updateEntityStrategy[this.databaseAdapter](id, { expiresAt: newExpiresAt });
+		this.logger.info("Updated encrypted data expiration date", { id });
+	}
+	async getExpiration(id) {
+		const expiresAt = await this.findExpirationStrategy[this.databaseAdapter](id);
+		if (!expiresAt) {
+			this.logger.error("Encrypted data is not found in storage", { id });
+			throw new NotFoundError("Missing data");
+		}
+		return expiresAt;
+	}
+	async getStorageItemById(id, options = {}) {
+		const storageItem = await this.findEntityStrategy[this.databaseAdapter](id, options);
+		if (!storageItem) {
+			this.logger.error("Encrypted data is not found in storage", { id });
+			throw new NotFoundError("Missing data");
+		}
+		return storageItem;
+	}
+	getModel() {
+		if (!this.encryptedStorageModel) throw new Error("Encrypted storage model is not provided");
+		return this.encryptedStorageModel;
+	}
+	getPostgresDatabase() {
+		if (!this.postgresDatabase) throw new Error("Postgres database is not provided");
+		return this.postgresDatabase;
+	}
+};
+//#endregion
+export { EncryptedStorageService };

package/dist/services/index.d.ts

@@ -0,0 +1,4 @@
+import { DatabaseService } from "./database.js";
+import { PostgresDatabaseService } from "./postgresDatabase.js";
+import { EncryptedStorageService } from "./encryptedStorage.js";
+import { CounterService } from "./counter.js";

package/dist/services/index.js

@@ -1,21 +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("./database"), exports);
-__exportStar(require("./postgresDatabase"), exports);
-__exportStar(require("./encryptedStorage"), exports);
-__exportStar(require("./counter"), exports);
-//# sourceMappingURL=index.js.map
+import "./database.js";
+import "./postgresDatabase.js";
+import "./encryptedStorage.js";
+import "./counter.js";
+export {};

package/dist/services/postgresDatabase.d.ts

@@ -0,0 +1,12 @@
+import { DatabaseAdapterType, PostgresDatabase } from "../interfaces/database.js";
+import { OnInit } from "@diia-inhouse/types";
+
+//#region src/services/postgresDatabase.d.ts
+declare class PostgresDatabaseService implements OnInit {
+  private readonly databaseAdapter;
+  private readonly postgresDatabase;
+  constructor(databaseAdapter: DatabaseAdapterType, postgresDatabase: PostgresDatabase);
+  onInit(): Promise<void>;
+}
+//#endregion
+export { PostgresDatabaseService };

package/dist/services/postgresDatabase.js

@@ -1,25 +1,20 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresDatabaseService = void 0;
-const errors_1 = require("@diia-inhouse/errors");
-class PostgresDatabaseService {
-    databaseAdapter;
-    postgresDatabase;
-    constructor(databaseAdapter, postgresDatabase) {
-        this.databaseAdapter = databaseAdapter;
-        this.postgresDatabase = postgresDatabase;
-    }
-    async onInit() {
-        if (this.databaseAdapter !== 'postgres') {
-            return;
-        }
-        try {
-            await this.postgresDatabase.execute('SELECT 1');
-        }
-        catch (err) {
-            throw new errors_1.DatabaseError('Failed to connect to postgres database', { err });
-        }
-    }
-}
-exports.PostgresDatabaseService = PostgresDatabaseService;
-//# sourceMappingURL=postgresDatabase.js.map
+import { DatabaseError } from "@diia-inhouse/errors";
+//#region src/services/postgresDatabase.ts
+var PostgresDatabaseService = class {
+	databaseAdapter;
+	postgresDatabase;
+	constructor(databaseAdapter, postgresDatabase) {
+		this.databaseAdapter = databaseAdapter;
+		this.postgresDatabase = postgresDatabase;
+	}
+	async onInit() {
+		if (this.databaseAdapter !== "postgres") return;
+		try {
+			await this.postgresDatabase.execute("SELECT 1");
+		} catch (err) {
+			throw new DatabaseError("Failed to connect to postgres database", { err });
+		}
+	}
+};
+//#endregion
+export { PostgresDatabaseService };

package/dist/tables/counter.d.ts

@@ -0,0 +1,4 @@
+//#region src/tables/counter.d.ts
+declare const counter: any;
+//#endregion
+export { counter };

package/dist/tables/counter.js

@@ -1,12 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.counter = void 0;
-const pg_core_1 = require("drizzle-orm/pg-core");
-const postgresUtils_1 = require("../postgresUtils");
-exports.counter = (0, pg_core_1.pgTable)('counter', {
-    code: (0, pg_core_1.varchar)().notNull(),
-    value: (0, pg_core_1.integer)().notNull(),
-    date: (0, pg_core_1.timestamp)().notNull(),
-    ...postgresUtils_1.timestamps,
-}, (table) => [(0, pg_core_1.unique)('counter_code_date_idx').on(table.code, table.date)]);
-//# sourceMappingURL=counter.js.map
+import { timestamps } from "../postgresUtils.js";
+import { integer, pgTable, timestamp, unique, varchar } from "drizzle-orm/pg-core";
+//#region src/tables/counter.ts
+const counter = pgTable("counter", {
+	code: varchar().notNull(),
+	value: integer().notNull(),
+	date: timestamp().notNull(),
+	...timestamps
+}, (table) => [unique("counter_code_date_idx").on(table.code, table.date)]);
+//#endregion
+export { counter };

package/dist/tables/encryptedStorage.d.ts

@@ -0,0 +1,4 @@
+//#region src/tables/encryptedStorage.d.ts
+declare const encryptedStorage: any;
+//#endregion
+export { encryptedStorage };

package/dist/tables/encryptedStorage.js

@@ -1,14 +1,13 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.encryptedStorage = void 0;
-const pg_core_1 = require("drizzle-orm/pg-core");
-const types_1 = require("@diia-inhouse/types");
-const postgresUtils_1 = require("../postgresUtils");
-exports.encryptedStorage = (0, pg_core_1.pgTable)('encrypted_storage', {
-    id: (0, pg_core_1.uuid)('id').primaryKey().defaultRandom(),
-    data: (0, pg_core_1.text)('data').notNull(),
-    expiresAt: (0, postgresUtils_1.expiringTimestamp)('expires_at', { expireAfterSeconds: types_1.DurationS.Day }).notNull(),
-    source: (0, pg_core_1.jsonb)('source'),
-    ...postgresUtils_1.timestamps,
+import { expiringTimestamp, timestamps } from "../postgresUtils.js";
+import { DurationS } from "@diia-inhouse/types";
+import { jsonb, pgTable, text, uuid } from "drizzle-orm/pg-core";
+//#region src/tables/encryptedStorage.ts
+const encryptedStorage = pgTable("encrypted_storage", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	data: text("data").notNull(),
+	expiresAt: expiringTimestamp("expires_at", { expireAfterSeconds: DurationS.Day }).notNull(),
+	source: jsonb("source"),
+	...timestamps
 });
-//# sourceMappingURL=encryptedStorage.js.map
+//#endregion
+export { encryptedStorage };

package/dist/tables/index.d.ts

@@ -0,0 +1,9 @@
+import { counter } from "./counter.js";
+import { encryptedStorage } from "./encryptedStorage.js";
+
+//#region src/tables/index.d.ts
+declare namespace index_d_exports {
+  export { counter, encryptedStorage };
+}
+//#endregion
+export { index_d_exports };

package/dist/tables/index.js

@@ -1,19 +1,3 @@
-"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);
-//# sourceMappingURL=index.js.map
+import "./encryptedStorage.js";
+import "./counter.js";
+export {};