@rimelight/cms 0.0.2 → 0.0.4

package/src/docs/sidebar.ts

@@ -0,0 +1,251 @@
+import type { DocsConfig, SidebarItem, SidebarScope, BadgeProps } from "./config"
+
+export interface ResolvedSidebarItem {
+  label: string
+  href?: string | undefined
+  icon?: string | undefined
+  badge?: string | BadgeProps | undefined
+  active?: boolean | undefined
+  children?: ResolvedSidebarItem[] | undefined
+  collapsed?: boolean | undefined
+}
+
+export interface ResolvedScope {
+  id: string
+  label: string
+  href: string
+  icon?: string | undefined
+  active?: boolean | undefined
+}
+
+function formatDocsUrl(
+  href: string,
+  locale: string,
+  activeVersion?: string,
+  includeVersionInUrl?: boolean
+): string {
+  let url = href.replace("{locale}", locale)
+  if (activeVersion && includeVersionInUrl) {
+    if (url.includes(`/${activeVersion}/`) || url.endsWith(`/${activeVersion}`)) {
+      return url
+    }
+    const docsPattern = new RegExp(`(/${locale}/docs)(/|$)`)
+    const companyDocsPattern = new RegExp(`(/${locale}/company/docs)(/|$)`)
+
+    if (companyDocsPattern.test(url)) {
+      url = url.replace(companyDocsPattern, `$1/${activeVersion}$2`)
+    } else if (docsPattern.test(url)) {
+      url = url.replace(docsPattern, `$1/${activeVersion}$2`)
+    }
+
+    url = url.replace(/\/{2,}/g, "/")
+  }
+  return url
+}
+
+function findFirstHref(
+  items: SidebarItem[],
+  locale: string,
+  activeVersion?: string,
+  includeVersionInUrl?: boolean
+): string | undefined {
+  for (const item of items) {
+    if (item.href) return formatDocsUrl(item.href, locale, activeVersion, includeVersionInUrl)
+    const childItems = item.children || item.items
+    if (childItems) {
+      const found = findFirstHref(childItems, locale, activeVersion, includeVersionInUrl)
+      if (found) return found
+    }
+  }
+  return undefined
+}
+
+function getScopePrefix(
+  items: SidebarItem[],
+  locale: string,
+  activeVersion?: string,
+  includeVersionInUrl?: boolean
+): string {
+  const allHrefs: string[] = []
+
+  function collect(item: SidebarItem) {
+    if (item.href)
+      allHrefs.push(formatDocsUrl(item.href, locale, activeVersion, includeVersionInUrl))
+    const childItems = item.children || item.items
+    if (childItems) childItems.forEach(collect)
+  }
+
+  items.forEach(collect)
+  if (allHrefs.length === 0) return ""
+
+  const parts = allHrefs.map((h) => h.split("/").filter(Boolean))
+  let commonLen = 0
+  const firstPart = parts[0]
+  if (!firstPart) return ""
+  for (let i = 0; i < firstPart.length; i++) {
+    if (parts.every((p) => p[i] === firstPart[i])) commonLen++
+    else break
+  }
+
+  return "/" + firstPart.slice(0, commonLen).join("/") + "/"
+}
+
+function hasPath(
+  items: SidebarItem[],
+  locale: string,
+  normPath: string,
+  activeVersion?: string,
+  includeVersionInUrl?: boolean
+): boolean {
+  for (const item of items) {
+    if (
+      item.href &&
+      formatDocsUrl(item.href, locale, activeVersion, includeVersionInUrl)
+        .replace(/\/$/, "")
+        .toLowerCase() === normPath
+    ) {
+      return true
+    }
+    const childItems = item.children || item.items
+    if (childItems && hasPath(childItems, locale, normPath, activeVersion, includeVersionInUrl)) {
+      return true
+    }
+  }
+  return false
+}
+
+export async function getDocsSidebar(
+  config: DocsConfig,
+  locale: string,
+  currentPath: string,
+  activeVersion?: string,
+  includeVersionInUrl?: boolean
+): Promise<{
+  items: ResolvedSidebarItem[]
+  scopes: ResolvedScope[]
+  activeScope?: ResolvedScope | undefined
+}> {
+  const normPath = currentPath.replace(/\/$/, "").toLowerCase()
+
+  const sidebarScopes: SidebarScope[] = Array.isArray(config.sidebar)
+    ? config.sidebar.filter((item): item is SidebarScope => "id" in item || "scopes" in item)
+    : config.sidebar.scopes || []
+
+  const scopes: ResolvedScope[] = sidebarScopes.map((scope) => {
+    const id = scope.id || scope.label
+    let href = scope.href || ""
+    if (!href && scope.items && scope.items.length > 0) {
+      href = findFirstHref(scope.items, locale, activeVersion, includeVersionInUrl) || ""
+    }
+    return {
+      id,
+      label: scope.label,
+      href: formatDocsUrl(href, locale, activeVersion, includeVersionInUrl),
+      icon: scope.icon
+    }
+  })
+
+  const scopePrefixes: string[] = sidebarScopes.map((scope) =>
+    scope.items ? getScopePrefix(scope.items, locale, activeVersion, includeVersionInUrl) : ""
+  )
+
+  let activeScope = scopes.find((s) => normPath === s.href.replace(/\/$/, "").toLowerCase())
+  if (!activeScope) {
+    for (let i = 0; i < sidebarScopes.length; i++) {
+      const scope = sidebarScopes[i]
+      if (
+        scope &&
+        scope.items &&
+        hasPath(scope.items, locale, normPath, activeVersion, includeVersionInUrl)
+      ) {
+        activeScope = scopes[i]
+        break
+      }
+    }
+  }
+  if (!activeScope) {
+    const sorted = [...scopePrefixes.entries()]
+      .filter(([, p]) => p)
+      .toSorted(([, a], [, b]) => b.length - a.length)
+    for (const [i] of sorted) {
+      const prefix = scopePrefixes[i]
+      if (prefix && normPath.startsWith(prefix.toLowerCase())) {
+        activeScope = scopes[i]
+        break
+      }
+    }
+  }
+  if (!activeScope && scopes.length > 0) {
+    activeScope = scopes[0]
+  }
+  if (activeScope) activeScope.active = true
+
+  const sidebarConfig = sidebarScopes.find(
+    (item) => activeScope && (item.id === activeScope.id || item.label === activeScope.id)
+  )
+
+  const items = sidebarConfig?.items || []
+
+  async function resolveItem(item: SidebarItem): Promise<ResolvedSidebarItem[]> {
+    const resolved: ResolvedSidebarItem = {
+      label: item.label || "",
+      href: item.href
+        ? formatDocsUrl(item.href, locale, activeVersion, includeVersionInUrl)
+        : undefined,
+      icon: item.icon,
+      badge: item.badge,
+      collapsed: item.collapsed
+    }
+
+    if (resolved.href) {
+      resolved.active = normPath === resolved.href.replace(/\/$/, "").toLowerCase()
+    }
+
+    const childItems = item.children || item.items
+    if (childItems) {
+      const children: ResolvedSidebarItem[] = []
+      const resolvedChildren = await Promise.all(childItems.map((child) => resolveItem(child)))
+      for (const res of resolvedChildren) {
+        children.push(...res)
+      }
+      resolved.children = children
+      if (!resolved.active) {
+        resolved.active = children.some((c) => c.active)
+      }
+    }
+
+    return [resolved]
+  }
+
+  const resolvedItems: ResolvedSidebarItem[] = []
+  const resolvedAllItems = await Promise.all(items.map((item) => resolveItem(item)))
+  for (const res of resolvedAllItems) {
+    resolvedItems.push(...res)
+  }
+
+  return { items: resolvedItems, scopes, activeScope }
+}
+
+export function getSurroundItems(sidebar: ResolvedSidebarItem[], currentPath: string) {
+  const flatItems: { label: string; href: string }[] = []
+
+  function flatten(items: ResolvedSidebarItem[]) {
+    for (const item of items) {
+      if (item.href) flatItems.push({ label: item.label, href: item.href })
+      if (item.children) flatten(item.children)
+    }
+  }
+
+  flatten(sidebar)
+
+  const normPath = currentPath.replace(/\/$/, "").toLowerCase()
+  const currentIndex = flatItems.findIndex(
+    (item) => item.href.replace(/\/$/, "").toLowerCase() === normPath
+  )
+
+  return {
+    prev: currentIndex > 0 ? flatItems[currentIndex - 1] : null,
+    next:
+      currentIndex >= 0 && currentIndex < flatItems.length - 1 ? flatItems[currentIndex + 1] : null
+  }
+}

