@rimelight/cms 0.0.9 → 0.0.11

package/src/schema/content_types.ts

@@ -0,0 +1,59 @@
+import { boolean, jsonb, pgTable, text, timestamp, uuid } from "drizzle-orm/pg-core"
+import type { Localized } from "../core/types/pages"
+import type { BaseBlock } from "../core/types/blocks"
+
+export type CollectionMode = "document" | "data" | "singleton"
+
+export interface DynamicFieldDefinition {
+  type:
+    | "text"
+    | "number"
+    | "boolean"
+    | "enum"
+    | "media"
+    | "relation"
+    | "currency"
+    | "array"
+    | "json"
+  label: Localized
+  description?: Localized
+  required?: boolean
+  defaultValue?: any
+  options?: { label: Localized; value: string }[]
+  allowedCollections?: string[]
+  validation?: {
+    min?: number
+    max?: number
+    pattern?: string
+  }
+}
+
+export interface EcomSettings {
+  enabled: boolean
+  currencyDefault: string
+  trackInventory: boolean
+  hasVariants: boolean
+  allowDigitalDownloads: boolean
+  stripeSync?: boolean
+}
+
+export const contentTypes = pgTable("content_types", {
+  id: uuid("id").defaultRandom().notNull().primaryKey(),
+  slug: text("slug").notNull().unique(),
+  name: jsonb("name").$type<Localized>().notNull(),
+  description: jsonb("description").$type<Localized>(),
+  icon: text("icon").default("i-lucide-box").notNull(),
+  mode: text("mode").$type<CollectionMode>().default("document").notNull(),
+
+  fieldSchema: jsonb("field_schema")
+    .$type<Record<string, { label: Localized; fields: Record<string, DynamicFieldDefinition> }>>()
+    .default({})
+    .notNull(),
+
+  ecomSettings: jsonb("ecom_settings").$type<EcomSettings>(),
+  initialBlocks: jsonb("initial_blocks").$type<BaseBlock[]>().default([]).notNull(),
+  isSystem: boolean("is_system").default(false).notNull(),
+
+  createdAt: timestamp("created_at", { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp("updated_at", { withTimezone: true }).$onUpdate(() => new Date())
+})

package/src/schema/index.ts

@@ -9,3 +9,4 @@ export * from "./search.ts"
 export * from "./site_settings.ts"
 export * from "./taxonomies.ts"
 export * from "./bylines.ts"
+export * from "./content_types.ts"

package/src/schema/sqlite.ts

@@ -342,3 +342,38 @@ export type Byline = typeof bylines.$inferSelect
 export type NewByline = typeof bylines.$inferInsert
 export type SiteSettings = typeof siteSettings.$inferSelect
 export type InsertSiteSettings = typeof siteSettings.$inferInsert
+
+// 12. Dynamic Content Types
+export const contentTypes = sqliteTable(
+  "content_types",
+  {
+    id: text("id")
+      .$defaultFn(() => crypto.randomUUID())
+      .primaryKey(),
+    slug: text("slug").notNull(),
+    name: text("name", { mode: "json" }).$type<Localized>().notNull(),
+    description: text("description", { mode: "json" }).$type<Localized>(),
+    icon: text("icon").default("i-lucide-box").notNull(),
+    mode: text("mode").$type<"document" | "data" | "singleton">().default("document").notNull(),
+    fieldSchema: text("field_schema", { mode: "json" })
+      .$type<Record<string, any>>()
+      .default(sql`'{}'`)
+      .notNull(),
+    ecomSettings: text("ecom_settings", { mode: "json" }).$type<Record<string, any>>(),
+    initialBlocks: text("initial_blocks", { mode: "json" })
+      .$type<BaseBlock[]>()
+      .default(sql`'[]'`)
+      .notNull(),
+    isSystem: integer("is_system", { mode: "boolean" }).default(false).notNull(),
+    createdAt: integer("created_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .notNull(),
+    updatedAt: integer("updated_at", { mode: "timestamp" })
+      .$defaultFn(() => new Date())
+      .$onUpdate(() => new Date())
+  },
+  (table) => [uniqueIndex("content_types_slug_idx").on(table.slug)]
+)
+
+export type ContentType = typeof contentTypes.$inferSelect
+export type InsertContentType = typeof contentTypes.$inferInsert

package/src/services/search-indexer.ts

@@ -36,23 +36,34 @@ export async function indexPageForSearch(
         .where(and(eq(contentSearchIndex.pageId, page.id), eq(contentSearchIndex.locale, locale)))
         .limit(1)
 
+      const hasSearchVector = "searchVector" in contentSearchIndex
+
+      const updatePayload: Record<string, any> = {
+        titleText,
+        contentText
+      }
+      if (hasSearchVector) {
+        updatePayload["searchVector"] =
+          sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
+      }
+
       if (existing.length > 0) {
         await db
           .update(contentSearchIndex)
-          .set({
-            titleText,
-            contentText,
-            searchVector: sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
-          })
+          .set(updatePayload)
           .where(eq(contentSearchIndex.id, existing[0].id))
       } else {
-        await db.insert(contentSearchIndex).values({
+        const insertPayload: Record<string, any> = {
           pageId: page.id,
           locale,
           titleText,
-          contentText,
-          searchVector: sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
-        })
+          contentText
+        }
+        if (hasSearchVector) {
+          insertPayload["searchVector"] =
+            sql`to_tsvector('english', ${titleText} || ' ' || ${contentText})`
+        }
+        await db.insert(contentSearchIndex).values(insertPayload)
       }
     } catch (err) {
       console.error(`[Search Indexer] Failed to index page ${page.id} for locale ${locale}:`, err)

package/src/services/site-settings.ts

@@ -32,6 +32,22 @@ export const DEFAULT_SITE_SETTINGS: InsertSiteSettings = {
   }
 }
 
+function fallbackSettings(overrides?: Partial<InsertSiteSettings>): SiteSettings {
+  return {
+    id: overrides?.id ?? "default",
+    name: overrides?.name ?? DEFAULT_SITE_SETTINGS.name,
+    description: overrides?.description ?? DEFAULT_SITE_SETTINGS.description,
+    url: overrides?.url ?? DEFAULT_SITE_SETTINGS.url,
+    ogImage: overrides?.ogImage ?? DEFAULT_SITE_SETTINGS.ogImage,
+    author: overrides?.author ?? DEFAULT_SITE_SETTINGS.author,
+    email: overrides?.email ?? "",
+    branding: overrides?.branding ?? DEFAULT_SITE_SETTINGS.branding,
+    seo: overrides?.seo ?? DEFAULT_SITE_SETTINGS.seo,
+    createdAt: new Date(),
+    updatedAt: new Date()
+  }
+}
+
 /**
  * Retrieves the dynamic site settings from the database. If no settings are found, seeds the
  * default record and returns it.
@@ -41,13 +57,7 @@ export async function getSiteSettings(
   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
+    return fallbackSettings(fallbackDefaults)
   }
 
   try {
@@ -71,13 +81,7 @@ export async function getSiteSettings(
     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
+    return fallbackSettings(fallbackDefaults)
   }
 }
 

package/src/services/template-seeder.ts

@@ -0,0 +1,249 @@
+import { pageTemplates } from "../schema/page_templates.ts"
+import {
+  BLOG_POST_DEFINITION,
+  DOCUMENT_DEFINITION,
+  CHARACTER_DEFINITION,
+  HERO_DEFINITION,
+  SERIES_DEFINITION,
+  PATCH_NOTE_DEFINITION,
+  LOCATION_DEFINITION,
+  ITEM_DEFINITION,
+  SPECIES_DEFINITION,
+  SKILL_DEFINITION
+} from "../core/page-definitions.ts"
+
+export interface BuiltinTemplate {
+  slug: string
+  title: { en: string }
+  description: { en: string }
+  pageType: string
+  version: number
+  allowedRoles: string[]
+  rolePermissions: {
+    whoCanCreate: string[]
+    whoCanEdit: string[]
+    whoCanReview: string[]
+    whoCanView: string[]
+  }
+  approvalRules: {
+    allowSelfApproval: boolean
+    minApprovals: number
+  }
+  defaultProperties: Record<string, any>
+  initialBlocks: any[]
+}
+
+export function getBuiltinTemplates(): BuiltinTemplate[] {
+  return [
+    {
+      slug: "blog-post",
+      title: { en: "Blog Post" },
+      description: {
+        en: "Standard blog article with category metadata, author attribution, and formatted headings"
+      },
+      pageType: "blog",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: BLOG_POST_DEFINITION.properties,
+      initialBlocks: [
+        {
+          id: crypto.randomUUID(),
+          type: "HeadingBlock",
+          props: { level: 2, text: "Introduction" },
+          isTemplated: false
+        },
+        {
+          id: crypto.randomUUID(),
+          type: "ParagraphBlock",
+          props: { content: "Start writing your blog article here..." },
+          isTemplated: false
+        }
+      ]
+    },
+    {
+      slug: "documentation",
+      title: { en: "Documentation Guide" },
+      description: {
+        en: "Technical documentation page with structured sections, callouts, and code blocks"
+      },
+      pageType: "doc",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: DOCUMENT_DEFINITION.properties,
+      initialBlocks: [
+        {
+          id: crypto.randomUUID(),
+          type: "HeadingBlock",
+          props: { level: 2, text: "Overview" },
+          isTemplated: false
+        },
+        {
+          id: crypto.randomUUID(),
+          type: "CalloutBlock",
+          props: { variant: "info", content: "Key guide details and prerequisites go here." },
+          isTemplated: false
+        },
+        {
+          id: crypto.randomUUID(),
+          type: "HeadingBlock",
+          props: { level: 2, text: "Usage" },
+          isTemplated: false
+        }
+      ]
+    },
+    {
+      slug: "character-profile",
+      title: { en: "Character Profile" },
+      description: {
+        en: "Franchise character sheet with identity, characteristics, inventory, and backstory lore"
+      },
+      pageType: "character",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: CHARACTER_DEFINITION.properties,
+      initialBlocks: CHARACTER_DEFINITION.initialBlocks ? CHARACTER_DEFINITION.initialBlocks() : []
+    },
+    {
+      slug: "hero-sheet",
+      title: { en: "Hero Combat Sheet" },
+      description: {
+        en: "Hero character with combat stats, progression mechanics, and playstyle lore"
+      },
+      pageType: "hero",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: HERO_DEFINITION.properties,
+      initialBlocks: HERO_DEFINITION.initialBlocks ? HERO_DEFINITION.initialBlocks() : []
+    },
+    {
+      slug: "series-overview",
+      title: { en: "Series Overview" },
+      description: {
+        en: "Media show / series page with genre, season metadata, and episode overviews"
+      },
+      pageType: "series",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: SERIES_DEFINITION.properties,
+      initialBlocks: SERIES_DEFINITION.initialBlocks ? SERIES_DEFINITION.initialBlocks() : []
+    },
+    {
+      slug: "patch-note",
+      title: { en: "Release / Patch Note" },
+      description: {
+        en: "Version changelog, release highlights, balance adjustments, and bug fixes"
+      },
+      pageType: "patchnote",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: PATCH_NOTE_DEFINITION.properties,
+      initialBlocks: [
+        {
+          id: crypto.randomUUID(),
+          type: "HeadingBlock",
+          props: { level: 2, text: "Release Highlights" },
+          isTemplated: false
+        },
+        {
+          id: crypto.randomUUID(),
+          type: "HeadingBlock",
+          props: { level: 3, text: "Bug Fixes & Improvements" },
+          isTemplated: false
+        }
+      ]
+    },
+    {
+      slug: "location-guide",
+      title: { en: "World Location" },
+      description: { en: "Worldbuilding geography, climate conditions, and notable landmarks" },
+      pageType: "location",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: LOCATION_DEFINITION.properties,
+      initialBlocks: []
+    },
+    {
+      slug: "game-item",
+      title: { en: "Item & Equipment" },
+      description: { en: "Item rarity, pricing, quest associations, and equipment stats" },
+      pageType: "item",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: ITEM_DEFINITION.properties,
+      initialBlocks: []
+    },
+    {
+      slug: "species-entry",
+      title: { en: "Species Entry" },
+      description: { en: "Biological taxonomy, lifespan, and homeworld association" },
+      pageType: "species",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: SPECIES_DEFINITION.properties,
+      initialBlocks: []
+    },
+    {
+      slug: "skill-entry",
+      title: { en: "Skill & Ability" },
+      description: { en: "Ability cooldown, mana cost, and damage type mechanics" },
+      pageType: "skill",
+      version: 1,
+      allowedRoles: [],
+      rolePermissions: { whoCanCreate: [], whoCanEdit: [], whoCanReview: [], whoCanView: [] },
+      approvalRules: { allowSelfApproval: true, minApprovals: 1 },
+      defaultProperties: SKILL_DEFINITION.properties,
+      initialBlocks: []
+    }
+  ]
+}
+
+/**
+ * Ensures built-in page templates exist in the database. If page_templates table is empty,
+ * populates it with starter templates.
+ */
+export async function ensureDefaultTemplates(
+  dbInstance: any,
+  templateTable = pageTemplates
+): Promise<number> {
+  if (!dbInstance) return 0
+
+  try {
+    const existing = await dbInstance.select({ id: templateTable.id }).from(templateTable)
+    if (existing.length > 0) {
+      return existing.length
+    }
+
+    const defaultTemplates = getBuiltinTemplates()
+    for (const tmpl of defaultTemplates) {
+      try {
+        await dbInstance.insert(templateTable).values(tmpl)
+      } catch (insertErr) {
+        console.warn(`Failed to seed template ${tmpl.slug}:`, insertErr)
+      }
+    }
+
+    const seeded = await dbInstance.select().from(templateTable)
+    return seeded.length
+  } catch (err) {
+    console.warn("Error checking or seeding default templates:", err)
+    return 0
+  }
+}

package/src/storage/index.ts

@@ -58,7 +58,6 @@ export function r2(options: R2StorageOptions = {}): StorageConfig {
 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]