@rimelight/cms 0.0.1 → 0.0.3

package/src/markdown/parser.ts

@@ -1,347 +0,0 @@
-import type { BaseBlock, HeadingLevel } from "../core/types/blocks"
-import type { InlineNode } from "../core/types/inline"
-
-function genId(): string {
-  return typeof crypto !== "undefined" && crypto.randomUUID
-    ? crypto.randomUUID()
-    : Math.random().toString(36).slice(2, 11)
-}
-
-export function parseInlines(text: string): InlineNode[] {
-  if (!text) return []
-
-  const inlines: InlineNode[] = []
-  // Regex to match markdown links: [text](url)
-  const linkRegex = /\[([^\]]+)\]\(([^)]+)\)/g
-  let lastIndex = 0
-  let match: RegExpExecArray | null
-
-  while ((match = linkRegex.exec(text)) !== null) {
-    const beforeText = text.substring(lastIndex, match.index)
-    if (beforeText) {
-      inlines.push(...parseFormattedText(beforeText))
-    }
-
-    const linkText = match[1] || ""
-    const linkUrl = match[2] || ""
-
-    inlines.push({
-      type: "link",
-      url: linkUrl,
-      children: [{ type: "text", text: linkText }]
-    })
-
-    lastIndex = linkRegex.lastIndex
-  }
-
-  const remainingText = text.substring(lastIndex)
-  if (remainingText) {
-    inlines.push(...parseFormattedText(remainingText))
-  }
-
-  return inlines.length > 0 ? inlines : [{ type: "text", text }]
-}
-
-function parseFormattedText(str: string): InlineNode[] {
-  if (!str) return []
-
-  // Tokenize bold, italic, code marks
-  // Format: `code`, **bold**, *italic*, ~~strikethrough~~
-  const result: InlineNode[] = []
-  const tokenRegex = /(`[^`]+`|\*\*[^*]+\*\*|\*[^*]+\*|~~[^~]+~~)/g
-  let lastIdx = 0
-  let match: RegExpExecArray | null
-
-  while ((match = tokenRegex.exec(str)) !== null) {
-    const rawBefore = str.substring(lastIdx, match.index)
-    if (rawBefore) {
-      result.push({ type: "text", text: rawBefore })
-    }
-
-    const token = match[1] || ""
-    if (token.startsWith("`") && token.endsWith("`")) {
-      result.push({
-        type: "text",
-        text: token.slice(1, -1),
-        marks: ["code"]
-      })
-    } else if (token.startsWith("**") && token.endsWith("**")) {
-      result.push({
-        type: "text",
-        text: token.slice(2, -2),
-        marks: ["bold"]
-      })
-    } else if (token.startsWith("*") && token.endsWith("*")) {
-      result.push({
-        type: "text",
-        text: token.slice(1, -1),
-        marks: ["italic"]
-      })
-    } else if (token.startsWith("~~") && token.endsWith("~~")) {
-      result.push({
-        type: "text",
-        text: token.slice(2, -2),
-        marks: ["strikethrough"]
-      })
-    }
-
-    lastIdx = tokenRegex.lastIndex
-  }
-
-  const remaining = str.substring(lastIdx)
-  if (remaining) {
-    result.push({ type: "text", text: remaining })
-  }
-
-  return result
-}
-
-export function parseMarkdownTable(tableText: string): BaseBlock | null {
-  const lines = tableText
-    .trim()
-    .split("\n")
-    .map((l) => l.trim())
-    .filter(Boolean)
-  if (lines.length < 2) return null
-
-  const parseRow = (line: string) =>
-    line
-      .replace(/^\|/, "")
-      .replace(/\|$/, "")
-      .split("|")
-      .map((c) => c.trim())
-
-  const headerCells = parseRow(lines[0] || "")
-  const alignCells = parseRow(lines[1] || "")
-
-  // Verify second line is alignment separator (e.g. ---, :---:, ---:)
-  if (!alignCells.every((c) => /^[:-]+$/.test(c))) {
-    return null
-  }
-
-  const columns = headerCells.map((header, idx) => {
-    const alignStr = alignCells[idx] || ""
-    let align: "left" | "center" | "right" = "left"
-    if (alignStr.startsWith(":") && alignStr.endsWith(":")) {
-      align = "center"
-    } else if (alignStr.endsWith(":")) {
-      align = "right"
-    }
-    return {
-      key: `col_${idx}`,
-      header,
-      align
-    }
-  })
-
-  const rows: Record<string, string>[] = []
-  for (let i = 2; i < lines.length; i++) {
-    const cells = parseRow(lines[i] || "")
-    const rowObj: Record<string, string> = {}
-    columns.forEach((col, idx) => {
-      rowObj[col.key] = cells[idx] || ""
-    })
-    rows.push(rowObj)
-  }
-
-  return {
-    id: genId(),
-    type: "TableBlock",
-    props: {
-      columns,
-      rows,
-      caption: ""
-    }
-  }
-}
-
-export function markdownToBlocks(markdown: string): BaseBlock[] {
-  if (!markdown) return []
-
-  // Strip frontmatter if present
-  let cleanMd = markdown.trim()
-  if (cleanMd.startsWith("---")) {
-    const endFm = cleanMd.indexOf("---", 3)
-    if (endFm !== -1) {
-      cleanMd = cleanMd.substring(endFm + 3).trim()
-    }
-  }
-
-  const rootBlocks: BaseBlock[] = []
-  const sectionStack: { level: number; block: BaseBlock }[] = []
-
-  const appendToCurrentScope = (block: BaseBlock) => {
-    if (sectionStack.length > 0) {
-      const topSection = sectionStack[sectionStack.length - 1]!.block
-      if (!topSection.children) topSection.children = []
-      if (!topSection.props.children) topSection.props.children = []
-      topSection.children.push(block)
-      topSection.props.children.push(block)
-    } else {
-      rootBlocks.push(block)
-    }
-  }
-
-  const lines = cleanMd.split("\n")
-  let i = 0
-
-  while (i < lines.length) {
-    const line = lines[i] || ""
-    const trimmed = line.trim()
-
-    if (!trimmed) {
-      i++
-      continue
-    }
-
-    // 1. Code Block Fence (```)
-    if (trimmed.startsWith("```")) {
-      const lang = trimmed.slice(3).trim()
-      const codeLines: string[] = []
-      i++
-      while (i < lines.length && !(lines[i] || "").trim().startsWith("```")) {
-        codeLines.push(lines[i] || "")
-        i++
-      }
-      i++ // Skip closing ```
-      appendToCurrentScope({
-        id: genId(),
-        type: "CodeBlock",
-        props: {
-          language: lang || "text",
-          code: codeLines.join("\n"),
-          caption: ""
-        }
-      })
-      continue
-    }
-
-    // 2. Headings (# to ######)
-    const headingMatch = line.match(/^(#{1,6})\s(.*)$/)
-    if (headingMatch) {
-      const hashes = headingMatch[1] || ""
-      const title = (headingMatch[2] || "").trim()
-      const level = Math.min(6, Math.max(2, hashes.length)) as HeadingLevel
-
-      const newSection: BaseBlock = {
-        id: genId(),
-        type: "SectionBlock",
-        children: [],
-        props: {
-          title,
-          level,
-          description: "",
-          children: []
-        }
-      }
-
-      // Pop sections with higher or equal level
-      while (sectionStack.length > 0 && sectionStack[sectionStack.length - 1]!.level >= level) {
-        sectionStack.pop()
-      }
-
-      appendToCurrentScope(newSection)
-      sectionStack.push({ level, block: newSection })
-      i++
-      continue
-    }
-
-    // 3. Callouts / Blockquotes (> [!NOTE], > [!WARNING], > etc.)
-    if (trimmed.startsWith(">")) {
-      const calloutLines: string[] = []
-      while (i < lines.length && (lines[i] || "").trim().startsWith(">")) {
-        calloutLines.push((lines[i] || "").trim().replace(/^>\s?/, ""))
-        i++
-      }
-      const firstLine = calloutLines[0] || ""
-      const variantMatch = firstLine.match(/^\[!([A-Z]+)\]/i)
-      let variant = "info"
-      let contentLines = calloutLines
-
-      if (variantMatch) {
-        variant = (variantMatch[1] || "info").toLowerCase()
-        contentLines = calloutLines.slice(1)
-      }
-
-      const childMd = contentLines.join("\n").trim()
-      const calloutChildren = childMd ? markdownToBlocks(childMd) : []
-
-      appendToCurrentScope({
-        id: genId(),
-        type: "CalloutBlock",
-        children: calloutChildren,
-        props: {
-          variant,
-          children: calloutChildren
-        }
-      })
-      continue
-    }
-
-    // 4. Markdown Table (| Header | Header |)
-    if (trimmed.startsWith("|") && trimmed.endsWith("|")) {
-      const tableLines: string[] = []
-      while (
-        i < lines.length &&
-        (lines[i] || "").trim().startsWith("|") &&
-        (lines[i] || "").trim().endsWith("|")
-      ) {
-        tableLines.push(lines[i] || "")
-        i++
-      }
-      const tableBlock = parseMarkdownTable(tableLines.join("\n"))
-      if (tableBlock) {
-        appendToCurrentScope(tableBlock)
-        continue
-      }
-    }
-
-    // 5. Image (![alt](src))
-    const imageMatch = trimmed.match(/^!\[([^\]]*)\]\(([^)]+)\)$/)
-    if (imageMatch) {
-      appendToCurrentScope({
-        id: genId(),
-        type: "ImageBlock",
-        props: {
-          alt: imageMatch[1] || "",
-          src: imageMatch[2] || "",
-          caption: ""
-        }
-      })
-      i++
-      continue
-    }
-
-    // 6. Regular Paragraph (gather lines until blank line or block start)
-    const paragraphLines: string[] = []
-    while (
-      i < lines.length &&
-      (lines[i] || "").trim() &&
-      !(lines[i] || "").trim().startsWith("```") &&
-      !(lines[i] || "").trim().startsWith("#") &&
-      !(lines[i] || "").trim().startsWith(">") &&
-      !((lines[i] || "").trim().startsWith("|") && (lines[i] || "").trim().endsWith("|")) &&
-      !/^[0-9]+\.\s/.test((lines[i] || "").trim())
-    ) {
-      paragraphLines.push(lines[i] || "")
-      i++
-    }
-
-    if (paragraphLines.length > 0) {
-      const paragraphText = paragraphLines.join(" ").trim()
-      const inlines = parseInlines(paragraphText)
-      appendToCurrentScope({
-        id: genId(),
-        type: "ParagraphBlock",
-        props: {
-          text: inlines
-        }
-      })
-    } else {
-      // Advance if no block consumed
-      i++
-    }
-  }
-
-  return rootBlocks
-}

