katecms 0.0.0-stage → 1.0.0-beta.1

package/src/runtime/server/api/_katecms/auth/register.post.ts

@@ -0,0 +1,112 @@
+import { createError, defineEventHandler, readBody } from 'h3'
+import { useRuntimeConfig } from '#imports'
+import {
+  OWNER_ROLE,
+  SUBSCRIBER_ROLE,
+  createUser,
+  hasAnyUser,
+  hashPassword,
+  isUniqueConstraintError,
+  toSafeUser,
+  validateEmail,
+  validatePassword,
+} from '@katecms/core'
+import type { SafeUser } from '@katecms/core'
+import { getDb } from '../../../utils/db'
+import { setUserSession } from '../../../utils/session'
+import {
+  assertAuthAttemptAllowed,
+  getAuthAttemptKeys,
+  recordAuthAttemptFailure,
+  recordAuthAttemptSuccess,
+  throwTooManyAttempts,
+} from '../../../utils/auth-rate-limit'
+
+interface RegisterBody {
+  email?: unknown
+  password?: unknown
+  passwordConfirm?: unknown
+}
+
+/**
+ * Self-service registration.
+ *
+ * The first account ever created becomes `owner` (the protected superuser);
+ * every later registration is a `subscriber`. The "is this the first user?"
+ * check and the INSERT run inside a single transaction so two concurrent
+ * first-time registrations can't both claim ownership.
+ *
+ * `registration: false` rejects every account after the first. Admin user
+ * creation does not use this handler.
+ *
+ * A duplicate email is a generic 422. The message does not say the address
+ * is already registered, and no session is issued.
+ */
+export default defineEventHandler(async (event): Promise<{ user: SafeUser }> => {
+  const body = await readBody<RegisterBody>(event)
+  const email = typeof body?.email === 'string' ? body.email.trim() : ''
+  const password = typeof body?.password === 'string' ? body.password : ''
+  const passwordConfirm = typeof body?.passwordConfirm === 'string' ? body.passwordConfirm : ''
+
+  const attemptKeys = getAuthAttemptKeys(event, 'register', email)
+  assertAuthAttemptAllowed(event, attemptKeys)
+
+  const failValidation = (statusMessage: string): never => {
+    const { retryAfterMs } = recordAuthAttemptFailure(attemptKeys)
+    if (retryAfterMs > 0) {
+      throwTooManyAttempts(event, retryAfterMs)
+    }
+    throw createError({ statusCode: 422, statusMessage: 'Unprocessable Entity', message: statusMessage })
+  }
+
+  const emailCheck = validateEmail(email)
+  if (!emailCheck.ok) {
+    failValidation(emailCheck.error)
+  }
+  const passwordCheck = validatePassword(password)
+  if (!passwordCheck.ok) {
+    failValidation(passwordCheck.error)
+  }
+  if (password !== passwordConfirm) {
+    failValidation('Passwords do not match.')
+  }
+
+  const passwordHash = await hashPassword(password)
+  const registrationOpen = useRuntimeConfig().katecms?.registration === true
+
+  try {
+    const user = await getDb().transaction().execute(async (trx) => {
+      const isFirstUser = !(await hasAnyUser(trx))
+      if (!isFirstUser && !registrationOpen) {
+        throw createError({
+          statusCode: 403,
+          statusMessage: 'Forbidden',
+          message: 'Registration is disabled.',
+        })
+      }
+      return createUser(trx, {
+        email,
+        password_hash: passwordHash,
+        role: isFirstUser ? OWNER_ROLE : SUBSCRIBER_ROLE,
+      })
+    })
+
+    recordAuthAttemptSuccess(attemptKeys)
+    await setUserSession(event, user.id, user.session_version)
+    return { user: toSafeUser(user) }
+  }
+  catch (error) {
+    if (isUniqueConstraintError(error)) {
+      const { retryAfterMs } = recordAuthAttemptFailure(attemptKeys)
+      if (retryAfterMs > 0) {
+        throwTooManyAttempts(event, retryAfterMs)
+      }
+      throw createError({
+        statusCode: 422,
+        statusMessage: 'Unprocessable Entity',
+        message: 'Could not create the account.',
+      })
+    }
+    throw error
+  }
+})

package/src/runtime/server/api/_katecms/auth/state.get.ts

