@bgord/bun 1.9.0 → 1.9.2

package/src/hash-content.strategy.ts

@@ -0,0 +1,5 @@
+import type { Hash } from "./hash.vo";
+
+export interface HashContentStrategy {
+  hash(content: string): Promise<Hash>;
+}

package/src/hash-file-noop.adapter.ts

@@ -0,0 +1,14 @@
+import * as tools from "@bgord/tools";
+import { Hash } from "./hash.vo";
+import type { HashFilePort } from "./hash-file.port";
+
+export class HashFileNoopAdapter implements HashFilePort {
+  async hash(_path: tools.FilePathAbsolute | tools.FilePathRelative) {
+    return {
+      etag: Hash.fromString("0000000000000000000000000000000000000000000000000000000000000000"),
+      size: tools.Size.fromBytes(10),
+      lastModified: tools.Timestamp.fromNumber(1000),
+      mime: tools.MIMES.text,
+    };
+  }
+}

package/src/hash-file-sha256-bun.adapter.ts

@@ -0,0 +1,23 @@
+import * as tools from "@bgord/tools";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { HashFilePort } from "./hash-file.port";
+
+type Dependencies = { HashContent: HashContentStrategy };
+
+export class HashFileSha256BunAdapter implements HashFilePort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async hash(path: tools.FilePathAbsolute | tools.FilePathRelative) {
+    const file = Bun.file(path.get());
+    const extension = path.getFilename().getExtension();
+
+    const arrayBuffer = await file.arrayBuffer();
+
+    return {
+      etag: await this.deps.HashContent.hash(await file.text()),
+      size: tools.Size.fromBytes(arrayBuffer.byteLength),
+      lastModified: tools.Timestamp.fromNumber(file.lastModified),
+      mime: tools.Mime.fromExtension(extension),
+    };
+  }
+}

package/src/hash-file.port.ts

@@ -0,0 +1,13 @@
+import type * as tools from "@bgord/tools";
+import type { Hash } from "./hash.vo";
+
+export type HashFileResult = {
+  etag: Hash;
+  size: tools.Size;
+  lastModified: tools.Timestamp;
+  mime: tools.Mime;
+};
+
+export interface HashFilePort {
+  hash(path: tools.FilePathAbsolute | tools.FilePathRelative): Promise<HashFileResult>;
+}

package/src/hash-value.vo.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+
+export const HashValueError = { Type: "hash.value.type", InvalidHex: "hash.value.invalid.hex" } as const;
+
+// 64 hex chars allowed
+const CHARS_WHITELIST = /^[a-fA-F0-9]{64}$/;
+
+// Stryker disable all
+export const HashValue = z
+  // Stryker restore all
+  .string(HashValueError.Type)
+  .regex(CHARS_WHITELIST, HashValueError.InvalidHex)
+  .brand("HashValue");
+
+export type HashValueType = z.infer<typeof HashValue>;

package/src/hash.vo.ts

