@rimelight/cms 0.0.2 → 0.0.3

package/src/migration-tools.ts

@@ -1,334 +0,0 @@
-import type { BaseBlock, ComponentShowcaseBlock } from "./core/types/blocks.ts"
-
-export interface ComponentReference {
-  componentName: string
-  componentPath: string
-  framework: "astro" | "vue" | "solid"
-  propsConfig: Record<string, string[]> | undefined
-  defaultProps: Record<string, any> | undefined
-  togglingPattern: "icon" | "select-option" | "tab-segmented" | "pill-toggle" | undefined
-  codeExamples: {
-    astro?: string
-    vue?: string
-    solid?: string
-  } | undefined
-  playgroundUrl: string | undefined
-}
-
-export interface MigrationReport {
-  totalFiles: number
-  migratedFiles: number
-  totalComponentShowcases: number
-  migratedComponentShowcases: number
-  errors: string[]
-  warnings: string[]
-}
-
-export interface ValidationResult {
-  valid: boolean
-  errors: string[]
-  warnings: string[]
-}
-
-export class MigrationTools {
-  convertMDXToBlocks(mdxContent: string): BaseBlock[] {
-    const blocks: BaseBlock[] = []
-    const lines = mdxContent.split("\n")
-    let i = 0
-
-    while (i < lines.length) {
-      const line = lines[i] || ""
-      const trimmed = line.trim()
-
-      if (!trimmed) {
-        i++
-        continue
-      }
-
-      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++
-        blocks.push({
-          id: crypto.randomUUID(),
-          type: "CodeBlock",
-          props: {
-            language: lang || "text",
-            code: codeLines.join("\n"),
-            caption: ""
-          }
-        })
-        continue
-      }
-
-      if (trimmed.startsWith("#")) {
-        const match = line.match(/^(#{1,6})\s(.*)$/)
-        if (match) {
-          const level = Math.min(6, Math.max(2, match[1]!.length)) as 2 | 3 | 4 | 5 | 6
-          blocks.push({
-            id: crypto.randomUUID(),
-            type: "SectionBlock",
-            props: {
-              title: match[2] || "",
-              level,
-              description: "",
-              children: []
-            },
-            children: []
-          })
-          i++
-          continue
-        }
-      }
-
-      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)
-        const variant = variantMatch ? (variantMatch[1] || "info").toLowerCase() : "info"
-
-        blocks.push({
-          id: crypto.randomUUID(),
-          type: "CalloutBlock",
-          props: {
-            variant: variant as "info" | "success" | "warning" | "error" | "commentary" | "ideation" | "source",
-            children: []
-          },
-          children: []
-        })
-        continue
-      }
-
-      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 = this.parseMarkdownTable(tableLines.join("\n"))
-        if (tableBlock) {
-          blocks.push(tableBlock)
-          continue
-        }
-      }
-
-      if (trimmed.startsWith("!")) {
-        const imageMatch = trimmed.match(/^!\[([^\]]*)\]\(([^)]+)\)$/)
-        if (imageMatch) {
-          blocks.push({
-            id: crypto.randomUUID(),
-            type: "ImageBlock",
-            props: {
-              alt: imageMatch[1] || "",
-              src: imageMatch[2] || "",
-              caption: ""
-            }
-          })
-          i++
-          continue
-        }
-      }
-
-      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("|"))
-      ) {
-        paragraphLines.push(lines[i] || "")
-        i++
-      }
-
-      if (paragraphLines.length > 0) {
-        blocks.push({
-          id: crypto.randomUUID(),
-          type: "ParagraphBlock",
-          props: {
-            text: { en: paragraphLines.join(" ").trim() }
-          }
-        })
-      } else {
-        i++
-      }
-    }
-
-    return blocks
-  }
-
-  extractComponentReferences(mdxContent: string): ComponentReference[] {
-    const references: ComponentReference[] = []
-    const componentRegex = /<ComponentShowcase[^>]*>/g
-    let match: RegExpExecArray | null
-
-    while ((match = componentRegex.exec(mdxContent)) !== null) {
-      const tag = match[0]
-      const componentNameMatch = tag.match(/componentName=["']([^"']+)["']/)
-      const componentPathMatch = tag.match(/componentPath=["']([^"']+)["']/)
-      const frameworkMatch = tag.match(/framework=["']([^"']+)["']/)
-      const propsConfigMatch = tag.match(/propsConfig=\{\{([^}]+)\}\}/)
-      const defaultPropsMatch = tag.match(/defaultProps=\{\{([^}]+)\}\}/)
-      const togglingPatternMatch = tag.match(/togglingPattern=["']([^"']+)["']/)
-
-      references.push({
-        componentName: componentNameMatch?.[1] || "unknown",
-        componentPath: componentPathMatch?.[1] || "",
-        framework: (frameworkMatch?.[1] as "astro" | "vue" | "solid") || "astro",
-        propsConfig: propsConfigMatch?.[1] ? this.parseSimpleObject(propsConfigMatch[1]) : undefined,
-        defaultProps: defaultPropsMatch?.[1] ? this.parseSimpleObject(defaultPropsMatch[1]) : undefined,
-        togglingPattern: togglingPatternMatch?.[1] as "icon" | "select-option" | "tab-segmented" | "pill-toggle" || "tab-segmented",
-        codeExamples: undefined,
-        playgroundUrl: undefined
-      })
-    }
-
-    return references
-  }
-
-  validateMigratedContent(blocks: BaseBlock[]): ValidationResult {
-    const errors: string[] = []
-    const warnings: string[] = []
-
-    const seenIds = new Set<string>()
-    const blockCounts: Record<string, number> = {}
-
-    function checkBlocks(nodes: BaseBlock[]) {
-      for (const b of nodes) {
-        if (!b.id || typeof b.id !== "string") {
-          errors.push(`Block of type '${b.type}' missing id`)
-        } else if (seenIds.has(b.id)) {
-          warnings.push(`Duplicate block id: ${b.id}`)
-        } else {
-          seenIds.add(b.id)
-        }
-
-        if (!b.type || typeof b.type !== "string") {
-          errors.push("Block missing valid 'type' field")
-        }
-
-        blockCounts[b.type] = (blockCounts[b.type] || 0) + 1
-
-        if (b.children && Array.isArray(b.children)) {
-          checkBlocks(b.children)
-        }
-      }
-    }
-
-    checkBlocks(blocks)
-
-    return {
-      valid: errors.length === 0,
-      errors,
-      warnings
-    }
-  }
-
-  generateMigrationReport(original: string, migrated: BaseBlock[]): MigrationReport {
-    const componentRefs = this.extractComponentReferences(original)
-    const validation = this.validateMigratedContent(migrated)
-
-    return {
-      totalFiles: 1,
-      migratedFiles: validation.valid ? 1 : 0,
-      totalComponentShowcases: componentRefs.length,
-      migratedComponentShowcases: componentRefs.length,
-      errors: validation.errors,
-      warnings: validation.warnings
-    }
-  }
-
-  convertComponentShowcaseToBlock(ref: ComponentReference): ComponentShowcaseBlock {
-    return {
-      id: crypto.randomUUID(),
-      type: "ComponentShowcaseBlock",
-      props: {
-        componentName: ref.componentName,
-        componentPath: ref.componentPath,
-        framework: ref.framework,
-        defaultProps: ref.defaultProps || {},
-        propsConfig: ref.propsConfig || {},
-        togglingPattern: ref.togglingPattern || "tab-segmented",
-        codeExamples: ref.codeExamples || {},
-        playgroundUrl: ref.playgroundUrl
-      },
-      children: []
-    }
-  }
-
-  private parseSimpleObject(str: string): Record<string, any> {
-    try {
-      return new Function(`return ${str}`)()
-    } catch {
-      return {}
-    }
-  }
-
-  private 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] || "")
-
-    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: crypto.randomUUID(),
-      type: "TableBlock",
-      props: {
-        columns,
-        rows,
-        caption: ""
-      }
-    }
-  }
-}

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/schema/component_dependencies.ts

