@crombolo/data 0.10.0 → 0.12.1

package/src/repositories/content-types.ts

@@ -27,10 +27,26 @@ import type { Db } from '../database.ts'
 import { DbDate, fromDbBool } from '../dialect.ts'
 import { pendingUntil } from '../pending.ts'
 import type { NodeSchemaState } from '../schema-state.ts'
+import { queueContentTypesForSearch, queueEverythingForSearch } from '../search.ts'
 import { NodeRepository } from './nodes.ts'
 
 const GROUP_TYPE_NAMES = ['Group', 'Tab'] as const
 
+/** The live properties of a type, by alias, variation and storage: what its items are indexed by. */
+async function propertySignature(db: Db, contentTypeNodeId: number): Promise<string> {
+  const rows = await db.query<Record<string, unknown>>(
+    `SELECT p.id, p.alias, p.variations, p.data_type_id, p.searchable FROM property_type p
+     WHERE p.content_type_id = ? AND p.retired_at IS NULL ORDER BY p.id`,
+    [contentTypeNodeId],
+  )
+  return rows
+    .map(
+      (row) =>
+        `${row.id}:${row.alias}:${row.variations}:${row.data_type_id}:${fromDbBool(row.searchable)}`,
+    )
+    .join('|')
+}
+
 export interface SaveContentTypeOptions {
   userId?: number
   /** The schema state that introduced anything created by this save. */
@@ -228,6 +244,9 @@ export class ContentTypeRepository {
         ? ((await repo.nodes.byKey(aggregate.parentKey))?.id ?? SystemNodes.Root)
         : SystemNodes.Root
 
+      // What the search index holds depends on which properties are live and what
+      // they are called, so a change to either has the type's items re-indexed.
+      const propertiesBefore = existing ? await propertySignature(tx, existing.id) : ''
       let nodeId: number
       if (existing) {
         nodeId = existing.id
@@ -361,13 +380,25 @@ export class ContentTypeRepository {
              WHERE id = ?`,
             [...columns, Number(found[0].id)],
           )
+          // Only a schema sync says; a backoffice save leaves it as it was.
+          if (property.searchable !== undefined)
+            await tx.exec('UPDATE property_type SET searchable = ? WHERE id = ?', [
+              bool(property.searchable),
+              Number(found[0].id),
+            ])
         } else {
           await tx.exec(
             `INSERT INTO property_type
                (unique_id, content_type_id, data_type_id, property_type_group_id, alias, name, description, sort_order,
-                mandatory, mandatory_message, validation_reg_exp, validation_reg_exp_message, label_on_top, variations, since_version, since_state_id)
-             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
-            [key, nodeId, ...columns, options.sinceStateId ?? null],
+                mandatory, mandatory_message, validation_reg_exp, validation_reg_exp_message, label_on_top, variations, since_version, since_state_id, searchable)
+             VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+            [
+              key,
+              nodeId,
+              ...columns,
+              options.sinceStateId ?? null,
+              bool(property.searchable !== false),
+            ],
           )
         }
       }
@@ -451,6 +482,11 @@ export class ContentTypeRepository {
           )
       }
 
+      if (existing && propertiesBefore !== (await propertySignature(tx, nodeId))) {
+        if (aggregate.isElement) await queueEverythingForSearch(tx)
+        else await queueContentTypesForSearch(tx, [nodeId])
+      }
+
       const saved = await repo.byKey(aggregate.key)
       if (!saved) throw new Error('Content type could not be read back after saving.')
       return saved