@@ -0,0 +1,29 @@
+import { HashValue, type HashValueType } from "./hash-value.vo";
+
+export class Hash {
+  private constructor(private readonly value: HashValueType) {}
+
+  static fromValue(value: HashValueType): Hash {
+    return new Hash(value);
+  }
+
+  static fromString(candidate: string): Hash {
+    return new Hash(HashValue.parse(candidate));
+  }
+
+  get(): HashValueType {
+    return this.value;
+  }
+
+  matches(another: Hash): boolean {
+    return this.value === another.value;
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  toJSON(): string {
+    return this.value;
+  }
+}

package/src/hcaptcha-secret-key.vo.ts

@@ -0,0 +1,15 @@
+import * as z from "zod/v4";
+
+export const HCaptchaSecretKeyError = {
+  Type: "hcaptcha.secret.key.type",
+  Length: "hcaptcha.secret.key.length",
+};
+
+// Stryker disable all
+export const HCaptchaSecretKey = z
+  // Stryker restore all
+  .string(HCaptchaSecretKeyError.Type)
+  .length(35, HCaptchaSecretKeyError.Length)
+  .brand("HCaptchaSecretKey");
+
+export type HCaptchaSecretKeyType = z.infer<typeof HCaptchaSecretKey>;

package/src/hcaptcha-site-key.vo.ts

@@ -0,0 +1,12 @@
+import * as z from "zod/v4";
+
+export const HCaptchaSiteKeyError = { Type: "hcaptcha.site.key.type", Length: "hcaptcha.site.key.length" };
+
+// Stryker disable all
+export const HCaptchaSiteKey = z
+  // Stryker restore all
+  .string(HCaptchaSiteKeyError.Type)
+  .length(36, HCaptchaSiteKeyError.Length)
+  .brand("HCaptchaSiteKey");
+
+export type HCaptchaSiteKeyType = z.infer<typeof HCaptchaSiteKey>;

package/src/healthcheck.service.ts

@@ -0,0 +1,138 @@
+import os from "node:os";
+import * as tools from "@bgord/tools";
+import { createFactory } from "hono/factory";
+import type { BuildInfoRepositoryStrategy } from "./build-info-repository.strategy";
+import type { ClockPort } from "./clock.port";
+import type { CommitShaValueType } from "./commit-sha-value.vo";
+import { EventLoopLag } from "./event-loop-lag.service";
+import { EventLoopUtilization, type EventLoopUtilizationSnapshot } from "./event-loop-utilization.service";
+import { InFlightRequestsTracker } from "./in-flight-requests-tracker.service";
+import { MemoryConsumption } from "./memory-consumption.service";
+import type { NodeEnvironmentEnum } from "./node-env.vo";
+import { Prerequisite, type PrerequisiteLabelType } from "./prerequisite.vo";
+import {
+  PrerequisiteVerificationOutcome,
+  type PrerequisiteVerificationResult,
+} from "./prerequisite-verifier.port";
+import { PrerequisiteVerifierSelfAdapter } from "./prerequisite-verifier-self.adapter";
+import { Stopwatch } from "./stopwatch.service";
+import { Uptime, type UptimeResultType } from "./uptime.service";
+
+const handler = createFactory();
+const self = new Prerequisite("self", new PrerequisiteVerifierSelfAdapter());
+
+type HealthcheckResultType = {
+  ok: boolean;
+  deployment: {
+    version: string;
+    timestamp: tools.TimestampValueType;
+    date: string;
+    sha: CommitShaValueType;
+    size: string;
+    environment: NodeEnvironmentEnum;
+  };
+  server: {
+    pid: typeof process.pid;
+    hostname: ReturnType<typeof os.hostname>;
+    cpus: number;
+    startup: tools.TimestampValueType;
+    uptime: Omit<UptimeResultType, "duration"> & { durationMs: tools.DurationMsType };
+    memory: {
+      total: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
+      heap: {
+        used: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
+        total: { bytes: tools.Size["bytes"]; formatted: ReturnType<tools.Size["format"]> };
+      };
+    };
+    eventLoop: {
+      lag: { p50: tools.DurationMsType; p95: tools.DurationMsType; p99: tools.DurationMsType };
+      utilization: EventLoopUtilizationSnapshot;
+    };
+    inFlight: tools.IntegerType;
+  };
+  details: {
+    label: PrerequisiteLabelType;
+    outcome: PrerequisiteVerificationResult;
+    durationMs: tools.DurationMsType;
+  }[];
+  durationMs: tools.Duration["ms"];
+  timestamp: tools.TimestampValueType;
+};
+
+type Dependencies = { Clock: ClockPort; BuildInfoRepository: BuildInfoRepositoryStrategy };
+
+export class Healthcheck {
+  static build = (Env: NodeEnvironmentEnum, _prerequisites: Prerequisite[], deps: Dependencies) =>
+    handler.createHandlers(async (c) => {
+      const stopwatch = new Stopwatch(deps);
+
+      const prerequisites = [self, ..._prerequisites]
+        .filter((prerequisite) => prerequisite.enabled)
+        .filter((prerequisite) => prerequisite.kind !== "port");
+
+      const details: HealthcheckResultType["details"][number][] = await Promise.all(
+        prerequisites.map(async (prerequisite) => {
+          const stopwatch = new Stopwatch(deps);
+
+          return {
+            label: prerequisite.label,
+            outcome: await prerequisite.build().verify(),
+            durationMs: stopwatch.stop().ms,
+          };
+        }),
+      );
+
+      const ok = details.every(
+        (result) => result.outcome.outcome !== PrerequisiteVerificationOutcome.failure,
+      );
+
+      const code = ok ? 200 : 424;
+
+      const build = await deps.BuildInfoRepository.extract();
+      const uptime = Uptime.get(deps.Clock);
+      const histogram = EventLoopLag.snapshot();
+      const memory = MemoryConsumption.snapshot();
+
+      const response: HealthcheckResultType = {
+        ok,
+        details,
+        deployment: {
+          version: build.version.toString(),
+          timestamp: build.timestamp.ms,
+          date: new Date(build.timestamp.ms).toISOString(),
+          sha: build.sha.toString(),
+          size: build.size.format(tools.Size.unit.MB),
+          environment: Env,
+        },
+        server: {
+          pid: process.pid,
+          hostname: os.hostname(),
+          cpus: os.cpus().length,
+          startup: deps.Clock.now().subtract(uptime.duration).ms,
+          uptime: { durationMs: uptime.duration.ms, formatted: uptime.formatted },
+          memory: {
+            total: { bytes: memory.total.toBytes(), formatted: memory.total.format(tools.Size.unit.MB) },
+            heap: {
+              used: {
+                bytes: memory.heap.used.toBytes(),
+                formatted: memory.heap.used.format(tools.Size.unit.MB),
+              },
+              total: {
+                bytes: memory.heap.total.toBytes(),
+                formatted: memory.heap.total.format(tools.Size.unit.MB),
+              },
+            },
+          },
+          eventLoop: {
+            lag: { p50: histogram.p50.ms, p95: histogram.p95.ms, p99: histogram.p99.ms },
+            utilization: EventLoopUtilization.snapshot(),
+          },
+          inFlight: InFlightRequestsTracker.get(),
+        },
+        durationMs: stopwatch.stop().ms,
+        timestamp: deps.Clock.now().ms,
+      };
+
+      return c.json(response, code);
+    });
+}

package/src/http-logger.middleware.ts

@@ -0,0 +1,100 @@
+import { createMiddleware } from "hono/factory";
+import { CacheSourceEnum } from "./cache-resolver.strategy";
+import { CacheResponse } from "./cache-response.middleware";
+import { ClientFromHono } from "./client-from-hono.adapter";
+import type { ClockPort } from "./clock.port";
+import type { LoggerPort } from "./logger.port";
+import { Stopwatch } from "./stopwatch.service";
+
+export const UNINFORMATIVE_HEADERS = [
+  "accept",
+  "accept-encoding",
+  "cache-control",
+  "connection",
+  "content-length",
+  "content-type",
+  "cookie",
+  "dnt",
+  "host",
+  "pragma",
+  "sec-fetch-dest",
+  "sec-fetch-mode",
+  "sec-fetch-site",
+  "sec-fetch-user",
+  "sec-gpc",
+  "upgrade-insecure-requests",
+  "user-agent",
+  "if-none-match",
+  "priority",
+];
+
+type Dependencies = { Logger: LoggerPort; Clock: ClockPort };
+
+export type HttpLoggerOptions = { skip?: readonly string[] };
+
+export class HttpLogger {
+  static build = (deps: Dependencies, options?: HttpLoggerOptions) =>
+    createMiddleware(async (context, next) => {
+      const request = context.req.raw.clone();
+
+      const pathname = new URL(request.url).pathname;
+
+      // Stryker disable all
+      if (options?.skip?.some((prefix) => pathname.startsWith(prefix))) return await next();
+      // Stryker restore all
+
+      const correlationId = context.get("requestId");
+      const client = ClientFromHono.translate(context).toJSON();
+
+      const httpRequestBeforeMetadata = {
+        params: context.req.param(),
+        headers: Object.fromEntries(
+          Object.entries(request.headers.toJSON()).filter(
+            ([header]) => !UNINFORMATIVE_HEADERS.includes(header),
+          ),
+        ),
+        body: (await HttpLogger.parseJSON(request)) ?? {},
+        query: context.req.queries(),
+      };
+
+      deps.Logger.http({
+        component: "http",
+        operation: "http_request_before",
+        correlationId,
+        message: "request",
+        method: request.method,
+        url: request.url,
+        client,
+        metadata: httpRequestBeforeMetadata,
+      });
+
+      const stopwatch = new Stopwatch(deps);
+      await next();
+      const duration = stopwatch.stop();
+
+      const response = context.res.clone();
+
+      deps.Logger.http({
+        component: "http",
+        operation: "http_request_after",
+        correlationId,
+        message: "response",
+        method: request.method,
+        url: request.url,
+        status: response.status,
+        durationMs: duration.ms,
+        client,
+        cacheHit: response.headers.get(CacheResponse.CACHE_HIT_HEADER) === CacheSourceEnum.hit,
+        metadata: { response: await HttpLogger.parseJSON(response) },
+      });
+    });
+
+  private static async parseJSON(resource: Request | Response) {
+    let result: any;
+    try {
+      result = await resource.json();
+    } catch {}
+
+    return result;
+  }
+}

package/src/i18n.service.ts

@@ -0,0 +1,62 @@
+import * as tools from "@bgord/tools";
+import type { FileReaderJsonPort } from "../src/file-reader-json.port";
+import type { LoggerPort } from "../src/logger.port";
+
+export type TranslationsKeyType = string;
+export type TranslationsValueType = string;
+export type TranslationsType = Record<TranslationsKeyType, TranslationsValueType>;
+export type TranslationPlaceholderType = string;
+export type TranslationPlaceholderValueType = string | number;
+export type TranslationVariableType = Record<TranslationPlaceholderType, TranslationPlaceholderValueType>;
+
+export type TranslationsSupportedLanguagesType = Record<string, string>;
+
+export type I18nConfigType = {
+  supportedLanguages: TranslationsSupportedLanguagesType;
+  translationsPath?: tools.DirectoryPathRelativeType;
+  defaultLanguage?: string;
+};
+
+type Dependencies = { FileReaderJson: FileReaderJsonPort; Logger: LoggerPort };
+
+export class I18n {
+  private readonly base = { component: "infra", operation: "translations" };
+
+  static DEFAULT_TRANSLATIONS_PATH = tools.DirectoryPathRelativeSchema.parse("infra/translations");
+
+  constructor(
+    private readonly deps: Dependencies,
+    private translationsPath: tools.DirectoryPathRelativeType = I18n.DEFAULT_TRANSLATIONS_PATH,
+  ) {}
+
+  async getTranslations(language: tools.LanguageType): Promise<TranslationsType> {
+    return this.deps.FileReaderJson.read(this.getTranslationPathForLanguage(language));
+  }
+
+  useTranslations(translations: TranslationsType) {
+    const that = this;
+
+    return function translate(key: TranslationsKeyType, variables?: TranslationVariableType) {
+      const translation = translations[key];
+
+      if (!translation) {
+        that.deps.Logger.warn({ message: `Missing translation for key ${key}`, ...that.base });
+        return key;
+      }
+
+      if (!variables) return translation;
+
+      return Object.entries(variables).reduce(
+        (result, [placeholder, value]) => result.replace(`{{${placeholder}}}`, String(value)),
+        translation,
+      );
+    };
+  }
+
+  getTranslationPathForLanguage(language: tools.LanguageType): tools.FilePathRelative {
+    return tools.FilePathRelative.fromParts(
+      this.translationsPath,
+      tools.Filename.fromParts(language, "json"),
+    );
+  }
+}

package/src/id-provider-crypto.adapter.ts

@@ -0,0 +1,8 @@
+import type { IdProviderPort } from "./id-provider.port";
+import type { UUIDType } from "./uuid.vo";
+
+export class IdProviderCryptoAdapter implements IdProviderPort {
+  generate(): UUIDType {
+    return crypto.randomUUID();
+  }
+}

package/src/id-provider-deterministic.adapter.ts

@@ -0,0 +1,21 @@
+import type { IdProviderPort } from "./id-provider.port";
+import type { UUIDType } from "./uuid.vo";
+
+export const IdProviderDeterministicAdapterError = {
+  SequenceExhausted: "id.provider.deterministic.adapter.sequence.exhausted",
+} as const;
+
+export class IdProviderDeterministicAdapter implements IdProviderPort {
+  private readonly queue: UUIDType[];
+
+  constructor(sequence: UUIDType[]) {
+    this.queue = [...sequence];
+  }
+
+  generate(): UUIDType {
+    const next = this.queue.shift();
+
+    if (!next) throw new Error(IdProviderDeterministicAdapterError.SequenceExhausted);
+    return next;
+  }
+}

package/src/id-provider.port.ts

@@ -0,0 +1,5 @@
+import type { UUIDType } from "./uuid.vo";
+
+export interface IdProviderPort {
+  generate(): UUIDType;
+}

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

@@ -0,0 +1,7 @@
+import type { ImageAlphaPort, ImageAlphaStrategy } from "./image-alpha.port";
+
+export class ImageAlphaNoopAdapter implements ImageAlphaPort {
+  async flatten(recipe: ImageAlphaStrategy) {
+    return recipe.strategy === "output_path" ? recipe.output : recipe.input;
+  }
+}

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

@@ -0,0 +1,38 @@
+import type { FileRenamerPort } from "./file-renamer.port";
+import type { ImageAlphaPort, ImageAlphaStrategy } from "./image-alpha.port";
+
+type Dependencies = { FileRenamer: FileRenamerPort };
+
+export class ImageAlphaSharpAdapter implements ImageAlphaPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  private async load() {
+    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
+    return (await import(name)).default;
+  }
+
+  async flatten(recipe: ImageAlphaStrategy) {
+    const sharp = await this.load();
+
+    const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
+
+    const filename = final.getFilename();
+    const temporary = final.withFilename(filename.withSuffix("-flattened"));
+
+    const extension = final.getFilename().getExtension();
+    const format = (extension === "jpg" ? "jpeg" : extension) as keyof import("sharp").FormatEnum;
+
+    const pipeline = sharp(recipe.input.get());
+    using _pipeline_dispose = { [Symbol.dispose]: () => pipeline.destroy() };
+
+    await pipeline
+      .rotate()
+      .flatten({ background: recipe.background })
+      .toFormat(format)
+      .toFile(temporary.get());
+
+    await this.deps.FileRenamer.rename(temporary, final);
+
+    return final;
+  }
+}

