@crombolo/data 0.11.0 → 0.12.1

package/src/repositories/dynamic-roots.ts

@@ -0,0 +1,151 @@
+/**
+ * Dynamic roots: a content picker's start node, found from the document being
+ * edited by an origin and a list of steps, as Umbraco's are. docs/api-contract.md.
+ */
+import { normaliseUuid, ObjectTypes } from '@crombolo/core'
+import type { Db } from '../database.ts'
+
+export interface DynamicRootQuery {
+  /** The document being edited; null while it is being created. */
+  currentKey: string | null
+  /** Its parent; null at the root of the tree. */
+  parentKey: string | null
+  origin: { alias: string; key?: string | null }
+  steps: Array<{ alias: string; documentTypeKeys: string[] }>
+}
+
+interface Node {
+  id: number
+  key: string
+  level: number
+  path: string
+  typeKey: string
+}
+
+/** The virtual root above the tree: ContentRoot's origin, which descendant steps start from. */
+const CONTENT_ROOT: Node = { id: -1, key: '', level: 0, path: '-1', typeKey: '' }
+
+const SELECT = `SELECT n.id, n.unique_id, n.level, n.path, t.unique_id AS type_key
+  FROM node n
+  JOIN content c ON c.node_id = n.id
+  JOIN node t ON t.id = c.content_type_id`
+
+export class DynamicRootRepository {
+  #db: Db
+
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  /** The keys the query lands on, nearest first; empty when it finds nothing. */
+  async resolve(query: DynamicRootQuery): Promise<string[]> {
+    const origin = await this.#origin(query)
+    if (!origin) return []
+    let found: Node[] = [origin]
+    for (const step of query.steps) {
+      const types = new Set(step.documentTypeKeys.map((key) => normaliseUuid(key)))
+      const next = new Map<number, Node>()
+      for (const node of found)
+        for (const hit of await this.#step(node, step.alias, types)) next.set(hit.id, hit)
+      found = [...next.values()]
+      if (found.length === 0) return []
+    }
+    return found.filter((node) => node.id !== CONTENT_ROOT.id).map((node) => node.key)
+  }
+
+  async #origin(query: DynamicRootQuery): Promise<Node | undefined> {
+    const context = query.currentKey ?? query.parentKey
+    switch (query.origin.alias) {
+      case 'ContentRoot':
+        return CONTENT_ROOT
+      case 'ByKey':
+        return query.origin.key ? this.#byKey(query.origin.key) : undefined
+      case 'Current':
+        return query.currentKey ? this.#byKey(query.currentKey) : undefined
+      case 'Parent':
+        return query.parentKey ? this.#byKey(query.parentKey) : undefined
+      case 'Root':
+        return context ? this.#root(context) : undefined
+      case 'Site':
+        return context ? ((await this.#site(context)) ?? this.#root(context)) : undefined
+      default:
+        return undefined
+    }
+  }
+
+  async #step(node: Node, alias: string, types: Set<string>): Promise<Node[]> {
+    const matches = (candidate: Node) => types.size === 0 || types.has(candidate.typeKey)
+    switch (alias) {
+      case 'NearestAncestorOrSelf':
+      case 'FurthestAncestorOrSelf': {
+        const line = (await this.#ancestorsOrSelf(node)).filter(matches)
+        const pick = alias === 'NearestAncestorOrSelf' ? line.at(-1) : line[0]
+        return pick ? [pick] : []
+      }
+      case 'NearestDescendantOrSelf':
+      case 'FurthestDescendantOrSelf': {
+        const below = (await this.#descendantsOrSelf(node)).filter(matches)
+        if (below.length === 0) return []
+        const levels = below.map((candidate) => candidate.level)
+        const level =
+          alias === 'NearestDescendantOrSelf' ? Math.min(...levels) : Math.max(...levels)
+        return below.filter((candidate) => candidate.level === level)
+      }
+      default:
+        return []
+    }
+  }
+
+  async #query(where: string, params: unknown[]): Promise<Node[]> {
+    const rows = await this.#db.query(
+      `${SELECT} WHERE n.node_object_type = ? AND n.trashed = ? AND ${where} ORDER BY n.level, n.sort_order`,
+      [ObjectTypes.Document, this.#db.dialect.boolValue(false), ...params],
+    )
+    return rows.map((row) => ({
+      id: Number(row.id),
+      key: normaliseUuid(String(row.unique_id)),
+      level: Number(row.level),
+      path: String(row.path),
+      typeKey: normaliseUuid(String(row.type_key)),
+    }))
+  }
+
+  async #byKey(key: string): Promise<Node | undefined> {
+    return (await this.#query('n.unique_id = ?', [normaliseUuid(key)]))[0]
+  }
+
+  /** Top of the tree first, `node` last. */
+  async #ancestorsOrSelf(node: Node): Promise<Node[]> {
+    if (node.id === CONTENT_ROOT.id) return []
+    const ids = node.path
+      .split(',')
+      .map(Number)
+      .filter((id) => id > 0)
+    if (ids.length === 0) return []
+    return this.#query(`n.id IN (${ids.map(() => '?').join(', ')})`, ids)
+  }
+
+  async #descendantsOrSelf(node: Node): Promise<Node[]> {
+    if (node.id === CONTENT_ROOT.id) return this.#query('n.level >= 1', [])
+    return this.#query('(n.id = ? OR n.path LIKE ?)', [node.id, `${node.path},%`])
+  }
+
+  async #root(key: string): Promise<Node | undefined> {
+    const node = await this.#byKey(key)
+    return node ? (await this.#ancestorsOrSelf(node))[0] : undefined
+  }
+
+  /** The nearest ancestor-or-self that a hostname makes a site root. */
+  async #site(key: string): Promise<Node | undefined> {
+    const node = await this.#byKey(key)
+    if (!node) return undefined
+    const line = await this.#ancestorsOrSelf(node)
+    if (line.length === 0) return undefined
+    const rows = await this.#db.query<{ node_id: number }>(
+      `SELECT DISTINCT node_id FROM domain WHERE domain_name NOT LIKE '*%' AND node_id IN (${line.map(() => '?').join(', ')})`,
+      line.map((candidate) => candidate.id),
+    )
+    const sites = new Set(rows.map((row) => Number(row.node_id)))
+    return line.filter((candidate) => sites.has(candidate.id)).at(-1)
+  }
+}