@@ -1,21 +0,0 @@
-import { pgTable, text, uuid, uniqueIndex } from "drizzle-orm/pg-core"
-
-export const componentDependencies = pgTable(
-  "component_dependencies",
-  {
-    id: uuid("id").defaultRandom().notNull().primaryKey(),
-    sourceComponent: text("source_component").notNull(),
-    targetComponent: text("target_component").notNull(),
-    dependencyType: text("dependency_type").notNull()
-  },
-  (table) => [
-    uniqueIndex("component_dependencies_unique_idx").on(
-      table.sourceComponent,
-      table.targetComponent,
-      table.dependencyType
-    )
-  ]
-)
-
-export type ComponentDependency = typeof componentDependencies.$inferSelect
-export type NewComponentDependency = typeof componentDependencies.$inferInsert

package/src/schema/component_metadata.ts

@@ -1,31 +0,0 @@
-import {
-  pgTable,
-  text,
-  timestamp,
-  uuid,
-  uniqueIndex,
-  jsonb
-} from "drizzle-orm/pg-core"
-
-export const componentMetadata = pgTable(
-  "component_metadata",
-  {
-    id: uuid("id").defaultRandom().notNull().primaryKey(),
-    componentName: text("component_name").notNull(),
-    version: text("version").notNull(),
-    framework: text("framework").notNull(),
-    filePath: text("file_path").notNull(),
-    props: jsonb("props").$type<Record<string, any>>().notNull(),
-    slots: jsonb("slots").$type<Record<string, any>>().notNull(),
-    emits: jsonb("emits").$type<Record<string, any>>().notNull(),
-    theme: jsonb("theme").$type<Record<string, any>>(),
-    extractedAt: timestamp("extracted_at", { withTimezone: true }).defaultNow().notNull(),
-    updatedAt: timestamp("updated_at", { withTimezone: true }).$onUpdate(() => new Date())
-  },
-  (table) => [
-    uniqueIndex("component_metadata_name_version_idx").on(table.componentName, table.version)
-  ]
-)
-
-export type ComponentMetadata = typeof componentMetadata.$inferSelect
-export type NewComponentMetadata = typeof componentMetadata.$inferInsert

