@crombolo/data 0.0.0-stage → 0.9.1

package/src/repositories/redirects.ts

@@ -0,0 +1,274 @@
+/**
+ * Redirects: the routes a page used to answer on, and the rules a site declares.
+ *
+ * Tracking writes a rule per route a publish or a move retired; the site's own
+ * `redirects` config is synced into the same table so the backoffice can list
+ * everything in force, and those rows are marked `config` and refuse to be
+ * deleted through the API — the file owns them. A rule an administrator wrote in
+ * the backoffice is `manual`, and is the only kind this repository will let a
+ * bundle touch (`server/src/bundles.ts`).
+ *
+ * A rule is identified by what it matches (kind, pattern, hostname root and
+ * culture), so re-registering a route replaces where it points instead of
+ * stacking another row behind it, which is how Umbraco's "most recent wins"
+ * ends up behaving without the duplicates.
+ */
+import { normaliseUuid } from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { DbDate } from '../dialect.ts'
+
+export type RedirectMatchKind = 'exact' | 'prefix' | 'regex'
+export type RedirectTargetKind = 'document' | 'path' | 'url'
+/**
+ * Where a rule came from, and — because `ORDER` sorts on this column — its
+ * precedence: `config` before `manual` before `tracked`, which is alphabetical
+ * and so needs no CASE expression. That order is the intent, not a coincidence:
+ * a rule in the site's code outranks one an administrator typed, which outranks
+ * one a rename recorded by itself.
+ */
+export type RedirectSource = 'tracked' | 'config' | 'manual'
+
+export interface RedirectRow {
+  key: string
+  source: RedirectSource
+  matchKind: RedirectMatchKind
+  pattern: string
+  rootKey: string | null
+  culture: string | null
+  targetKind: RedirectTargetKind
+  target: string
+  statusCode: number
+  sortOrder: number
+  createDate: Date
+}
+
+/** A rule to store; `key` and `createDate` are assigned when it is new. */
+export type RedirectInput = Omit<RedirectRow, 'key' | 'createDate'>
+
+interface Row {
+  key: string
+  source: string
+  match_kind: string
+  pattern: string
+  root_key: string | null
+  culture: string | null
+  target_kind: string
+  target: string
+  status_code: number
+  sort_order: number
+  create_date: unknown
+}
+
+const SELECT = `SELECT key, source, match_kind, pattern, root_key, culture,
+                       target_kind, target, status_code, sort_order, create_date
+                  FROM redirect_url`
+
+/** By source — see `RedirectSource` — then by the rule's own order, newest first. */
+const ORDER = 'ORDER BY source, sort_order, create_date DESC, id DESC'
+
+const hydrate = (row: Row): RedirectRow => ({
+  key: normaliseUuid(String(row.key)),
+  source: String(row.source) as RedirectSource,
+  matchKind: String(row.match_kind) as RedirectMatchKind,
+  pattern: String(row.pattern),
+  rootKey: row.root_key === null ? null : String(row.root_key),
+  culture: row.culture === null ? null : String(row.culture),
+  targetKind: String(row.target_kind) as RedirectTargetKind,
+  target: String(row.target),
+  statusCode: Number(row.status_code),
+  sortOrder: Number(row.sort_order),
+  createDate: DbDate.fromDb(row.create_date) ?? new Date(0),
+})
+
+/** A digest of everything a rule matches on; see migration 015. */
+export function matchHash(input: {
+  source: RedirectSource
+  matchKind: RedirectMatchKind
+  pattern: string
+  rootKey: string | null
+  culture: string | null
+}): string {
+  const parts = [
+    input.source,
+    input.matchKind,
+    input.pattern,
+    input.rootKey ?? '',
+    (input.culture ?? '').toLowerCase(),
+  ]
+  return new Bun.CryptoHasher('sha256').update(parts.join('\u0000')).digest('hex')
+}
+
+export class RedirectRepository {
+  #db: Db
+
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  /** Every rule, in the order they are matched. */
+  async all(): Promise<RedirectRow[]> {
+    const rows = await this.#db.query<Row>(`${SELECT} ${ORDER}`)
+    return rows.map(hydrate)
+  }
+
+  async byKey(key: string): Promise<RedirectRow | undefined> {
+    const rows = await this.#db.query<Row>(`${SELECT} WHERE key = ?`, [normaliseUuid(key)])
+    return rows[0] ? hydrate(rows[0]) : undefined
+  }
+
+  /**
+   * A page of rules, newest first, optionally filtered on either URL. Umbraco's
+   * dashboard searches the original URL; matching the destination too costs
+   * nothing and is what someone auditing "where does this page get traffic
+   * from" actually wants.
+   */
+  async list(options: { filter?: string; skip?: number; take?: number } = {}): Promise<{
+    total: number
+    items: RedirectRow[]
+  }> {
+    const filter = options.filter?.trim().toLowerCase()
+    const where = filter ? 'WHERE LOWER(pattern) LIKE ? OR LOWER(target) LIKE ?' : ''
+    const params = filter ? [`%${filter}%`, `%${filter}%`] : []
+    const counted = await this.#db.query<{ total: number }>(
+      `SELECT COUNT(*) AS total FROM redirect_url ${where}`,
+      params,
+    )
+    const rows = await this.#db.query<Row>(`${SELECT} ${where} ${ORDER} LIMIT ? OFFSET ?`, [
+      ...params,
+      options.take ?? 100,
+      options.skip ?? 0,
+    ])
+    return { total: Number(counted[0]?.total ?? 0), items: rows.map(hydrate) }
+  }
+
+  /** The rules pointing at one document, newest first. */
+  async byDocument(
+    documentKey: string,
+    options: { skip?: number; take?: number } = {},
+  ): Promise<{ total: number; items: RedirectRow[] }> {
+    const target = normaliseUuid(documentKey)
+    const where = "WHERE target_kind = 'document' AND LOWER(target) = ?"
+    const counted = await this.#db.query<{ total: number }>(
+      `SELECT COUNT(*) AS total FROM redirect_url ${where}`,
+      [target],
+    )
+    const rows = await this.#db.query<Row>(`${SELECT} ${where} ${ORDER} LIMIT ? OFFSET ?`, [
+      target,
+      options.take ?? 100,
+      options.skip ?? 0,
+    ])
+    return { total: Number(counted[0]?.total ?? 0), items: rows.map(hydrate) }
+  }
+
+  /**
+   * Stores a rule, replacing any existing one matching the same thing. The
+   * returned row carries the key, which is a fresh one only when the rule is new.
+   */
+  async save(input: RedirectInput): Promise<RedirectRow> {
+    const hash = matchHash(input)
+    const now = new Date()
+    return this.#db.transaction(async (tx) => {
+      const existing = await tx.query<{ key: string }>(
+        'SELECT key FROM redirect_url WHERE match_hash = ?',
+        [hash],
+      )
+      if (existing[0]) {
+        const key = normaliseUuid(String(existing[0].key))
+        await tx.exec(
+          `UPDATE redirect_url
+              SET target_kind = ?, target = ?, status_code = ?, sort_order = ?, create_date = ?
+            WHERE key = ?`,
+          [
+            input.targetKind,
+            input.target,
+            input.statusCode,
+            input.sortOrder,
+            DbDate.toDb(now),
+            key,
+          ],
+        )
+        return { ...input, key, createDate: now }
+      }
+      const key = crypto.randomUUID()
+      await tx.exec(
+        `INSERT INTO redirect_url
+           (key, source, match_kind, pattern, root_key, culture,
+            target_kind, target, status_code, sort_order, match_hash, create_date)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+        [
+          key,
+          input.source,
+          input.matchKind,
+          input.pattern,
+          input.rootKey,
+          input.culture,
+          input.targetKind,
+          input.target,
+          input.statusCode,
+          input.sortOrder,
+          hash,
+          DbDate.toDb(now),
+        ],
+      )
+      return { ...input, key, createDate: now }
+    })
+  }
+
+  /** Deletes one rule. `false` means there was nothing with that key. */
+  async delete(key: string): Promise<boolean> {
+    const found = await this.byKey(key)
+    if (!found) return false
+    await this.#db.exec('DELETE FROM redirect_url WHERE key = ?', [normaliseUuid(key)])
+    return true
+  }
+
+  /**
+   * Drops any rule that matches `path` under `rootKey` and points at this
+   * document — the case where a page was renamed and then renamed back, which
+   * would otherwise leave a rule redirecting a live URL to itself.
+   */
+  async removeSelfReferencing(
+    documentKey: string,
+    rootKey: string | null,
+    path: string,
+  ): Promise<void> {
+    await this.#db.exec(
+      `DELETE FROM redirect_url
+        WHERE source = 'tracked' AND target_kind = 'document'
+          AND LOWER(target) = ? AND match_kind = 'exact' AND LOWER(pattern) = ?
+          AND ${rootKey === null ? 'root_key IS NULL' : 'root_key = ?'}`,
+      rootKey === null
+        ? [normaliseUuid(documentKey), path.toLowerCase()]
+        : [normaliseUuid(documentKey), path.toLowerCase(), rootKey],
+    )
+  }
+
+  /**
+   * Brings the `config` rows into line with the site's configuration: the ones
+   * it still declares are stored in order, and any left over from a previous
+   * boot are removed. Tracked rows are untouched.
+   */
+  async syncConfigured(inputs: readonly Omit<RedirectInput, 'source' | 'sortOrder'>[]): Promise<{
+    stored: number
+    removed: number
+  }> {
+    const kept = new Set<string>()
+    let sortOrder = 0
+    for (const input of inputs) {
+      const rule: RedirectInput = { ...input, source: 'config', sortOrder: sortOrder++ }
+      kept.add(matchHash(rule))
+      await this.save(rule)
+    }
+    const stale = await this.#db.query<{ match_hash: string }>(
+      "SELECT match_hash FROM redirect_url WHERE source = 'config'",
+    )
+    let removed = 0
+    for (const row of stale) {
+      const hash = String(row.match_hash)
+      if (kept.has(hash)) continue
+      await this.#db.exec('DELETE FROM redirect_url WHERE match_hash = ?', [hash])
+      removed += 1
+    }
+    return { stored: kept.size, removed }
+  }
+}

package/src/repositories/references.ts

@@ -0,0 +1,162 @@
+/**
+ * What refers to what, derived from the values themselves.
+ *
+ * Umbraco keeps a `umbracoRelation` row per reference, written when content is
+ * saved. Deriving the answer from the current property values instead cannot go
+ * stale — a relation table is only as good as the last save that maintained it —
+ * and needs no migration. The cost is a scan of `property_value`, which is
+ * acceptable for an editor asking "what breaks if I delete this?".
+ *
+ * A picker stores its target as `umb://document/<hex>` or a bare uuid, so both
+ * spellings are matched.
+ */
+import { normaliseUuid } from '@crombolo/core'
+import type { Db } from '../database.ts'
+
+export interface ReferencingNode {
+  key: string
+  name: string | null
+  objectType: string | null
+  published: boolean | null
+  contentTypeKey: string | null
+  contentTypeAlias: string | null
+  contentTypeIcon: string | null
+}
+
+/** The two spellings a key appears in inside a stored value. */
+function patterns(key: string): [string, string] {
+  const dashed = normaliseUuid(key)
+  return [`%${dashed}%`, `%${dashed.replaceAll('-', '')}%`]
+}
+
+export class ReferenceRepository {
+  #db: Db
+
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  /** Node ids whose current values mention any of `keys`, excluding `keys` themselves. */
+  async #referencingIds(keys: readonly string[]): Promise<Map<string, number[]>> {
+    const found = new Map<string, number[]>()
+    for (const key of keys) {
+      const [dashed, plain] = patterns(key)
+      const rows = await this.#db.query<{ id: number }>(
+        `SELECT DISTINCT pv.node_id AS id
+           FROM property_value pv
+          WHERE pv.is_current = ?
+            AND ( LOWER(pv.varchar_value) LIKE ? OR LOWER(pv.text_value) LIKE ?
+               OR LOWER(pv.varchar_value) LIKE ? OR LOWER(pv.text_value) LIKE ? )`,
+        [this.#db.dialect.boolValue(true), dashed, dashed, plain, plain],
+      )
+      found.set(
+        normaliseUuid(key),
+        rows.map((row) => Number(row.id)),
+      )
+    }
+    return found
+  }
+
+  async #describe(ids: readonly number[]): Promise<ReferencingNode[]> {
+    if (ids.length === 0) return []
+    const holes = ids.map(() => '?').join(', ')
+    const rows = await this.#db.query<{
+      unique_id: string
+      text: string | null
+      node_object_type: string | null
+      published: unknown
+      type_key: string | null
+      type_alias: string | null
+      type_icon: string | null
+    }>(
+      `SELECT n.unique_id, n.text, n.node_object_type,
+              d.published AS published,
+              tn.unique_id AS type_key, ct.alias AS type_alias, ct.icon AS type_icon
+         FROM node n
+         LEFT JOIN content c ON c.node_id = n.id
+         LEFT JOIN content_type ct ON ct.node_id = c.content_type_id
+         LEFT JOIN node tn ON tn.id = ct.node_id
+         LEFT JOIN document d ON d.node_id = n.id
+        WHERE n.id IN (${holes})
+        ORDER BY n.text`,
+      [...ids],
+    )
+    return rows.map((row) => ({
+      key: String(row.unique_id),
+      name: row.text,
+      objectType: row.node_object_type,
+      published: row.published === null || row.published === undefined ? null : !!row.published,
+      contentTypeKey: row.type_key ? String(row.type_key) : null,
+      contentTypeAlias: row.type_alias,
+      contentTypeIcon: row.type_icon,
+    }))
+  }
+
+  /** What refers to this one, newest name order, paged. */
+  async referencedBy(
+    key: string,
+    skip: number,
+    take: number,
+  ): Promise<{ total: number; items: ReferencingNode[] }> {
+    const self = await this.#db.query<{ id: number }>('SELECT id FROM node WHERE unique_id = ?', [
+      normaliseUuid(key),
+    ])
+    const selfId = self[0]?.id
+    const ids = (await this.#referencingIds([key])).get(normaliseUuid(key)) ?? []
+    const others = ids.filter((id) => id !== Number(selfId))
+    return { total: others.length, items: await this.#describe(others.slice(skip, skip + take)) }
+  }
+
+  /**
+   * Descendants of this node that something else refers to — what an editor
+   * needs before deleting a branch.
+   */
+  async referencedDescendants(
+    key: string,
+    skip: number,
+    take: number,
+  ): Promise<{ total: number; items: string[] }> {
+    const self = await this.#db.query<{ id: number; path: string }>(
+      'SELECT id, path FROM node WHERE unique_id = ?',
+      [normaliseUuid(key)],
+    )
+    const node = self[0]
+    if (!node) return { total: 0, items: [] }
+    const descendants = await this.#db.query<{ id: number; unique_id: string }>(
+      'SELECT id, unique_id FROM node WHERE path LIKE ? AND id <> ?',
+      [`${node.path},%`, node.id],
+    )
+    const referenced: string[] = []
+    for (const descendant of descendants) {
+      const ids = (await this.#referencingIds([String(descendant.unique_id)])).values().next()
+        .value as number[] | undefined
+      // A reference from inside the branch being deleted does not count.
+      const outside = (ids ?? []).filter(
+        (id) => !descendants.some((d) => Number(d.id) === id) && id !== Number(node.id),
+      )
+      if (outside.length > 0) referenced.push(String(descendant.unique_id))
+    }
+    return { total: referenced.length, items: referenced.slice(skip, skip + take) }
+  }
+
+  /** Of these keys, the ones something refers to. */
+  async areReferenced(
+    keys: readonly string[],
+    skip: number,
+    take: number,
+  ): Promise<{ total: number; items: string[] }> {
+    const wanted = keys.map(normaliseUuid)
+    const found = await this.#referencingIds(wanted)
+    const selfIds = new Map<string, number>()
+    for (const key of wanted) {
+      const rows = await this.#db.query<{ id: number }>('SELECT id FROM node WHERE unique_id = ?', [
+        key,
+      ])
+      if (rows[0]) selfIds.set(key, Number(rows[0].id))
+    }
+    const referenced = wanted.filter((key) =>
+      (found.get(key) ?? []).some((id) => id !== selfIds.get(key)),
+    )
+    return { total: referenced.length, items: referenced.slice(skip, skip + take) }
+  }
+}

