@unitninety/site-kit 1.6.2 → 1.6.3

package/src/site/formView.ts

@@ -0,0 +1,175 @@
+import { z } from 'zod'
+import { isLeaf, type CollectionDecl, type FieldDecl } from '../elements/define'
+import { orderedEntries } from '../elements/order'
+
+const safeKey = z
+  .string()
+  .min(1)
+  .max(200)
+  .refine((key) => !['__proto__', 'constructor', 'prototype'].includes(key), 'Invalid field key.')
+const Field = z.strictObject({ key: safeKey, width: z.enum(['half', 'full']) })
+const Group = z.strictObject({
+  id: z.string().regex(/^[a-zA-Z0-9_-]{1,80}$/),
+  label: z.string().trim().max(80),
+  fields: z.array(Field).max(500),
+})
+/** UI presentation only. No visibility, defaults, validation or site design settings. */
+export const CollectionViewSchema = z.strictObject({
+  version: z.literal(1),
+  groups: z.array(Group).min(1).max(50),
+})
+export const CollectionViewsSchema = z
+  .custom<Record<string, unknown>>(
+    (value) =>
+      !!value &&
+      typeof value === 'object' &&
+      !Array.isArray(value) &&
+      Object.keys(value).length <= 200 &&
+      Object.keys(value).every((key) => !['__proto__', 'constructor', 'prototype'].includes(key)),
+    'Invalid collection views.',
+  )
+  .pipe(z.record(safeKey, CollectionViewSchema))
+export type CollectionView = z.infer<typeof CollectionViewSchema>
+export type CollectionViews = z.infer<typeof CollectionViewsSchema>
+export type CollectionViewField = {
+  key: string
+  label: string
+  width: 'half' | 'full'
+  required: boolean
+}
+const humanise = (name: string) =>
+  name
+    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+    .replace(/[-_]/g, ' ')
+    .replace(/^./, (c) => c.toUpperCase())
+const editable = (field: FieldDecl): boolean =>
+  isLeaf(field)
+    ? !field.lock?.includes('$')
+    : field.container !== 'u90/group' || Object.values(field.fields).some(editable)
+
+/** Complex schema containers remain single units, with their own nested editors. */
+export function collectionViewFields(decl: CollectionDecl): CollectionViewField[] {
+  const fields = orderedEntries(decl.fields, decl.order).filter(([, field]) => editable(field))
+  const title = fields.find(([, field]) => isLeaf(field) && field.element === 'u90/text')?.[0]
+  return fields.map(([key, field]) => ({
+    key,
+    label: field.label || humanise(key),
+    required:
+      key === title ||
+      (isLeaf(field)
+        ? field.required === true
+        : field.container === 'u90/list' && (field.min ?? 0) > 0),
+    width:
+      key === title ||
+      !isLeaf(field) ||
+      field.options?.multiline === true ||
+      ['u90/image', 'u90/video', 'u90/file', 'u90/rich-text', 'u90/link', 'u90/query'].includes(
+        field.element,
+      )
+        ? 'full'
+        : 'half',
+  }))
+}
+const MAX_GROUPS = 50
+const MAX_FIELDS_PER_GROUP = 500
+export const defaultCollectionView = (fields: CollectionViewField[]): CollectionView => {
+  if (fields.length > MAX_GROUPS * MAX_FIELDS_PER_GROUP)
+    throw new Error('This collection has too many fields to configure.')
+  return {
+    version: 1,
+    groups: Array.from(
+      { length: Math.max(1, Math.ceil(fields.length / MAX_FIELDS_PER_GROUP)) },
+      (_, i) => ({
+        id: i ? `fields_${i}` : 'fields',
+        label: '',
+        fields: fields
+          .slice(i * MAX_FIELDS_PER_GROUP, (i + 1) * MAX_FIELDS_PER_GROUP)
+          .map(({ key, width }) => ({ key, width })),
+      }),
+    ),
+  }
+}
+
+/** Saved views from older schemas may not conceal newly added fields or revive locked ones. */
+export function reconcileCollectionView(
+  input: unknown,
+  fields: CollectionViewField[],
+): CollectionView {
+  const parsed = CollectionViewSchema.safeParse(input)
+  if (!parsed.success) return defaultCollectionView(fields)
+  const available = new Set(fields.map((f) => f.key))
+  const seen = new Set<string>()
+  const ids = new Set<string>()
+  const groups = parsed.data.groups
+    .filter((group) => {
+      if (ids.has(group.id)) return false
+      ids.add(group.id)
+      return true
+    })
+    .map((group) => ({
+      ...group,
+      fields: group.fields.filter((field) => {
+        if (!available.has(field.key) || seen.has(field.key)) return false
+        seen.add(field.key)
+        return true
+      }),
+    }))
+  const missing = fields
+    .filter((field) => !seen.has(field.key))
+    .map(({ key, width }) => ({ key, width }))
+  for (const field of missing) {
+    let target = groups.find((group) => !group.label && group.fields.length < MAX_FIELDS_PER_GROUP)
+    if (!target && groups.length < MAX_GROUPS) {
+      let id = 'fields'
+      let suffix = 1
+      while (ids.has(id)) id = `fields_${suffix++}`
+      ids.add(id)
+      target = { id, label: '', fields: [] }
+      groups.push(target)
+    }
+    target ??= groups.find((group) => group.fields.length < MAX_FIELDS_PER_GROUP)
+    if (!target) throw new Error('This collection has too many fields to configure.')
+    target.fields.push(field)
+  }
+  return { version: 1, groups }
+}
+
+/** Writes must account for every field, exactly once. Reads alone reconcile schema drift. */
+export function validateCollectionView(
+  input: unknown,
+  fields: CollectionViewField[],
+): CollectionView {
+  const view = CollectionViewSchema.parse(input)
+  if (new Set(view.groups.map((g) => g.id)).size !== view.groups.length)
+    throw new Error('Each group needs a unique ID.')
+  const keys = view.groups.flatMap((g) => g.fields.map((f) => f.key))
+  const expected = new Set(fields.map((f) => f.key))
+  if (
+    keys.length !== expected.size ||
+    new Set(keys).size !== keys.length ||
+    keys.some((key) => !expected.has(key))
+  )
+    throw new Error('Include every editable field once. Reload the view if the schema changed.')
+  return view
+}
+
+export function collectionViewsIssues(
+  input: CollectionViews | undefined,
+  collections: Record<string, CollectionDecl>,
+): { path: string; message: string }[] {
+  return Object.entries(input ?? {}).flatMap(([name, view]) => {
+    if (!Object.hasOwn(collections, name))
+      return [{ path: `collectionViews/${name}`, message: 'This collection is not declared.' }]
+    try {
+      validateCollectionView(view, collectionViewFields(collections[name]))
+      return []
+    } catch (error) {
+      return [
+        {
+          path: `collectionViews/${name}`,
+          message: error instanceof Error ? error.message : 'Invalid collection view.',
+        },
+      ]
+    }
+  })
+}

