@rimelight/cms 0.0.2 → 0.0.4

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/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)]
+)

package/src/services/bylines.ts

@@ -0,0 +1,74 @@
+import { eq, and, isNull, or } from "drizzle-orm"
+import { bylines, type Byline, type NewByline } from "../schema/bylines.ts"
+
+/**
+ * Returns all active (non-deleted) bylines.
+ */
+export async function getBylines(db: any): Promise<Byline[]> {
+  if (!db) return []
+  return db.select().from(bylines).where(isNull(bylines.deletedAt)).orderBy(bylines.name)
+}
+
+/**
+ * Retrieves a single byline by ID or slug.
+ */
+export async function getByline(db: any, idOrSlug: string): Promise<Byline | null> {
+  if (!db || !idOrSlug) return null
+  const rows = await db
+    .select()
+    .from(bylines)
+    .where(
+      and(
+        isNull(bylines.deletedAt),
+        or(eq(bylines.id, idOrSlug as any), eq(bylines.slug, idOrSlug))
+      )
+    )
+    .limit(1)
+
+  return rows[0] || null
+}
+
+/**
+ * Creates a new byline.
+ */
+export async function createByline(db: any, data: NewByline): Promise<Byline> {
+  const [created] = await db
+    .insert(bylines)
+    .values({
+      ...data,
+      updatedAt: new Date()
+    })
+    .returning()
+  return created
+}
+
+/**
+ * Updates an existing byline.
+ */
+export async function updateByline(
+  db: any,
+  id: string,
+  data: Partial<NewByline>
+): Promise<Byline | null> {
+  const [updated] = await db
+    .update(bylines)
+    .set({
+      ...data,
+      updatedAt: new Date()
+    })
+    .where(and(eq(bylines.id, id as any), isNull(bylines.deletedAt)))
+    .returning()
+  return updated || null
+}
+
+/**
+ * Soft deletes a byline.
+ */
+export async function deleteByline(db: any, id: string): Promise<boolean> {
+  const [deleted] = await db
+    .update(bylines)
+    .set({ deletedAt: new Date(), updatedAt: new Date() })
+    .where(and(eq(bylines.id, id as any), isNull(bylines.deletedAt)))
+    .returning()
+  return !!deleted
+}

package/src/services/search-indexer.ts

@@ -0,0 +1,61 @@
+import { extractTextFromBlocks } from "../core/excerpt"
+import { contentSearchIndex } from "../schema/search"
+import { eq, and, sql } from "drizzle-orm"
+
+export async function indexPageForSearch(
+  db: any,
+  page: {
+    id: string
+    title: any
+    content: any
+  },
+  locales: string[] = ["en", "pt"]
+) {
+  if (!db) return
+
+  const parseJson = (val: any) => (typeof val === "string" ? JSON.parse(val) : val)
+  const titleObj = parseJson(page.title) || {}
+  const contentObj = parseJson(page.content) || {}
+  const blocks = contentObj.blocks || []
+
+  for (const locale of locales) {
+    const titleText =
+      typeof titleObj === "object" && titleObj !== null
+        ? titleObj[locale] || titleObj.en || Object.values(titleObj)[0] || ""
+        : String(titleObj || "")
+
+    const contentText = extractTextFromBlocks(blocks, locale)
+
+    if (!titleText && !contentText) continue
+
+    // Upsert search index record
+    try {
+      const existing = await db
+        .select()
+        .from(contentSearchIndex)
+        .where(and(eq(contentSearchIndex.pageId, page.id), eq(contentSearchIndex.locale, locale)))
+        .limit(1)
+
+      if (existing.length > 0) {
+        await db
+          .update(contentSearchIndex)
+          .set({
+            titleText,
+            contentText,
+            searchVector: sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
+          })
+          .where(eq(contentSearchIndex.id, existing[0].id))
+      } else {
+        await db.insert(contentSearchIndex).values({
+          pageId: page.id,
+          locale,
+          titleText,
+          contentText,
+          searchVector: sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
+        })
+      }
+    } catch (err) {
+      console.error(`[Search Indexer] Failed to index page ${page.id} for locale ${locale}:`, err)
+    }
+  }
+}

package/src/services/site-settings.ts

@@ -0,0 +1,108 @@
+import { eq } from "drizzle-orm"
+import {
+  siteSettings,
+  type InsertSiteSettings,
+  type SiteSettings
+} from "../schema/site_settings.ts"
+
+export const DEFAULT_SITE_SETTINGS: InsertSiteSettings = {
+  id: "default",
+  name: "Rimelight",
+  description: "Built with Rimelight CMS",
+  url: "https://rimelight.com",
+  ogImage: "https://cdn.rimelight.com/Images/og-placeholder.webp",
+  author: "Rimelight",
+  email: "",
+  branding: {
+    logo: {
+      alt: "Rimelight"
+    },
+    favicon: {
+      svg: "/favicon.svg"
+    },
+    colors: {
+      themeColor: "#ffffff",
+      backgroundColor: "#ffffff"
+    }
+  },
+  seo: {
+    titleTemplate: "%s | Rimelight",
+    ogImageFallback: "https://cdn.rimelight.com/Images/og-placeholder.webp",
+    maxDescriptionLength: 160
+  }
+}
+
+/**
+ * Retrieves the dynamic site settings from the database. If no settings are found, seeds the
+ * default record and returns it.
+ */
+export async function getSiteSettings(
+  db: any,
+  fallbackDefaults?: Partial<InsertSiteSettings>
+): Promise<SiteSettings> {
+  if (!db) {
+    // eslint-disable-next-line typescript/no-unsafe-type-assertion
+    return {
+      ...DEFAULT_SITE_SETTINGS,
+      ...fallbackDefaults,
+      createdAt: new Date(),
+      updatedAt: new Date()
+    } as SiteSettings
+  }
+
+  try {
+    const records = await db
+      .select()
+      .from(siteSettings)
+      .where(eq(siteSettings.id, "default"))
+      .limit(1)
+
+    if (records.length > 0) {
+      return records[0]
+    }
+
+    const initial: InsertSiteSettings = {
+      ...DEFAULT_SITE_SETTINGS,
+      ...fallbackDefaults,
+      id: "default"
+    }
+
+    const inserted = await db.insert(siteSettings).values(initial).returning()
+    return inserted[0]
+  } catch (error) {
+    console.warn("Failed to fetch site settings from DB, using fallback:", error)
+    // eslint-disable-next-line typescript/no-unsafe-type-assertion
+    return {
+      ...DEFAULT_SITE_SETTINGS,
+      ...fallbackDefaults,
+      createdAt: new Date(),
+      updatedAt: new Date()
+    } as SiteSettings
+  }
+}
+
+/**
+ * Updates dynamic site settings in the database.
+ */
+export async function updateSiteSettings(
+  db: any,
+  updates: Partial<InsertSiteSettings>,
+  id: string = "default"
+): Promise<SiteSettings> {
+  const current = await getSiteSettings(db)
+
+  const updatedValues = {
+    ...updates,
+    branding: updates.branding ? { ...current.branding, ...updates.branding } : current.branding,
+    seo: updates.seo ? { ...current.seo, ...updates.seo } : current.seo,
+    updatedAt: new Date()
+  }
+
+  const result = await db
+    .update(siteSettings)
+    .set(updatedValues)
+    .where(eq(siteSettings.id, id))
+    .returning()
+
+  return result[0]
+}