@crombolo/data 0.0.0-stage → 0.9.1

package/src/repositories/data-types.ts

@@ -0,0 +1,222 @@
+/** Data types: the property editor plus its configuration. */
+import {
+  type DataTypeModel,
+  normaliseUuid,
+  ObjectTypes,
+  type Page,
+  SystemNodes,
+} from '@crombolo/core'
+import type { Db } from '../database.ts'
+import { NodeRepository } from './nodes.ts'
+
+function parseValues(config: unknown): Array<{ alias: string; value: unknown }> {
+  if (typeof config !== 'string' || config.length === 0) return []
+  try {
+    const parsed = JSON.parse(config) as unknown
+    if (Array.isArray(parsed)) return parsed as Array<{ alias: string; value: unknown }>
+    if (parsed && typeof parsed === 'object') {
+      return Object.entries(parsed as Record<string, unknown>).map(([alias, value]) => ({
+        alias,
+        value,
+      }))
+    }
+  } catch {
+    // A malformed configuration should not make the data type unopenable.
+  }
+  return []
+}
+
+export class DataTypeRepository {
+  #db: Db
+  #nodes: NodeRepository
+
+  constructor(db: Db) {
+    this.#db = db
+    this.#nodes = new NodeRepository(db)
+  }
+
+  get nodes(): NodeRepository {
+    return this.#nodes
+  }
+
+  async byKey(key: string): Promise<DataTypeModel | undefined> {
+    const rows = await this.#db.query(
+      `SELECT n.unique_id, n.text, n.parent_id, d.alias, d.editor_alias, d.editor_ui_alias, d.db_type, d.config
+       FROM data_type d JOIN node n ON n.id = d.node_id
+       WHERE n.unique_id = ?`,
+      [normaliseUuid(key)],
+    )
+    const row = rows[0]
+    if (!row) return undefined
+    const parent =
+      Number(row.parent_id) > 0 ? await this.#nodes.byId(Number(row.parent_id)) : undefined
+    return {
+      key: normaliseUuid(String(row.unique_id)),
+      alias: (row.alias as string | null) ?? null,
+      name: String(row.text ?? ''),
+      editorAlias: String(row.editor_alias),
+      editorUiAlias: (row.editor_ui_alias as string | null) ?? null,
+      dbType: String(row.db_type),
+      values: parseValues(row.config),
+      parentKey: parent?.key ?? null,
+    }
+  }
+
+  async byAlias(alias: string): Promise<DataTypeModel | undefined> {
+    const rows = await this.#db.query<{ unique_id: string }>(
+      'SELECT n.unique_id FROM data_type d JOIN node n ON n.id = d.node_id WHERE d.alias = ?',
+      [alias],
+    )
+    return rows[0] ? this.byKey(String(rows[0].unique_id)) : undefined
+  }
+
+  async byKeys(keys: readonly string[]): Promise<DataTypeModel[]> {
+    const found: DataTypeModel[] = []
+    for (const key of keys) {
+      const dataType = await this.byKey(key)
+      if (dataType) found.push(dataType)
+    }
+    return found
+  }
+
+  /** The storage type, which decides which `property_data` column a value uses. */
+  async storageTypeByPropertyTypeId(propertyTypeId: number): Promise<string | undefined> {
+    const rows = await this.#db.query<{ db_type: string }>(
+      `SELECT d.db_type FROM property_type p JOIN data_type d ON d.node_id = p.data_type_id
+       WHERE p.id = ?`,
+      [propertyTypeId],
+    )
+    return rows[0] ? String(rows[0].db_type) : undefined
+  }
+
+  async list(skip: number, take: number): Promise<Page<DataTypeModel>> {
+    const page = await this.#nodes.children(SystemNodes.Root, ObjectTypes.DataType, skip, take)
+    const items: DataTypeModel[] = []
+    for (const node of page.items) {
+      const dataType = await this.byKey(node.key)
+      if (dataType) items.push(dataType)
+    }
+    return { total: page.total, items }
+  }
+
+  async all(): Promise<DataTypeModel[]> {
+    const rows = await this.#db.query<{ unique_id: string }>(
+      'SELECT n.unique_id FROM data_type d JOIN node n ON n.id = d.node_id ORDER BY n.text',
+    )
+    return this.byKeys(rows.map((r) => String(r.unique_id)))
+  }
+
+  /** The editor picker's filter: by name fragment and editor aliases. */
+  async filter(
+    criteria: { name?: string; editorAlias?: string; editorUiAlias?: string },
+    paging: { skip: number; take: number },
+  ): Promise<{ total: number; items: DataTypeModel[] }> {
+    const name = criteria.name?.toLowerCase()
+    const items = (await this.all()).filter(
+      (d) =>
+        (!name || d.name.toLowerCase().includes(name)) &&
+        (!criteria.editorAlias || d.editorAlias === criteria.editorAlias) &&
+        (!criteria.editorUiAlias || d.editorUiAlias === criteria.editorUiAlias),
+    )
+    return { total: items.length, items: items.slice(paging.skip, paging.skip + paging.take) }
+  }
+
+  /** Property types using this data type, with the type each belongs to. */
+  async referencedBy(key: string): Promise<
+    Array<{
+      propertyKey: string
+      alias: string
+      name: string
+      contentType: { key: string; alias: string; name: string; icon: string }
+    }>
+  > {
+    const node = await this.#nodes.byKey(key)
+    if (!node) return []
+    const rows = await this.#db.query(
+      `SELECT p.unique_id, p.alias, p.name, ctn.unique_id AS type_key, ct.alias AS type_alias, ctn.text AS type_name, ct.icon
+       FROM property_type p
+       JOIN content_type ct ON ct.node_id = p.content_type_id
+       JOIN node ctn ON ctn.id = ct.node_id
+       WHERE p.data_type_id = ? AND p.retired_at IS NULL AND ct.retired_at IS NULL
+       ORDER BY ctn.text, p.sort_order`,
+      [node.id],
+    )
+    return rows.map((row) => ({
+      propertyKey: normaliseUuid(String(row.unique_id)),
+      alias: String(row.alias),
+      name: String(row.name),
+      contentType: {
+        key: normaliseUuid(String(row.type_key)),
+        alias: String(row.type_alias),
+        name: String(row.type_name ?? ''),
+        icon: String(row.icon ?? 'icon-document'),
+      },
+    }))
+  }
+
+  async move(key: string, parentKey: string | null): Promise<boolean> {
+    const node = await this.#nodes.byKey(key)
+    if (!node || node.objectType !== ObjectTypes.DataType) return false
+    const parentId = parentKey ? (await this.#nodes.byKey(parentKey))?.id : SystemNodes.Root
+    if (parentId === undefined) return false
+    await this.#nodes.move(node.id, parentId)
+    return true
+  }
+
+  async copy(key: string, parentKey: string | null): Promise<DataTypeModel | undefined> {
+    const source = await this.byKey(key)
+    if (!source) return undefined
+    return this.save({
+      ...source,
+      key: crypto.randomUUID(),
+      alias: null,
+      name: `${source.name} (copy)`,
+      parentKey,
+    })
+  }
+
+  async save(model: DataTypeModel, userId?: number): Promise<DataTypeModel> {
+    return this.#db.transaction(async (tx) => {
+      const repo = new DataTypeRepository(tx)
+      const existing = await repo.nodes.byKey(model.key)
+      const config = JSON.stringify(
+        Object.fromEntries(model.values.map((value) => [value.alias, value.value])),
+      )
+      if (existing) {
+        await repo.nodes.rename(existing.id, model.name)
+        await tx.exec(
+          'UPDATE data_type SET alias = ?, editor_alias = ?, editor_ui_alias = ?, db_type = ?, config = ? WHERE node_id = ?',
+          [model.alias, model.editorAlias, model.editorUiAlias, model.dbType, config, existing.id],
+        )
+      } else {
+        const parentId = model.parentKey
+          ? ((await repo.nodes.byKey(model.parentKey))?.id ?? SystemNodes.Root)
+          : SystemNodes.Root
+        const node = await repo.nodes.create({
+          key: model.key,
+          parentId,
+          objectType: ObjectTypes.DataType,
+          text: model.name,
+          userId,
+        })
+        await tx.exec(
+          'INSERT INTO data_type (node_id, alias, editor_alias, editor_ui_alias, db_type, config) VALUES (?, ?, ?, ?, ?, ?)',
+          [node.id, model.alias, model.editorAlias, model.editorUiAlias, model.dbType, config],
+        )
+      }
+      const saved = await repo.byKey(model.key)
+      if (!saved) throw new Error('Data type could not be read back after saving.')
+      return saved
+    })
+  }
+
+  async delete(key: string): Promise<boolean> {
+    const node = await this.#nodes.byKey(key)
+    if (!node || node.objectType !== ObjectTypes.DataType) return false
+    return this.#db.transaction(async (tx) => {
+      await tx.exec('DELETE FROM data_type WHERE node_id = ?', [node.id])
+      await tx.exec('DELETE FROM node WHERE id = ?', [node.id])
+      return true
+    })
+  }
+}

