@podosoft/podokit 1.0.2 → 1.1.4

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

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "bun:test";
+import { SQL } from "bun";
+import { Database as SqliteDatabase } from "bun:sqlite";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import {
+  revertLatestSqliteMigration,
+  runSqliteMigrations,
+  type SqliteMigrationDefinition,
+} from "../database/sqlite-migrator";
+import { InitTodos1720100000000 } from "../migrations/1720100000000-InitTodos";
+import { TodoRepository } from "./todo.repository";
+
+const migrations: readonly SqliteMigrationDefinition[] = [
+  { timestamp: 1720100000000, migration: new InitTodos1720100000000() },
+];
+
+describe("Todo SQLite persistence", () => {
+  it("preserves boolean and Date rows returned by PostgreSQL", async (): Promise<void> => {
+    const row = {
+      id: crypto.randomUUID(),
+      title: "Existing task",
+      completed: true,
+      createdAt: new Date("2026-10-07T00:00:00.000Z"),
+    };
+    const sql = ((): Promise<typeof row[]> => Promise.resolve([row])) as unknown as SQL;
+    expect(await new TodoRepository(sql).find(row.id)).toEqual({
+      ...row,
+      createdAt: "2026-10-07T00:00:00.000Z",
+    });
+  });
+
+  it("applies the initial migration once and reverts it", async (): Promise<void> => {
+    const database = new SqliteDatabase(":memory:");
+    try {
+      await runSqliteMigrations(database, migrations);
+      await runSqliteMigrations(database, migrations);
+      expect(database.query<{ count: number }, []>("SELECT count(*) AS count FROM migrations").get()?.count).toBe(1);
+      expect(database.query<{ name: string }, []>("SELECT name FROM sqlite_master WHERE name = 'todos'").get()?.name).toBe("todos");
+      expect(await revertLatestSqliteMigration(database, migrations)).toBe(true);
+      expect(database.query("SELECT name FROM sqlite_master WHERE name = 'todos'").get()).toBeNull();
+    } finally {
+      database.close();
+    }
+  });
+
+  it("creates, reads, updates, and removes records with stable API types", async (): Promise<void> => {
+    const directory = mkdtempSync(join(tmpdir(), "podokit-todo-"));
+    const path = join(directory, "podokit.sqlite");
+    const database = new SqliteDatabase(path);
+    let sql: SQL | undefined;
+    try {
+      await runSqliteMigrations(database, migrations);
+      sql = new SQL(`sqlite://${path}`, { adapter: "sqlite" });
+      const repository = new TodoRepository(sql);
+      const todo = await repository.create("First task");
+      expect(todo.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+      expect(todo.completed).toBe(false);
+      expect(new Date(todo.createdAt).toISOString()).toBe(todo.createdAt);
+      expect(await repository.find(todo.id)).toEqual(todo);
+      expect(await repository.all()).toEqual([todo]);
+
+      const updated = await repository.update(todo.id, { title: "Completed task", completed: true });
+      expect(updated).toEqual({ ...todo, title: "Completed task", completed: true });
+      expect(await repository.remove(todo.id)).toBe(true);
+      expect(await repository.find(todo.id)).toBeNull();
+      expect(await repository.update(todo.id, { completed: false })).toBeNull();
+      expect(await repository.remove(todo.id)).toBe(false);
+    } finally {
+      await sql?.close();
+      database.close();
+      rmSync(directory, { recursive: true, force: true });
+    }
+  });
+});

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

@@ -10,12 +10,16 @@ export interface TodoRecord {
 interface TodoRow {
   id: string;
   title: string;
-  completed: boolean;
-  createdAt: Date;
+  completed: boolean | number;
+  createdAt: Date | string;
 }
 
 function record(row: TodoRow): TodoRecord {
-  return { ...row, createdAt: row.createdAt.toISOString() };
+  return {
+    ...row,
+    completed: Boolean(row.completed),
+    createdAt: (row.createdAt instanceof Date ? row.createdAt : new Date(row.createdAt)).toISOString(),
+  };
 }
 
 export class TodoRepository {
@@ -39,8 +43,9 @@ export class TodoRepository {
   }
 
   async create(title: string): Promise<TodoRecord> {
+    const id = crypto.randomUUID();
     const rows = await this.sql<TodoRow[]>`
-      INSERT INTO todos (title) VALUES (${title})
+      INSERT INTO todos (id, title) VALUES (${id}, ${title})
       RETURNING id, title, completed, "createdAt"
     `;
     const row = rows[0];

package/dist/templates/todo/tests/api/todo.api.spec.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "@playwright/test";
+
+test("Todo CRUD preserves UUIDs, booleans, and timestamps @smoke", async ({ request, baseURL }): Promise<void> => {
+  const title = `Todo API ${crypto.randomUUID()}`;
+  const headers = { Origin: baseURL ?? "http://localhost:5001" };
+  const response = await request.post("/api/todos", { data: { title }, headers });
+  expect(response.status()).toBe(201);
+  const created: unknown = await response.json();
+  expect(created).toMatchObject({ title, completed: false, id: expect.any(String), createdAt: expect.any(String) });
+  if (typeof created !== "object" || created === null || !("id" in created) || typeof created.id !== "string"
+    || !("createdAt" in created) || typeof created.createdAt !== "string") {
+    throw new Error("Todo response must include an ID and timestamp");
+  }
+  const id = created.id;
+  try {
+    expect(id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/);
+    expect(new Date(created.createdAt).toISOString()).toBe(created.createdAt);
+    const list = await request.get("/api/todos");
+    expect(list.status()).toBe(200);
+    expect(await list.json()).toEqual(expect.arrayContaining([created]));
+
+    const update = await request.patch(`/api/todos/${id}`, { data: { title: `${title} updated`, completed: true }, headers });
+    expect(update.status()).toBe(200);
+    expect(await update.json()).toEqual({ ...created, title: `${title} updated`, completed: true });
+    expect((await request.delete(`/api/todos/${id}`, { headers })).status()).toBe(204);
+    expect((await request.get(`/api/todos/${id}`)).status()).toBe(404);
+    expect((await request.patch(`/api/todos/${id}`, { data: { completed: false }, headers })).status()).toBe(404);
+    expect((await request.delete(`/api/todos/${id}`, { headers })).status()).toBe(404);
+  } finally {
+    await request.delete(`/api/todos/${id}`, { headers });
+  }
+});

package/dist/templates/todo/tests/ui/todo.ui.spec.ts

@@ -0,0 +1,31 @@
+import { expect, test } from "@playwright/test";
+
+test("Todo items persist through create, complete, reload, and delete @smoke", async ({ page, request, baseURL }): Promise<void> => {
+  const title = `Todo UI ${crypto.randomUUID()}`;
+  try {
+    await page.goto("/");
+    await page.getByPlaceholder("Add a todo…").fill(title);
+    await page.getByRole("button", { name: "Add", exact: true }).click();
+    const row = page.getByRole("listitem").filter({ hasText: title });
+    await expect(row).toBeVisible();
+    await expect(row.getByRole("checkbox")).not.toBeChecked();
+    await row.getByRole("checkbox").check();
+    await expect(row.getByRole("checkbox")).toBeChecked();
+    await page.reload();
+    await expect(row.getByRole("checkbox")).toBeChecked();
+    await row.getByRole("button", { name: "Delete", exact: true }).click();
+    await expect(row).toHaveCount(0);
+    await page.reload();
+    await expect(row).toHaveCount(0);
+  } finally {
+    const items: unknown = await (await request.get("/api/todos")).json();
+    if (Array.isArray(items)) {
+      for (const item of items as unknown[]) {
+        if (typeof item === "object" && item !== null && "title" in item && item.title === title
+          && "id" in item && typeof item.id === "string") {
+          await request.delete(`/api/todos/${item.id}`, { headers: { Origin: baseURL ?? "http://localhost:5001" } });
+        }
+      }
+    }
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@podosoft/podokit",
-  "version": "1.0.2",
+  "version": "1.1.4",
   "description": "An opinionated Bun and Elysia full-stack TypeScript starter toolkit and CLI with SvelteKit, TailwindCSS, shadcn-svelte, Docker, and k3s.",
   "license": "Apache-2.0",
   "repository": {
@@ -45,6 +45,7 @@
     "test": "vitest run"
   },
   "dependencies": {
+    "@podosoft/podokit-runtime": "^0.2.0",
     "@podosoft/podokit-template-engine": "^0.4.2"
   }
 }

package/dist/templates/modules/job-progress/files/apps/api/src/progress/progress.bridge.ts

@@ -1,32 +0,0 @@
-import { RedisService } from "../redis/redis.service";
-import { EventsService } from "../events/events.service";
-import { PROGRESS_CHANNEL } from "./progress.processor";
-
-// Runs in the API process: relays worker progress (Redis pub/sub) to SSE.
-export class ProgressBridge {
-  private unsubscribe?: () => Promise<void>;
-
-  constructor(
-    private readonly redis: RedisService,
-    private readonly events: EventsService,
-  ) {}
-
-  async connect(): Promise<void> {
-    this.unsubscribe = await this.redis.subscribe(PROGRESS_CHANNEL, (message) => {
-      try {
-        const parsed: unknown = JSON.parse(message);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-          process.stderr.write("Discard invalid job progress event\n");
-          return;
-        }
-        this.events.publishLocal({ type: "job-progress", ...parsed });
-      } catch {
-        process.stderr.write("Discard malformed job progress event\n");
-      }
-    });
-  }
-
-  async close(): Promise<void> {
-    await this.unsubscribe?.();
-  }
-}

package/dist/templates/modules/mailer/files/apps/api/src/mail/db.ts

@@ -1,13 +0,0 @@
-import { Pool } from "pg";
-
-// The mailer's own pg pool, in its own module so the mailer stays independent of
-// any other module. Used only to read the optional admin-configured SMTP settings
-// from `auth_config` when the auth module is present; with no such table the read
-// fails softly and the mailer falls back to SMTP_* env (see mailer.ts).
-export const pool = new Pool({
-  host: process.env.POSTGRES_HOST ?? "localhost",
-  port: Number(process.env.POSTGRES_PORT ?? 5432),
-  user: process.env.POSTGRES_USER ?? "podokit",
-  password: process.env.POSTGRES_PASSWORD ?? "podokit",
-  database: process.env.POSTGRES_DB ?? "podokit",
-});

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

@@ -1,111 +0,0 @@
-import { RedisClient } from "bun";
-import { redisConnectionUrl } from "../config/redis.connection";
-
-export type EventHandler = (data: unknown) => void;
-
-export interface EventsTransport {
-  connect(handler: EventHandler): Promise<void>;
-  publish(data: unknown): Promise<void>;
-  ready(): Promise<void>;
-  close(): Promise<void>;
-}
-
-function maxEventBytes(env: NodeJS.ProcessEnv): number {
-  const value = Number(env.SSE_MAX_EVENT_BYTES ?? 65_536);
-  if (!Number.isInteger(value) || value < 1) {
-    throw new Error("SSE_MAX_EVENT_BYTES must be a positive integer");
-  }
-  return value;
-}
-
-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 (Buffer.byteLength(message, "utf8") > maximumBytes) {
-    throw new Error("Event data exceeds SSE_MAX_EVENT_BYTES");
-  }
-  return message;
-}
-
-export class MemoryEventsTransport implements EventsTransport {
-  private handler?: EventHandler;
-  private readonly maximumBytes: number;
-
-  constructor(env: NodeJS.ProcessEnv = process.env) {
-    this.maximumBytes = maxEventBytes(env);
-  }
-
-  connect(handler: EventHandler): Promise<void> {
-    this.handler = handler;
-    return Promise.resolve();
-  }
-
-  async publish(data: unknown): Promise<void> {
-    this.handler?.(JSON.parse(encodedEvent(data, this.maximumBytes)) as unknown);
-  }
-
-  ready(): Promise<void> {
-    return Promise.resolve();
-  }
-
-  close(): Promise<void> {
-    this.handler = undefined;
-    return Promise.resolve();
-  }
-}
-
-export class RedisEventsTransport implements EventsTransport {
-  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) {
-    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);
-  }
-
-  async connect(handler: EventHandler): Promise<void> {
-    this.handler = handler;
-    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> {
-    await this.publisher.publish(this.channel, encodedEvent(data, this.maximumBytes));
-  }
-
-  async ready(): Promise<void> {
-    if (!this.subscriber.connected) throw new Error("Redis event subscriber is not ready");
-    await this.publisher.ping();
-  }
-
-  async close(): Promise<void> {
-    if (this.listener) await this.subscriber.unsubscribe(this.channel, this.listener);
-    this.handler = undefined;
-    this.listener = undefined;
-    this.publisher.close();
-    this.subscriber.close();
-  }
-}
-
-export function createEventsTransport(env: NodeJS.ProcessEnv = process.env): EventsTransport {
-  const name = env.SSE_TRANSPORT?.trim().toLowerCase() || "memory";
-  if (name === "memory") return new MemoryEventsTransport(env);
-  if (name === "redis") return new RedisEventsTransport(env);
-  throw new Error('SSE_TRANSPORT must be either "memory" or "redis"');
-}