@@ -0,0 +1,19 @@
+import { defineEventHandler } from 'h3'
+import { hasAnyUser, type AuthState } from '@katecms/core'
+import { getDb } from '../../../utils/db'
+import { getCurrentUser } from '../../../utils/session'
+
+/**
+ * Combined auth snapshot for the route guard:
+ * - hasUsers drives the first-run flow (no users -> /admin/register, else /admin/login);
+ * - user drives the authenticated redirects (keep logged-in users out of the
+ *   auth pages).
+ */
+export default defineEventHandler(async (event): Promise<AuthState> => {
+  const hasUsers = await hasAnyUser(getDb())
+  const user = await getCurrentUser(event)
+  return {
+    user,
+    hasUsers,
+  }
+})

package/src/runtime/server/api/_katecms/collections/[collection]/[id].delete.ts

@@ -0,0 +1,77 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { useRuntimeConfig } from '#imports'
+import {
+  canOnEntry,
+  deleteCollection,
+  deleteTrashedCollections,
+  findCollectionById,
+  listCollections,
+} from '@katecms/core'
+import { getDb } from '../../../../utils/db'
+import { requireUser } from '../../../../utils/session'
+import { requireEntryPermission, requirePermission } from '../../../../utils/permissions'
+import {
+  fail,
+  readCollectionSlug,
+  readEntryId,
+  requireCollection,
+  toCollectionMeta,
+} from '../../../../utils/collections'
+import type { AdminCollectionMeta } from '../../../../../utils/collections'
+
+type DeleteEntryResult = { collection: AdminCollectionMeta, ok: true }
+type EmptyTrashResult = { collection: AdminCollectionMeta, deleted: number }
+
+/**
+ * Permanently delete one entry (`/:id`) or every trashed entry the actor may
+ * delete (`/trash`). Nitro would otherwise treat `trash` as `:id`.
+ */
+export default defineEventHandler(async (event): Promise<DeleteEntryResult | EmptyTrashResult> => {
+  const actor = await requireUser(event)
+  const collectionSlug = readCollectionSlug(getRouterParam(event, 'collection'))
+  const rawId = getRouterParam(event, 'id')
+  const def = requireCollection(collectionSlug)
+  const roles = useRuntimeConfig().katecms?.roles ?? {}
+  requirePermission(actor, 'collections', 'delete', roles, collectionSlug)
+
+  const db = getDb()
+
+  if (rawId === 'trash') {
+    const rows = await listCollections(db, collectionSlug, { status: 'trash' })
+    const ids = rows
+      .filter(row => canOnEntry(actor, 'collections', 'delete', { authorId: row.author_id }, {
+        roles,
+        scope: collectionSlug,
+        userId: actor.id,
+      }))
+      .map(row => row.id)
+
+    const deleted = await deleteTrashedCollections(db, collectionSlug, ids)
+    return {
+      collection: toCollectionMeta(collectionSlug, def),
+      deleted,
+    }
+  }
+
+  const id = readEntryId(rawId)
+  const existing = await findCollectionById(db, id)
+  if (!existing || existing.type !== collectionSlug) {
+    fail(404, 'Entry not found.')
+  }
+
+  requireEntryPermission(
+    actor,
+    'collections',
+    'delete',
+    { authorId: existing.author_id },
+    roles,
+    collectionSlug,
+  )
+
+  await deleteCollection(db, id)
+
+  return {
+    collection: toCollectionMeta(collectionSlug, def),
+    ok: true,
+  }
+})

package/src/runtime/server/api/_katecms/collections/[collection]/[id].get.ts

@@ -0,0 +1,57 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { useRuntimeConfig } from '#imports'
+import { findCollectionById, listCollectionParentOptions, loadCollectionSlugPath } from '@katecms/core'
+import { getDb } from '../../../../utils/db'
+import { requireUser } from '../../../../utils/session'
+import { requirePermission } from '../../../../utils/permissions'
+import {
+  entryFlags,
+  fail,
+  readCollectionSlug,
+  readEntryId,
+  requireCollection,
+  toAdminEntry,
+  toCollectionMeta,
+  toParentOption,
+} from '../../../../utils/collections'
+import type { CollectionEntryResponse } from '../../../../../utils/collections'
+import {
+  loadCollectionDictionaryPickers,
+  selectedDictionaryIds,
+} from '../../../../utils/dictionaries'
+
+/** Fetch a single collection entry (including trash). */
+export default defineEventHandler(async (event): Promise<CollectionEntryResponse> => {
+  const actor = await requireUser(event)
+  const collectionSlug = readCollectionSlug(getRouterParam(event, 'collection'))
+  const id = readEntryId(getRouterParam(event, 'id'))
+  const def = requireCollection(collectionSlug)
+  const roles = useRuntimeConfig().katecms?.roles ?? {}
+  requirePermission(actor, 'collections', 'read', roles, collectionSlug)
+
+  const db = getDb()
+  const row = await findCollectionById(db, id)
+  if (!row || row.type !== collectionSlug) {
+    fail(404, 'Entry not found.')
+  }
+
+  const slugPath = (await loadCollectionSlugPath(db, collectionSlug, id)) || row.slug
+  const flags = entryFlags(actor, row, roles)
+  const meta = toCollectionMeta(collectionSlug, def)
+  const pickers = await loadCollectionDictionaryPickers(db, collectionSlug)
+  const dictionaryIds = await selectedDictionaryIds(db, id, pickers)
+  const response: CollectionEntryResponse = {
+    collection: meta,
+    entry: toAdminEntry(row, slugPath, { ...flags, dictionaryIds }),
+    canUpdate: flags.canUpdate,
+    canDelete: flags.canDelete,
+    dictionaries: pickers,
+  }
+
+  if (meta.hierarchical) {
+    const parents = await listCollectionParentOptions(db, collectionSlug, id)
+    response.parents = parents.map(toParentOption)
+  }
+
+  return response
+})