@@ -739,7 +775,7 @@ export class ContentTypeRepository {
               p.validation_reg_exp, p.validation_reg_exp_message, p.label_on_top, p.variations,
               dtn.unique_id AS data_type_key, g.unique_id AS container_key,
               p.since_version, ss.version AS since_v, ss.revision AS since_r,
-              m.member_can_edit, m.member_can_view, m.is_sensitive
+              m.member_can_edit, m.member_can_view, m.is_sensitive, p.searchable
        FROM property_type p
        JOIN node dtn ON dtn.id = p.data_type_id
        LEFT JOIN property_type_group g ON g.id = p.property_type_group_id
@@ -766,6 +802,7 @@ export class ContentTypeRepository {
       labelOnTop: fromDbBool(row.label_on_top),
       sinceVersion: (row.since_version as string | null) ?? null,
       pending: this.#pending(row),
+      ...(fromDbBool(row.searchable) ? {} : { searchable: false }),
       ...(this.#kind === 'member'
         ? {
             memberCanEdit: fromDbBool(row.member_can_edit),

package/src/repositories/data-types.ts

@@ -121,6 +121,44 @@ export class DataTypeRepository {
     return { total: items.length, items: items.slice(paging.skip, paging.skip + paging.take) }
   }
 
+  /** Whether any current value is saved through this data type; undefined when there is no such type. */
+  async isUsed(key: string): Promise<boolean | undefined> {
+    const node = await this.#nodes.byKey(key)
+    if (!node || node.objectType !== ObjectTypes.DataType) return undefined
+    return this.#hasValues('p.data_type_id = ?', [node.id])
+  }
+
+  /**
+   * Whether any current value is saved for the property `alias` of a content type;
+   * undefined when the type or the property does not exist.
+   */
+  async isPropertyUsed(contentTypeKey: string, alias: string): Promise<boolean | undefined> {
+    const rows = await this.#db.query<{ id: number }>(
+      `SELECT p.id FROM property_type p
+       JOIN node ctn ON ctn.id = p.content_type_id
+       WHERE ctn.unique_id = ? AND p.alias = ? AND p.retired_at IS NULL`,
+      [normaliseUuid(contentTypeKey), alias],
+    )
+    const property = rows[0]
+    if (!property) return undefined
+    return this.#hasValues('p.id = ?', [Number(property.id)])
+  }
+
+  /** A current value that holds something: an empty string or an all-null row is not a use. */
+  async #hasValues(where: string, params: unknown[]): Promise<boolean> {
+    const rows = await this.#db.query(
+      `SELECT 1 AS used FROM property_value v
+       JOIN property_type p ON p.id = v.property_type_id
+       WHERE ${where} AND v.is_current = ? AND p.retired_at IS NULL
+         AND (v.int_value IS NOT NULL OR v.decimal_value IS NOT NULL OR v.date_value IS NOT NULL
+           OR (v.varchar_value IS NOT NULL AND v.varchar_value <> '')
+           OR (v.text_value IS NOT NULL AND v.text_value <> ''))
+       LIMIT 1`,
+      [...params, this.#db.dialect.boolValue(true)],
+    )
+    return rows.length > 0
+  }
+
   /** Property types using this data type, with the type each belongs to. */
   async referencedBy(key: string): Promise<
     Array<{

package/src/repositories/delivery-member-tokens.ts

@@ -0,0 +1,110 @@
+/**
+ * The Delivery API's member tokens. A token is random and opaque; only its
+ * SHA-256 is kept, so the table cannot be replayed from a backup.
+ */
+import { createHash, randomBytes } from 'node:crypto'
+import type { Db } from '../database.ts'
+import { DbDate } from '../dialect.ts'
+
+export type MemberTokenKind = 'code' | 'access' | 'refresh'
+
+export interface MemberToken {
+  kind: MemberTokenKind
+  memberKey: string
+  clientId: string
+  scopes: string[]
+  redirectUri: string | null
+  codeChallenge: string | null
+  expiresAt: Date
+  redeemedAt: Date | null
+}
+
+/** A new token for a client to hold, and the hash it is stored under. Pure apart from the randomness. */
+export function newToken(): { token: string; hash: string } {
+  const token = randomBytes(32).toString('base64url')
+  return { token, hash: hashToken(token) }
+}
+
+export const hashToken = (token: string): string => createHash('sha256').update(token).digest('hex')
+
+/** PKCE S256: the verifier's SHA-256, base64url, against the challenge. Pure. */
+export const pkceMatches = (verifier: string, challenge: string): boolean =>
+  createHash('sha256').update(verifier).digest('base64url') === challenge
+
+export class DeliveryMemberTokenRepository {
+  #db: Db
+  constructor(db: Db) {
+    this.#db = db
+  }
+
+  async issue(
+    token: Omit<MemberToken, 'redeemedAt' | 'expiresAt'> & { lifetimeMs: number },
+  ): Promise<{ token: string; expiresAt: Date }> {
+    const { token: value, hash } = newToken()
+    const now = new Date()
+    const expiresAt = new Date(now.getTime() + token.lifetimeMs)
+    await this.#db.exec(
+      `INSERT INTO delivery_member_token
+         (hash, kind, member_key, client_id, scopes, redirect_uri, code_challenge, expires_at, create_date)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
+      [
+        hash,
+        token.kind,
+        token.memberKey,
+        token.clientId,
+        token.scopes.join(' '),
+        token.redirectUri,
+        token.codeChallenge,
+        DbDate.toDb(expiresAt),
+        DbDate.toDb(now),
+      ],
+    )
+    return { token: value, expiresAt }
+  }
+
+  /** The token a client presents, whatever its state; the caller judges it. */
+  async find(token: string): Promise<MemberToken | undefined> {
+    const rows = await this.#db.query('SELECT * FROM delivery_member_token WHERE hash = ?', [
+      hashToken(token),
+    ])
+    const row = rows[0]
+    if (!row) return undefined
+    return {
+      kind: String(row.kind) as MemberTokenKind,
+      memberKey: String(row.member_key),
+      clientId: String(row.client_id),
+      scopes: String(row.scopes ?? '')
+        .split(' ')
+        .filter(Boolean),
+      redirectUri: (row.redirect_uri as string | null) ?? null,
+      codeChallenge: (row.code_challenge as string | null) ?? null,
+      expiresAt: DbDate.fromDb(row.expires_at) ?? new Date(0),
+      redeemedAt: DbDate.fromDb(row.redeemed_at) ?? null,
+    }
+  }
+
+  /** Marks a code or refresh token used; false when it already was, so only one redemption wins. */
+  async redeem(token: string): Promise<boolean> {
+    const rows = await this.#db.query<{ hash: string }>(
+      'UPDATE delivery_member_token SET redeemed_at = ? WHERE hash = ? AND redeemed_at IS NULL RETURNING hash',
+      [DbDate.toDb(new Date()), hashToken(token)],
+    )
+    return rows.length > 0
+  }
+
+  async revoke(token: string): Promise<void> {
+    await this.#db.exec('DELETE FROM delivery_member_token WHERE hash = ?', [hashToken(token)])
+  }
+
+  /** Every token a member holds, as signing out ends them. */
+  async revokeMember(memberKey: string): Promise<void> {
+    await this.#db.exec('DELETE FROM delivery_member_token WHERE member_key = ?', [memberKey])
+  }
+
+  /** Expired tokens, which nothing will accept again. */
+  async purgeExpired(): Promise<void> {
+    await this.#db.exec('DELETE FROM delivery_member_token WHERE expires_at < ?', [
+      DbDate.toDb(new Date()),
+    ])
+  }
+}

package/src/repositories/dictionary.ts

@@ -240,6 +240,24 @@ export class DictionaryRepository {
     })
   }
 
+  /** Every item's key, name and parent's name, for a choice list drawn from the dictionary. */
+  async outline(): Promise<Array<{ key: string; name: string; parentName: string | null }>> {
+    const rows = await this.#db.query<{
+      key: string
+      item_key: string
+      parent_name: string | null
+    }>(
+      `SELECT d.key, d.item_key, p.item_key AS parent_name FROM dictionary_item d
+       LEFT JOIN dictionary_item p ON p.key = d.parent_key
+       ORDER BY d.item_key`,
+    )
+    return rows.map((row) => ({
+      key: normaliseUuid(String(row.key)),
+      name: String(row.item_key),
+      parentName: row.parent_name === null ? null : String(row.parent_name),
+    }))
+  }
+
   /** 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 }>(