@michaelthielemann/kestrel 4.1.2 → 5.0.0

package/layers/admin/app/composables/useBlockTree.ts

@@ -1,95 +0,0 @@
-import { ref, computed } from 'vue'
-import type { Ref } from 'vue'
-import { useEchoGuard } from '../../../ui/app/composables/useEchoGuard'
-import type { SerializedBlock } from '@michaelthielemann/kestrel-core'
-import {
-  type BlockRow,
-  findInTree,
-  updatePropById,
-  removeById,
-  removalRetarget,
-  moveById,
-  duplicateById,
-  addBlock,
-} from '../utils/block-tree'
-
-/**
- * Reactive state for the 3-pane block editor: one nested `content` tree plus a single shared selection
- * (the stable `block.id`, or `null` for the page root). The tree pane and the fields pane both drive
- * the same instance — the tree selects + does structural ops, the fields pane edits the selected
- * block's props. Every mutation is id-addressed and immutable (see `block-tree.ts`) and re-emits the
- * whole array (so `useEditForm`'s `setField('content', …)` reconciliation still runs). `genId` is
- * injectable for deterministic tests; defaults to `crypto.randomUUID` (the server requires a non-empty id).
- */
-export function useBlockTree(
-  model: Ref<unknown[] | null | undefined>,
-  schemas: Ref<Record<string, SerializedBlock>>,
-  genId: () => string = () => crypto.randomUUID(),
-  // Routes an emit through the caller's own undo-history capture point instead of a plain `model.value =`
-  // assignment, tagged with a per-op coalesce key (see `emit`) — so a structural op landing inside another
-  // edit's coalesce window (e.g. a delete right after typing) still gets its own undo step.
-  setContent?: (value: unknown[], coalesceAs: string) => void,
-) {
-  // JSON round-trip (not structuredClone — which throws on Vue reactive proxies): reads through the
-  // proxy into detached plain objects. Block content is JSON by definition, so this is lossless here.
-  const clone = (v: unknown): BlockRow[] => (Array.isArray(v) ? (JSON.parse(JSON.stringify(v)) as BlockRow[]) : [])
-
-  const blocks = ref<BlockRow[]>(clone(model.value))
-  const selectedId = ref<string | null>(null)
-
-  function emit(coalesceAs: string): void {
-    if (setContent) setContent(blocks.value, coalesceAs)
-    else model.value = blocks.value
-  }
-
-  // Echo-guard against the tree's OWN emit (shared primitive): an external change (load / locale copy /
-  // undo / redo) differs from the current tree, so it reseeds and drops a now-missing selection to root.
-  useEchoGuard(model, () => blocks.value, (v) => {
-    blocks.value = clone(v)
-    if (selectedId.value !== null && !findInTree(blocks.value, selectedId.value)) selectedId.value = null
-  }, [])
-
-  const selectedBlock = computed<BlockRow | null>(() =>
-    selectedId.value === null ? null : (findInTree(blocks.value, selectedId.value)?.block ?? null),
-  )
-
-  function select(id: string | null): void {
-    selectedId.value = id
-  }
-
-  function setProp(id: string, key: string, value: unknown): void {
-    blocks.value = updatePropById(blocks.value, id, key, value)
-    // Coalesces a typing burst into that one field, same as an ordinary text field would.
-    emit(`content:prop:${id}:${key}`)
-  }
-
-  function remove(id: string): void {
-    const retarget = removalRetarget(blocks.value, id)
-    blocks.value = removeById(blocks.value, id)
-    // Heal the selection whenever it no longer exists — covers removing the selected block itself AND
-    // removing an ANCESTOR of it (the whole subtree goes); land on the removed block's sibling/parent.
-    if (selectedId.value !== null && !findInTree(blocks.value, selectedId.value)) selectedId.value = retarget
-    emit(`content:remove:${id}`)
-  }
-
-  function move(id: string, dir: -1 | 1): void {
-    blocks.value = moveById(blocks.value, id, dir)
-    emit(`content:move:${id}`)
-  }
-
-  function duplicate(id: string): void {
-    const { tree, newId } = duplicateById(blocks.value, id, genId)
-    blocks.value = tree
-    selectedId.value = newId
-    emit(`content:duplicate:${id}`)
-  }
-
-  function add(parentId: string | null, slotName: string | null, type: string): void {
-    const { tree, newId } = addBlock(blocks.value, parentId, slotName, type, schemas.value, genId)
-    blocks.value = tree
-    selectedId.value = newId
-    emit(`content:add:${parentId}:${slotName}:${type}`)
-  }
-
-  return { blocks, selectedId, selectedBlock, select, setProp, remove, move, duplicate, add }
-}

