@rimelight/cms 0.0.2 → 0.0.3

package/src/loader/live.ts

@@ -0,0 +1,254 @@
+import { and, desc, eq, isNotNull, isNull, lte, sql, type SQL } from "drizzle-orm"
+import { pages } from "../schema/pages.ts"
+import { createPageExcerpt } from "../core/excerpt.ts"
+import type { BaseBlock } from "../core/types/blocks.ts"
+import type { Localized, PageType } from "../core/types/pages.ts"
+
+import { taxonomyTerms, pageTaxonomyTerms } from "../schema/taxonomies.ts"
+
+export interface CmsLoaderOptions {
+  type?: PageType | undefined
+  db?: any
+  locale?: string | undefined
+  includeDrafts?: boolean | undefined
+  includeScheduled?: boolean | undefined
+  taxonomy?:
+    | {
+        category?: string | undefined
+        tag?: string | undefined
+        [key: string]: string | undefined
+      }
+    | undefined
+}
+
+export interface CmsPageData {
+  id: string
+  slug: string
+  type: PageType
+  title: Localized
+  resolvedTitle: string
+  description?: Localized
+  resolvedDescription: string
+  excerpt: string
+  tags: Localized[]
+  authorIds: string[]
+  blocks: BaseBlock[]
+  properties: Record<string, any>
+  publishedVersionId: string | null
+  postedAt: Date | null
+  createdAt: Date
+  updatedAt: Date | null
+}
+
+export interface CmsEntry {
+  id: string
+  data: CmsPageData
+}
+
+export interface CacheHint {
+  tags?: string[]
+  lastModified?: Date
+  maxAge?: number
+}
+
+function resolveLocalized(val: unknown, locale: string = "en"): string {
+  if (!val) return ""
+  if (typeof val === "string") return val
+  if (typeof val === "object" && val !== null) {
+    const rec = val as Record<string, string>
+    return rec[locale] || rec.en || Object.values(rec)[0] || ""
+  }
+  return typeof val === "number" ? String(val) : ""
+}
+
+function transformPageToEntry(rawPage: any, locale: string = "en"): CmsEntry {
+  let contentObj = rawPage.content
+  if (typeof contentObj === "string") {
+    try {
+      contentObj = JSON.parse(contentObj)
+    } catch {
+      contentObj = { blocks: [], properties: {} }
+    }
+  } else if (!contentObj || typeof contentObj !== "object") {
+    contentObj = { blocks: [], properties: {} }
+  }
+
+  const blocks: BaseBlock[] = Array.isArray(contentObj.blocks) ? contentObj.blocks : []
+  const properties: Record<string, any> = contentObj.properties || {}
+
+  const resolvedTitle = resolveLocalized(rawPage.title, locale)
+  const resolvedDescription = resolveLocalized(rawPage.description, locale)
+  const excerpt = createPageExcerpt(rawPage, { locale, maxLength: 160 })
+
+  return {
+    id: rawPage.slug || rawPage.id,
+    data: {
+      id: rawPage.id,
+      slug: rawPage.slug,
+      type: rawPage.type,
+      title: rawPage.title,
+      resolvedTitle,
+      description: rawPage.description,
+      resolvedDescription,
+      excerpt,
+      tags: rawPage.tags || [],
+      authorIds: rawPage.authorIds || [],
+      blocks,
+      properties,
+      publishedVersionId: rawPage.publishedVersionId,
+      postedAt: rawPage.postedAt ? new Date(rawPage.postedAt) : null,
+      createdAt: new Date(rawPage.createdAt),
+      updatedAt: rawPage.updatedAt ? new Date(rawPage.updatedAt) : null
+    }
+  }
+}
+
+/**
+ * Direct querying helper for CMS collections.
+ */
+export async function getCmsCollection(
+  db: any,
+  options: CmsLoaderOptions & {
+    limit?: number | undefined
+    offset?: number | undefined
+    where?: SQL | undefined
+  } = {}
+): Promise<{ entries: CmsEntry[]; cacheHint: CacheHint }> {
+  const {
+    type,
+    locale = "en",
+    includeDrafts = false,
+    includeScheduled = false,
+    limit,
+    offset,
+    where: customWhere
+  } = options
+
+  if (!db) {
+    return { entries: [], cacheHint: { tags: ["cms"] } }
+  }
+
+  const conditions: SQL[] = [isNull(pages.deletedAt)]
+
+  if (type) {
+    // eslint-disable-next-line typescript/no-unsafe-type-assertion
+    conditions.push(eq(pages.type, type as PageType))
+  }
+
+  if (!includeDrafts) {
+    conditions.push(isNotNull(pages.publishedVersionId))
+  }
+
+  if (!includeScheduled) {
+    conditions.push(lte(pages.postedAt, new Date()))
+  }
+
+  if (customWhere) {
+    conditions.push(customWhere)
+  }
+
+  if (options.taxonomy) {
+    for (const [taxName, termSlug] of Object.entries(options.taxonomy)) {
+      if (termSlug) {
+        conditions.push(
+          sql`${pages.id} IN (
+            SELECT ${pageTaxonomyTerms.pageId} FROM ${pageTaxonomyTerms}
+            INNER JOIN ${taxonomyTerms} ON ${taxonomyTerms.id} = ${pageTaxonomyTerms.termId}
+            WHERE ${taxonomyTerms.taxonomy} = ${taxName} AND ${taxonomyTerms.slug} = ${termSlug}
+          )`
+        )
+      }
+    }
+  }
+
+  let query = db
+    .select()
+    .from(pages)
+    .where(and(...conditions))
+    .orderBy(desc(pages.postedAt))
+
+  if (typeof limit === "number") {
+    query = query.limit(limit)
+  }
+
+  if (typeof offset === "number") {
+    query = query.offset(offset)
+  }
+
+  const rows = await query
+  const entries = rows.map((r: any) => transformPageToEntry(r, locale))
+
+  let lastModified = new Date(0)
+  for (const entry of entries) {
+    if (entry.data.updatedAt && entry.data.updatedAt > lastModified) {
+      lastModified = entry.data.updatedAt
+    }
+  }
+
+  const tags = ["cms"]
+  if (type) tags.push(`cms:${type}`)
+
+  return {
+    entries,
+    cacheHint: {
+      tags,
+      lastModified: lastModified.getTime() > 0 ? lastModified : new Date()
+    }
+  }
+}
+
+/**
+ * Direct querying helper for a single CMS entry by slug or id.
+ */
+export async function getCmsEntry(
+  db: any,
+  slugOrId: string,
+  options: CmsLoaderOptions = {}
+): Promise<{ entry: CmsEntry | null; cacheHint: CacheHint }> {
+  const { entries, cacheHint } = await getCmsCollection(db, {
+    ...options,
+    limit: 1,
+    where: eq(pages.slug, slugOrId)
+  })
+
+  const entry = entries[0] || null
+  if (entry) {
+    cacheHint.tags?.push(`page:${entry.data.slug}`)
+  }
+
+  return { entry, cacheHint }
+}
+
+/**
+ * Astro Live Loader for CMS collections. Use inside src/live.config.ts with defineLiveCollection({
+ * loader: rimelightCmsLoader({ type: 'blog' }) })
+ */
+export function rimelightCmsLoader(loaderOptions: CmsLoaderOptions = {}) {
+  return {
+    name: "rimelight-cms-loader",
+    loadCollection: async (context: {
+      filter?: { limit?: number; offset?: number }
+      collection?: string
+    }) => {
+      const db = loaderOptions.db || (globalThis as any).db
+      const limit = typeof context.filter?.limit === "number" ? context.filter.limit : undefined
+      const offset = typeof context.filter?.offset === "number" ? context.filter.offset : undefined
+
+      return getCmsCollection(db, {
+        ...loaderOptions,
+        limit,
+        offset
+      })
+    },
+    loadEntry: async (context: { filter: { id: string }; collection?: string }) => {
+      const db = loaderOptions.db || (globalThis as any).db
+      const { entry, cacheHint } = await getCmsEntry(db, context.filter.id, loaderOptions)
+      if (!entry) return undefined
+      return {
+        id: entry.id,
+        data: entry.data,
+        cacheHint
+      }
+    }
+  }
+}