package/src/docs/toc.ts

@@ -0,0 +1,47 @@
+export interface TableOfContentsHeading {
+  depth: number
+  slug: string
+  text: string
+}
+
+export function slugifyHeading(text: string): string {
+  return text
+    .toString()
+    .toLowerCase()
+    .normalize("NFD")
+    .replace(/[\u0300-\u036f]/g, "")
+    .replace(/\s+/g, "-")
+    .replace(/[^\w-]+/g, "")
+    .replace(/-{2,}/g, "-")
+    .replace(/^-+/, "")
+    .replace(/-+$/, "")
+}
+
+export function extractHeadingsFromBlocks(
+  blocks: any[] = [],
+  currentDepth = 2
+): TableOfContentsHeading[] {
+  if (!Array.isArray(blocks)) return []
+  const headings: TableOfContentsHeading[] = []
+
+  for (const block of blocks) {
+    if (!block) continue
+    if (block.type === "SectionBlock") {
+      const title = block.props?.title || ""
+      const level = Number(block.props?.level) || currentDepth
+      if (title) {
+        headings.push({
+          depth: level,
+          slug: slugifyHeading(title),
+          text: title
+        })
+      }
+      const children = block.children || block.props?.children || []
+      if (Array.isArray(children) && children.length > 0) {
+        headings.push(...extractHeadingsFromBlocks(children, Math.min(6, level + 1)))
+      }
+    }
+  }
+
+  return headings
+}

