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

package/src/server/routes/globals.ts

@@ -0,0 +1,93 @@
+import { z } from 'astro/zod'
+import type { Auth } from '../better-auth.js'
+import type { VulseDb } from '../../core/db.js'
+import { GlobalsRepo } from '../../core/repos/globals.js'
+import { GlobalSetDefinitionSchema } from '../../core/globals/definition.js'
+import { NotFoundError } from '../../core/errors.js'
+import { defineHandler } from '../handler.js'
+
+const paramsHandle = z.object({ handle: z.string() })
+
+export function globalsRoutes(db: VulseDb, auth: Auth) {
+  const globals = new GlobalsRepo(db)
+
+  return {
+    list: defineHandler(auth, { requireRole: ['admin', 'editor'] }, async () => {
+      const rows = await globals.listSets()
+      return rows.map((row) => ({
+        handle: row.handle,
+        label: row.label,
+        fieldCount: row.definition.fields.length,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+      }))
+    }),
+
+    get: defineHandler(auth, {
+      params: paramsHandle,
+      requireRole: ['admin', 'editor'],
+    }, async ({ params }) => {
+      const set = await globals.findSetByHandle(params.handle)
+      if (!set) throw new NotFoundError('global set not found')
+      const value = await globals.getValue(params.handle)
+      return {
+        set: {
+          handle: set.handle,
+          label: set.label,
+          fields: set.definition.fields,
+          createdAt: set.createdAt,
+          updatedAt: set.updatedAt,
+        },
+        value: value ? {
+          handle: value.handle,
+          content: value.content,
+          createdAt: value.createdAt,
+          updatedAt: value.updatedAt,
+        } : null,
+      }
+    }),
+
+    create: defineHandler(auth, {
+      body: GlobalSetDefinitionSchema,
+      requireRole: ['admin'],
+    }, async ({ body }) => {
+      const row = await globals.createSet(body)
+      return {
+        handle: row.handle,
+        label: row.label,
+        fields: row.definition.fields,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+      }
+    }),
+
+    update: defineHandler(auth, {
+      params: paramsHandle,
+      body: GlobalSetDefinitionSchema,
+      requireRole: ['admin'],
+    }, async ({ params, body }) => {
+      const row = await globals.updateSet(params.handle, body)
+      return {
+        handle: row.handle,
+        label: row.label,
+        fields: row.definition.fields,
+        createdAt: row.createdAt,
+        updatedAt: row.updatedAt,
+      }
+    }),
+
+    updateValue: defineHandler(auth, {
+      params: paramsHandle,
+      body: z.record(z.string(), z.unknown()),
+      requireRole: ['admin'],
+    }, async ({ params, body }) => globals.updateValue(params.handle, body)),
+
+    delete: defineHandler(auth, {
+      params: paramsHandle,
+      requireRole: ['admin'],
+    }, async ({ params }) => {
+      await globals.deleteSet(params.handle)
+      return null
+    }),
+  }
+}

package/src/server/routes/media.ts

