katecms 0.0.0-stage → 1.0.0-beta.1

package/src/runtime/server/utils/dictionaries.ts

@@ -0,0 +1,397 @@
+import { useRuntimeConfig } from '#imports'
+import {
+  buildSlugPathMap,
+  flattenCollectionTree,
+  formatRequiredFieldsError,
+  isUniqueConstraintError,
+  listDictionaries,
+  listDictionariesByCollection,
+  setCollectionDictionaries,
+  validateRequiredFields,
+} from '@katecms/core'
+import type {
+  Database,
+  Dictionaries,
+  Dictionary,
+  DictionaryDefinition,
+  Fields,
+} from '@katecms/core'
+import type { Kysely } from 'kysely'
+import type { CollectionDictionaryPicker, PublicDictionaryTerm } from '../../utils/collections'
+import type {
+  AdminDictionaryMeta,
+  AdminDictionaryTerm,
+  ParentOption,
+} from '../../utils/dictionaries'
+import {
+  fail,
+  readEntryId,
+  readFields,
+  readParentId,
+  readSlug,
+  readTitle,
+} from './collections'
+
+export { fail, readEntryId, readFields, readParentId, readSlug, readTitle }
+
+export function getDictionaries(): Dictionaries {
+  return useRuntimeConfig().katecms?.dictionaries ?? {}
+}
+
+export function getDictionaryDefinition(slug: string): DictionaryDefinition | undefined {
+  return getDictionaries()[slug]
+}
+
+export function requireDictionary(slug: string): DictionaryDefinition {
+  const dictionary = getDictionaryDefinition(slug)
+  if (!dictionary) {
+    fail(404, 'Dictionary not found.')
+  }
+  return dictionary
+}
+
+export function toDictionaryMeta(slug: string, def: DictionaryDefinition): AdminDictionaryMeta {
+  return {
+    slug,
+    labels: {
+      name: def.labels.name,
+      singularName: def.labels.singularName ?? def.labels.name,
+    },
+    fields: (def.fields ?? {}) as Fields,
+    collections: [...def.collections],
+    multiple: def.multiple === true,
+    hierarchical: def.hierarchical === true,
+    public: def.public !== false,
+    rewrite: def.rewrite,
+  }
+}
+
+function toIso(value: Date | string | null | undefined): string {
+  if (value == null) {
+    return new Date(0).toISOString()
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? new Date(0).toISOString() : value.toISOString()
+  }
+  const date = new Date(value)
+  return Number.isNaN(date.getTime()) ? new Date(0).toISOString() : date.toISOString()
+}
+
+export function toPublicTerm(row: Dictionary, slugPath: string): PublicDictionaryTerm {
+  return {
+    id: row.id,
+    type: row.type,
+    slug: row.slug,
+    slugPath: slugPath || row.slug,
+    title: row.title,
+    fields: (row.fields ?? {}) as Record<string, unknown>,
+    parentId: row.parent_id,
+  }
+}
+
+export function toAdminTerm(
+  row: Dictionary,
+  slugPath: string,
+  flags?: { canUpdate?: boolean, canDelete?: boolean, depth?: number },
+): AdminDictionaryTerm {
+  return {
+    id: row.id,
+    type: row.type,
+    slug: row.slug,
+    slugPath: slugPath || row.slug,
+    title: row.title,
+    fields: (row.fields ?? {}) as Record<string, unknown>,
+    parentId: row.parent_id,
+    createdAt: toIso(row.created_at),
+    updatedAt: toIso(row.updated_at),
+    ...flags,
+  }
+}
+
+export function toParentOption(row: {
+  id: number
+  title: string
+  slug: string
+  parent_id: number | null
+  slugPath: string
+  depth: number
+}): ParentOption {
+  return {
+    id: row.id,
+    title: row.title,
+    slug: row.slug,
+    parentId: row.parent_id,
+    slugPath: row.slugPath,
+    depth: row.depth,
+  }
+}
+
+export function readDictionarySlug(raw: string | undefined): string {
+  const slug = typeof raw === 'string' ? raw.trim() : ''
+  if (!slug) {
+    fail(400, 'Dictionary is required.')
+  }
+  return slug
+}
+
+export function requireTermFields(
+  def: DictionaryDefinition,
+  fields: Record<string, unknown>,
+): void {
+  const issues = validateRequiredFields(def.fields ?? {}, fields)
+  if (issues.length > 0) {
+    fail(422, formatRequiredFieldsError(issues))
+  }
+}
+
+function descendantIds(
+  rows: Array<{ id: number, parent_id: number | null }>,
+  rootId: number,
+): Set<number> {
+  const children = new Map<number, number[]>()
+  for (const row of rows) {
+    if (row.parent_id == null) {
+      continue
+    }
+    const list = children.get(row.parent_id) ?? []
+    list.push(row.id)
+    children.set(row.parent_id, list)
+  }
+  const out = new Set<number>()
+  const stack = [...(children.get(rootId) ?? [])]
+  while (stack.length > 0) {
+    const id = stack.pop()!
+    if (out.has(id)) {
+      continue
+    }
+    out.add(id)
+    stack.push(...(children.get(id) ?? []))
+  }
+  return out
+}
+
+export function listDictionaryParentOptions(
+  rows: Array<{ id: number, title: string, slug: string, parent_id: number | null }>,
+  excludeId?: number,
+): ParentOption[] {
+  const blocked = excludeId === undefined
+    ? new Set<number>()
+    : descendantIds(rows, excludeId)
+  if (excludeId !== undefined) {
+    blocked.add(excludeId)
+  }
+  const visible = rows.filter(row => !blocked.has(row.id))
+  const paths = buildSlugPathMap(visible)
+  return flattenCollectionTree(visible).map(({ row, depth }) => toParentOption({
+    ...row,
+    slugPath: paths.get(row.id) ?? row.slug,
+    depth,
+  }))
+}
+
+export function flattenDictionaryTerms(
+  rows: Dictionary[],
+): Array<{ row: Dictionary, depth: number, slugPath: string }> {
+  const paths = buildSlugPathMap(rows)
+  return flattenCollectionTree(rows).map(({ row, depth }) => ({
+    row,
+    depth,
+    slugPath: paths.get(row.id) ?? row.slug,
+  }))
+}
+
+export function assertDictionaryParent(
+  rows: Array<{ id: number, type: string, parent_id: number | null }>,
+  type: string,
+  parentId: number | null,
+  excludeId?: number,
+): void {
+  if (parentId == null) {
+    return
+  }
+  const parent = rows.find(row => row.id === parentId)
+  if (!parent || parent.type !== type) {
+    fail(422, 'Invalid parent.')
+  }
+  if (excludeId !== undefined && parentId === excludeId) {
+    fail(422, 'Invalid parent.')
+  }
+  if (excludeId !== undefined) {
+    const blocked = descendantIds(rows, excludeId)
+    if (blocked.has(parentId)) {
+      fail(422, 'Invalid parent.')
+    }
+  }
+}
+
+export function rethrowDictionaryWriteError(error: unknown): never {
+  if (isUniqueConstraintError(error)) {
+    fail(409, 'A term with this slug already exists.')
+  }
+  const message = error instanceof Error ? error.message : ''
+  if (
+    /parent/i.test(message)
+    || /descendant/i.test(message)
+    || /hierarchy/i.test(message)
+  ) {
+    fail(422, message.startsWith('dictionaries:') ? 'Invalid parent.' : message)
+  }
+  throw error
+}
+
+export function dictionariesForCollection(collectionSlug: string): Array<{ slug: string, def: DictionaryDefinition }> {
+  return Object.entries(getDictionaries())
+    .filter(([, def]) => def.collections.includes(collectionSlug))
+    .map(([slug, def]) => ({ slug, def }))
+}
+
+export async function loadCollectionDictionaryPickers(
+  db: Kysely<Database>,
+  collectionSlug: string,
+): Promise<CollectionDictionaryPicker[]> {
+  const attached = dictionariesForCollection(collectionSlug)
+  const pickers: CollectionDictionaryPicker[] = []
+  for (const { slug, def } of attached) {
+    const rows = await listDictionaries(db, slug)
+    pickers.push({
+      slug,
+      labels: {
+        name: def.labels.name,
+        singularName: def.labels.singularName ?? def.labels.name,
+      },
+      multiple: def.multiple === true,
+      terms: listDictionaryParentOptions(rows),
+    })
+  }
+  return pickers
+}
+
+/** Assigned terms for a public entry, keyed by dictionary slug (empty arrays when none). */
+export async function loadAssignedEntryDictionaries(
+  db: Kysely<Database>,
+  collectionId: number,
+  collectionSlug: string,
+): Promise<Record<string, PublicDictionaryTerm[]>> {
+  const attached = dictionariesForCollection(collectionSlug)
+  const grouped: Record<string, PublicDictionaryTerm[]> = Object.fromEntries(
+    attached.map(({ slug }) => [slug, [] as PublicDictionaryTerm[]]),
+  )
+  if (attached.length === 0) {
+    return grouped
+  }
+
+  const allowed = new Set(attached.map(({ slug }) => slug))
+  const linked = (await listDictionariesByCollection(db, collectionId))
+    .filter(term => allowed.has(term.type))
+  if (linked.length === 0) {
+    return grouped
+  }
+
+  const typesNeeded = [...new Set(linked.map(term => term.type))]
+  const typeRows = await Promise.all(typesNeeded.map(type => listDictionaries(db, type)))
+  const pathMaps = new Map(typesNeeded.map((type, index) => [
+    type,
+    buildSlugPathMap(typeRows[index]),
+  ]))
+
+  for (const term of linked) {
+    grouped[term.type].push(toPublicTerm(term, pathMaps.get(term.type)?.get(term.id) ?? term.slug))
+  }
+  return grouped
+}
+
+export async function selectedDictionaryIds(
+  db: Kysely<Database>,
+  collectionId: number,
+  pickers: CollectionDictionaryPicker[],
+): Promise<Record<string, number[]>> {
+  const ids: Record<string, number[]> = Object.fromEntries(
+    pickers.map(picker => [picker.slug, [] as number[]]),
+  )
+  if (pickers.length === 0) {
+    return ids
+  }
+  const allowed = new Set(pickers.map(picker => picker.slug))
+  const linked = await listDictionariesByCollection(db, collectionId)
+  for (const term of linked) {
+    if (!allowed.has(term.type)) {
+      continue
+    }
+    ids[term.type].push(term.id)
+  }
+  return ids
+}
+
+function readTermIdList(value: unknown): number[] {
+  if (value === undefined || value === null || value === '') {
+    return []
+  }
+  const raw = Array.isArray(value) ? value : [value]
+  const ids: number[] = []
+  const seen = new Set<number>()
+  for (const item of raw) {
+    const id = typeof item === 'number' ? item : Number(item)
+    if (!Number.isInteger(id) || id <= 0) {
+      fail(422, 'Invalid dictionary term.')
+    }
+    if (seen.has(id)) {
+      continue
+    }
+    seen.add(id)
+    ids.push(id)
+  }
+  return ids
+}
+
+export function readDictionaryAssignments(
+  value: unknown,
+  pickers: CollectionDictionaryPicker[],
+): Record<string, number[]> {
+  if (value === undefined || value === null) {
+    return Object.fromEntries(pickers.map(picker => [picker.slug, [] as number[]]))
+  }
+  if (typeof value !== 'object' || Array.isArray(value)) {
+    fail(422, 'Invalid dictionary selection.')
+  }
+  const raw = value as Record<string, unknown>
+  const allowed = new Set(pickers.map(picker => picker.slug))
+  for (const slug of Object.keys(raw)) {
+    if (!allowed.has(slug)) {
+      fail(422, 'Unknown dictionary.')
+    }
+  }
+  const assigned: Record<string, number[]> = {}
+  for (const picker of pickers) {
+    const termIds = new Set(picker.terms.map(term => term.id))
+    const selected = readTermIdList(raw[picker.slug])
+    for (const id of selected) {
+      if (!termIds.has(id)) {
+        fail(422, 'Invalid dictionary term.')
+      }
+    }
+    if (!picker.multiple && selected.length > 1) {
+      fail(422, `Only one ${picker.labels.singularName.toLowerCase()} can be selected.`)
+    }
+    assigned[picker.slug] = selected
+  }
+  return assigned
+}
+
+export async function applyDictionaryAssignments(
+  db: Kysely<Database>,
+  collectionId: number,
+  collectionSlug: string,
+  value: unknown,
+): Promise<Record<string, number[]>> {
+  const pickers = await loadCollectionDictionaryPickers(db, collectionSlug)
+  if (pickers.length === 0) {
+    return {}
+  }
+  const assigned = readDictionaryAssignments(value, pickers)
+  const linked = await listDictionariesByCollection(db, collectionId)
+  const replaceTypes = new Set(pickers.map(picker => picker.slug))
+  const keep = linked.filter(term => !replaceTypes.has(term.type)).map(term => term.id)
+  const next = [...keep, ...Object.values(assigned).flat()]
+  await setCollectionDictionaries(db, collectionId, next)
+  return assigned
+}

