@sekiban/create-dcb 0.0.0-stage → 0.1.1

package/template/src/booking-routes.ts

@@ -0,0 +1,160 @@
+import { ClientError, createSekibanExecutor, type ExecuteResult } from "@sekiban/dcb-client";
+import {
+  createV1Transport,
+  executeBookingCommand,
+  parseBookingCommandRequest,
+  type InternalRuntimeFetcher,
+} from "./booking-transport";
+import { reservationTag, roomTag } from "./booking-domain";
+import type { CloudflareOnlyEnv } from "@sekiban/dcb-runtime/cloudflare";
+
+export interface StarterEnvironment extends CloudflareOnlyEnv {
+  readonly ASSETS?: Fetcher;
+  readonly SDT_SERVICE_ID: string;
+}
+
+export interface StarterRuntime {
+  readonly fetch: (request: Request, env: StarterEnvironment, ctx: ExecutionContext) => Promise<Response>;
+}
+
+function json(body: unknown, status = 200): Response {
+  return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json; charset=utf-8" } });
+}
+
+function runtimeFetcher(runtime: StarterRuntime, env: StarterEnvironment, ctx: ExecutionContext): InternalRuntimeFetcher {
+  return {
+    fetch: (input, init) => runtime.fetch(new Request(input, init), env, ctx),
+  };
+}
+
+function resultBody(result: ExecuteResult): Record<string, unknown> {
+  const body = { ...result } as Record<string, unknown>;
+  delete body.cause;
+  return body;
+}
+
+function resultResponse(result: ExecuteResult): Response {
+  const body = resultBody(result);
+  switch (result.kind) {
+    case "committed":
+    case "noop":
+      return json(body);
+    case "conflict":
+      return json({ error: result.error ?? "Command conflicted", code: result.code ?? result.kind, ...body }, 409);
+    case "rejected":
+    case "invalid":
+      return json({ error: result.error ?? "Command was rejected", code: result.code ?? result.kind, ...body }, 400);
+    case "partial":
+      return json({ error: result.error ?? "Commit was partial", code: result.code ?? result.kind, ...body }, 500);
+    case "timeout":
+      return json({ error: result.error ?? "Command outcome is undetermined", code: result.code ?? result.kind, ...body }, 504);
+    case "unavailable":
+      return json({ error: result.error ?? "Projection is unavailable", code: result.code ?? result.kind, ...body }, 503);
+    case "transport":
+      return json({ error: result.error ?? "Command transport failed", code: result.code ?? result.kind, ...body }, 502);
+  }
+}
+
+async function command(request: Request, env: StarterEnvironment, ctx: ExecutionContext, runtime: StarterRuntime): Promise<Response> {
+  if (request.method !== "POST") return json({ error: "Command route requires POST", code: "validation_error" }, 405);
+  const commandId = new URL(request.url).pathname.slice("/api/commands/".length);
+  let body: unknown;
+  try {
+    body = await request.json();
+  } catch {
+    return json({ error: "Command request must be JSON", code: "validation_error" }, 400);
+  }
+  try {
+    const parsed = parseBookingCommandRequest(body);
+    const result = await executeBookingCommand(commandId, parsed.input, {
+      RUNTIME: runtimeFetcher(runtime, env, ctx),
+      serviceId: env.SDT_SERVICE_ID,
+    }, parsed.options);
+    return resultResponse(result);
+  } catch (error) {
+    return json({ error: error instanceof Error ? error.message : "Command request was invalid", code: "validation_error" }, 400);
+  }
+}
+
+function decodePayload(value: unknown): unknown {
+  if (typeof value !== "string") return value;
+  try {
+    const binary = atob(value);
+    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
+    return JSON.parse(new TextDecoder().decode(bytes));
+  } catch {
+    try { return JSON.parse(value); } catch { return value; }
+  }
+}
+
+async function readProjection(request: Request, env: StarterEnvironment, ctx: ExecutionContext, runtime: StarterRuntime): Promise<Response> {
+  if (request.method !== "GET") return json({ error: "Projection routes require GET", code: "validation_error" }, 405);
+  const url = new URL(request.url);
+  const isRoom = url.pathname === "/api/read/room";
+  const isReservation = url.pathname === "/api/read/reservation";
+  const parameter = isRoom ? "roomId" : "reservationId";
+  const value = url.searchParams.get(parameter);
+  if (!isRoom && !isReservation) return json({ error: "Projection route was not found", code: "not_found" }, 404);
+  if (value === null || value.length === 0) return json({ error: `${parameter} is required`, code: "validation_error" }, 400);
+  const tag = isRoom ? roomTag(value) : reservationTag(value);
+  const projector = isRoom ? "RoomProjector" : "ReservationProjector";
+  const response = await runtime.fetch(new Request("https://runtime.internal/api/sekiban/serialized/tag-state", {
+    method: "POST",
+    headers: { "content-type": "application/json", accept: "application/json" },
+    body: JSON.stringify({ tagStateId: `${tag.id}:${projector}` }),
+  }), env, ctx);
+  let body: unknown;
+  try { body = await response.json(); } catch { return json({ error: "Projection read returned invalid JSON", code: "transport" }, 502); }
+  if (!response.ok) return json(body, response.status);
+  if (typeof body !== "object" || body === null || Array.isArray(body)) return json({ error: "Projection read returned an invalid body", code: "transport" }, 502);
+  const record = body as Record<string, unknown>;
+  return json({ projection: isRoom ? "room" : "reservation", [parameter]: value, tagStateId: `${tag.id}:${projector}`, state: decodePayload(record.payload), version: record.version, lastSortableUniqueId: record.lastSortableUniqueId });
+}
+
+function positiveInteger(value: string | null, fallback: number): number | Response {
+  if (value === null) return fallback;
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1) return json({ error: "page values must be positive integers", code: "validation_error" }, 400);
+  return parsed;
+}
+
+async function readQuery(request: Request, env: StarterEnvironment, ctx: ExecutionContext, runtime: StarterRuntime): Promise<Response> {
+  if (request.method !== "GET") return json({ error: "Query routes require GET", code: "validation_error" }, 405);
+  const url = new URL(request.url);
+  const reservations = url.pathname === "/api/read/reservations";
+  const rooms = url.pathname === "/api/read/room-query";
+  if (!reservations && !rooms) return json({ error: "Query route was not found", code: "not_found" }, 404);
+  const transport = createV1Transport(runtimeFetcher(runtime, env, ctx), env.SDT_SERVICE_ID);
+  const executor = createSekibanExecutor(transport, { serviceId: env.SDT_SERVICE_ID });
+  try {
+    if (reservations) {
+      const pageNumber = positiveInteger(url.searchParams.get("pageNumber"), 1);
+      const pageSize = positiveInteger(url.searchParams.get("pageSize"), 20);
+      if (pageNumber instanceof Response) return pageNumber;
+      if (pageSize instanceof Response) return pageSize;
+      const result = await executor.listQuery({
+        queryType: "GetReservationListQuery",
+        queryParamsJson: JSON.stringify({ PageNumber: pageNumber, PageSize: pageSize, NewestFirst: url.searchParams.get("newestFirst") === "true" }),
+      }, { consistency: "unsafe" });
+      return json(result);
+    }
+    const result = await executor.query({
+      queryType: "GetRoomStateQuery",
+      queryParamsJson: JSON.stringify({ roomId: url.searchParams.get("roomId") ?? undefined }),
+    });
+    return json(result);
+  } catch (error) {
+    if (error instanceof ClientError) return json({ error: error.message, code: error.code }, error.status ?? 502);
+    return json({ error: "Query read failed", code: "transport" }, 502);
+  }
+}
+
+export async function applicationFetch(request: Request, env: StarterEnvironment, ctx: ExecutionContext, runtime: StarterRuntime): Promise<Response> {
+  const path = new URL(request.url).pathname;
+  if (path.startsWith("/api/commands/")) return command(request, env, ctx, runtime);
+  if (path === "/api/read/room" || path === "/api/read/reservation") return readProjection(request, env, ctx, runtime);
+  if (path === "/api/read/reservations" || path === "/api/read/room-query") return readQuery(request, env, ctx, runtime);
+  if (env.ASSETS !== undefined) return env.ASSETS.fetch(request);
+  if (path === "/" || path === "/index.html") return new Response("Booking starter", { headers: { "content-type": "text/plain; charset=utf-8" } });
+  return new Response("Not found", { status: 404 });
+}