package/src/repositories/form-entries.ts

@@ -23,6 +23,11 @@ export interface FormEntryValue {
   fieldAlias: string
   /** One row per selection for a multi-value field, in the order submitted. */
   values: string[]
+  /**
+   * What the visitor saw for each value, when the choice came from a source and
+   * the value is a key; present only then.
+   */
+  labels?: string[]
 }
 
 export interface FormEntry {
@@ -83,6 +88,7 @@ interface ValueRow {
   field_alias: string
   sort_order: number
   value: string | null
+  label: string | null
 }
 
 const SELECT = `SELECT id, form_key, form_alias, state, culture, page_key, ip_hash,
@@ -109,19 +115,24 @@ const hydrate = (row: EntryRow, values: FormEntryValue[]): FormEntry => ({
 
 /** Value rows into one entry per id, each field's selections in order. */
 function group(rows: readonly ValueRow[]): Map<string, FormEntryValue[]> {
-  const byEntry = new Map<string, Map<string, string[]>>()
+  const byEntry = new Map<string, Map<string, ValueRow[]>>()
   for (const row of rows) {
-    const fields = byEntry.get(row.entry_id) ?? new Map<string, string[]>()
+    const fields = byEntry.get(row.entry_id) ?? new Map<string, ValueRow[]>()
     byEntry.set(row.entry_id, fields)
     const values = fields.get(row.field_alias) ?? []
     fields.set(row.field_alias, values)
-    values.push(row.value ?? '')
+    values.push(row)
   }
   const out = new Map<string, FormEntryValue[]>()
   for (const [id, fields] of byEntry)
     out.set(
       id,
-      [...fields].map(([fieldAlias, values]) => ({ fieldAlias, values })),
+      [...fields].map(([fieldAlias, list]) => {
+        const values = list.map((row) => row.value ?? '')
+        return list.some((row) => row.label !== null)
+          ? { fieldAlias, values, labels: list.map((row, i) => row.label ?? (values[i] as string)) }
+          : { fieldAlias, values }
+      }),
     )
   return out
 }
@@ -137,7 +148,7 @@ export class FormEntryRepository {
     if (ids.length === 0) return new Map()
     const placeholders = ids.map(() => '?').join(', ')
     const rows = await this.#db.query<ValueRow>(
-      `SELECT entry_id, field_alias, sort_order, value
+      `SELECT entry_id, field_alias, sort_order, value, label
          FROM form_entry_value
         WHERE entry_id IN (${placeholders})
         ORDER BY field_alias, sort_order`,
@@ -176,8 +187,10 @@ export class FormEntryRepository {
       params.push(this.#db.dialect.boolValue(false))
     }
     if (query.search) {
-      where.push(`id IN (SELECT entry_id FROM form_entry_value WHERE LOWER(value) LIKE ?)`)
-      params.push(`%${query.search.toLowerCase()}%`)
+      where.push(
+        `id IN (SELECT entry_id FROM form_entry_value WHERE LOWER(value) LIKE ? OR LOWER(label) LIKE ?)`,
+      )
+      params.push(`%${query.search.toLowerCase()}%`, `%${query.search.toLowerCase()}%`)
     }
     const clause = `WHERE ${where.join(' AND ')}`
 
@@ -242,9 +255,9 @@ export class FormEntryRepository {
       const list = value.values.length === 0 ? [''] : value.values
       for (const [sort, text] of list.entries())
         await this.#db.exec(
-          `INSERT INTO form_entry_value (entry_id, field_alias, sort_order, value)
-           VALUES (?, ?, ?, ?)`,
-          [id, value.fieldAlias, sort, text],
+          `INSERT INTO form_entry_value (entry_id, field_alias, sort_order, value, label)
+           VALUES (?, ?, ?, ?, ?)`,
+          [id, value.fieldAlias, sort, text, value.labels?.[sort] ?? null],
         )
     }
   }