package/src/runtime/server/utils/media-list.ts

@@ -0,0 +1,131 @@
+import type { Database } from '@katecms/core'
+import { sql, type RawBuilder, type SelectQueryBuilder, type SqlBool } from 'kysely'
+import type { Kysely } from 'kysely'
+import {
+  ARCHIVE_MIME_TYPES,
+  DOCUMENT_MIME_TYPES,
+  SPREADSHEET_MIME_TYPES,
+  clampUtcOffsetMinutes,
+  searchNeedle,
+} from '../../utils/media-library-query'
+import type { MediaSort, MediaTypeFilter } from '../../utils/media-library-query'
+
+export interface MediaListFilter {
+  type: MediaTypeFilter
+  /** `YYYY-MM`, or empty for every month. */
+  month: string
+  search: string
+  offsetMinutes: number
+  sort: MediaSort
+}
+
+type MediaQuery<T> = SelectQueryBuilder<Database, 'media', T>
+
+function exactMimes(type: MediaTypeFilter): readonly string[] | null {
+  if (type === 'document') {
+    return DOCUMENT_MIME_TYPES
+  }
+  if (type === 'spreadsheet') {
+    return SPREADSHEET_MIME_TYPES
+  }
+  if (type === 'archive') {
+    return ARCHIVE_MIME_TYPES
+  }
+  return null
+}
+
+/** Local `YYYY-MM` of `created_at`. SQLite stores UTC ISO text; Postgres stores timestamptz. */
+function monthExpression(driver: 'sqlite' | 'postgres', offsetMinutes: number): RawBuilder<string> {
+  const offset = clampUtcOffsetMinutes(offsetMinutes)
+  if (driver === 'postgres') {
+    return sql<string>`to_char((media.created_at AT TIME ZONE 'UTC') + (${offset} * interval '1 minute'), 'YYYY-MM')`
+  }
+  const modifier = `${offset >= 0 ? '+' : ''}${offset} minutes`
+  return sql<string>`substr(datetime(substr(replace(replace(media.created_at, 'T', ' '), 'Z', ''), 1, 19), ${modifier}), 1, 7)`
+}
+
+export function applyMediaListFilter<T>(
+  query: MediaQuery<T>,
+  filter: MediaListFilter,
+  driver: 'sqlite' | 'postgres',
+): MediaQuery<T> {
+  let next = query
+  if (filter.type === 'image' || filter.type === 'audio' || filter.type === 'video') {
+    next = next.where(sql<SqlBool>`lower(media.mime_type) like ${`${filter.type}/%`}`)
+  }
+  else {
+    const mimes = exactMimes(filter.type)
+    if (mimes) {
+      next = next.where(sql<SqlBool>`lower(media.mime_type) in (${sql.join(mimes.map(mime => sql`${mime}`))})`)
+    }
+  }
+
+  if (/^\d{4}-(0[1-9]|1[0-2])$/.test(filter.month)) {
+    const month = monthExpression(driver, filter.offsetMinutes)
+    next = next.where(sql<SqlBool>`${month} = ${filter.month}`)
+  }
+
+  const needle = searchNeedle(filter.search)
+  if (needle) {
+    const pattern = `%${needle}%`
+    next = next.where(sql<SqlBool>`(
+      lower(media.filename) like ${pattern}
+      or lower(coalesce(media.alt, '')) like ${pattern}
+      or lower(coalesce(media.caption, '')) like ${pattern}
+    )`)
+  }
+
+  return next
+}
+
+function sortParts(sort: MediaSort): { field: string, direction: 'asc' | 'desc' } {
+  const direction = sort.endsWith('-asc') ? 'asc' : 'desc'
+  const field = sort.slice(0, -(direction.length + 1))
+  return { field, direction }
+}
+
+/** Stable order for the paged library. Non-images stay last when sorting by pixel size. */
+export function applyMediaListOrder<T>(query: MediaQuery<T>, sort: MediaSort): MediaQuery<T> {
+  const { field, direction } = sortParts(sort)
+  if (field === 'name') {
+    return query.orderBy(sql`lower(media.filename)`, direction).orderBy('id', 'asc')
+  }
+  if (field === 'filesize') {
+    return query.orderBy('filesize', direction).orderBy('id', 'asc')
+  }
+  if (field === 'dimensions') {
+    return query
+      .orderBy(sql`(media.width is null or media.height is null)`)
+      .orderBy(sql`coalesce(media.width, 0) * coalesce(media.height, 0)`, direction)
+      .orderBy('id', 'asc')
+  }
+  if (field === 'author') {
+    const author = sql`(select lower(coalesce(nullif(trim(users.name), ''), users.email)) from users where users.id = media.uploaded_by)`
+    return query
+      .orderBy(sql`${author} is null`)
+      .orderBy(author, direction)
+      .orderBy('id', 'asc')
+  }
+  return query.orderBy('created_at', direction).orderBy('id', direction)
+}
+
+export async function listMediaMonths(
+  db: Kysely<Database>,
+  filter: MediaListFilter,
+  driver: 'sqlite' | 'postgres',
+): Promise<string[]> {
+  const month = monthExpression(driver, filter.offsetMinutes)
+  const rows = await applyMediaListFilter(
+    db.selectFrom('media'),
+    { ...filter, month: '' },
+    driver,
+  )
+    .select(month.as('month'))
+    .distinct()
+    .execute()
+
+  return rows
+    .map(row => String(row.month ?? ''))
+    .filter(value => /^\d{4}-(0[1-9]|1[0-2])$/.test(value))
+    .sort((a, b) => b.localeCompare(a))
+}