package/src/runtime/server/api/_katecms/collections/[collection]/[id].patch.ts

@@ -0,0 +1,157 @@
+import { defineEventHandler, getRouterParam, readBody } from 'h3'
+import { useRuntimeConfig } from '#imports'
+import { findCollectionById, listCollectionParentOptions, loadCollectionSlugPath, updateCollection } from '@katecms/core'
+import type { CollectionUpdate } from '@katecms/core'
+import { getDb } from '../../../../utils/db'
+import { requireUser } from '../../../../utils/session'
+import { requireEntryPermission, requirePermission } from '../../../../utils/permissions'
+import {
+  entryFlags,
+  fail,
+  readCollectionSlug,
+  readEntryId,
+  readFields,
+  readMenuOrder,
+  readParentId,
+  readPublishedAt,
+  readSlug,
+  readStatus,
+  readTitle,
+  requireCollection,
+  requirePublishedFields,
+  resolveAuthorId,
+  rethrowCollectionWriteError,
+  toAdminEntry,
+  toCollectionMeta,
+  toParentOption,
+  collectionRevisionsEnabled,
+} from '../../../../utils/collections'
+import type { CollectionEntryResponse } from '../../../../../utils/collections'
+import {
+  applyDictionaryAssignments,
+  loadCollectionDictionaryPickers,
+  selectedDictionaryIds,
+} from '../../../../utils/dictionaries'
+import { entryRevisionSnapshot, recordEntryRevision } from '../../../../utils/revisions'
+interface PatchBody {
+  title?: unknown
+  slug?: unknown
+  status?: unknown
+  fields?: unknown
+  parentId?: unknown
+  menuOrder?: unknown
+  publishedAt?: unknown
+  authorId?: unknown
+  dictionaries?: unknown
+}
+
+/** Partial update of a collection entry (including restore / move to trash). */
+export default defineEventHandler(async (event): Promise<CollectionEntryResponse> => {
+  const actor = await requireUser(event)
+  const collectionSlug = readCollectionSlug(getRouterParam(event, 'collection'))
+  const id = readEntryId(getRouterParam(event, 'id'))
+  const def = requireCollection(collectionSlug)
+  const roles = useRuntimeConfig().katecms?.roles ?? {}
+  requirePermission(actor, 'collections', 'update', roles, collectionSlug)
+
+  const db = getDb()
+  const existing = await findCollectionById(db, id)
+  if (!existing || existing.type !== collectionSlug) {
+    fail(404, 'Entry not found.')
+  }
+
+  requireEntryPermission(
+    actor,
+    'collections',
+    'update',
+    { authorId: existing.author_id },
+    roles,
+    collectionSlug,
+  )
+
+  const body = await readBody<PatchBody>(event)
+  const patch: CollectionUpdate = {}
+
+  if (body?.title !== undefined) {
+    patch.title = readTitle(body.title)
+  }
+  if (body?.slug !== undefined) {
+    patch.slug = readSlug(body.slug)
+  }
+  if (body?.fields !== undefined) {
+    patch.fields = readFields(body.fields)
+  }
+  if (body?.menuOrder !== undefined) {
+    patch.menu_order = readMenuOrder(body.menuOrder)
+  }
+  if (def.hierarchical === true && body?.parentId !== undefined) {
+    patch.parent_id = readParentId(body.parentId)
+  }
+  if (body?.status !== undefined) {
+    patch.status = readStatus(body.status, existing.status)
+  }
+  if (body?.publishedAt !== undefined) {
+    const publishedAt = readPublishedAt(body.publishedAt)
+    const nextStatus = patch.status ?? existing.status
+    if (nextStatus === 'published' && publishedAt == null) {
+      // Keep existing date (or let core fill on first publish).
+    }
+    else {
+      patch.published_at = publishedAt
+    }
+  }
+  if (body?.authorId !== undefined) {
+    patch.author_id = await resolveAuthorId(
+      db,
+      actor,
+      roles,
+      body.authorId,
+      existing.author_id ?? actor.id,
+    )
+  }
+
+  const nextStatus = patch.status ?? existing.status
+  if (nextStatus === 'published') {
+    const nextFields = (patch.fields ?? existing.fields ?? {}) as Record<string, unknown>
+    requirePublishedFields(def, nextStatus, nextFields)
+  }
+
+  const trackRevisions = collectionRevisionsEnabled(def)
+  const pickersBefore = await loadCollectionDictionaryPickers(db, collectionSlug)
+  const previous = trackRevisions
+    ? entryRevisionSnapshot(existing, await selectedDictionaryIds(db, id, pickersBefore))
+    : null
+
+  try {
+    const row = await updateCollection(db, id, patch)
+    if (!row) {
+      fail(404, 'Entry not found.')
+    }
+    if (body?.dictionaries !== undefined) {
+      await applyDictionaryAssignments(db, id, collectionSlug, body.dictionaries)
+    }
+    const slugPath = (await loadCollectionSlugPath(db, collectionSlug, id)) || row.slug
+    const flags = entryFlags(actor, row, roles)
+    const meta = toCollectionMeta(collectionSlug, def)
+    const pickers = pickersBefore
+    const dictionaryIds = await selectedDictionaryIds(db, id, pickers)
+    if (trackRevisions && previous) {
+      await recordEntryRevision(db, id, actor.id, previous, entryRevisionSnapshot(row, dictionaryIds))
+    }
+    const response: CollectionEntryResponse = {
+      collection: meta,
+      entry: toAdminEntry(row, slugPath, { ...flags, dictionaryIds }),
+      canUpdate: flags.canUpdate,
+      canDelete: flags.canDelete,
+      dictionaries: pickers,
+    }
+    if (meta.hierarchical) {
+      const parents = await listCollectionParentOptions(db, collectionSlug, id)
+      response.parents = parents.map(toParentOption)
+    }
+    return response
+  }
+  catch (error) {
+    rethrowCollectionWriteError(error)
+  }
+})