package/layers/admin/app/composables/useBlocks.ts

@@ -1,7 +0,0 @@
-import type { SerializedBlock } from '@michaelthielemann/kestrel-core'
-
-// Thin wrapper over the shared cached-resource loader; keeps the named `blocks` return.
-export function useBlocks() {
-  const { state: blocks, load } = useCachedResource<SerializedBlock>('kestrel-blocks', '/api/blocks')
-  return { blocks, load }
-}

package/layers/admin/app/composables/useCachedResource.ts

@@ -1,35 +0,0 @@
-// Generic cached-resource loader: a `useState`-backed list that fetches once and is shared by every
-// caller. Backs `useBlocks` / `useCollections` (structurally identical loaders).
-//
-// SSR isolation: the in-flight (dedup) promise is keyed first by the per-request Nuxt app (a WeakMap,
-// so it can't leak across SSR requests) AND then by `stateKey` — otherwise two different resources
-// loading concurrently in ONE request would share a single promise and cross-contaminate (one
-// resolves with the other's data).
-const inflight = new WeakMap<object, Map<string, Promise<unknown>>>()
-
-export function useCachedResource<T>(stateKey: string, url: string) {
-  const state = useState<T[] | null>(stateKey, () => null)
-  const nuxtApp = useNuxtApp()
-
-  async function load(): Promise<T[]> {
-    if (state.value) return state.value
-    let perApp = inflight.get(nuxtApp)
-    if (!perApp) {
-      perApp = new Map()
-      inflight.set(nuxtApp, perApp)
-    }
-    let pending = perApp.get(stateKey) as Promise<T[]> | undefined
-    if (!pending) {
-      pending = $fetch<{ data: T[] }>(url)
-        .then(({ data }) => {
-          state.value = data
-          return data
-        })
-        .finally(() => perApp!.delete(stateKey))
-      perApp.set(stateKey, pending)
-    }
-    return pending
-  }
-
-  return { state, load }
-}

package/layers/admin/app/composables/useCollectionOps.ts

