@ekrist1/vulse 0.1.6-alpha.3 → 0.1.7-alpha.4

package/src/server/runtime.ts

@@ -0,0 +1,99 @@
+import { createDb } from '../core/db.js'
+import { createAuth } from './better-auth.js'
+import { BlueprintRegistry } from '../core/blueprints/registry.js'
+import { entriesRoutes } from './routes/entries.js'
+import { revisionsRoutes } from './routes/revisions.js'
+import { usersRoutes } from './routes/users.js'
+import { settingsRoutes } from './routes/settings.js'
+import { blueprintsRoutes } from './routes/blueprints.js'
+import { setsRoutes } from './routes/sets.js'
+import { mediaRoutes } from './routes/media.js'
+import { searchRoutes } from './routes/search.js'
+import { previewRoutes } from './routes/preview.js'
+import { previewSessionsRoutes } from './routes/preview-sessions.js'
+import { formsRoutes } from './routes/forms.js'
+import { formSubmitRoutes } from './routes/form-submit.js'
+import { formUploadRoutes } from './routes/form-upload.js'
+import { globalsRoutes } from './routes/globals.js'
+import { globalsPublicRoutes } from './routes/globals-public.js'
+import { createSdk } from './sdk/index.js'
+import { previewSecret } from './preview.js'
+import type { Auth } from './better-auth.js'
+import type { RuntimeEnv } from './env.js'
+
+export interface VulseRuntime {
+  db: ReturnType<typeof createDb>
+  auth: Auth
+  registry: BlueprintRegistry
+  sdk: ReturnType<typeof createSdk>
+  routes: {
+    entries: ReturnType<typeof entriesRoutes>
+    revisions: ReturnType<typeof revisionsRoutes>
+    users: ReturnType<typeof usersRoutes>
+    settings: ReturnType<typeof settingsRoutes>
+    blueprints: ReturnType<typeof blueprintsRoutes>
+    sets: ReturnType<typeof setsRoutes>
+    media: ReturnType<typeof mediaRoutes>
+    search: ReturnType<typeof searchRoutes>
+    preview: ReturnType<typeof previewRoutes>
+    previewSessions: ReturnType<typeof previewSessionsRoutes>
+    forms: ReturnType<typeof formsRoutes>
+    formSubmit: ReturnType<typeof formSubmitRoutes>
+    formUpload: ReturnType<typeof formUploadRoutes>
+    globals: ReturnType<typeof globalsRoutes>
+    globalsPublic: ReturnType<typeof globalsPublicRoutes>
+  }
+}
+
+let cached: VulseRuntime | null = null
+
+export async function getRuntime(env: RuntimeEnv, registry: BlueprintRegistry, baseURL: string): Promise<VulseRuntime> {
+  if (cached) return cached
+  const db = createDb(env.DB)
+  const auth = await createAuth(db, {
+    baseURL: env.BETTER_AUTH_URL ?? baseURL,
+    secret: env.BETTER_AUTH_SECRET,
+    ...(env.VULSE_ALLOW_MEMBER_SIGNUP === 'true' ? { allowSignUp: true } : {}),
+    env: env as unknown as Record<string, unknown>,
+  })
+  if (!env.BUCKET) throw new Error('Vulse: R2 binding "BUCKET" is missing. Add it to wrangler.toml.')
+  const cfImages = {
+    ...(env.CF_IMAGES_ACCOUNT_HASH ? { accountHash: env.CF_IMAGES_ACCOUNT_HASH } : {}),
+    ...(env.CF_IMAGES_TOKEN ? { token: env.CF_IMAGES_TOKEN } : {}),
+  }
+  cached = {
+    db, auth, registry,
+    sdk: createSdk(db, auth, registry, cfImages),
+    routes: {
+      entries: entriesRoutes(db, auth, registry),
+      revisions: revisionsRoutes(db, auth),
+      users: usersRoutes(db, auth),
+      settings: settingsRoutes(db, auth),
+      blueprints: blueprintsRoutes(db, auth),
+      sets: setsRoutes(db, auth),
+      media: mediaRoutes(db, auth, {
+        bucket: env.BUCKET,
+        cfImages,
+      }),
+      search: searchRoutes(db, auth),
+      preview: previewRoutes(auth, previewSecret(env)),
+      previewSessions: previewSessionsRoutes(db, auth, registry),
+      forms: formsRoutes(db, auth),
+      formSubmit: formSubmitRoutes(db, {
+        ...(env.FORM_QUEUE ? { queue: env.FORM_QUEUE } : {}),
+        env: env as unknown as Record<string, unknown>,
+      }),
+      formUpload: formUploadRoutes(db, { bucket: env.BUCKET }),
+      globals: globalsRoutes(db, auth),
+      globalsPublic: globalsPublicRoutes(db),
+    },
+  }
+  return cached
+}
+
+export function invalidateRuntime(): void { cached = null }
+
+/** @deprecated use invalidateRuntime */
+export function _resetRuntime(): void { invalidateRuntime() }
+
+export type { RuntimeEnv } from './env.js'