package/src/image-alpha.port.ts

@@ -0,0 +1,19 @@
+import type * as tools from "@bgord/tools";
+
+type ImageAlphaBackground = string | { r: number; g: number; b: number; alpha?: number };
+type ImageAlphaOutputPathStrategy = {
+  strategy: "output_path";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  output: tools.FilePathRelative | tools.FilePathAbsolute;
+  background: ImageAlphaBackground;
+};
+type ImageAlphaInPlaceStrategy = {
+  strategy: "in_place";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  background: ImageAlphaBackground;
+};
+export type ImageAlphaStrategy = ImageAlphaInPlaceStrategy | ImageAlphaOutputPathStrategy;
+
+export interface ImageAlphaPort {
+  flatten(recipe: ImageAlphaStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;
+}

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

@@ -0,0 +1,7 @@
+import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
+
+export class ImageBlurNoopAdapter implements ImageBlurPort {
+  async blur(recipe: ImageBlurStrategy) {
+    return recipe.strategy === "output_path" ? recipe.output : recipe.input;
+  }
+}

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

@@ -0,0 +1,33 @@
+import type { FileRenamerPort } from "./file-renamer.port";
+import type { ImageBlurPort, ImageBlurStrategy } from "./image-blur.port";
+
+type Dependencies = { FileRenamer: FileRenamerPort };
+
+export class ImageBlurSharpAdapter implements ImageBlurPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  private async load() {
+    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
+    return (await import(name)).default;
+  }
+
+  async blur(recipe: ImageBlurStrategy) {
+    const sharp = await this.load();
+
+    const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
+
+    const filename = final.getFilename();
+    const temporary = final.withFilename(filename.withSuffix("-blurred"));
+
+    const extension = final.getFilename().getExtension();
+    const format = (extension === "jpg" ? "jpeg" : extension) as keyof import("sharp").FormatEnum;
+
+    const pipeline = sharp(recipe.input.get());
+    using _sharp_ = { [Symbol.dispose]: () => pipeline.destroy() };
+
+    await pipeline.rotate().blur(recipe.sigma).toFormat(format).toFile(temporary.get());
+    await this.deps.FileRenamer.rename(temporary, final);
+
+    return final;
+  }
+}

