@bgord/bun 1.18.11 → 1.18.13

package/src/job-failer-sqlite.adapter.ts

@@ -1,6 +1,7 @@
 import type { Database } from "bun:sqlite";
 import type { GenericJob } from "./job.types";
 import type { JobFailerPort } from "./job-failer.port";
+import { JobStatusEnum } from "./job-status.vo";
 
 type Dependencies = { db: Database };
 
@@ -8,6 +9,8 @@ export class JobFailerSqliteAdapter implements JobFailerPort {
   constructor(private readonly deps: Dependencies) {}
 
   async fail(id: GenericJob["id"]): Promise<void> {
-    this.deps.db.run<[GenericJob["id"]]>("UPDATE jobs SET status = 'failed' WHERE id = ?", [id]);
+    this.deps.db.run<[GenericJob["id"]]>(`UPDATE jobs SET status = '${JobStatusEnum.failed}' WHERE id = ?`, [
+      id,
+    ]);
   }
 }

package/src/job-pruner-collecting.adapter.ts

@@ -0,0 +1,14 @@
+import * as tools from "@bgord/tools";
+import type { JobPrunerPort } from "./job-pruner.port";
+
+export class JobPrunerCollectingAdapter implements JobPrunerPort {
+  readonly pruned: Array<[tools.Duration, tools.IntegerNonNegativeType]> = [];
+
+  async prune(olderThan: tools.Duration): Promise<tools.IntegerNonNegativeType> {
+    const count = tools.Int.nonNegative(0);
+
+    this.pruned.push([olderThan, count]);
+
+    return count;
+  }
+}

package/src/job-pruner-noop.adapter.ts

@@ -0,0 +1,8 @@
+import * as tools from "@bgord/tools";
+import type { JobPrunerPort } from "./job-pruner.port";
+
+export class JobPrunerNoopAdapter implements JobPrunerPort {
+  async prune(_olderThan: tools.Duration): Promise<tools.IntegerNonNegativeType> {
+    return tools.Int.nonNegative(1);
+  }
+}

package/src/job-pruner-sqlite.adapter.ts

@@ -0,0 +1,23 @@
+import type { Database } from "bun:sqlite";
+import * as tools from "@bgord/tools";
+import type { ClockPort } from "./clock.port";
+import type { JobPrunerPort } from "./job-pruner.port";
+
+type Dependencies = { db: Database; Clock: ClockPort };
+
+export class JobPrunerSqliteAdapter implements JobPrunerPort {
+  constructor(private readonly deps: Dependencies) {}
+
+  async prune(olderThan: tools.Duration): Promise<tools.IntegerNonNegativeType> {
+    const threshold = this.deps.Clock.now().subtract(olderThan).ms;
+
+    const result = this.deps.db.run<[tools.TimestampValueType]>(
+      `DELETE FROM jobs
+         WHERE status IN ('completed', 'failed')
+           AND createdAt <= ?`,
+      [threshold],
+    );
+
+    return tools.Int.nonNegative(result.changes);
+  }
+}

package/src/job-pruner.port.ts

@@ -0,0 +1,5 @@
+import type * as tools from "@bgord/tools";
+
+export interface JobPrunerPort {
+  prune(olderThan: tools.Duration): Promise<tools.IntegerNonNegativeType>;
+}

package/src/job-pruner.service.ts

@@ -0,0 +1,16 @@
+import type * as tools from "@bgord/tools";
+import type { CronTask } from "./cron-task.vo";
+import type { JobPrunerPort } from "./job-pruner.port";
+
+type Config = { label: CronTask["label"]; cron: CronTask["cron"]; olderThan: tools.Duration };
+type Dependencies = { JobPruner: JobPrunerPort };
+
+export function JobPrunerService(config: Config, deps: Dependencies): CronTask {
+  return {
+    label: config.label,
+    cron: config.cron,
+    handler: async () => {
+      await deps.JobPruner.prune(config.olderThan);
+    },
+  };
+}

package/src/job-queue-sqlite-store.service.ts

@@ -1,4 +1,5 @@
 import { Database } from "bun:sqlite";
+import { JobStatusEnum } from "./job-status.vo";
 
 type Config = { database: string };
 