package/src/server/sdk/collections.ts

@@ -0,0 +1,98 @@
+import type { VulseDb } from '../../core/db.js'
+import { readLocalesConfig } from '../../core/locales.js'
+import { EntriesRepo, type EntryOrderBy, type EntryRow } from '../../core/repos/entries.js'
+import { evaluate } from '../../core/access.js'
+import type { BlueprintRegistry } from '../../core/blueprints/registry.js'
+import type { AuthContext } from '../../core/blueprints/types.js'
+
+export interface CollectionSdkOptions {
+  audience?: AuthContext['user'] | null
+  includeDrafts?: boolean
+  locale?: string
+}
+
+export interface CollectionFindOptions extends CollectionSdkOptions {
+  limit?: number
+  offset?: number
+  createdBy?: string
+  /** ISO date string or Date */
+  publishedAfter?: Date | string
+  publishedBefore?: Date | string
+  orderBy?: EntryOrderBy
+  order?: 'asc' | 'desc'
+}
+
+function parseDate(v: Date | string | undefined): Date | undefined {
+  if (v === undefined) return undefined
+  const d = v instanceof Date ? v : new Date(v)
+  return Number.isNaN(d.getTime()) ? undefined : d
+}
+
+export function collectionsSdk(db: VulseDb, reg: BlueprintRegistry) {
+  const entries = new EntriesRepo(db)
+
+  async function resolveLocale(explicit?: string): Promise<string> {
+    if (explicit) return explicit
+    return (await readLocalesConfig(db)).defaultLocale
+  }
+
+  async function gatedRows(
+    name: string,
+    audience: AuthContext['user'] | null,
+    listOpts: Omit<Parameters<EntriesRepo['list']>[0], 'collection' | 'status'>,
+    status?: 'draft' | 'published',
+  ): Promise<EntryRow[]> {
+    const bp = reg.get(name)
+    if (!bp) throw new Error(`Unknown collection: ${name}`)
+    const rows = await entries.list({ collection: name, ...(status ? { status } : {}), ...listOpts })
+    const out: EntryRow[] = []
+    for (const r of rows) {
+      const allowed = await evaluate(bp, 'read', {
+        user: audience ?? null,
+        entry: { id: r.id, status: r.status, createdBy: r.createdBy, content: r.content },
+      })
+      if (allowed) out.push(r)
+    }
+    return out
+  }
+
+  return {
+    find: async (collection: string, opts: CollectionFindOptions = {}) => {
+      const status = opts.includeDrafts ? undefined : 'published'
+      const publishedAfter = parseDate(opts.publishedAfter)
+      const publishedBefore = parseDate(opts.publishedBefore)
+      return gatedRows(collection, opts.audience ?? null, {
+        locale: await resolveLocale(opts.locale),
+        ...(opts.limit !== undefined ? { limit: opts.limit } : {}),
+        ...(opts.offset !== undefined ? { offset: opts.offset } : {}),
+        ...(opts.createdBy !== undefined ? { createdBy: opts.createdBy } : {}),
+        ...(publishedAfter !== undefined ? { publishedAfter } : {}),
+        ...(publishedBefore !== undefined ? { publishedBefore } : {}),
+        ...(opts.orderBy !== undefined ? { orderBy: opts.orderBy } : {}),
+        ...(opts.order !== undefined ? { order: opts.order } : {}),
+      }, status)
+    },
+    findById: async (collection: string, id: string, opts: CollectionSdkOptions = {}) => {
+      const bp = reg.get(collection)
+      if (!bp) throw new Error(`Unknown collection: ${collection}`)
+      const r = await entries.findById(id, await resolveLocale(opts.locale))
+      if (!r) return null
+      const allowed = await evaluate(bp, 'read', {
+        user: opts.audience ?? null,
+        entry: { id: r.id, status: r.status, createdBy: r.createdBy, content: r.content },
+      })
+      return allowed ? r : null
+    },
+    findBySlug: async (collection: string, slug: string, opts: CollectionSdkOptions = {}) => {
+      const bp = reg.get(collection)
+      if (!bp) throw new Error(`Unknown collection: ${collection}`)
+      const r = await entries.findBySlug(collection, slug, await resolveLocale(opts.locale))
+      if (!r) return null
+      const allowed = await evaluate(bp, 'read', {
+        user: opts.audience ?? null,
+        entry: { id: r.id, status: r.status, createdBy: r.createdBy, content: r.content },
+      })
+      return allowed ? r : null
+    },
+  }
+}

