@bgord/bun 1.4.19 → 1.4.21

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.4.19",
+  "version": "1.4.21",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",
@@ -38,13 +38,13 @@
   },
   "dependencies": {
     "@axiomhq/winston": "1.3.1",
-    "@bgord/tools": "1.1.18",
+    "@bgord/tools": "1.1.20",
     "@hono/ua-blocker": "0.1.21",
-    "better-auth": "1.4.6",
+    "better-auth": "1.4.7",
     "croner": "9.1.0",
     "csv": "6.4.1",
     "hcaptcha": "0.2.0",
-    "hono": "4.10.8",
+    "hono": "4.11.0",
     "isomorphic-dompurify": "2.34.0",
     "lodash": "4.17.21",
     "marked": "17.0.1",

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

@@ -7,7 +7,7 @@ export const HCaptchaSecretKeyError = {
 
 export const HCaptchaSecretKey = z
   .string(HCaptchaSecretKeyError.Type)
-  .length(42, HCaptchaSecretKeyError.Length)
+  .length(35, HCaptchaSecretKeyError.Length)
   .brand("HCaptchaSecretKey");
 
 export type HCaptchaSecretKeyType = z.infer<typeof HCaptchaSecretKey>;

package/src/modules/preferences/command-handlers/handleSetUserLanguageCommand.ts

@@ -9,27 +9,28 @@ import * as Invariants from "../invariants";
 import type * as Ports from "../ports";
 import type * as VO from "../value-objects";
 
+type Dependencies = {
+  EventStore: EventStoreLike<AcceptedEvent>;
+  IdProvider: IdProviderPort;
+  Clock: ClockPort;
+  UserLanguageQuery: Ports.UserLanguageQueryPort;
+};
+
 type AcceptedEvent = Events.UserLanguageSetEventType;
 
 export const handleSetUserLanguageCommand =
-  <L extends readonly tools.LanguageType[]>(
-    EventStore: EventStoreLike<AcceptedEvent>,
-    IdProvider: IdProviderPort,
-    Clock: ClockPort,
-    query: Ports.UserLanguageQueryPort,
-    supported: VO.SupportedLanguagesSet<L>,
-  ) =>
+  <L extends readonly tools.LanguageType[]>(supported: VO.SupportedLanguagesSet<L>, deps: Dependencies) =>
   async (command: Commands.SetUserLanguageCommandType) => {
     const candidate = supported.ensure(command.payload.language);
-    const current = await query.get(command.payload.userId);
+    const current = await deps.UserLanguageQuery.get(command.payload.userId);
 
     if (Invariants.UserLanguageHasChanged.fails({ current, candidate: command.payload.language })) return;
 
     const event = Events.UserLanguageSetEvent.parse({
-      ...createEventEnvelope(`preferences_${command.payload.userId}`, { IdProvider, Clock }),
+      ...createEventEnvelope(`preferences_${command.payload.userId}`, deps),
       name: Events.USER_LANGUAGE_SET_EVENT,
       payload: { userId: command.payload.userId, language: candidate },
     } satisfies Events.UserLanguageSetEventType);
 
-    await EventStore.save([event]);
+    await deps.EventStore.save([event]);
   };

package/src/prerequisites/clock-drift.ts

@@ -5,38 +5,37 @@ import type { TimekeeperPort } from "../timekeeper.port";
 import { TimekeeperGoogleAdapter } from "../timekeeper-google.adapter";
 import { Timeout } from "../timeout.service";
 
+type Dependencies = { Timekeeper?: TimekeeperPort };
+
 export class PrerequisiteClockDrift implements prereqs.Prerequisite {
   readonly kind = "clock-drift";
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
   readonly skew: tools.Duration;
-  readonly Timekeeper: TimekeeperPort;
   readonly timeout: tools.Duration;
 
   constructor(
-    config: prereqs.PrerequisiteConfigType & {
-      skew: tools.Duration;
-      Timekeeper?: TimekeeperPort;
-      timeout?: tools.Duration;
-    },
+    config: prereqs.PrerequisiteConfigType & { skew: tools.Duration; timeout?: tools.Duration },
+    private readonly deps?: Dependencies,
   ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.skew = config.skew;
-    this.Timekeeper = config.Timekeeper ?? new TimekeeperGoogleAdapter();
     this.timeout = config.timeout ?? tools.Duration.Seconds(2);
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const Timekeeper = this.deps?.Timekeeper ?? new TimekeeperGoogleAdapter();
+
     const stopwatch = new tools.Stopwatch(clock.now());
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const timestamp = await Timeout.cancellable(
-        (signal: AbortSignal) => this.Timekeeper.get(signal),
+        (signal: AbortSignal) => Timekeeper.get(signal),
         this.timeout,
       );
       if (!timestamp) return prereqs.Verification.undetermined(stopwatch.stop());

package/src/prerequisites/log-file.ts

@@ -3,18 +3,19 @@ import type { ClockPort } from "../clock.port";
 import type { LoggerPort } from "../logger.port";
 import * as prereqs from "../prerequisites.service";
 
+type Dependencies = { Logger: LoggerPort };
+
 export class PrerequisiteLogFile implements prereqs.Prerequisite {
   readonly kind = "log-file";
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly Logger: LoggerPort;
-
-  constructor(config: prereqs.PrerequisiteConfigType & { Logger: LoggerPort }) {
+  constructor(
+    config: prereqs.PrerequisiteConfigType,
+    private readonly deps: Dependencies,
+  ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
-
-    this.Logger = config.Logger;
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -23,7 +24,7 @@ export class PrerequisiteLogFile implements prereqs.Prerequisite {
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
-      const path = this.Logger.getFilePath();
+      const path = this.deps.Logger.getFilePath();
       if (!path) return prereqs.Verification.undetermined(stopwatch.stop());
 
       const result = await Bun.file(path.get()).exists();

package/src/prerequisites/mailer.ts

@@ -4,19 +4,22 @@ import type { MailerPort } from "../mailer.port";
 import * as prereqs from "../prerequisites.service";
 import { Timeout } from "../timeout.service";
 
+type Dependencies = { Mailer: MailerPort };
+
 export class PrerequisiteMailer implements prereqs.Prerequisite {
   readonly kind = "mailer";
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly Mailer: MailerPort;
   readonly timeout: tools.Duration;
 
-  constructor(config: prereqs.PrerequisiteConfigType & { Mailer: MailerPort; timeout?: tools.Duration }) {
+  constructor(
+    config: prereqs.PrerequisiteConfigType & { timeout?: tools.Duration },
+    private readonly deps: Dependencies,
+  ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
-    this.Mailer = config.Mailer;
     this.timeout = config.timeout ?? tools.Duration.Seconds(2);
   }
 
@@ -26,7 +29,7 @@ export class PrerequisiteMailer implements prereqs.Prerequisite {
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
-      await Timeout.run(this.Mailer.verify(), this.timeout);
+      await Timeout.run(this.deps.Mailer.verify(), this.timeout);
       return prereqs.Verification.success(stopwatch.stop());
     } catch (error) {
       return prereqs.Verification.failure(stopwatch.stop(), error as Error);

package/src/prerequisites/space.ts

@@ -5,32 +5,34 @@ import type { DiskSpaceCheckerPort } from "../disk-space-checker.port";
 import { DiskSpaceCheckerBunAdapter } from "../disk-space-checker-bun.adapter";
 import * as prereqs from "../prerequisites.service";
 
+type Dependencies = { DiskSpaceChecker?: DiskSpaceCheckerPort };
+
 export class PrerequisiteSpace implements prereqs.Prerequisite {
   readonly kind = "space";
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
   private readonly minimum: tools.Size;
-  private readonly DiskSpaceChecker: DiskSpaceCheckerPort;
 
   constructor(
-    config: prereqs.PrerequisiteConfigType & { minimum: tools.Size; DiskSpaceChecker?: DiskSpaceCheckerPort },
+    config: prereqs.PrerequisiteConfigType & { minimum: tools.Size },
+    private readonly deps?: Dependencies,
   ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.minimum = config.minimum;
-    this.DiskSpaceChecker = config.DiskSpaceChecker ?? new DiskSpaceCheckerBunAdapter();
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const DiskSpaceChecker = this.deps?.DiskSpaceChecker ?? new DiskSpaceCheckerBunAdapter();
     const stopwatch = new tools.Stopwatch(clock.now());
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
     try {
       const root = path.sep;
-      const freeDiskSpace = await this.DiskSpaceChecker.get(root);
+      const freeDiskSpace = await DiskSpaceChecker.get(root);
 
       if (freeDiskSpace.isGreaterThan(this.minimum)) return prereqs.Verification.success(stopwatch.stop());
       return prereqs.Verification.failure(stopwatch.stop(), {

package/src/prerequisites/ssl-certificate-expiry.ts

@@ -3,6 +3,8 @@ import type { CertificateInspectorPort } from "../certificate-inspector.port";
 import type { ClockPort } from "../clock.port";
 import * as prereqs from "../prerequisites.service";
 
+type Dependencies = { CertificateInspector: CertificateInspectorPort };
+
 export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
   readonly kind = "ssl-certificate-expiry";
   readonly label: prereqs.PrerequisiteLabelType;
@@ -10,21 +12,16 @@ export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
 
   private readonly hostname: string;
   private readonly days: number;
-  private readonly CertificateInspector: CertificateInspectorPort;
 
   constructor(
-    config: prereqs.PrerequisiteConfigType & {
-      hostname: string;
-      days: number;
-      CertificateInspector: CertificateInspectorPort;
-    },
+    config: prereqs.PrerequisiteConfigType & { hostname: string; days: number },
+    private readonly deps: Dependencies,
   ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.hostname = config.hostname;
     this.days = config.days;
-    this.CertificateInspector = config.CertificateInspector;
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
@@ -32,7 +29,7 @@ export class PrerequisiteSSLCertificateExpiry implements prereqs.Prerequisite {
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
 
-    const result = await this.CertificateInspector.inspect(this.hostname);
+    const result = await this.deps.CertificateInspector.inspect(this.hostname);
 
     if (!result.success)
       return prereqs.Verification.failure(stopwatch.stop(), { message: "Certificate unavailable" });

package/src/prerequisites/translations.ts

@@ -15,6 +15,8 @@ type PrerequisiteTranslationsProblemType = {
   missingIn: tools.LanguageType;
 };
 
+type Dependencies = { Logger: LoggerPort; JsonFileReader?: JsonFileReaderPort };
+
 export class PrerequisiteTranslations implements prereqs.Prerequisite {
   readonly kind = "translations";
   readonly label: prereqs.PrerequisiteLabelType;
@@ -23,28 +25,23 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
   private readonly translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
   private readonly supportedLanguages: types.I18nConfigType["supportedLanguages"];
 
-  private readonly Logger: LoggerPort;
-  private readonly JsonFileReader: JsonFileReaderPort;
-
   constructor(
     config: prereqs.PrerequisiteConfigType & {
       translationsPath?: typeof I18n.DEFAULT_TRANSLATIONS_PATH;
       supportedLanguages: types.I18nConfigType["supportedLanguages"];
-      Logger: LoggerPort;
-      JsonFileReader?: JsonFileReaderPort;
     },
+    private readonly deps: Dependencies,
   ) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
     this.translationsPath = config.translationsPath;
     this.supportedLanguages = config.supportedLanguages;
-
-    this.Logger = config.Logger;
-    this.JsonFileReader = config.JsonFileReader ?? new JsonFileReaderBunForgivingAdapter();
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
+    const JsonFileReader = this.deps.JsonFileReader ?? new JsonFileReaderBunForgivingAdapter();
+
     const stopwatch = new tools.Stopwatch(clock.now());
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
@@ -52,7 +49,7 @@ export class PrerequisiteTranslations implements prereqs.Prerequisite {
     const translationsPath = this.translationsPath ?? I18n.DEFAULT_TRANSLATIONS_PATH;
 
     const supportedLanguages = Object.keys(this.supportedLanguages);
-    const i18n = new I18n({ Logger: this.Logger, JsonFileReader: this.JsonFileReader });
+    const i18n = new I18n({ Logger: this.deps.Logger, JsonFileReader: JsonFileReader });
 
     try {
       await fsp.access(translationsPath, constants.R_OK);