koguma 0.4.0

package/src/db/migrate.ts

@@ -0,0 +1,146 @@
+/**
+ * Schema migration — detects drift between site.config.ts and the D1 database,
+ * then generates safe ALTER TABLE SQL to bring the DB in sync.
+ *
+ * Design:
+ * - Only ADD COLUMN is safe in SQLite — removals/renames are warned, never applied.
+ * - Type changes are warned but not applied (SQLite doesn't support ALTER COLUMN).
+ * - System columns (id, created_at, updated_at, status, publishAt) are ignored.
+ */
+import type { ContentTypeConfig } from '../config/define.ts';
+import type { FieldMeta } from '../config/field.ts';
+
+// ── Types ───────────────────────────────────────────────────────────
+
+export interface ColumnInfo {
+  name: string;
+  type: string;
+}
+
+export interface DriftResult {
+  table: string;
+  added: { name: string; sqlType: string; meta: FieldMeta }[];
+  removed: string[];
+  typeChanged: { name: string; expected: string; actual: string }[];
+}
+
+export interface MigrationResult {
+  drift: DriftResult[];
+  sql: string[];
+  warnings: string[];
+}
+
+// ── System columns (skip during drift detection) ────────────────────
+
+const SYSTEM_COLUMNS = new Set([
+  'id',
+  'created_at',
+  'updated_at',
+  'status',
+  'publishAt'
+]);
+
+// ── SQL type mapping (same as schema.ts) ────────────────────────────
+
+function sqlType(fieldType: string): string {
+  switch (fieldType) {
+    case 'text':
+    case 'longText':
+    case 'richText':
+    case 'url':
+    case 'image':
+    case 'reference':
+    case 'date':
+    case 'select':
+      return 'TEXT';
+    case 'number':
+      return 'REAL';
+    case 'boolean':
+      return 'INTEGER';
+    case 'references':
+      return '__JOIN__';
+    default:
+      return 'TEXT';
+  }
+}
+
+// ── Drift detection ─────────────────────────────────────────────────
+
+export function detectDrift(
+  contentTypes: ContentTypeConfig[],
+  existingColumns: Record<string, ColumnInfo[]>
+): MigrationResult {
+  const drift: DriftResult[] = [];
+  const sql: string[] = [];
+  const warnings: string[] = [];
+
+  for (const ct of contentTypes) {
+    const tableCols = existingColumns[ct.id];
+    if (!tableCols) {
+      // Table doesn't exist at all — schema.ts will create it
+      warnings.push(
+        `Table '${ct.id}' does not exist yet — run 'koguma seed' to create it.`
+      );
+      continue;
+    }
+
+    const existing = new Map(
+      tableCols.map(c => [c.name, c.type.toUpperCase()])
+    );
+    const result: DriftResult = {
+      table: ct.id,
+      added: [],
+      removed: [],
+      typeChanged: []
+    };
+
+    // Check for new fields in config not in DB
+    for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
+      const st = sqlType(meta.fieldType);
+      if (st === '__JOIN__') continue; // join tables handled separately
+
+      if (!existing.has(fieldId)) {
+        result.added.push({ name: fieldId, sqlType: st, meta });
+        const notNull = meta.required ? " NOT NULL DEFAULT ''" : '';
+        sql.push(`ALTER TABLE ${ct.id} ADD COLUMN ${fieldId} ${st}${notNull};`);
+      } else {
+        // Check type match
+        const actualType = existing.get(fieldId)!;
+        if (actualType !== st) {
+          result.typeChanged.push({
+            name: fieldId,
+            expected: st,
+            actual: actualType
+          });
+          warnings.push(
+            `Column '${ct.id}.${fieldId}' type mismatch: config says ${st}, DB has ${actualType}. ` +
+              `SQLite does not support ALTER COLUMN — manual migration needed.`
+          );
+        }
+      }
+    }
+
+    // Check for DB columns not in config (removed fields)
+    for (const [colName] of existing) {
+      if (SYSTEM_COLUMNS.has(colName)) continue;
+      const configHasField = colName in ct.fieldMeta;
+      if (!configHasField) {
+        result.removed.push(colName);
+        warnings.push(
+          `Column '${ct.id}.${colName}' exists in DB but not in config. ` +
+            `Koguma will NOT drop this column (data safety). Remove it manually if needed.`
+        );
+      }
+    }
+
+    if (
+      result.added.length ||
+      result.removed.length ||
+      result.typeChanged.length
+    ) {
+      drift.push(result);
+    }
+  }
+
+  return { drift, sql, warnings };
+}