@@ -0,0 +1,145 @@
+import { z } from 'astro/zod'
+import type { VulseDb } from '../../core/db.js'
+import type { Auth } from '../better-auth.js'
+import type { AuthContext, Role } from '../../core/blueprints/types.js'
+import { MediaRepo, type MediaRow } from '../../core/repos/media.js'
+import { defineHandler } from '../handler.js'
+import { putToR2, deleteFromR2 } from '../r2.js'
+import { probeDimensions } from '../image-probe.js'
+import { buildDeliveryUrl, type CfImagesConfig } from '../cf-images.js'
+import { AccessDeniedError, NotFoundError, ValidationError } from '../../core/errors.js'
+import { fail, ok } from '../envelope.js'
+
+export interface MediaEnv {
+  bucket: R2Bucket
+  cfImages: CfImagesConfig
+}
+
+export interface MediaItem extends MediaRow {
+  deliveryUrl: string | null
+  previewUrl: string
+}
+
+const paramsId = z.object({ id: z.string() })
+
+const ALLOWED_MIME = new Set([
+  'image/jpeg',
+  'image/png',
+  'image/gif',
+  'image/webp',
+  'image/avif',
+  'image/svg+xml',
+])
+const MAX_UPLOAD_BYTES = 25 * 1024 * 1024 // 25 MB
+
+export function mediaRoutes(db: VulseDb, auth: Auth, mediaEnv: MediaEnv) {
+  const repo = new MediaRepo(db)
+
+  function withUrls(row: MediaRow): MediaItem {
+    const deliveryUrl = buildDeliveryUrl(mediaEnv.cfImages, row.id)
+    return {
+      ...row,
+      deliveryUrl,
+      previewUrl: deliveryUrl ?? `/api/vulse/media/${row.id}/file`,
+    }
+  }
+
+  async function requireRole(request: Request, roles: Role[]): Promise<AuthContext> {
+    const session = await auth.api.getSession({ headers: request.headers })
+    const authCtx: AuthContext = session ? {
+      user: {
+        id: session.user.id,
+        email: session.user.email,
+        role: (session.user as { role?: Role }).role ?? 'member',
+      },
+    } : { user: null }
+    if (!authCtx.user) throw new AccessDeniedError('Authentication required')
+    if (!roles.includes(authCtx.user.role)) {
+      throw new AccessDeniedError(`Requires role: ${roles.join(' or ')}`)
+    }
+    return authCtx
+  }
+
+  return {
+    list: defineHandler(auth, { requireRole: ['admin', 'editor'] }, async () => {
+      return (await repo.list({})).map(withUrls)
+    }),
+
+    upload: async (request: Request): Promise<Response> => {
+      try {
+        const authCtx = await requireRole(request, ['admin', 'editor'])
+        const form = await request.formData()
+        const entry = form.get('file')
+        if (!entry || typeof entry === 'string') throw new ValidationError('file required')
+        const file = entry as File
+        if (!ALLOWED_MIME.has(file.type)) {
+          throw new ValidationError(`Unsupported file type: ${file.type || 'unknown'}`)
+        }
+        if (file.size > MAX_UPLOAD_BYTES) {
+          throw new ValidationError(`File too large (max ${MAX_UPLOAD_BYTES} bytes)`)
+        }
+        const buf = await file.arrayBuffer()
+        if (buf.byteLength > MAX_UPLOAD_BYTES) {
+          throw new ValidationError(`File too large (max ${MAX_UPLOAD_BYTES} bytes)`)
+        }
+        const dims = probeDimensions(buf, file.type)
+        const { key } = await putToR2({ bucket: mediaEnv.bucket }, buf, file.type)
+        const row = await repo.create({
+          r2Key: key,
+          mime: file.type,
+          size: file.size,
+          ...(dims?.width !== undefined ? { width: dims.width } : {}),
+          ...(dims?.height !== undefined ? { height: dims.height } : {}),
+          uploadedBy: authCtx.user!.id,
+        })
+        return ok(withUrls(row))
+      } catch (err) {
+        return fail(err)
+      }
+    },
+
+    updateAlt: defineHandler(auth, {
+      params: paramsId,
+      body: z.object({ alt: z.string() }),
+      requireRole: ['admin', 'editor'],
+    }, async ({ params, body }) => {
+      await repo.updateAlt(params.id, body.alt)
+      return { ok: true }
+    }),
+
+    delete: defineHandler(auth, {
+      params: paramsId,
+      requireRole: ['admin', 'editor'],
+    }, async ({ params }) => {
+      await repo.softDelete(params.id)
+      return { ok: true }
+    }),
+
+    file: async (request: Request, rawParams: Record<string, string>): Promise<Response> => {
+      try {
+        await requireRole(request, ['admin', 'editor'])
+        const id = rawParams.id
+        if (!id) throw new ValidationError('id required')
+        const row = await repo.findById(id)
+        if (!row || row.deletedAt) throw new NotFoundError(`Media ${id} not found`)
+        const obj = await mediaEnv.bucket.get(row.r2Key)
+        if (!obj) throw new NotFoundError(`Media file ${id} not found`)
+        const headers = new Headers()
+        if (obj.httpMetadata?.contentType) headers.set('content-type', obj.httpMetadata.contentType)
+        headers.set('cache-control', 'private, max-age=3600')
+        return new Response(obj.body, { headers })
+      } catch (err) {
+        return fail(err)
+      }
+    },
+
+    purge: async (): Promise<{ purged: number }> => {
+      const rows = await repo.listPurgeable(7)
+      for (const r of rows) {
+        await deleteFromR2({ bucket: mediaEnv.bucket }, r.r2Key)
+        await repo.hardDelete(r.id)
+      }
+      return { purged: rows.length }
+    },
+  }
+}