@@ -17,7 +18,7 @@ export class JobQueueSqliteStore {
         name TEXT NOT NULL,
         revision INTEGER NOT NULL DEFAULT 0,
         payload TEXT NOT NULL,
-        status TEXT NOT NULL DEFAULT 'pending',
+        status TEXT NOT NULL DEFAULT '${JobStatusEnum.pending}',
         claimableAt INTEGER NOT NULL DEFAULT 0
       )
     `);

package/src/job-queue-stats-provider-sqlite.adapter.ts

@@ -1,6 +1,7 @@
 import type { Database } from "bun:sqlite";
 import * as tools from "@bgord/tools";
 import type { JobQueueStatsProviderPort, JobQueueStatsSnapshot } from "./job-queue-stats-provider.port";
+import { JobStatusEnum } from "./job-status.vo";
 
 type Dependencies = { db: Database };
 
@@ -14,9 +15,9 @@ export class JobQueueStatsProviderSqliteAdapter implements JobQueueStatsProvider
       )
       .all();
 
-    const oldest = this.deps.db
+    const oldestPending = this.deps.db
       .query<{ createdAt: number | null }, []>(
-        "SELECT MIN(createdAt) as createdAt FROM jobs WHERE status = 'pending'",
+        `SELECT MIN(createdAt) as createdAt FROM jobs WHERE status = '${JobStatusEnum.pending}'`,
       )
       .get();
 
@@ -27,7 +28,7 @@ export class JobQueueStatsProviderSqliteAdapter implements JobQueueStatsProvider
       claimed: tools.Int.nonNegative(counts["claimed"] ?? 0),
       completed: tools.Int.nonNegative(counts["completed"] ?? 0),
       failed: tools.Int.nonNegative(counts["failed"] ?? 0),
-      oldestPending: oldest?.createdAt ? tools.Timestamp.fromNumber(oldest.createdAt).ms : null,
+      oldestPending: oldestPending?.createdAt ? tools.Timestamp.fromNumber(oldestPending.createdAt).ms : null,
     };
   }
 }

package/src/job-queue.adapter.ts

@@ -23,11 +23,11 @@ type Config<Job extends GenericJob> = {
 export class JobQueueAdapter<Job extends GenericJob> implements JobQueuePort<Job> {
   constructor(private readonly config: Config<Job>) {}
 
-  async enqueue<EnqueuedJob extends Job>(job: EnqueuedJob): Promise<EnqueuedJob> {
-    const serialized = await this.config.enqueuer.enqueue({
-      ...job,
-      payload: this.config.serializer.serialize(job.payload),
-    });
+  async enqueue<EnqueuedJob extends Job>(job: EnqueuedJob, delay?: tools.Duration): Promise<EnqueuedJob> {
+    const serialized = await this.config.enqueuer.enqueue(
+      { ...job, payload: this.config.serializer.serialize(job.payload) },
+      delay,
+    );
 
     return { ...serialized, payload: this.config.serializer.deserialize(serialized.payload) } as EnqueuedJob;
   }

package/src/job-queue.port.ts

@@ -4,7 +4,7 @@ import type { JobHandler } from "./job-registry.port";
 import type { JobRetryPolicyStrategy } from "./job-retry-policy.strategy";
 
 export interface JobDispatcherPort<Job extends GenericJob> {
-  enqueue<EnqueuedJob extends Job>(job: EnqueuedJob): Promise<EnqueuedJob>;
+  enqueue<EnqueuedJob extends Job>(job: EnqueuedJob, delay?: tools.Duration): Promise<EnqueuedJob>;
 }
 
 export interface JobQueuePort<Job extends GenericJob> extends JobDispatcherPort<Job> {

package/src/job-requeuer-sqlite.adapter.ts

@@ -3,6 +3,7 @@ import type * as tools from "@bgord/tools";
 import type { ClockPort } from "./clock.port";
 import type { GenericJob } from "./job.types";
 import type { JobRequeuerPort } from "./job-requeuer.port";
+import { JobStatusEnum } from "./job-status.vo";
 
 type Dependencies = { db: Database; Clock: ClockPort };
 
@@ -15,7 +16,7 @@ export class JobRequeuerSqliteAdapter implements JobRequeuerPort {
     delay: tools.Duration,
   ): Promise<void> {
     this.deps.db.run<[GenericJob["revision"], tools.TimestampValueType, GenericJob["id"]]>(
-      "UPDATE jobs SET status = 'pending', revision = ?, claimableAt = ? WHERE id = ?",
+      `UPDATE jobs SET status = '${JobStatusEnum.pending}', revision = ?, claimableAt = ? WHERE id = ?`,
       [revision, this.deps.Clock.now().add(delay).ms, id],
     );
   }

package/src/job-status.vo.ts

@@ -0,0 +1,6 @@
+export enum JobStatusEnum {
+  pending = "pending",
+  claimed = "claimed",
+  completed = "completed",
+  failed = "failed",
+}

package/src/sitemap-changefreq.vo.ts

@@ -0,0 +1,9 @@
+export enum SitemapChangefreqEnum {
+  always = "always",
+  hourly = "hourly",
+  daily = "daily",
+  weekly = "weekly",
+  monthly = "monthly",
+  yearly = "yearly",
+  never = "never",
+}

package/src/sitemap-entries-provider-dynamic.adapter.ts

@@ -0,0 +1,14 @@
+import type { SitemapEntriesProvider } from "./sitemap-entries-provider.port";
+import type { SitemapEntry } from "./sitemap-entry.vo";
+
+type Config<T> = { fetcher: () => Promise<ReadonlyArray<T>>; mapper: (item: T) => SitemapEntry };
+
+export class SitemapEntriesProviderDynamicAdapter<T> implements SitemapEntriesProvider {
+  constructor(private readonly config: Config<T>) {}
+
+  async produce(): Promise<ReadonlyArray<SitemapEntry>> {
+    const items = await this.config.fetcher();
+
+    return items.map(this.config.mapper);
+  }
+}

package/src/sitemap-entries-provider-static.adapter.ts

@@ -0,0 +1,10 @@
+import type { SitemapEntriesProvider } from "./sitemap-entries-provider.port";
+import type { SitemapEntry } from "./sitemap-entry.vo";
+
+export class SitemapEntriesProviderStaticAdapter implements SitemapEntriesProvider {
+  constructor(private readonly entries: ReadonlyArray<SitemapEntry>) {}
+
+  async produce(): Promise<ReadonlyArray<SitemapEntry>> {
+    return this.entries;
+  }
+}

package/src/sitemap-entries-provider-with-cache.adapter.ts

@@ -0,0 +1,32 @@
+import type { CacheResolverStrategy } from "./cache-resolver.strategy";
+import type { HashContentStrategy } from "./hash-content.strategy";
+import type { SitemapEntriesProvider } from "./sitemap-entries-provider.port";
+import type { SitemapEntry } from "./sitemap-entry.vo";
+import { SubjectApplicationResolver } from "./subject-application-resolver.vo";
+import { SubjectSegmentFixedStrategy } from "./subject-segment-fixed.strategy";
+
+type Config = { id: string; inner: SitemapEntriesProvider };
+type Dependencies = { CacheResolver: CacheResolverStrategy; HashContent: HashContentStrategy };
+
+export class SitemapEntriesProviderWithCacheAdapter implements SitemapEntriesProvider {
+  constructor(
+    private readonly config: Config,
+    private readonly deps: Dependencies,
+  ) {}
+
+  async produce(): Promise<ReadonlyArray<SitemapEntry>> {
+    const resolver = new SubjectApplicationResolver(
+      [
+        new SubjectSegmentFixedStrategy("sitemap_entries_provider"),
+        new SubjectSegmentFixedStrategy(this.config.id),
+      ],
+      this.deps,
+    );
+
+    const subject = await resolver.resolve();
+
+    return this.deps.CacheResolver.resolve<ReadonlyArray<SitemapEntry>>(subject.hex, () =>
+      this.config.inner.produce(),
+    );
+  }
+}

package/src/sitemap-entries-provider.port.ts

@@ -0,0 +1,5 @@
+import type { SitemapEntry } from "./sitemap-entry.vo";
+
+export interface SitemapEntriesProvider {
+  produce(): Promise<ReadonlyArray<SitemapEntry>>;
+}

package/src/sitemap-entry.vo.ts

@@ -0,0 +1,28 @@
+import type * as tools from "@bgord/tools";
+import type { SitemapChangefreqEnum } from "./sitemap-changefreq.vo";
+import type { SitemapPriorityType } from "./sitemap-priority.vo";
+import type { SitemapUrlType } from "./sitemap-url.vo";
+
+export type SitemapEntryType = {
+  loc: SitemapUrlType;
+  lastmod?: tools.DayIsoIdType;
+  changefreq?: SitemapChangefreqEnum;
+  priority?: SitemapPriorityType;
+};
+
+export class SitemapEntry {
+  constructor(private readonly entry: SitemapEntryType) {}
+
+  toXml(): string {
+    const lastmod = this.entry.lastmod ? `<lastmod>${this.entry.lastmod}</lastmod>` : "";
+
+    const changefreq = this.entry.changefreq ? `<changefreq>${this.entry.changefreq}</changefreq>` : "";
+
+    const priority =
+      this.entry.priority !== undefined ? `<priority>${this.entry.priority.toFixed(1)}</priority>` : "";
+
+    const loc = `<loc>${this.entry.loc}</loc>`;
+
+    return ["<url>", loc, lastmod, changefreq, priority, "</url>"].join("");
+  }
+}

package/src/sitemap-hono.handler.ts

@@ -0,0 +1,22 @@
+import { createFactory } from "hono/factory";
+import type { HandlerHonoPort } from "./handler-hono.port";
+import { SitemapHandler, type SitemapHandlerConfig } from "./sitemap.handler";
+
+const factory = createFactory();
+
+export class SitemapHonoHandler implements HandlerHonoPort {
+  private readonly handler: SitemapHandler;
+
+  constructor(config: SitemapHandlerConfig) {
+    this.handler = new SitemapHandler(config);
+  }
+
+  handle() {
+    return factory.createHandlers(async (c) => {
+      const xml = await this.handler.generate();
+
+      c.header("Content-Type", "application/xml");
+      return c.body(xml, 200);
+    });
+  }
+}

package/src/sitemap-priority.vo.ts

@@ -0,0 +1,13 @@
+import * as v from "valibot";
+
+export const SitemapPriorityError = { Invalid: "sitemap.priority.invalid" };
+
+export const SitemapPriority = v.pipe(
+  v.number(SitemapPriorityError.Invalid),
+  v.minValue(0, SitemapPriorityError.Invalid),
+  v.maxValue(1, SitemapPriorityError.Invalid),
+  // Stryker disable next-line StringLiteral
+  v.brand("SitemapPriority"),
+);
+
+export type SitemapPriorityType = v.InferOutput<typeof SitemapPriority>;

package/src/sitemap-url.vo.ts

@@ -0,0 +1,12 @@
+import * as tools from "@bgord/tools";
+import * as v from "valibot";
+
+export const SitemapUrlError = { Invalid: "sitemap.url.invalid" };
+
+export const SitemapUrl = v.pipe(
+  v.union([tools.UrlWithSlash, tools.UrlWithoutSlash], SitemapUrlError.Invalid),
+  // Stryker disable next-line StringLiteral
+  v.brand("SitemapUrl"),
+);
+
+export type SitemapUrlType = v.InferOutput<typeof SitemapUrl>;

package/src/sitemap.handler.ts

@@ -0,0 +1,11 @@
+import type { Sitemap } from "./sitemap.service";
+
+export type SitemapHandlerConfig = { sitemap: Sitemap };
+
+export class SitemapHandler {
+  constructor(private readonly config: SitemapHandlerConfig) {}
+
+  async generate(): Promise<string> {
+    return this.config.sitemap.toXml();
+  }
+}

package/src/sitemap.service.ts

@@ -0,0 +1,20 @@
+import type { SitemapEntriesProvider } from "./sitemap-entries-provider.port";
+
+export type SitemapXml = string;
+
+export class Sitemap {
+  constructor(private readonly providers: ReadonlyArray<SitemapEntriesProvider>) {}
+
+  async toXml(): Promise<SitemapXml> {
+    const resolved = await Promise.all(this.providers.map((provider) => provider.produce()));
+
+    const xmls = resolved.flat().map((entry) => entry.toXml());
+
+    return [
+      '<?xml version="1.0" encoding="UTF-8"?>',
+      '<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
+      ...xmls,
+      "</urlset>",
+    ].join("");
+  }
+}