@bgord/bun 1.20.4 → 1.21.0

package/src/ab-hono.middleware.ts

@@ -2,7 +2,6 @@ import type { MiddlewareHandler } from "hono";
 import { AbMiddleware } from "./ab.middleware";
 import type { AbAssignmentStrategy } from "./ab-assignment.strategy";
 import type { AbVariant } from "./ab-variant.vo";
-import type { AbVariants } from "./ab-variants.vo";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 
@@ -11,16 +10,18 @@ export type AbVariables = { abVariant: AbVariant | undefined };
 export class AbHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: AbMiddleware;
 
-  constructor(variants: AbVariants, strategy: AbAssignmentStrategy) {
-    this.middleware = new AbMiddleware(variants, strategy);
+  constructor(strategy: AbAssignmentStrategy) {
+    this.middleware = new AbMiddleware(strategy);
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: AbVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
-      const variant = await this.middleware.evaluate(context);
 
-      c.set("abVariant", variant);
+      try {
+        const variant = await this.middleware.evaluate(context);
+        c.set("abVariant", variant);
+      } catch {}
 
       return next();
     };

package/src/ab.middleware.ts

@@ -1,15 +1,11 @@
 import type { AbAssignmentStrategy } from "./ab-assignment.strategy";
 import type { AbVariant } from "./ab-variant.vo";
-import type { AbVariants } from "./ab-variants.vo";
 import type { RequestContext } from "./request-context.port";
 
 export class AbMiddleware {
-  constructor(
-    private readonly variants: AbVariants,
-    private readonly strategy: AbAssignmentStrategy,
-  ) {}
+  constructor(private readonly strategy: AbAssignmentStrategy) {}
 
   async evaluate(context: RequestContext): Promise<AbVariant | undefined> {
-    return this.strategy.assign(context, this.variants);
+    return this.strategy.assign(context);
   }
 }

package/src/alert-channel-composite.adapter.ts

@@ -4,6 +4,7 @@ import type { AlertMessage } from "./alert-message.vo";
 export const AlertChannelCompositeError = {
   Min: "alert.channel.composite.channels.min",
   Max: "alert.channel.composite.channels.max",
+  AllFailed: "alert.channel.composite.all.failed",
 };
 
 export class AlertChannelCompositeAdapter implements AlertChannelPort {
@@ -13,7 +14,13 @@ export class AlertChannelCompositeAdapter implements AlertChannelPort {
   }
 
   async send(alert: AlertMessage): Promise<void> {
-    await Promise.allSettled(this.channels.map((channel) => channel.send(alert)));
+    const results = await Promise.allSettled(this.channels.map((channel) => channel.send(alert)));
+
+    if (results.some((result) => result.status === "fulfilled")) return;
+
+    const reasons = results.map((result) => (result as PromiseRejectedResult).reason);
+
+    throw new AggregateError(reasons, AlertChannelCompositeError.AllFailed);
   }
 
   async verify(): Promise<boolean> {

package/src/alert-channel-with-logger.adapter.ts

@@ -23,7 +23,7 @@ export class AlertChannelWithLoggerAdapter implements AlertChannelPort {
       this.deps.Logger.info({
         message: "Alert channel attempt",
         correlationId: CorrelationStorage.get(),
-        metadata: alert.toJSON(),
+        metadata: { alert: alert.toJSON() },
         ...this.base,
       });
 

package/src/antivirus-clamav.adapter.ts

@@ -17,12 +17,13 @@ export class AntivirusClamavAdapter implements AntivirusPort {
     if (!antivirus.stdin) throw new Error(AntivirusPortError.ScanFailed);
     antivirus.stdin.write(bytes);
     await antivirus.stdin.end();
+
+    const stdoutText = new Response(antivirus.stdout).text();
+    const stderrText = new Response(antivirus.stderr).text();
+
     await antivirus.exited;
 
-    const [stdout, stderr] = await Promise.all([
-      new Response(antivirus.stdout).text(),
-      new Response(antivirus.stderr).text(),
-    ]);
+    const [stdout, stderr] = await Promise.all([stdoutText, stderrText]);
 
     if (antivirus.exitCode === 0) return { clean: true };
 

package/src/antivirus-with-logger.adapter.ts

@@ -31,7 +31,7 @@ export class AntivirusWithLoggerAdapter implements AntivirusPort {
       this.deps.Logger.info({
         message: "Antivirus scan success",
         correlationId: CorrelationStorage.get(),
-        metadata: { clean: result.clean, duration: duration.stop() },
+        metadata: { ...result, duration: duration.stop() },
         ...this.base,
       });
 
@@ -41,7 +41,7 @@ export class AntivirusWithLoggerAdapter implements AntivirusPort {
         message: "Antivirus scan error",
         correlationId: CorrelationStorage.get(),
         error,
-        metadata: duration.stop(),
+        metadata: { duration: duration.stop() },
         ...this.base,
       });
 

package/src/api-version-hono.middleware.ts

@@ -1,31 +1,23 @@
 import type { MiddlewareHandler } from "hono";
-import { ApiVersionMiddleware } from "./api-version.middleware";
-import type { BuildInfoType } from "./build-info.vo";
-import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import type { HashContentStrategy } from "./hash-content.strategy";
+import { ApiVersionMiddleware, type ApiVersionMiddlewareDependencies } from "./api-version.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
-import type { ReactiveConfigPort } from "./reactive-config.port";
-
-type Dependencies = {
-  CacheResolver: CacheResolverStrategy;
-  HashContent: HashContentStrategy;
-  BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
-};
 
 export class ApiVersionHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: ApiVersionMiddleware;
 
-  constructor(deps: Dependencies) {
+  constructor(deps: ApiVersionMiddlewareDependencies) {
     this.middleware = new ApiVersionMiddleware(deps);
   }
 
   handle(): MiddlewareHandler {
     return async (c, next) => {
-      const version = await this.middleware.evaluate();
+      await next();
 
-      c.header(ApiVersionMiddleware.HEADER_NAME, version.toString());
+      try {
+        const version = await this.middleware.evaluate();
 
-      return next();
+        c.res.headers.set(ApiVersionMiddleware.HEADER_NAME, version.toString());
+      } catch {}
     };
   }
 }

package/src/api-version.middleware.ts

@@ -6,7 +6,7 @@ import type { ReactiveConfigPort } from "./reactive-config.port";
 import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
 import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
 
-type Dependencies = {
+export type ApiVersionMiddlewareDependencies = {
   CacheResolver: CacheResolverStrategy;
   HashContent: HashContentStrategy;
   BuildInfoConfig: ReactiveConfigPort<BuildInfoType>;
@@ -17,7 +17,7 @@ export class ApiVersionMiddleware {
 
   private readonly resolver: SubjectApplicationResolver;
 
-  constructor(private readonly deps: Dependencies) {
+  constructor(private readonly deps: ApiVersionMiddlewareDependencies) {
     this.resolver = new SubjectApplicationResolver(
       [new SubjectSegmentFixedStrategy("api-version")],
       this.deps,

package/src/auth-session-reader-noop.adapter.ts

@@ -1,5 +1,5 @@
-import type { AuthSessionReaderPort, AuthSessionType } from "../src/auth-session-reader.port";
-import type { HasRequestHeaders } from "../src/request-context.port";
+import type { AuthSessionReaderPort, AuthSessionType } from "./auth-session-reader.port";
+import type { HasRequestHeaders } from "./request-context.port";
 
 export type AuthSessionReaderNoopUserType = { id: string; email: string };
 export type AuthSessionReaderNoopSessionType = { id: string };

package/src/better-auth-logger.service.ts

@@ -27,6 +27,10 @@ export class BetterAuthLogger {
             this.deps.Logger.warn(base);
             break;
           }
+          case LogLevelEnum.debug: {
+            this.deps.Logger.debug(base);
+            break;
+          }
           default: {
             this.deps.Logger.info(base);
             break;
@@ -39,6 +43,7 @@ export class BetterAuthLogger {
   private mapLevel(level: LogLevel | undefined) {
     if (level === "warn") return LogLevelEnum.warn;
     if (level === "error") return LogLevelEnum.error;
+    if (level === "debug") return LogLevelEnum.debug;
     return LogLevelEnum.info;
   }
 }

package/src/cache-file.service.ts

@@ -15,7 +15,8 @@ export const CacheFileMustRevalidate: CacheFileHandler = {
       headers: new Headers({
         ETag: options.etag.get(),
         "Cache-Control": "private, max-age=0, must-revalidate",
-        "Last-Modified": options.lastModified.toInstant().toString(),
+        // biome-ignore lint: lint/style/noRestrictedGlobals
+        "Last-Modified": new Date(options.lastModified.ms).toUTCString(),
         Vary: "Authorization, Cookie",
         ...overrides,
       }),
@@ -28,7 +29,8 @@ export const CacheFileMustRevalidate: CacheFileHandler = {
       "Cache-Control": "private, max-age=0, must-revalidate",
       ETag: options.etag.get(),
       "Content-Length": options.size.toBytes().toString(),
-      "Last-Modified": options.lastModified.toInstant().toString(),
+      // biome-ignore lint: lint/style/noRestrictedGlobals
+      "Last-Modified": new Date(options.lastModified.ms).toUTCString(),
       "Accept-Ranges": "bytes",
       Vary: "Authorization, Cookie",
       ...overrides,

package/src/cache-repository-node-cache.adapter.ts

@@ -19,7 +19,9 @@ export class CacheRepositoryNodeCacheAdapter implements CacheRepositoryPort {
   }
 
   async set<T>(subject: Hash, value: T): Promise<void> {
-    this.store.set(subject.get(), value);
+    try {
+      this.store.set(subject.get(), value);
+    } catch {}
   }
 
   async delete(subject: Hash): Promise<void> {

package/src/cache-response-hono.middleware.ts

@@ -1,17 +1,17 @@
 import { createMiddleware } from "hono/factory";
 import type { ContentfulStatusCode } from "hono/utils/http-status";
-import type { CacheResolverStrategy } from "./cache-resolver.strategy";
-import type { CacheResponseConfig } from "./cache-response.middleware";
-import { CacheResponseMiddleware } from "./cache-response.middleware";
+import {
+  CacheResponseMiddleware,
+  type CacheResponseMiddlewareConfig,
+  type CacheResponseMiddlewareDependencies,
+} from "./cache-response.middleware";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 
-type Dependencies = { CacheResolver: CacheResolverStrategy };
-
 export class CacheResponseHonoMiddleware implements MiddlewareHonoPort {
   private readonly middleware: CacheResponseMiddleware;
 
-  constructor(config: CacheResponseConfig, deps: Dependencies) {
+  constructor(config: CacheResponseMiddlewareConfig, deps: CacheResponseMiddlewareDependencies) {
     this.middleware = new CacheResponseMiddleware(config, deps);
   }
 

package/src/cache-response.middleware.ts

@@ -2,9 +2,9 @@ import type { CacheResolverStrategy, CacheSourceEnum } from "./cache-resolver.st
 import type { RequestContext } from "./request-context.port";
 import type { SubjectRequestResolver } from "./subject-request-resolver.vo";
 
-type Dependencies = { CacheResolver: CacheResolverStrategy };
+export type CacheResponseMiddlewareDependencies = { CacheResolver: CacheResolverStrategy };
 
-export type CacheResponseConfig = { enabled: boolean; resolver: SubjectRequestResolver };
+export type CacheResponseMiddlewareConfig = { enabled: boolean; resolver: SubjectRequestResolver };
 
 export type CachedResponse<T = string> = {
   body: T;
@@ -21,8 +21,8 @@ export class CacheResponseMiddleware {
   static readonly CACHE_HIT_HEADER = "Cache-Hit";
 
   constructor(
-    private readonly config: CacheResponseConfig,
-    private readonly deps: Dependencies,
+    private readonly config: CacheResponseMiddlewareConfig,
+    private readonly deps: CacheResponseMiddlewareDependencies,
   ) {}
 
   async evaluate<T = string>(

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

@@ -11,35 +11,37 @@ export class CertificateInspectorTLSAdapter implements CertificateInspectorPort
 
   async inspect(hostname: HostnameType): Promise<CertificateInspection> {
     return new Promise((resolve) => {
-      // Stryker disable all
-      const cleanup = (socket: tls.TLSSocket) => socket.destroy();
-      // Stryker restore all
+      const settle = (result: CertificateInspection) => {
+        // Stryker disable all
+        socket.destroy();
+        // Stryker restore all
+        resolve(result);
+      };
 
       const socket = tls.connect(
         { host: hostname, port: 443, servername: hostname, rejectUnauthorized: false },
         () => {
-          const certificate = socket.getPeerCertificate();
+          try {
+            const certificate = socket.getPeerCertificate();
 
-          if (!certificate?.valid_to) {
-            cleanup(socket);
-            return resolve({ success: false });
-          }
-          // biome-ignore lint: lint/style/noRestrictedGlobals
-          const remaining = tools.Timestamp.fromNumber(new Date(certificate.valid_to).getTime()).difference(
-            this.deps.Clock.now(),
-          );
+            // Stryker disable next-line ConditionalExpression
+            if (!certificate.valid_to) return settle({ success: false });
 
-          cleanup(socket);
-          resolve({ success: true, remaining });
+            // biome-ignore lint: lint/style/noRestrictedGlobals
+            const remaining = tools.Timestamp.fromNumber(new Date(certificate.valid_to).getTime()).difference(
+              this.deps.Clock.now(),
+            );
+
+            settle({ success: true, remaining });
+          } catch {
+            settle({ success: false });
+          }
         },
       );
 
       // Stryker disable all
-      socket.once("error", () => {
-        // Stryker restore all
-        cleanup(socket);
-        resolve({ success: false });
-      });
+      socket.once("error", () => settle({ success: false }));
+      // Stryker restore all
     });
   }
 }

package/src/correlation-hono.middleware.ts

@@ -1,32 +1,32 @@
 import { createMiddleware } from "hono/factory";
-import { CorrelationMiddleware } from "./correlation.middleware";
+import { CorrelationMiddleware, type CorrelationMiddlewareDependencies } from "./correlation.middleware";
 import { CorrelationStorage } from "./correlation-storage.service";
-import type { IdProviderPort } from "./id-provider.port";
 import type { MiddlewareHonoPort } from "./middleware-hono.port";
 import { RequestContextHonoAdapter } from "./request-context-hono.adapter";
 import type { UUIDType } from "./uuid.vo";
 
-type Dependencies = { IdProvider: IdProviderPort };
-
 export type CorrelationVariables = { correlationId: UUIDType };
 
 export class CorrelationHonoMiddleware implements MiddlewareHonoPort {
   private readonly correlationId: CorrelationMiddleware;
 
-  constructor(deps: Dependencies) {
+  constructor(deps: CorrelationMiddlewareDependencies) {
     this.correlationId = new CorrelationMiddleware(deps);
   }
 
   handle() {
-    return createMiddleware(async (c, next) => {
+    return createMiddleware<{ Variables: CorrelationVariables }>(async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
 
       const result = this.correlationId.evaluate(context);
 
       c.set("correlationId", result);
-      c.header(CorrelationMiddleware.HEADER_NAME, result);
 
-      return CorrelationStorage.run(result, next);
+      return CorrelationStorage.run(result, async () => {
+        await next();
+
+        c.header(CorrelationMiddleware.HEADER_NAME, result);
+      });
     });
   }
 }

package/src/correlation.middleware.ts

@@ -3,12 +3,12 @@ import { CorrelationId, type CorrelationIdType } from "./correlation-id.vo";
 import type { IdProviderPort } from "./id-provider.port";
 import type { HasRequestHeader } from "./request-context.port";
 
-type Dependencies = { IdProvider: IdProviderPort };
+export type CorrelationMiddlewareDependencies = { IdProvider: IdProviderPort };
 
 export class CorrelationMiddleware {
   static readonly HEADER_NAME = "correlation-id";
 
-  constructor(private readonly deps: Dependencies) {}
+  constructor(private readonly deps: CorrelationMiddlewareDependencies) {}
 
   evaluate(context: HasRequestHeader): CorrelationIdType {
     const incoming = context.request.header(CorrelationMiddleware.HEADER_NAME);

package/src/cron-scheduler.adapter.ts

@@ -2,11 +2,13 @@ import type { CronSchedulerPort } from "./cron-scheduler.port";
 import type { CronTask } from "./cron-task.vo";
 
 export class CronSchedulerAdapter implements CronSchedulerPort {
+  private readonly tasks: Array<Bun.CronJob> = [];
+
   schedule(task: CronTask): void {
-    Bun.cron(task.cron, task.handler);
+    this.tasks.push(Bun.cron(task.cron, task.handler));
   }
 
   async verify(): Promise<boolean> {
-    return true;
+    return this.tasks.length > 0;
   }
 }

package/src/cron-task-handler-with-logger.strategy.ts

@@ -24,13 +24,6 @@ export class CronTaskHandlerWithLoggerStrategy implements CronTaskHandlerStrateg
           this.deps.Logger.info({ message: `${task.label} start`, correlationId, ...this.base });
 
           await CorrelationStorage.run(correlationId, task.handler);
-
-          this.deps.Logger.info({
-            message: `${task.label} success`,
-            correlationId,
-            metadata: { duration: duration.stop() },
-            ...this.base,
-          });
         } catch (error) {
           this.deps.Logger.error({
             message: `${task.label} error`,
@@ -40,8 +33,15 @@ export class CronTaskHandlerWithLoggerStrategy implements CronTaskHandlerStrateg
             ...this.base,
           });
 
-          throw error;
+          return;
         }
+
+        this.deps.Logger.info({
+          message: `${task.label} success`,
+          correlationId,
+          metadata: { duration: duration.stop() },
+          ...this.base,
+        });
       },
     };
   }

package/src/csv-stringifier.adapter.ts

@@ -23,8 +23,8 @@ export class CsvStringifierAdapter implements CsvStringifierPort {
     return new CsvStringifierAdapter(dependency);
   }
 
-  async process(columns: ReadonlyArray<CsvColumnType>, data: Array<CsvRowType>): Promise<string> {
+  async process(columns: ReadonlyArray<CsvColumnType>, data: ReadonlyArray<CsvRowType>): Promise<string> {
     // TODO: Potential formula injection
-    return text(this.csv.stringify(data, { header: true, columns }));
+    return text(this.csv.stringify([...data], { header: true, columns }));
   }
 }

package/src/disk-space-checker-fs.adapter.ts

@@ -0,0 +1,12 @@
+/* cSpell:disable */
+import fs from "node:fs/promises";
+import * as tools from "@bgord/tools";
+import type { DiskSpaceCheckerPort } from "./disk-space-checker.port";
+
+export class DiskSpaceCheckerFsAdapter implements DiskSpaceCheckerPort {
+  async get(root: tools.DirectoryPathAbsoluteType): Promise<tools.Size> {
+    const stats = await fs.statfs(root);
+
+    return tools.Size.fromBytes(stats.bavail * stats.bsize);
+  }
+}

package/src/dynamic-import.service.ts

@@ -11,8 +11,8 @@ export class DynamicImport<T> {
   async resolve(): Promise<T> {
     try {
       return await this.import();
-    } catch {
-      throw new Error(this.error);
+    } catch (error) {
+      throw new Error(this.error, { cause: error });
     }
   }
 

package/src/environment-loader-process-safe.adapter.ts

@@ -26,7 +26,10 @@ export class EnvironmentLoaderProcessSafeAdapter<T extends object> implements En
       StandardSchemaValidator.validate(this.config.EnvironmentSchema, this.env),
     );
 
-    for (const key of Object.keys(parsed)) delete process.env[key];
+    for (const key of Object.keys(parsed)) {
+      delete this.env[key];
+      delete process.env[key];
+    }
 
     return Object.freeze({ ...parsed, type: this.config.type });
   }

package/src/environment-loader.port.ts

@@ -1,5 +1,5 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { NodeEnvironmentEnum } from "../src/node-env.vo";
+import type { NodeEnvironmentEnum } from "./node-env.vo";
 
 export type EnvironmentLoaderConfig<T extends object> = {
   type: NodeEnvironmentEnum;

package/src/etag-extractor-header.strategy.ts

@@ -7,6 +7,8 @@ export class ETagExtractorHeaderStrategy implements ETagExtractorStrategy {
     try {
       const header = context.request.header(tools.ETag.IF_MATCH_HEADER_NAME);
 
+      if (!header?.trim()) return null;
+
       return tools.ETag.fromHeader(header);
     } catch {
       return null;

package/src/etag-extractor-hono.middleware.ts

@@ -13,7 +13,7 @@ export class ETagExtractorHonoMiddleware implements MiddlewareHonoPort {
     this.middleware = new ETagExtractorMiddleware(config);
   }
 
-  handle(): MiddlewareHandler {
+  handle(): MiddlewareHandler<{ Variables: ETagVariables }> {
     return async (c, next) => {
       const context = new RequestContextHonoAdapter(c);
       const etag = this.middleware.evaluate(context);

package/src/etag-extractor-param.strategy.ts

@@ -9,6 +9,8 @@ export class ETagExtractorParamStrategy implements ETagExtractorStrategy {
     try {
       const value = context.request.param(this.name);
 
+      if (!value?.trim()) return null;
+
       return tools.ETag.fromHeader(value);
     } catch {
       return null;

package/src/etag-extractor.strategy.ts

@@ -1,6 +1,6 @@
 import type * as tools from "@bgord/tools";
-import type { RequestContext } from "./request-context.port";
+import type { HasRequestHeader, HasRequestParam } from "./request-context.port";
 
 export interface ETagExtractorStrategy {
-  detect(context: RequestContext): tools.ETag | null;
+  detect(context: HasRequestHeader & HasRequestParam): tools.ETag | null;
 }

package/src/file-inspection.adapter.ts

@@ -50,16 +50,16 @@ export class FileInspectionAdapter implements FileInspectionPort {
   }
 
   async size(path: tools.FilePathRelative | tools.FilePathAbsolute | string): Promise<tools.Size> {
-    const file = Bun.file(typeof path === "string" ? path : path.get());
+    const node = await stat(typeof path === "string" ? path : path.get());
 
-    return tools.Size.fromBytes(file.size);
+    return tools.Size.fromBytes(node.size);
   }
 
   async lastModified(
     path: tools.FilePathRelative | tools.FilePathAbsolute | string,
   ): Promise<tools.Timestamp> {
-    const file = Bun.file(typeof path === "string" ? path : path.get());
+    const node = await stat(typeof path === "string" ? path : path.get());
 
-    return tools.Timestamp.fromNumber(file.lastModified);
+    return tools.Timestamp.fromNumber(Math.round(node.mtimeMs));
   }
 }

package/src/file-reader-json-forgiving.adapter.ts

@@ -6,7 +6,7 @@ export class FileReaderJsonForgivingAdapter implements FileReaderJsonPort {
     path: tools.FilePathRelative | tools.FilePathAbsolute | string,
   ): Promise<FileReaderJsonOutputType> {
     try {
-      return Bun.file(typeof path === "string" ? path : path.get()).json();
+      return await Bun.file(typeof path === "string" ? path : path.get()).json();
     } catch {
       return {};
     }

package/src/file-uploader-hono.middleware.ts

@@ -12,8 +12,10 @@ export class FileUploaderHonoMiddleware implements MiddlewareHonoPort {
   }
 
   handle() {
-    return createMiddleware(async (context, next) => {
-      const result = await this.middleware.validate(new RequestContextHonoAdapter(context));
+    return createMiddleware(async (c, next) => {
+      const context = new RequestContextHonoAdapter(c);
+
+      const result = await this.middleware.validate(context);
 
       if (result.valid === false) throw new HTTPException(400, { message: result.error });
       return next();

package/src/graceful-shutdown.service.ts

@@ -12,7 +12,7 @@ export class GracefulShutdown {
 
   constructor(
     private readonly deps: Dependencies,
-    private readonly config: Config = { cleanup: tools.noop, exit: process.exit },
+    private readonly config: Config = { cleanup: tools.noop },
   ) {}
 
   private async shutdown(server: ServerType, exitCode: number) {
@@ -22,7 +22,7 @@ export class GracefulShutdown {
     // Stryker restore all
 
     try {
-      server.stop();
+      await server.stop();
     } catch (error) {
       this.deps.Logger.error({ message: "Server stop failed", error, ...this.base });
     }
@@ -33,7 +33,7 @@ export class GracefulShutdown {
     } catch (error) {
       this.deps.Logger.error({ message: "Cleanup hook failed", error, ...this.base });
     } finally {
-      this.config.exit?.(exitCode);
+      (this.config.exit ?? process.exit)(exitCode);
     }
   }
 

package/src/hash.vo.ts

@@ -13,7 +13,7 @@ export class Hash {
   }
 
   static fromString(candidate: string): Hash {
-    return new Hash(v.parse(HashValue, candidate));
+    return new Hash(v.parse(HashValue, candidate.toLowerCase()));
   }
 
   get(): HashValueType {