koguma 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "koguma",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "description": "🐻 A little CMS with big heart — schema-driven, runs on Cloudflare's free tier",
   "type": "module",
   "license": "MIT",

package/src/config/define.ts

@@ -82,7 +82,7 @@ export function contentType<
   displayField: string;
   singleton?: boolean;
   fields: F;
-}): ContentTypeConfig {
+}) {
   // Collect all field builders (from groups or flat)
   const allFields: Record<string, FieldBuilder> = {};
   const groups: GroupConfig[] = [];
@@ -116,11 +116,11 @@ export function contentType<
     name: opts.name,
     displayField: opts.displayField,
     singleton: opts.singleton,
-    schema: schema as z.ZodType,
+    schema,
     fieldMeta,
     groups,
     flatFields
-  };
+  } satisfies ContentTypeConfig;
 }
 
 // ── defineConfig ─────────────────────────────────────────────────────

package/src/db/migrate.ts

@@ -48,7 +48,13 @@ function sqlType(fieldType: string): string {
     case 'longText':
     case 'richText':
     case 'url':
+    case 'email':
+    case 'phone':
+    case 'color':
+    case 'youtube':
+    case 'instagram':
     case 'image':
+    case 'images':
     case 'reference':
     case 'date':
     case 'select':
@@ -76,7 +82,7 @@ export function detectDrift(
 
   for (const ct of contentTypes) {
     const tableCols = existingColumns[ct.id];
-    if (!tableCols) {
+    if (!tableCols || tableCols.length === 0) {
       // Table doesn't exist — generate CREATE TABLE
       const columns: string[] = [
         'id TEXT PRIMARY KEY',

package/src/db/sql.ts

@@ -0,0 +1,169 @@
+/**
+ * sql.ts — Pure SQL generation utilities for D1 operations.
+ *
+ * These functions are used by seed, import, push, pull, and export commands.
+ * Extracted here to enable thorough unit testing without wrangler dependencies.
+ */
+
+// ── Value escaping ──────────────────────────────────────────────────
+
+/**
+ * Escape a JavaScript value for safe embedding in a SQL string.
+ * Returns a SQL-safe string (already quoted if needed).
+ */
+export function escapeValue(v: unknown): string {
+  if (v === null || v === undefined) return 'NULL';
+  if (typeof v === 'number') return String(v);
+  if (typeof v === 'boolean') return v ? '1' : '0';
+  return `'${String(v).replace(/'/g, "''")}'`;
+}
+
+// ── INSERT OR REPLACE generation ────────────────────────────────────
+
+/**
+ * Generate an INSERT OR REPLACE statement from a table name and row data.
+ */
+export function buildInsertSql(
+  table: string,
+  row: Record<string, unknown>
+): string {
+  const cols = Object.keys(row);
+  const vals = Object.values(row).map(escapeValue);
+  return `INSERT OR REPLACE INTO ${table} (${cols.join(', ')}) VALUES (${vals.join(', ')})`;
+}
+
+// ── Shell-safe SQL escaping ─────────────────────────────────────────
+
+/**
+ * Wrap a SQL statement for safe use in `wrangler d1 execute --command "..."`.
+ * Escapes inner double quotes.
+ */
+export function wrapForShell(sql: string): string {
+  return sql.replace(/"/g, '\\"');
+}
+
+// ── Asset title resolution ──────────────────────────────────────────
+
+export interface AssetIndex {
+  /** Map of lowercase title → asset ID */
+  titleMap: Map<string, string>;
+}
+
+/**
+ * Build an asset index from raw _assets rows.
+ * Maps both full title and title-without-extension to asset IDs.
+ */
+export function buildAssetIndex(
+  assets: { id: string; title: string }[]
+): AssetIndex {
+  const titleMap = new Map<string, string>();
+  for (const a of assets) {
+    titleMap.set(a.title.toLowerCase(), a.id);
+    const noExt = a.title.replace(/\.\w+$/, '').toLowerCase();
+    if (noExt !== a.title.toLowerCase()) titleMap.set(noExt, a.id);
+  }
+  return { titleMap };
+}
+
+/**
+ * Resolve a human-friendly asset reference (title or filename) to an asset ID.
+ * Returns the original value if not found.
+ */
+export function resolveAssetRef(
+  value: string,
+  index: AssetIndex
+): { id: string; resolved: boolean } {
+  const lower = value.toLowerCase();
+  const id = index.titleMap.get(lower);
+  if (id) return { id, resolved: true };
+  const noExt = value.replace(/\.\w+$/, '').toLowerCase();
+  const id2 = index.titleMap.get(noExt);
+  if (id2) return { id: id2, resolved: true };
+  return { id: value, resolved: false };
+}
+
+// ── Seed entry processing ───────────────────────────────────────────
+
+export interface FieldMeta {
+  fieldType: string;
+  required: boolean;
+}
+
+/**
+ * Process a seed entry by resolving image references and converting
+ * markdown strings in richText fields to KogumaDocument JSON.
+ *
+ * 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>
+): { processed: Record<string, unknown>; resolutions: string[] } {
+  const processed: Record<string, unknown> = {
+    id: (entry.id as string) ?? crypto.randomUUID(),
+    status: (entry.status as string) ?? 'published',
+    ...entry
+  };
+
+  const resolutions: string[] = [];
+
+  for (const [fieldId, meta] of Object.entries(fieldMeta)) {
+    const value = processed[fieldId];
+    if (value === undefined || value === null) continue;
+
+    if (meta.fieldType === 'image' && typeof value === 'string') {
+      const result = resolveAssetRef(value, assetIndex);
+      if (result.resolved) {
+        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;
+        const result = resolveAssetRef(v, assetIndex);
+        if (result.resolved) {
+          resolutions.push(`${fieldId}: "${v}" → ${result.id}`);
+          return result.id;
+        }
+        return v;
+      });
+      processed[fieldId] = JSON.stringify(ids);
+    }
+  }
+
+  return { processed, resolutions };
+}
+
+// ── Batch SQL generation ────────────────────────────────────────────
+
+/**
+ * Generate all INSERT OR REPLACE statements for importing a set of entries
+ * into a table, including join table rows.
+ */
+export function buildImportSql(
+  typeId: string,
+  entries: Record<string, unknown>[],
+  joinTables?: Record<string, 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));
+      }
+    }
+  }
+  return statements;
+}

package/src/rich-text/index.ts

@@ -1,3 +1,4 @@
 export { lexicalToKoguma } from './lexical-to-koguma.ts';
+export { kogumaToLexical } from './koguma-to-lexical.ts';
 export { richTextToPlain } from './plain.ts';
 export type { PlainTextOptions } from './plain.ts';

package/src/rich-text/koguma-to-lexical.ts

@@ -0,0 +1,340 @@
+/**
+ * koguma-to-lexical.ts — Converts KogumaDocument back to Lexical's SerializedEditorState.
+ *
+ * The inverse of lexicalToKoguma(). Used by the seed pipeline to store
+ * content in the format D1/admin expects (Lexical JSON), rather than
+ * the public-API KogumaDocument format.
+ */
+import type {
+  KogumaDocument,
+  KogumaBlockNode,
+  KogumaInlineNode,
+  KogumaListItem
+} from '../config/types.ts';
+
+// ── Lexical format bitmask constants (mirror of lexical-to-koguma.ts) ──
+const IS_BOLD = 1;
+const IS_ITALIC = 2;
+const IS_STRIKETHROUGH = 4;
+const IS_UNDERLINE = 8;
+const IS_CODE = 16;
+const IS_SUBSCRIPT = 32;
+const IS_SUPERSCRIPT = 64;
+
+// ── Output types (Lexical serialized JSON) ──────────────────────────
+
+interface LexicalNode {
+  type: string;
+  version: number;
+  [k: string]: unknown;
+}
+
+// ── Main entry point ────────────────────────────────────────────────
+
+export function kogumaToLexical(doc: KogumaDocument): Record<string, unknown> {
+  return {
+    root: {
+      type: 'root',
+      children: doc.nodes.map(convertBlockNode),
+      direction: 'ltr',
+      format: '',
+      indent: 0,
+      version: 1
+    }
+  };
+}
+
+// ── Block node conversion ────────────────────────────────────────────
+
+function convertBlockNode(node: KogumaBlockNode): LexicalNode {
+  switch (node.type) {
+    case 'paragraph':
+      return {
+        type: 'paragraph',
+        version: 1,
+        children: (node.children ?? []).map(convertInlineNode),
+        direction: 'ltr',
+        format: alignToFormat(node.align),
+        indent: 0,
+        textFormat: 0,
+        textStyle: ''
+      };
+
+    case 'heading':
+      return {
+        type: 'heading',
+        version: 1,
+        tag: `h${node.level ?? 2}`,
+        children: (node.children ?? []).map(convertInlineNode),
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        textFormat: 0,
+        textStyle: ''
+      };
+
+    case 'quote':
+      return {
+        type: 'quote',
+        version: 1,
+        children: [
+          {
+            type: 'paragraph',
+            version: 1,
+            children: (node.children ?? []).map(convertInlineNode),
+            direction: 'ltr',
+            format: '',
+            indent: 0,
+            textFormat: 0,
+            textStyle: ''
+          }
+        ],
+        direction: 'ltr',
+        format: '',
+        indent: 0
+      };
+
+    case 'list':
+      return convertList(node);
+
+    case 'code':
+      return {
+        type: 'code',
+        version: 1,
+        language: node.language ?? null,
+        children: codeTextToHighlightNodes(node.text ?? ''),
+        direction: 'ltr',
+        format: '',
+        indent: 0
+      };
+
+    case 'image':
+      return {
+        type: 'image',
+        version: 1,
+        src: node.url ?? '',
+        altText: node.alt ?? '',
+        width: node.width ?? null,
+        height: node.height ?? null
+      };
+
+    case 'hr':
+      return {
+        type: 'horizontalrule',
+        version: 1
+      };
+
+    case 'table':
+      return convertTable(node);
+
+    case 'layout':
+      return convertLayout(node);
+
+    case 'custom':
+      return {
+        type: node.name ?? 'unknown',
+        version: 1,
+        ...(node.data ?? {})
+      };
+
+    default:
+      return {
+        type: 'paragraph',
+        version: 1,
+        children: [],
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        textFormat: 0,
+        textStyle: ''
+      };
+  }
+}
+
+// ── List conversion ──────────────────────────────────────────────────
+
+function convertList(node: KogumaBlockNode): LexicalNode {
+  const ordered = (node as any).ordered ?? false;
+  const listType = ordered ? 'number' : 'bullet';
+  const items = (node as any).items ?? [];
+
+  return {
+    type: 'list',
+    version: 1,
+    listType,
+    start: 1,
+    tag: ordered ? 'ol' : 'ul',
+    children: items.map((item: KogumaListItem, i: number) =>
+      convertListItem(item, listType, i + 1)
+    ),
+    direction: 'ltr',
+    format: '',
+    indent: 0
+  };
+}
+
+function convertListItem(
+  item: KogumaListItem,
+  listType: string,
+  value: number
+): LexicalNode {
+  const children: LexicalNode[] = (item.children ?? []).map(convertInlineNode);
+
+  if (item.nestedList) {
+    children.push(
+      convertList({
+        type: 'list',
+        ordered: item.nestedList.ordered,
+        items: item.nestedList.items
+      } as any)
+    );
+  }
+
+  return {
+    type: 'listitem',
+    version: 1,
+    value,
+    children,
+    checked: listType === 'check' ? (item.checked ?? false) : undefined,
+    direction: 'ltr',
+    format: '',
+    indent: 0
+  };
+}
+
+// ── Table conversion ─────────────────────────────────────────────────
+
+function convertTable(node: KogumaBlockNode): LexicalNode {
+  const rows = (node as any).rows ?? [];
+  return {
+    type: 'table',
+    version: 1,
+    children: rows.map((row: any) => ({
+      type: 'tablerow',
+      version: 1,
+      key: row.key,
+      children: (row.cells ?? []).map((cell: any) => ({
+        type: 'tablecell',
+        version: 1,
+        key: cell.key,
+        children: (cell.children ?? []).map(convertInlineNode)
+      }))
+    }))
+  };
+}
+
+// ── Layout conversion ────────────────────────────────────────────────
+
+function convertLayout(node: KogumaBlockNode): LexicalNode {
+  const columns = (node as any).columns ?? [];
+  return {
+    type: 'layoutcontainer',
+    version: 1,
+    children: columns.map((col: KogumaBlockNode[]) => ({
+      type: 'layoutitem',
+      version: 1,
+      children: col.map(convertBlockNode)
+    }))
+  };
+}
+
+// ── Inline node conversion ───────────────────────────────────────────
+
+function convertInlineNode(node: KogumaInlineNode): LexicalNode {
+  switch (node.type) {
+    case 'text': {
+      let format = 0;
+      if (node.bold) format |= IS_BOLD;
+      if (node.italic) format |= IS_ITALIC;
+      if (node.underline) format |= IS_UNDERLINE;
+      if (node.strikethrough) format |= IS_STRIKETHROUGH;
+      if (node.code) format |= IS_CODE;
+      if (node.subscript) format |= IS_SUBSCRIPT;
+      if (node.superscript) format |= IS_SUPERSCRIPT;
+
+      return {
+        type: 'text',
+        version: 1,
+        text: node.text ?? '',
+        format,
+        detail: 0,
+        mode: 'normal',
+        style: ''
+      };
+    }
+
+    case 'link':
+      return {
+        type: 'link',
+        version: 1,
+        url: node.url ?? '',
+        target: node.newTab ? '_blank' : null,
+        children: (node.children ?? []).map(convertInlineNode),
+        direction: 'ltr',
+        format: '',
+        indent: 0,
+        rel: null
+      };
+
+    case 'line-break':
+      return {
+        type: 'linebreak',
+        version: 1
+      };
+
+    case 'custom':
+      return {
+        type: node.name ?? 'unknown',
+        version: 1,
+        ...(node.data ?? {})
+      };
+
+    default:
+      return {
+        type: 'text',
+        version: 1,
+        text: (node as any).text ?? '',
+        format: 0,
+        detail: 0,
+        mode: 'normal',
+        style: ''
+      };
+  }
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────
+
+function alignToFormat(align?: string): string | number {
+  switch (align) {
+    case 'left':
+      return 1;
+    case 'center':
+      return 2;
+    case 'right':
+      return 3;
+    case 'justify':
+      return 4;
+    default:
+      return '';
+  }
+}
+
+/** Convert plain code text to Lexical CodeHighlightNode children */
+function codeTextToHighlightNodes(text: string): LexicalNode[] {
+  const lines = text.split('\n');
+  const nodes: LexicalNode[] = [];
+
+  for (let i = 0; i < lines.length; i++) {
+    if (i > 0) {
+      nodes.push({ type: 'linebreak', version: 1 });
+    }
+    nodes.push({
+      type: 'code-highlight',
+      version: 1,
+      text: lines[i]!,
+      highlightType: null
+    });
+  }
+
+  return nodes;
+}