package/src/server/routes/preview-sessions.ts

@@ -0,0 +1,76 @@
+import { z } from 'astro/zod'
+import type { Auth } from '../better-auth.js'
+import type { VulseDb } from '../../core/db.js'
+import type { BlueprintRegistry } from '../../core/blueprints/registry.js'
+import { defineHandler } from '../handler.js'
+import { resolvePreviewPath } from '../../core/blueprints/preview-path.js'
+import { PreviewSessionsRepo } from '../../core/repos/preview-sessions.js'
+import { AccessDeniedError, NotFoundError } from '../../core/errors.js'
+
+function buildPreviewUrl(origin: string, pathTemplate: string, slug: string, token: string): string {
+  const path = pathTemplate.replace('{slug}', encodeURIComponent(slug))
+  const url = new URL(path, origin)
+  url.searchParams.set('vulse_live_preview', token)
+  return url.toString()
+}
+
+export function previewSessionsRoutes(db: VulseDb, auth: Auth, registry: BlueprintRegistry) {
+  const repo = new PreviewSessionsRepo(db)
+
+  return {
+    create: defineHandler(auth, {
+      requireRole: ['admin', 'editor'],
+      body: z.object({
+        collection: z.string(),
+        entryId: z.string().nullable().optional(),
+        slug: z.string(),
+        content: z.record(z.string(), z.unknown()),
+        locale: z.string().optional(),
+      }),
+    }, async ({ auth: ctx, body, url }) => {
+      const bp = registry.get(body.collection)
+      if (!bp) throw new NotFoundError(`Collection ${body.collection} not found`)
+      const row = await repo.create({
+        userId: ctx.user!.id,
+        collection: body.collection,
+        slug: body.slug,
+        content: body.content,
+        entryId: body.entryId ?? null,
+        ...(body.locale !== undefined ? { locale: body.locale } : {}),
+      })
+      const previewPath = resolvePreviewPath(bp)
+      return {
+        id: row.id,
+        previewUrl: buildPreviewUrl(url.origin, previewPath, row.slug, row.id),
+        expiresAt: row.expiresAt.toISOString(),
+      }
+    }),
+
+    update: defineHandler(auth, {
+      requireRole: ['admin', 'editor'],
+      params: z.object({ id: z.string() }),
+      body: z.object({
+        slug: z.string().optional(),
+        content: z.record(z.string(), z.unknown()).optional(),
+        locale: z.string().optional(),
+      }),
+    }, async ({ auth: ctx, params, body }) => {
+      const patch: { slug?: string; content?: unknown; locale?: string } = {}
+      if (body.slug !== undefined) patch.slug = body.slug
+      if (body.content !== undefined) patch.content = body.content
+      if (body.locale !== undefined) patch.locale = body.locale
+      const updated = await repo.update(params.id, ctx.user!.id, patch)
+      if (!updated) throw new AccessDeniedError('Session not found or not owned by you')
+      return { expiresAt: updated.expiresAt.toISOString() }
+    }),
+
+    remove: defineHandler(auth, {
+      requireRole: ['admin', 'editor'],
+      params: z.object({ id: z.string() }),
+    }, async ({ auth: ctx, params }) => {
+      const ok = await repo.delete(params.id, ctx.user!.id)
+      if (!ok) throw new NotFoundError('Session not found')
+      return { ok: true }
+    }),
+  }
+}

package/src/server/routes/preview.ts