package/src/site/index.ts

@@ -12,3 +12,6 @@ export { metadataFor, type PageSeoInput } from '../seo/metadata'
 export { organisationJsonLd } from '../seo/jsonLd'
 export { robotsFor } from '../seo/robots'
 export { sitemapFor } from '../seo/sitemap'
+
+export { SeoSeedsSchema, DocumentSeoSeedSchema, SiteSeoSeedSchema, seoSeedIssues, seoSeedAssets, type SeoSeeds, type DocumentSeoSeed, type SiteSeoSeed } from '../seo/seeds'
+export { CollectionViewSchema, CollectionViewsSchema, collectionViewFields, defaultCollectionView, reconcileCollectionView, validateCollectionView, collectionViewsIssues, type CollectionView, type CollectionViews, type CollectionViewField } from './formView'

package/src/site/replies.ts

@@ -22,7 +22,7 @@ const tagOf = (r: Ref): string =>
   r.kind === 'media' ? `media:${r.id}` : r.kind === 'page' ? `page:${r.id}` : r.kind === 'single' ? `single:${r.key}` : r.kind === 'entry' ? `entry:${r.id}` : `collection:${r.collection}`
 
 /** A query over the store: `where` (eq, neq, in, not-in, is-set), a field `sort`, then the placement's picks and `limit`, which `applyQueryPicks` applies. */