@@ -1,102 +0,0 @@
-import { ref, toValue, type MaybeRefOrGetter } from 'vue'
-import { buildDeleteReport, type BatchAction, type BatchDeleteReport, type BatchPipelineResult, type BulkResult, type ReferrerCounts } from '../utils/collection-ops'
-import type { SerializedAction } from '@michaelthielemann/kestrel-core'
-
-/** Which write pipeline each batch action runs, and the body it takes. A publish/unpublish is an
- *  `updateMany` with a status patch — the same pipeline any other field-wide edit would use. */
-const BATCH_PIPELINE: Record<BatchAction, { op: string, patch?: { status: 'published' | 'draft' } }> = {
-  delete: { op: 'deleteMany' },
-  duplicate: { op: 'duplicate' },
-  publish: { op: 'updateMany', patch: { status: 'published' } },
-  unpublish: { op: 'updateMany', patch: { status: 'draft' } },
-}
-
-/**
- * Client orchestration for the collection batch operations — ONE module, two entry points: a row action
- * passes a single id, the bulk bar passes many. Every mutating call runs a batch pipeline
- * (`POST /api/{collection}/{pipeline}`); the server does the batching, the client never loops N requests.
- * Mirrors media/useMediaOps (busy/error + an onChanged refetch hook).
- */
-export function useCollectionOps(collection: MaybeRefOrGetter<string>, onChanged?: () => void | Promise<void>) {
-  const { t } = useT()
-  const busy = ref(false)
-  const error = ref<string | null>(null)
-  const name = () => toValue(collection)
-
-  async function bulk(action: BatchAction, ids: number[]): Promise<BulkResult> {
-    busy.value = true
-    error.value = null
-    try {
-      const { op, patch } = BATCH_PIPELINE[action]
-      const res = await $fetch<BatchPipelineResult>(`/api/${name()}/${op}`, { method: 'POST', body: { ids, ...(patch ? { patch } : {}) } })
-      await onChanged?.()
-      // `duplicate` answers with the CREATED rows, the two batch ops with a count + the ids they touched;
-      // both fold into the one shape the list UI reports.
-      return Array.isArray(res)
-        ? { action, count: res.length, ids: res.map((row) => Number(row.id)) }
-        : { action, count: res.count, ids: res.ids }
-    } catch (e) {
-      error.value = (e as { statusMessage?: string })?.statusMessage ?? t('list.opFailed')
-      throw e
-    } finally {
-      busy.value = false
-    }
-  }
-
-  /** Read-only pre-delete summary (referrer aggregate). Best-effort: sets `error` and rethrows on failure
-   *  so the caller can decide whether to still proceed (deletion is not blocked on the warning lookup). */
-  async function previewDelete(ids: number[]): Promise<BatchDeleteReport> {
-    error.value = null
-    try {
-      const res = await $fetch<ReferrerCounts>(`/api/${name()}/referrers`, { query: { ids: ids.join(',') } })
-      // The endpoint flags whether the index lookup ran; carry that through rather than inferring safety from
-      // an empty `counts`. A missing body is indeterminate too — it is no evidence that nothing links here.
-      return buildDeleteReport(ids, res?.counts ?? {}, res != null && res.checked !== false)
-    } catch (e) {
-      error.value = (e as { statusMessage?: string })?.statusMessage ?? t('list.refCheckFailed')
-      throw e
-    }
-  }
-
-  /**
-   * Run a schema-driven custom action (a consumer's `definePipeline` beyond the built-in bulk set). The
-   * response shape is whatever that pipeline answers with — unlike the built-ins, generic rendering has no
-   * contract to decode, so the reported result is simply the ids the caller asked to act on.
-   */
-  async function runCustomAction(action: SerializedAction, ids: number[]): Promise<BulkResult> {
-    busy.value = true
-    error.value = null
-    try {
-      const record = action.kind === 'record'
-      const url = record ? `/api/${name()}/${action.name}/${ids[0]}` : `/api/${name()}/${action.name}`
-      await $fetch(url, { method: 'POST', body: record ? undefined : { ids } })
-      await onChanged?.()
-      return { action: action.name, count: ids.length, ids }
-    } catch (e) {
-      error.value = (e as { statusMessage?: string })?.statusMessage ?? t('list.opFailed')
-      throw e
-    } finally {
-      busy.value = false
-    }
-  }
-
-  const confirmDelete = (ids: number[]) => bulk('delete', ids)
-  const duplicate = (ids: number[]) => bulk('duplicate', ids)
-  /**
-   * Persist a new status and, for a publish, write the static output too (ADR-0008). Two calls because
-   * they are two things: `updateMany` owns the DB write (validation, all-or-nothing, write events),
-   * `/api/publish` owns the render. Unpublishing needs no second call — the write event prunes the pages
-   * on its own, since taking a page offline must never wait for a separate action.
-   */
-  const setStatus = async (ids: number[], status: 'published' | 'draft'): Promise<BulkResult> => {
-    const res = await bulk(status === 'published' ? 'publish' : 'unpublish', ids)
-    if (status === 'published') {
-      // Best-effort: the records ARE published (the state the list shows); a failed render surfaces on the
-      // record's own status lamp, and re-pressing Publish retries it.
-      await $fetch('/api/publish', { method: 'POST', body: { collection: name(), ids } }).catch(() => null)
-    }
-    return res
-  }
-
-  return { busy, error, previewDelete, confirmDelete, duplicate, setStatus, runCustomAction }
-}

package/layers/admin/app/composables/useCollections.ts

@@ -1,6 +0,0 @@
-import type { SerializedCollection } from '@michaelthielemann/kestrel-core'
-
-export function useCollections() {
-  const { state: collections, load } = useCachedResource<SerializedCollection>('kestrel-collections', '/api/collections')
-  return { collections, load }
-}

package/layers/admin/app/composables/useContentLocales.ts

@@ -1,23 +0,0 @@
-export interface ContentLocales {
-  /** Website/content locales (NOT the admin-UI language) — what the editor LocaleBar offers. */
-  locales: string[]
-  primary: string
-  /** Whether the primary locale is prefixed in public URLs too (`/en/about`); the `localePath` flag. */
-  prefixPrimary: boolean
-}
-
-/** Resolve the configured content locales from a `runtimeConfig.public`-shaped object. Pure, so the
- *  fallback/primary logic is unit-testable without a Nuxt context. The `['en']` fallback is a safe
- *  last resort for an absent/empty config (nuxt.config always sets `public.locales`): primary-only is
- *  a safer guess than assuming a second locale exists, so it intentionally differs from the server's
- *  `['en','de']` *default* (which applies only when KESTREL_LOCALES itself is unset). */
-export function pickContentLocales(pub: { locales?: unknown; primaryLocale?: unknown; prefixPrimary?: unknown }): ContentLocales {
-  const locales = Array.isArray(pub.locales) && pub.locales.length ? pub.locales.map(String) : ['en']
-  const primary =
-    typeof pub.primaryLocale === 'string' && locales.includes(pub.primaryLocale) ? pub.primaryLocale : locales[0]!
-  return { locales, primary, prefixPrimary: pub.prefixPrimary === true }
-}
-
-export function useContentLocales(): ContentLocales {
-  return pickContentLocales(useRuntimeConfig().public as { locales?: unknown; primaryLocale?: unknown; prefixPrimary?: unknown })
-}