@@ -0,0 +1,36 @@
+import type { Auth } from '../better-auth.js'
+import { defineHandler } from '../handler.js'
+import { mintPreviewToken } from '../preview.js'
+
+function safePreviewTarget(raw: string | null, origin: string): URL {
+  const fallback = new URL('/', origin)
+  if (!raw) return fallback
+  // Reject anything that could escape origin: protocol-relative URLs (//evil.com)
+  // and any input that isn't a single leading "/" path.
+  if (!raw.startsWith('/') || raw.startsWith('//')) return fallback
+  try {
+    const candidate = new URL(raw, origin)
+    if (candidate.origin !== new URL(origin).origin) return fallback
+    return candidate
+  } catch {
+    return fallback
+  }
+}
+
+export function previewRoutes(auth: Auth, secret: string) {
+  return {
+    start: defineHandler(auth, { requireRole: ['admin', 'editor'] }, async ({ auth: authCtx, url }) => {
+      const token = await mintPreviewToken(secret, authCtx.user!.id)
+      const secure = url.protocol === 'https:'
+      const cookie = `vulse_preview=${token}; Path=/; HttpOnly; SameSite=Lax; Max-Age=3600${secure ? '; Secure' : ''}`
+      const redirect = safePreviewTarget(url.searchParams.get('to'), url.origin)
+      return new Response(null, { status: 302, headers: { Location: redirect.toString(), 'Set-Cookie': cookie } })
+    }),
+    stop: defineHandler(auth, {}, async ({ url }) => {
+      return new Response(null, {
+        status: 302,
+        headers: { Location: new URL('/', url.origin).toString(), 'Set-Cookie': 'vulse_preview=; Path=/; Max-Age=0' },
+      })
+    }),
+  }
+}

package/src/server/routes/revisions.ts

@@ -0,0 +1,29 @@
+import { z } from 'astro/zod'
+import type { VulseDb } from '../../core/db.js'
+import type { Auth } from '../better-auth.js'
+import { RevisionsRepo } from '../../core/repos/revisions.js'
+import { resolveLocale } from '../../core/locales.js'
+import { defineHandler } from '../handler.js'
+
+export function revisionsRoutes(db: VulseDb, auth: Auth) {
+  const repo = new RevisionsRepo(db)
+  return {
+    list: defineHandler(auth, {
+      params: z.object({ collection: z.string(), id: z.string() }),
+      requireRole: ['admin', 'editor'],
+    }, async ({ params, url }) => {
+      const locale = await resolveLocale(db, url.searchParams.get('locale'))
+      return await repo.listByEntry(params.id, locale)
+    }),
+
+    restore: defineHandler(auth, {
+      params: z.object({ collection: z.string(), id: z.string(), version: z.string() }),
+      requireRole: ['admin', 'editor'],
+    }, async ({ params, url, auth: authCtx }) => {
+      if (!authCtx.user) throw new Error('unreachable')
+      const locale = await resolveLocale(db, url.searchParams.get('locale'))
+      await repo.restore(params.id, Number(params.version), { userId: authCtx.user.id, locale })
+      return { restored: Number(params.version) }
+    }),
+  }
+}

package/src/server/routes/search.ts

@@ -0,0 +1,31 @@
+import { z } from 'astro/zod'
+import type { VulseDb } from '../../core/db.js'
+import type { Auth } from '../better-auth.js'
+import { defineHandler } from '../handler.js'
+import { searchSdk } from '../sdk/search.js'
+
+export function searchRoutes(db: VulseDb, auth: Auth) {
+  const sdk = searchSdk(db)
+  return {
+    query: defineHandler(auth, {
+      params: z.object({}),
+      body: z.object({
+        q: z.string(),
+        collections: z.array(z.string()).optional(),
+        limit: z.number().optional(),
+        includeDrafts: z.boolean().optional(),
+        locale: z.string().optional(),
+      }),
+    }, async ({ body, auth: authCtx }) => {
+      const role = authCtx.user?.role
+      const mayReadDrafts = role === 'admin' || role === 'editor'
+      const includeDrafts = body.includeDrafts === true && mayReadDrafts
+      return sdk.query(body.q, {
+        ...(body.collections !== undefined ? { collections: body.collections } : {}),
+        ...(body.limit !== undefined ? { limit: body.limit } : {}),
+        ...(body.locale !== undefined ? { locale: body.locale } : {}),
+        includeDrafts,
+      })
+    }),
+  }
+}

