@bgord/bun 1.1.5 → 1.1.6

package/src/prerequisites/translations.ts

@@ -1,6 +1,7 @@
 import { constants } from "node:fs";
 import fsp from "node:fs/promises";
-import type * as tools from "@bgord/tools";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "../clock.port";
 import type * as types from "../i18n.service";
 import { I18n } from "../i18n.service";
 import type { JsonFileReaderPort } from "../json-file-reader.port";
@@ -42,8 +43,10 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
     this.JsonFileReader = config.JsonFileReader;
   }
 
-  async verify(): Promise<prereqs.VerifyOutcome> {
-    if (!this.enabled) return prereqs.Verification.undetermined();
+  async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const stopwatch = new tools.Stopwatch(clock.now());
+
+    if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     const translationsPath = this.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
 
@@ -57,10 +60,10 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
         await fsp.access(i18n.getTranslationPathForLanguage(language).get(), constants.R_OK);
       }
     } catch (error) {
-      return prereqs.Verification.failure(error as Error);
+      return prereqs.Verification.failure(stopwatch.stop(), error as Error);
     }
 
-    if (supportedLanguages.length === 1) return prereqs.Verification.success();
+    if (supportedLanguages.length === 1) return prereqs.Verification.success(stopwatch.stop());
 
     const languageToTranslationKeys: Record<tools.LanguageType, types.TranslationsKeyType[]> = {};
 
@@ -91,12 +94,12 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
       }
     }
 
-    if (problems.length === 0) return prereqs.Verification.success();
+    if (problems.length === 0) return prereqs.Verification.success(stopwatch.stop());
 
     const summary = problems
       .map((problem) => `Key: ${problem.key}, exists in ${problem.existsIn}, missing in ${problem.missingIn}`)
       .join("\n");
 
-    return prereqs.Verification.failure({ message: summary });
+    return prereqs.Verification.failure(stopwatch.stop(), { message: summary });
   }
 }

package/src/prerequisites.service.ts

@@ -1,3 +1,5 @@
+import type * as tools from "@bgord/tools";
+import type { ClockPort } from "../src/clock.port";
 import type { ErrorInfo, LoggerPort } from "../src/logger.port";
 import { formatError } from "../src/logger-format-error.service";
 
@@ -9,37 +11,45 @@ export enum PrerequisiteStatusEnum {
   undetermined = "undetermined",
 }
 
-export type VerifySuccess = Readonly<{ status: PrerequisiteStatusEnum.success }>;
-export type VerifyFailure = Readonly<{ status: PrerequisiteStatusEnum.failure; error?: ErrorInfo }>;
-export type VerifyUndetermined = Readonly<{ status: PrerequisiteStatusEnum.undetermined }>;
+export type VerifySuccess = { status: PrerequisiteStatusEnum.success; duration: tools.DurationMsType };
+export type VerifyFailure = {
+  status: PrerequisiteStatusEnum.failure;
+  duration: tools.DurationMsType;
+  error?: ErrorInfo;
+};
+export type VerifyUndetermined = {
+  status: PrerequisiteStatusEnum.undetermined;
+  duration: tools.DurationMsType;
+};
 export type VerifyOutcome = VerifySuccess | VerifyFailure | VerifyUndetermined;
 
 export interface Prerequisite {
   readonly label: PrerequisiteLabelType;
   readonly kind: string;
   readonly enabled?: boolean;
-  verify(): Promise<VerifyOutcome>;
+  verify(clock: ClockPort): Promise<VerifyOutcome>;
 }
 
-export type PrerequisiteResult = Readonly<{
+export type PrerequisiteResult = {
   label: PrerequisiteLabelType;
   status: PrerequisiteStatusEnum;
   kind: string;
   error?: ErrorInfo;
-}>;
+};
 
 export class Verification {
-  static success(): VerifySuccess {
-    return { status: PrerequisiteStatusEnum.success };
+  static success(duration: tools.Duration): VerifySuccess {
+    return { status: PrerequisiteStatusEnum.success, duration: duration.ms };
   }
-  static failure(meta?: Error | ErrorInfo): VerifyFailure {
+  static failure(duration: tools.Duration, meta?: Error | ErrorInfo): VerifyFailure {
     return {
       status: PrerequisiteStatusEnum.failure,
+      duration: duration.ms,
       error: meta instanceof Error ? formatError(meta) : meta,
     };
   }
-  static undetermined(): VerifyUndetermined {
-    return { status: PrerequisiteStatusEnum.undetermined };
+  static undetermined(duration: tools.Duration): VerifyUndetermined {
+    return { status: PrerequisiteStatusEnum.undetermined, duration: duration.ms };
   }
 }
 
@@ -47,23 +57,28 @@ export type PrerequisiteConfigType = { label: string; enabled?: boolean };
 
 export const PrerequisitesError = { Failure: "prerequisites.failure" } as const;
 
+type Dependencies = { logger: LoggerPort; clock: ClockPort };
+
 /** @public */
 export class Prerequisites {
   private readonly base = { component: "infra", operation: "startup" };
 
-  constructor(private readonly logger: LoggerPort) {}
+  constructor(private readonly deps: Dependencies) {}
 
   async check(prerequisites: Prerequisite[]) {
     const results = await Promise.all(
-      prerequisites.map(async (prerequisite) => ({ prerequisite, outcome: await prerequisite.verify() })),
+      prerequisites.map(async (prerequisite) => ({
+        prerequisite,
+        outcome: await prerequisite.verify(this.deps.clock),
+      })),
     );
 
     const failed = results.filter((result) => result.outcome.status === PrerequisiteStatusEnum.failure);
 
-    if (failed.length === 0) return this.logger.info({ message: "Prerequisites ok", ...this.base });
+    if (failed.length === 0) return this.deps.logger.info({ message: "Prerequisites ok", ...this.base });
 
     for (const failure of failed) {
-      this.logger.error({
+      this.deps.logger.error({
         message: "Prerequisite failed",
         metadata: { label: failure.prerequisite.label, kind: failure.prerequisite.kind },
         // @ts-expect-error