@bgord/bun 1.16.1 → 1.16.2

package/src/image-formatter-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageFormatterPort, ImageFormatterStrategy } from "./image-formatter.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageFormatterPort; semaphore: Semaphore };
+
+export class ImageFormatterWithSemaphoreAdapter implements ImageFormatterPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async format(recipe: ImageFormatterStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.format(recipe));
+  }
+}

package/src/image-grayscale-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageGrayscalePort, ImageGrayscaleStrategy } from "./image-grayscale.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageGrayscalePort; semaphore: Semaphore };
+
+export class ImageGrayscaleWithSemaphoreAdapter implements ImageGrayscalePort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async grayscale(recipe: ImageGrayscaleStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.grayscale(recipe));
+  }
+}

package/src/image-info-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageInfoPort, ImageInfoType } from "./image-info.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageInfoPort; semaphore: Semaphore };
+
+export class ImageInfoWithSemaphoreAdapter implements ImageInfoPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async inspect(input: tools.FilePathRelative | tools.FilePathAbsolute): Promise<ImageInfoType> {
+    return this.deps.semaphore.run(() => this.deps.inner.inspect(input));
+  }
+}

package/src/image-processor-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageProcessorPort, ImageProcessorStrategy } from "./image-processor.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageProcessorPort; semaphore: Semaphore };
+
+export class ImageProcessorWithSemaphoreAdapter implements ImageProcessorPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async process(recipe: ImageProcessorStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.process(recipe));
+  }
+}

package/src/image-resizer-with-semaphore.adapter.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { ImageResizerPort, ImageResizerStrategy } from "./image-resizer.port";
+import type { Semaphore } from "./semaphore.service";
+
+type Dependencies = { inner: ImageResizerPort; semaphore: Semaphore };
+
+export class ImageResizerWithSemaphoreAdapter implements ImageResizerPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async resize(recipe: ImageResizerStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute> {
+    return this.deps.semaphore.run(() => this.deps.inner.resize(recipe));
+  }
+}

package/src/index.ts

@@ -24,6 +24,8 @@ export * from "./alert-message.vo";
 export * from "./antivirus.port";
 export * from "./antivirus-clamav.adapter";
 export * from "./antivirus-noop.adapter";
+export * from "./antivirus-with-logger.adapter";
+export * from "./antivirus-with-semaphore.adapter";
 export * from "./api-version.middleware";
 export * from "./api-version-hono.middleware";
 export * from "./auth-session-reader.port";
@@ -70,6 +72,7 @@ export * from "./crypto-key-provider-noop.adapter";
 export * from "./crypto-key-provider-with-cache.adapter";
 export * from "./csv-stringifier.adapter";
 export * from "./csv-stringifier.port";
+export * from "./csv-stringifier-noop.adapter";
 export * from "./directory-ensurer.adapter";
 export * from "./directory-ensurer.port";
 export * from "./directory-ensurer-noop.adapter";
@@ -87,7 +90,6 @@ export * from "./environment-loader-encrypted.adapter";
 export * from "./environment-loader-noop.adapter";
 export * from "./environment-loader-process.adapter";
 export * from "./environment-loader-process-safe.adapter";
-export * from "./error-normalizer.service";
 export * from "./etag-extractor.middleware";
 export * from "./etag-extractor-hono.middleware";
 export * from "./event.types";
@@ -153,6 +155,7 @@ export * from "./file-uploader.middleware";
 export * from "./file-uploader-hono.middleware";
 export * from "./file-writer.adapter";
 export * from "./file-writer.port";
+export * from "./file-writer-forgiving.adapter";
 export * from "./file-writer-noop.adapter";
 export * from "./fnv1a32.service";
 export * from "./graceful-shutdown.service";
@@ -183,30 +186,39 @@ export * from "./id-provider-deterministic.adapter";
 export * from "./image-alpha.port";
 export * from "./image-alpha-noop.adapter";
 export * from "./image-alpha-sharp.adapter";
