@sapporta/server 0.0.1

package/src/testing/test-utils.ts

@@ -0,0 +1,44 @@
+import Database from "better-sqlite3";
+import { drizzle, type BetterSQLite3Database } from "drizzle-orm/better-sqlite3";
+import type { ProjectDbConnection } from "../db/sqlite-connection.js";
+
+/**
+ * Create an in-memory SQLite database for testing.
+ *
+ * Returns both the raw better-sqlite3 handle and a Drizzle instance.
+ * This is the "unit test" variant — use it for testing individual functions
+ * that accept a Drizzle db parameter.
+ *
+ * Configures WAL mode and foreign keys to match production settings
+ * from sqlite-connection.ts.
+ */
+export function createTestDb(): {
+  sqlite: Database.Database;
+  db: BetterSQLite3Database;
+} {
+  const sqlite = new Database(":memory:");
+  // Match production PRAGMA settings from sqlite-connection.ts.
+  // WAL mode isn't meaningful for :memory: but setting it keeps the
+  // configuration path consistent with production.
+  sqlite.pragma("journal_mode = WAL");
+  sqlite.pragma("foreign_keys = ON");
+  const db = drizzle(sqlite) as BetterSQLite3Database;
+  return { sqlite, db };
+}
+
+/**
+ * Create an in-memory SQLite ProjectDbConnection for integration tests.
+ *
+ * The returned connection has the same ProjectDbConnection shape as
+ * production (sqlite + db), backed by an ephemeral in-memory database.
+ */
+export function createTestConnection(): {
+  conn: ProjectDbConnection;
+  teardown: () => void;
+} {
+  const { sqlite, db } = createTestDb();
+  return {
+    conn: { sqlite, db },
+    teardown: () => sqlite.close(),
+  };
+}

package/src/views/loader.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { loadViewMeta } from "./loader.js";
+
+describe("loadViewMeta", () => {
+  let dir: string;
+
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), "sapporta-view-test-"));
+  });
+
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it("derives name and label from .tsx filename", async () => {
+    await writeFile(join(dir, "dashboard.tsx"), "export default function() { return null; }");
+
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(1);
+    expect(views[0]).toEqual({ name: "dashboard", label: "Dashboard" });
+  });
+
+  it("humanizes hyphenated filenames", async () => {
+    await writeFile(join(dir, "log-meal.tsx"), "export default function() { return null; }");
+
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(1);
+    expect(views[0]).toEqual({ name: "log-meal", label: "Log Meal" });
+  });
+
+  it("skips non-.tsx files", async () => {
+    await writeFile(join(dir, "helpers.ts"), "export const x = 1;");
+    await writeFile(join(dir, "style.css"), "body {}");
+
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(0);
+  });
+
+  it("skips test files", async () => {
+    await writeFile(join(dir, "my-view.test.ts"), "");
+    await writeFile(join(dir, "my-view.test.tsx"), "");
+
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(0);
+  });
+
+  it("skips files starting with underscore", async () => {
+    await writeFile(join(dir, "_internal.tsx"), "");
+
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(0);
+  });
+
+  it("returns empty array for empty directory", async () => {
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(0);
+  });
+
+  it("loads multiple views from multiple files", async () => {
+    await writeFile(join(dir, "alpha.tsx"), "");
+    await writeFile(join(dir, "beta.tsx"), "");
+
+    const views = await loadViewMeta(dir);
+    expect(views).toHaveLength(2);
+    expect(views.map((v) => v.name).sort()).toEqual(["alpha", "beta"]);
+  });
+});

package/src/views/loader.ts

@@ -0,0 +1,38 @@
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import type { ViewMeta } from "./view.js";
+
+/** "log-meal" → "Log Meal" */
+function humanize(slug: string): string {
+  return slug
+    .split("-")
+    .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
+    .join(" ");
+}
+
+/**
+ * Load view metadata from a project's views/ directory.
+ *
+ * Metadata is derived entirely from filenames — no file imports needed.
+ * `log-meal.tsx` → { name: "log-meal", label: "Log Meal" }
+ *
+ * Files starting with `_` are treated as internal helpers and skipped.
+ * Test files (*.test.ts, *.test.tsx) are also skipped.
+ * Only `.tsx` files are considered views.
+ */
+export async function loadViewMeta(dir: string): Promise<ViewMeta[]> {
+  const absDir = resolve(dir);
+  const files = await readdir(absDir);
+  const views: ViewMeta[] = [];
+
+  for (const file of files) {
+    if (file.startsWith("_")) continue;
+    if (file.endsWith(".test.ts") || file.endsWith(".test.tsx")) continue;
+    if (!file.endsWith(".tsx")) continue;
+
+    const name = file.replace(/\.tsx$/, "");
+    views.push({ name, label: humanize(name) });
+  }
+
+  return views;
+}

