thatcher 1.0.7 → 1.0.34

package/src/lib/busybase-store.js

@@ -0,0 +1,338 @@
+/*
+ * BusyBase data store — async replacement for the better-sqlite3 query engine.
+ *
+ * busybase is a Supabase-style async document store (LanceDB) with no SQL joins or
+ * foreign keys, so the relational behaviours of the old query-engine are reimplemented
+ * here in JS:
+ *   - ref "display" fields (old LEFT JOIN) -> client-side lookup of the referenced row
+ *   - soft-delete / archive filtering       -> in-memory predicate on the result set
+ *   - sort / limit / offset                  -> busybase order()/range()
+ *
+ * Every export is async (busybase is async); callers are the already-async API route
+ * handlers and crud-handlers, so the await ripple terminates at an existing boundary.
+ *
+ * Requires Bun (busybase embedded uses Bun.password + the vectordb native binding).
+ */
+
+import { getSpec } from '../config/spec-helpers.js';
+import { RECORD_STATUS } from '../config/constants.js';
+import { genId, now } from './id-helpers.js';
+
+let _client = null;
+
+export function setBusyBaseClient(client) {
+  _client = client;
+}
+
+function client() {
+  if (!_client) throw new Error('BusyBase store not initialised. Call setBusyBaseClient() first.');
+  return _client;
+}
+
+// busybase uses the entity name as the table; map the special `user` -> `users`.
+function tableName(entity) {
+  return entity === 'user' ? 'users' : entity;
+}
+
+function unwrap({ data, error }, op) {
+  if (error) throw new Error(`BusyBase ${op} failed: ${error.message || error}`);
+  return data;
+}
+
+// Resolve ref "display" fields for a set of rows the way the old LEFT JOIN did:
+// for every ref field with a `display` spec, fetch the referenced rows and attach
+// `<field>_display`. Batched per ref-table to avoid N+1 within a single field.
+//
+// getSpec returns null for raw infra tables (sessions, audit_logs, structured_logs,
+// password_reset_tokens, mwr_bridge_tokens, email, activity_log, ...) that aren't
+// config entities. Treat those as plain document tables: no ref-display, no
+// soft-delete, hard CRUD. specOf() guarantees a usable shape.
+function specOf(entity) {
+  return getSpec(entity) || { fields: {}, raw: true };
+}
+
+async function attachRefDisplays(entity, rows) {
+  if (!rows.length) return rows;
+  const spec = specOf(entity);
+  const refFields = Object.entries(spec.fields || {}).filter(([, f]) => f.type === 'ref' && f.display);
+  if (!refFields.length) return rows;
+
+  for (const [key, f] of refFields) {
+    const refTable = tableName(f.ref);
+    const displayField = (f.display.split('.')[1]) || 'name';
+    const ids = [...new Set(rows.map(r => r[key]).filter(v => v != null))];
+    if (!ids.length) continue;
+    const refRows = unwrap(await client().from(refTable).select('*').in('id', ids), 'ref-resolve');
+    const byId = new Map(refRows.map(r => [String(r.id), r]));
+    for (const r of rows) {
+      const ref = r[key] != null ? byId.get(String(r[key])) : null;
+      if (ref) r[`${key}_display`] = ref[displayField];
+    }
+  }
+  return rows;
+}
+
+// Apply soft-delete / archive default filtering in memory (no SQL WHERE).
+function applyVisibility(spec, rows, where, options) {
+  let out = rows;
+  if (spec.fields?.status && !('status' in where) && !options.includeDeleted) {
+    out = out.filter(r => r.status !== RECORD_STATUS.DELETED);
+  }
+  if (spec.fields?.archived && !('archived' in where) && !options.includeArchived) {
+    out = out.filter(r => !r.archived || r.archived === 0);
+  }
+  return out;
+}
+
+// Compile a where-object onto the busybase query builder. A scalar value is an
+// equality (the original behaviour); an operator object opens range/set/negation
+// filters the builder already supports (sdk.js eq/neq/gt/gte/lt/lte/in/like/ilike,
+// and a top-level $or clause). This lets a config-driven query express "today"
+// (created_at between), "near me" (a lat/lon bounding box), and "open" (status in
+// the non-terminal set) without the caller hand-rolling JS filters. Operators are a
+// small fixed allowlist; an unknown operator key throws rather than silently
+// matching everything (a wrong filter must fail loud, not leak rows).
+const WHERE_OPS = {
+  $eq: (b, k, v) => b.eq(k, v),
+  $ne: (b, k, v) => b.neq(k, v),
+  $gt: (b, k, v) => b.gt(k, v),
+  $gte: (b, k, v) => b.gte(k, v),
+  $lt: (b, k, v) => b.lt(k, v),
+  $lte: (b, k, v) => b.lte(k, v),
+  $in: (b, k, v) => b.in(k, Array.isArray(v) ? v : [v]),
+  $like: (b, k, v) => b.like(k, v),
+  $ilike: (b, k, v) => b.ilike(k, v),
+};
+function applyWhere(builder, where) {
+  for (const [k, v] of Object.entries(where)) {
+    if (v === undefined || v === null) continue;
+    // Top-level $or: an array of {field: value|operator-object} sub-clauses,
+    // OR-joined (e.g. find a case the worker reported OR is assigned to).
+    // LIMITATION: busybase's or() parser splits the compiled clause string on
+    // ',' (between sub-filters) and '.' (between field/op/value), and there is
+    // no escaping mechanism -- a value containing either character (e.g.
+    // 'Underberg, KZN' or '1.5') cannot be represented and would corrupt the
+    // clause into bogus sub-filters that silently leak or miss rows. Fail loud
+    // instead: reject such values here. Callers needing them must use a
+    // non-$or filter (eq/like) or restructure the query.
+    if (k === '$or' && Array.isArray(v)) {
+      const assertOrSafe = (val) => {
+        const s = String(val);
+        if (s.includes(',') || s.includes('.')) {
+          throw new Error(
+            `busybase applyWhere: $or sub-clause value ${JSON.stringify(s)} contains ',' or '.', ` +
+            `which busybase's or() delimiter syntax cannot escape; use a non-$or filter for this value`
+          );
+        }
+        return s;
+      };
+      // busybase's or() parser reads PostgREST order: field.op.value (NOT
+      // op.field.value -- a mismatched sub-clause parses to null and is
+      // silently dropped, making the $or match everything).
+      const clause = v.map(sub => Object.entries(sub).map(([sk, sv]) => {
+        if (sv && typeof sv === 'object' && !Array.isArray(sv)) {
+          const [op, ov] = Object.entries(sv)[0];
+          const bare = op.replace(/^\$/, '');
+          return `${sk}.${bare}.${Array.isArray(ov) ? ov.map(assertOrSafe).join(',') : assertOrSafe(ov)}`;
+        }
+        return `${sk}.eq.${assertOrSafe(sv)}`;
+      }).join(',')).join(',');
+      builder = builder.or(clause);
+      continue;
+    }
+    // An operator object: { $gte: x, $lt: y } applies each supported operator.
+    if (typeof v === 'object' && !Array.isArray(v)) {
+      for (const [op, ov] of Object.entries(v)) {
+        const fn = WHERE_OPS[op];
+        if (!fn) throw new Error(`busybase applyWhere: unsupported operator ${op} on field ${k}`);
+        builder = fn(builder, k, ov);
+      }
+      continue;
+    }
+    // A bare array value is an IN set; a scalar is equality.
+    builder = Array.isArray(v) ? builder.in(k, v) : builder.eq(k, v);
+  }
+  return builder;
+}
+
+export async function list(entity, where = {}, options = {}) {
+  const spec = specOf(entity);
+  const tbl = tableName(entity);
+  let rows = unwrap(await applyWhere(client().from(tbl).select('*'), where), 'list');
+  rows = applyVisibility(spec, rows, where, options);
+
+  // Row-access scoping: when a caller passes options.user AND the entity declares
+  // rowAccess, restrict the rows to what that user may see (their assigned cases,
+  // their team, etc.). Opt-in -- no user means the read is unchanged, so internal
+  // and admin callers are unaffected. This makes a config row_access spec actually
+  // enforced on the read path (previously list() took no user, so the spec was
+  // inert and a scoped enquiry would leak every row).
+  if (options.user && (spec.rowAccess || spec.row_access)) {
+    const { permissionService } = await import('../services/permission.service.js');
+    rows = permissionService.filterRecords(options.user, spec, rows);
+  }
+
+  // Sort accepts a single {field,dir} (the original) OR an ARRAY of them for
+  // tie-broken order (e.g. [{field:'priority',dir:'DESC'},{field:'last_event_at',
+  // dir:'DESC'}]) -- so a recency-with-tiebreak list is config, not a JS sort in
+  // the caller. Each key is guarded against spec.fields; unknown keys are skipped.
+  const sortSpec = options.sort || spec.list?.defaultSort;
+  const sortKeys = (Array.isArray(sortSpec) ? sortSpec : sortSpec ? [sortSpec] : [])
+    .filter(s => s && s.field && spec.fields?.[s.field]);
+  if (sortKeys.length) {
+    rows.sort((a, b) => {
+      for (const s of sortKeys) {
+        const av = a[s.field], bv = b[s.field];
+        if (av === bv) continue;
+        const desc = (s.dir || 'ASC').toUpperCase() === 'DESC';
+        return (av > bv ? 1 : -1) * (desc ? -1 : 1);
+      }
+      return 0;
+    });
+  }
+  if (options.offset || options.limit) {
+    const off = parseInt(options.offset || 0, 10);
+    const lim = options.limit ? parseInt(options.limit, 10) : rows.length;
+    rows = rows.slice(off, off + lim);
+  }
+  return attachRefDisplays(entity, rows);
+}
+
+export async function count(entity, where = {}, options = {}) {
+  const spec = specOf(entity);
+  const tbl = tableName(entity);
+  let rows = unwrap(await applyWhere(client().from(tbl).select('*'), where), 'count');
+  rows = applyVisibility(spec, rows, where, options);
+  return rows.length;
+}
+
+export async function listWithPagination(entity, where = {}, page = 1, pageSize = 50) {
+  const finalPage = Math.max(1, page);
+  const total = await count(entity, where);
+  const items = await list(entity, where, { offset: (finalPage - 1) * pageSize, limit: pageSize });
+  return { items, pagination: { page: finalPage, pageSize, total, totalPages: Math.ceil(total / pageSize) } };
+}
+
+export async function get(entity, id) {
+  const tbl = tableName(entity);
+  const row = unwrap(await client().from(tbl).select('*').eq('id', id).maybeSingle(), 'get');
+  if (!row) return null;
+  const [withDisplay] = await attachRefDisplays(entity, [row]);
+  return withDisplay;
+}
+
+export async function getBy(entity, field, value) {
+  const tbl = tableName(entity);
+  return unwrap(await client().from(tbl).select('*').eq(field, value).maybeSingle(), 'getBy');
+}
+
+export async function create(entity, data, user) {
+  const spec = specOf(entity);
+  const tbl = tableName(entity);
+
+  const record = {
+    ...data,
+    id: data.id || genId(),
+    created_by: user?.id || '',
+    created_at: now(),
+    updated_at: 0,
+    status: data.status || RECORD_STATUS.ACTIVE,
+  };
+  for (const [key, field] of Object.entries(spec.fields || {})) {
+    if (field.auto === 'uuid' && !record[key]) record[key] = genId();
+    if (field.auto === 'timestamp' && !record[key]) record[key] = now();
+  }
+  // LanceDB cannot infer a column's type from a null on first insert; coerce any
+  // null/undefined to a typed sentinel ('' for strings) so the insert schema is stable.
+  for (const k of Object.keys(record)) {
+    if (record[k] === null || record[k] === undefined) record[k] = '';
+  }
+  unwrap(await client().from(tbl).insert(record), 'create');
+  // Always return the locally-constructed record: it holds the genId we put in
+  // the TEXT id column. The store's insert() may return a rowid/driver shape, so
+  // trusting `created` would hand callers the wrong id.
+  return record;
+}
+
+export async function update(entity, id, data) {
+  const spec = specOf(entity);
+  const tbl = tableName(entity);
+
+  const existing = await get(entity, id);
+  if (!existing) throw new Error(`${entity} with id ${id} not found`);
+
+  const patch = { ...data, updated_at: now() };
+  unwrap(await client().from(tbl).update(patch).eq('id', id), 'update');
+  return get(entity, id);
+}
+
+export async function remove(entity, id) {
+  const spec = specOf(entity);
+  const tbl = tableName(entity);
+
+  const existing = await get(entity, id);
+  if (!existing) throw new Error(`${entity} with id ${id} not found`);
+
+  if (spec.fields && 'status' in spec.fields) {
+    unwrap(await client().from(tbl).update({ status: RECORD_STATUS.DELETED, updated_at: now() }).eq('id', id), 'soft-delete');
+    return { ...existing, status: RECORD_STATUS.DELETED };
+  }
+  if (spec.fields && 'archived' in spec.fields) {
+    unwrap(await client().from(tbl).update({ archived: 1, updated_at: now() }).eq('id', id), 'archive');
+    return { ...existing, archived: 1 };
+  }
+  unwrap(await client().from(tbl).delete().eq('id', id), 'delete');
+  return existing;
+}
+
+export async function bulkCreate(entity, records, user) {
+  const out = [];
+  for (const data of records) out.push(await create(entity, data, user));
+  return out;
+}
+
+// Substring search across the entity's text-ish fields (busybase has no FTS,
+// so this is the in-memory equivalent of the old LIKE fallback). Returns visible rows only.
+export async function search(entity, query, where = {}, options = {}) {
+  const spec = specOf(entity);
+  const rows = await list(entity, where, { ...options, limit: undefined, offset: undefined });
+  const q = String(query || '').toLowerCase();
+  if (!q) return rows;
+  const fields = Object.keys(spec.fields || {}).filter(
+    f => ['text', 'textarea', 'email'].includes(spec.fields[f].type)
+  );
+  let matched = rows.filter(r => fields.some(f => String(r[f] ?? '').toLowerCase().includes(q)));
+  if (options.offset || options.limit) {
+    const off = parseInt(options.offset || 0, 10);
+    const lim = options.limit ? parseInt(options.limit, 10) : matched.length;
+    matched = matched.slice(off, off + lim);
+  }
+  return matched;
+}
+
+export async function searchWithPagination(entity, query, where = {}, page = 1, pageSize = null) {
+  const spec = specOf(entity);
+  const finalPageSize = pageSize || spec.list?.pageSize || 50;
+  const finalPage = Math.max(1, page);
+  const all = await search(entity, query, where);
+  const total = all.length;
+  const items = all.slice((finalPage - 1) * finalPageSize, finalPage * finalPageSize);
+  return { items, pagination: { page: finalPage, pageSize: finalPageSize, total, totalPages: Math.ceil(total / finalPageSize) } };
+}
+
+// Children of a parent via foreign-key field (old: WHERE fk = ? AND status != deleted).
+export async function getChildren(parentEntity, parentId, childDef) {
+  const fk = childDef.fk || childDef.foreignKey || `${parentEntity}_id`;
+  return list(childDef.entity, { [fk]: parentId });
+}
+
+export async function batchGetChildren(parentEntity, parentId, childSpecs) {
+  const defs = Array.isArray(childSpecs)
+    ? childSpecs.map(e => [e, { entity: e }])
+    : Object.entries(childSpecs);
+  const out = {};
+  for (const [key, def] of defs) {
+    out[key] = await getChildren(parentEntity, parentId, def.entity ? def : { entity: key, ...def });
+  }
+  return out;
+}

