@podosoft/podokit 0.17.4 → 1.0.2

package/dist/templates/modules/sse/files/apps/api/src/events/events.service.spec.ts

@@ -1,61 +1,30 @@
-import { describe, expect, it } from "@jest/globals";
-import { firstValueFrom, take } from "rxjs";
+import { describe, expect, it } from "bun:test";
 import { ReadinessService } from "../health/readiness.service";
 import { EventsService } from "./events.service";
-import type { EventHandler, EventsTransport } from "./events.transport";
-
-class TestTransport implements EventsTransport {
-  handler?: EventHandler;
-  published: unknown[] = [];
-  available = true;
-
-  connect(handler: EventHandler): Promise<void> {
-    this.handler = handler;
-    return Promise.resolve();
-  }
-
-  publish(data: unknown): Promise<void> {
-    if (!this.available) return Promise.reject(new Error("unavailable"));
-    this.published.push(data);
-    this.handler?.(data);
-    return Promise.resolve();
-  }
-
-  ready(): Promise<void> {
-    return this.available ? Promise.resolve() : Promise.reject(new Error("unavailable"));
-  }
-
-  close(): Promise<void> {
-    return Promise.resolve();
-  }
-}
+import { MemoryEventsTransport } from "./events.transport";
 
 describe("EventsService", () => {
-  it("publishes through the transport and exposes local delivery", async () => {
-    const transport = new TestTransport();
+  it("publishes through the transport and delivers locally", async () => {
     const readiness = new ReadinessService();
-    const service = new EventsService(transport, readiness);
-    await service.onModuleInit();
-
-    const next = firstValueFrom(service.asObservable().pipe(take(1)));
+    const service = new EventsService(new MemoryEventsTransport(), readiness);
+    const received: unknown[] = [];
+    service.subscribe((data) => received.push(data));
+    await service.connect();
     await service.publishAsync({ type: "changed" });
-    await expect(next).resolves.toEqual({ data: { type: "changed" } });
-    expect(transport.published).toEqual([{ type: "changed" }]);
-
+    expect(received).toEqual([{ type: "changed" }]);
     await expect(readiness.run()).resolves.toEqual({ events: "up" });
-    await service.onModuleDestroy();
-    await expect(readiness.run()).resolves.toEqual({});
+    await service.close();
   });
 
-  it("reports a failed transport through publishAsync and readiness", async () => {
-    const transport = new TestTransport();
-    const readiness = new ReadinessService();
-    const service = new EventsService(transport, readiness);
-    await service.onModuleInit();
-    transport.available = false;
-
-    await expect(service.publishAsync({ type: "changed" })).rejects.toThrow("unavailable");
-    await expect(readiness.run()).resolves.toEqual({ events: "down" });
-    await service.onModuleDestroy();
+  it("rejects events larger than the configured limit", async () => {
+    const service = new EventsService(
+      new MemoryEventsTransport({ SSE_MAX_EVENT_BYTES: "8" }),
+      new ReadinessService(),
+    );
+    await service.connect();
+    await expect(service.publishAsync({ message: "too large" })).rejects.toThrow(
+      "Event data exceeds SSE_MAX_EVENT_BYTES",
+    );
+    await service.close();
   });
 });

package/dist/templates/modules/sse/files/apps/api/src/events/events.service.ts

@@ -1,39 +1,26 @@
-import {
-  Inject,
-  Injectable,
-  Logger,
-  type MessageEvent,
-  type OnModuleDestroy,
-  type OnModuleInit,
-} from "@nestjs/common";
-import { Observable, Subject } from "rxjs";
 import { ReadinessService } from "../health/readiness.service";
 import type { EventsTransport } from "./events.transport";
 
-export const EVENTS_TRANSPORT = Symbol("EVENTS_TRANSPORT");
+type LocalHandler = (data: unknown) => void;
 
-@Injectable()
-export class EventsService implements OnModuleInit, OnModuleDestroy {
-  private readonly logger = new Logger(EventsService.name);
-  private readonly subject = new Subject<MessageEvent>();
+export class EventsService {
+  private readonly handlers = new Set<LocalHandler>();
   private unregisterReadiness?: () => void;
 
   constructor(
-    @Inject(EVENTS_TRANSPORT) private readonly transport: EventsTransport,
+    private readonly transport: EventsTransport,
     private readonly readiness: ReadinessService,
   ) {}
 
-  async onModuleInit(): Promise<void> {
+  async connect(): Promise<void> {
     await this.transport.connect((data) => this.publishLocal(data));
     this.unregisterReadiness = this.readiness.register("events", () => this.transport.ready());
   }
 
   publish(data: unknown): void {
     void this.publishAsync(data).catch((error: unknown) => {
-      this.logger.error(
-        "Failed to publish event",
-        error instanceof Error ? error.stack : undefined,
-      );
+      const message = error instanceof Error ? error.message : String(error);
+      process.stderr.write(`Publish event failed: ${message}\n`);
     });
   }
 
@@ -42,16 +29,44 @@ export class EventsService implements OnModuleInit, OnModuleDestroy {
   }
 
   publishLocal(data: unknown): void {
-    this.subject.next({ data } as MessageEvent);
+    for (const handler of this.handlers) handler(data);
   }
 
-  asObservable(): Observable<MessageEvent> {
-    return this.subject.asObservable();
+  subscribe(handler: LocalHandler): () => void {
+    this.handlers.add(handler);
+    return () => this.handlers.delete(handler);
   }
 
-  async onModuleDestroy(): Promise<void> {
+  async *stream(signal: AbortSignal): AsyncGenerator<unknown> {
+    const queue: unknown[] = [];
+    let wake: (() => void) | undefined;
+    const unsubscribe = this.subscribe((data) => {
+      queue.push(data);
+      wake?.();
+      wake = undefined;
+    });
+    let heartbeat = 0;
+    try {
+      while (!signal.aborted) {
+        if (queue.length === 0) {
+          const delivered = await Promise.race([
+            new Promise<"event">((resolve) => {
+              wake = () => resolve("event");
+            }),
+            Bun.sleep(5_000).then(() => "heartbeat" as const),
+          ]);
+          if (delivered === "heartbeat") yield { type: "heartbeat", n: heartbeat++ };
+        }
+        while (queue.length > 0) yield queue.shift();
+      }
+    } finally {
+      unsubscribe();
+    }
+  }
+
+  async close(): Promise<void> {
     this.unregisterReadiness?.();
-    this.subject.complete();
+    this.handlers.clear();
     await this.transport.close();
   }
 }

package/dist/templates/modules/sse/files/apps/api/src/events/events.transport.ts

@@ -1,9 +1,5 @@
-import { Logger } from "@nestjs/common";
-import Redis from "ioredis";
-import {
-  redisConnectionOptions,
-  type RedisConnectionOptions,
-} from "../config/redis.connection";
+import { RedisClient } from "bun";
+import { redisConnectionUrl } from "../config/redis.connection";
 
 export type EventHandler = (data: unknown) => void;
 
@@ -14,23 +10,6 @@ export interface EventsTransport {
   close(): Promise<void>;
 }
 
-interface RedisClient {
-  readonly status: string;
-  connect(): Promise<void>;
-  publish(channel: string, message: string): Promise<number>;
-  subscribe(channel: string): Promise<unknown>;
-  ping(): Promise<string>;
-  quit(): Promise<string>;
-  on(event: "message", listener: (channel: string, message: string) => void): this;
-  off(event: "message", listener: (channel: string, message: string) => void): this;
-}
-
-export type RedisClientFactory = (options: RedisConnectionOptions) => RedisClient;
-
-function defaultRedisClientFactory(options: RedisConnectionOptions): RedisClient {
-  return new Redis(options);
-}
-
 function maxEventBytes(env: NodeJS.ProcessEnv): number {
   const value = Number(env.SSE_MAX_EVENT_BYTES ?? 65_536);
   if (!Number.isInteger(value) || value < 1) {
@@ -41,9 +20,7 @@ function maxEventBytes(env: NodeJS.ProcessEnv): number {
 
 function encodedEvent(data: unknown, maximumBytes: number): string {
   const message = JSON.stringify(data);
-  if (message === undefined) {
-    throw new Error("Event data must be JSON serializable");
-  }
+  if (message === undefined) throw new Error("Event data must be JSON serializable");
   if (Buffer.byteLength(message, "utf8") > maximumBytes) {
     throw new Error("Event data exceeds SSE_MAX_EVENT_BYTES");
   }
@@ -64,8 +41,7 @@ export class MemoryEventsTransport implements EventsTransport {
   }
 
   async publish(data: unknown): Promise<void> {
-    const message = encodedEvent(data, this.maximumBytes);
-    this.handler?.(JSON.parse(message) as unknown);
+    this.handler?.(JSON.parse(encodedEvent(data, this.maximumBytes)) as unknown);
   }
 
   ready(): Promise<void> {
@@ -79,64 +55,34 @@ export class MemoryEventsTransport implements EventsTransport {
 }
 
 export class RedisEventsTransport implements EventsTransport {
-  private readonly logger = new Logger(RedisEventsTransport.name);
   private readonly publisher: RedisClient;
   private readonly subscriber: RedisClient;
   private readonly channel: string;
   private readonly maximumBytes: number;
   private handler?: EventHandler;
+  private listener?: (message: string) => void;
 
-  constructor(
-    env: NodeJS.ProcessEnv = process.env,
-    createClient: RedisClientFactory = defaultRedisClientFactory,
-  ) {
+  constructor(env: NodeJS.ProcessEnv = process.env) {
+    const url = redisConnectionUrl(env);
+    this.publisher = new RedisClient(url, { connectionTimeout: 5_000 });
+    this.subscriber = new RedisClient(url, { connectionTimeout: 5_000 });
     this.channel = env.SSE_REDIS_CHANNEL?.trim() || "podokit:events";
     this.maximumBytes = maxEventBytes(env);
-    this.publisher = createClient(
-      redisConnectionOptions(env, {
-        lazyConnect: true,
-        enableReadyCheck: true,
-        maxRetriesPerRequest: 1,
-        connectTimeout: 5_000,
-        commandTimeout: 5_000,
-      }),
-    );
-    this.subscriber = createClient(
-      redisConnectionOptions(env, {
-        lazyConnect: true,
-        enableReadyCheck: true,
-        maxRetriesPerRequest: null,
-        connectTimeout: 5_000,
-      }),
-    );
   }
 
-  private readonly onMessage = (channel: string, message: string): void => {
-    if (channel !== this.channel) return;
-    if (Buffer.byteLength(message, "utf8") > this.maximumBytes) {
-      this.logger.warn("Discarded oversized event transport message");
-      return;
-    }
-    try {
-      this.handler?.(JSON.parse(message) as unknown);
-    } catch {
-      this.logger.warn("Discarded malformed event transport message");
-    }
-  };
-
   async connect(handler: EventHandler): Promise<void> {
     this.handler = handler;
-    this.subscriber.on("message", this.onMessage);
-    try {
-      await Promise.all([this.publisher.connect(), this.subscriber.connect()]);
-      await this.subscriber.subscribe(this.channel);
-      await this.ready();
-    } catch (error) {
-      this.subscriber.off("message", this.onMessage);
-      this.handler = undefined;
-      await Promise.allSettled([this.publisher.quit(), this.subscriber.quit()]);
-      throw error;
-    }
+    this.listener = (message: string): void => {
+      if (Buffer.byteLength(message, "utf8") > this.maximumBytes) return;
+      try {
+        this.handler?.(JSON.parse(message) as unknown);
+      } catch {
+        process.stderr.write("Discard malformed event transport message\n");
+      }
+    };
+    await Promise.all([this.publisher.connect(), this.subscriber.connect()]);
+    await this.subscriber.subscribe(this.channel, this.listener);
+    await this.ready();
   }
 
   async publish(data: unknown): Promise<void> {
@@ -144,16 +90,16 @@ export class RedisEventsTransport implements EventsTransport {
   }
 
   async ready(): Promise<void> {
-    if (this.subscriber.status !== "ready") {
-      throw new Error("Redis event subscriber is not ready");
-    }
+    if (!this.subscriber.connected) throw new Error("Redis event subscriber is not ready");
     await this.publisher.ping();
   }
 
   async close(): Promise<void> {
-    this.subscriber.off("message", this.onMessage);
+    if (this.listener) await this.subscriber.unsubscribe(this.channel, this.listener);
     this.handler = undefined;
-    await Promise.allSettled([this.publisher.quit(), this.subscriber.quit()]);
+    this.listener = undefined;
+    this.publisher.close();
+    this.subscriber.close();
   }
 }
 

package/dist/templates/modules/sse/module.manifest.json

@@ -7,9 +7,6 @@
     "apps/api/src/health/readiness.service.ts"
   ],
   "targetApp": "api",
-  "dependencies": {
-    "ioredis": "^5.4.1"
-  },
   "env": [
     "# Server-Sent Events transport: memory for one API replica, redis for multiple replicas",
     "SSE_TRANSPORT=memory",
@@ -17,8 +14,8 @@
     "SSE_MAX_EVENT_BYTES=65536"
   ],
   "inject": [
-    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:end:imports", "text": "import { EventsModule } from \"./events/events.module\";" },
-    { "file": "apps/api/src/app.module.ts", "marker": "// podokit:end:module-imports", "text": "EventsModule," }
+    { "file": "apps/api/src/app.ts", "marker": "// podokit:end:imports", "text": "import { eventsModule } from \"./events/events.module\";" },
+    { "file": "apps/api/src/app.ts", "marker": "// podokit:end:modules", "text": "eventsModule," }
   ],
   "instructions": [
     "Stream events:  curl -N localhost:5002/events/stream",

package/dist/templates/todo/AGENTS.md

@@ -6,29 +6,32 @@ Follow it so your changes match the project's conventions.
 
 ## Project overview
 
-A full-stack TypeScript monorepo (npm workspaces):
+A Bun 1.4 full-stack TypeScript monorepo ({{packageManager}} workspaces):
 
-- `apps/api` — **NestJS** backend (`{{projectName}}-api`), TypeORM + PostgreSQL, Swagger at `/api-docs`.
+- `apps/api` — **Elysia** backend (`{{projectName}}-api`), Bun.SQL + PostgreSQL, merged OpenAPI at `/api-docs`.
 - `apps/web` — **SvelteKit** frontend (`{{projectName}}-web`), Tailwind v4 + shadcn-svelte + typesafe-i18n.
 - `infra/` — Docker Compose (PostgreSQL/Redis) and example k3s manifests.
 - `.podokit/` — PodoKit's generation lockfile (see "PodoKit tooling" below). Do not edit by hand.
-- **Todo example**: `apps/api/src/todos/` (controller/service/entity/DTO + migration) and the todo UI in `apps/web/src/routes/` show the end-to-end patterns to follow.
+- **Todo example**: `apps/api/src/todos/` (Elysia plugin, Bun.SQL repository, and migration) and the todo UI in `apps/web/src/routes/` show the end-to-end patterns to follow.
 
 ## Setup & commands
 
 ```bash
-npm install
+{{packageManager}} install
 cp .env.example .env
 docker compose -f infra/docker/docker-compose.yml up -d   # PostgreSQL (+ Redis)
-npm run dev        # api on http://localhost:5002, web on http://localhost:5001
+{{rootRun}} dev        # api on http://localhost:5002, web on http://localhost:5001
 ```
 
 - **Ports: web = 5001, api = 5002.** The web app reaches the API only through its
   SvelteKit server proxy (`/api/*`), never with a direct browser `fetch`.
-- Build: `npm run build`  ·  Type-check/lint: `npm run lint`  ·  Unit tests: `npm test`
-- Per workspace: `npm run build -w {{projectName}}-api` / `-w {{projectName}}-web`.
-- DB migrations (TypeORM): `npm run migration:run -w {{projectName}}-api`.
-- e2e (Playwright, ships in `tests/`): `npm run test:e2e`.
+- Build: `{{rootRun}} build`  ·  Type-check/lint: `{{rootRun}} lint`  ·  Unit tests: `{{rootRun}} test`
+- Per workspace: `{{apiRun}} build` / `{{webRun}} build`.
+- DB migrations (TypeORM migration layer only): `{{apiRun}} migration:run`.
+- e2e (Playwright, ships in `tests/`): `{{rootRun}} test:e2e`.
+- Playwright officially runs on Node, so `bunx playwright` respects its Node
+  shebang. Node LTS is a test-tool dependency only; API, web, worker, migrations,
+  builds, and unit tests run on Bun.
 
 **Always** verify a change by building the affected workspace (and `svelte-check`
 for web) before considering it done. UI changes need a Playwright test; API
@@ -38,7 +41,7 @@ changes need an e2e/unit test.
 
 ### TypeScript (both apps)
 - `strict` mode. **No `any`** — use `unknown` + narrowing. **No `@ts-ignore`/`@ts-expect-error`** and no `eslint-disable`.
-- Explicit function return types. DTOs use `class-validator` decorators.
+- Explicit function return types. Validate HTTP inputs with Elysia `t` schemas.
 - Keep `noUnusedLocals`, `noUnusedParameters`, `noImplicitReturns`, `noUncheckedIndexedAccess`.
 
 ### Svelte 5 (web)
@@ -60,8 +63,8 @@ changes need an e2e/unit test.
 This project is managed by the `podo` CLI. Files have an ownership tier recorded
 in `.podokit/files.lock` — respect it:
 
-- **owned** (your code: `apps/web/src/routes/**`, your components/services, `apps/api/src/app.extensions.ts`, and this `AGENTS.md`) — edit freely. To add or override Nest providers/modules, use `app.extensions.ts` (spread into `AppModule` after the module-wired providers, so a same-token override wins) rather than editing `app.module.ts`.
-- **assembled** (e.g. `apps/api/src/app.module.ts`, `auth.ts`) — contain `// podokit:begin:… / …:end` fenced regions that the toolkit recomputes. Edit outside the fences only; **never hand-edit inside the fences**.
+- **owned** (your code: `apps/web/src/routes/**`, your components/services, `apps/api/src/app.extensions.ts`, and this `AGENTS.md`) — edit freely. Add application-owned services or module descriptors through `app.extensions.ts` instead of changing toolkit registrations.
+- **assembled** (e.g. `apps/api/src/app.ts`, `auth.ts`) — contain `// podokit:begin:… / …:end` fenced regions that the toolkit recomputes. Edit outside the fences only; **never hand-edit inside the fences**.
 - **managed** (bootstrap/config like `main.ts`) — the toolkit may update these; avoid gratuitous edits.
 
 Useful commands:

package/dist/templates/todo/README.md

@@ -2,7 +2,7 @@
 
 Full-stack TypeScript app generated with [PodoKit](https://github.com/podosoft-dev/podokit).
 
-- `apps/api` — NestJS API: schema-validated env, `/health` + `/health/ready`, a `todos` CRUD resource (TypeORM + PostgreSQL), Swagger docs at `/api-docs`, and a standard error envelope.
+- `apps/api` — Bun 1.4 + Elysia API: schema-validated env, `/health` + `/health/ready`, a Bun.SQL Todo CRUD resource backed by PostgreSQL, merged OpenAPI at `/api-docs`, and a standard error envelope.
 - `apps/web` — SvelteKit app (TailwindCSS v4, shadcn-svelte, typesafe-i18n) with a todo UI that talks to the API through a server-side proxy.
 - `infra/` — Docker Compose (PostgreSQL, Redis) and k3s manifests.
 
@@ -13,7 +13,7 @@ Full-stack TypeScript app generated with [PodoKit](https://github.com/podosoft-d
 ```bash
 {{packageManager}} install
 cp .env.example .env
-npx @podosoft/podokit dev watch
+{{packageExecutor}} @podosoft/podokit dev watch
 ```
 
 Open the URL printed by the command; a new project defaults to
@@ -23,15 +23,20 @@ one user-level Traefik gateway on `127.0.0.1:80`; additional projects reuse it a
 route by that hostname. Even a single app uses
 the same topology, with one route and no project-specific host port.
 
+When the API exposes WebSocket endpoints, add their exact paths to
+`.podokit/dev.json` under `webSocketPaths`. The shared gateway sends only those paths
+directly to the API and leaves every other path on the web app. Add `publicUrl` to the
+same file when an HTTPS tunnel preserves its public `Host` header.
+
 In a second terminal, apply the included Todo migration and use the lifecycle helpers:
 
 ```bash
-npx @podosoft/podokit dev exec api npm run migration:run -w {{projectName}}-api
-npx @podosoft/podokit dev url
-npx @podosoft/podokit dev up -d # detached stack without source watching
-npx @podosoft/podokit dev ps
-npx @podosoft/podokit dev logs
-npx @podosoft/podokit dev down
+{{packageExecutor}} @podosoft/podokit dev exec api {{apiRun}} migration:run
+{{packageExecutor}} @podosoft/podokit dev url
+{{packageExecutor}} @podosoft/podokit dev up -d # detached stack without source watching
+{{packageExecutor}} @podosoft/podokit dev ps
+{{packageExecutor}} @podosoft/podokit dev logs
+{{packageExecutor}} @podosoft/podokit dev down
 ```
 
 `dev watch` reads `.podokit/manifest.json` and automatically activates `cache`,
@@ -41,7 +46,7 @@ Watch attached.
 You can still activate an additional Compose profile explicitly:
 
 ```bash
-npx @podosoft/podokit dev watch --profile dev
+{{packageExecutor}} @podosoft/podokit dev watch --profile dev
 ```
 
 Explicit profile flags are preserved for other lifecycle commands. `dev down`
@@ -59,7 +64,7 @@ Use this loop when you want only the web and API processes on the host:
 docker compose -f infra/docker/docker-compose.yml up -d
 
 # run database migrations
-{{packageManager}} run migration:run -w {{projectName}}-api
+{{apiRun}} migration:run
 
 # run api + web
 {{packageManager}} run dev
@@ -73,11 +78,12 @@ tunnel, see the PodoKit [development guide](https://github.com/podosoft-dev/podo
 
 ## Database & migrations
 
-The API uses TypeORM with PostgreSQL. A sample `Todo` entity and an initial migration are included — replace them with your own domain model.
+The API uses Bun.SQL with PostgreSQL. TypeORM is limited to the migration layer;
+a sample Todo repository and initial migration are included.
 
 ```bash
-{{packageManager}} run migration:run -w {{projectName}}-api      # apply migrations
-{{packageManager}} run migration:revert -w {{projectName}}-api   # roll back the last one
+{{apiRun}} migration:run      # apply migrations
+{{apiRun}} migration:revert   # roll back the last one
 ```
 
 ## Deploy

package/dist/templates/todo/apps/api/src/todos/todo.plugin.ts

@@ -0,0 +1,59 @@
+import { AppException } from "@podosoft/podokit-contracts";
+import { Elysia, t } from "elysia";
+import type { AppPlugin } from "../core/services";
+import { TodoRepository } from "./todo.repository";
+
+const todoSchema = t.Object({
+  id: t.String({ format: "uuid" }),
+  title: t.String(),
+  completed: t.Boolean(),
+  createdAt: t.String(),
+});
+
+export const todoPlugin: AppPlugin = ({ database }) => {
+  const todos = new TodoRepository(database.sql);
+  return new Elysia({ name: "podokit.todos" })
+    .get("/todos", () => todos.all(), {
+      response: t.Array(todoSchema),
+      detail: { tags: ["todos"], summary: "List todos" },
+    })
+    .get("/todos/:id", async ({ params }) => {
+      const todo = await todos.find(params.id);
+      if (!todo) throw new AppException("TODO_NOT_FOUND", `Todo ${params.id} not found`, 404);
+      return todo;
+    }, {
+      params: t.Object({ id: t.String({ format: "uuid" }) }),
+      response: todoSchema,
+      detail: { tags: ["todos"], summary: "Get a todo" },
+    })
+    .post("/todos", ({ body, set }) => {
+      set.status = 201;
+      return todos.create(body.title);
+    }, {
+      body: t.Object({ title: t.String({ minLength: 1, maxLength: 500 }) }),
+      response: todoSchema,
+      detail: { tags: ["todos"], summary: "Create a todo" },
+    })
+    .patch("/todos/:id", async ({ params, body }) => {
+      const todo = await todos.update(params.id, body);
+      if (!todo) throw new AppException("TODO_NOT_FOUND", `Todo ${params.id} not found`, 404);
+      return todo;
+    }, {
+      params: t.Object({ id: t.String({ format: "uuid" }) }),
+      body: t.Object({
+        title: t.Optional(t.String({ minLength: 1, maxLength: 500 })),
+        completed: t.Optional(t.Boolean()),
+      }),
+      response: todoSchema,
+      detail: { tags: ["todos"], summary: "Update a todo" },
+    })
+    .delete("/todos/:id", async ({ params, set }) => {
+      if (!(await todos.remove(params.id))) {
+        throw new AppException("TODO_NOT_FOUND", `Todo ${params.id} not found`, 404);
+      }
+      set.status = 204;
+    }, {
+      params: t.Object({ id: t.String({ format: "uuid" }) }),
+      detail: { tags: ["todos"], summary: "Delete a todo" },
+    });
+};

package/dist/templates/todo/apps/api/src/todos/todo.repository.ts

@@ -0,0 +1,69 @@
+import type { SQL } from "bun";
+
+export interface TodoRecord {
+  id: string;
+  title: string;
+  completed: boolean;
+  createdAt: string;
+}
+
+interface TodoRow {
+  id: string;
+  title: string;
+  completed: boolean;
+  createdAt: Date;
+}
+
+function record(row: TodoRow): TodoRecord {
+  return { ...row, createdAt: row.createdAt.toISOString() };
+}
+
+export class TodoRepository {
+  constructor(private readonly sql: SQL) {}
+
+  async all(): Promise<TodoRecord[]> {
+    const rows = await this.sql<TodoRow[]>`
+      SELECT id, title, completed, "createdAt"
+      FROM todos
+      ORDER BY "createdAt" DESC
+    `;
+    return rows.map(record);
+  }
+
+  async find(id: string): Promise<TodoRecord | null> {
+    const rows = await this.sql<TodoRow[]>`
+      SELECT id, title, completed, "createdAt" FROM todos WHERE id = ${id}
+    `;
+    const row = rows[0];
+    return row ? record(row) : null;
+  }
+
+  async create(title: string): Promise<TodoRecord> {
+    const rows = await this.sql<TodoRow[]>`
+      INSERT INTO todos (title) VALUES (${title})
+      RETURNING id, title, completed, "createdAt"
+    `;
+    const row = rows[0];
+    if (!row) throw new Error("Todo insert returned no row");
+    return record(row);
+  }
+
+  async update(id: string, input: { title?: string; completed?: boolean }): Promise<TodoRecord | null> {
+    const current = await this.find(id);
+    if (!current) return null;
+    const title = input.title ?? current.title;
+    const completed = input.completed ?? current.completed;
+    const rows = await this.sql<TodoRow[]>`
+      UPDATE todos SET title = ${title}, completed = ${completed}
+      WHERE id = ${id}
+      RETURNING id, title, completed, "createdAt"
+    `;
+    const row = rows[0];
+    return row ? record(row) : null;
+  }
+
+  async remove(id: string): Promise<boolean> {
+    const rows = await this.sql<{ id: string }[]>`DELETE FROM todos WHERE id = ${id} RETURNING id`;
+    return rows.length > 0;
+  }
+}

package/dist/templates/todo/apps/web/src/routes/+page.svelte

@@ -1,9 +1,9 @@
 <script lang="ts">
-  import { Button } from "$lib/components/ui/button";
-  import { Input } from "$lib/components/ui/input";
-  import { Checkbox } from "$lib/components/ui/checkbox";
-  import * as Card from "$lib/components/ui/card";
-  import { api } from "$lib/api";
+  import { Button } from "#lib/components/ui/button/index.js";
+  import { Input } from "#lib/components/ui/input/index.js";
+  import { Checkbox } from "#lib/components/ui/checkbox/index.js";
+  import * as Card from "#lib/components/ui/card/index.js";
+  import { api } from "#lib/api.js";
   import { ApiError } from "@podosoft/podokit-api-client";
 
   type Todo = { id: string; title: string; completed: boolean };
@@ -56,13 +56,13 @@
 <main class="mx-auto flex min-h-full max-w-xl flex-col gap-6 p-8">
   <div>
     <h1 class="text-3xl font-bold">{{projectName}}</h1>
-    <p class="text-muted-foreground text-sm">Full-stack starter generated with PodoKit.</p>
+    <p class="text-muted-foreground text-sm">Your PodoKit application is ready.</p>
   </div>
 
   <Card.Root>
     <Card.Header>
       <Card.Title>Todos</Card.Title>
-      <Card.Description>A NestJS + SvelteKit CRUD example via the typed ApiClient.</Card.Description>
+      <Card.Description>Create, complete, and remove items.</Card.Description>
     </Card.Header>
     <Card.Content class="flex flex-col gap-4">
       <form class="flex gap-2" onsubmit={add}>