package/src/markdown/index.ts

@@ -1,2 +1 @@
 export * from "./serializer.ts"
-export * from "./parser.ts"

package/src/mcp/index.ts

@@ -0,0 +1,228 @@
+import { and, desc, eq, isNotNull, isNull } from "drizzle-orm"
+import { pages } from "../schema/pages.ts"
+import { pageDrafts } from "../schema/page_drafts.ts"
+import { getSiteSettings, updateSiteSettings } from "../services/site-settings.ts"
+import type { PageType } from "../core/types/pages.ts"
+import type { BaseBlock } from "../core/types/blocks.ts"
+
+export const CMS_MCP_TOOLS = [
+  {
+    name: "cms_list_pages",
+    description: "List CMS pages with optional filters for type, draft status, and pagination.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        type: {
+          type: "string",
+          description: "Filter by page type (e.g. 'blog', 'docs', 'landing')"
+        },
+        includeDrafts: { type: "boolean", description: "Whether to include unpublished drafts" },
+        limit: { type: "number", description: "Maximum number of pages to return (default 20)" }
+      }
+    }
+  },
+  {
+    name: "cms_get_page",
+    description:
+      "Get full details, block tree, and properties for a specific CMS page by slug or id.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        slugOrId: { type: "string", description: "Page slug or UUID" }
+      },
+      required: ["slugOrId"]
+    }
+  },
+  {
+    name: "cms_create_draft",
+    description: "Create or update a draft version for a CMS page.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        pageId: { type: "string", description: "Page UUID" },
+        userId: { type: "string", description: "User ID creating the draft" },
+        blocks: { type: "array", description: "Array of structured CMS blocks" },
+        properties: { type: "object", description: "Page properties object" }
+      },
+      required: ["pageId", "userId", "blocks"]
+    }
+  },
+  {
+    name: "cms_get_site_settings",
+    description: "Retrieve current dynamic site settings including branding and SEO defaults.",
+    inputSchema: {
+      type: "object",
+      properties: {}
+    }
+  },
+  {
+    name: "cms_update_site_settings",
+    description: "Update dynamic site settings (name, description, branding, SEO).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        name: { type: "string" },
+        description: { type: "string" },
+        author: { type: "string" },
+        email: { type: "string" },
+        branding: { type: "object" },
+        seo: { type: "object" }
+      }
+    }
+  }
+]
+
+/**
+ * Handles Model Context Protocol (MCP) JSON-RPC requests for CMS tools.
+ */
+export async function handleCmsMcpRequest(
+  body: {
+    jsonrpc?: string
+    id?: string | number
+    method: string
+    params?: any
+  },
+  db: any
+): Promise<any> {
+  const { id = 1, method, params = {} } = body
+
+  if (method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        tools: CMS_MCP_TOOLS
+      }
+    }
+  }
+
+  if (method === "tools/call") {
+    const { name, arguments: args = {} } = params
+
+    switch (name) {
+      case "cms_list_pages": {
+        const conditions = [isNull(pages.deletedAt)]
+        if (args.type) {
+          // eslint-disable-next-line typescript/no-unsafe-type-assertion
+          conditions.push(eq(pages.type, args.type as PageType))
+        }
+        if (!args.includeDrafts) {
+          conditions.push(isNotNull(pages.publishedVersionId))
+        }
+
+        const queryLimit = typeof args.limit === "number" ? args.limit : 20
+        const rows = await db
+          .select({
+            id: pages.id,
+            slug: pages.slug,
+            type: pages.type,
+            title: pages.title,
+            postedAt: pages.postedAt,
+            publishedVersionId: pages.publishedVersionId
+          })
+          .from(pages)
+          .where(and(...conditions))
+          .orderBy(desc(pages.postedAt))
+          .limit(queryLimit)
+
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(rows, null, 2) }]
+          }
+        }
+      }
+
+      case "cms_get_page": {
+        const row = await db
+          .select()
+          .from(pages)
+          .where(and(isNull(pages.deletedAt), eq(pages.slug, args.slugOrId)))
+          .limit(1)
+
+        const page = row[0] || null
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(page, null, 2) }]
+          }
+        }
+      }
+
+      case "cms_create_draft": {
+        const contentPayload = {
+          blocks: args.blocks as BaseBlock[],
+          properties: args.properties || {}
+        }
+
+        const draft = await db
+          .insert(pageDrafts)
+          .values({
+            pageId: args.pageId,
+            updatedBy: args.userId,
+            content: contentPayload
+          })
+          .onConflictDoUpdate({
+            target: [pageDrafts.pageId],
+            set: {
+              content: contentPayload,
+              updatedBy: args.userId,
+              updatedAt: new Date()
+            }
+          })
+          .returning()
+
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(draft[0], null, 2) }]
+          }
+        }
+      }
+
+      case "cms_get_site_settings": {
+        const settings = await getSiteSettings(db)
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(settings, null, 2) }]
+          }
+        }
+      }
+
+      case "cms_update_site_settings": {
+        const updated = await updateSiteSettings(db, args)
+        return {
+          jsonrpc: "2.0",
+          id,
+          result: {
+            content: [{ type: "text", text: JSON.stringify(updated, null, 2) }]
+          }
+        }
+      }
+
+      default:
+        return {
+          jsonrpc: "2.0",
+          id,
+          error: {
+            code: -32601,
+            message: `Method or tool '${name}' not found`
+          }
+        }
+    }
+  }
+
+  return {
+    jsonrpc: "2.0",
+    id,
+    error: {
+      code: -32601,
+      message: `Unknown method: ${method}`
+    }
+  }
+}

