@rimelight/cms 0.0.2 → 0.0.4

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

package/src/storage/index.ts

@@ -0,0 +1,256 @@
+export interface StorageFile {
+  key: string
+  name: string
+  size: number
+  mimeType: string
+  uploadedAt: string
+  url: string
+  etag?: string
+  customMetadata?: Record<string, string>
+}
+
+export interface StorageListResult {
+  files: StorageFile[]
+  truncated: boolean
+  cursor?: string
+}
+
+export interface R2StorageOptions {
+  binding?: string | undefined
+  publicUrl?: string | undefined
+  prefix?: string | undefined
+}
+
+export interface StorageConfig {
+  provider: "r2" | "local" | "s3"
+  binding?: string | undefined
+  publicUrl?: string | undefined
+  prefix?: string | undefined
+}
+
+export interface StorageListOptions {
+  prefix?: string | undefined
+  cursor?: string | undefined
+  limit?: number | undefined
+  publicUrl?: string | undefined
+  apiBasePath?: string | undefined
+}
+
+export interface StorageUploadOptions {
+  key?: string | undefined
+  prefix?: string | undefined
+  publicUrl?: string | undefined
+  apiBasePath?: string | undefined
+}
+
+export function r2(options: R2StorageOptions = {}): StorageConfig {
+  return {
+    provider: "r2",
+    binding: options.binding ?? "BLOB",
+    publicUrl: options.publicUrl,
+    prefix: options.prefix ?? "media/"
+  }
+}
+
+/**
+ * Resolves Cloudflare R2 bucket instance from Cloudflare env or Astro locals.
+ */
+export async function getR2Bucket(locals?: any, bindingName = "BLOB"): Promise<any> {
+  // 1. Try cloudflare:workers standard export (Astro v6+)
+  try {
+    // @ts-ignore
+    const cf = await import("cloudflare:workers")
+    if (cf?.env && cf.env[bindingName]) {
+      return cf.env[bindingName]
+    }
+  } catch {}
+
+  // 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]
+    }
+    if (locals[bindingName]) {
+      return locals[bindingName]
+    }
+  }
+
+  // 3. Global process.env fallback
+  if (typeof process !== "undefined" && process.env && (process.env as any)[bindingName]) {
+    return (process.env as any)[bindingName]
+  }
+
+  return null
+}
+
+/**
+ * Lists files from R2 Bucket under configured prefix.
+ */
+export async function listR2Files(
+  bucket: any,
+  options: StorageListOptions = {}
+): Promise<StorageListResult> {
+  if (!bucket || typeof bucket.list !== "function") {
+    return { files: [], truncated: false }
+  }
+
+  const prefix = options.prefix ?? "media/"
+  const limit = options.limit ?? 50
+
+  const result = await bucket.list({
+    prefix,
+    cursor: options.cursor,
+    limit
+  })
+
+  const files: StorageFile[] = (result.objects || []).map((obj: any) => {
+    const rawKey = obj.key as string
+    const name = rawKey.startsWith(prefix) ? rawKey.slice(prefix.length) : rawKey
+    const cleanedName = name.includes("/") ? name.split("/").pop()! : name
+    const mimeType = obj.httpMetadata?.contentType || guessMimeType(rawKey)
+
+    // Resolve public URL: custom domain, or proxy endpoint
+    let url = ""
+    if (options.publicUrl) {
+      const baseUrl = options.publicUrl.endsWith("/")
+        ? options.publicUrl.slice(0, -1)
+        : options.publicUrl
+      url = `${baseUrl}/${rawKey}`
+    } else if (options.apiBasePath) {
+      const baseApi = options.apiBasePath.endsWith("/")
+        ? options.apiBasePath.slice(0, -1)
+        : options.apiBasePath
+      url = `${baseApi}/${rawKey}`
+    } else {
+      url = `/cms/api/media/${rawKey}`
+    }
+
+    return {
+      key: rawKey,
+      name: cleanedName,
+      size: obj.size,
+      mimeType,
+      uploadedAt: obj.uploaded ? new Date(obj.uploaded).toISOString() : new Date().toISOString(),
+      url,
+      etag: obj.etag,
+      customMetadata: obj.customMetadata
+    }
+  })
+
+  return {
+    files,
+    truncated: result.truncated,
+    cursor: result.cursor
+  }
+}
+
+/**
+ * Uploads a file buffer/stream into R2 Bucket.
+ */
+export async function uploadR2File(
+  bucket: any,
+  file: File,
+  options: StorageUploadOptions = {}
+): Promise<StorageFile> {
+  if (!bucket || typeof bucket.put !== "function") {
+    throw new Error("R2 bucket binding is not available in runtime environment.")
+  }
+
+  const prefix = options.prefix ?? "media/"
+  const timestamp = Date.now()
+  const safeName = file.name.replace(/[^a-zA-Z0-9._-]/g, "_")
+  const randomSuffix = Math.random().toString(36).substring(2, 8)
+  const key = options.key ?? `${prefix}${timestamp}-${randomSuffix}/${safeName}`
+
+  const arrayBuffer = await file.arrayBuffer()
+
+  const r2Object = await bucket.put(key, arrayBuffer, {
+    httpMetadata: {
+      contentType: file.type || guessMimeType(safeName),
+      contentDisposition: `inline; filename="${safeName}"`
+    },
+    customMetadata: {
+      originalName: file.name,
+      uploadedAt: new Date().toISOString()
+    }
+  })
+
+  let url = ""
+  if (options.publicUrl) {
+    const baseUrl = options.publicUrl.endsWith("/")
+      ? options.publicUrl.slice(0, -1)
+      : options.publicUrl
+    url = `${baseUrl}/${key}`
+  } else if (options.apiBasePath) {
+    const baseApi = options.apiBasePath.endsWith("/")
+      ? options.apiBasePath.slice(0, -1)
+      : options.apiBasePath
+    url = `${baseApi}/${key}`
+  } else {
+    url = `/cms/api/media/${key}`
+  }
+
+  return {
+    key,
+    name: safeName,
+    size: file.size,
+    mimeType: file.type || guessMimeType(safeName),
+    uploadedAt: new Date().toISOString(),
+    url,
+    etag: r2Object?.etag
+  }
+}
+
+/**
+ * Deletes a file from R2 Bucket by key.
+ */
+export async function deleteR2File(bucket: any, key: string): Promise<boolean> {
+  if (!bucket || typeof bucket.delete !== "function") {
+    throw new Error("R2 bucket binding is not available in runtime environment.")
+  }
+  await bucket.delete(key)
+  return true
+}
+
+/**
+ * MIME type guesser fallback.
+ */
+function guessMimeType(filename: string): string {
+  const ext = filename.split(".").pop()?.toLowerCase()
+  switch (ext) {
+    case "jpg":
+    case "jpeg":
+      return "image/jpeg"
+    case "png":
+      return "image/png"
+    case "webp":
+      return "image/webp"
+    case "gif":
+      return "image/gif"
+    case "svg":
+      return "image/svg+xml"
+    case "avif":
+      return "image/avif"
+    case "mp4":
+      return "video/mp4"
+    case "webm":
+      return "video/webm"
+    case "mp3":
+      return "audio/mpeg"
+    case "wav":
+      return "audio/wav"
+    case "pdf":
+      return "application/pdf"
+    case "json":
+      return "application/json"
+    case "txt":
+      return "text/plain"
+    case "zip":
+      return "application/zip"
+    default:
+      return "application/octet-stream"
+  }
+}