@bgord/bun 1.4.15 → 1.4.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bgord/bun",
-  "version": "1.4.15",
+  "version": "1.4.17",
   "license": "MIT",
   "type": "module",
   "author": "Bartosz Gordon",

package/readme.md

@@ -135,6 +135,7 @@ src/
 ├── image-resizer.port.ts
 ├── invariant-error-handler.service.ts
 ├── invariant.service.ts
+├── job-handler.service.ts
 ├── jobs.service.ts
 ├── json-file-reader-bun-forgiving.adapter.ts
 ├── json-file-reader-bun.adapter.ts

package/src/environment-validator.service.ts

@@ -1,6 +1,8 @@
 import type { z } from "zod/v4";
 import { NodeEnvironment, type NodeEnvironmentEnum } from "../src/node-env.vo";
 
+export type EnvironmentResultType<Schema> = z.infer<Schema> & { type: NodeEnvironmentEnum };
+
 export class EnvironmentValidator<Schema extends z.ZodObject<any>> {
   private readonly type: NodeEnvironmentEnum;
   private readonly schema: Schema;
@@ -10,7 +12,7 @@ export class EnvironmentValidator<Schema extends z.ZodObject<any>> {
     this.type = NodeEnvironment.parse(config.type);
   }
 
-  load(env: NodeJS.ProcessEnv): z.infer<Schema> & { type: NodeEnvironmentEnum } {
+  load(env: NodeJS.ProcessEnv): EnvironmentResultType<Schema> {
     return { ...this.schema.parse(env), type: this.type };
   }
 }

package/src/index.ts

@@ -110,6 +110,7 @@ export * from "./image-resizer-noop.adapter";
 export * from "./image-resizer-sharp.adapter";
 export * from "./invariant.service";
 export * from "./invariant-error-handler.service";
+export * from "./job-handler.service";
 export * from "./jobs.service";
 export * from "./json-file-reader.port";
 export * from "./json-file-reader-bun.adapter";

package/src/job-handler.service.ts

@@ -0,0 +1,54 @@
+import * as tools from "@bgord/tools";
+import type { Cron } from "croner";
+import type { ClockPort } from "./clock.port";
+import { CorrelationStorage } from "./correlation-storage.service";
+import type { IdProviderPort } from "./id-provider.port";
+import type { JobNameType } from "./jobs.service";
+import type { LoggerPort } from "./logger.port";
+import { formatError } from "./logger-format-error.service";
+
+type Dependencies = { Logger: LoggerPort; IdProvider: IdProviderPort; Clock: ClockPort };
+
+export interface UnitOfWork {
+  label: JobNameType;
+  process: () => Promise<void>;
+}
+
+export class JobHandler {
+  private readonly base = { component: "infra", operation: "job_handler" };
+
+  constructor(private readonly deps: Dependencies) {}
+
+  handle(uow: UnitOfWork) {
+    const correlationId = this.deps.IdProvider.generate();
+
+    return async () => {
+      const stopwatch = new tools.Stopwatch(this.deps.Clock.now());
+
+      try {
+        this.deps.Logger.info({ message: `${uow.label} start`, correlationId, ...this.base });
+
+        await CorrelationStorage.run(correlationId, uow.process);
+
+        this.deps.Logger.info({
+          message: `${uow.label} success`,
+          correlationId,
+          metadata: stopwatch.stop(),
+          ...this.base,
+        });
+      } catch (error) {
+        this.deps.Logger.error({
+          message: `${uow.label} error`,
+          correlationId,
+          error: formatError(error),
+          metadata: { ...stopwatch.stop() },
+          ...this.base,
+        });
+      }
+    };
+  }
+
+  protect(cron: Cron) {
+    return async () => this.deps.Logger.info({ message: `${cron.name} overrun`, ...this.base });
+  }
+}

package/src/jobs.service.ts

@@ -1,16 +1,7 @@
-import * as tools from "@bgord/tools";
 import type { Cron } from "croner";
-import type { ClockPort } from "./clock.port";
-import { CorrelationStorage } from "./correlation-storage.service";
-import type { IdProviderPort } from "./id-provider.port";
-import type { LoggerPort } from "./logger.port";
-import { formatError } from "./logger-format-error.service";
 
 export type JobNameType = string;
 export type MultipleJobsType = Record<JobNameType, Cron>;
-export type JobProcessorType = { cron: string; label: JobNameType; process: () => Promise<void> };
-
-type Dependencies = { Logger: LoggerPort; IdProvider: IdProviderPort; Clock: ClockPort };
 
 export class Jobs {
   static SCHEDULES = { EVERY_MINUTE: "* * * * *", EVERY_HOUR: "0 * * * *" };
@@ -23,48 +14,3 @@ export class Jobs {
     return Object.values(jobs).every((job) => job.isRunning());
   }
 }
-
-export class JobHandler {
-  private readonly base = { component: "infra", operation: "job_handler" };
-
-  constructor(private readonly deps: Dependencies) {}
-
-  handle(jobProcessor: JobProcessorType) {
-    const correlationId = this.deps.IdProvider.generate();
-
-    // biome-ignore lint: lint/complexity/noUselessThisAlias
-    const that = this;
-
-    return async () => {
-      const stopwatch = new tools.Stopwatch(this.deps.Clock.now());
-
-      try {
-        that.deps.Logger.info({ message: `${jobProcessor.label} start`, correlationId, ...this.base });
-
-        await CorrelationStorage.run(correlationId, jobProcessor.process);
-
-        that.deps.Logger.info({
-          message: `${jobProcessor.label} success`,
-          correlationId,
-          metadata: stopwatch.stop(),
-          ...this.base,
-        });
-      } catch (error) {
-        that.deps.Logger.error({
-          message: `${jobProcessor.label} error`,
-          correlationId,
-          error: formatError(error),
-          metadata: { ...stopwatch.stop() },
-          ...this.base,
-        });
-      }
-    };
-  }
-
-  protect(cron: Cron) {
-    // biome-ignore lint: lint/complexity/noUselessThisAlias
-    const that = this;
-
-    return async () => that.deps.Logger.info({ message: `${cron.name} overrun`, ...this.base });
-  }
-}

package/src/prerequisites/jobs.ts

@@ -8,20 +8,20 @@ export class PrerequisiteJobs implements prereqs.Prerequisite {
   readonly label: prereqs.PrerequisiteLabelType;
   readonly enabled?: boolean = true;
 
-  private readonly jobs: MultipleJobsType;
+  private readonly Jobs: MultipleJobsType;
 
-  constructor(config: prereqs.PrerequisiteConfigType & { jobs: MultipleJobsType }) {
+  constructor(config: prereqs.PrerequisiteConfigType & { Jobs: MultipleJobsType }) {
     this.label = config.label;
     this.enabled = config.enabled === undefined ? true : config.enabled;
 
-    this.jobs = config.jobs;
+    this.Jobs = config.Jobs;
   }
 
   async verify(clock: ClockPort): Promise<prereqs.VerifyOutcome> {
     const stopwatch = new tools.Stopwatch(clock.now());
 
     if (!this.enabled) return prereqs.Verification.undetermined(stopwatch.stop());
-    if (Jobs.areAllRunning(this.jobs)) return prereqs.Verification.success(stopwatch.stop());
+    if (Jobs.areAllRunning(this.Jobs)) return prereqs.Verification.success(stopwatch.stop());
     return prereqs.Verification.failure(stopwatch.stop());
   }
 }