@crombolo/server 0.10.0 → 0.12.1

package/src/adapters/health.ts

@@ -0,0 +1,333 @@
+/**
+ * The diagnostics port: health checks for what actually goes wrong on a site,
+ * the troubleshooting report and the upgrade check. docs/diagnostics.md.
+ */
+import type { DiagnosticsPort, HealthCheckGroup, HealthCheckResult } from '@crombolo/api-management'
+import {
+  compareStates,
+  cromboloPlan,
+  currentSchemaState,
+  type Db,
+  liveNodes,
+  type NodeSchemaState,
+  pendingMigrations,
+} from '@crombolo/data'
+import { BundleConfigurationError, bundleChainsFor, pendingBundleSteps } from '../bundle-tables.ts'
+import { type CromboloConfig, describeDatabase, VERSION } from '../config.ts'
+import { type EmailPort, emailAvailability } from '../email.ts'
+import type { MediaStore } from '../media-store.ts'
+import { backofficeVersion } from '../status.ts'
+
+export const UPGRADE_PACKAGE = '@crombolo/crombolo'
+
+/** How recently a node must have polled to count as part of the cluster. */
+const LIVE_WITHIN_MS = 60_000
+
+const CHECKS = {
+  database: { id: '6f1d4a8e-0047-4c1a-9e7d-000000000001', name: 'Database connection' },
+  migrations: { id: '6f1d4a8e-0047-4c1a-9e7d-000000000002', name: 'Database upgrades' },
+  media: { id: '6f1d4a8e-0047-4c1a-9e7d-000000000003', name: 'Media storage' },
+  email: { id: '6f1d4a8e-0047-4c1a-9e7d-000000000004', name: 'E-mail delivery' },
+  nodes: { id: '6f1d4a8e-0047-4c1a-9e7d-000000000005', name: 'Servers' },
+} as const
+
+const GROUPS: HealthCheckGroup[] = [
+  {
+    name: 'Database',
+    checks: [
+      { ...CHECKS.database, description: 'Whether the database answers, and which one it is.' },
+      {
+        ...CHECKS.migrations,
+        description: 'Whether the database is up to date with this release and its schema files.',
+      },
+    ],
+  },
+  {
+    name: 'Media',
+    checks: [{ ...CHECKS.media, description: 'Whether uploaded files can be written and read.' }],
+  },
+  {
+    name: 'E-mail',
+    checks: [{ ...CHECKS.email, description: 'Whether this site can send e-mail.' }],
+  },
+  {
+    name: 'Servers',
+    checks: [
+      {
+        ...CHECKS.nodes,
+        description: 'The servers running this site, and whether they run the same release.',
+      },
+    ],
+  },
+]
+
+export interface HealthCheckOptions {
+  config: CromboloConfig
+  db: Db
+  media: MediaStore
+  email?: EmailPort
+  /** What this node deploys at; read from the database's own state when omitted. */
+  nodeState?: NodeSchemaState
+  fetch?: typeof fetch
+  now?: () => Date
+}
+
+const result = (
+  resultType: HealthCheckResult['resultType'],
+  message: string,
+): HealthCheckResult => ({ resultType, message })
+
+const failure = (error: unknown) => (error instanceof Error ? error.message : String(error))
+
+/** `0.13.0` against `0.12.0`: which part moved, or None when the first is not newer. */
+export function upgradeType(latest: string, current: string): 'None' | 'Patch' | 'Minor' | 'Major' {
+  const parts = (value: string) =>
+    (value.split('-')[0] ?? '').split('.').map((part) => Number(part) || 0)
+  const [a, b] = [parts(latest), parts(current)]
+  for (const [index, type] of (['Major', 'Minor', 'Patch'] as const).entries()) {
+    const difference = (a[index] ?? 0) - (b[index] ?? 0)
+    if (difference > 0) return type
+    if (difference < 0) return 'None'
+  }
+  return 'None'
+}
+
+function ago(then: Date, now: Date): string {
+  const seconds = Math.max(0, Math.round((now.getTime() - then.getTime()) / 1000))
+  return seconds < 2 ? 'just now' : `${seconds} seconds ago`
+}
+
+export function createDiagnosticsPort(options: HealthCheckOptions): DiagnosticsPort {
+  const { config, db, media } = options
+  const now = options.now ?? (() => new Date())
+  const call = options.fetch ?? fetch
+  let checked:
+    | { at: number; answer: Awaited<ReturnType<DiagnosticsPort['upgradeCheck']>> }
+    | undefined
+
+  async function database(): Promise<HealthCheckResult[]> {
+    const dialect = db.dialect.name === 'postgres' ? 'PostgreSQL' : 'SQLite'
+    try {
+      await db.query('SELECT 1 AS ok')
+      return [result('Success', `${dialect} is answering (${describeDatabase(config)}).`)]
+    } catch (error) {
+      return [result('Error', `${dialect} is not answering: ${failure(error)}`)]
+    }
+  }
+
+  async function migrations(): Promise<HealthCheckResult[]> {
+    const results: HealthCheckResult[] = []
+    try {
+      const pending = await pendingMigrations(db, cromboloPlan)
+      results.push(
+        pending.length === 0
+          ? result('Success', `The database is up to date with Crombolo ${VERSION}.`)
+          : result(
+              'Error',
+              `${pending.length} database upgrade(s) for Crombolo ${VERSION} have not run yet: ${pending.map((m) => m.name).join(', ')}. Run \`crombolo upgrade\`.`,
+            ),
+      )
+      for (const bundle of await pendingBundleSteps(db, bundleChainsFor(config)))
+        if (bundle.pending.length > 0)
+          results.push(
+            result(
+              'Error',
+              `The bundle "${bundle.name}" has ${bundle.pending.length} upgrade step(s) that have not run yet. Run \`crombolo upgrade\`.`,
+            ),
+          )
+      if (options.nodeState) {
+        const state = await currentSchemaState(db)
+        const difference = compareStates(options.nodeState, state)
+        if (difference < 0)
+          results.push(
+            result(
+              'Warning',
+              `The database's schema is ${state.version} (revision ${state.revision}), newer than this server's ${options.nodeState.version} (revision ${options.nodeState.revision}): this server reads but refuses changes until it is replaced.`,
+            ),
+          )
+        else if (difference > 0)
+          results.push(
+            result(
+              'Warning',
+              `This server's schema files are ${options.nodeState.version} (revision ${options.nodeState.revision}), ahead of the database's ${state.version} (revision ${state.revision}).`,
+            ),
+          )
+      }
+    } catch (error) {
+      results.push(
+        result(
+          'Error',
+          error instanceof BundleConfigurationError
+            ? error.problems.join(' ')
+            : `The upgrade state could not be read: ${failure(error)}`,
+        ),
+      )
+    }
+    return results
+  }
+
+  async function mediaStorage(): Promise<HealthCheckResult[]> {
+    const key = `health-check/${crypto.randomUUID()}.txt`
+    const written = new TextEncoder().encode('ok')
+    try {
+      await media.put(key, written, { contentType: 'text/plain' })
+      const read = await media.get(key)
+      const bytes = read ? await read.bytes() : undefined
+      await media.delete(key)
+      if (!bytes || new TextDecoder().decode(bytes) !== 'ok')
+        return [result('Error', `A file written to ${media.description} could not be read back.`)]
+      return [result('Success', `Files can be written to and read from ${media.description}.`)]
+    } catch (error) {
+      return [result('Error', `${media.description} could not be used: ${failure(error)}`)]
+    }
+  }
+
+  function email(): HealthCheckResult[] {
+    const availability = emailAvailability(options.email)
+    if (availability.available)
+      return [result('Success', `E-mail is sent through ${availability.description}.`)]
+    const affects =
+      availability.affects.length > 0
+        ? ` Unavailable until it is: ${availability.affects.join(', ')}.`
+        : ''
+    return [
+      result(
+        availability.provider === 'log' ? 'Info' : 'Warning',
+        `${availability.reason}${affects}`,
+      ),
+    ]
+  }
+
+  async function nodes(): Promise<HealthCheckResult[]> {
+    const live = await liveNodes(db, { seenWithinMs: LIVE_WITHIN_MS })
+    if (live.length === 0) return [result('Warning', 'No server has reported in the last minute.')]
+    const at = now()
+    const results = live.map((node) =>
+      result(
+        'Info',
+        `${node.nodeId}${node.role ? ` (${node.role})` : ''} runs Crombolo ${node.cromboloVersion ?? 'of an unknown release'} with schema ${node.version ?? '?'} revision ${node.revision ?? '?'}, last seen ${ago(node.lastSeen, at)}.`,
+      ),
+    )
+    const releases = new Set(live.map((node) => node.cromboloVersion ?? 'unknown'))
+    const schemas = new Set(live.map((node) => `${node.version}/${node.revision}`))
+    if (releases.size > 1)
+      results.unshift(
+        result(
+          'Warning',
+          `The servers run different releases (${[...releases].join(', ')}). That is expected only while an upgrade rolls out.`,
+        ),
+      )
+    else if (schemas.size > 1)
+      results.unshift(
+        result(
+          'Warning',
+          'The servers deploy different schema files. That is expected only while a deploy rolls out.',
+        ),
+      )
+    else
+      results.unshift(
+        result('Success', `${live.length} server(s) running Crombolo ${[...releases][0]}.`),
+      )
+    return results
+  }
+
+  const runners: Record<string, () => HealthCheckResult[] | Promise<HealthCheckResult[]>> = {
+    [CHECKS.database.id]: database,
+    [CHECKS.migrations.id]: migrations,
+    [CHECKS.media.id]: mediaStorage,
+    [CHECKS.email.id]: email,
+    [CHECKS.nodes.id]: nodes,
+  }
+
+  return {
+    groups: () => GROUPS,
+
+    async run(name) {
+      const group = GROUPS.find((candidate) => candidate.name === name)
+      if (!group) return undefined
+      return Promise.all(
+        group.checks.map(async (check) => {
+          try {
+            return {
+              id: check.id,
+              results: await (runners[check.id] as () => Promise<HealthCheckResult[]>)(),
+            }
+          } catch (error) {
+            return {
+              id: check.id,
+              results: [result('Error', `The check failed: ${failure(error)}`)],
+            }
+          }
+        }),
+      )
+    },
+
+    async troubleshooting() {
+      const availability = emailAvailability(options.email)
+      const state = options.nodeState
+      const items: Array<[string, string | undefined]> = [
+        ['Crombolo version', VERSION],
+        ['Backoffice version', backofficeVersion()],
+        ['Runtime', `Bun ${Bun.version}`],
+        ['Operating system', `${process.platform} ${process.arch}`],
+        ['Mode', config.development ? 'Development' : 'Production'],
+        ['Server', `${config.nodeId} (${config.role})`],
+        ['Database', db.dialect.name === 'postgres' ? 'PostgreSQL' : 'SQLite'],
+        ['Database location', describeDatabase(config)],
+        ['Schema', state ? `${state.version} revision ${state.revision}` : undefined],
+        ['Upgrade policy', config.upgradePolicy],
+        ['Media storage', media.description],
+        [
+          'E-mail',
+          availability.available ? (availability.description ?? undefined) : 'Not configured',
+        ],
+        ['Log level', config.logLevel],
+        ['Time zone', Intl.DateTimeFormat().resolvedOptions().timeZone],
+        ['Server time', now().toISOString()],
+      ]
+      return {
+        items: items
+          .filter((item): item is [string, string] => item[1] !== undefined)
+          .map(([name, data]) => ({ name, data })),
+      }
+    },
+
+    async upgradeCheck() {
+      if (config.versionCheckPeriod <= 0)
+        return { type: 'None', comment: 'Checking for new releases is turned off.', url: '' }
+      const periodMs = config.versionCheckPeriod * 86_400_000
+      if (checked && now().getTime() - checked.at < periodMs) return checked.answer
+      let answer: Awaited<ReturnType<DiagnosticsPort['upgradeCheck']>>
+      try {
+        const response = await call(
+          `${config.npmRegistry.replace(/\/$/, '')}/${encodeURIComponent(UPGRADE_PACKAGE)}`,
+          { headers: { accept: 'application/json' } },
+        )
+        if (!response.ok) throw new Error(`the registry answered ${response.status}`)
+        const latest = ((await response.json()) as { 'dist-tags'?: { latest?: string } })[
+          'dist-tags'
+        ]?.latest
+        if (!latest) throw new Error('the registry named no latest release')
+        const type = upgradeType(latest, VERSION)
+        answer =
+          type === 'None'
+            ? { type, comment: `Crombolo ${VERSION} is the latest release.`, url: '' }
+            : {
+                type,
+                comment: `Crombolo ${latest} is available; this site runs ${VERSION}.`,
+                url: `https://www.npmjs.com/package/${UPGRADE_PACKAGE}/v/${latest}`,
+              }
+      } catch (error) {
+        // Not cached: an air-gapped site asks again next time rather than
+        // being told nothing for a week.
+        return {
+          type: 'None',
+          comment: `The package registry could not be reached to check for a newer release (${failure(error)}).`,
+          url: '',
+        }
+      }
+      checked = { at: now().getTime(), answer }
+      return answer
+    },
+  }
+}

