koguma 0.6.6 → 2.0.0

package/src/config/types.ts

@@ -1,6 +1,6 @@
 /**
  * Core CMS types used across Koguma.
- * These are the runtime types for assets, rich text, and references.
+ * These are the runtime types for assets and references.
  */
 
 /** A media asset stored in R2 */
@@ -13,100 +13,6 @@ export interface KogumaAsset {
   height?: number;
 }
 
-// ── Rich Text ─────────────────────────────────────────────────────────
-
-/**
- * A koguma-normalized rich text document.
- * Editor-agnostic — does not expose Lexical internals.
- * Produced server-side from Lexical's SerializedEditorState.
- */
-export interface KogumaDocument {
-  nodes: KogumaBlockNode[];
-}
-
-export type KogumaBlockNode =
-  | {
-      type: 'paragraph';
-      key?: string;
-      align?: 'left' | 'center' | 'right' | 'justify';
-      children: KogumaInlineNode[];
-    }
-  | {
-      type: 'heading';
-      key?: string;
-      level: 1 | 2 | 3 | 4 | 5 | 6;
-      children: KogumaInlineNode[];
-    }
-  | { type: 'list'; key?: string; ordered: boolean; items: KogumaListItem[] }
-  | { type: 'quote'; key?: string; children: KogumaInlineNode[] }
-  | { type: 'code'; key?: string; language?: string; text: string }
-  | {
-      type: 'image';
-      key?: string;
-      url: string;
-      alt?: string;
-      width?: number;
-      height?: number;
-    }
-  | { type: 'hr'; key?: string }
-  | { type: 'table'; key?: string; rows: KogumaTableRow[] }
-  | { type: 'layout'; key?: string; columns: KogumaBlockNode[][] }
-  | {
-      type: 'custom';
-      key?: string;
-      name: string;
-      data: Record<string, unknown>;
-    };
-
-/** A list item — supports nesting and checklists */
-export interface KogumaListItem {
-  key?: string;
-  children: KogumaInlineNode[];
-  /** Defined = checklist item. true = checked, false = unchecked */
-  checked?: boolean;
-  nestedList?: { ordered: boolean; items: KogumaListItem[] };
-}
-
-export interface KogumaTableRow {
-  key?: string;
-  isHeader?: boolean;
-  cells: KogumaTableCell[];
-}
-
-export interface KogumaTableCell {
-  key?: string;
-  children: KogumaInlineNode[];
-}
-
-export type KogumaInlineNode =
-  | {
-      type: 'text';
-      key?: string;
-      text: string;
-      bold?: boolean;
-      italic?: boolean;
-      underline?: boolean;
-      code?: boolean;
-      strikethrough?: boolean;
-      superscript?: boolean;
-      subscript?: boolean;
-    }
-  | {
-      type: 'link';
-      key?: string;
-      url: string;
-      newTab?: boolean;
-      children: KogumaInlineNode[];
-    }
-  | { type: 'inline-image'; key?: string; url: string; alt?: string }
-  | { type: 'line-break'; key?: string }
-  | {
-      type: 'custom';
-      key?: string;
-      name: string;
-      data: Record<string, unknown>;
-    };
-
 /** Reference to another entry */
 export interface EntryReference<T = Record<string, unknown>> {
   id: string;

package/src/db/init.ts

@@ -0,0 +1,68 @@
+/**
+ * Database initialization — hardcoded 2-table schema for the JSON document store.
+ *
+ * Two tables, forever. No migrations.
+ *
+ *   entries — all content, keyed by content_type. Field data stored as JSON blob.
+ *   assets  — media metadata as JSON blob. Files live in R2.
+ */
+
+// ── Schema SQL ──────────────────────────────────────────────────────
+
+export const INIT_SQL = `
+CREATE TABLE IF NOT EXISTS entries (
+  id TEXT PRIMARY KEY,
+  content_type TEXT NOT NULL,
+  slug TEXT,
+  data TEXT NOT NULL,
+  status TEXT NOT NULL DEFAULT 'draft',
+  publish_at TEXT,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(content_type);
+CREATE INDEX IF NOT EXISTS idx_entries_slug ON entries(content_type, slug);
+
+CREATE TABLE IF NOT EXISTS assets (
+  id TEXT PRIMARY KEY,
+  data TEXT NOT NULL,
+  created_at TEXT DEFAULT (datetime('now')),
+  updated_at TEXT DEFAULT (datetime('now'))
+);
+`.trim();
+
+// ── D1 database interface ───────────────────────────────────────────
+
+interface D1Database {
+  prepare(query: string): D1PreparedStatement;
+  batch<T = unknown>(statements: D1PreparedStatement[]): Promise<D1Result<T>[]>;
+  exec(sql: string): Promise<D1ExecResult>;
+}
+
+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>;
+}
+
+interface D1ExecResult {
+  count: number;
+  duration: number;
+}
+
+// ── Init function ───────────────────────────────────────────────────
+
+/**
+ * Initialize the database with the 2-table schema.
+ * Safe to call multiple times (uses IF NOT EXISTS).
+ */
+export async function initDatabase(db: D1Database): Promise<void> {
+  await db.exec(INIT_SQL);
+}