package/src/views/view.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect } from "vitest";
+import { Hono } from "hono";
+import { z } from "zod";
+import type { ViewMeta } from "./view.js";
+import { viewApi } from "../api/views.js";
+import { action } from "../actions/action.js";
+import { actionApi } from "../api/actions.js";
+
+describe("ViewMeta type", () => {
+  it("accepts a valid ViewMeta object", () => {
+    const meta: ViewMeta = {
+      name: "log-meal",
+      label: "Log Meal",
+      icon: "utensils",
+    };
+
+    expect(meta.name).toBe("log-meal");
+    expect(meta.label).toBe("Log Meal");
+    expect(meta.icon).toBe("utensils");
+  });
+
+  it("icon is optional", () => {
+    const meta: ViewMeta = {
+      name: "dashboard",
+      label: "Dashboard",
+    };
+
+    expect(meta.icon).toBeUndefined();
+  });
+});
+
+describe("viewApi", () => {
+  const views: ViewMeta[] = [
+    { name: "log-meal", label: "Log Meal", icon: "utensils" },
+    { name: "dashboard", label: "Dashboard" },
+  ];
+
+  it("GET / lists views with metadata", async () => {
+    const app = new Hono();
+    app.route("/views", viewApi(views));
+
+    const res = await app.request("/views");
+    expect(res.status).toBe(200);
+
+    const json = await res.json();
+    expect(json.views).toHaveLength(2);
+    expect(json.views[0]).toEqual({ name: "log-meal", label: "Log Meal", icon: "utensils" });
+    expect(json.views[1]).toEqual({ name: "dashboard", label: "Dashboard", icon: undefined });
+  });
+
+  it("GET /:name returns view metadata", async () => {
+    const app = new Hono();
+    app.route("/views", viewApi(views));
+
+    const res = await app.request("/views/log-meal");
+    expect(res.status).toBe(200);
+
+    const json = await res.json();
+    expect(json.name).toBe("log-meal");
+    expect(json.label).toBe("Log Meal");
+    expect(json.icon).toBe("utensils");
+  });
+
+  it("GET /:name returns 404 for unknown view", async () => {
+    const app = new Hono();
+    app.route("/views", viewApi(views));
+
+    const res = await app.request("/views/nonexistent");
+    expect(res.status).toBe(404);
+  });
+});
+
+describe("GET /actions (action listing)", () => {
+  it("lists actions with JSON Schema from Zod", async () => {
+    const createItem = action({
+      name: "create_item",
+      label: "Create Item",
+      input: z.object({
+        name: z.string().min(1),
+        quantity: z.number().optional(),
+      }),
+      run: async ({ input }) => input,
+    });
+
+    const app = new Hono();
+    // Need a mock db for actionApi — just use null since GET doesn't need it
+    app.route("/actions", actionApi([createItem], null as any));
+
+    const res = await app.request("/actions");
+    expect(res.status).toBe(200);
+
+    const json = await res.json();
+    expect(json.actions).toHaveLength(1);
+    expect(json.actions[0].name).toBe("create_item");
+    expect(json.actions[0].label).toBe("Create Item");
+
+    // Verify JSON Schema structure
+    const schema = json.actions[0].inputSchema;
+    expect(schema.type).toBe("object");
+    expect(schema.properties.name).toBeDefined();
+    expect(schema.properties.name.type).toBe("string");
+    expect(schema.properties.quantity).toBeDefined();
+    expect(schema.required).toContain("name");
+    expect(schema.required).not.toContain("quantity");
+  });
+
+  it("handles actions without label", async () => {
+    const act = action({
+      name: "simple",
+      input: z.object({ value: z.number() }),
+      run: async ({ input }) => input,
+    });
+
+    const app = new Hono();
+    app.route("/actions", actionApi([act], null as any));
+
+    const res = await app.request("/actions");
+    const json = await res.json();
+    expect(json.actions[0].label).toBeUndefined();
+  });
+});

package/src/views/view.ts

@@ -0,0 +1,16 @@
+/**
+ * View metadata — describes a custom screen defined as a React component
+ * in the project's `views/` directory.
+ *
+ * Metadata is derived from the filename: `log-meal.tsx` becomes
+ * `{ name: "log-meal", label: "Log Meal" }`. View files only need a
+ * default React component export.
+ */
+export interface ViewMeta {
+  /** URL-friendly name (used in routing, must match filename) */
+  name: string;
+  /** Human-readable label (shown in sidebar) */
+  label: string;
+  /** Lucide icon name (default: "layout-dashboard") */
+  icon?: string;
+}