+export * from "./image-alpha-with-semaphore.adapter";
 export * from "./image-blur.port";
 export * from "./image-blur-noop.adapter";
 export * from "./image-blur-sharp.adapter";
+export * from "./image-blur-with-semaphore.adapter";
 export * from "./image-compressor.port";
 export * from "./image-compressor-noop.adapter";
 export * from "./image-compressor-sharp.adapter";
+export * from "./image-compressor-with-semaphore.adapter";
 export * from "./image-exif-clear.port";
 export * from "./image-exif-clear-noop.adapter";
 export * from "./image-exif-clear-sharp.adapter";
+export * from "./image-exif-clear-with-semaphore.adapter";
 export * from "./image-formatter.port";
 export * from "./image-formatter-noop.adapter";
 export * from "./image-formatter-sharp.adapter";
+export * from "./image-formatter-with-semaphore.adapter";
 export * from "./image-grayscale.port";
 export * from "./image-grayscale-noop.adapter";
 export * from "./image-grayscale-sharp.adapter";
+export * from "./image-grayscale-with-semaphore.adapter";
 export * from "./image-info.port";
 export * from "./image-info-noop.adapter";
 export * from "./image-info-sharp.adapter";
+export * from "./image-info-with-semaphore.adapter";
 export * from "./image-processor.port";
 export * from "./image-processor-noop.adapter";
 export * from "./image-processor-sharp.adapter";
+export * from "./image-processor-with-semaphore.adapter";
 export * from "./image-resizer.port";
 export * from "./image-resizer-noop.adapter";
 export * from "./image-resizer-sharp.adapter";
+export * from "./image-resizer-with-semaphore.adapter";
 export * from "./in-flight-requests-hono.middleware";
 export * from "./in-flight-requests-tracker.service";
 export * from "./instrumentation.service";
@@ -324,6 +336,7 @@ export * from "./redactor-noop.strategy";
 export * from "./remote-file-storage.port";
 export * from "./remote-file-storage-disk.adapter";
 export * from "./remote-file-storage-noop.adapter";
+export * from "./remote-file-storage-with-logger.adapter";
 export * from "./request-context.port";
 export * from "./request-context-hono.adapter";
 export * from "./retry.service";
@@ -357,6 +370,7 @@ export * from "./security-rule-or.strategy";
 export * from "./security-rule-pass.strategy";
 export * from "./security-rule-user-agent.strategy";
 export * from "./security-rule-violation-threshold.strategy";
+export * from "./semaphore.service";
 export * from "./setup-hono.service";
 export * from "./shield-api-key.strategy";
 export * from "./shield-api-key-hono.strategy";

package/src/language-detector-header.strategy.ts

@@ -12,11 +12,9 @@ export class LanguageDetectorHeaderStrategy<T extends tools.LanguageType>
     if (!header) return null;
 
     // Example Accept-Language header: en-US,en;q=0.9,pl;q=0.8
-    // Stryker disable all
     const incoming = header
       .split(",")
       .map((language) => language.split(";")[0]?.trim().toLowerCase().split("-")[0]);
-    // Stryker restore all
 
     return incoming.find((language) => languages.isSupported(language)) ?? null;
   }

package/src/logger.port.ts

@@ -1,6 +1,5 @@
 import type * as tools from "@bgord/tools";
 import type { CorrelationIdType } from "./correlation-id.vo";
-import type { NormalizedError } from "./error-normalizer.service";
 import type { NodeEnvironmentEnum } from "./node-env.vo";
 
 export type LoggerAppType = string;
@@ -50,7 +49,7 @@ export type LoggerEntryBare = Omit<
   AdapterInjectedFields
 >;
 