package/src/repositories/tags.ts

@@ -0,0 +1,93 @@
+/**
+ * Tags, read from the current values of Tags properties rather than kept in a
+ * table of their own: what the tags editor's suggestions and `GET /tag` list.
+ * A tag's group comes from its data type's configuration, as in Umbraco.
+ */
+import { createHash } from 'node:crypto'
+import type { Db } from '../database.ts'
+
+export interface TagRow {
+  id: string
+  text: string
+  group: string
+  culture: string | null
+  nodeCount: number
+}
+
+/** A stable id for a tag: Umbraco's are rows; these are derived from what identifies one. */
+function tagId(group: string, text: string, culture: string | null): string {
+  const hex = createHash('sha1')
+    .update(`${group}\u0000${text}\u0000${culture ?? ''}`)
+    .digest('hex')
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-5${hex.slice(13, 16)}-${((Number.parseInt(hex.slice(16, 17), 16) & 0x3) | 0x8).toString(16)}${hex.slice(17, 20)}-${hex.slice(20, 32)}`
+}
+
+function parseTags(raw: unknown): string[] {
+  if (typeof raw !== 'string' || raw.trim() === '') return []
+  try {
+    const parsed = JSON.parse(raw)
+    if (Array.isArray(parsed)) return parsed.map(String)
+  } catch {
+    // CSV storage
+  }
+  return raw.split(',')
+}
+
+export class TagRepository {
+  #db: Db
+
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  async all(
+    filter: { query?: string; group?: string; culture?: string | null } = {},
+  ): Promise<TagRow[]> {
+    const rows = await this.#db.query(
+      `SELECT pv.node_id, pv.text_value, pv.varchar_value, d.config, l.iso_code
+       FROM property_value pv
+       JOIN property_type p ON p.id = pv.property_type_id
+       JOIN data_type d ON d.node_id = p.data_type_id
+       JOIN node n ON n.id = pv.node_id
+       LEFT JOIN language l ON l.id = pv.language_id
+       WHERE pv.is_current = ? AND d.editor_alias = ? AND n.trashed = ?`,
+      [this.#db.dialect.boolValue(true), 'Umbraco.Tags', this.#db.dialect.boolValue(false)],
+    )
+    const tags = new Map<string, TagRow & { nodes: Set<number> }>()
+    for (const row of rows) {
+      let group = 'default'
+      try {
+        const config = JSON.parse(String(row.config ?? '{}')) as Record<string, unknown>
+        if (typeof config.group === 'string' && config.group) group = config.group
+      } catch {
+        // an unreadable configuration keeps the default group
+      }
+      const culture = (row.iso_code as string | null) ?? null
+      for (const raw of parseTags(row.text_value ?? row.varchar_value)) {
+        const text = raw.trim()
+        if (!text) continue
+        const id = tagId(group, text.toLowerCase(), culture)
+        const tag = tags.get(id) ?? {
+          id,
+          text,
+          group,
+          culture,
+          nodeCount: 0,
+          nodes: new Set<number>(),
+        }
+        tag.nodes.add(Number(row.node_id))
+        tag.nodeCount = tag.nodes.size
+        tags.set(id, tag)
+      }
+    }
+    const query = filter.query?.trim().toLowerCase()
+    return [...tags.values()]
+      .filter((t) => !query || t.text.toLowerCase().includes(query))
+      .filter((t) => !filter.group || t.group === filter.group)
+      .filter(
+        (t) => filter.culture === undefined || (t.culture ?? null) === (filter.culture ?? null),
+      )
+      .map(({ nodes: _nodes, ...tag }) => tag)
+      .sort((a, b) => a.text.localeCompare(b.text))
+  }
+}

package/src/repositories/templates.ts

@@ -0,0 +1,114 @@
+/**
+ * Templates. The database row carries the alias and the tree placement; the view
+ * file lives on disk, and the file system is the source of truth for its content.
+ */
+import {
+  type ComponentModel,
+  normaliseUuid,
+  ObjectTypes,
+  type Page,
+  SystemNodes,
+} from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { NodeRepository } from './nodes.ts'
+
+export interface ComponentFileStore {
+  read(alias: string): Promise<string | undefined>
+  write(alias: string, content: string): Promise<void>
+  remove(alias: string): Promise<void>
+}
+
+export class ComponentRepository {
+  #db: Db
+  #nodes: NodeRepository
+  #files: ComponentFileStore | undefined
+
+  constructor(db: Db, files?: ComponentFileStore) {
+    this.#db = db
+    this.#nodes = new NodeRepository(db)
+    this.#files = files
+  }
+
+  get nodes(): NodeRepository {
+    return this.#nodes
+  }
+
+  async byKey(key: string): Promise<ComponentModel | undefined> {
+    const rows = await this.#db.query(
+      `SELECT n.unique_id, n.text, t.alias FROM template t
+       JOIN node n ON n.id = t.node_id WHERE n.unique_id = ?`,
+      [normaliseUuid(key)],
+    )
+    const row = rows[0]
+    if (!row) return undefined
+    const alias = String(row.alias)
+    return {
+      key: normaliseUuid(String(row.unique_id)),
+      name: String(row.text ?? ''),
+      alias,
+      content: (await this.#files?.read(alias)) ?? null,
+    }
+  }
+
+  async byAlias(alias: string): Promise<ComponentModel | undefined> {
+    const rows = await this.#db.query<{ unique_id: string }>(
+      'SELECT n.unique_id FROM template t JOIN node n ON n.id = t.node_id WHERE t.alias = ?',
+      [alias],
+    )
+    return rows[0] ? this.byKey(String(rows[0].unique_id)) : undefined
+  }
+
+  async all(): Promise<ComponentModel[]> {
+    return (await this.list(0, 10_000)).items
+  }
+
+  async list(skip: number, take: number): Promise<Page<ComponentModel>> {
+    const page = await this.#nodes.children(SystemNodes.Root, ObjectTypes.Template, skip, take)
+    const items: ComponentModel[] = []
+    for (const node of page.items) {
+      const template = await this.byKey(node.key)
+      if (template) items.push(template)
+    }
+    return { total: page.total, items }
+  }
+
+  async save(model: ComponentModel, userId?: number): Promise<ComponentModel> {
+    const saved = await this.#db.transaction(async (tx) => {
+      const repo = new ComponentRepository(tx, this.#files)
+      const existing = await repo.nodes.byKey(model.key)
+      if (existing) {
+        await repo.nodes.rename(existing.id, model.name)
+        await tx.exec('UPDATE template SET alias = ? WHERE node_id = ?', [model.alias, existing.id])
+      } else {
+        const node = await repo.nodes.create({
+          key: model.key,
+          parentId: SystemNodes.Root,
+          objectType: ObjectTypes.Template,
+          text: model.name,
+          userId,
+        })
+        await tx.exec('INSERT INTO template (node_id, alias) VALUES (?, ?)', [node.id, model.alias])
+      }
+      return model
+    })
+    if (model.content !== null && model.content !== undefined) {
+      await this.#files?.write(model.alias, model.content)
+    }
+    const result = await this.byKey(saved.key)
+    if (!result) throw new Error('Template could not be read back after saving.')
+    return result
+  }
+
+  async delete(key: string): Promise<boolean> {
+    const template = await this.byKey(key)
+    const node = await this.#nodes.byKey(key)
+    if (!template || !node) return false
+    await this.#db.transaction(async (tx) => {
+      await tx.exec('DELETE FROM content_type_template WHERE template_node_id = ?', [node.id])
+      await tx.exec('DELETE FROM template WHERE node_id = ?', [node.id])
+      await tx.exec('DELETE FROM node WHERE id = ?', [node.id])
+    })
+    await this.#files?.remove(template.alias)
+    return true
+  }
+}