package/src/adapters/media.ts

@@ -19,6 +19,7 @@ import {
   DataTypeRepository,
   type Db,
   DocumentRepository,
+  InvalidParentError,
   type NodeRow,
   type NodeSchemaState,
   type ValueIntake,
@@ -65,6 +66,8 @@ export function createMediaPort(
   const failure = (error: unknown) => {
     if (error instanceof WriteRejectedError)
       return { ok: false as const, reason: error.message, status: 409 }
+    if (error instanceof InvalidParentError)
+      return { ok: false as const, reason: error.message, status: 400 }
     if (error instanceof TemporaryFileMissingError)
       return { ok: false as const, reason: error.message, status: 400 }
     throw error

package/src/adapters/members.ts

@@ -45,6 +45,11 @@ export interface MemberPortOptions extends DocumentRepositoryOptions {
   valueIntake?: ValueIntake
   /** How many failed sign-ins lock an account out; Umbraco's default is 5. */
   maxFailedPasswordAttempts?: number
+  /**
+   * The members the Delivery API's client credentials sign in as: Umbraco shows
+   * them as kind `Api`, derived from config rather than stored.
+   */
+  apiMemberUserNames?: readonly string[]
 }
 
 const notFound = () => ({
@@ -54,6 +59,9 @@ const notFound = () => ({
 })
 
 export function createMemberPort(db: Db, options: MemberPortOptions = {}): MemberPort {
+  const apiMembers = new Set((options.apiMemberUserNames ?? []).map((n) => n.toLowerCase()))
+  const kindOf = (userName: string): 'Api' | 'Default' =>
+    apiMembers.has(userName.toLowerCase()) ? 'Api' : 'Default'
   const members = new MemberRepository(db, options)
   const memberTypes = new ContentTypeRepository(db, { kind: 'member' })
 
@@ -110,7 +118,7 @@ export function createMemberPort(db: Db, options: MemberPortOptions = {}): Membe
       lastLockoutDate: member.lastLockoutDate?.toISOString() ?? null,
       lastPasswordChangeDate: member.lastPasswordChangeDate?.toISOString() ?? null,
       groups: await members.groupKeys(member.key),
-      kind: 'Default',
+      kind: kindOf(member.username),
       profileData: null,
       flags: [],
       values: content.values
@@ -136,7 +144,7 @@ export function createMemberPort(db: Db, options: MemberPortOptions = {}): Membe
     id: member.key,
     memberType: { id: member.contentTypeKey, icon: member.contentTypeIcon ?? 'icon-user' },
     variants: [{ name: member.name, culture: null }],
-    kind: 'Default',
+    kind: kindOf(member.username),
     flags: [],
   })
 

package/src/adapters/references.ts

@@ -50,7 +50,20 @@ function toReference(node: ReferencingNode): unknown {
 
 export function createReferencePort(db: Db): ReferencePort {
   const references = new ReferenceRepository(db)
+  const binTypes = {
+    Document: ObjectTypes.Document,
+    Media: ObjectTypes.Media,
+    Element: ObjectTypes.Element,
+  } as const
   return {
+    async recycleBinReferencedBy(area, paging) {
+      const result = await references.referencingRecycleBin(
+        binTypes[area],
+        paging.skip,
+        paging.take,
+      )
+      return { total: result.total, items: result.items.map(toReference) }
+    },
     async referencedBy(key, paging) {
       const result = await references.referencedBy(key, paging.skip, paging.take)
       return { total: result.total, items: result.items.map(toReference) }

package/src/adapters/relations.ts

@@ -0,0 +1,48 @@
+/** Relation types and their derived relations, shaped for the wire. */
+import type { RelationPort, RelationTypeView } from '@crombolo/api-management'
+import { ObjectTypes } from '@crombolo/core'
+import { type Db, RELATION_TYPES, RelationRepository, relationTypeByKey } from '@crombolo/data'
+
+/** Umbraco's friendly names for the object types a relation type joins. */
+const OBJECT_TYPE_NAMES: Record<string, string> = {
+  [ObjectTypes.Document]: 'Document',
+  [ObjectTypes.Media]: 'Media',
+  [ObjectTypes.Member]: 'Member',
+  [ObjectTypes.Element]: 'Element',
+  [ObjectTypes.ElementContainer]: 'Element Container',
+}
+
+const objectType = (id: string | null) => (id ? { id, name: OBJECT_TYPE_NAMES[id] ?? id } : null)
+
+const VIEWS: readonly RelationTypeView[] = RELATION_TYPES.map((type) => ({
+  id: type.key,
+  alias: type.alias,
+  name: type.name,
+  parentObject: objectType(type.parentObjectType),
+  childObject: objectType(type.childObjectType),
+  isBidirectional: type.isBidirectional,
+  isDependency: type.isDependency,
+}))
+
+export function createRelationPort(db: Db): RelationPort {
+  const relations = new RelationRepository(db)
+  return {
+    types: () => VIEWS,
+    async relations(typeKey, paging) {
+      const type = relationTypeByKey(typeKey)
+      if (!type) return undefined
+      const result = await relations.relations(type, paging.skip, paging.take)
+      return {
+        total: result.total,
+        items: result.items.map((relation) => ({
+          id: relation.key,
+          relationType: { id: relation.typeKey },
+          parent: { id: relation.parent.key, name: relation.parent.name },
+          child: { id: relation.child.key, name: relation.child.name },
+          createDate: relation.createDate.toISOString(),
+          comment: null,
+        })),
+      }
+    },
+  }
+}

package/src/adapters/schema-files.ts

@@ -8,7 +8,7 @@
 import { existsSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
 import { join, relative } from 'node:path'
 import type { PortFailure } from '@crombolo/api-management'
-import type { ContentTypeAggregate, DataTypeModel } from '@crombolo/core'
+import type { ContentTypeAggregate, DataTypeModel, FormTypes } from '@crombolo/core'
 import { currentSchemaState, type Db, updateSchemaStateHash } from '@crombolo/data'
 import {
   type ChangeClass,
@@ -18,6 +18,7 @@ import {
   loadSchemaDirectory,
   nextSchemaVersion,
   type SchemaTypeKind,
+  type SchemaUrls,
   TYPE_KIND_FILES,
   validateSchemaSet,
   writeContentType,
@@ -32,6 +33,8 @@ export interface SchemaFiles {
   schemaDir: string
   writable: boolean
   componentAliases(): ReadonlySet<string>
+  /** The form types the site's wired bundles add. */
+  formTypes?: FormTypes
   /**
    * Called after any write, so a shared schema store outlives this container.
    * Absent when the schema is a directory on disk, which needs no publishing.
@@ -54,6 +57,8 @@ export interface SchemaFileWriter {
   writeDataType(model: DataTypeModel): Promise<void>
   removeDataType(alias: string): Promise<void>
   writeLanguages(): Promise<void>
+  /** `[urls]` in `schema.toml`, the version left as it is. */
+  writeUrlOptions(urls: SchemaUrls): Promise<void>
   /** After a move or a folder change: every file, from the database, canonically. */
   rewriteAll(): Promise<void>
 }
@@ -82,7 +87,7 @@ export function createSchemaFileWriter(
     await updateSchemaStateHash(
       db,
       state.id,
-      hashSchemaSet(loadSchemaDirectory(files.schemaDir).set),
+      hashSchemaSet(loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes }).set),
     )
     await files.onChanged?.()
   }
@@ -100,10 +105,10 @@ export function createSchemaFileWriter(
 
     async bumpVersion(classification) {
       if (!managed() || !files.writable || classification === 'none') return
-      const loaded = loadSchemaDirectory(files.schemaDir)
+      const loaded = loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes })
       const next = nextSchemaVersion(loaded.set.version, classification)
       if (next === loaded.set.version) return
-      writeFileSync(join(files.schemaDir, 'schema.toml'), writeSchemaVersion(next))
+      writeFileSync(join(files.schemaDir, 'schema.toml'), writeSchemaVersion(next, loaded.set.urls))
       logger('schema').info('Schema version {from} → {to} ({classification})', {
         from: loaded.set.version,
         to: next,
@@ -113,7 +118,10 @@ export function createSchemaFileWriter(
 
     async write(aggregate, previousAlias) {
       if (!managed() || !files.writable) return
-      const set = await exportSchemaSet(db, loadSchemaDirectory(files.schemaDir).set.version)
+      const set = await exportSchemaSet(
+        db,
+        loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes }).set.version,
+      )
       const list =
         kind === 'document'
           ? set.contentTypes
@@ -122,7 +130,10 @@ export function createSchemaFileWriter(
             : (set.memberTypes ?? [])
       const type = list.find((t) => t.key === aggregate.key)
       if (!type) return
-      const problems = validateSchemaSet(set, { componentAliases: files.componentAliases() })
+      const problems = validateSchemaSet(set, {
+        componentAliases: files.componentAliases(),
+        types: files.formTypes,
+      })
       if (problems.length > 0) {
         const detail = problems.map((p) => `${p.file}: ${p.message}`).join('; ')
         logger('schema').error('Not writing {file}: {detail}', {
@@ -146,7 +157,10 @@ export function createSchemaFileWriter(
 
     async writeDataType(model) {
       if (!managed() || !files.writable || !model.alias) return
-      const set = await exportSchemaSet(db, loadSchemaDirectory(files.schemaDir).set.version)
+      const set = await exportSchemaSet(
+        db,
+        loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes }).set.version,
+      )
       const dataType = set.dataTypes.find((d) => d.key === model.key)
       // An unchanged built-in has no file; a changed one does.
       if (!dataType) {
@@ -157,7 +171,10 @@ export function createSchemaFileWriter(
       // The same guard `write` applies to a content type: a set that does not
       // validate never reaches the disk, because the file is what every other
       // node reads and what a deploy boots from.
-      const problems = validateSchemaSet(set, { componentAliases: files.componentAliases() })
+      const problems = validateSchemaSet(set, {
+        componentAliases: files.componentAliases(),
+        types: files.formTypes,
+      })
       if (problems.length > 0) {
         const detail = problems.map((p) => `${p.file}: ${p.message}`).join('; ')
         logger('schema').error('Not writing {file}: {detail}', {
@@ -182,16 +199,29 @@ export function createSchemaFileWriter(
 
     async writeLanguages() {
       if (!managed() || !files.writable) return
-      const set = await exportSchemaSet(db, loadSchemaDirectory(files.schemaDir).set.version)
+      const set = await exportSchemaSet(
+        db,
+        loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes }).set.version,
+      )
       writeFileSync(join(files.schemaDir, 'languages.toml'), writeLanguages(set.languages))
       await settle()
     },
 
+    async writeUrlOptions(urls) {
+      if (!managed() || !files.writable) return
+      const { version } = loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes }).set
+      writeFileSync(join(files.schemaDir, 'schema.toml'), writeSchemaVersion(version, urls))
+      await settle()
+    },
+
     async rewriteAll() {
       if (!managed() || !files.writable) return
-      const loaded = loadSchemaDirectory(files.schemaDir)
+      const loaded = loadSchemaDirectory(files.schemaDir, { formTypes: files.formTypes })
       const set = await exportSchemaSet(db, loaded.set.version)
-      const problems = validateSchemaSet(set, { componentAliases: files.componentAliases() })
+      const problems = validateSchemaSet(set, {
+        componentAliases: files.componentAliases(),
+        types: files.formTypes,
+      })
       if (problems.length > 0) {
         const detail = problems.map((p) => `${p.file}: ${p.message}`).join('; ')
         logger('schema').error('Not rewriting the schema files: {detail}', { detail })

package/src/adapters/schema-proposals.ts

@@ -18,6 +18,7 @@ import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { dirname, join } from 'node:path'
 import type { SchemaProposalPort } from '@crombolo/assistant'
 import type { Db } from '@crombolo/data'
+import type { SyncReport } from '@crombolo/schema'
 import {
   fileNameFor,
   loadSchemaDirectory,
@@ -32,6 +33,7 @@ import {
   writeSchemaVersion,
 } from '@crombolo/schema'
 import type { CromboloConfig } from '../config.ts'
+import { formTypesFor } from '../form-types.ts'
 import { logger } from '../logging.ts'
 import { componentAliasesIn, importSchema } from '../schema.ts'
 
@@ -48,6 +50,8 @@ export interface SchemaProposalOptions {
   config: CromboloConfig
   /** The node's identity and state, refreshed in place by an import. */
   boot: { nodeId: string; nodeState: { version: string; revision: string } }
+  /** After an import applies: what a change to how URLs are built needs. */
+  afterSync?(report: SyncReport | undefined): Promise<void>
 }
 
 export function createSchemaProposals(options: SchemaProposalOptions): SchemaProposalPort {
@@ -70,12 +74,12 @@ export function createSchemaProposals(options: SchemaProposalOptions): SchemaPro
           ? parsed.problems
           : [{ file, path: '', message: 'the file defines no data type' }]
       }
-      const set = loadSchemaDirectory(config.schemaDir).set
+      const set = loadSchemaDirectory(config.schemaDir, { formTypes: formTypesFor(config) }).set
       const dataTypes = [
         ...set.dataTypes.filter((existing) => existing.alias !== dataType.alias),
         dataType,
       ]
-      return validateSchemaSet({ ...set, dataTypes })
+      return validateSchemaSet({ ...set, dataTypes }, { types: formTypesFor(config) })
     }
 
     const parsed = parseContentType(file, toml)
@@ -85,14 +89,14 @@ export function createSchemaProposals(options: SchemaProposalOptions): SchemaPro
         ? parsed.problems
         : [{ file, path: '', message: 'the file defines no content type' }]
     }
-    const set = loadSchemaDirectory(config.schemaDir).set
+    const set = loadSchemaDirectory(config.schemaDir, { formTypes: formTypesFor(config) }).set
     const contentTypes = [
       ...set.contentTypes.filter((existing) => existing.alias !== contentType.alias),
       contentType,
     ]
     return validateSchemaSet(
       { ...set, contentTypes },
-      { componentAliases: componentAliasesIn(config.componentsDir) },
+      { componentAliases: componentAliasesIn(config.componentsDir), types: formTypesFor(config) },
     )
   }
 
@@ -140,9 +144,11 @@ export function createSchemaProposals(options: SchemaProposalOptions): SchemaPro
       // import lands at a version the other nodes already have and they never
       // learn they are behind.
       const ahead = await importSchema(options.db, config, options.boot, { dryRun: true })
-      const version = loadSchemaDirectory(config.schemaDir).set.version
+      const { version, urls } = loadSchemaDirectory(config.schemaDir, {
+        formTypes: formTypesFor(config),
+      }).set
       const next = nextSchemaVersion(version, ahead.classification)
-      if (next !== version) await writeFile(versionFile, writeSchemaVersion(next), 'utf8')
+      if (next !== version) await writeFile(versionFile, writeSchemaVersion(next, urls), 'utf8')
 
       const result = await importSchema(options.db, config, options.boot)
       if (result.report && result.report.action !== 'applied') {
@@ -154,6 +160,7 @@ export function createSchemaProposals(options: SchemaProposalOptions): SchemaPro
           error: result.report.reason ?? `the import was ${result.report.action}`,
         }
       }
+      await options.afterSync?.(result.report)
       log.info('{alias} applied from a proposal: {classification}, schema at {version}', {
         alias,
         classification: ahead.classification,