package/src/schema/bylines.ts

@@ -0,0 +1,23 @@
+import { pgTable, uuid, text, jsonb, timestamp, uniqueIndex } from "drizzle-orm/pg-core"
+
+export const bylines = pgTable(
+  "bylines",
+  {
+    id: uuid("id").primaryKey().defaultRandom(),
+    name: text("name").notNull(),
+    slug: text("slug").notNull(),
+    websiteUrl: text("website_url"),
+    bio: text("bio"),
+    avatar: text("avatar"),
+    userId: text("user_id"),
+    socials: jsonb("socials").$type<Record<string, string>>().default({}),
+    metadata: jsonb("metadata").$type<Record<string, any>>().default({}),
+    createdAt: timestamp("created_at").defaultNow().notNull(),
+    updatedAt: timestamp("updated_at").defaultNow().notNull(),
+    deletedAt: timestamp("deleted_at")
+  },
+  (table) => [uniqueIndex("bylines_slug_idx").on(table.slug)]
+)
+
+export type Byline = typeof bylines.$inferSelect
+export type NewByline = typeof bylines.$inferInsert

package/src/schema/index.ts

@@ -6,7 +6,6 @@ export * from "./page_version_comments.ts"
 export * from "./page_version_approvals.ts"
 export * from "./page_templates.ts"
 export * from "./search.ts"