package/src/lib/config-field-helpers.js

@@ -1,12 +1,5 @@
-/**
- * Config Field Helpers - Field definition processing and validation
- */
-
 import { getSpec } from '../config/spec-helpers.js';
 
-/**
- * Generate fields from field overrides
- */
 export function generateFieldsFromOverrides(overrides, baseFields) {
   const result = { ...baseFields };
   if (!overrides) return result;
@@ -22,13 +15,9 @@ export function generateFieldsFromOverrides(overrides, baseFields) {
   return result;
 }
 
-/**
- * Generate default field definitions for implicit fields
- */
 export function generateDefaultFields(entityDef) {
   const defaults = {};
 
-  // Add common fields
   if (!entityDef.fields) return defaults;
 
   for (const [key, field] of Object.entries(entityDef.fields)) {
@@ -45,9 +34,6 @@ export function generateDefaultFields(entityDef) {
   return defaults;
 }
 
-/**
- * Build enum options from various sources (array, ref to status enum, etc.)
- */
 export function buildEnumOptions(fieldDef, entityName, configEngine) {
   if (Array.isArray(fieldDef.options)) {
     return fieldDef.options.map(o => typeof o === 'object' ? o.value : o);
@@ -76,9 +62,6 @@ export function buildEnumOptions(fieldDef, entityName, configEngine) {
   return [];
 }
 
-/**
- * Ensure all fields have labels
- */
 export function ensureFieldLabels(fields) {
   const result = {};
   for (const [key, field] of Object.entries(fields)) {

package/src/lib/config-generator-engine.js

@@ -1,8 +1,4 @@
-/**
- * Config Generator Engine - Resolves entity specs from YAML config
- * Core of Thatcher's configuration-driven architecture
- * Adapted from moonlanding/src/lib/config-generator-engine.js
- */
+// Adapted from moonlanding/src/lib/config-generator-engine.js
 
 import yaml from 'js-yaml';
 import { LRUCache, deepFreeze, deepClone, recursiveResolve } from './config-helpers.js';
@@ -17,9 +13,6 @@ export class ConfigGeneratorEngine {
     this._plugins = new Map();
   }
 
-  /**
-   * Register a plugin to extend an entity
-   */
   registerPlugin(entityName, plugin = {}) {
     if (!entityName || typeof entityName !== 'string') {
       throw new Error('[ConfigGeneratorEngine] registerPlugin: entityName required');
@@ -232,10 +225,6 @@ export class ConfigGeneratorEngine {
     return this;
   }
 
-  /**
-   * Generate complete entity specification from config
-   * This is the main method that builds the spec used by CRUD, UI, etc.
-   */
   generateEntitySpec(entityName) {
     if (!entityName) throw new Error('[config] generateEntitySpec: entityName required');
 
@@ -291,24 +280,35 @@ export class ConfigGeneratorEngine {
       options: {},
     };
 
-    // Merge field overrides
     if (entityDef.field_overrides) {
       spec.field_overrides = recursiveResolve(entityDef.field_overrides, config);
     }
 
-    // Build fields from definition + overrides + plugin additions
     const baseFields = entityDef.fields || {};
     const plugin = this._plugins.get(entityName);
     const pluginFields = plugin?.fields || {};
 
-    // Combine and process fields
     const allFields = {
       ...baseFields,
       ...spec.field_overrides,
       ...pluginFields,
     };
 
-    // Ensure required metadata (label, type defaults)
+    // Auto-inject the system fields every entity needs (id is the primary key;
+    // created_at/created_by/updated_at/status are written by the store on every
+    // create/update). Declared fields of the same name win, so a config can
+    // still override e.g. status into an enum.
+    const SYSTEM_FIELDS = {
+      id: { type: 'id', readonly: true },
+      created_at: { type: 'timestamp', readonly: true },
+      created_by: { type: 'text', readonly: true },
+      updated_at: { type: 'timestamp', readonly: true },
+      status: { type: 'text' },
+    };
+    for (const [key, field] of Object.entries(SYSTEM_FIELDS)) {
+      if (!(key in allFields)) allFields[key] = field;
+    }
+
     for (const [key, field] of Object.entries(allFields)) {
       spec.fields[key] = {
         type: field.type || 'text',
@@ -330,7 +330,6 @@ export class ConfigGeneratorEngine {
       };
     }
 
-    // Permission matrix
     if (entityDef.permission_template) {
       const matrix = this.getPermissionTemplate(entityDef.permission_template);
       const access = {};
@@ -349,7 +348,6 @@ export class ConfigGeneratorEngine {
       spec.permissions = roleActions;
     }
 
-    // Workflow binding
     if (entityDef.workflow) {
       const wf = this.getWorkflow(entityDef.workflow);
       spec.workflow = wf;
@@ -368,7 +366,6 @@ export class ConfigGeneratorEngine {
       spec.variants = deepClone(entityDef.variants);
     }
 
-    // List options
     if (entityDef.list) {
       spec.list = {
         defaultSort: entityDef.list.defaultSort || { field: 'created_at', dir: 'desc' },
@@ -406,9 +403,6 @@ export class ConfigGeneratorEngine {
   }
 }
 
-/**
- * Get or create singleton config engine
- */
 let _singleton = null;
 
 export function getConfigEngineSync() {
@@ -429,11 +423,6 @@ export async function getConfigEngine() {
   return getConfigEngineSync();
 }
 
-/**
- * Initialize config engine from config source
- * @param {string|object} configSource
- * @returns {ConfigGeneratorEngine}
- */
 export async function initConfig(configSource) {
   const { loadConfig } = await import('../config/config-loader.js');
   const { validateConfig, getConfigWithDefaults } = await import('../config/config-loader.js');
@@ -450,20 +439,14 @@ export async function initConfig(configSource) {
   return _singleton;
 }
 
-/**
- * Set the singleton config engine directly (used by the bootstrap in index.js,
- * which constructs the engine from an already-parsed config object). This is what
- * makes getConfigEngineSync() resolve for the server/plugin/spec paths.
- * @param {ConfigGeneratorEngine} engine
- */
+// Used by the bootstrap in index.js which constructs the engine from an already-parsed
+// config object; makes getConfigEngineSync() resolve for the server/plugin/spec paths.
 export function setConfigEngine(engine) {
   _singleton = engine;
   return _singleton;
 }
 
-/**
- * Reset singleton (for hot reload)
- */
+// Called during hot reload to force re-initialization.
 export function resetConfigEngine() {
   _singleton = null;
 }

package/src/lib/config-helpers.js

@@ -1,11 +1,3 @@
-/**
- * Configuration Helpers - Utilities for config processing
- * LRUCache, deep cloning, freezing, recursive resolution
- */
-
-/**
- * LRU Cache implementation
- */
 export class LRUCache {
   constructor(maxSize = 100) {
     this.maxSize = maxSize;
@@ -39,9 +31,6 @@ export class LRUCache {
   }
 }
 
-/**
- * Deep freeze object (immutable)
- */
 export function deepFreeze(obj) {
   if (obj === null || typeof obj !== 'object') return obj;
   if (Object.isFrozen(obj)) return obj;
@@ -55,9 +44,6 @@ export function deepFreeze(obj) {
   return obj;
 }
 
-/**
- * Deep clone object
- */
 export function deepClone(obj) {
   if (obj === null || typeof obj !== 'object') return obj;
   if (Array.isArray(obj)) return obj.map(deepClone);
@@ -69,10 +55,6 @@ export function deepClone(obj) {
   return cloned;
 }
 
-/**
- * Recursively resolve string template references in config
- * Replaces ${ref.path} with value from config
- */
 export function recursiveResolve(value, config) {
   if (typeof value === 'string') {
     return value.replace(/\$\{([^}]+)\}/g, (_, path) => {
@@ -104,9 +86,6 @@ export function recursiveResolve(value, config) {
   return value;
 }
 
-/**
- * Merge objects deeply
- */
 export function deepMerge(target, source) {
   const output = { ...target };
   for (const key of Object.keys(source)) {

package/src/lib/crud-action-helpers.js

@@ -1,6 +1,6 @@
-import { AppError } from '@/lib/errors';
+import { AppError } from '@/lib/error-handler';
 import { HTTP } from '@/config/constants';
-import { now } from '@/lib/database-core';
+import { now } from '@/lib/id-helpers';
 
 const ACTION_FIELD_MAPS = {
   resolve_highlight: { status: 'resolved', color: 'green' },

package/src/lib/crud-factory.js

@@ -1,23 +1,14 @@
-/**
- * CRUD Factory - Creates per-entity CRUD handler objects
- * Adapted from moonlanding/src/lib/crud-factory.js
- */
+// Adapted from moonlanding/src/lib/crud-factory.js
 
 import { createCrudHandlers as buildHandlers } from './crud-handlers.js';
 import { getConfigEngineSync } from './config-generator-engine.js';
 
-/**
- * Create CRUD handlers for an entity
- * @param {string} entityName
- * @returns {object} Handler functions (GET, POST, PUT, PATCH, DELETE)
- */
 export function createCrudHandlers(entityName) {
   const configEngine = getConfigEngineSync();
   const spec = configEngine.generateEntitySpec(entityName);
 
   return {
     GET: async (request, context) => {
-      // Handle list or single get based on presence of id
       const { params } = context;
       const id = params?.id;
 
@@ -55,11 +46,6 @@ export function createCrudHandlers(entityName) {
   };
 }
 
-/**
- * Create generic controller for an entity
- * @param {string} entityName
- * @returns {object}
- */
 export function createEntityController(entityName) {
   const configEngine = getConfigEngineSync();
   const spec = configEngine.generateEntitySpec(entityName);
@@ -72,7 +58,6 @@ export function createEntityController(entityName) {
     update: handlers.update,
     delete: handlers.remove,
 
-    // Custom actions from config
     async customAction(action, request, context) {
       const { params } = context;
       const id = params?.id;