package/src/image-blur.port.ts

@@ -0,0 +1,18 @@
+import type * as tools from "@bgord/tools";
+
+type ImageBlurOutputPathStrategy = {
+  strategy: "output_path";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  output: tools.FilePathRelative | tools.FilePathAbsolute;
+  sigma?: number;
+};
+type ImageBlurInPlaceStrategy = {
+  strategy: "in_place";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  sigma?: number;
+};
+export type ImageBlurStrategy = ImageBlurOutputPathStrategy | ImageBlurInPlaceStrategy;
+
+export interface ImageBlurPort {
+  blur(recipe: ImageBlurStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;
+}

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

@@ -0,0 +1,7 @@
+import type { ImageCompressorPort, ImageCompressorStrategy } from "./image-compressor.port";
+
+export class ImageCompressorNoopAdapter implements ImageCompressorPort {
+  async compress(recipe: ImageCompressorStrategy) {
+    return recipe.strategy === "output_path" ? recipe.output : recipe.input;
+  }
+}

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

@@ -0,0 +1,36 @@
+import type { FileRenamerPort } from "./file-renamer.port";
+import type { ImageCompressorPort, ImageCompressorStrategy } from "./image-compressor.port";
+
+type Dependencies = { FileRenamer: FileRenamerPort };
+
+export class ImageCompressorSharpAdapter implements ImageCompressorPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  private async load() {
+    const name = "sha" + "rp"; // Bun does not resolve dynamic imports with a dynamic name
+    return (await import(name)).default;
+  }
+
+  private static readonly DEFAULT_QUALITY = 85;
+
+  async compress(recipe: ImageCompressorStrategy) {
+    const sharp = await this.load();
+
+    const quality = recipe.quality ?? ImageCompressorSharpAdapter.DEFAULT_QUALITY;
+
+    const final = recipe.strategy === "output_path" ? recipe.output : recipe.input;
+    const filename = final.getFilename();
+    const temporary = final.withFilename(filename.withSuffix("-compressed"));
+
+    const extension = final.getFilename().getExtension();
+    const format = (extension === "jpg" ? "jpeg" : extension) as keyof import("sharp").FormatEnum;
+
+    const pipeline = sharp(recipe.input.get());
+    using _sharp_ = { [Symbol.dispose]: () => pipeline.destroy() };
+
+    await pipeline.rotate().toFormat(format, { quality }).toFile(temporary.get());
+    await this.deps.FileRenamer.rename(temporary, final);
+
+    return final;
+  }
+}

package/src/image-compressor.port.ts

@@ -0,0 +1,18 @@
+import type * as tools from "@bgord/tools";
+
+export type ImageCompressorOutputPathStrategy = {
+  strategy: "output_path";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  output: tools.FilePathRelative | tools.FilePathAbsolute;
+  quality?: tools.IntegerPositiveType;
+};
+export type ImageCompressorInPlaceStrategy = {
+  strategy: "in_place";
+  input: tools.FilePathRelative | tools.FilePathAbsolute;
+  quality?: tools.IntegerPositiveType;
+};
+export type ImageCompressorStrategy = ImageCompressorInPlaceStrategy | ImageCompressorOutputPathStrategy;
+
+export interface ImageCompressorPort {
+  compress(recipe: ImageCompressorStrategy): Promise<tools.FilePathRelative | tools.FilePathAbsolute>;
+}