package/src/runtime/server/api/_katecms/collections/[collection]/revisions/[revisionId].post.ts

@@ -0,0 +1,133 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { useRuntimeConfig } from '#imports'
+import {
+  findCollectionById,
+  findCollectionRevisionById,
+  listCollectionParentOptions,
+  loadCollectionSlugPath,
+  updateCollection,
+} from '@katecms/core'
+import { getDb } from '../../../../../utils/db'
+import { requireUser } from '../../../../../utils/session'
+import { requireEntryPermission, requirePermission } from '../../../../../utils/permissions'
+import {
+  entryFlags,
+  fail,
+  readCollectionSlug,
+  readEntryId,
+  readFields,
+  readMenuOrder,
+  readPublishedAt,
+  readSlug,
+  readStatus,
+  readTitle,
+  requireCollection,
+  requirePublishedFields,
+  rethrowCollectionWriteError,
+  toAdminEntry,
+  toCollectionMeta,
+  toParentOption,
+  collectionRevisionsEnabled,
+} from '../../../../../utils/collections'
+import type { CollectionEntryResponse } from '../../../../../../utils/collections'
+import {
+  applyDictionaryAssignments,
+  loadCollectionDictionaryPickers,
+  selectedDictionaryIds,
+} from '../../../../../utils/dictionaries'
+import {
+  entryRevisionSnapshot,
+  readEntryRevisionData,
+  recordEntryRevision,
+  revisionAuthorId,
+} from '../../../../../utils/revisions'
+
+/** Replace an entry with a saved revision. The current state stays in the revision list. */
+export default defineEventHandler(async (event): Promise<CollectionEntryResponse> => {
+  const actor = await requireUser(event)
+  const collectionSlug = readCollectionSlug(getRouterParam(event, 'collection'))
+  const id = readEntryId(getRouterParam(event, 'id'))
+  const revisionId = readRevisionId(getRouterParam(event, 'revisionId'))
+  const def = requireCollection(collectionSlug)
+  if (!collectionRevisionsEnabled(def)) {
+    fail(404, 'Revisions are disabled for this collection.')
+  }
+  const roles = useRuntimeConfig().katecms?.roles ?? {}
+  requirePermission(actor, 'collections', 'update', roles, collectionSlug)
+
+  const db = getDb()
+  const existing = await findCollectionById(db, id)
+  if (!existing || existing.type !== collectionSlug) {
+    fail(404, 'Entry not found.')
+  }
+  requireEntryPermission(
+    actor,
+    'collections',
+    'update',
+    { authorId: existing.author_id },
+    roles,
+    collectionSlug,
+  )
+
+  const revision = await findCollectionRevisionById(db, revisionId)
+  if (!revision || revision.collection_id !== id) {
+    fail(404, 'Revision not found.')
+  }
+  const snapshot = readEntryRevisionData(revision.data)
+  const title = readTitle(snapshot.title)
+  const slug = readSlug(snapshot.slug)
+  const status = readStatus(snapshot.status, existing.status)
+  const fields = readFields(snapshot.fields)
+  requirePublishedFields(def, status, fields)
+  const publishedAt = readPublishedAt(snapshot.publishedAt)
+  const authorId = await revisionAuthorId(db, snapshot.authorId)
+
+  const pickers = await loadCollectionDictionaryPickers(db, collectionSlug)
+  const previous = entryRevisionSnapshot(existing, await selectedDictionaryIds(db, id, pickers))
+
+  try {
+    const row = await updateCollection(db, id, {
+      title,
+      slug,
+      status,
+      fields,
+      menu_order: readMenuOrder(snapshot.menuOrder, existing.menu_order),
+      published_at: publishedAt,
+      author_id: authorId,
+      ...(def.hierarchical === true ? { parent_id: snapshot.parentId } : {}),
+    })
+    if (!row) {
+      fail(404, 'Entry not found.')
+    }
+    await applyDictionaryAssignments(db, id, collectionSlug, snapshot.dictionaryIds)
+    const dictionaryIds = await selectedDictionaryIds(db, id, pickers)
+    await recordEntryRevision(db, id, actor.id, previous, entryRevisionSnapshot(row, dictionaryIds))
+
+    const slugPath = (await loadCollectionSlugPath(db, collectionSlug, id)) || row.slug
+    const flags = entryFlags(actor, row, roles)
+    const meta = toCollectionMeta(collectionSlug, def)
+    const response: CollectionEntryResponse = {
+      collection: meta,
+      entry: toAdminEntry(row, slugPath, { ...flags, dictionaryIds }),
+      canUpdate: flags.canUpdate,
+      canDelete: flags.canDelete,
+      dictionaries: pickers,
+    }
+    if (meta.hierarchical) {
+      const parents = await listCollectionParentOptions(db, collectionSlug, id)
+      response.parents = parents.map(toParentOption)
+    }
+    return response
+  }
+  catch (error) {
+    rethrowCollectionWriteError(error)
+  }
+})
+
+function readRevisionId(raw: string | undefined): number {
+  const id = Number(raw)
+  if (!Number.isInteger(id) || id <= 0) {
+    fail(400, 'Invalid revision.')
+  }
+  return id
+}

