@rimelight/cms 0.0.3 → 0.0.4

package/src/integration.ts

@@ -3,6 +3,7 @@ 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 {
   /**
@@ -27,6 +28,12 @@ export interface RimelightCmsOptions {
    * "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 {
@@ -66,6 +73,47 @@ export function rimelightCms(options: RimelightCmsOptions = {}): AstroIntegratio
           }
         }
 
+        // 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}`,
@@ -166,6 +214,9 @@ export function rimelightCms(options: RimelightCmsOptions = {}): AstroIntegratio
                   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) {
@@ -184,6 +235,9 @@ export function rimelightCms(options: RimelightCmsOptions = {}): AstroIntegratio
                   if (id === "\0virtual:rimelight-cms/storage") {
                     return `export const storageConfig = ${JSON.stringify(storageConfig)};`
                   }
+                  if (id === "\0virtual:rimelight-cms/auth") {
+                    return resolvedAuthCode
+                  }
                   return undefined
                 }
               }

package/src/schema/sqlite.ts

@@ -0,0 +1,344 @@
+import { sql } from "drizzle-orm"
+import {
+  sqliteTable,
+  text,
+  integer,
+  uniqueIndex,
+  index,
+  type AnySQLiteColumn
+} from "drizzle-orm/sqlite-core"
+import type { BaseBlock } from "../core/types/blocks"
+import type { Localized, PageType } from "../core/types/pages"
+import type { BylineCredit } from "../core/types/bylines"
+import type { PageVersionStatus } from "../core/types/versioning"
+import type { TemplateApprovalRules, TemplateRolePermissions } from "../core/types/templates"
+
+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
+}
+
+// 1. Page Templates
+export const pageTemplates = sqliteTable("page_templates", {
+  id: text("id")
+    .$defaultFn(() => crypto.randomUUID())
+    .notNull()
+    .primaryKey(),
+  slug: text("slug").notNull().unique(),
+  title: text("title", { mode: "json" }).$type<Localized>().notNull(),
+  description: text("description", { mode: "json" }).$type<Localized>(),
+  pageType: text("page_type").$type<PageType>().notNull(),
+  version: integer("version").default(1).notNull(),
+  allowedRoles: text("allowed_roles", { mode: "json" })
+    .$type<string[]>()
+    .default(sql`'[]'`)
+    .notNull(),
+  rolePermissions: text("role_permissions", { mode: "json" })
+    .$type<TemplateRolePermissions>()
+    .default(sql`'{"whoCanCreate":[],"whoCanEdit":[],"whoCanReview":[],"whoCanView":[]}'`)
+    .notNull(),
+  requiredPermission: text("required_permission"),
+  approvalRules: text("approval_rules", { mode: "json" })
+    .$type<TemplateApprovalRules>()
+    .default(sql`'{"allowSelfApproval":true,"minApprovals":1}'`)
+    .notNull(),
+  defaultProperties: text("default_properties", { mode: "json" })
+    .default(sql`'{}'`)
+    .notNull(),
+  initialBlocks: text("initial_blocks", { mode: "json" })
+    .$type<BaseBlock[]>()
+    .default(sql`'[]'`)
+    .notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => new Date())
+})
+
+// 2. Page Versions
+export const pageVersions = sqliteTable(
+  "page_versions",
+  {
+    id: text("id")
+      .$defaultFn(() => crypto.randomUUID())
+      .notNull()
+      .primaryKey(),
+    pageId: text("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: text("title", { mode: "json" }).$type<Localized>().notNull(),
+    description: text("description", { mode: "json" }).$type<Localized>(),
+    tags: text("tags", { mode: "json" })
+      .$type<Localized[]>()
+      .default(sql`'[]'`)
+      .notNull(),
+    authorIds: text("author_ids", { mode: "json" })
+      .$type<string[]>()
+      .default(sql`'[]'`),
+    bylines: text("bylines", { mode: "json" })
+      .$type<BylineCredit[]>()
+      .default(sql`'[]'`),
+    content: text("content", { mode: "json" })
+      .$type<{
+        blocks: BaseBlock[]
+        properties: Record<string, any>
+      }>()
+      .notNull(),
+    createdBy: text("created_by").notNull(),
+    approvedBy: text("approved_by", { mode: "json" })
+      .$type<string[]>()
+      .default(sql`'[]'`)
+      .notNull(),
+    approvedAt: integer("approved_at", { mode: "timestamp" }),
+    changeSummary: text("change_summary"),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull()
+  },
+  (table) => [
+    uniqueIndex("page_versions_page_id_version_idx").on(table.pageId, table.versionNumber)
+  ]
+)
+
+// 3. Pages
+export const pages = sqliteTable(
+  "pages",
+  {
+    id: text("id")
+      .$defaultFn(() => crypto.randomUUID())
+      .notNull()
+      .primaryKey(),
+    slug: text("slug").notNull(),
+    type: text("type").$type<PageType>().notNull(),
+    templateId: text("template_id").references(() => pageTemplates.id, { onDelete: "set null" }),
+    templateVersion: integer("template_version").default(1).notNull(),
+    title: text("title", { mode: "json" }).$type<Localized>().notNull(),
+    description: text("description", { mode: "json" }).$type<Localized>(),
+    tags: text("tags", { mode: "json" })
+      .$type<Localized[]>()
+      .default(sql`'[]'`)
+      .notNull(),
+    authorIds: text("author_ids", { mode: "json" })
+      .$type<string[]>()
+      .default(sql`'[]'`),
+    bylines: text("bylines", { mode: "json" })
+      .$type<BylineCredit[]>()
+      .default(sql`'[]'`),
+    content: text("content", { mode: "json" })
+      .$type<{
+        blocks: BaseBlock[]
+        properties: Record<string, any>
+      }>()
+      .notNull(),
+    publishedVersionId: text("published_version_id").references(() => pageVersions.id, {
+      onDelete: "set null"
+    }),
+    postedAt: integer("posted_at", { mode: "timestamp" }),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => new Date()),
+    deletedAt: integer("deleted_at", { mode: "timestamp" })
+  },
+  (table) => [
+    uniqueIndex("pages_slug_active_unique_idx")
+      .on(table.slug)
+      .where(sql`deleted_at IS NULL`)
+  ]
+)
+
+// 4. Page Drafts
+export const pageDrafts = sqliteTable("page_drafts", {
+  pageId: text("page_id")
+    .notNull()
+    .primaryKey()
+    .references(() => pages.id, { onDelete: "cascade" }),
+  content: text("content", { mode: "json" })
+    .$type<{
+      blocks: BaseBlock[]
+      properties: Record<string, any>
+    }>()
+    .notNull(),
+  updatedBy: text("updated_by").notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull()
+})
+
+// 5. Page Draft Locks
+export const pageDraftLocks = sqliteTable("page_draft_locks", {
+  pageId: text("page_id")
+    .notNull()
+    .primaryKey()
+    .references(() => pages.id, { onDelete: "cascade" }),
+  lockedByUserId: text("locked_by_user_id").notNull(),
+  lockedByUserName: text("locked_by_user_name").notNull(),
+  acquiredAt: integer("acquired_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull(),
+  expiresAt: integer("expires_at", { mode: "timestamp" }).notNull()
+})
+
+// 6. Page Version Approvals
+export const pageVersionApprovals = sqliteTable("page_version_approvals", {
+  id: text("id")
+    .$defaultFn(() => crypto.randomUUID())
+    .notNull()
+    .primaryKey(),
+  versionId: text("version_id")
+    .notNull()
+    .references(() => pageVersions.id, { onDelete: "cascade" }),
+  userId: text("user_id").notNull(),
+  userRole: text("user_role").notNull(),
+  approvedAt: integer("approved_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull()
+})
+
+// 7. Page Version Comments
+export const pageVersionComments = sqliteTable("page_version_comments", {
+  id: text("id")
+    .$defaultFn(() => crypto.randomUUID())
+    .notNull()
+    .primaryKey(),
+  versionId: text("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: integer("created_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull()
+})
+
+// 8. Search
+export const contentSearchIndex = sqliteTable(
+  "content_search_index",
+  {
+    id: text("id")
+      .$defaultFn(() => crypto.randomUUID())
+      .notNull()
+      .primaryKey(),
+    pageId: text("page_id")
+      .notNull()
+      .references(() => pages.id, { onDelete: "cascade" }),
+    locale: text("locale").notNull(),
+    titleText: text("title_text").notNull(),
+    contentText: text("content_text").notNull()
+  },
+  (table) => [index("content_search_index_page_id_idx").on(table.pageId)]
+)
+
+// 9. Site Settings
+export const siteSettings = sqliteTable("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: text("branding", { mode: "json" }).$type<SiteSettingsBranding>().notNull(),
+  seo: text("seo", { mode: "json" }).$type<SiteSettingsSeo>().notNull(),
+  createdAt: integer("created_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .notNull(),
+  updatedAt: integer("updated_at", { mode: "timestamp" })
+    .$defaultFn(() => new Date())
+    .$onUpdate(() => new Date())
+    .notNull()
+})
+
+// 10. Taxonomies
+export const taxonomyTerms = sqliteTable(
+  "taxonomy_terms",
+  {
+    id: text("id")
+      .$defaultFn(() => crypto.randomUUID())
+      .notNull()
+      .primaryKey(),
+    taxonomy: text("taxonomy").notNull(),
+    slug: text("slug").notNull(),
+    label: text("label", { mode: "json" }).$type<Localized | string>().notNull(),
+    description: text("description", { mode: "json" }).$type<Localized | string>(),
+    parentId: text("parent_id").references((): AnySQLiteColumn => taxonomyTerms.id, {
+      onDelete: "cascade"
+    }),
+    displayOrder: integer("display_order").default(0).notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" }).$onUpdate(() => new Date())
+  },
+  (table) => [uniqueIndex("taxonomy_terms_tax_slug_idx").on(table.taxonomy, table.slug)]
+)
+
+export const pageTaxonomyTerms = sqliteTable(
+  "page_taxonomy_terms",
+  {
+    pageId: text("page_id")
+      .notNull()
+      .references(() => pages.id, { onDelete: "cascade" }),
+    termId: text("term_id")
+      .notNull()
+      .references(() => taxonomyTerms.id, { onDelete: "cascade" }),
+    assignedAt: integer("assigned_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull()
+  },
+  (table) => [uniqueIndex("page_taxonomy_terms_page_term_idx").on(table.pageId, table.termId)]
+)
+
+// 11. Bylines
+export const bylines = sqliteTable(
+  "bylines",
+  {
+    id: text("id")
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    name: text("name").notNull(),
+    slug: text("slug").notNull(),
+    websiteUrl: text("website_url"),
+    bio: text("bio"),
+    avatar: text("avatar"),
+    userId: text("user_id"),
+    socials: text("socials", { mode: "json" })
+      .$type<Record<string, string>>()
+      .default(sql`'{}'`),
+    metadata: text("metadata", { mode: "json" })
+      .$type<Record<string, any>>()
+      .default(sql`'{}'`),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull(),
+    deletedAt: integer("deleted_at", { mode: "timestamp" })
+  },
+  (table) => [uniqueIndex("bylines_slug_idx").on(table.slug)]
+)
+
+export type Byline = typeof bylines.$inferSelect
+export type NewByline = typeof bylines.$inferInsert
+export type SiteSettings = typeof siteSettings.$inferSelect
+export type InsertSiteSettings = typeof siteSettings.$inferInsert

package/src/storage/index.ts

@@ -65,8 +65,11 @@ export async function getR2Bucket(locals?: any, bindingName = "BLOB"): Promise<a
     }
   } catch {}
 
-  // 2. Direct locals property check (locals.env or locals[bindingName])
+  // 2. Direct locals property check (locals.runtime.env, locals.env or locals[bindingName])
   if (locals) {
+    if (locals.runtime?.env && locals.runtime.env[bindingName]) {
+      return locals.runtime.env[bindingName]
+    }
     if (locals.env && locals.env[bindingName]) {
       return locals.env[bindingName]
     }