-export * from "./component_metadata.ts"
-export * from "./component_versions.ts"
-export * from "./component_metadata_cache.ts"
-export * from "./component_dependencies.ts"
+export * from "./site_settings.ts"
+export * from "./taxonomies.ts"
+export * from "./bylines.ts"

package/src/schema/page_versions.ts

@@ -2,6 +2,7 @@ import { integer, jsonb, pgTable, text, timestamp, uniqueIndex, uuid } from "dri
 import type { BaseBlock } from "../core/types/blocks"
 import type { Localized, PageType } from "../core/types/pages"
 import type { PageVersionStatus } from "../core/types/versioning"
+import type { BylineCredit } from "../core/types/bylines"
 
 export const pageVersions = pgTable(
   "page_versions",
@@ -16,6 +17,7 @@ export const pageVersions = pgTable(
     description: jsonb("description").$type<Localized>(),
     tags: jsonb("tags").$type<Localized[]>().default([]).notNull(),
     authorIds: jsonb("author_ids").$type<string[]>().default([]),
+    bylines: jsonb("bylines").$type<BylineCredit[]>().default([]),
     content: jsonb("content")
       .$type<{
         blocks: BaseBlock[]

package/src/schema/pages.ts

@@ -2,6 +2,7 @@ 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 type { BylineCredit } from "../core/types/bylines"
 import { pageVersions } from "./page_versions.ts"
 import { pageTemplates } from "./page_templates.ts"
 
@@ -17,6 +18,7 @@ export const pages = pgTable(
     description: jsonb("description").$type<Localized>(),
     tags: jsonb("tags").$type<Localized[]>().default([]).notNull(),
     authorIds: jsonb("author_ids").$type<string[]>().default([]),
+    bylines: jsonb("bylines").$type<BylineCredit[]>().default([]),
     /**
      * Denormalized read-cache of the active published version content (NULL if unpublished draft)
      */

package/src/schema/site_settings.ts

@@ -0,0 +1,41 @@
+import { jsonb, pgTable, text, timestamp } from "drizzle-orm/pg-core"
+
+export interface SiteSettingsBranding {
+  logo: {
+    alt: string
+  }
+  favicon: {
+    svg: string
+  }
+  colors: {
+    themeColor: string
+    backgroundColor: string
+  }
+}
+
+export interface SiteSettingsSeo {
+  titleTemplate: string
+  ogImageFallback: string
+  maxDescriptionLength: number
+  authorHandle?: string
+}
+
+export const siteSettings = pgTable("site_settings", {
+  id: text("id").primaryKey().default("default"),
+  name: text("name").notNull(),
+  description: text("description").notNull(),
+  url: text("url").notNull(),
+  ogImage: text("og_image").notNull(),
+  author: text("author").notNull(),
+  email: text("email").notNull().default(""),
+  branding: jsonb("branding").$type<SiteSettingsBranding>().notNull(),
+  seo: jsonb("seo").$type<SiteSettingsSeo>().notNull(),
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true })
+    .defaultNow()
+    .$onUpdate(() => new Date())
+    .notNull()
+})
+
+export type SiteSettings = typeof siteSettings.$inferSelect
+export type InsertSiteSettings = typeof siteSettings.$inferInsert

package/src/schema/taxonomies.ts

@@ -0,0 +1,49 @@
+import {
+  foreignKey,
+  integer,
+  jsonb,
+  pgTable,
+  text,
+  timestamp,
+  uniqueIndex,
+  uuid
+} from "drizzle-orm/pg-core"
+import { pages } from "./pages.ts"
+import type { Localized } from "../core/types/pages"
+
+export const taxonomyTerms = pgTable(
+  "taxonomy_terms",
+  {
+    id: uuid("id").defaultRandom().notNull().primaryKey(),
+    taxonomy: text("taxonomy").notNull(), // "category" | "tag" | custom (e.g. "genre")
+    slug: text("slug").notNull(),
+    label: jsonb("label").$type<Localized | string>().notNull(),
+    description: jsonb("description").$type<Localized | string>(),
+    parentId: uuid("parent_id"),
+    displayOrder: integer("display_order").default(0).notNull(),
+    createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+    updatedAt: timestamp("updated_at", { withTimezone: true }).$onUpdate(() => new Date())
+  },
+  (table) => [
+    uniqueIndex("taxonomy_terms_tax_slug_idx").on(table.taxonomy, table.slug),
+    foreignKey({
+      columns: [table.parentId],
+      foreignColumns: [table.id],
+      name: "taxonomy_terms_parent_id_fk"
+    }).onDelete("cascade")
+  ]
+)
+
+export const pageTaxonomyTerms = pgTable(
+  "page_taxonomy_terms",
+  {
+    pageId: uuid("page_id")
+      .notNull()
+      .references(() => pages.id, { onDelete: "cascade" }),
+    termId: uuid("term_id")
+      .notNull()
+      .references(() => taxonomyTerms.id, { onDelete: "cascade" }),
+    assignedAt: timestamp("assigned_at", { withTimezone: true }).defaultNow().notNull()
+  },
+  (table) => [uniqueIndex("page_taxonomy_terms_page_term_idx").on(table.pageId, table.termId)]
+)