package/src/runtime/server/api/_katecms/collections/[collection]/revisions.get.ts

@@ -0,0 +1,35 @@
+import { defineEventHandler, getRouterParam } from 'h3'
+import { useRuntimeConfig } from '#imports'
+import { findCollectionById } from '@katecms/core'
+import { getDb } from '../../../../utils/db'
+import { requireUser } from '../../../../utils/session'
+import { requirePermission } from '../../../../utils/permissions'
+import {
+  fail,
+  readCollectionSlug,
+  readEntryId,
+  requireCollection,
+  collectionRevisionsEnabled,
+} from '../../../../utils/collections'
+import { listEntryRevisions } from '../../../../utils/revisions'
+import type { EntryRevisionItem } from '../../../../../utils/collections'
+
+/** Saved versions of one collection entry. */
+export default defineEventHandler(async (event): Promise<{ revisions: EntryRevisionItem[] }> => {
+  const actor = await requireUser(event)
+  const collectionSlug = readCollectionSlug(getRouterParam(event, 'collection'))
+  const id = readEntryId(getRouterParam(event, 'id'))
+  const def = requireCollection(collectionSlug)
+  const roles = useRuntimeConfig().katecms?.roles ?? {}
+  requirePermission(actor, 'collections', 'read', roles, collectionSlug)
+
+  const db = getDb()
+  const existing = await findCollectionById(db, id)
+  if (!existing || existing.type !== collectionSlug) {
+    fail(404, 'Entry not found.')
+  }
+  if (!collectionRevisionsEnabled(def)) {
+    return { revisions: [] }
+  }
+  return { revisions: await listEntryRevisions(db, id) }
+})