package/src/db/queries.ts

@@ -0,0 +1,293 @@
+/**
+ * Generic CRUD queries — parameterized by the content type config.
+ *
+ * These work with any D1 database generated by schema.ts.
+ * All queries use parameterized SQL to prevent injection.
+ */
+import type { ContentTypeConfig } from '../config/define.ts';
+import type { FieldMeta } from '../config/field.ts';
+
+// ── D1 database interface (Cloudflare Workers binding) ──────────────
+
+interface D1Database {
+  prepare(query: string): D1PreparedStatement;
+  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+}
+
+interface D1PreparedStatement {
+  bind(...values: unknown[]): D1PreparedStatement;
+  first<T = Record<string, unknown>>(): Promise<T | null>;
+  all<T = Record<string, unknown>>(): Promise<D1Result<T>>;
+  run(): Promise<D1Result>;
+}
+
+interface D1Result<T = unknown> {
+  results?: T[];
+  success: boolean;
+  meta: Record<string, unknown>;
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function scalarFields(ct: ContentTypeConfig): [string, FieldMeta][] {
+  return Object.entries(ct.fieldMeta).filter(
+    ([_, meta]) => meta.fieldType !== 'references'
+  );
+}
+
+function refArrayFields(ct: ContentTypeConfig): [string, FieldMeta][] {
+  return Object.entries(ct.fieldMeta).filter(
+    ([_, meta]) => meta.fieldType === 'references'
+  );
+}
+
+// ── GET ONE ─────────────────────────────────────────────────────────
+
+export async function getEntry(
+  db: D1Database,
+  ct: ContentTypeConfig,
+  id: string
+): Promise<Record<string, unknown> | null> {
+  const row = await db
+    .prepare(`SELECT * FROM ${ct.id} WHERE id = ?`)
+    .bind(id)
+    .first();
+
+  if (!row) return null;
+
+  // Parse JSON fields (richText stored as JSON string)
+  const entry = { ...row } as Record<string, unknown>;
+  for (const [fieldId, meta] of scalarFields(ct)) {
+    if (meta.fieldType === 'richText' && typeof entry[fieldId] === 'string') {
+      try {
+        entry[fieldId] = JSON.parse(entry[fieldId] as string);
+      } catch {
+        // leave as string if not valid JSON
+      }
+    }
+  }
+
+  // Load references arrays
+  for (const [fieldId] of refArrayFields(ct)) {
+    const joinTable = `${ct.id}__${fieldId}`;
+    const refs = await db
+      .prepare(
+        `SELECT target_id FROM ${joinTable} WHERE source_id = ? ORDER BY sort_order`
+      )
+      .bind(id)
+      .all();
+    entry[fieldId] =
+      refs.results?.map((r: Record<string, unknown>) => r.target_id) ?? [];
+  }
+
+  return entry;
+}
+
+// ── GET ALL ─────────────────────────────────────────────────────────
+
+export async function getEntries(
+  db: D1Database,
+  ct: ContentTypeConfig,
+  opts?: { publishedOnly?: boolean }
+): Promise<Record<string, unknown>[]> {
+  const whereClause = opts?.publishedOnly
+    ? " WHERE status = 'published' AND (publishAt IS NULL OR publishAt <= datetime('now'))"
+    : '';
+  const result = await db
+    .prepare(`SELECT * FROM ${ct.id}${whereClause} ORDER BY created_at DESC`)
+    .all();
+
+  const rows = (result.results ?? []) as Record<string, unknown>[];
+
+  // Parse JSON + load refs for each row
+  const entries: Record<string, unknown>[] = [];
+  for (const row of rows) {
+    const entry = { ...row };
+    for (const [fieldId, meta] of scalarFields(ct)) {
+      if (meta.fieldType === 'richText' && typeof entry[fieldId] === 'string') {
+        try {
+          entry[fieldId] = JSON.parse(entry[fieldId] as string);
+        } catch {
+          /* skip */
+        }
+      }
+    }
+
+    for (const [fieldId] of refArrayFields(ct)) {
+      const joinTable = `${ct.id}__${fieldId}`;
+      const refs = await db
+        .prepare(
+          `SELECT target_id FROM ${joinTable} WHERE source_id = ? ORDER BY sort_order`
+        )
+        .bind(entry.id)
+        .all();
+      entry[fieldId] =
+        refs.results?.map((r: Record<string, unknown>) => r.target_id) ?? [];
+    }
+
+    entries.push(entry);
+  }
+
+  return entries;
+}
+
+// ── CREATE ──────────────────────────────────────────────────────────
+
+export async function createEntry(
+  db: D1Database,
+  ct: ContentTypeConfig,
+  data: Record<string, unknown>
+): Promise<Record<string, unknown>> {
+  const id = (data.id as string) ?? crypto.randomUUID();
+  const fields = scalarFields(ct);
+  const refFields = refArrayFields(ct);
+
+  const columns = ['id', 'status', 'publishAt', ...fields.map(([f]) => f)];
+  const placeholders = columns.map(() => '?').join(', ');
+  const values = [
+    id,
+    (data.status as string) ?? 'draft',
+    (data.publishAt as string) ?? null,
+    ...fields.map(([f, meta]) => {
+      const val = data[f];
+      if (
+        meta.fieldType === 'richText' &&
+        val != null &&
+        typeof val === 'object'
+      ) {
+        return JSON.stringify(val);
+      }
+      return val ?? null;
+    })
+  ];
+
+  const statements: D1PreparedStatement[] = [
+    db
+      .prepare(
+        `INSERT INTO ${ct.id} (${columns.join(', ')}) VALUES (${placeholders})`
+      )
+      .bind(...values)
+  ];
+
+  // Insert join table entries for refs
+  for (const [fieldId] of refFields) {
+    const refs = data[fieldId] as string[] | undefined;
+    if (refs?.length) {
+      const joinTable = `${ct.id}__${fieldId}`;
+      for (let i = 0; i < refs.length; i++) {
+        statements.push(
+          db
+            .prepare(
+              `INSERT INTO ${joinTable} (source_id, target_id, sort_order) VALUES (?, ?, ?)`
+            )
+            .bind(id, refs[i], i)
+        );
+      }
+    }
+  }
+
+  await db.batch(statements);
+  return (await getEntry(db, ct, id))!;
+}
+
+// ── UPDATE ──────────────────────────────────────────────────────────
+
+export async function updateEntry(
+  db: D1Database,
+  ct: ContentTypeConfig,
+  id: string,
+  data: Record<string, unknown>
+): Promise<Record<string, unknown> | null> {
+  const fields = scalarFields(ct);
+  const refFields = refArrayFields(ct);
+
+  // Only update fields that are present in data
+  const updates: string[] = ["updated_at = datetime('now')"];
+  const values: unknown[] = [];
+
+  // Handle status updates
+  if ('status' in data) {
+    updates.push('status = ?');
+    values.push(data.status);
+  }
+
+  // Handle publishAt updates
+  if ('publishAt' in data) {
+    updates.push('publishAt = ?');
+    values.push(data.publishAt);
+  }
+
+  for (const [fieldId, meta] of fields) {
+    if (fieldId in data) {
+      updates.push(`${fieldId} = ?`);
+      const val = data[fieldId];
+      if (
+        meta.fieldType === 'richText' &&
+        val != null &&
+        typeof val === 'object'
+      ) {
+        values.push(JSON.stringify(val));
+      } else {
+        values.push(val ?? null);
+      }
+    }
+  }
+
+  values.push(id);
+
+  const statements: D1PreparedStatement[] = [
+    db
+      .prepare(`UPDATE ${ct.id} SET ${updates.join(', ')} WHERE id = ?`)
+      .bind(...values)
+  ];
+
+  // Replace ref arrays (delete + re-insert)
+  for (const [fieldId] of refFields) {
+    if (fieldId in data) {
+      const joinTable = `${ct.id}__${fieldId}`;
+      statements.push(
+        db.prepare(`DELETE FROM ${joinTable} WHERE source_id = ?`).bind(id)
+      );
+      const refs = data[fieldId] as string[] | undefined;
+      if (refs?.length) {
+        for (let i = 0; i < refs.length; i++) {
+          statements.push(
+            db
+              .prepare(
+                `INSERT INTO ${joinTable} (source_id, target_id, sort_order) VALUES (?, ?, ?)`
+              )
+              .bind(id, refs[i], i)
+          );
+        }
+      }
+    }
+  }
+
+  await db.batch(statements);
+  return getEntry(db, ct, id);
+}
+
+// ── DELETE ───────────────────────────────────────────────────────────
+
+export async function deleteEntry(
+  db: D1Database,
+  ct: ContentTypeConfig,
+  id: string
+): Promise<boolean> {
+  const refFields = refArrayFields(ct);
+
+  const statements: D1PreparedStatement[] = [
+    db.prepare(`DELETE FROM ${ct.id} WHERE id = ?`).bind(id)
+  ];
+
+  // Clean up join tables
+  for (const [fieldId] of refFields) {
+    const joinTable = `${ct.id}__${fieldId}`;
+    statements.push(
+      db.prepare(`DELETE FROM ${joinTable} WHERE source_id = ?`).bind(id)
+    );
+  }
+
+  await db.batch(statements);
+  return true;
+}

package/src/db/schema.ts

@@ -0,0 +1,115 @@
+/**
+ * Schema generator — reads a Koguma config and produces SQL DDL for D1.
+ *
+ * Design:
+ * - Each content type → one table
+ * - Scalar fields → columns on that table
+ * - `field.ref()`  → TEXT column (foreign key to the target table's id)
+ * - `field.refs()` → join table: `{source}_{field}` with (source_id, target_id, sort_order)
+ * - `field.richText()` → TEXT column storing JSON
+ * - `field.image()` → TEXT column (FK to assets table id)
+ * - Every table gets `id TEXT PRIMARY KEY`, `created_at`, `updated_at`
+ */
+import type { ContentTypeConfig } from '../config/define.ts';
+import type { FieldMeta, FieldType } from '../config/field.ts';
+
+// ── SQL type mapping ────────────────────────────────────────────────
+
+function sqlType(fieldType: FieldType): string {
+  switch (fieldType) {
+    case 'text':
+    case 'longText':
+    case 'richText':
+    case 'url':
+    case 'image':
+    case 'reference':
+    case 'date':
+    case 'select':
+      return 'TEXT';
+    case 'number':
+      return 'REAL';
+    case 'boolean':
+      return 'INTEGER'; // 0/1
+    case 'references':
+      return '__JOIN__'; // handled separately
+  }
+}
+
+// ── Collect all fields from a content type (flat or grouped) ────────
+
+function collectFields(ct: ContentTypeConfig): Record<string, FieldMeta> {
+  return ct.fieldMeta;
+}
+
+// ── Generate SQL ─────────────────────────────────────────────────────
+
+export interface GeneratedSchema {
+  /** CREATE TABLE statements */
+  tables: string[];
+  /** CREATE INDEX statements */
+  indexes: string[];
+  /** All SQL as a single string */
+  sql: string;
+}
+
+export function generateSchema(
+  contentTypes: ContentTypeConfig[]
+): GeneratedSchema {
+  const tables: string[] = [];
+  const indexes: string[] = [];
+
+  // ── Assets table (always present) ────────────────────────────────
+  tables.push(`CREATE TABLE IF NOT EXISTS _assets (
+  id TEXT PRIMARY KEY,
+  title TEXT NOT NULL DEFAULT '',
+  description TEXT DEFAULT '',
+  url TEXT NOT NULL,
+  content_type TEXT DEFAULT '',
+  width INTEGER,
+  height INTEGER,
+  file_size INTEGER,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);`);
+
+  // ── Content type tables ──────────────────────────────────────────
+  for (const ct of contentTypes) {
+    const fields = collectFields(ct);
+    const columns: string[] = [
+      'id TEXT PRIMARY KEY',
+      "created_at TEXT DEFAULT (datetime('now'))",
+      "updated_at TEXT DEFAULT (datetime('now'))",
+      "status TEXT NOT NULL DEFAULT 'draft'",
+      'publishAt TEXT'
+    ];
+
+    for (const [fieldId, meta] of Object.entries(fields)) {
+      const st = sqlType(meta.fieldType);
+
+      if (st === '__JOIN__') {
+        // Create a join table for `references` fields
+        const joinTable = `${ct.id}__${fieldId}`;
+        tables.push(`CREATE TABLE IF NOT EXISTS ${joinTable} (
+  source_id TEXT NOT NULL,
+  target_id TEXT NOT NULL,
+  sort_order INTEGER NOT NULL DEFAULT 0,
+  PRIMARY KEY (source_id, target_id)
+);`);
+        indexes.push(
+          `CREATE INDEX IF NOT EXISTS idx_${joinTable}_source ON ${joinTable} (source_id);`
+        );
+        continue;
+      }
+
+      const notNull = meta.required ? ' NOT NULL' : '';
+      columns.push(`${fieldId} ${st}${notNull}`);
+    }
+
+    tables.push(
+      `CREATE TABLE IF NOT EXISTS ${ct.id} (\n  ${columns.join(',\n  ')}\n);`
+    );
+  }
+
+  const sql = [...tables, '', ...indexes].join('\n\n');
+  return { tables, indexes, sql };
+}

package/src/media/index.ts

@@ -0,0 +1,89 @@
+/**
+ * Media handlers — upload to and serve from R2.
+ */
+import type { Context } from 'hono';
+
+/** Serve a media file from R2 */
+export async function serveMedia(c: Context): Promise<Response> {
+  const media = (c.env as Record<string, R2Bucket>).MEDIA;
+  const key = c.req.param('key');
+
+  const object = await media.get(key);
+  if (!object) return c.notFound();
+
+  return new Response(await object.arrayBuffer(), {
+    headers: {
+      'Content-Type':
+        object.httpMetadata?.contentType ?? 'application/octet-stream',
+      'Cache-Control': 'public, max-age=31536000, immutable'
+    }
+  });
+}
+
+/** Upload a media file to R2 + register in _assets table */
+export async function uploadMedia(c: Context): Promise<Response> {
+  const media = (c.env as Record<string, R2Bucket>).MEDIA;
+  const db = (c.env as Record<string, D1Database>).DB;
+
+  const formData = await c.req.formData();
+  const file = formData.get('file') as File | null;
+  const title = (formData.get('title') as string) ?? '';
+
+  if (!file) {
+    return c.json({ error: 'No file provided' }, 400);
+  }
+
+  const id = crypto.randomUUID();
+  const ext = file.name.split('.').pop() ?? '';
+  const key = `${id}${ext ? '.' + ext : ''}`;
+
+  // Upload to R2
+  await media.put(key, await file.arrayBuffer(), {
+    httpMetadata: { contentType: file.type }
+  });
+
+  // Register in _assets table
+  const url = `/api/media/${key}`;
+  await db
+    .prepare(
+      `INSERT INTO _assets (id, title, url, content_type, file_size) VALUES (?, ?, ?, ?, ?)`
+    )
+    .bind(id, title || file.name, url, file.type, file.size)
+    .run();
+
+  return c.json({ id, url, title: title || file.name, contentType: file.type });
+}
+
+/** List all media assets */
+export async function listMedia(c: Context): Promise<Response> {
+  const db = (c.env as Record<string, D1Database>).DB;
+  const result = await db
+    .prepare('SELECT * FROM _assets ORDER BY created_at DESC')
+    .all();
+
+  return c.json({ assets: result.results ?? [] });
+}
+
+/** Delete a media asset from R2 + _assets table */
+export async function deleteMedia(c: Context): Promise<Response> {
+  const media = (c.env as Record<string, R2Bucket>).MEDIA;
+  const db = (c.env as Record<string, D1Database>).DB;
+  const id = c.req.param('id');
+
+  // Get the asset to find the R2 key
+  const asset = await db
+    .prepare('SELECT * FROM _assets WHERE id = ?')
+    .bind(id)
+    .first();
+
+  if (!asset) return c.notFound();
+
+  // Extract R2 key from URL (/api/media/{key})
+  const url = asset.url as string;
+  const key = url.replace('/api/media/', '');
+
+  await media.delete(key);
+  await db.prepare('DELETE FROM _assets WHERE id = ?').bind(id).run();
+
+  return c.json({ ok: true });
+}