package/template/src/booking-transport.ts

@@ -0,0 +1,169 @@
+import {
+  createInProcessTransport,
+  createSekibanExecutor,
+  type CommitEnvelope,
+  type CommitHttpResult,
+  type ExecuteCommandOptions,
+  type ExecuteCommandResult,
+  type ReadonlyTagStateResponse,
+  type SerializedDcbTransport,
+} from "@sekiban/dcb-client";
+import { normalizeTag, type PortableSnapshot } from "@sekiban/dcb-domain";
+import { assertJsonValue } from "@sekiban/dcb-core";
+import {
+  bookingCommands,
+  cancelReservationCommand,
+  createRoomCommand,
+  releaseRoomCommand,
+  reserveRoomCommand,
+} from "./booking-domain";
+
+export interface InternalRuntimeFetcher {
+  fetch(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+}
+
+export interface BookingCommandEnvironment {
+  readonly RUNTIME: InternalRuntimeFetcher;
+  readonly serviceId: string;
+}
+
+export interface BookingCommandRequest {
+  readonly input: unknown;
+  readonly options?: ExecuteCommandOptions;
+}
+
+function jsonBytes(value: unknown): string {
+  const bytes = new TextEncoder().encode(JSON.stringify(value));
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary);
+}
+
+function v1ConsistencyEntry(entry: { readonly tag: string; readonly lastSortableUniqueId: string }): { readonly tag: string; readonly lastSortableUniqueId: string } {
+  return { tag: entry.tag, lastSortableUniqueId: entry.lastSortableUniqueId };
+}
+
+async function readBody(response: Response): Promise<unknown> {
+  try {
+    return await response.json();
+  } catch {
+    return { error: `HTTP ${response.status}`, code: "transport" };
+  }
+}
+
+/** Small V1 transport used by the demo's query routes. */
+export function createV1Transport(fetcher: InternalRuntimeFetcher, serviceId: string): SerializedDcbTransport {
+  const call = async (path: string, body: unknown, signal?: AbortSignal): Promise<CommitHttpResult> => {
+    const response = await fetcher.fetch(`https://runtime.internal${path}`, {
+      method: "POST",
+      headers: { "content-type": "application/json", accept: "application/json" },
+      body: JSON.stringify(body),
+      signal,
+    });
+    const headers: Record<string, string> = {};
+    response.headers.forEach((value, key) => { headers[key] = value; });
+    return { status: response.status, headers, body: await readBody(response) };
+  };
+  return {
+    serviceId,
+    async readTagState(request, signal) {
+      const result = await call("/api/sekiban/serialized/tag-state", request, signal);
+      return result.status >= 200 && result.status < 300 ? result.body as ReadonlyTagStateResponse : result;
+    },
+    async readTagLatestSortable(request, signal) {
+      const result = await call("/api/sekiban/serialized/tag-latest-sortable", request, signal);
+      return result.status >= 200 && result.status < 300
+        ? result.body as { readonly exists: boolean; readonly lastSortableUniqueId: string }
+        : result;
+    },
+    async commit(request: CommitEnvelope, signal) {
+      return call("/api/sekiban/serialized/commit", {
+        version: 1,
+        eventCandidates: request.candidates.map((candidate) => ({
+          payload: jsonBytes(candidate.payload),
+          eventPayloadName: candidate.eventPayloadName,
+          tags: [...candidate.tags],
+        })),
+        consistencyTags: request.consistency.map(v1ConsistencyEntry),
+      }, signal);
+    },
+    async query(request, signal) {
+      const result = await call("/api/sekiban/serialized/query", request, signal);
+      return result.status >= 200 && result.status < 300 ? result.body as { readonly resultJson: string } : result;
+    },
+    async listQuery(request, signal) {
+      const result = await call("/api/sekiban/serialized/list-query", request, signal);
+      return result.status >= 200 && result.status < 300 ? result.body as {
+        readonly itemsJson: string;
+        readonly totalCount: number;
+        readonly totalPages: number;
+        readonly currentPage: number;
+        readonly pageSize: number;
+      } : result;
+    },
+  };
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function portableSnapshot(value: unknown): PortableSnapshot {
+  if (!isRecord(value) || typeof value.projectorId !== "string" || typeof value.tag !== "string" ||
+      (value.head !== null && typeof value.head !== "string") || typeof value.exists !== "boolean" || !("state" in value)) {
+    throw new Error("Portable snapshot fields are invalid");
+  }
+  return Object.freeze({
+    projectorId: value.projectorId,
+    tag: normalizeTag(value.tag),
+    head: value.head as string | null,
+    state: assertJsonValue(value.state, "state-persistence"),
+    exists: value.exists,
+  });
+}
+
+export function parseBookingCommandRequest(body: unknown): BookingCommandRequest {
+  if (!isRecord(body) || !("input" in body)) return { input: body };
+  const executor = body.executor;
+  if (executor === undefined) return { input: body.input };
+  if (!isRecord(executor)) throw new Error("executor must be an object");
+  const readMode = executor.readMode;
+  if (readMode !== undefined && readMode !== "read-through" && readMode !== "snapshot-only") {
+    throw new Error("Executor readMode must be read-through or snapshot-only");
+  }
+  const rawSnapshots = executor.snapshots;
+  if (rawSnapshots !== undefined && !Array.isArray(rawSnapshots)) throw new Error("Executor snapshots must be an array");
+  const snapshots = rawSnapshots === undefined ? undefined : rawSnapshots.map(portableSnapshot);
+  return {
+    input: body.input,
+    options: {
+      ...(snapshots === undefined ? {} : { snapshots }),
+      ...(readMode === undefined ? {} : { readMode }),
+    },
+  };
+}
+
+function commandFor(commandId: string) {
+  switch (commandId) {
+    case "create-room": return createRoomCommand;
+    case "reserve-room": return reserveRoomCommand;
+    case "cancel-reservation": return cancelReservationCommand;
+    case "release-room": return releaseRoomCommand;
+    default: return undefined;
+  }
+}
+
+export async function executeBookingCommand(
+  commandId: string,
+  input: unknown,
+  environment: BookingCommandEnvironment,
+  options?: ExecuteCommandOptions,
+): Promise<ExecuteCommandResult> {
+  const command = commandFor(commandId);
+  if (command === undefined || !(commandId in bookingCommands)) {
+    return { kind: "invalid", attempts: 0, error: "Unknown booking command", code: "command_not_found" } as ExecuteCommandResult;
+  }
+  const transport = createInProcessTransport({ RUNTIME: environment.RUNTIME }, { serviceId: environment.serviceId });
+  const executor = createSekibanExecutor(transport, { serviceId: environment.serviceId });
+  return executor.execute(command, input as never, options);
+}

package/template/src/worker.ts

@@ -0,0 +1,38 @@
+import { composeHandlers, requireHandlers } from "@sekiban/dcb-cloudflare";
+import { createCloudflareOnlyRuntimeWorker } from "@sekiban/dcb-runtime/cloudflare";
+import { applicationFetch, type StarterEnvironment } from "./booking-routes";
+import { bookingDomain, bookingRuntimeConfig } from "./booking-domain";
+import { bookingDeliveryViews, catchUpBookingViews, ensureBookingViews } from "./booking-mv";
+
+export {
+  AllocatorDurableObject,
+  BootstrapCoordinatorDurableObject,
+  JournalDurableObject,
+  TagDurableObject,
+  TagStateDurableObject,
+} from "@sekiban/dcb-cloudflare";
+
+const runtime = requireHandlers(createCloudflareOnlyRuntimeWorker({
+  domain: bookingDomain,
+  config: bookingRuntimeConfig,
+  afterBootstrapVerify: async ({ serviceId, env }) => {
+    await ensureBookingViews(env, serviceId);
+    await catchUpBookingViews(env, serviceId);
+  },
+  deliveryViews: ({ env }) => bookingDeliveryViews(env),
+}));
+
+const worker: ExportedHandler<StarterEnvironment> = composeHandlers<StarterEnvironment>({
+  application: {
+    fetch: (request, env, ctx) => applicationFetch(request, env, ctx, runtime),
+  },
+  sekiban: {
+    prefix: "/internal/sekiban",
+    fetch: runtime.fetch,
+    authorize: () => true,
+    queue: runtime.queue,
+    scheduled: runtime.scheduled,
+  },
+});
+
+export default worker;

package/template/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "WebWorker"],
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "types": ["@cloudflare/workers-types"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/template/wrangler.jsonc

@@ -0,0 +1,55 @@
+{
+  "$schema": "./node_modules/wrangler/config-schema.json",
+  "name": "{{WORKER_NAME}}",
+  "main": "src/worker.ts",
+  "compatibility_date": "2026-08-18",
+  "compatibility_flags": ["nodejs_compat"],
+  "vars": {
+    "DOMAIN_DELIVERY_CLASS": "immediate-preferred",
+    "SDT_SERVICE_ID": "{{SERVICE_ID}}"
+  },
+  "assets": { "directory": "public" },
+  "triggers": { "crons": ["* * * * *"] },
+  "d1_databases": [
+    {
+      "binding": "D1",
+      "database_name": "{{PIPELINE_DB}}",
+      "database_id": "REPLACE_WITH_PIPELINE_D1_ID",
+      "migrations_dir": "migrations/d1/g32"
+    },
+    {
+      "binding": "D1_MV",
+      "database_name": "{{MV_DB}}",
+      "database_id": "REPLACE_WITH_MV_D1_ID",
+      "migrations_dir": "migrations/mv"
+    }
+  ],
+  "queues": {
+    "producers": [{ "binding": "DOWNSTREAM_QUEUE", "queue": "{{QUEUE_NAME}}" }],
+    "consumers": [{
+      "queue": "{{QUEUE_NAME}}",
+      "max_batch_timeout": 1,
+      "max_retries": 3,
+      "dead_letter_queue": "{{DLQ_NAME}}"
+    }]
+  },
+  "durable_objects": {
+    "bindings": [
+      { "name": "ALLOCATOR", "class_name": "AllocatorDurableObject" },
+      { "name": "BOOTSTRAP", "class_name": "BootstrapCoordinatorDurableObject" },
+      { "name": "JOURNAL", "class_name": "JournalDurableObject" },
+      { "name": "TAG", "class_name": "TagDurableObject" },
+      { "name": "TAG_STATE", "class_name": "TagStateDurableObject" }
+    ]
+  },
+  "migrations": [{
+    "tag": "v1",
+    "new_sqlite_classes": ["AllocatorDurableObject", "JournalDurableObject", "TagDurableObject"]
+  }, {
+    "tag": "v2",
+    "new_sqlite_classes": ["BootstrapCoordinatorDurableObject"]
+  }, {
+    "tag": "v3",
+    "new_sqlite_classes": ["TagStateDurableObject"]
+  }]
+}