@rimelight/cms 0.0.1

package/src/migration.ts

@@ -0,0 +1,155 @@
+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/index.ts

@@ -0,0 +1,8 @@
+export * from "./pages.ts"
+export * from "./page_drafts.ts"
+export * from "./page_draft_locks.ts"
+export * from "./page_versions.ts"
+export * from "./page_version_comments.ts"
+export * from "./page_version_approvals.ts"
+export * from "./page_templates.ts"
+export * from "./search.ts"

package/src/schema/page_draft_locks.ts

@@ -0,0 +1,13 @@
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import { pages } from "./pages.ts"
+
+export const pageDraftLocks = pgTable("page_draft_locks", {
+  pageId: uuid("page_id")
+    .notNull()
+    .primaryKey()
+    .references(() => pages.id, { onDelete: "cascade" }),
+  lockedByUserId: text("locked_by_user_id").notNull(),
+  lockedByUserName: text("locked_by_user_name").notNull(),
+  acquiredAt: timestamp("acquired_at", { withTimezone: true }).defaultNow().notNull(),
+  expiresAt: timestamp("expires_at", { withTimezone: true }).notNull()
+})

package/src/schema/page_drafts.ts

@@ -0,0 +1,18 @@
+import { jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import { pages } from "./pages.ts"
+import type { BaseBlock } from "../core/types/blocks"
+
+export const pageDrafts = pgTable("page_drafts", {
+  pageId: uuid("page_id")
+    .notNull()
+    .primaryKey()
+    .references(() => pages.id, { onDelete: "cascade" }),
+  content: jsonb("content")
+    .$type<{
+      blocks: BaseBlock[]
+      properties: Record<string, any>
+    }>()
+    .notNull(),
+  updatedBy: text("updated_by").notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).defaultNow().notNull()
+})

package/src/schema/page_templates.ts

@@ -0,0 +1,27 @@
+import { integer, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import type { BaseBlock } from "../core/types/blocks"
+import type { Localized, PageType } from "../core/types/pages"
+import type { TemplateApprovalRules, TemplateRolePermissions } from "../core/types/templates"
+
+export const pageTemplates = pgTable("page_templates", {
+  id: uuid("id").defaultRandom().notNull().primaryKey(),
+  slug: text("slug").notNull().unique(),
+  title: jsonb("title").$type<Localized>().notNull(),
+  description: jsonb("description").$type<Localized>(),
+  pageType: text("page_type").$type<PageType>().notNull(),
+  version: integer("version").default(1).notNull(),
+  allowedRoles: jsonb("allowed_roles").$type<string[]>().default([]).notNull(),
+  rolePermissions: jsonb("role_permissions")
+    .$type<TemplateRolePermissions>()
+    .default({ whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] })
+    .notNull(),
+  requiredPermission: text("required_permission"),
+  approvalRules: jsonb("approval_rules")
+    .$type<TemplateApprovalRules>()
+    .default({ allowSelfApproval: true, minApprovals: 1 })
+    .notNull(),
+  defaultProperties: jsonb("default_properties").default({}).notNull(),
+  initialBlocks: jsonb("initial_blocks").$type<BaseBlock[]>().default([]).notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).$onUpdate(() => new Date())
+})

package/src/schema/page_version_approvals.ts