@@ -280,8 +293,16 @@ export class FormEntryRepository {
   async setValues(id: string, values: readonly FormEntryValue[]): Promise<FormEntry | undefined> {
     const existing = await this.byId(id)
     if (!existing) return undefined
+    // An edit sends values only; a label still describes a value left as it was.
+    const before = new Map(existing.values.map((value) => [value.fieldAlias, value]))
+    const kept = values.map((value) => {
+      const old = before.get(value.fieldAlias)
+      if (value.labels || !old?.labels) return value
+      const labels = value.values.map((v) => old.labels?.[old.values.indexOf(v)] ?? v)
+      return { ...value, labels }
+    })
     await this.#db.exec('DELETE FROM form_entry_value WHERE entry_id = ?', [id])
-    await this.#writeValues(id, values)
+    await this.#writeValues(id, kept)
     await this.#db.exec('UPDATE form_entry SET update_date = ? WHERE id = ?', [
       DbDate.toDb(new Date()),
       id,

package/src/repositories/form-workflows.ts

@@ -21,7 +21,7 @@ export interface FormWorkflowRun {
   /** The entry this came from; absent for a form that stores none. */
   entryId: string | null
   /** The submitted values, as the workflow needs them. */
-  payload: { fieldAlias: string; values: string[] }[]
+  payload: { fieldAlias: string; values: string[]; labels?: string[] }[]
   state: FormWorkflowState
   attempts: number
   lastError: string | null

package/src/repositories/members.ts

@@ -300,6 +300,17 @@ export class MemberRepository {
   }
 
   /** Records a successful sign-in, clearing whatever failures came before it. */
+  /**
+   * Replaces an imported hash with argon2id after a successful sign-in. The
+   * password is the same, so the security stamp and change date stand.
+   */
+  async rehashPassword(key: string, passwordHash: string, passwordConfig: string): Promise<void> {
+    await this.#db.exec(
+      'UPDATE member SET password = ?, password_config = ? WHERE node_id = (SELECT id FROM node WHERE unique_id = ?)',
+      [passwordHash, passwordConfig, normaliseUuid(key)],
+    )
+  }
+
   async recordLogin(key: string): Promise<void> {
     const node = await this.#nodes.byKey(key)
     if (!node) return

package/src/repositories/nodes.ts

@@ -284,6 +284,17 @@ export class NodeRepository {
     return { total: Number(totals[0]?.n ?? 0), items: rows.map(mapNode) }
   }
 
+  /** The nodes with these ids, in no particular order; one query. */
+  async byIds(ids: readonly number[]): Promise<NodeRow[]> {
+    if (ids.length === 0) return []
+    const placeholders = ids.map(() => '?').join(', ')
+    const rows = await this.#db.query(
+      `SELECT ${NODE_COLUMNS} FROM node WHERE id IN (${placeholders})`,
+      [...ids],
+    )
+    return rows.map(mapNode)
+  }
+
   /** Ancestors of a node, root first, excluding the node itself. */
   async ancestors(key: string): Promise<NodeRow[]> {
     const node = await this.byKey(key)

package/src/repositories/public-access.ts

@@ -85,6 +85,36 @@ export class PublicAccessRepository {
     }
   }
 
+  /**
+   * Every protected node with who may see it, in two queries: what a request
+   * checking many pages at once reads, rather than an entry per page.
+   */
+  async allRules(): Promise<
+    Array<{ nodeId: number; memberGroupNames: string[]; memberUserNames: string[] }>
+  > {
+    const entries = await this.#db.query<{ id: number; node_id: number }>(
+      'SELECT id, node_id FROM public_access',
+    )
+    if (entries.length === 0) return []
+    const rules = await this.#db.query<{
+      public_access_id: number
+      rule_type: string
+      rule_value: string
+    }>('SELECT public_access_id, rule_type, rule_value FROM public_access_rule')
+    return entries.map((entry) => {
+      const own = rules.filter((r) => Number(r.public_access_id) === Number(entry.id))
+      return {
+        nodeId: Number(entry.node_id),
+        memberGroupNames: own
+          .filter((r) => r.rule_type === MEMBER_GROUP_RULE)
+          .map((r) => r.rule_value),
+        memberUserNames: own
+          .filter((r) => r.rule_type === MEMBER_USERNAME_RULE)
+          .map((r) => r.rule_value),
+      }
+    })
+  }
+
   /** The entry protecting this page itself, if any. */
   async byNodeKey(nodeKey: string): Promise<PublicAccessEntry | undefined> {
     const rows = await this.#db.query<EntryRow>(`${SELECT} WHERE n.unique_id = ?`, [

package/src/repositories/references.ts

@@ -12,6 +12,7 @@
  */
 import { normaliseUuid } from '@crombolo/core'
 import type { Db } from '../database.ts'
+import { RelationRepository } from '../relations.ts'
 
 export interface ReferencingNode {
   key: string
@@ -159,4 +160,18 @@ export class ReferenceRepository {
     )
     return { total: referenced.length, items: referenced.slice(skip, skip + take) }
   }
+
+  /**
+   * What refers to anything of `objectType` in the recycle bin — what the
+   * "empty the bin" dialog warns about — in name order, paged.
+   */
+  async referencingRecycleBin(
+    objectType: string,
+    skip: number,
+    take: number,
+  ): Promise<{ total: number; items: ReferencingNode[] }> {
+    const ids = await new RelationRepository(this.#db).referencingRecycleBin(objectType)
+    const described = await this.#describe(ids)
+    return { total: described.length, items: described.slice(skip, skip + take) }
+  }
 }

package/src/repositories/transfer-answers.ts

@@ -0,0 +1,151 @@
+/**
+ * Pending content imports and the answers given to their conflicts in the
+ * backoffice. The answers are laid over a bundle's `resolutions.json` at import.
+ */
+import type { Db } from '../database.ts'
+import { DbDate, fromDbBool } from '../dialect.ts'
+
+export interface PendingTransfer {
+  bundleId: string
+  label: string | null
+  /** A package name the site depends on, or a directory on this server. */
+  target: string
+  targetKind: 'package' | 'directory'
+  /** Where the check placed the bundle's roots, as given. */
+  under: string | null
+  publish: boolean
+  allowMissingBlobs: boolean
+  checkedAt: Date
+  checkedBy: string | null
+}
+
+export interface TransferAnswer {
+  nodeKey: string
+  /** `"*"` for the whole node, else `alias` or `alias@culture`. */
+  handle: string
+  resolution: string
+  answeredBy: string | null
+  answeredAt: Date
+}
+
+/** Answers as `byNode`, the shape `resolutions.json` and the import take. Pure. */
+export function answersByNode(
+  answers: readonly Pick<TransferAnswer, 'nodeKey' | 'handle' | 'resolution'>[],
+): Record<string, Record<string, string>> {
+  const byNode: Record<string, Record<string, string>> = {}
+  for (const answer of answers)
+    byNode[answer.nodeKey] = {
+      ...(byNode[answer.nodeKey] ?? {}),
+      [answer.handle]: answer.resolution,
+    }
+  return byNode
+}
+
+const pendingFrom = (row: Record<string, unknown>): PendingTransfer => ({
+  bundleId: row.bundle_id as string,
+  label: (row.label as string | null) ?? null,
+  target: row.target as string,
+  targetKind: row.target_kind === 'directory' ? 'directory' : 'package',
+  under: (row.under_target as string | null) ?? null,
+  publish: fromDbBool(row.publish),
+  allowMissingBlobs: fromDbBool(row.allow_missing_blobs),
+  checkedAt: DbDate.fromDb(row.checked_at) ?? new Date(0),
+  checkedBy: (row.checked_by as string | null) ?? null,
+})
+
+export class TransferAnswerRepository {
+  #db: Db
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  /** Records the latest check of a bundle; its answers stand. */
+  async recordCheck(pending: PendingTransfer): Promise<void> {
+    const bool = (value: boolean) => this.#db.dialect.boolValue(value)
+    await this.#db.transaction(async (tx) => {
+      await tx.exec('DELETE FROM transfer_pending WHERE bundle_id = ?', [pending.bundleId])
+      await tx.exec(
+        `INSERT INTO transfer_pending
+           (bundle_id, label, target, target_kind, under_target, publish, allow_missing_blobs, checked_at, checked_by)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          pending.bundleId,
+          pending.label,
+          pending.target,
+          pending.targetKind,
+          pending.under,
+          bool(pending.publish),
+          bool(pending.allowMissingBlobs),
+          DbDate.toDb(pending.checkedAt),
+          pending.checkedBy,
+        ],
+      )
+    })
+  }
+
+  async pending(bundleId: string): Promise<PendingTransfer | undefined> {
+    const rows = await this.#db.query('SELECT * FROM transfer_pending WHERE bundle_id = ?', [
+      bundleId,
+    ])
+    return rows[0] ? pendingFrom(rows[0]) : undefined
+  }
+
+  async allPending(): Promise<PendingTransfer[]> {
+    return (await this.#db.query('SELECT * FROM transfer_pending ORDER BY checked_at DESC')).map(
+      pendingFrom,
+    )
+  }
+
+  async setAllowMissingBlobs(bundleId: string, allow: boolean): Promise<void> {
+    await this.#db.exec('UPDATE transfer_pending SET allow_missing_blobs = ? WHERE bundle_id = ?', [
+      this.#db.dialect.boolValue(allow),
+      bundleId,
+    ])
+  }
+
+  async answers(bundleId: string): Promise<TransferAnswer[]> {
+    const rows = await this.#db.query(
+      'SELECT * FROM transfer_answer WHERE bundle_id = ? ORDER BY node_key, handle',
+      [bundleId],
+    )
+    return rows.map((row) => ({
+      nodeKey: row.node_key as string,
+      handle: row.handle as string,
+      resolution: row.resolution as string,
+      answeredBy: (row.answered_by as string | null) ?? null,
+      answeredAt: DbDate.fromDb(row.answered_at) ?? new Date(0),
+    }))
+  }
+
+  /** Sets one answer, or clears it when `resolution` is null. */
+  async answer(
+    bundleId: string,
+    answer: { nodeKey: string; handle: string; resolution: string | null; by: string | null },
+  ): Promise<void> {
+    await this.#db.transaction(async (tx) => {
+      await tx.exec(
+        'DELETE FROM transfer_answer WHERE bundle_id = ? AND node_key = ? AND handle = ?',
+        [bundleId, answer.nodeKey, answer.handle],
+      )
+      if (answer.resolution === null) return
+      await tx.exec(
+        `INSERT INTO transfer_answer (bundle_id, node_key, handle, resolution, answered_by, answered_at)
+         VALUES (?, ?, ?, ?, ?, ?)`,
+        [
+          bundleId,
+          answer.nodeKey,
+          answer.handle,
+          answer.resolution,
+          answer.by,
+          DbDate.toDb(new Date()),
+        ],
+      )
+    })
+  }
+
+  /** Once the import is applied there is nothing pending, and nothing left to answer. */
+  async clear(bundleId: string): Promise<void> {
+    await this.#db.exec('DELETE FROM transfer_answer WHERE bundle_id = ?', [bundleId])
+    await this.#db.exec('DELETE FROM transfer_pending WHERE bundle_id = ?', [bundleId])
+  }
+}