package/src/runtime/server/utils/media.ts

@@ -0,0 +1,94 @@
+import { useRuntimeConfig } from '#imports'
+import type { H3Event } from 'h3'
+import { createError } from 'h3'
+import {
+  createLocalMediaStorage,
+  findUserById,
+  toMediaItem,
+} from '@katecms/core'
+import type { Media, MediaItem, MediaStorage, ResolvedMediaConfig, StoredMediaVariant } from '@katecms/core'
+import { getDb } from './db'
+
+/** Public URL prefix; files in `public/uploads` are served here by Nuxt. */
+export const UPLOADS_PUBLIC_PATH = '/uploads'
+
+let storage: MediaStorage | undefined
+
+export function getMediaConfig(): ResolvedMediaConfig {
+  const media = useRuntimeConfig().katecms?.media
+  if (!media?.dir) {
+    throw createError({
+      statusCode: 500,
+      statusMessage: 'Media upload directory is not configured.',
+    })
+  }
+  return media
+}
+
+export function getMediaStorage(): MediaStorage {
+  if (storage) {
+    return storage
+  }
+  storage = createLocalMediaStorage({
+    dir: getMediaConfig().dir!,
+    publicPrefix: UPLOADS_PUBLIC_PATH,
+  })
+  return storage
+}
+
+export function toClientMedia(row: Media, uploadedByName?: string | null): MediaItem {
+  return toMediaItem(row, {
+    publicUrl: key => getMediaStorage().publicUrl(key),
+    uploadedByName,
+  })
+}
+
+export function parseMediaId(raw: string | undefined): number {
+  const id = Number(raw)
+  if (!Number.isInteger(id) || id <= 0) {
+    throw createError({ statusCode: 400, statusMessage: 'Invalid id.' })
+  }
+  return id
+}
+
+export function storedVariants(value: unknown): StoredMediaVariant[] {
+  if (!Array.isArray(value)) {
+    return []
+  }
+  return value.filter((row): row is StoredMediaVariant => {
+    if (!row || typeof row !== 'object') {
+      return false
+    }
+    const variant = row as Partial<StoredMediaVariant>
+    return typeof variant.filename === 'string'
+      && typeof variant.size === 'string'
+      && typeof variant.format === 'string'
+  })
+}
+
+export async function uploaderNames(
+  ids: Array<number | null | undefined>,
+): Promise<Map<number, string>> {
+  const unique = [...new Set(ids.filter((id): id is number => typeof id === 'number'))]
+  const names = new Map<number, string>()
+  const db = getDb()
+  await Promise.all(unique.map(async (id) => {
+    const user = await findUserById(db, id)
+    if (user) {
+      names.set(id, user.name?.trim() || user.email)
+    }
+  }))
+  return names
+}
+
+export async function toClientMediaRow(row: Media): Promise<MediaItem> {
+  const names = await uploaderNames([row.uploaded_by])
+  return toClientMedia(row, row.uploaded_by != null ? names.get(row.uploaded_by) ?? null : null)
+}
+
+export function scheduleBackground(event: H3Event, task: Promise<unknown>): void {
+  const waitUntil = (event as { waitUntil?: (promise: Promise<unknown>) => void }).waitUntil
+  if (typeof waitUntil === 'function') {
+    waitUntil(task)
+  }
+}