@@ -0,0 +1,12 @@
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import { pageVersions } from "./page_versions.ts"
+
+export const pageVersionApprovals = pgTable("page_version_approvals", {
+  id: uuid("id").defaultRandom().notNull().primaryKey(),
+  versionId: uuid("version_id")
+    .notNull()
+    .references(() => pageVersions.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull(),
+  userRole: text("user_role").notNull(),
+  approvedAt: timestamp("approved_at", { withTimezone: true }).defaultNow().notNull()
+})

package/src/schema/page_version_comments.ts

@@ -0,0 +1,14 @@
+import { pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import { pageVersions } from "./page_versions.ts"
+
+export const pageVersionComments = pgTable("page_version_comments", {
+  id: uuid("id").defaultRandom().notNull().primaryKey(),
+  versionId: uuid("version_id")
+    .notNull()
+    .references(() => pageVersions.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull(),
+  userRole: text("user_role").notNull(),
+  content: text("content").notNull(),
+  blockId: text("block_id"),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+})

package/src/schema/page_versions.ts

@@ -0,0 +1,34 @@
+import { integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core"
+import type { BaseBlock } from "../core/types/blocks"
+import type { Localized, PageType } from "../core/types/pages"
+import type { PageVersionStatus } from "../core/types/versioning"
+
+export const pageVersions = pgTable(
+  "page_versions",
+  {
+    id: uuid("id").defaultRandom().notNull().primaryKey(),
+    pageId: uuid("page_id").notNull(),
+    versionNumber: integer("version_number").notNull(),
+    status: text("status").$type<PageVersionStatus>().default("pending").notNull(),
+    slug: text("slug").notNull(),
+    type: text("type").$type<PageType>().notNull(),
+    title: jsonb("title").$type<Localized>().notNull(),
+    description: jsonb("description").$type<Localized>(),
+    tags: jsonb("tags").$type<Localized[]>().default([]).notNull(),
+    authorIds: jsonb("author_ids").$type<string[]>().default([]),
+    content: jsonb("content")
+      .$type<{
+        blocks: BaseBlock[]
+        properties: Record<string, any>
+      }>()
+      .notNull(),
+    createdBy: text("created_by").notNull(),
+    approvedBy: jsonb("approved_by").$type<string[]>().default([]).notNull(),
+    approvedAt: timestamp("approved_at", { withTimezone: true }),
+    changeSummary: text("change_summary"),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull()
+  },
+  (table) => [
+    uniqueIndex("page_versions_page_id_version_idx").on(table.pageId, table.versionNumber)
+  ]
+)

package/src/schema/pages.ts

@@ -0,0 +1,42 @@
+import { sql } from "drizzle-orm"
+import { integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "drizzle-orm/pg-core"
+import type { BaseBlock } from "../core/types/blocks"
+import type { Localized, PageType } from "../core/types/pages"
+import { pageVersions } from "./page_versions.ts"
+import { pageTemplates } from "./page_templates.ts"
+
+export const pages = pgTable(
+  "pages",
+  {
+    id: uuid("id").defaultRandom().notNull().primaryKey(),
+    slug: text("slug").notNull(),
+    type: text("type").$type<PageType>().notNull(),
+    templateId: uuid("template_id").references(() => pageTemplates.id, { onDelete: "set null" }),
+    templateVersion: integer("template_version").default(1).notNull(),
+    title: jsonb("title").$type<Localized>().notNull(),
+    description: jsonb("description").$type<Localized>(),
+    tags: jsonb("tags").$type<Localized[]>().default([]).notNull(),
+    authorIds: jsonb("author_ids").$type<string[]>().default([]),
+    /**
+     * Denormalized read-cache of the active published version content (NULL if unpublished draft)
+     */
+    content: jsonb("content")
+      .$type<{
+        blocks: BaseBlock[]
+        properties: Record<string, any>
+      }>()
+      .notNull(),
+    publishedVersionId: uuid("published_version_id").references(() => pageVersions.id, {
+      onDelete: "set null"
+    }),
+    postedAt: timestamp("posted_at", { withTimezone: true }),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).$onUpdate(() => new Date()),
+    deletedAt: timestamp("deleted_at", { withTimezone: true })
+  },
+  (table) => [
+    uniqueIndex("pages_slug_active_unique_idx")
+      .on(table.slug)
+      .where(sql`deleted_at IS NULL`)
+  ]
+)

package/src/schema/search.ts

@@ -0,0 +1,23 @@
+import { customType, index, pgTable, text, uuid } from "drizzle-orm/pg-core"
+import { pages } from "./pages.ts"
+
+const tsvector = customType<{ data: string }>({
+  dataType() {
+    return "tsvector"
+  }
+})
+
+export const contentSearchIndex = pgTable(
+  "content_search_index",
+  {
+    id: uuid("id").defaultRandom().notNull().primaryKey(),
+    pageId: uuid("page_id")
+      .notNull()
+      .references(() => pages.id, { onDelete: "cascade" }),
+    locale: text("locale").notNull(),
+    titleText: text("title_text").notNull(),
+    contentText: text("content_text").notNull(),
+    searchVector: tsvector("search_vector")
+  },
+  (table) => [index("search_vector_gin_idx").using("gin", table.searchVector)]
+)

package/src/search/query.ts

@@ -0,0 +1,10 @@
+export const POSTGRES_SEARCH_CONFIGS: Record<string, string> = {
+  en: "english",
+  es: "spanish",
+  de: "german",
+  fr: "french"
+}
+
+export function getPostgresSearchConfig(locale: string): string {
+  return POSTGRES_SEARCH_CONFIGS[locale] || "simple"
+}

package/src/search/sync.ts

@@ -0,0 +1,32 @@
+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(" ")
+}