package/src/server/sdk/index.ts

@@ -0,0 +1,25 @@
+import type { VulseDb } from '../../core/db.js'
+import type { Auth } from '../better-auth.js'
+import type { BlueprintRegistry } from '../../core/blueprints/registry.js'
+import { collectionsSdk } from './collections.js'
+import { mediaSdk } from './media.js'
+import { searchSdk } from './search.js'
+import type { CfImagesConfig } from '../cf-images.js'
+
+export function createSdk(
+  db: VulseDb,
+  auth: Auth,
+  registry: BlueprintRegistry,
+  cfImages: CfImagesConfig,
+) {
+  return {
+    collections: collectionsSdk(db, registry),
+    media: mediaSdk(db, cfImages),
+    search: searchSdk(db),
+    auth: {
+      session: (request: Request) => auth.api.getSession({ headers: request.headers }),
+    },
+  }
+}
+
+export type VulseSdk = ReturnType<typeof createSdk>

package/src/server/sdk/media.ts

@@ -0,0 +1,11 @@
+import type { VulseDb } from '../../core/db.js'
+import { MediaRepo } from '../../core/repos/media.js'
+import { buildDeliveryUrl, type CfImagesConfig, type Variant } from '../cf-images.js'
+
+export function mediaSdk(db: VulseDb, cfg: CfImagesConfig) {
+  const repo = new MediaRepo(db)
+  return {
+    url: (id: string, variant: Variant | string = 'card') => buildDeliveryUrl(cfg, id, variant),
+    findById: (id: string) => repo.findById(id),
+  }
+}

package/src/server/sdk/search.ts

@@ -0,0 +1,90 @@
+import type { VulseDb } from '../../core/db.js'
+
+export interface SearchResult {
+  entryId: string
+  collection: string
+  locale: string
+  slug: string
+  title: string
+  snippet: string
+}
+
+export interface SearchOptions {
+  collections?: string[]
+  limit?: number
+  includeDrafts?: boolean
+  locale?: string
+}
+
+function safeCollection(name: string): string {
+  if (!/^[a-z0-9_-]+$/.test(name)) throw new Error(`Invalid collection: ${name}`)
+  return name
+}
+
+function buildMatchExpression(query: string): string {
+  // FTS5: quote each token and append * for prefix match. Doubling " escapes it
+  // inside the quoted token. Tokens that reduce to empty after stripping non-
+  // word characters are dropped.
+  const tokens = query
+    .split(/\s+/)
+    .map((t) => t.replace(/[^\p{L}\p{N}_]+/gu, ''))
+    .filter((t) => t.length > 0)
+    .map((t) => `"${t.replace(/"/g, '""')}"*`)
+  return tokens.join(' ')
+}
+
+export function searchSdk(db: VulseDb) {
+  const d1 = db.$client
+
+  return {
+    query: async (query: string, opts: SearchOptions = {}): Promise<SearchResult[]> => {
+      const limit = Math.max(1, Math.min(opts.limit ?? 20, 100))
+      const match = buildMatchExpression(query)
+      if (!match) return []
+
+      const parts = [
+        `SELECT f.entry_id, f.collection, f.locale, f.slug, f.title,`,
+        `snippet(vulse_entries_fts, 4, '<mark>', '</mark>', '…', 8) AS snippet`,
+        `FROM vulse_entries_fts f`,
+        `INNER JOIN vulse_entry_locales el`,
+        `  ON el.entry_id = f.entry_id AND el.locale = f.locale`,
+        `WHERE vulse_entries_fts MATCH ?`,
+      ]
+      const binds: unknown[] = [match]
+
+      if (opts.locale) {
+        parts.push(`AND f.locale = ?`)
+        binds.push(opts.locale)
+      }
+
+      if (!opts.includeDrafts) parts.push(`AND el.status = 'published'`)
+
+      if (opts.collections && opts.collections.length > 0) {
+        const collections = opts.collections.map(safeCollection)
+        const placeholders = collections.map(() => '?').join(', ')
+        parts.push(`AND f.collection IN (${placeholders})`)
+        binds.push(...collections)
+      }
+
+      parts.push(`LIMIT ${limit}`)
+
+      const { results } = await d1.prepare(parts.join(' ')).bind(...binds).all<{
+        entry_id: string
+        collection: string
+        locale: string
+        slug: string
+        title: string | null
+        snippet: string
+      }>()
+
+      return results.map((r) => ({
+        entryId: r.entry_id,
+        collection: r.collection,
+        locale: r.locale,
+        slug: r.slug,
+        title: r.title ?? r.slug,
+        snippet: r.snippet,
+      }))
+    },
+  }
+}