@rimelight/cms 0.0.2 → 0.0.4

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

package/src/services/component-metadata.ts

@@ -1,134 +0,0 @@
-import { eq, desc } from "drizzle-orm"
-import type {
-  NewComponentMetadata
-} from "../schema/index.ts"
-
-export interface ComponentMeta {
-  componentName: string
-  version: string
-  framework: string
-  filePath: string
-  props: Record<string, any>
-  slots: Record<string, any>
-  emits: Record<string, any>
-  theme?: Record<string, any>
-}
-
-export interface ComponentDependencyRecord {
-  sourceComponent: string
-  targetComponent: string
-  dependencyType: "uses" | "extends" | "related"
-}
-
-export class ComponentMetadataService {
-  constructor(private db: any) {}
-
-  async extractMetadata(componentPath: string): Promise<ComponentMeta> {
-    const props: Record<string, any> = {}
-    const slots: Record<string, any> = {}
-    const emits: Record<string, any> = {}
-
-    try {
-      const content = await this.readComponentFile(componentPath)
-      props.raw = content
-      props.extractedAt = new Date().toISOString()
-    } catch (e) {
-      console.warn(`Failed to read component file: ${componentPath}`, e)
-    }
-
-    return {
-      componentName: componentPath.split("/").pop()?.replace(/\.[^/.]+$/, "") || "unknown",
-      version: "latest",
-      framework: "astro",
-      filePath: componentPath,
-      props,
-      slots,
-      emits
-    }
-  }
-
-  async storeMetadata(metadata: ComponentMeta): Promise<void> {
-    const record: NewComponentMetadata = {
-      componentName: metadata.componentName,
-      version: metadata.version,
-      framework: metadata.framework,
-      filePath: metadata.filePath,
-      props: metadata.props,
-      slots: metadata.slots,
-      emits: metadata.emits,
-      theme: metadata.theme || {}
-    }
-
-    await this.db.insert(this.db.componentMetadata).values(record).onConflictDoUpdate({
-      target: [this.db.componentMetadata.componentName, this.db.componentMetadata.version],
-      set: {
-        framework: record.framework,
-        filePath: record.filePath,
-        props: record.props,
-        slots: record.slots,
-        emits: record.emits,
-        theme: record.theme,
-        updatedAt: new Date()
-      }
-    })
-  }
-
-  async getMetadata(componentName: string): Promise<ComponentMeta | null> {
-    const result = await this.db
-      .select()
-      .from(this.db.componentMetadata)
-      .where(eq(this.db.componentMetadata.componentName, componentName))
-      .orderBy(desc(this.db.componentMetadata.extractedAt))
-      .limit(1)
-
-    if (!result[0]) return null
-
-    const row = result[0]
-    return {
-      componentName: row.componentName,
-      version: row.version,
-      framework: row.framework,
-      filePath: row.filePath,
-      props: row.props,
-      slots: row.slots,
-      emits: row.emits,
-      theme: row.theme
-    }
-  }
-
-  async updateMetadata(componentName: string): Promise<void> {
-    const metadata = await this.getMetadata(componentName)
-    if (!metadata) return
-
-    const freshMeta = await this.extractMetadata(metadata.filePath)
-    await this.storeMetadata(freshMeta)
-  }
-
-  async getDependencies(componentName: string): Promise<ComponentDependencyRecord[]> {
-    const result = await this.db
-      .select()
-      .from(this.db.componentDependencies)
-      .where(eq(this.db.componentDependencies.sourceComponent, componentName))
-
-    return result.map((row: any) => ({
-      sourceComponent: row.sourceComponent,
-      targetComponent: row.targetComponent,
-      dependencyType: row.dependencyType as "uses" | "extends" | "related"
-    }))
-  }
-
-  async invalidateCache(componentName: string): Promise<void> {
-    await this.db
-      .delete(this.db.componentMetadataCache)
-      .where(eq(this.db.componentMetadataCache.componentName, componentName))
-  }
-
-  private async readComponentFile(path: string): Promise<string> {
-    try {
-      const fs = await import("fs")
-      return fs.readFileSync(path, "utf-8")
-    } catch {
-      return ""
-    }
-  }
-}