-export type LoggerEntryBareWithError = Omit<LoggerEntryBare, "error"> & { error: NormalizedError };
+export type LoggerEntryBareWithError = Omit<LoggerEntryBare, "error"> & { error: tools.NormalizedError };
 
 export type LoggerEntry = LogCoreType | LogHttpType | LogWarnType | LogErrorType;
 

package/src/prerequisite-verifier-dns.adapter.ts

@@ -1,4 +1,4 @@
-import dns from "dns/promises";
+import dns from "node:dns/promises";
 import {
   PrerequisiteVerification,
   type PrerequisiteVerificationResult,

package/src/prerequisite-verifier-with-retry.adapter.ts

@@ -21,9 +21,7 @@ export class PrerequisiteVerifierWithRetryAdapter implements PrerequisiteVerifie
       return await new Retry(this.deps).run<PrerequisiteVerificationResult>(async () => {
         const result = await this.config.inner.verify();
 
-        // Stryker disable all
         if (result.outcome === PrerequisiteVerificationOutcome.failure) throw result.error?.message;
-        // Stryker restore all
         return result;
       }, this.config.retry);
     } catch (error) {

package/src/prerequisite-verifier.port.ts

@@ -1,4 +1,4 @@
-import { ErrorNormalizer, type NormalizedError } from "./error-normalizer.service";
+import * as tools from "@bgord/tools";
 
 export enum PrerequisiteVerificationOutcome {
   success = "success",
@@ -9,7 +9,7 @@ export enum PrerequisiteVerificationOutcome {
 export type PrerequisiteVerificationSuccess = { outcome: PrerequisiteVerificationOutcome.success };
 export type PrerequisiteVerificationFailure = {
   outcome: PrerequisiteVerificationOutcome.failure;
-  error?: NormalizedError;
+  error?: tools.NormalizedError;
 };
 export type PrerequisiteVerificationUndetermined = { outcome: PrerequisiteVerificationOutcome.undetermined };
 export type PrerequisiteVerificationResult =
@@ -23,7 +23,7 @@ export class PrerequisiteVerification {
   static failure(meta?: unknown): PrerequisiteVerificationFailure {
     return {
       outcome: PrerequisiteVerificationOutcome.failure,
-      error: meta ? ErrorNormalizer.normalize(meta) : undefined,
+      error: meta ? tools.ErrorNormalizer.normalize(meta) : undefined,
     };
   }
 

package/src/randomness-crypto.strategy.ts

@@ -4,6 +4,6 @@ export class RandomnessCryptoStrategy implements RandomnessStrategy {
   next(): number {
     const array = new Uint32Array(1);
     crypto.getRandomValues(array);
-    return array[0]! / 0xffffffff;
+    return (array[0] ?? 0) / 0xffffffff;
   }
 }

package/src/redactor-error-cause-depth-limit.strategy.ts

@@ -1,20 +1,16 @@
 import * as tools from "@bgord/tools";
-import { ErrorNormalizer, type NormalizedError } from "./error-normalizer.service";
-import { isPlainObject } from "./is-plain-object";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 export class RedactorErrorCauseDepthLimit implements RedactorStrategy {
   constructor(private readonly max: tools.IntegerNonNegativeType) {}
 
   redact<T>(input: T): T {
-    // Stryker disable all
-    if (!isPlainObject(input)) return input;
-    // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    if (!tools.isPlainObject(input)) return input;
+    if (!tools.ErrorNormalizer.isNormalizedError(input["error"])) return input;
     return { ...input, error: this.limit(input["error"], tools.Int.nonNegative(0)) };
   }
 
-  private limit(error: NormalizedError, depth: tools.IntegerNonNegativeType): NormalizedError {
+  private limit(error: tools.NormalizedError, depth: tools.IntegerNonNegativeType): tools.NormalizedError {
     if (!error.cause || depth >= this.max) return { ...error, cause: undefined };
     return { ...error, cause: this.limit(error.cause, tools.Int.nonNegative(depth + 1)) };
   }

package/src/redactor-error-stack-hide.strategy.ts

@@ -1,17 +1,14 @@
-import { ErrorNormalizer, type NormalizedError } from "./error-normalizer.service";
-import { isPlainObject } from "./is-plain-object";
+import * as tools from "@bgord/tools";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 export class RedactorErrorStackHide implements RedactorStrategy {
   redact<T>(input: T): T {
-    // Stryker disable all
-    if (!isPlainObject(input)) return input;
-    // Stryker restore all
-    if (!ErrorNormalizer.isNormalizedError(input["error"])) return input;
+    if (!tools.isPlainObject(input)) return input;
+    if (!tools.ErrorNormalizer.isNormalizedError(input["error"])) return input;
     return { ...input, error: this.hide(input["error"]) };
   }
 
-  private hide(error: NormalizedError): NormalizedError {
+  private hide(error: tools.NormalizedError): tools.NormalizedError {
     return {
       ...error,
       stack: undefined,

package/src/redactor-mask.strategy.ts

@@ -1,4 +1,4 @@
-import { deepCloneWith } from "./deep-clone-with";
+import * as tools from "@bgord/tools";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 export class RedactorMask implements RedactorStrategy {
@@ -28,7 +28,7 @@ export class RedactorMask implements RedactorStrategy {
   }
 
   redact<T>(input: T): T {
-    return deepCloneWith(input, (_value, key) =>
+    return tools.deepCloneWith(input, (_value, key) =>
       typeof key === "string" && this.keys.has(key.toLowerCase()) ? "***" : undefined,
     );
   }

package/src/redactor-metadata-compact-array.strategy.ts

@@ -1,6 +1,4 @@
 import * as tools from "@bgord/tools";
-import { deepCloneWith } from "./deep-clone-with";
-import { isPlainObject } from "./is-plain-object";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 type RedactorMetadataCompactArrayOptions = { maxItems?: tools.IntegerPositiveType };
@@ -15,11 +13,11 @@ export class RedactorMetadataCompactArray implements RedactorStrategy {
   }
 
   redact<T>(input: T): T {
-    if (!isPlainObject(input)) return input;
+    if (!tools.isPlainObject(input)) return input;
 
     return {
       ...input,
-      metadata: deepCloneWith(
+      metadata: tools.deepCloneWith(
         input["metadata"],
         (value) => {
           if (!Array.isArray(value)) return undefined;

package/src/redactor-metadata-compact-object.strategy.ts

@@ -1,6 +1,4 @@
 import * as tools from "@bgord/tools";
-import { deepCloneWith } from "./deep-clone-with";
-import { isPlainObject } from "./is-plain-object";
 import type { RedactorStrategy } from "./redactor.strategy";
 
 type RedactorMetadataCompactObjectOptions = { maxKeys?: tools.IntegerPositiveType };
@@ -15,14 +13,14 @@ export class RedactorMetadataCompactObject implements RedactorStrategy {
   }
 
   redact<T>(input: T): T {
-    if (!isPlainObject(input)) return input;
+    if (!tools.isPlainObject(input)) return input;
 
     return {
       ...input,
-      metadata: deepCloneWith(
+      metadata: tools.deepCloneWith(
         input["metadata"],
         (value) => {
-          if (!isPlainObject(value) || Array.isArray(value)) return undefined;
+          if (!tools.isPlainObject(value) || Array.isArray(value)) return undefined;
 
           const keys = Object.keys(value).length;
 

package/src/remote-file-storage-noop.adapter.ts

@@ -1,7 +1,6 @@
 import * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
 import { Hash } from "./hash.vo";
-import type { LoggerPort } from "./logger.port";
 import type {
   RemoteFileStoragePort,
   RemoteHeadResult,
@@ -9,25 +8,17 @@ import type {
   RemotePutFromPathResult,
 } from "./remote-file-storage.port";
 
-type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+type Dependencies = { Clock: ClockPort };
 
 type RemoteFileStorageNoopConfig = { root: tools.DirectoryPathAbsoluteType };
 
 export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
-  private readonly base = { component: "infra", operation: "RemoteFileStorageNoopAdapter" };
-
   constructor(
     private readonly config: RemoteFileStorageNoopConfig,
     private readonly deps: Dependencies,
   ) {}
 
-  async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter putFromPath",
-      metadata: { input },
-      ...this.base,
-    });
-
+  async putFromPath(_input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
     return {
       etag: Hash.fromString("0".repeat(64)),
       size: tools.Size.fromBytes(10),
@@ -36,33 +27,15 @@ export class RemoteFileStorageNoopAdapter implements RemoteFileStoragePort {
     };
   }
 
-  async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter head",
-      metadata: { key },
-      ...this.base,
-    });
-
+  async head(_key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
     return { exists: false };
   }
 
-  async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter getStream",
-      metadata: { key },
-      ...this.base,
-    });
-
+  async getStream(_key: tools.ObjectKeyType): Promise<ReadableStream | null> {
     return null;
   }
 
-  async delete(key: tools.ObjectKeyType): Promise<void> {
-    this.deps.Logger.info({
-      message: "[NOOP] RemoteFileStorageNoopAdapter delete",
-      metadata: { key },
-      ...this.base,
-    });
-  }
+  async delete(_key: tools.ObjectKeyType): Promise<void> {}
 
   get root(): tools.DirectoryPathAbsoluteType {
     return this.config.root;

package/src/remote-file-storage-with-logger.adapter.ts

@@ -0,0 +1,140 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
+import type {
+  RemoteFileStoragePort,
+  RemoteHeadResult,
+  RemotePutFromPathInput,
+  RemotePutFromPathResult,
+} from "./remote-file-storage.port";
+import { Stopwatch } from "./stopwatch.service";
+
+type Dependencies = { inner: RemoteFileStoragePort; Logger: LoggerPort; Clock: ClockPort };
+
+export class RemoteFileStorageWithLoggerAdapter implements RemoteFileStoragePort {
+  private readonly base = { component: "infra", operation: "remote_file_storage" };
+
+  constructor(private readonly deps: Dependencies) {}
+
+  async putFromPath(input: RemotePutFromPathInput): Promise<RemotePutFromPathResult> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Remote file storage put attempt",
+        metadata: { key: input.key },
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.putFromPath(input);
+
+      this.deps.Logger.info({
+        message: "Remote file storage put success",
+        metadata: { key: input.key, size: result.size, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage put error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async head(key: tools.ObjectKeyType): Promise<RemoteHeadResult> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({ message: "Remote file storage head attempt", metadata: { key }, ...this.base });
+
+      const result = await this.deps.inner.head(key);
+
+      this.deps.Logger.info({
+        message: "Remote file storage head success",
+        metadata: { key, exists: result.exists, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage head error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async getStream(key: tools.ObjectKeyType): Promise<ReadableStream | null> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Remote file storage get stream attempt",
+        metadata: { key },
+        ...this.base,
+      });
+
+      const result = await this.deps.inner.getStream(key);
+
+      this.deps.Logger.info({
+        message: "Remote file storage get stream success",
+        metadata: { key, duration: duration.stop() },
+        ...this.base,
+      });
+
+      return result;
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage get stream error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  async delete(key: tools.ObjectKeyType): Promise<void> {
+    const duration = new Stopwatch(this.deps);
+
+    try {
+      this.deps.Logger.info({
+        message: "Remote file storage delete attempt",
+        metadata: { key },
+        ...this.base,
+      });
+
+      await this.deps.inner.delete(key);
+
+      this.deps.Logger.info({
+        message: "Remote file storage delete success",
+        metadata: { key, duration: duration.stop() },
+        ...this.base,
+      });
+    } catch (error) {
+      this.deps.Logger.error({
+        message: "Remote file storage delete error",
+        error,
+        metadata: duration.stop(),
+        ...this.base,
+      });
+
+      throw error;
+    }
+  }
+
+  get root(): tools.DirectoryPathAbsoluteType {
+    return this.deps.inner.root;
+  }
+}

package/src/retry.service.ts

@@ -2,8 +2,6 @@ import * as tools from "@bgord/tools";
 import type { RetryBackoffStrategy } from "./retry-backoff.strategy";
 import type { SleeperPort } from "./sleeper.port";
 
-export const RetryError = { InvalidMax: "retry.invalid.max" };
-
 type Dependencies = { Sleeper: SleeperPort };
 
 export type RetryConfig = {
@@ -16,8 +14,6 @@ export class Retry {
   constructor(private readonly deps: Dependencies) {}
 
   async run<T>(action: () => Promise<T>, config: RetryConfig): Promise<T> {
-    if (config.max < 1) throw new Error(RetryError.InvalidMax);
-
     let lastError: unknown;
 
     for (let attempt = 1; attempt <= config.max; attempt++) {

package/src/semaphore.service.ts

@@ -0,0 +1,26 @@
+import type * as tools from "@bgord/tools";
+
+export type SemaphoreConfig = { limit: tools.IntegerPositiveType };
+
+export class Semaphore {
+  private readonly slots: Array<Promise<void>>;
+
+  constructor(config: SemaphoreConfig) {
+    this.slots = Array.from({ length: config.limit }, () => Promise.resolve());
+  }
+
+  async run<T>(action: () => Promise<T>): Promise<T> {
+    const slot = this.slots.shift()!;
+    const { promise, resolve } = Promise.withResolvers<void>();
+
+    this.slots.push(promise);
+
+    await slot;
+
+    try {
+      return await action();
+    } finally {
+      resolve();
+    }
+  }
+}

package/src/setup-hono.service.ts

@@ -69,18 +69,7 @@ export class SetupHono {
         xFrameOptions: false,
       }),
       cors({
-        // Stryker disable all
-        origin: (origin, c) => {
-          // server-to-server, curl, same-origin navigation
-          if (!origin) return undefined;
-
-          // same-origin fetch
-          if (origin === new URL(c.req.url).origin) return origin;
-
-          // deny cross-origin
-          return null;
-        },
-        // Stryker restore all
+        origin: (origin, c) => (origin === new URL(c.req.url).origin ? origin : null),
         credentials: false,
         maxAge: tools.Duration.Minutes(10).seconds,
         ...config.cors,

package/src/shield-ip-whitelist.strategy.ts

@@ -12,9 +12,7 @@ export class ShieldIpWhitelistStrategy {
   evaluate(context: HasIdentityIp): boolean {
     const ip = v.safeParse(ClientIp, context.identity.ip());
 
-    // Stryker disable all
     if (!ip.success) return false;
-    // Stryker restore all
     return this.config.whitelist.includes(ip.output);
   }
 }

package/src/sse-registry.adapter.ts

@@ -8,7 +8,7 @@ export class SseRegistryAdapter<Messages extends Message> implements SseRegistry
   register(identity: HashValueType, connection: SseSenderType<Messages>): void {
     if (!this.senders.has(identity)) this.senders.set(identity, new Set());
 
-    this.senders.get(identity)!.add(connection);
+    this.senders.get(identity)?.add(connection);
   }
 
   unregister(identity: HashValueType, connection: SseSenderType<Messages>): void {

package/src/static-files-hono.service.ts

@@ -72,9 +72,7 @@ export class StaticFilesHono {
 
           const contentType = context.res.headers.get("Content-Type");
 
-          // Stryker disable all
           if (contentType?.startsWith("text/html")) staticDocumentHeaders(context, noop);
-          // Stryker restore all
           else staticAssetHeaders(context, noop);
         },
         etag(),