package/src/repositories/dictionary.ts

@@ -0,0 +1,259 @@
+/** Dictionary items: a tree of keys, each with a translation per language. */
+import { normaliseUuid } from '@crombolo/core'
+import type { Db } from '../database.ts'
+
+export interface DictionaryTranslation {
+  isoCode: string
+  translation: string
+}
+
+export interface DictionaryItem {
+  key: string
+  name: string
+  parentKey: string | null
+  translations: DictionaryTranslation[]
+}
+
+export type DictionaryWriteResult =
+  | 'Success'
+  | 'DuplicateItemKey'
+  | 'DuplicateKey'
+  | 'ParentNotFound'
+  | 'NotFound'
+  | 'InvalidParent'
+  | 'InvalidLanguage'
+
+interface Row {
+  key: string
+  item_key: string
+  parent_key: string | null
+}
+
+export class DictionaryRepository {
+  #db: Db
+
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  async #rows(where = '', params: unknown[] = []): Promise<Row[]> {
+    return this.#db.query<Row>(
+      `SELECT key, item_key, parent_key FROM dictionary_item ${where} ORDER BY item_key`,
+      params,
+    )
+  }
+
+  async #withTranslations(rows: Row[]): Promise<DictionaryItem[]> {
+    if (rows.length === 0) return []
+    const keys = rows.map((r) => normaliseUuid(String(r.key)))
+    const texts = await this.#db.query<{ dictionary_key: string; iso_code: string; value: string }>(
+      `SELECT t.dictionary_key, l.iso_code, t.value FROM dictionary_text t
+       JOIN language l ON l.id = t.language_id
+       WHERE t.dictionary_key IN (${keys.map(() => '?').join(', ')})
+       ORDER BY l.iso_code`,
+      keys,
+    )
+    return rows.map((row) => {
+      const key = normaliseUuid(String(row.key))
+      return {
+        key,
+        name: String(row.item_key),
+        parentKey: row.parent_key ? normaliseUuid(String(row.parent_key)) : null,
+        translations: texts
+          .filter((t) => normaliseUuid(String(t.dictionary_key)) === key)
+          .map((t) => ({ isoCode: String(t.iso_code), translation: String(t.value) })),
+      }
+    })
+  }
+
+  async get(key: string): Promise<DictionaryItem | undefined> {
+    return (
+      await this.#withTranslations(await this.#rows('WHERE key = ?', [normaliseUuid(key)]))
+    )[0]
+  }
+
+  async byName(name: string): Promise<DictionaryItem | undefined> {
+    return (await this.#withTranslations(await this.#rows('WHERE item_key = ?', [name])))[0]
+  }
+
+  async many(keys: readonly string[]): Promise<DictionaryItem[]> {
+    const wanted = keys.filter((k) => /^[0-9a-f-]{32,36}$/i.test(k)).map(normaliseUuid)
+    if (wanted.length === 0) return []
+    return this.#withTranslations(
+      await this.#rows(`WHERE key IN (${wanted.map(() => '?').join(', ')})`, wanted),
+    )
+  }
+
+  /** Every item, or those whose key contains `filter`, in tree order by key. */
+  async all(filter?: string): Promise<DictionaryItem[]> {
+    const rows = filter
+      ? await this.#rows('WHERE LOWER(item_key) LIKE ?', [`%${filter.toLowerCase()}%`])
+      : await this.#rows()
+    return this.#withTranslations(rows)
+  }
+
+  async children(
+    parentKey: string | null,
+  ): Promise<Array<{ key: string; name: string; parentKey: string | null; hasChildren: boolean }>> {
+    const rows = parentKey
+      ? await this.#rows('WHERE parent_key = ?', [normaliseUuid(parentKey)])
+      : await this.#rows('WHERE parent_key IS NULL')
+    const parents = new Set(
+      (
+        await this.#db.query<{ parent_key: string }>(
+          'SELECT DISTINCT parent_key FROM dictionary_item WHERE parent_key IS NOT NULL',
+        )
+      ).map((r) => normaliseUuid(String(r.parent_key))),
+    )
+    return rows.map((row) => {
+      const key = normaliseUuid(String(row.key))
+      return {
+        key,
+        name: String(row.item_key),
+        parentKey: row.parent_key ? normaliseUuid(String(row.parent_key)) : null,
+        hasChildren: parents.has(key),
+      }
+    })
+  }
+
+  /** The item and its ancestors, root first. */
+  async ancestry(key: string): Promise<DictionaryItem[]> {
+    const chain: DictionaryItem[] = []
+    let current = await this.get(key)
+    while (current) {
+      chain.unshift(current)
+      current = current.parentKey ? await this.get(current.parentKey) : undefined
+    }
+    return chain
+  }
+
+  async #descendantKeys(key: string): Promise<string[]> {
+    const out: string[] = []
+    const queue = [normaliseUuid(key)]
+    while (queue.length > 0) {
+      const next = queue.shift() as string
+      for (const child of await this.#rows('WHERE parent_key = ?', [next])) {
+        const childKey = normaliseUuid(String(child.key))
+        out.push(childKey)
+        queue.push(childKey)
+      }
+    }
+    return out
+  }
+
+  async #languageIds(
+    translations: readonly DictionaryTranslation[],
+  ): Promise<Map<string, number> | undefined> {
+    const languages = await this.#db.query<{ id: number; iso_code: string }>(
+      'SELECT id, iso_code FROM language',
+    )
+    const byIso = new Map(languages.map((l) => [String(l.iso_code).toLowerCase(), Number(l.id)]))
+    const ids = new Map<string, number>()
+    for (const t of translations) {
+      const id = byIso.get(t.isoCode.toLowerCase())
+      if (id === undefined) return undefined
+      ids.set(t.isoCode, id)
+    }
+    return ids
+  }
+
+  async #writeTranslations(
+    key: string,
+    translations: readonly DictionaryTranslation[],
+    ids: Map<string, number>,
+  ): Promise<void> {
+    await this.#db.exec('DELETE FROM dictionary_text WHERE dictionary_key = ?', [key])
+    for (const t of translations)
+      await this.#db.exec(
+        'INSERT INTO dictionary_text (dictionary_key, language_id, value) VALUES (?, ?, ?)',
+        [key, ids.get(t.isoCode), t.translation],
+      )
+  }
+
+  async create(item: DictionaryItem): Promise<DictionaryWriteResult> {
+    const key = normaliseUuid(item.key)
+    return this.#db.transaction(async (tx) => {
+      const repo = new DictionaryRepository(tx)
+      if (await repo.get(key)) return 'DuplicateKey'
+      if (await repo.byName(item.name)) return 'DuplicateItemKey'
+      if (item.parentKey && !(await repo.get(item.parentKey))) return 'ParentNotFound'
+      const ids = await repo.#languageIds(item.translations)
+      if (!ids) return 'InvalidLanguage'
+      await tx.exec('INSERT INTO dictionary_item (key, parent_key, item_key) VALUES (?, ?, ?)', [
+        key,
+        item.parentKey ? normaliseUuid(item.parentKey) : null,
+        item.name,
+      ])
+      await repo.#writeTranslations(key, item.translations, ids)
+      return 'Success'
+    })
+  }
+
+  async update(
+    key: string,
+    change: { name: string; translations: readonly DictionaryTranslation[] },
+  ): Promise<DictionaryWriteResult> {
+    const k = normaliseUuid(key)
+    return this.#db.transaction(async (tx) => {
+      const repo = new DictionaryRepository(tx)
+      if (!(await repo.get(k))) return 'NotFound'
+      const clash = await repo.byName(change.name)
+      if (clash && clash.key !== k) return 'DuplicateItemKey'
+      const ids = await repo.#languageIds(change.translations)
+      if (!ids) return 'InvalidLanguage'
+      await tx.exec('UPDATE dictionary_item SET item_key = ? WHERE key = ?', [change.name, k])
+      await repo.#writeTranslations(k, change.translations, ids)
+      return 'Success'
+    })
+  }
+
+  async move(key: string, parentKey: string | null): Promise<DictionaryWriteResult> {
+    const k = normaliseUuid(key)
+    return this.#db.transaction(async (tx) => {
+      const repo = new DictionaryRepository(tx)
+      if (!(await repo.get(k))) return 'NotFound'
+      if (parentKey) {
+        const parent = normaliseUuid(parentKey)
+        if (!(await repo.get(parent))) return 'ParentNotFound'
+        if (parent === k || (await repo.#descendantKeys(k)).includes(parent)) return 'InvalidParent'
+      }
+      await tx.exec('UPDATE dictionary_item SET parent_key = ? WHERE key = ?', [
+        parentKey ? normaliseUuid(parentKey) : null,
+        k,
+      ])
+      return 'Success'
+    })
+  }
+
+  /** Deletes the item and everything below it. */
+  async delete(key: string): Promise<DictionaryWriteResult> {
+    const k = normaliseUuid(key)
+    return this.#db.transaction(async (tx) => {
+      const repo = new DictionaryRepository(tx)
+      if (!(await repo.get(k))) return 'NotFound'
+      const doomed = [...(await repo.#descendantKeys(k)).reverse(), k]
+      for (const d of doomed) {
+        await tx.exec('DELETE FROM dictionary_text WHERE dictionary_key = ?', [d])
+        await tx.exec('DELETE FROM dictionary_item WHERE key = ?', [d])
+      }
+      return 'Success'
+    })
+  }
+
+  /** Every translation, keyed by item name then iso code, for rendering. */
+  async translations(): Promise<Map<string, Map<string, string>>> {
+    const rows = await this.#db.query<{ item_key: string; iso_code: string; value: string }>(
+      `SELECT d.item_key, l.iso_code, t.value FROM dictionary_item d
+       JOIN dictionary_text t ON t.dictionary_key = d.key
+       JOIN language l ON l.id = t.language_id`,
+    )
+    const out = new Map<string, Map<string, string>>()
+    for (const row of rows) {
+      const name = String(row.item_key)
+      const entry = out.get(name) ?? new Map<string, string>()
+      entry.set(String(row.iso_code), String(row.value))
+      out.set(name, entry)
+    }
+    return out
+  }
+}