-function runQuery(store: Store, collection: string, q: QueryStored): { ids: Id[]; total: number } {
+function runQuery(store: Store, collection: string, q: QueryStored, draft: boolean): { ids: Id[]; total: number; matches?: Id[] } {
   let rows = [...store.entries.values()].filter((e) => e.collection === collection)
   for (const w of q.where ?? [])
     rows = rows.filter((e) => {
@@ -31,7 +31,8 @@ function runQuery(store: Store, collection: string, q: QueryStored): { ids: Id[]
     })
   const sort = q.sort
   if (sort && sort !== 'manual') rows.sort((a, b) => String(a.fields[sort.field]).localeCompare(String(b.fields[sort.field])) * (sort.dir === 'desc' ? -1 : 1))
-  return applyQueryPicks(rows.map((r) => r.id), q, (id) => store.entries.has(entryKey(collection, id)))
+  const matches = rows.map(r => r.id)
+  return { ...applyQueryPicks(matches, q, id => store.entries.has(entryKey(collection, id))), ...(draft ? { matches } : {}) }
 }
 
 type Found = { doc: ReplyDocument; decl: DocumentDecl }
@@ -59,7 +60,7 @@ const entryFound = (site: Site, store: Store, collection: string, slug: string):
  * lookups they ask for, and the tags the read depends on. The fake answers with it, and a site
  * reading its own defaults goes through it too, so every read is assembled the same way.
  */
-export function replyFrom(site: Site, store: Store, target: ReplyTarget, manifest: string): Reply {
+export function replyFrom(site: Site, store: Store, target: ReplyTarget, manifest: string, draft = false): Reply {
   let found: Found | null = null
   if ('route' in target) {
     const p = [...store.pages.values()].find((x) => x.route === target.route)
@@ -96,7 +97,7 @@ export function replyFrom(site: Site, store: Store, target: ReplyTarget, manifes
   const queries: DocumentReply['queries'] = {}
   const inverses: DocumentReply['inverses'] = {}
   for (const r of lookups) {
-    if (r.kind === 'query') queries[queryKey(r.collection, r.query)] ??= runQuery(store, r.collection, r.query as QueryStored)
+    if (r.kind === 'query') queries[queryKey(r.collection, r.query)] ??= runQuery(store, r.collection, r.query as QueryStored, draft)
     if (r.kind === 'inverse')
       inverses[inverseKey(r.collection, r.field, r.id)] ??= [...store.entries.values()]
         .filter((e) => e.collection === r.collection && (Array.isArray(e.fields[r.field]) ? (e.fields[r.field] as unknown[]) : [e.fields[r.field]]).some((v) => String(v) === String(r.id)))

package/src/site/types.ts

@@ -31,11 +31,12 @@ export type EntrySeed = { slug: string; fields?: Record<string, unknown>; blocks
 export type CollectionDef<F extends Fields = Fields> = {
   kind: 'collection'; name: string; label: string; fields: F
   route?: string; defaultSort?: CollectionDecl['defaultSort']
+  authoring?: CollectionDecl['authoring']
   template?: { zone: ZoneDecl; layout?: string }
   entries?: EntrySeed[]
 }
 export type BlockDef<F extends Fields = Fields, C extends CollectionDef | undefined = CollectionDef | undefined> = {
-  kind: 'block'; name: string; label: string; fields: F; component: unknown; entry?: C
+  kind: 'block'; name: string; label: string; fields: F; component: unknown; entry?: C; shared?: BlockDecl['shared']
 }
 export type LayoutDef = { kind: 'layout'; default?: boolean; parent?: string; entries: Array<BlockDef | 'SLOT'> }
 export type PageDef = { kind: 'page'; route: string; layout?: string; blocks: ZoneDecl }
@@ -73,3 +74,4 @@ export type BlockProps<B> = B extends BlockDef<infer F, infer C>
   ? Simplify<{ [K in keyof F]: Read<F[K]> } & (C extends CollectionDef ? { entry: EntryReadOf<C> } : {})>
   : never
 export type { FieldDecl, LeafDecl, GroupDecl, ListDecl, ZoneDecl, BlockDecl, CollectionDecl, SingleDecl, Schema }
+export type { CollectionAuthoring, CollectionAuthoringAnchor, CollectionAuthoringSections } from '../elements'

package/src/site/version.ts

@@ -1 +1 @@
-export const SITE_KIT_VERSION = '1.6.2'
+export const SITE_KIT_VERSION = '1.6.3'

package/src/site/wire.ts

@@ -33,7 +33,7 @@ export type DocumentReply = {
   /** By `entryKey(collection, id)`. */
   entries: Record<string, EntryRecord>
   /** By `queryKey(collection, query)`. */
-  queries: Record<string, { ids: Id[]; total: number }>
+  queries: Record<string, { ids: Id[]; total: number; matches?: Id[] }>
   /** By `inverseKey(collection, field, id)`. */
   inverses: Record<string, Id[]>
   tags: string[]

package/src/testing/fake.ts

@@ -6,7 +6,7 @@ import { seedCtx, seedEntry, seedSite, type Store } from '../site/store'
 
 export type { RouteRead }
 const assembled = (site: Site, store: Store, target: ReplyTarget, draft: boolean): RouteRead =>
-  assemble(site, replyFrom(site, store, target, ''), { draft, target, stale: false, defaults: null })
+  assemble(site, replyFrom(site, store, target, '', draft), { draft, target, stale: false, defaults: null })
 /** A route read against a store, assembled as the site assembles a platform's reply. */
 export const routeRead = (site: Site, store: Store, pathname: string, draft: boolean): RouteRead => assembled(site, store, { route: pathname }, draft)
 /**
@@ -83,14 +83,14 @@ export async function createFakePlatform(site: Site, store?: Store, opts: { mani
     // A site with languages hears which language answered, as the platform says it, and which languages have copy of the document (ruling R2).
     const answer = (reply: Reply) =>
       json(reply.status === 'ok' && chain?.locale ? { ...reply, locale: chain.locale, ...(languages ? { translated: translatedOf(`${reply.document.kind}:${reply.document.id}`) } : {}) } : reply)
-    if (p === '/route') return answer(replyFrom(site, view, { route: url.searchParams.get('path') ?? '/' }, manifest))
-    if (p.startsWith('/page/')) return answer(replyFrom(site, view, { page: decodeURIComponent(p.slice(6)) }, manifest))
+    if (p === '/route') return answer(replyFrom(site, view, { route: url.searchParams.get('path') ?? '/' }, manifest, draft))
+    if (p.startsWith('/page/')) return answer(replyFrom(site, view, { page: decodeURIComponent(p.slice(6)) }, manifest, draft))
     if (p.startsWith('/entry/')) {
       // The read client encodes both segments (and a URL's pathname keeps them encoded), so a
       // non-ASCII slug arrives as `caf%C3%A9`; decoded after the split, so an encoded `/` stays in its segment.
       let segments: string[]
       try { segments = p.split('/').slice(2).map(decodeURIComponent) } catch { return json({ error: 'malformed path' }, 400) }
-      return answer(replyFrom(site, view, { entry: { collection: segments[0], slug: segments[1] } }, manifest))
+      return answer(replyFrom(site, view, { entry: { collection: segments[0], slug: segments[1] } }, manifest, draft))
     }
     if (p === '/site') return opts.failSite ? json({ error: 'site settings unavailable' }, 500) : json(languages ? { ...settings, languages } : settings)
     if (p === '/sitemap') {