koguma 0.6.6 → 2.0.0

package/src/api/router.integration.test.ts

@@ -3,13 +3,11 @@
  *
  * Integration tests for the Hono API router.
  *
- * Tests the critical invariant that was broken by the initial implementation:
- *   - Public routes  (/api/content/*)  → richText fields are KogumaDocument
- *   - Admin routes   (/api/admin/*)    → richText fields stay as raw Lexical JSON
+ * V2: markdown fields are stored as markdown strings (not Lexical JSON).
+ * Both public and admin routes return the same markdown value.
  *
- * This is the exact bug class that broke the production admin editor.
- *
- * Also covers: CRUD, auth gating, schema endpoint, 404 handling.
+ * Also covers: CRUD, auth gating, schema endpoint, 404 handling,
+ * and the media PATCH rename endpoint.
  */
 import { describe, test, expect } from 'bun:test';
 import { createApiRouter } from './router.ts';
@@ -17,35 +15,37 @@ import { contentType, field, defineConfig } from '../config/index.ts';
 
 // ── Minimal in-memory D1 stub ─────────────────────────────────────────────
 
-const SAMPLE_LEXICAL_JSON = {
-  root: {
-    children: [
-      {
-        type: 'paragraph',
-        version: 1,
-        children: [{ type: 'text', text: 'Hello world', version: 1, format: 0 }]
-      }
-    ],
-    type: 'root',
-    version: 1
-  }
+const SAMPLE_MARKDOWN = '## Hello\n\nThis is a **bold** paragraph.';
+
+// The new schema stores all entry fields inside a JSON `data` blob,
+// with system columns (id, content_type, slug, status, etc.) at top level.
+const ENTRY_ROW = {
+  id: 'entry-1',
+  content_type: 'article',
+  slug: 'test-entry',
+  data: JSON.stringify({
+    title: 'Test Entry',
+    body: SAMPLE_MARKDOWN
+  }),
+  status: 'published',
+  publish_at: null,
+  created_at: '2025-01-01T00:00:00.000Z',
+  updated_at: '2025-01-01T00:00:00.000Z'
 };
 
-const SAMPLE_LEXICAL_STRING = JSON.stringify(SAMPLE_LEXICAL_JSON);
+// Asset row (JSON data blob)
+const ASSET_ROW = {
+  id: 'asset-1',
+  data: JSON.stringify({
+    title: 'Original Title',
+    url: '/api/media/asset-1.jpg',
+    content_type: 'image/jpeg'
+  }),
+  created_at: '2025-01-01T00:00:00.000Z',
+  updated_at: '2025-01-01T00:00:00.000Z'
+};
 
 function createFakeDb() {
-  const entries: Record<string, Record<string, unknown>> = {
-    'entry-1': {
-      id: 'entry-1',
-      title: 'Test Entry',
-      body: SAMPLE_LEXICAL_STRING,
-      status: 'published',
-      created_at: '2025-01-01T00:00:00.000Z',
-      updated_at: '2025-01-01T00:00:00.000Z',
-      publishAt: null
-    }
-  };
-
   return {
     prepare(sql: string) {
       let boundArgs: unknown[] = [];
@@ -59,21 +59,25 @@ function createFakeDb() {
           if (sql.includes('_sessions')) return null;
           // User lookup for login tests
           if (sql.includes('_admin_users')) return null;
-          // SELECT by id
-          if (sql.includes('WHERE id = ?')) {
-            const id = boundArgs[0] as string;
-            return (entries[id] ?? null) as T | null;
+          // SELECT from entries by content_type + id
+          if (sql.includes('FROM entries') && sql.includes('id = ?')) {
+            const id = boundArgs[1] ?? boundArgs[0];
+            if (id === 'entry-1') return ENTRY_ROW as T;
+            return null;
+          }
+          // SELECT from assets by id
+          if (sql.includes('FROM assets') && sql.includes('id = ?')) {
+            const id = boundArgs[0];
+            if (id === 'asset-1') return ASSET_ROW as T;
+            return null;
           }
           return null;
         },
         async all<T = Record<string, unknown>>() {
-          // join table for refs — return empty
-          if (sql.includes('__'))
-            return { results: [] as T[], success: true, meta: {} };
-          // SELECT * FROM article
-          if (sql.includes('FROM article')) {
+          // SELECT * FROM entries WHERE content_type = ?
+          if (sql.includes('FROM entries')) {
             return {
-              results: Object.values(entries) as T[],
+              results: [ENTRY_ROW] as T[],
               success: true,
               meta: {}
             };
@@ -105,7 +109,7 @@ const articleType = contentType({
   displayField: 'title',
   fields: {
     title: field.text('Title').required(),
-    body: field.richText('Body')
+    body: field.markdown('Body')
   }
 });
 
@@ -142,18 +146,15 @@ describe('Public content routes', () => {
       expect(Array.isArray(body.entries)).toBe(true);
     });
 
-    test('richText fields are KogumaDocument (not raw Lexical JSON)', async () => {
+    test('markdown fields are markdown strings (V2)', async () => {
       const res = await makeRequest('/api/content/article');
       const body = (await res.json()) as {
         entries: Array<Record<string, unknown>>;
       };
       const entry = body.entries[0]!;
-      // KogumaDocument has a `nodes` array at top level
-      const doc = entry.body as Record<string, unknown>;
-      expect(doc).toHaveProperty('nodes');
-      expect(Array.isArray(doc.nodes)).toBe(true);
-      // Must NOT be raw Lexical JSON (which has a `root` key)
-      expect(doc).not.toHaveProperty('root');
+      // V2: markdown field is stored as a markdown string, returned as-is
+      expect(typeof entry.body).toBe('string');
+      expect(entry.body).toBe(SAMPLE_MARKDOWN);
     });
 
     test('returns 404 for unknown content type', async () => {
@@ -170,12 +171,11 @@ describe('Public content routes', () => {
       expect(body.id).toBe('entry-1');
     });
 
-    test('richText field is KogumaDocument on single-entry public route', async () => {
+    test('markdown field is markdown string on single-entry public route', async () => {
       const res = await makeRequest('/api/content/article/entry-1');
       const body = (await res.json()) as Record<string, unknown>;
-      const doc = body.body as Record<string, unknown>;
-      expect(doc).toHaveProperty('nodes');
-      expect(doc).not.toHaveProperty('root');
+      expect(typeof body.body).toBe('string');
+      expect(body.body).toBe(SAMPLE_MARKDOWN);
     });
 
     test('returns 404 for missing entry', async () => {
@@ -205,34 +205,21 @@ async function makeSessionCookie(secret: string): Promise<string> {
   return `koguma_session=${token}`;
 }
 
-describe('Admin routes — richText format invariant (authenticated)', () => {
-  /**
-   * THE REGRESSION TEST.
-   *
-   * This test would have caught the original bug where lexicalToKoguma() was
-   * applied in queries.ts (shared by all routes), so the admin route returned
-   * KogumaDocument instead of raw Lexical JSON and the editor crashed.
-   *
-   * If this test fails, it means admin GET routes are returning KogumaDocument
-   * format, which will break the Lexical editor.
-   */
-  test('GET /api/admin/:type/:id returns raw Lexical JSON (has `root`, not `nodes`)', async () => {
+describe('Admin routes — markdown format (authenticated)', () => {
+  test('GET /api/admin/:type/:id returns markdown string for markdown field', async () => {
     const cookie = await makeSessionCookie('test-secret');
     const res = await makeRequest('/api/admin/article/entry-1', {
       headers: { Cookie: cookie }
     });
     expect(res.status).toBe(200);
     const body = (await res.json()) as Record<string, unknown>;
-    const doc = body.body as Record<string, unknown>;
-
-    // Admin must return raw Lexical JSON (editor needs this to parse editor state)
-    expect(doc).toHaveProperty('root');
 
-    // Must NOT be KogumaDocument (which would crash the Lexical editor)
-    expect(doc).not.toHaveProperty('nodes');
+    // V2: Admin route also returns markdown string (same as public)
+    expect(typeof body.body).toBe('string');
+    expect(body.body).toBe(SAMPLE_MARKDOWN);
   });
 
-  test('GET /api/admin/:type returns list with raw Lexical JSON richText', async () => {
+  test('GET /api/admin/:type returns list with markdown field', async () => {
     const cookie = await makeSessionCookie('test-secret');
     const res = await makeRequest('/api/admin/article', {
       headers: { Cookie: cookie }
@@ -242,10 +229,9 @@ describe('Admin routes — richText format invariant (authenticated)', () => {
       entries: Array<Record<string, unknown>>;
     };
     const entry = body.entries[0]!;
-    const doc = entry.body as Record<string, unknown>;
 
-    expect(doc).toHaveProperty('root');
-    expect(doc).not.toHaveProperty('nodes');
+    expect(typeof entry.body).toBe('string');
+    expect(entry.body).toBe(SAMPLE_MARKDOWN);
   });
 });
 
@@ -295,10 +281,7 @@ describe('Schema endpoint', () => {
 
 describe('Media admin routes — PATCH rename', () => {
   test('PATCH /api/admin/media/:id renames asset and returns 200', async () => {
-    // This test would have caught the original bug:
-    // The D1 stub's run() returned meta:{} (no `changes`), causing the handler
-    // to call c.notFound() even for existing assets.
-    const cookie = await makeSessionCookie("test-secret");
+    const cookie = await makeSessionCookie('test-secret');
     const res = await makeRequest('/api/admin/media/asset-1', {
       method: 'PATCH',
       headers: {
@@ -315,7 +298,7 @@ describe('Media admin routes — PATCH rename', () => {
   });
 
   test('PATCH /api/admin/media/:id returns 400 when title is empty', async () => {
-    const cookie = await makeSessionCookie("test-secret");
+    const cookie = await makeSessionCookie('test-secret');
     const res = await makeRequest('/api/admin/media/asset-1', {
       method: 'PATCH',
       headers: {

package/src/api/router.ts

@@ -31,7 +31,6 @@ import {
   updateEntry,
   deleteEntry
 } from '../db/queries.ts';
-import { lexicalToKoguma } from '../rich-text/index.ts';
 import { handleLogin, handleLogout, requireAuth } from '../auth/index.ts';
 import {
   serveMedia,
@@ -55,6 +54,25 @@ export function createApiRouter(config: KogumaConfig): Hono {
     ctMap.set(ct.id, ct);
   }
 
+  // ── Dev sync webhook ──────────────────────────────────────────────
+  // Fire-and-forget notification to the dev sync server.
+  // Only active when KOGUMA_DEV_SYNC env var is set (by `koguma dev`).
+  function notifyDevSync(
+    env: Record<string, unknown>,
+    action: 'create' | 'update' | 'delete',
+    contentType: string,
+    entry?: Record<string, unknown> | null,
+    entryId?: string
+  ): void {
+    const url = env.KOGUMA_DEV_SYNC as string | undefined;
+    if (!url) return;
+    fetch(`${url}/sync`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action, contentType, entry, entryId })
+    }).catch(() => {}); // fire-and-forget
+  }
+
   // ── Reference resolution ─────────────────────────────────────────
   // Resolves ref, refs, and image fields from flat IDs into nested objects.
   // depth=1 resolves the entry's refs; depth=2 resolves refs-of-refs.
@@ -71,32 +89,46 @@ export function createApiRouter(config: KogumaConfig): Hono {
       if (meta.fieldType === 'image') {
         const assetId = entry[fieldId] as string | null;
         if (assetId) {
-          const asset = await db
-            .prepare('SELECT * FROM _assets WHERE id = ?')
+          const row = await db
+            .prepare('SELECT * FROM assets WHERE id = ?')
             .bind(assetId)
             .first();
-          resolved[fieldId] = asset ?? null;
+          if (row) {
+            const data =
+              typeof row.data === 'string'
+                ? JSON.parse(row.data as string)
+                : row.data;
+            resolved[fieldId] = { id: row.id, ...data };
+          } else {
+            resolved[fieldId] = null;
+          }
         }
       } else if (meta.fieldType === 'images') {
-        // images stores a JSON array of asset IDs — resolve each
-        const raw = entry[fieldId] as string | null;
+        // images stores an array of asset IDs — resolve each
+        const raw = entry[fieldId];
         if (raw) {
-          try {
-            const ids = typeof raw === 'string' ? JSON.parse(raw) : raw;
-            if (Array.isArray(ids) && ids.length > 0) {
-              const assets = await Promise.all(
-                ids.map((id: string) =>
-                  db
-                    .prepare('SELECT * FROM _assets WHERE id = ?')
-                    .bind(id)
-                    .first()
-                )
-              );
-              resolved[fieldId] = assets.filter(Boolean);
-            } else {
-              resolved[fieldId] = [];
-            }
-          } catch {
+          const ids = Array.isArray(raw)
+            ? raw
+            : typeof raw === 'string'
+              ? JSON.parse(raw)
+              : [];
+          if (Array.isArray(ids) && ids.length > 0) {
+            const assets = await Promise.all(
+              ids.map(async (id: string) => {
+                const row = await db
+                  .prepare('SELECT * FROM assets WHERE id = ?')
+                  .bind(id)
+                  .first();
+                if (!row) return null;
+                const data =
+                  typeof row.data === 'string'
+                    ? JSON.parse(row.data as string)
+                    : row.data;
+                return { id: row.id, ...data };
+              })
+            );
+            resolved[fieldId] = assets.filter(Boolean);
+          } else {
             resolved[fieldId] = [];
           }
         }
@@ -105,7 +137,7 @@ export function createApiRouter(config: KogumaConfig): Hono {
         if (refId) {
           const refCt = ctMap.get(meta.refContentType);
           if (refCt) {
-            const refEntry = await getEntry(db, refCt, refId);
+            const refEntry = await getEntry(db, meta.refContentType, refId);
             resolved[fieldId] = refEntry
               ? await resolveEntry(db, refEntry, refCt, depth - 1)
               : null;
@@ -118,7 +150,7 @@ export function createApiRouter(config: KogumaConfig): Hono {
           if (refCt) {
             const items = await Promise.all(
               ids.map(async id => {
-                const refEntry = await getEntry(db, refCt, id);
+                const refEntry = await getEntry(db, meta.refContentType!, id);
                 return refEntry
                   ? resolveEntry(db, refEntry, refCt, depth - 1)
                   : null;
@@ -133,24 +165,6 @@ export function createApiRouter(config: KogumaConfig): Hono {
     return resolved;
   }
 
-  /**
-   * Converts raw Lexical JSON richText fields → KogumaDocument.
-   * Applied only to public /api/content/* responses.
-   * Admin routes receive raw Lexical JSON so the editor can parse it.
-   */
-  function convertRichTextFields(
-    entry: Record<string, unknown>,
-    ct: ContentTypeConfig
-  ): Record<string, unknown> {
-    const out = { ...entry };
-    for (const [fieldId, meta] of Object.entries(ct.fieldMeta)) {
-      if (meta.fieldType === 'richText' && out[fieldId] != null) {
-        out[fieldId] = lexicalToKoguma(out[fieldId] as Record<string, unknown>);
-      }
-    }
-    return out;
-  }
-
   // ── Auth routes ──────────────────────────────────────────────────
   app.post('/api/auth/login', handleLogin);
   app.post('/api/auth/logout', handleLogout);
@@ -166,14 +180,14 @@ export function createApiRouter(config: KogumaConfig): Hono {
       typeof getEntries
     >[0];
     const includeDrafts = c.req.query('drafts') === 'true';
-    const entries = await getEntries(db, ct, { publishedOnly: !includeDrafts });
+    const entries = await getEntries(db, ct.id, {
+      publishedOnly: !includeDrafts
+    });
     // Always resolve references for public API
     const resolved = await Promise.all(
       entries.map(e => resolveEntry(db, e, ct, 2))
     );
-    // Convert Lexical JSON → KogumaDocument for public consumers
-    const converted = resolved.map(e => convertRichTextFields(e, ct));
-    return c.json({ entries: converted });
+    return c.json({ entries: resolved });
   });
 
   app.get('/api/content/:type/:id', async c => {
@@ -183,11 +197,10 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof getEntry
     >[0];
-    const entry = await getEntry(db, ct, c.req.param('id'));
+    const entry = await getEntry(db, ct.id, c.req.param('id'));
     if (!entry) return c.notFound();
     const resolved = await resolveEntry(db, entry, ct, 2);
-    // Convert Lexical JSON → KogumaDocument for public consumers
-    return c.json(convertRichTextFields(resolved, ct));
+    return c.json(resolved);
   });
 
   // ── Media serving (public) ───────────────────────────────────────
@@ -234,7 +247,7 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof getEntries
     >[0];
-    const entries = await getEntries(db, ct);
+    const entries = await getEntries(db, ct.id);
     return c.json({ entries });
   });
 
@@ -245,7 +258,7 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof getEntry
     >[0];
-    const entry = await getEntry(db, ct, c.req.param('id'));
+    const entry = await getEntry(db, ct.id, c.req.param('id'));
     if (!entry) return c.notFound();
     return c.json(entry);
   });
@@ -280,7 +293,8 @@ export function createApiRouter(config: KogumaConfig): Hono {
       return c.json({ error: 'Validation failed', issues }, 422);
     }
 
-    const entry = await createEntry(db, ct, data);
+    const entry = await createEntry(db, ct.id, data);
+    notifyDevSync(c.env as Record<string, unknown>, 'create', ct.id, entry);
     return c.json(entry, 201);
   });
 
@@ -316,8 +330,9 @@ export function createApiRouter(config: KogumaConfig): Hono {
       return c.json({ error: 'Validation failed', issues }, 422);
     }
 
-    const entry = await updateEntry(db, ct, c.req.param('id'), data);
+    const entry = await updateEntry(db, ct.id, c.req.param('id'), data);
     if (!entry) return c.notFound();
+    notifyDevSync(c.env as Record<string, unknown>, 'update', ct.id, entry);
     return c.json(entry);
   });
 
@@ -329,16 +344,17 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof getEntries
     >[0];
-    const entries = await getEntries(db, ct);
+    const entries = await getEntries(db, ct.id);
     if (entries.length === 0) return c.json({ error: 'No entry found' }, 404);
 
     const data = await c.req.json();
     const entry = await updateEntry(
       db as Parameters<typeof updateEntry>[0],
-      ct,
+      ct.id,
       entries[0]!.id as string,
       data
     );
+    notifyDevSync(c.env as Record<string, unknown>, 'update', ct.id, entry);
     return c.json(entry);
   });
 
@@ -349,7 +365,14 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof deleteEntry
     >[0];
-    await deleteEntry(db, ct, c.req.param('id'));
+    await deleteEntry(db, ct.id, c.req.param('id'));
+    notifyDevSync(
+      c.env as Record<string, unknown>,
+      'delete',
+      ct.id,
+      null,
+      c.req.param('id')
+    );
     return c.json({ ok: true });
   });
 
@@ -361,11 +384,12 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof updateEntry
     >[0];
-    const entry = await updateEntry(db, ct, c.req.param('id'), {
+    const entry = await updateEntry(db, ct.id, c.req.param('id'), {
       status: 'published',
       publishAt: null // clear scheduled time — publish immediately
     });
     if (!entry) return c.notFound();
+    notifyDevSync(c.env as Record<string, unknown>, 'update', ct.id, entry);
     return c.json(entry);
   });
 
@@ -376,11 +400,12 @@ export function createApiRouter(config: KogumaConfig): Hono {
     const db = (c.env as Record<string, unknown>).DB as Parameters<
       typeof updateEntry
     >[0];
-    const entry = await updateEntry(db, ct, c.req.param('id'), {
+    const entry = await updateEntry(db, ct.id, c.req.param('id'), {
       status: 'draft',
       publishAt: null // clear scheduled time
     });
     if (!entry) return c.notFound();
+    notifyDevSync(c.env as Record<string, unknown>, 'update', ct.id, entry);
     return c.json(entry);
   });
 
@@ -396,11 +421,12 @@ export function createApiRouter(config: KogumaConfig): Hono {
     if (!body.publishAt) {
       return c.json({ error: 'publishAt is required' }, 400);
     }
-    const entry = await updateEntry(db, ct, c.req.param('id'), {
+    const entry = await updateEntry(db, ct.id, c.req.param('id'), {
       status: 'published',
       publishAt: body.publishAt
     });
     if (!entry) return c.notFound();
+    notifyDevSync(c.env as Record<string, unknown>, 'update', ct.id, entry);
     return c.json(entry);
   });
 

package/src/config/define.ts

@@ -59,7 +59,7 @@ export interface ContentTypeConfig<S extends z.ZodType = z.ZodType> {
  *   displayField: "title",
  *   fields: {
  *     title: field.text("Title").required(),
- *     body:  field.richText("Body"),
+ *     body:  field.markdown("Body"),
  *   },
  * });
  *

package/src/config/field.ts

@@ -5,19 +5,19 @@
  * The admin label is always the first argument for readability:
  *
  *   field.text("Page Title").required().max(100)
- *   field.richText("Body Text")
+ *   field.markdown("Body Text")
  *   field.image("Hero Photo")
  *   field.refs("featureCard", "Highlights")
  */
 import { z } from 'zod/v4';
-import type { KogumaAsset, KogumaDocument, EntryReference } from './types.ts';
+import type { KogumaAsset, EntryReference } from './types.ts';
 
 // ── Field metadata (extracted by the admin + schema generator) ──────
 
 export type FieldType =
   | 'text'
   | 'longText'
-  | 'richText'
+  | 'markdown'
   | 'url'
   | 'email'
   | 'phone'
@@ -116,12 +116,13 @@ export const field = {
     });
   },
 
-  /** Rich text field (Lexical rich text document) */
-  richText(label: string) {
-    return new FieldBuilder(
-      z.custom<KogumaDocument>().optional().describe(label),
-      { label, fieldType: 'richText', required: false }
-    );
+  /** Markdown field (WYSIWYG editor, stored as markdown string) */
+  markdown(label: string) {
+    return new FieldBuilder(z.string().optional().describe(label), {
+      label,
+      fieldType: 'markdown',
+      required: false
+    });
   },
 
   /** URL field with validation */

package/src/config/index.ts

@@ -20,19 +20,7 @@ export { field } from './field.ts';
 export type { FieldBuilder, FieldType, FieldMeta } from './field.ts';
 
 // Runtime types
-export type {
-  KogumaAsset,
-  KogumaDocument,
-  KogumaBlockNode,
-  KogumaInlineNode,
-  KogumaListItem,
-  KogumaTableRow,
-  KogumaTableCell,
-  EntryReference
-} from './types.ts';
-
-// Rich text utilities
-export { richTextToPlain } from '../rich-text/index.ts';
+export type { KogumaAsset, EntryReference } from './types.ts';
 
 // Meta registry (for dev tools like the Schema Builder)
 export { fieldRegistry, fieldSuggestions } from './meta.ts';

package/src/config/meta.ts

@@ -43,11 +43,11 @@ export const fieldRegistry: FieldTypeMeta[] = [
     modifiers: ['required', 'min', 'max', 'default']
   },
   {
-    type: 'richText',
-    label: 'Rich Text',
+    type: 'markdown',
+    label: 'Markdown',
     icon: '📝',
     category: 'basics',
-    description: 'Rich text editor',
+    description: 'Markdown editor',
     args: 'label',
     modifiers: ['required']
   },
@@ -205,10 +205,10 @@ export const fieldSuggestions: Record<string, FieldSuggestion> = {
   bio: { type: 'longText' },
   notes: { type: 'longText' },
   excerpt: { type: 'longText' },
-  // Rich text
-  body: { type: 'richText' },
-  content: { type: 'richText' },
-  story: { type: 'richText' },
+  // Markdown
+  body: { type: 'markdown' },
+  content: { type: 'markdown' },
+  story: { type: 'markdown' },
   // URL
   email: { type: 'email' }, // was incorrectly 'url'
   website: { type: 'url' },