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

package/src/core/repos/forms.ts

@@ -0,0 +1,270 @@
+import { eq, and, gt, lt, sql, desc } from 'drizzle-orm'
+import { nanoid } from 'nanoid'
+import type { VulseDb } from '../db.js'
+import {
+  vulseForms,
+  vulseFormSubmissions,
+  vulseFormUniqueValues,
+  vulseFormUploadDrafts,
+} from '../schema.js'
+import { NotFoundError, ValidationError } from '../errors.js'
+import {
+  type FormDefinition,
+  FormDefinitionSchema,
+} from '../forms/definition.js'
+
+export interface FormRow {
+  handle: string
+  label: string
+  definition: FormDefinition
+  enabled: boolean
+  createdAt: Date
+  updatedAt: Date
+  submissionCount?: number
+}
+
+function parseRow(row: typeof vulseForms.$inferSelect): FormRow {
+  return {
+    handle: row.handle,
+    label: row.label,
+    definition: FormDefinitionSchema.parse(row.definition),
+    enabled: row.enabled,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+export class FormsRepo {
+  constructor(private db: VulseDb) {}
+
+  async create(input: FormDefinition): Promise<FormRow> {
+    const parsed = FormDefinitionSchema.safeParse(input)
+    if (!parsed.success) throw new ValidationError('Invalid form', { issues: parsed.error.issues })
+    const def = parsed.data
+    const now = new Date()
+    await this.db.insert(vulseForms).values({
+      handle: def.handle,
+      label: def.label,
+      definition: def,
+      enabled: def.settings.enabled,
+      createdAt: now,
+      updatedAt: now,
+    })
+    const row = await this.findByHandle(def.handle)
+    if (!row) throw new Error(`form not found after create: ${def.handle}`)
+    return row
+  }
+
+  async findByHandle(handle: string): Promise<FormRow | null> {
+    const row = await this.db.select().from(vulseForms).where(eq(vulseForms.handle, handle)).get()
+    return row ? parseRow(row) : null
+  }
+
+  async list(): Promise<FormRow[]> {
+    const rows = await this.db
+      .select({
+        handle: vulseForms.handle,
+        label: vulseForms.label,
+        definition: vulseForms.definition,
+        enabled: vulseForms.enabled,
+        createdAt: vulseForms.createdAt,
+        updatedAt: vulseForms.updatedAt,
+        submissionCount: sql<number>`(
+          SELECT COUNT(*) FROM vulse_form_submissions
+          WHERE form_handle = ${vulseForms.handle}
+        )`.mapWith(Number),
+      })
+      .from(vulseForms)
+      .orderBy(vulseForms.createdAt)
+    return rows.map((r) => ({
+      ...parseRow({
+        ...r,
+        // The list query intentionally omits schemaVersion; supply the default
+        // so parseRow's type-cast remains accurate without an over-broad `as`.
+        schemaVersion: 1,
+      } as typeof vulseForms.$inferSelect),
+      submissionCount: r.submissionCount,
+    }))
+  }
+
+  async update(handle: string, input: FormDefinition): Promise<FormRow> {
+    if (input.handle !== handle) {
+      throw new Error(`form handle is immutable (got '${input.handle}', expected '${handle}')`)
+    }
+    const parsed = FormDefinitionSchema.safeParse(input)
+    if (!parsed.success) throw new ValidationError('Invalid form', { issues: parsed.error.issues })
+    const def = parsed.data
+    await this.db.update(vulseForms).set({
+      label: def.label,
+      definition: def,
+      enabled: def.settings.enabled,
+      updatedAt: new Date(),
+    }).where(eq(vulseForms.handle, handle))
+    const row = await this.findByHandle(handle)
+    if (!row) throw new NotFoundError('form not found')
+    return row
+  }
+
+  async delete(handle: string): Promise<void> {
+    await this.db.delete(vulseForms).where(eq(vulseForms.handle, handle))
+  }
+}
+
+export interface SubmissionMeta {
+  ip?: string
+  userAgent?: string
+  referer?: string
+  locale?: string
+}
+
+export interface FileRef {
+  field: string
+  mediaId: string
+}
+
+export interface SubmissionRow {
+  id: string
+  formHandle: string
+  payload: Record<string, unknown>
+  fileRefs: FileRef[]
+  meta: SubmissionMeta
+  status: 'received' | 'processed' | 'failed'
+  error: string | null
+  createdAt: Date
+}
+
+function parseSubmission(row: typeof vulseFormSubmissions.$inferSelect): SubmissionRow {
+  return {
+    id: row.id,
+    formHandle: row.formHandle,
+    payload: row.payload as Record<string, unknown>,
+    fileRefs: (row.fileRefs ?? []) as FileRef[],
+    meta: row.meta as SubmissionMeta,
+    status: row.status,
+    error: row.error ?? null,
+    createdAt: row.createdAt,
+  }
+}
+
+export class SubmissionsRepo {
+  constructor(private db: VulseDb) {}
+
+  async create(input: {
+    formHandle: string
+    payload: Record<string, unknown>
+    fileRefs?: FileRef[]
+    meta: SubmissionMeta
+  }): Promise<SubmissionRow> {
+    const now = new Date()
+    const row = {
+      id: nanoid(),
+      formHandle: input.formHandle,
+      payload: input.payload,
+      fileRefs: input.fileRefs ?? [],
+      meta: input.meta,
+      status: 'received' as const,
+      error: null,
+      createdAt: now,
+    }
+    await this.db.insert(vulseFormSubmissions).values(row)
+    return parseSubmission(row as typeof vulseFormSubmissions.$inferSelect)
+  }
+
+  async findById(id: string): Promise<SubmissionRow | null> {
+    const row = await this.db.select().from(vulseFormSubmissions).where(eq(vulseFormSubmissions.id, id)).get()
+    return row ? parseSubmission(row) : null
+  }
+
+  async list(opts: { formHandle: string; limit?: number; offset?: number }): Promise<SubmissionRow[]> {
+    let query = this.db.select().from(vulseFormSubmissions)
+      .where(eq(vulseFormSubmissions.formHandle, opts.formHandle))
+      .orderBy(desc(vulseFormSubmissions.createdAt))
+    if (opts.limit !== undefined) query = query.limit(opts.limit) as typeof query
+    if (opts.offset !== undefined) query = query.offset(opts.offset) as typeof query
+    const rows = await query
+    return rows.map(parseSubmission)
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.db.delete(vulseFormUniqueValues).where(eq(vulseFormUniqueValues.submissionId, id))
+    await this.db.delete(vulseFormSubmissions).where(eq(vulseFormSubmissions.id, id))
+  }
+
+  async deleteMany(ids: string[]): Promise<number> {
+    if (ids.length === 0) return 0
+    for (const id of ids) {
+      await this.db.delete(vulseFormUniqueValues).where(eq(vulseFormUniqueValues.submissionId, id))
+    }
+    let deleted = 0
+    for (const id of ids) {
+      await this.db.delete(vulseFormSubmissions).where(eq(vulseFormSubmissions.id, id))
+      deleted++
+    }
+    return deleted
+  }
+
+  async updateStatus(id: string, status: 'processed' | 'failed', error?: string | null): Promise<void> {
+    await this.db.update(vulseFormSubmissions).set({
+      status,
+      error: error ?? null,
+    }).where(eq(vulseFormSubmissions.id, id))
+  }
+}
+
+export interface UploadDraftRow {
+  id: string
+  formHandle: string
+  fieldName: string
+  mediaId: string
+  expiresAt: Date
+  createdAt: Date
+}
+
+export class FormUploadDraftsRepo {
+  constructor(private db: VulseDb) {}
+
+  async create(input: {
+    formHandle: string
+    fieldName: string
+    mediaId: string
+    expiresAt: Date
+  }): Promise<UploadDraftRow> {
+    const now = new Date()
+    const row = {
+      id: nanoid(),
+      formHandle: input.formHandle,
+      fieldName: input.fieldName,
+      mediaId: input.mediaId,
+      expiresAt: input.expiresAt,
+      createdAt: now,
+    }
+    await this.db.insert(vulseFormUploadDrafts).values(row)
+    return row
+  }
+
+  async findValid(formHandle: string, fieldName: string, mediaId: string): Promise<UploadDraftRow | null> {
+    const row = await this.db.select().from(vulseFormUploadDrafts)
+      .where(and(
+        eq(vulseFormUploadDrafts.formHandle, formHandle),
+        eq(vulseFormUploadDrafts.fieldName, fieldName),
+        eq(vulseFormUploadDrafts.mediaId, mediaId),
+        gt(vulseFormUploadDrafts.expiresAt, new Date()),
+      ))
+      .get()
+    return row ?? null
+  }
+
+  async delete(id: string): Promise<void> {
+    await this.db.delete(vulseFormUploadDrafts).where(eq(vulseFormUploadDrafts.id, id))
+  }
+
+  async listExpired(before: Date): Promise<UploadDraftRow[]> {
+    const rows = await this.db.select().from(vulseFormUploadDrafts)
+      .where(lt(vulseFormUploadDrafts.expiresAt, before))
+    return rows
+  }
+
+  async attachToSubmission(draftId: string): Promise<void> {
+    await this.delete(draftId)
+  }
+}

package/src/core/repos/globals.ts

@@ -0,0 +1,179 @@
+import { eq } from 'drizzle-orm'
+import type { VulseDb } from '../db.js'
+import { vulseGlobalSets, vulseGlobalValues } from '../schema.js'
+import { ConflictError, NotFoundError, ValidationError } from '../errors.js'
+import { loadCompiledSets } from '../sets/service.js'
+import {
+  type GlobalSetDefinition,
+  GlobalSetDefinitionSchema,
+  hashGlobalSetDefinition,
+} from '../globals/definition.js'
+import { compileGlobalSet } from '../globals/compile.js'
+
+export interface GlobalSetRow {
+  handle: string
+  label: string
+  definition: GlobalSetDefinition
+  blueprintHash: string
+  createdAt: Date
+  updatedAt: Date
+}
+
+export interface GlobalValueRow {
+  handle: string
+  content: Record<string, unknown>
+  createdAt: Date
+  updatedAt: Date
+}
+
+export type PublicGlobals = Record<string, Record<string, unknown>>
+
+function parseSetRow(row: typeof vulseGlobalSets.$inferSelect): GlobalSetRow {
+  return {
+    handle: row.handle,
+    label: row.label,
+    definition: GlobalSetDefinitionSchema.parse(row.definition),
+    blueprintHash: row.blueprintHash,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+function parseValueRow(row: typeof vulseGlobalValues.$inferSelect): GlobalValueRow {
+  return {
+    handle: row.handle,
+    content: (row.content ?? {}) as Record<string, unknown>,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+export class GlobalsRepo {
+  constructor(private db: VulseDb) {}
+
+  async listSets(): Promise<GlobalSetRow[]> {
+    const rows = await this.db.select().from(vulseGlobalSets).orderBy(vulseGlobalSets.createdAt)
+    return rows.map(parseSetRow)
+  }
+
+  async findSetByHandle(handle: string): Promise<GlobalSetRow | null> {
+    const row = await this.db.select().from(vulseGlobalSets).where(eq(vulseGlobalSets.handle, handle)).get()
+    return row ? parseSetRow(row) : null
+  }
+
+  async createSet(input: GlobalSetDefinition): Promise<GlobalSetRow> {
+    const parsed = GlobalSetDefinitionSchema.safeParse(input)
+    if (!parsed.success) throw new ValidationError('Invalid global set', { issues: parsed.error.issues })
+    const def = parsed.data
+    const existing = await this.findSetByHandle(def.handle)
+    if (existing) throw new ConflictError(`global set already exists: ${def.handle}`)
+
+    const now = new Date()
+    const hash = await hashGlobalSetDefinition(def)
+    await this.db.insert(vulseGlobalSets).values({
+      handle: def.handle,
+      label: def.label,
+      definition: def,
+      blueprintHash: hash,
+      createdAt: now,
+      updatedAt: now,
+    })
+    await this.db.insert(vulseGlobalValues).values({
+      handle: def.handle,
+      content: {},
+      createdAt: now,
+      updatedAt: now,
+    })
+
+    const row = await this.findSetByHandle(def.handle)
+    if (!row) throw new Error(`global set not found after create: ${def.handle}`)
+    return row
+  }
+
+  async updateSet(handle: string, input: GlobalSetDefinition): Promise<GlobalSetRow> {
+    if (input.handle !== handle) {
+      throw new ValidationError('Global set handles are immutable', { issues: [{ path: ['handle'], message: 'Handle cannot be changed' }] })
+    }
+    const parsed = GlobalSetDefinitionSchema.safeParse(input)
+    if (!parsed.success) throw new ValidationError('Invalid global set', { issues: parsed.error.issues })
+    const def = parsed.data
+    const existing = await this.findSetByHandle(handle)
+    if (!existing) throw new NotFoundError('global set not found')
+
+    await this.db.update(vulseGlobalSets).set({
+      label: def.label,
+      definition: def,
+      blueprintHash: await hashGlobalSetDefinition(def),
+      updatedAt: new Date(),
+    }).where(eq(vulseGlobalSets.handle, handle))
+
+    const row = await this.findSetByHandle(handle)
+    if (!row) throw new NotFoundError('global set not found')
+    return row
+  }
+
+  async deleteSet(handle: string): Promise<void> {
+    const existing = await this.findSetByHandle(handle)
+    if (!existing) throw new NotFoundError('global set not found')
+    await this.db.delete(vulseGlobalSets).where(eq(vulseGlobalSets.handle, handle))
+  }
+
+  async getValue(handle: string): Promise<GlobalValueRow | null> {
+    const set = await this.findSetByHandle(handle)
+    if (!set) return null
+    const row = await this.db.select().from(vulseGlobalValues).where(eq(vulseGlobalValues.handle, handle)).get()
+    return row ? parseValueRow(row) : null
+  }
+
+  async updateValue(handle: string, input: unknown): Promise<GlobalValueRow> {
+    const set = await this.findSetByHandle(handle)
+    if (!set) throw new NotFoundError('global set not found')
+
+    const sets = await loadCompiledSets(this.db)
+    const compiled = await compileGlobalSet(set.definition, sets)
+    const result = compiled.schema.safeParse(input)
+    if (!result.success) {
+      throw new ValidationError('Invalid global value', { issues: result.error.issues })
+    }
+
+    const now = new Date()
+    const content = result.data as Record<string, unknown>
+    await this.db.insert(vulseGlobalValues).values({
+      handle,
+      content,
+      createdAt: now,
+      updatedAt: now,
+    }).onConflictDoUpdate({
+      target: vulseGlobalValues.handle,
+      set: { content, updatedAt: now },
+    })
+
+    const row = await this.getValue(handle)
+    if (!row) throw new Error(`global value not found after update: ${handle}`)
+    return row
+  }
+
+  async publicValues(): Promise<PublicGlobals> {
+    const rows = await this.db
+      .select({
+        handle: vulseGlobalValues.handle,
+        content: vulseGlobalValues.content,
+      })
+      .from(vulseGlobalValues)
+      .innerJoin(vulseGlobalSets, eq(vulseGlobalValues.handle, vulseGlobalSets.handle))
+      .orderBy(vulseGlobalSets.createdAt)
+
+    const out: PublicGlobals = {}
+    for (const row of rows) {
+      out[row.handle] = (row.content ?? {}) as Record<string, unknown>
+    }
+    return out
+  }
+
+  async publicValue(handle: string): Promise<Record<string, unknown> | null> {
+    const set = await this.findSetByHandle(handle)
+    if (!set) return null
+    const value = await this.getValue(handle)
+    return value?.content ?? {}
+  }
+}

package/src/core/repos/media.ts

@@ -0,0 +1,106 @@
+import { and, desc, eq, isNotNull, isNull, lt } from 'drizzle-orm'
+import { nanoid } from 'nanoid'
+import type { VulseDb } from '../db.js'
+import { media } from '../schema.js'
+import { NotFoundError } from '../errors.js'
+
+export interface MediaRow {
+  id: string
+  r2Key: string
+  mime: string
+  size: number
+  width: number | null
+  height: number | null
+  alt: string | null
+  blurhash: string | null
+  uploadedBy: string | null
+  createdAt: Date
+  deletedAt: Date | null
+}
+
+function rowToMedia(row: typeof media.$inferSelect): MediaRow {
+  return {
+    id: row.id,
+    r2Key: row.r2Key,
+    mime: row.mime,
+    size: row.size,
+    width: row.width ?? null,
+    height: row.height ?? null,
+    alt: row.alt ?? null,
+    blurhash: row.blurhash ?? null,
+    uploadedBy: row.uploadedBy ?? null,
+    createdAt: row.createdAt,
+    deletedAt: row.deletedAt ?? null,
+  }
+}
+
+export class MediaRepo {
+  constructor(private db: VulseDb) {}
+
+  async create(input: {
+    r2Key: string
+    mime: string
+    size: number
+    uploadedBy?: string | null
+    width?: number | null
+    height?: number | null
+    alt?: string | null
+    blurhash?: string | null
+  }): Promise<MediaRow> {
+    const now = new Date()
+    const row = {
+      id: nanoid(),
+      r2Key: input.r2Key,
+      mime: input.mime,
+      size: input.size,
+      width: input.width ?? null,
+      height: input.height ?? null,
+      alt: input.alt ?? null,
+      blurhash: input.blurhash ?? null,
+      uploadedBy: input.uploadedBy ?? null,
+      createdAt: now,
+      deletedAt: null,
+    }
+    await this.db.insert(media).values(row)
+    return rowToMedia(row as typeof media.$inferSelect)
+  }
+
+  async list(opts: { includeDeleted?: boolean; limit?: number; offset?: number } = {}): Promise<MediaRow[]> {
+    const conditions = opts.includeDeleted ? undefined : isNull(media.deletedAt)
+    let query = this.db.select().from(media)
+    if (conditions) query = query.where(conditions) as typeof query
+    query = query.orderBy(desc(media.createdAt)) as typeof query
+    if (opts.limit !== undefined) query = query.limit(opts.limit) as typeof query
+    if (opts.offset !== undefined) query = query.offset(opts.offset) as typeof query
+    const rows = await query
+    return rows.map(rowToMedia)
+  }
+
+  async findById(id: string): Promise<MediaRow | null> {
+    const [row] = await this.db.select().from(media).where(eq(media.id, id))
+    return row ? rowToMedia(row) : null
+  }
+
+  async softDelete(id: string): Promise<void> {
+    const existing = await this.findById(id)
+    if (!existing) throw new NotFoundError(`Media ${id} not found`)
+    await this.db.update(media).set({ deletedAt: new Date() }).where(eq(media.id, id))
+  }
+
+  async updateAlt(id: string, alt: string): Promise<void> {
+    const existing = await this.findById(id)
+    if (!existing) throw new NotFoundError(`Media ${id} not found`)
+    await this.db.update(media).set({ alt }).where(eq(media.id, id))
+  }
+
+  async listPurgeable(days: number): Promise<MediaRow[]> {
+    const cutoff = new Date(Date.now() - days * 86_400_000)
+    const rows = await this.db.select().from(media)
+      .where(and(isNotNull(media.deletedAt), lt(media.deletedAt, cutoff)))
+    return rows.map(rowToMedia)
+  }
+
+  async hardDelete(id: string): Promise<void> {
+    await this.db.delete(media).where(eq(media.id, id))
+  }
+}

package/src/core/repos/preview-sessions.ts

@@ -0,0 +1,108 @@
+import { nanoid } from 'nanoid'
+import { eq, lt } from 'drizzle-orm'
+import type { VulseDb } from '../db.js'
+import { vulsePreviewSessions } from '../schema.js'
+import { DEFAULT_LOCALE } from './entries.js'
+
+const DEFAULT_TTL_MS = 60 * 60 * 1000
+
+export interface PreviewSessionRow {
+  id: string
+  userId: string
+  entryId: string | null
+  collection: string
+  locale: string
+  slug: string
+  content: unknown
+  expiresAt: Date
+  createdAt: Date
+  updatedAt: Date
+}
+
+function mapRow(row: typeof vulsePreviewSessions.$inferSelect): PreviewSessionRow {
+  return {
+    id: row.id,
+    userId: row.userId,
+    entryId: row.entryId ?? null,
+    collection: row.collection,
+    locale: row.locale,
+    slug: row.slug,
+    content: row.content,
+    expiresAt: row.expiresAt,
+    createdAt: row.createdAt,
+    updatedAt: row.updatedAt,
+  }
+}
+
+export class PreviewSessionsRepo {
+  constructor(private db: VulseDb) {}
+
+  async create(input: {
+    userId: string
+    collection: string
+    slug: string
+    content: unknown
+    locale?: string
+    entryId?: string | null
+    ttlMs?: number
+  }): Promise<PreviewSessionRow> {
+    const now = new Date()
+    const ttl = input.ttlMs ?? DEFAULT_TTL_MS
+    const id = nanoid(32)
+    const row = {
+      id,
+      userId: input.userId,
+      entryId: input.entryId ?? null,
+      collection: input.collection,
+      locale: input.locale ?? DEFAULT_LOCALE,
+      slug: input.slug,
+      content: input.content,
+      expiresAt: new Date(now.getTime() + ttl),
+      createdAt: now,
+      updatedAt: now,
+    }
+    await this.db.insert(vulsePreviewSessions).values(row)
+    return mapRow(row)
+  }
+
+  async findById(id: string): Promise<PreviewSessionRow | null> {
+    const row = await this.db.query.vulsePreviewSessions.findFirst({
+      where: eq(vulsePreviewSessions.id, id),
+    })
+    if (!row) return null
+    if (row.expiresAt.getTime() < Date.now()) return null
+    return mapRow(row)
+  }
+
+  async update(id: string, userId: string, patch: { slug?: string; content?: unknown; locale?: string }): Promise<PreviewSessionRow | null> {
+    const existing = await this.findById(id)
+    if (!existing || existing.userId !== userId) return null
+    const now = new Date()
+    const next = {
+      slug: patch.slug ?? existing.slug,
+      content: patch.content ?? existing.content,
+      locale: patch.locale ?? existing.locale,
+      expiresAt: new Date(now.getTime() + DEFAULT_TTL_MS),
+      updatedAt: now,
+    }
+    await this.db.update(vulsePreviewSessions).set(next).where(eq(vulsePreviewSessions.id, id))
+    return { ...existing, ...next }
+  }
+
+  async delete(id: string, userId: string): Promise<boolean> {
+    const existing = await this.findById(id)
+    if (!existing || existing.userId !== userId) return false
+    await this.db.delete(vulsePreviewSessions).where(eq(vulsePreviewSessions.id, id))
+    return true
+  }
+
+  async purgeExpired(now = new Date()): Promise<number> {
+    const expired = await this.db.select({ id: vulsePreviewSessions.id })
+      .from(vulsePreviewSessions)
+      .where(lt(vulsePreviewSessions.expiresAt, now))
+    for (const row of expired) {
+      await this.db.delete(vulsePreviewSessions).where(eq(vulsePreviewSessions.id, row.id))
+    }
+    return expired.length
+  }
+}