package/src/server/routes/sets.ts

@@ -0,0 +1,40 @@
+import { z } from 'astro/zod'
+import type { Auth } from '../better-auth.js'
+import type { VulseDb } from '../../core/db.js'
+import { SetDefinitionSchema } from '../../core/sets/definition.js'
+import { createSet, deleteSet, getSet, listSets, updateSet } from '../../core/sets/service.js'
+import { NotFoundError } from '../../core/errors.js'
+import { defineHandler } from '../handler.js'
+
+const paramsHandle = z.object({ handle: z.string() })
+
+export function setsRoutes(db: VulseDb, auth: Auth) {
+  return {
+    list: defineHandler(auth, {}, async () => listSets(db)),
+
+    get: defineHandler(auth, { params: paramsHandle }, async ({ params }) => {
+      const row = await getSet(db, params.handle)
+      if (!row) throw new NotFoundError('set not found')
+      return row
+    }),
+
+    create: defineHandler(auth, {
+      body: SetDefinitionSchema,
+      requireRole: ['admin'],
+    }, async ({ body }) => createSet(db, body)),
+
+    update: defineHandler(auth, {
+      params: paramsHandle,
+      body: SetDefinitionSchema,
+      requireRole: ['admin'],
+    }, async ({ params, body }) => updateSet(db, params.handle, body)),
+
+    delete: defineHandler(auth, {
+      params: paramsHandle,
+      requireRole: ['admin'],
+    }, async ({ params }) => {
+      await deleteSet(db, params.handle)
+      return null
+    }),
+  }
+}

package/src/server/routes/settings.ts

@@ -0,0 +1,24 @@
+import { z } from 'astro/zod'
+import type { VulseDb } from '../../core/db.js'
+import type { Auth } from '../better-auth.js'
+import { defineHandler } from '../handler.js'
+import { SettingsRepo } from '../../core/repos/settings.js'
+import { invalidateRuntime } from '../runtime.js'
+
+const AUTH_SETTING_KEYS = new Set(['allowMemberSignUp', 'allowedSignUpDomains'])
+
+export function settingsRoutes(db: VulseDb, auth: Auth) {
+  const repo = new SettingsRepo(db)
+  return {
+    list: defineHandler(auth, { requireRole: ['admin'] }, async () => await repo.all()),
+    set: defineHandler(auth, {
+      params: z.object({ key: z.string() }),
+      body: z.object({ value: z.unknown() }),
+      requireRole: ['admin'],
+    }, async ({ params, body }) => {
+      await repo.set(params.key, body.value)
+      if (AUTH_SETTING_KEYS.has(params.key)) invalidateRuntime()
+      return { key: params.key }
+    }),
+  }
+}

package/src/server/routes/users.ts