package/src/env.d.ts

@@ -2,3 +2,22 @@ declare module "*.astro" {
   const component: any
   export default component
 }
+
+declare module "virtual:rimelight-cms/parent-layout" {
+  const layout: any
+  export default layout
+}
+
+declare module "virtual:rimelight-cms/db" {
+  export const db: any
+}
+
+declare module "virtual:rimelight-cms/storage" {
+  export const storageConfig: any
+}
+
+declare module "virtual:rimelight-cms/auth" {
+  import type { AuthAdapter } from "@rimelight/auth"
+  export const authAdapter: AuthAdapter
+  export default authAdapter
+}

package/src/index.ts

@@ -6,6 +6,9 @@ export * from "./core/types/templates.ts"
 export * from "./core/types/versioning.ts"
 export * from "./core/page-definitions.ts"
 
+// Markdown Serialization & Parsing
+export * from "./markdown/index.ts"
+
 // Re-export specific types for convenience
 export type {
   TimeOfDay,
@@ -19,31 +22,73 @@ export type {
 // Core Services & Registries
 export * from "./core/registry.ts"
 export * from "./core/validator.ts"
-export * from "./core/template-sync.ts"
-export * from "./services/component-metadata.ts"
 
-// Auth & Security Guards
+// Universal Auth & Pluggable Adapters (RFC-0004 & RFC-0006)
 export * from "./auth/permissions.ts"
 export * from "./auth/filter-blocks.ts"
 export * from "./auth/editor-guards.ts"
 export * from "./auth/filter-templates.ts"
+export {
+  cfAccessAuth,
+  auth0Auth,
+  mockAuth,
+  hasRole,
+  hasPermission,
+  evaluateAccess
+} from "@rimelight/auth"
+export type {
+  AuthAdapter as CmsAuthAdapter,
+  AuthAdapter,
+  UserSessionContext,
+  UserType
+} from "@rimelight/auth"
 
 // Edge Cache & Search
 export * from "./cache/purge.ts"
 export * from "./search/query.ts"
-export * from "./search/sync.ts"
 
 // Database Schemas & Migration
 export * from "./schema/index.ts"
-export * from "./migration.ts"
 
-// Markdown Serialization & Parsing
-export * from "./markdown/index.ts"
-export * from "./migration-tools.ts"
-
-// Astro Components
-export { default as PageRenderer } from "./astro/PageRenderer.astro"
-export { default as BlockRenderer } from "./astro/BlockRenderer.astro"
+// Astro Integration & Components
+export { rimelightCms, type RimelightCmsOptions } from "./integration.ts"
 
 // Toast API
 export * from "./client/toast.ts"
+
+// Excerpts & Summaries
+export * from "./core/excerpt.ts"
+
+// Dynamic Site Settings
+export * from "./services/site-settings.ts"
+
+// Astro Live Loader & Collections
+export * from "./loader/live.ts"
+
+// Cloudflare Worker Cron Dispatcher
+export * from "./cron/scheduled.ts"
+
+// Model Context Protocol (MCP) Tools
+export * from "./mcp/index.ts"
+
+// Media & Bylines
+export * from "./core/types/media.ts"
+export * from "./core/types/bylines.ts"
+export * from "./services/bylines.ts"
+
+// Preview Tokens & Block Diffs
+export * from "./core/preview.ts"
+export * from "./core/diff.ts"
+
+// Search Indexer
+export * from "./services/search-indexer.ts"
+
+// Taxonomies Engine
+export * from "./core/types/taxonomies.ts"
+export * from "./services/taxonomies.ts"
+
+// Documentation Engine & Navigation
+export * from "./docs/index.ts"
+
+// Storage Adapters (R2, etc.)
+export * from "./storage/index.ts"

package/src/integration.ts

@@ -0,0 +1,250 @@
+import type { AstroIntegration } from "astro"
+import path from "node:path"
+import fs from "node:fs"
+import { fileURLToPath } from "node:url"
+import type { StorageConfig } from "./storage/index"
+import type { AuthAdapter } from "@rimelight/auth"
+
+export interface RimelightCmsOptions {
+  /**
+   * Route prefix for CMS admin pages. Defaults to "/[locale]/cms" (or "/cms" if no locale routing).
+   */
+  routePrefix?: string | undefined
+
+  /**
+   * Optional outer layout to wrap the CMS dashboard in (e.g. "./src/layouts/AppLayout.astro"). When
+   * omitted, renders as a dedicated standalone full-viewport dashboard.
+   */
+  parentLayout?: string | undefined
+
+  /**
+   * Path to the app database instance module exporting `db`. Defaults to "./src/db/index.ts" or
+   * "./src/db".
+   */
+  db?: string | undefined
+
+  /**
+   * Storage backend configuration (e.g. r2({ binding: "BLOB", publicUrl:
+   * "https://media.example.com" })).
+   */
+  storage?: StorageConfig | undefined
+
+  /**
+   * Pluggable Auth Adapter instance or module path (RFC-0004 / RFC-0006). E.g. cfAccessAuth({ ...
+   * }), auth0Auth({ ... }), or mockAuth().
+   */
+  auth?: AuthAdapter | string | undefined
+}
+
+export function rimelightCms(options: RimelightCmsOptions = {}): AstroIntegration {
+  const routePrefix = options.routePrefix ?? "/[locale]/cms"
+  const storageConfig = {
+    provider: options.storage?.provider ?? "r2",
+    binding: options.storage?.binding ?? "BLOB",
+    publicUrl: options.storage?.publicUrl,
+    prefix: options.storage?.prefix ?? "media/"
+  }
+
+  return {
+    name: "@rimelight/cms",
+    hooks: {
+      "astro:config:setup": ({ injectRoute, updateConfig, config }) => {
+        const rootDir = fileURLToPath(config.root)
+
+        // Resolve parent layout if provided
+        let resolvedParentLayout: string | null = null
+        if (options.parentLayout) {
+          resolvedParentLayout = path.isAbsolute(options.parentLayout)
+            ? options.parentLayout
+            : path.resolve(rootDir, options.parentLayout)
+        }
+
+        // Resolve db module if exists
+        let resolvedDb: string | null = null
+        if (options.db) {
+          resolvedDb = path.isAbsolute(options.db) ? options.db : path.resolve(rootDir, options.db)
+        } else {
+          const defaultDbTs = path.resolve(rootDir, "src/db/index.ts")
+          const defaultDbJs = path.resolve(rootDir, "src/db/index.js")
+          if (fs.existsSync(defaultDbTs)) {
+            resolvedDb = defaultDbTs
+          } else if (fs.existsSync(defaultDbJs)) {
+            resolvedDb = defaultDbJs
+          }
+        }
+
+        // Resolve auth module / adapter code
+        let resolvedAuthCode: string
+        if (typeof options.auth === "string") {
+          const resolvedAuthPath = path.isAbsolute(options.auth)
+            ? options.auth
+            : path.resolve(rootDir, options.auth)
+          resolvedAuthCode = `export { authAdapter, authAdapter as default } from ${JSON.stringify(resolvedAuthPath)};`
+        } else if (options.auth && typeof options.auth === "object") {
+          const authObj = options.auth as any
+          const adapterName = authObj.name || "mock"
+          const adapterOpts = authObj.options || {}
+
+          if (adapterName === "cf-access") {
+            resolvedAuthCode = `import { cfAccessAuth } from "@rimelight/auth/cf-access";
+export const authAdapter = cfAccessAuth(${JSON.stringify(adapterOpts)});
+export default authAdapter;`
+          } else if (adapterName === "auth0") {
+            resolvedAuthCode = `import { auth0Auth } from "@rimelight/auth/auth0";
+export const authAdapter = auth0Auth(${JSON.stringify(adapterOpts)});
+export default authAdapter;`
+          } else {
+            resolvedAuthCode = `import { mockAuth } from "@rimelight/auth/mock";
+export const authAdapter = mockAuth(${JSON.stringify(adapterOpts)});
+export default authAdapter;`
+          }
+        } else {
+          // Default fallback mock admin adapter for development
+          resolvedAuthCode = `import { mockAuth } from "@rimelight/auth/mock";
+export const authAdapter = mockAuth({
+  session: {
+    userId: "cms-admin",
+    name: "CMS Administrator",
+    email: "admin@rimelight.com",
+    roles: ["admin", "editor"],
+    permissions: ["*"],
+    userType: "employee"
+  }
+});
+export default authAdapter;`
+        }
+
+        // 1. Inject CMS admin routes
+        injectRoute({
+          pattern: `${routePrefix}`,
+          entrypoint: "@rimelight/cms/admin/pages/dashboard.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/pages`,
+          entrypoint: "@rimelight/cms/admin/pages/pages-index.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/pages/new`,
+          entrypoint: "@rimelight/cms/admin/pages/pages-new.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/pages/[id]/edit`,
+          entrypoint: "@rimelight/cms/admin/pages/pages-edit.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/pages/[id]/preview`,
+          entrypoint: "@rimelight/cms/admin/pages/pages-preview.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/pages/[id]/review`,
+          entrypoint: "@rimelight/cms/admin/pages/pages-review.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/templates`,
+          entrypoint: "@rimelight/cms/admin/pages/templates-index.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/templates/new`,
+          entrypoint: "@rimelight/cms/admin/pages/templates-new.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/templates/[id]/edit`,
+          entrypoint: "@rimelight/cms/admin/pages/templates-edit.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/assets`,
+          entrypoint: "@rimelight/cms/admin/pages/assets.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/categories`,
+          entrypoint: "@rimelight/cms/admin/pages/categories.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/tags`,
+          entrypoint: "@rimelight/cms/admin/pages/tags.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/bylines`,
+          entrypoint: "@rimelight/cms/admin/pages/bylines.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/versions`,
+          entrypoint: "@rimelight/cms/admin/pages/versions.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/content-types`,
+          entrypoint: "@rimelight/cms/admin/pages/content-types.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/byline-schema`,
+          entrypoint: "@rimelight/cms/admin/pages/byline-schema.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/users`,
+          entrypoint: "@rimelight/cms/admin/pages/users.astro"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/settings`,
+          entrypoint: "@rimelight/cms/admin/pages/settings.astro"
+        })
+
+        // Media API Routes
+        injectRoute({
+          pattern: `${routePrefix}/api/media`,
+          entrypoint: "@rimelight/cms/admin/api/media.ts"
+        })
+        injectRoute({
+          pattern: `${routePrefix}/api/media/file/[...key]`,
+          entrypoint: "@rimelight/cms/admin/api/media-file.ts"
+        })
+
+        // 2. Vite plugin for virtual modules
+        updateConfig({
+          vite: {
+            plugins: [
+              {
+                name: "vite-plugin-rimelight-cms-virtuals",
+                resolveId(id) {
+                  if (id === "virtual:rimelight-cms/parent-layout") {
+                    return "\0virtual:rimelight-cms/parent-layout"
+                  }
+                  if (id === "virtual:rimelight-cms/db") {
+                    return "\0virtual:rimelight-cms/db"
+                  }
+                  if (id === "virtual:rimelight-cms/storage") {
+                    return "\0virtual:rimelight-cms/storage"
+                  }
+                  if (id === "virtual:rimelight-cms/auth") {
+                    return "\0virtual:rimelight-cms/auth"
+                  }
+                  return undefined
+                },
+                load(id) {
+                  if (id === "\0virtual:rimelight-cms/parent-layout") {
+                    if (resolvedParentLayout && fs.existsSync(resolvedParentLayout)) {
+                      return `export { default } from ${JSON.stringify(resolvedParentLayout)};`
+                    }
+                    return `export { default } from "@rimelight/cms/admin/layouts/DefaultParentLayout.astro";`
+                  }
+                  if (id === "\0virtual:rimelight-cms/db") {
+                    if (resolvedDb && fs.existsSync(resolvedDb)) {
+                      return `export * from ${JSON.stringify(resolvedDb)};`
+                    }
+                    return `export const db = null;`
+                  }
+                  if (id === "\0virtual:rimelight-cms/storage") {
+                    return `export const storageConfig = ${JSON.stringify(storageConfig)};`
+                  }
+                  if (id === "\0virtual:rimelight-cms/auth") {
+                    return resolvedAuthCode
+                  }
+                  return undefined
+                }
+              }
+            ]
+          }
+        })
+      }
+    }
+  }
+}