package/src/schema/component_metadata_cache.ts

@@ -1,15 +0,0 @@
-import { pgTable, text, timestamp, jsonb, index } from "drizzle-orm/pg-core"
-
-export const componentMetadataCache = pgTable(
-  "component_metadata_cache",
-  {
-    componentName: text("component_name").primaryKey(),
-    metadata: jsonb("metadata").$type<Record<string, any>>().notNull(),
-    cacheKey: text("cache_key").notNull(),
-    expiresAt: timestamp("expires_at", { withTimezone: true }).notNull()
-  },
-  (table) => [index("component_metadata_cache_expires_idx").on(table.expiresAt)]
-)
-
-export type ComponentMetadataCache = typeof componentMetadataCache.$inferSelect
-export type NewComponentMetadataCache = typeof componentMetadataCache.$inferInsert

package/src/schema/component_versions.ts

@@ -1,19 +0,0 @@
-import { pgTable, text, timestamp, uuid, uniqueIndex } from "drizzle-orm/pg-core"
-
-export const componentVersions = pgTable(
-  "component_versions",
-  {
-    id: uuid("id").defaultRandom().notNull().primaryKey(),
-    componentName: text("component_name").notNull(),
-    version: text("version").notNull(),
-    filePath: text("file_path").notNull(),
-    gitCommit: text("git_commit"),
-    extractedAt: timestamp("extracted_at", { withTimezone: true }).defaultNow().notNull()
-  },
-  (table) => [
-    uniqueIndex("component_versions_name_version_idx").on(table.componentName, table.version)
-  ]
-)
-
-export type ComponentVersion = typeof componentVersions.$inferSelect
-export type NewComponentVersion = typeof componentVersions.$inferInsert

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(" ")
-}