@@ -0,0 +1,127 @@
+import { z } from 'astro/zod'
+import { and, eq, like, or } from 'drizzle-orm'
+import { hashPassword } from 'better-auth/crypto'
+import { nanoid } from 'nanoid'
+import type { VulseDb } from '../../core/db.js'
+import type { Auth } from '../better-auth.js'
+import { account as accountTable, user as userTable } from '../../core/schema.js'
+import { defineHandler } from '../handler.js'
+import { NotFoundError } from '../../core/errors.js'
+
+const userFields = {
+  id: userTable.id,
+  email: userTable.email,
+  name: userTable.name,
+  role: userTable.role,
+  displayName: userTable.displayName,
+  emailVerified: userTable.emailVerified,
+  createdAt: userTable.createdAt,
+  updatedAt: userTable.updatedAt,
+}
+
+export function usersRoutes(db: VulseDb, auth: Auth) {
+  return {
+    list: defineHandler(auth, { requireRole: ['admin'] }, async ({ url }) => {
+      const q = url.searchParams.get('q')?.trim()
+      if (q) {
+        const pattern = `%${q}%`
+        return await db.select(userFields).from(userTable).where(or(
+          like(userTable.email, pattern),
+          like(userTable.name, pattern),
+          like(userTable.displayName, pattern),
+          eq(userTable.id, q),
+        ))
+      }
+      return await db.select(userFields).from(userTable)
+    }),
+
+    get: defineHandler(auth, {
+      params: z.object({ id: z.string() }),
+      requireRole: ['admin'],
+    }, async ({ params }) => {
+      const rows = await db.select(userFields).from(userTable).where(eq(userTable.id, params.id))
+      if (!rows.length) throw new NotFoundError(`User ${params.id} not found`)
+      return rows[0]
+    }),
+
+    update: defineHandler(auth, {
+      params: z.object({ id: z.string() }),
+      body: z.object({
+        name: z.string().min(1).optional(),
+        displayName: z.string().nullable().optional(),
+        role: z.enum(['admin', 'editor', 'member']).optional(),
+      }),
+      requireRole: ['admin'],
+    }, async ({ params, body }) => {
+      const existing = await db.select({ id: userTable.id }).from(userTable).where(eq(userTable.id, params.id))
+      if (!existing.length) throw new NotFoundError(`User ${params.id} not found`)
+
+      const patch: Partial<typeof userTable.$inferInsert> = { updatedAt: new Date() }
+      if (body.name !== undefined) patch.name = body.name
+      if (body.displayName !== undefined) patch.displayName = body.displayName
+      if (body.role !== undefined) patch.role = body.role
+
+      await db.update(userTable).set(patch).where(eq(userTable.id, params.id))
+      const rows = await db.select(userFields).from(userTable).where(eq(userTable.id, params.id))
+      return rows[0]
+    }),
+
+    setRole: defineHandler(auth, {
+      params: z.object({ id: z.string() }),
+      body: z.object({ role: z.enum(['admin', 'editor', 'member']) }),
+      requireRole: ['admin'],
+    }, async ({ params, body }) => {
+      const existing = await db.select({ id: userTable.id }).from(userTable).where(eq(userTable.id, params.id))
+      if (!existing.length) throw new NotFoundError(`User ${params.id} not found`)
+      await db.update(userTable).set({ role: body.role, updatedAt: new Date() }).where(eq(userTable.id, params.id))
+      return { id: params.id, role: body.role }
+    }),
+
+    resetPassword: defineHandler(auth, {
+      params: z.object({ id: z.string() }),
+      body: z.discriminatedUnion('action', [
+        z.object({ action: z.literal('email'), redirectTo: z.string().optional() }),
+        z.object({ action: z.literal('set'), password: z.string().min(8) }),
+      ]),
+      requireRole: ['admin'],
+    }, async ({ params, body, request }) => {
+      const rows = await db.select({ id: userTable.id, email: userTable.email }).from(userTable).where(eq(userTable.id, params.id))
+      if (!rows.length) throw new NotFoundError(`User ${params.id} not found`)
+      const target = rows[0]!
+
+      if (body.action === 'email') {
+        await auth.api.requestPasswordReset({
+          body: {
+            email: target.email,
+            redirectTo: body.redirectTo ?? '/reset-password',
+          },
+          headers: request.headers,
+        })
+        return { action: 'email' as const, sent: true }
+      }
+
+      const hashedPassword = await hashPassword(body.password)
+      const accounts = await db.select({ id: accountTable.id }).from(accountTable).where(and(
+        eq(accountTable.userId, params.id),
+        eq(accountTable.providerId, 'credential'),
+      ))
+
+      const now = new Date()
+      if (accounts.length) {
+        await db.update(accountTable).set({ password: hashedPassword, updatedAt: now }).where(eq(accountTable.id, accounts[0]!.id))
+      } else {
+        await db.insert(accountTable).values({
+          id: nanoid(),
+          userId: params.id,
+          accountId: params.id,
+          providerId: 'credential',
+          password: hashedPassword,
+          createdAt: now,
+          updatedAt: now,
+        })
+      }
+
+      return { action: 'set' as const, updated: true }
+    }),
+  }
+}