package/src/db/queries.ts

@@ -1,11 +1,9 @@
 /**
- * Generic CRUD queries — parameterized by the content type config.
+ * Generic CRUD queries for the JSON document store.
  *
- * These work with any D1 database generated by schema.ts.
- * All queries use parameterized SQL to prevent injection.
+ * All content is stored in a single `entries` table with a `data` JSON blob.
+ * No per-content-type tables, no join tables, no schema generation.
  */
-import type { ContentTypeConfig } from '../config/define.ts';
-import type { FieldMeta } from '../config/field.ts';
 
 // ── D1 database interface (Cloudflare Workers binding) ──────────────
 
@@ -29,271 +27,182 @@ interface D1Result<T = unknown> {
 
 // ── Helpers ──────────────────────────────────────────────────────────
 
-function scalarFields(ct: ContentTypeConfig): [string, FieldMeta][] {
-  return Object.entries(ct.fieldMeta).filter(
-    ([_, meta]) => meta.fieldType !== 'references'
-  );
+/** Unpack a DB row into a flat entry: system fields + spread data blob. */
+function unpackRow(row: Record<string, unknown>): Record<string, unknown> {
+  const {
+    id,
+    content_type,
+    slug,
+    data,
+    status,
+    publish_at,
+    created_at,
+    updated_at,
+    ...rest
+  } = row;
+  const parsed = typeof data === 'string' ? JSON.parse(data) : (data ?? {});
+  return {
+    id,
+    content_type,
+    slug,
+    status,
+    publish_at,
+    created_at,
+    updated_at,
+    ...parsed,
+    ...rest
+  };
 }
 
-function refArrayFields(ct: ContentTypeConfig): [string, FieldMeta][] {
-  return Object.entries(ct.fieldMeta).filter(
-    ([_, meta]) => meta.fieldType === 'references'
-  );
+/** Pack a flat entry into system columns + data JSON blob. */
+function packData(data: Record<string, unknown>): string {
+  // Strip system fields — they live in columns, not the blob
+  const {
+    id,
+    content_type,
+    slug,
+    status,
+    publish_at,
+    publishAt,
+    created_at,
+    updated_at,
+    ...fields
+  } = data;
+  return JSON.stringify(fields);
 }
 
 // ── GET ONE ─────────────────────────────────────────────────────────
 
 export async function getEntry(
   db: D1Database,
-  ct: ContentTypeConfig,
+  contentType: string,
   id: string
 ): Promise<Record<string, unknown> | null> {
   const row = await db
-    .prepare(`SELECT * FROM ${ct.id} WHERE id = ?`)
-    .bind(id)
+    .prepare('SELECT * FROM entries WHERE content_type = ? AND id = ?')
+    .bind(contentType, id)
     .first();
 
   if (!row) return null;
-
-  // Parse JSON fields (richText and images stored as JSON strings)
-  const entry = { ...row } as Record<string, unknown>;
-  for (const [fieldId, meta] of scalarFields(ct)) {
-    if (
-      (meta.fieldType === 'richText' || meta.fieldType === 'images') &&
-      typeof entry[fieldId] === 'string'
-    ) {
-      try {
-        entry[fieldId] = JSON.parse(entry[fieldId] as string);
-      } catch {
-        // leave as-is 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;
+  return unpackRow(row);
 }
 
 // ── GET ALL ─────────────────────────────────────────────────────────
 
 export async function getEntries(
   db: D1Database,
-  ct: ContentTypeConfig,
+  contentType: string,
   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' || meta.fieldType === 'images') &&
-        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);
+  let query = 'SELECT * FROM entries WHERE content_type = ?';
+  if (opts?.publishedOnly) {
+    query +=
+      " AND status = 'published' AND (publish_at IS NULL OR publish_at <= datetime('now'))";
   }
+  query += ' ORDER BY created_at DESC';
 
-  return entries;
+  const result = await db.prepare(query).bind(contentType).all();
+  return (result.results ?? []).map(unpackRow);
 }
 
 // ── CREATE ──────────────────────────────────────────────────────────
 
 export async function createEntry(
   db: D1Database,
-  ct: ContentTypeConfig,
+  contentType: string,
   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' || meta.fieldType === 'images') &&
-        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))!;
+  const slug = (data.slug as string) ?? null;
+  const status = (data.status as string) ?? 'draft';
+  const publishAt =
+    (data.publishAt as string) ?? (data.publish_at as string) ?? null;
+  const blob = packData(data);
+
+  await db
+    .prepare(
+      `INSERT INTO entries (id, content_type, slug, data, status, publish_at) VALUES (?, ?, ?, ?, ?, ?)`
+    )
+    .bind(id, contentType, slug, blob, status, publishAt)
+    .run();
+
+  return (await getEntry(db, contentType, id))!;
 }
 
 // ── UPDATE ──────────────────────────────────────────────────────────
 
 export async function updateEntry(
   db: D1Database,
-  ct: ContentTypeConfig,
+  contentType: string,
   id: string,
   data: Record<string, unknown>
 ): Promise<Record<string, unknown> | null> {
-  const fields = scalarFields(ct);
-  const refFields = refArrayFields(ct);
+  // Read existing entry to merge data blobs
+  const existing = await db
+    .prepare('SELECT * FROM entries WHERE content_type = ? AND id = ?')
+    .bind(contentType, id)
+    .first();
 
-  // Only update fields that are present in data
-  const updates: string[] = ["updated_at = datetime('now')"];
-  const values: unknown[] = [];
+  if (!existing) return null;
+
+  const existingData =
+    typeof existing.data === 'string'
+      ? JSON.parse(existing.data as string)
+      : {};
+
+  // Merge new fields into existing data blob
+  const {
+    id: _,
+    content_type: __,
+    slug: newSlug,
+    status: newStatus,
+    publishAt,
+    publish_at,
+    created_at,
+    updated_at,
+    ...newFields
+  } = data;
+  const mergedBlob = JSON.stringify({ ...existingData, ...newFields });
+
+  // Build SET clause for system columns that were provided
+  const sets: string[] = ['data = ?', "updated_at = datetime('now')"];
+  const values: unknown[] = [mergedBlob];
 
-  // Handle status updates
   if ('status' in data) {
-    updates.push('status = ?');
+    sets.push('status = ?');
     values.push(data.status);
   }
-
-  // Handle publishAt updates
-  if ('publishAt' in data) {
-    updates.push('publishAt = ?');
-    values.push(data.publishAt);
+  if ('publishAt' in data || 'publish_at' in data) {
+    sets.push('publish_at = ?');
+    values.push(publishAt ?? publish_at ?? null);
   }
-
-  for (const [fieldId, meta] of fields) {
-    if (fieldId in data) {
-      updates.push(`${fieldId} = ?`);
-      const val = data[fieldId];
-      if (
-        (meta.fieldType === 'richText' || meta.fieldType === 'images') &&
-        val != null &&
-        typeof val === 'object'
-      ) {
-        values.push(JSON.stringify(val));
-      } else {
-        values.push(val ?? null);
-      }
-    }
+  if ('slug' in data) {
+    sets.push('slug = ?');
+    values.push(data.slug);
   }
 
-  values.push(id);
+  values.push(contentType, id);
 
-  const statements: D1PreparedStatement[] = [
-    db
-      .prepare(`UPDATE ${ct.id} SET ${updates.join(', ')} WHERE id = ?`)
-      .bind(...values)
-  ];
+  await db
+    .prepare(
+      `UPDATE entries SET ${sets.join(', ')} WHERE content_type = ? AND id = ?`
+    )
+    .bind(...values)
+    .run();
 
-  // 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);
+  return getEntry(db, contentType, id);
 }
 
 // ── DELETE ───────────────────────────────────────────────────────────
 
 export async function deleteEntry(
   db: D1Database,
-  ct: ContentTypeConfig,
+  contentType: string,
   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);
+  await db
+    .prepare('DELETE FROM entries WHERE content_type = ? AND id = ?')
+    .bind(contentType, id)
+    .run();
   return true;
 }

package/src/db/sql.ts

@@ -50,7 +50,7 @@ export interface AssetIndex {
 }
 
 /**
- * Build an asset index from raw _assets rows.
+ * Build an asset index from raw assets rows.
  * Maps both full title and title-without-extension to asset IDs.
  */
 export function buildAssetIndex(
@@ -90,18 +90,15 @@ export interface FieldMeta {
 }
 
 /**
- * Process a seed entry by resolving image references and converting
- * markdown strings in richText fields to KogumaDocument JSON.
+ * Process a seed entry by resolving image references.
+ * Markdown fields are left as-is (already markdown strings).
  *
  * Returns a new processed entry (does not mutate the input).
  */
 export function processSeedEntry(
   entry: Record<string, unknown>,
   fieldMeta: Record<string, FieldMeta>,
-  assetIndex: AssetIndex,
-  markdownToKoguma: (md: string) => { nodes: unknown[] },
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  kogumaToLexical: (doc: any) => Record<string, unknown>
+  assetIndex: AssetIndex
 ): { processed: Record<string, unknown>; resolutions: string[] } {
   const processed: Record<string, unknown> = {
     id: (entry.id as string) ?? crypto.randomUUID(),
@@ -121,11 +118,6 @@ export function processSeedEntry(
         processed[fieldId] = result.id;
         resolutions.push(`${fieldId}: "${value}" → ${result.id}`);
       }
-    } else if (meta.fieldType === 'richText' && typeof value === 'string') {
-      const doc = markdownToKoguma(value);
-      const lexical = kogumaToLexical(doc);
-      processed[fieldId] = JSON.stringify(lexical);
-      resolutions.push(`${fieldId}: markdown → Lexical JSON`);
     } else if (meta.fieldType === 'images' && Array.isArray(value)) {
       const ids = value.map((v: unknown) => {
         if (typeof v !== 'string') return v;
@@ -136,8 +128,9 @@ export function processSeedEntry(
         }
         return v;
       });
-      processed[fieldId] = JSON.stringify(ids);
+      processed[fieldId] = ids;
     }
+    // markdown: left as-is (markdown string) — no conversion needed
   }
 
   return { processed, resolutions };
@@ -147,23 +140,15 @@ export function processSeedEntry(
 
 /**
  * Generate all INSERT OR REPLACE statements for importing a set of entries
- * into a table, including join table rows.
+ * into a table.
  */
 export function buildImportSql(
-  typeId: string,
-  entries: Record<string, unknown>[],
-  joinTables?: Record<string, Record<string, unknown>[]>
+  table: string,
+  entries: Record<string, unknown>[]
 ): string[] {
   const statements: string[] = [];
   for (const entry of entries) {
-    statements.push(buildInsertSql(typeId, entry));
-  }
-  if (joinTables) {
-    for (const [jtName, rows] of Object.entries(joinTables)) {
-      for (const row of rows) {
-        statements.push(buildInsertSql(jtName, row));
-      }
-    }
+    statements.push(buildInsertSql(table, entry));
   }
   return statements;
 }