@bgord/bun 1.12.7 → 1.12.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.12.7",
+  "version": "1.12.8",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -33,7 +33,7 @@
     "knip": "5.86.0",
     "lefthook": "2.1.3",
     "lockfile-lint": "5.0.0",
-    "nodemailer": "8.0.1",
+    "nodemailer": "8.0.2",
     "only-allow": "1.2.2",
     "resend": "6.9.3",
     "sharp": "0.34.5",
@@ -45,13 +45,13 @@
   "dependencies": {
     "@bgord/tools": "1.3.24",
     "emittery": "2.0.0",
-    "hono": "4.12.5",
+    "hono": "4.12.6",
     "node-cache": "5.1.2"
   },
   "peerDependencies": {
     "better-auth": "1.5.4",
     "csv": "6.4.1",
-    "nodemailer": "8.0.1",
+    "nodemailer": "8.0.2",
     "resend": "6.9.3",
     "sharp": "0.34.5",
     "yazl": "3.3.1",

package/readme.md

@@ -97,6 +97,7 @@ src/
 ├── disk-space-checker-shell.adapter.ts
 ├── disk-space-checker.port.ts
 ├── dispatching-event-store.ts
+├── dynamic-import.service.ts
 ├── encryption-aes-gcm.adapter.ts
 ├── encryption-iv.vo.ts
 ├── encryption-key-value.vo.ts

package/src/certificate-inspector-tls.adapter.ts

@@ -5,38 +5,43 @@ import type { ClockPort } from "./clock.port";
 
 type Dependencies = { Clock: ClockPort };
 
-// Stryker disable all
 export class CertificateInspectorTLSAdapter implements CertificateInspectorPort {
   constructor(private readonly deps: Dependencies) {}
 
   async inspect(hostname: string): Promise<CertificateInspection> {
     return new Promise((resolve) => {
-      const settle = (value: CertificateInspection) => {
-        try {
-          socket.end();
-          socket.destroy();
-        } finally {
-          resolve(value);
-        }
+      // Stryker disable all
+      const cleanup = (socket: tls.TLSSocket) => {
+        socket.end();
+        socket.destroy();
       };
+      // Stryker restore all
 
       const socket = tls.connect(
         { host: hostname, port: 443, servername: hostname, rejectUnauthorized: false },
         () => {
           const certificate = socket.getPeerCertificate();
 
-          if (!certificate?.valid_to) return settle({ success: false });
+          if (!certificate?.valid_to) {
+            cleanup(socket);
+            return resolve({ success: false });
+          }
 
           const remaining = tools.Timestamp.fromDateLike(certificate.valid_to).difference(
             this.deps.Clock.now(),
           );
 
-          settle({ success: true, remaining });
+          cleanup(socket);
+          resolve({ success: true, remaining });
         },
       );
 
-      socket.once("error", () => settle({ success: false }));
+      // Stryker disable all
+      socket.once("error", () => {
+        // Stryker restore all
+        cleanup(socket);
+        resolve({ success: false });
+      });
     });
   }
 }
-// Stryker restore all

package/src/csv-stringifier.adapter.ts

@@ -1,5 +1,6 @@
 import { text } from "node:stream/consumers";
 import type { CsvColumnType, CsvRowType, CsvStringifierPort } from "./csv-stringifier.port";
+import { DynamicImport } from "./dynamic-import.service";
 
 export const CsvStringifierAdapterError = {
   MissingDependency: "csv.stringifier.adapter.error.missing.dependency",
@@ -8,23 +9,17 @@ export const CsvStringifierAdapterError = {
 type CsvLibrary = typeof import("csv");
 
 export class CsvStringifierAdapter implements CsvStringifierPort {
+  private static readonly importer = DynamicImport.for<CsvLibrary>(
+    "csv",
+    CsvStringifierAdapterError.MissingDependency,
+  );
+
   private constructor(private readonly csv: CsvLibrary) {}
 
   static async build(): Promise<CsvStringifierAdapter> {
-    return new CsvStringifierAdapter(await CsvStringifierAdapter.resolve());
-  }
-
-  private static async resolve(): Promise<CsvLibrary> {
-    try {
-      return await CsvStringifierAdapter.import();
-    } catch {
-      throw new Error(CsvStringifierAdapterError.MissingDependency);
-    }
-  }
+    const dependency = await CsvStringifierAdapter.importer.resolve();
 
-  static async import(): Promise<CsvLibrary> {
-    const name = "c" + "sv"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<CsvLibrary>;
+    return new CsvStringifierAdapter(dependency);
   }
 
   async process(columns: ReadonlyArray<CsvColumnType>, data: Array<CsvRowType>): Promise<string> {

package/src/dynamic-import.service.ts

@@ -0,0 +1,26 @@
+export class DynamicImport<T> {
+  private constructor(
+    private readonly dependency: string,
+    private readonly error: string,
+  ) {}
+
+  static for<T>(dependency: string, error: string): DynamicImport<T> {
+    return new DynamicImport<T>(dependency, error);
+  }
+
+  async resolve(): Promise<T> {
+    try {
+      return await this.import();
+    } catch {
+      throw new Error(this.error);
+    }
+  }
+
+  private async import(): Promise<T> {
+    return import(this.obfuscate(this.dependency)) as Promise<T>;
+  }
+
+  private obfuscate(name: string): string {
+    return name;
+  }
+}

package/src/file-draft-zip.service.ts

@@ -1,5 +1,6 @@
 import { Readable } from "node:stream";
 import * as tools from "@bgord/tools";
+import { DynamicImport } from "./dynamic-import.service";
 import { FileDraft } from "./file-draft.service";
 
 export const FileDraftZipError = {
@@ -9,6 +10,11 @@ export const FileDraftZipError = {
 type YazlLibrary = typeof import("yazl");
 
 export class FileDraftZip extends FileDraft {
+  private static readonly importer = DynamicImport.for<YazlLibrary>(
+    "yazl",
+    FileDraftZipError.MissingDependency,
+  );
+
   private constructor(
     basename: tools.BasenameType,
     private readonly parts: ReadonlyArray<FileDraft>,
@@ -18,20 +24,8 @@ export class FileDraftZip extends FileDraft {
   }
 
   static async build(basename: tools.BasenameType, parts: ReadonlyArray<FileDraft>): Promise<FileDraftZip> {
-    return new FileDraftZip(basename, parts, await FileDraftZip.resolve());
-  }
-
-  private static async resolve(): Promise<YazlLibrary> {
-    try {
-      return await FileDraftZip.import();
-    } catch {
-      throw new Error(FileDraftZipError.MissingDependency);
-    }
-  }
-
-  static async import(): Promise<YazlLibrary> {
-    const name = "ya" + "zl"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<YazlLibrary>;
+    const library = await FileDraftZip.importer.resolve();
+    return new FileDraftZip(basename, parts, library);
   }
 
   async create(): Promise<BodyInit> {

package/src/i18n.service.ts

@@ -31,9 +31,10 @@ export class I18n {
 
       if (!translation) {
         that.deps.Logger.warn({
-          message: `Missing translation for key ${key}`,
+          message: "Missing translation key",
           component: "infra",
           operation: "translations",
+          metadata: { key },
         });
 
         return key;

package/src/image-alpha-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageAlphaPort, ImageAlphaStrategy } from "./image-alpha.port";
 
@@ -8,34 +9,24 @@ export const ImageAlphaSharpAdapterError = {
 };
 
 type Dependencies = { FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageAlphaSharpAdapter implements ImageAlphaPort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageAlphaSharpAdapterError.MissingDependency,
+  );
+
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageAlphaSharpAdapter> {
-    return new ImageAlphaSharpAdapter(await ImageAlphaSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageAlphaSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageAlphaSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageAlphaSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageAlphaSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async flatten(recipe: ImageAlphaStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;

package/src/image-blur-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
 
@@ -8,34 +9,24 @@ export const ImageBlurSharpAdapterError = {
 };
 
 type Dependencies = { FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageBlurSharpAdapter implements ImageBlurPort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageBlurSharpAdapterError.MissingDependency,
+  );
+
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageBlurSharpAdapter> {
-    return new ImageBlurSharpAdapter(await ImageBlurSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageBlurSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageBlurSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageBlurSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageBlurSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async blur(recipe: ImageBlurStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;

package/src/image-compressor-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageCompressorPort, ImageCompressorStrategy } from "./image-compressor.port";
 
@@ -8,36 +9,25 @@ export const ImageCompressorSharpAdapterError = {
 };
 
 type Dependencies = { FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageCompressorSharpAdapter implements ImageCompressorPort {
   private static readonly DEFAULT_QUALITY = 85;
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageCompressorSharpAdapterError.MissingDependency,
+  );
 
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageCompressorSharpAdapter> {
-    return new ImageCompressorSharpAdapter(await ImageCompressorSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageCompressorSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageCompressorSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageCompressorSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageCompressorSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async compress(recipe: ImageCompressorStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const quality = recipe.quality ?? ImageCompressorSharpAdapter.DEFAULT_QUALITY;

package/src/image-exif-clear-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageExifClearPort, ImageExifClearStrategy } from "./image-exif-clear.port";
 
@@ -8,34 +9,24 @@ export const ImageExifClearSharpAdapterError = {
 };
 
 type Dependencies = { FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageExifClearSharpAdapter implements ImageExifClearPort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageExifClearSharpAdapterError.MissingDependency,
+  );
+
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageExifClearSharpAdapter> {
-    return new ImageExifClearSharpAdapter(await ImageExifClearSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageExifClearSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageExifClearSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageExifClearSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageExifClearSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async clear(recipe: ImageExifClearStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;

package/src/image-formatter-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileCleanerPort } from "./file-cleaner.port";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageFormatterPort, ImageFormatterStrategy } from "./image-formatter.port";
@@ -9,34 +10,24 @@ export const ImageFormatterSharpAdapterError = {
 };
 
 type Dependencies = { FileCleaner: FileCleanerPort; FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageFormatterSharpAdapter implements ImageFormatterPort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageFormatterSharpAdapterError.MissingDependency,
+  );
+
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageFormatterSharpAdapter> {
-    return new ImageFormatterSharpAdapter(await ImageFormatterSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageFormatterSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageFormatterSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageFormatterSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageFormatterSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async format(recipe: ImageFormatterStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final =

package/src/image-info-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileInspectionPort } from "./file-inspection.port";
 import type { ImageInfoPort, ImageInfoType } from "./image-info.port";
 
@@ -8,34 +9,24 @@ export const ImageInfoSharpAdapterError = {
 };
 
 type Dependencies = { FileInspection: FileInspectionPort; MimeRegistry: tools.MimeRegistry };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageInfoSharpAdapter implements ImageInfoPort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageInfoSharpAdapterError.MissingDependency,
+  );
+
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageInfoSharpAdapter> {
-    return new ImageInfoSharpAdapter(await ImageInfoSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageInfoSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageInfoSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageInfoSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageInfoSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async inspect(input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
     const size = await this.deps.FileInspection.size(input);

package/src/image-processor-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileCleanerPort } from "./file-cleaner.port";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageProcessorPort, ImageProcessorStrategy } from "./image-processor.port";
@@ -9,36 +10,25 @@ export const ImageProcessorSharpAdapterError = {
 };
 
 type Dependencies = { FileCleaner: FileCleanerPort; FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageProcessorSharpAdapter implements ImageProcessorPort {
   private static readonly DEFAULT_QUALITY = 85;
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageProcessorSharpAdapterError.MissingDependency,
+  );
 
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageProcessorSharpAdapter> {
-    return new ImageProcessorSharpAdapter(await ImageProcessorSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageProcessorSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageProcessorSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageProcessorSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageProcessorSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async process(recipe: ImageProcessorStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final =

package/src/image-resizer-sharp.adapter.ts

@@ -1,5 +1,6 @@
 import type * as tools from "@bgord/tools";
 import type sharp from "sharp";
+import { DynamicImport } from "./dynamic-import.service";
 import type { FileRenamerPort } from "./file-renamer.port";
 import type { ImageResizerPort, ImageResizerStrategy } from "./image-resizer.port";
 
@@ -8,34 +9,24 @@ export const ImageResizerSharpAdapterError = {
 };
 
 type Dependencies = { FileRenamer: FileRenamerPort };
-type SharpCallable = typeof sharp;
-type SharpModule = { default: SharpCallable };
+type Sharp = typeof sharp;
 
 export class ImageResizerSharpAdapter implements ImageResizerPort {
+  private static readonly importer = DynamicImport.for<{ default: Sharp }>(
+    "sharp",
+    ImageResizerSharpAdapterError.MissingDependency,
+  );
+
   private constructor(
-    private readonly sharp: SharpCallable,
+    private readonly sharp: Sharp,
     private readonly deps: Dependencies,
   ) {}
 
   static async build(deps: Dependencies): Promise<ImageResizerSharpAdapter> {
-    return new ImageResizerSharpAdapter(await ImageResizerSharpAdapter.resolve(), deps);
-  }
-
-  private static async resolve(): Promise<SharpCallable> {
-    try {
-      const module = await ImageResizerSharpAdapter.import();
-      return module.default;
-    } catch {
-      throw new Error(ImageResizerSharpAdapterError.MissingDependency);
-    }
-  }
+    const library = await ImageResizerSharpAdapter.importer.resolve();
 
-  // Stryker disable all
-  static async import(): Promise<SharpModule> {
-    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
-    return import(name) as Promise<SharpModule>;
+    return new ImageResizerSharpAdapter(library.default, deps);
   }
-  // Stryker restore all
 
   async resize(recipe: ImageResizerStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
     const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;

package/src/index.ts

@@ -69,6 +69,7 @@ export * from "./disk-space-checker.port";
 export * from "./disk-space-checker-noop.adapter";
 export * from "./disk-space-checker-shell.adapter";
 export * from "./dispatching-event-store";
+export * from "./dynamic-import.service";
 export * from "./encryption.port";
 export * from "./encryption-aes-gcm.adapter";
 export * from "./encryption-key.vo";