package/src/migration.ts

@@ -1,155 +0,0 @@
-import { sql } from "drizzle-orm"
-import { markdownToBlocks } from "./markdown/parser.ts"
-import type { BaseBlock } from "./core/types/blocks"
-
-export interface DocMigrationInput {
-  slug: string
-  title: string | Record<string, string>
-  description?: string | Record<string, string>
-  markdown: string
-  properties?: Record<string, any>
-  postedAt?: Date | null
-  authorIds?: string[]
-}
-
-export function parseMarkdownWithFrontmatter(raw: string): {
-  frontmatter: Record<string, any>
-  body: string
-} {
-  const frontmatter: Record<string, any> = {}
-  const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/)
-
-  if (!match) {
-    return { frontmatter, body: raw.trim() }
-  }
-
-  const yamlBlock = match[1] || ""
-  const body = (match[2] || "").trim()
-
-  const lines = yamlBlock.split(/\r?\n/)
-  for (const line of lines) {
-    const trimmed = line.trim()
-    if (!trimmed || trimmed.startsWith("#")) continue
-    const colonIndex = trimmed.indexOf(":")
-    if (colonIndex !== -1) {
-      const key = trimmed.slice(0, colonIndex).trim()
-      let value: any = trimmed.slice(colonIndex + 1).trim()
-
-      if (value === "true") value = true
-      else if (value === "false") value = false
-      else if (value === "null") value = null
-      else if (!isNaN(Number(value)) && value !== "") value = Number(value)
-      else if (
-        (value.startsWith('"') && value.endsWith('"')) ||
-        (value.startsWith("'") && value.endsWith("'"))
-      ) {
-        value = value.slice(1, -1)
-      }
-
-      frontmatter[key] = value
-    }
-  }
-
-  return { frontmatter, body }
-}
-
-export function convertMarkdownDocToPageRecord(input: DocMigrationInput) {
-  const blocks: BaseBlock[] = markdownToBlocks(input.markdown)
-  const titleObj =
-    typeof input.title === "string" ? { en: input.title } : input.title || { en: input.slug }
-  const descObj =
-    typeof input.description === "string"
-      ? { en: input.description }
-      : input.description || undefined
-
-  return {
-    id: crypto.randomUUID(),
-    slug: input.slug,
-    type: "doc" as const,
-    title: titleObj,
-    description: descObj,
-    tags: [],
-    authorIds: input.authorIds || [],
-    postedAt: input.postedAt !== undefined ? input.postedAt : new Date(),
-    createdAt: new Date(),
-    updatedAt: new Date(),
-    content: {
-      blocks,
-      properties: input.properties || {}
-    }
-  }
-}
-
-export async function migrateLegacyPagesToCMSv2(db: any) {
-  console.log("[Migration] Applying DDL schema updates...")
-
-  await db.execute(sql`
-    ALTER TABLE pages ADD COLUMN IF NOT EXISTS template_id UUID;
-    ALTER TABLE pages ADD COLUMN IF NOT EXISTS template_version INTEGER DEFAULT 1 NOT NULL;
-    ALTER TABLE page_versions ADD COLUMN IF NOT EXISTS version_number INTEGER DEFAULT 1 NOT NULL;
-
-    CREATE UNIQUE INDEX IF NOT EXISTS page_versions_page_id_version_idx
-    ON page_versions (page_id, version_number);
-  `)
-
-  console.log("[Migration] Transforming legacy page content in chunked batches...")
-
-  const BATCH_SIZE = 100
-  let offset = 0
-
-  async function fetchBatch(currentOffset: number) {
-    const batch = await db.execute(sql`
-      SELECT id, content FROM pages ORDER BY id LIMIT ${BATCH_SIZE} OFFSET ${currentOffset};
-    `)
-
-    if (!batch || !batch.rows || batch.rows.length === 0) {
-      return null
-    }
-
-    const rows: Array<{ id: string; content: unknown }> = batch.rows
-    return rows
-  }
-
-  async function processBatch(pagesList: Array<{ id: string; content: unknown }>) {
-    const updatePromises = pagesList.map((page) => {
-      const transformed = transformLegacyContent(page.content)
-      return db.execute(sql`
-        UPDATE pages SET content = ${JSON.stringify(transformed)}::jsonb WHERE id = ${page.id}::uuid;
-      `)
-    })
-
-    await Promise.all(updatePromises)
-  }
-
-  async function processAllBatches(currentOffset: number): Promise<void> {
-    const pagesList = await fetchBatch(currentOffset)
-    if (!pagesList) return
-    await processBatch(pagesList)
-    console.log(`[Migration] Migrated ${currentOffset + BATCH_SIZE} records...`)
-    return processAllBatches(currentOffset + BATCH_SIZE)
-  }
-
-  await processAllBatches(offset)
-
-  console.log("[Migration] Migration completed successfully.")
-}
-
-export function transformLegacyContent(raw: unknown) {
-  if (typeof raw === "object" && raw !== null && "blocks" in raw) return raw
-  let textContent = ""
-  try {
-    textContent = typeof raw === "string" ? raw : JSON.stringify(raw ?? "")
-  } catch {
-    textContent = ""
-  }
-  return {
-    blocks: [
-      {
-        id: crypto.randomUUID(),
-        type: "ParagraphBlock",
-        props: { text: { en: textContent } }
-      }
-    ],
-    properties: {}
-  }
-}

package/src/search/sync.ts

@@ -1,32 +0,0 @@
-import type { BaseBlock } from "../core/types/blocks"
-
-export function extractPlainTextFromBlocks(blocks: BaseBlock[], locale = "en"): string {
-  const parts: string[] = []
-
-  function walk(nodes: BaseBlock[]) {
-    for (const node of nodes) {
-      if (node.props) {
-        if (typeof node.props.text === "object" && node.props.text !== null) {
-          const locText = node.props.text[locale] || node.props.text.en
-          if (locText) parts.push(String(locText))
-        } else if (typeof node.props.text === "string") {
-          parts.push(node.props.text)
-        }
-
-        if (typeof node.props.title === "object" && node.props.title !== null) {
-          const locTitle = node.props.title[locale] || node.props.title.en
-          if (locTitle) parts.push(String(locTitle))
-        } else if (typeof node.props.title === "string") {
-          parts.push(node.props.title)
-        }
-      }
-
-      if (node.children?.length) {
-        walk(node.children)
-      }
-    }
-  }
-
-  walk(blocks)
-  return parts.join(" ")
-}