@rimelight/cms 0.0.2 → 0.0.3

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]
+}

package/src/services/taxonomies.ts

@@ -0,0 +1,276 @@
+import { taxonomyTerms, pageTaxonomyTerms } from "../schema/taxonomies"
+import { pages } from "../schema/pages"
+import type { TaxonomyTerm, TaxonomyQueryOptions } from "../core/types/taxonomies"
+import { eq, and, isNull, asc, sql } from "drizzle-orm"
+
+/**
+ * Retrieves all terms for a given taxonomy. If hierarchical, returns a tree structure with
+ * `children: TaxonomyTerm[]`.
+ */
+export async function getTaxonomyTerms(
+  db: any,
+  taxonomy: string,
+  options: TaxonomyQueryOptions = {}
+): Promise<TaxonomyTerm[]> {
+  if (!db) return []
+
+  const includeCounts = options.includeCounts ?? true
+
+  const rawTerms = await db
+    .select()
+    .from(taxonomyTerms)
+    .where(eq(taxonomyTerms.taxonomy, taxonomy))
+    .orderBy(asc(taxonomyTerms.displayOrder), asc(taxonomyTerms.createdAt))
+
+  if (!rawTerms || rawTerms.length === 0) return []
+
+  // Count active published posts per term if requested
+  const countsMap = new Map<string, number>()
+  if (includeCounts) {
+    try {
+      const counts = await db
+        .select({
+          termId: pageTaxonomyTerms.termId,
+          count: sql<number>`count(${pageTaxonomyTerms.pageId})::int`
+        })
+        .from(pageTaxonomyTerms)
+        .innerJoin(pages, eq(pages.id, pageTaxonomyTerms.pageId))
+        .where(isNull(pages.deletedAt))
+        .groupBy(pageTaxonomyTerms.termId)
+
+      for (const row of counts) {
+        countsMap.set(row.termId, Number(row.count))
+      }
+    } catch {
+      // Fallback if joined counts query fails
+    }
+  }
+
+  const termsWithCounts: TaxonomyTerm[] = rawTerms.map((t: any) => ({
+    id: t.id,
+    taxonomy: t.taxonomy,
+    slug: t.slug,
+    label: t.label,
+    description: t.description,
+    parentId: t.parentId,
+    displayOrder: t.displayOrder,
+    count: countsMap.get(t.id) ?? 0,
+    children: [],
+    createdAt: t.createdAt,
+    updatedAt: t.updatedAt
+  }))
+
+  // Determine if this taxonomy is hierarchical (any term has parentId)
+  const isHierarchical = termsWithCounts.some((t) => !!t.parentId)
+  if (!isHierarchical) {
+    return termsWithCounts
+  }
+
+  // Build tree
+  const idMap = new Map<string, TaxonomyTerm>()
+  const rootTerms: TaxonomyTerm[] = []
+
+  termsWithCounts.forEach((term) => {
+    idMap.set(term.id, term)
+  })
+
+  termsWithCounts.forEach((term) => {
+    if (term.parentId && idMap.has(term.parentId)) {
+      const parent = idMap.get(term.parentId)!
+      parent.children = parent.children || []
+      parent.children.push(term)
+    } else {
+      rootTerms.push(term)
+    }
+  })
+
+  return rootTerms
+}
+
+/**
+ * Retrieves a single term by taxonomy and slug.
+ */
+export async function getTerm(
+  db: any,
+  taxonomy: string,
+  slug: string
+): Promise<TaxonomyTerm | null> {
+  if (!db) return null
+
+  const results = await db
+    .select()
+    .from(taxonomyTerms)
+    .where(and(eq(taxonomyTerms.taxonomy, taxonomy), eq(taxonomyTerms.slug, slug)))
+    .limit(1)
+
+  if (!results[0]) return null
+
+  // Get post count
+  let count = 0
+  try {
+    const countResult = await db
+      .select({ count: sql<number>`count(${pageTaxonomyTerms.pageId})::int` })
+      .from(pageTaxonomyTerms)
+      .innerJoin(pages, eq(pages.id, pageTaxonomyTerms.pageId))
+      .where(and(eq(pageTaxonomyTerms.termId, results[0].id), isNull(pages.deletedAt)))
+    count = Number(countResult[0]?.count ?? 0)
+  } catch {
+    count = 0
+  }
+
+  return {
+    ...results[0],
+    count,
+    children: []
+  }
+}
+
+/**
+ * Retrieves all terms assigned to a specific page entry.
+ */
+export async function getEntryTerms(
+  db: any,
+  pageId: string,
+  taxonomy?: string
+): Promise<TaxonomyTerm[]> {
+  if (!db || !pageId) return []
+
+  const conditions = [eq(pageTaxonomyTerms.pageId, pageId)]
+  if (taxonomy) {
+    conditions.push(eq(taxonomyTerms.taxonomy, taxonomy))
+  }
+
+  const results = await db
+    .select({
+      id: taxonomyTerms.id,
+      taxonomy: taxonomyTerms.taxonomy,
+      slug: taxonomyTerms.slug,
+      label: taxonomyTerms.label,
+      description: taxonomyTerms.description,
+      parentId: taxonomyTerms.parentId,
+      displayOrder: taxonomyTerms.displayOrder
+    })
+    .from(pageTaxonomyTerms)
+    .innerJoin(taxonomyTerms, eq(taxonomyTerms.id, pageTaxonomyTerms.termId))
+    .where(and(...conditions))
+    .orderBy(asc(taxonomyTerms.displayOrder))
+
+  return results
+}
+
+/**
+ * Retrieves pages tagged with a given taxonomy term.
+ */
+export async function getEntriesByTerm(
+  db: any,
+  taxonomy: string,
+  slug: string,
+  options: { limit?: number; offset?: number; type?: string } = {}
+) {
+  if (!db) return { entries: [], total: 0 }
+
+  const term = await getTerm(db, taxonomy, slug)
+  if (!term) return { entries: [], total: 0 }
+
+  const conditions: any[] = [eq(pageTaxonomyTerms.termId, term.id), isNull(pages.deletedAt)]
+
+  if (options.type) {
+    conditions.push(eq(pages.type, options.type))
+  }
+
+  let query = db
+    .select({ page: pages })
+    .from(pageTaxonomyTerms)
+    .innerJoin(pages, eq(pages.id, pageTaxonomyTerms.pageId))
+    .where(and(...conditions))
+    .orderBy(asc(pages.createdAt))
+
+  if (options.limit) query = query.limit(options.limit)
+  if (options.offset) query = query.offset(options.offset)
+
+  const rows = await query
+  const entries = rows.map((r: any) => r.page)
+
+  return { entries, total: term.count ?? entries.length, term }
+}
+
+/**
+ * Sets/syncs the assigned terms for a page within a specific taxonomy.
+ */
+export async function assignEntryTerms(
+  db: any,
+  pageId: string,
+  taxonomy: string,
+  termIds: string[]
+) {
+  if (!db || !pageId) return
+
+  // Find all current terms in this taxonomy assigned to the page
+  const currentAssigned = await getEntryTerms(db, pageId, taxonomy)
+  const currentTermIds = new Set(currentAssigned.map((t) => t.id))
+  const newTermIds = new Set(termIds)
+
+  // Remove unassigned
+  for (const term of currentAssigned) {
+    if (!newTermIds.has(term.id)) {
+      await db
+        .delete(pageTaxonomyTerms)
+        .where(and(eq(pageTaxonomyTerms.pageId, pageId), eq(pageTaxonomyTerms.termId, term.id)))
+    }
+  }
+
+  // Insert newly assigned
+  for (const termId of termIds) {
+    if (!currentTermIds.has(termId)) {
+      await db.insert(pageTaxonomyTerms).values({ pageId, termId }).onConflictDoNothing()
+    }
+  }
+}
+
+/**
+ * Creates a new taxonomy term.
+ */
+export async function createTerm(
+  db: any,
+  data: {
+    taxonomy: string
+    slug: string
+    label: any
+    description?: any
+    parentId?: string | null
+    displayOrder?: number
+  }
+) {
+  const result = await db.insert(taxonomyTerms).values(data).returning()
+  return result[0]
+}
+
+/**
+ * Updates an existing taxonomy term.
+ */
+export async function updateTerm(
+  db: any,
+  id: string,
+  updates: Partial<{
+    slug: string
+    label: any
+    description: any
+    parentId: string | null
+    displayOrder: number
+  }>
+) {
+  const result = await db
+    .update(taxonomyTerms)
+    .set({ ...updates, updatedAt: new Date() })
+    .where(eq(taxonomyTerms.id, id))
+    .returning()
+  return result[0]
+}
+
+/**
+ * Deletes a taxonomy term.
+ */
+export async function deleteTerm(db: any, id: string) {
+  await db.delete(taxonomyTerms).where(eq(taxonomyTerms.id, id))
+  return { success: true }
+}