@gzl10/nexus-backend 0.18.0 → 0.19.0

package/dist/testing/index.js

@@ -0,0 +1,1675 @@
+// src/testing/test-helpers.ts
+import { vi } from "vitest";
+
+// src/db/filter-helpers.ts
+function applyInMemoryFilters(items, filters) {
+  return items.filter((item) => {
+    const record = item;
+    return matchRecordFilters(record, filters);
+  });
+}
+function matchRecordFilters(record, filters) {
+  for (const [key, value] of Object.entries(filters)) {
+    if (value === void 0) continue;
+    if (key === "$or") {
+      if (Array.isArray(value) && value.length > 0) {
+        const orMatch = value.some(
+          (group) => matchRecordFilters(record, group)
+        );
+        if (!orMatch) return false;
+      }
+      continue;
+    }
+    const itemValue = record[key];
+    if (value === null) {
+      if (itemValue !== null && itemValue !== void 0) return false;
+      continue;
+    }
+    if (value === "") continue;
+    if (Array.isArray(value)) {
+      if (value.length === 0) continue;
+      if (!value.includes(itemValue)) return false;
+      continue;
+    }
+    if (typeof value === "object" && !Array.isArray(value)) {
+      if (!matchFilterOperators(itemValue, value)) return false;
+      continue;
+    }
+    if (itemValue !== value) return false;
+  }
+  return true;
+}
+function matchFilterOperators(itemValue, operators) {
+  for (const [op, val] of Object.entries(operators)) {
+    if (val === void 0) continue;
+    switch (op) {
+      case "$eq":
+        if (val === null) {
+          if (itemValue !== null && itemValue !== void 0) return false;
+        } else if (itemValue !== val) return false;
+        break;
+      case "$ne":
+        if (val === null) {
+          if (itemValue === null || itemValue === void 0) return false;
+        } else if (itemValue === val) return false;
+        break;
+      case "$gt":
+        if (typeof itemValue !== "number" && typeof itemValue !== "string") return false;
+        if (!(itemValue > val)) return false;
+        break;
+      case "$gte":
+        if (typeof itemValue !== "number" && typeof itemValue !== "string") return false;
+        if (!(itemValue >= val)) return false;
+        break;
+      case "$lt":
+        if (typeof itemValue !== "number" && typeof itemValue !== "string") return false;
+        if (!(itemValue < val)) return false;
+        break;
+      case "$lte":
+        if (typeof itemValue !== "number" && typeof itemValue !== "string") return false;
+        if (!(itemValue <= val)) return false;
+        break;
+      case "$contains":
+        if (typeof itemValue !== "string" || typeof val !== "string") return false;
+        if (!itemValue.toLowerCase().includes(val.toLowerCase())) return false;
+        break;
+      case "$startswith":
+        if (typeof itemValue !== "string" || typeof val !== "string") return false;
+        if (!itemValue.toLowerCase().startsWith(val.toLowerCase())) return false;
+        break;
+      case "$endswith":
+        if (typeof itemValue !== "string" || typeof val !== "string") return false;
+        if (!itemValue.toLowerCase().endsWith(val.toLowerCase())) return false;
+        break;
+      case "$in":
+        if (!Array.isArray(val) || val.length === 0) break;
+        if (!val.includes(itemValue)) return false;
+        break;
+      case "$nin":
+        if (!Array.isArray(val) || val.length === 0) break;
+        if (val.includes(itemValue)) return false;
+        break;
+      case "$isnull":
+        if (val === true && itemValue !== null && itemValue !== void 0) return false;
+        if (val === false && (itemValue === null || itemValue === void 0)) return false;
+        break;
+      case "$between":
+        if (!Array.isArray(val) || val.length !== 2) break;
+        if (typeof itemValue !== "number" && typeof itemValue !== "string") return false;
+        if (!(itemValue >= val[0] && itemValue <= val[1])) return false;
+        break;
+    }
+  }
+  return true;
+}
+
+// src/db/memory-adapter.ts
+var DEFAULT_PAGE = 1;
+var DEFAULT_LIMIT = 20;
+var DEFAULT_MAX_LIMIT = 1e4;
+function generateId() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var InMemoryAdapter = class {
+  tables = /* @__PURE__ */ new Map();
+  ttlMap = /* @__PURE__ */ new Map();
+  get raw() {
+    return this.tables;
+  }
+  clear() {
+    for (const metadata of this.ttlMap.values()) {
+      clearTimeout(metadata.timerId);
+    }
+    this.ttlMap.clear();
+    this.tables.clear();
+  }
+  clearTable(table) {
+    this.tables.delete(table);
+  }
+  seed(table, records) {
+    const tableData = this.getOrCreateTable(table);
+    for (const record of records) {
+      const id = record["id"] || generateId();
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      tableData.set(id, {
+        ...record,
+        id,
+        created_at: record["created_at"] || now,
+        updated_at: record["updated_at"] || now
+      });
+    }
+  }
+  getOrCreateTable(table) {
+    let tableData = this.tables.get(table);
+    if (!tableData) {
+      tableData = /* @__PURE__ */ new Map();
+      this.tables.set(table, tableData);
+    }
+    return tableData;
+  }
+  // ---- DatabaseAdapter interface ----
+  async findMany(table, query) {
+    const maxLimit = query?.maxLimit ?? DEFAULT_MAX_LIMIT;
+    const page = Math.max(1, query?.page ?? DEFAULT_PAGE);
+    const limit = Math.min(maxLimit, Math.max(1, query?.limit ?? DEFAULT_LIMIT));
+    const offset = (page - 1) * limit;
+    const tableData = this.tables.get(table);
+    if (!tableData) {
+      return { items: [], total: 0, page, limit, totalPages: 0, hasNext: false };
+    }
+    let items = Array.from(tableData.values());
+    if (query?.filters) {
+      items = applyInMemoryFilters(items, query.filters);
+    }
+    if (query?.sort) {
+      const sortField = query.sort;
+      const order = query.order ?? "asc";
+      items.sort((a, b) => {
+        const aVal = a[sortField];
+        const bVal = b[sortField];
+        if (aVal === bVal) return 0;
+        if (aVal === null || aVal === void 0) return 1;
+        if (bVal === null || bVal === void 0) return -1;
+        const comparison = aVal < bVal ? -1 : 1;
+        return order === "asc" ? comparison : -comparison;
+      });
+    }
+    const total = items.length;
+    items = items.slice(offset, offset + limit);
+    const totalPages = Math.ceil(total / limit);
+    return { items, total, page, limit, totalPages, hasNext: page < totalPages };
+  }
+  async findOne(table, filters) {
+    const tableData = this.tables.get(table);
+    if (!tableData) return null;
+    for (const record of tableData.values()) {
+      const match = Object.entries(filters).every(([k, v]) => record[k] === v);
+      if (match) return record;
+    }
+    return null;
+  }
+  async findById(table, id) {
+    const tableData = this.tables.get(table);
+    if (!tableData) return null;
+    return tableData.get(id) ?? null;
+  }
+  async count(table, filters) {
+    const tableData = this.tables.get(table);
+    if (!tableData) return 0;
+    if (!filters || Object.keys(filters).length === 0) return tableData.size;
+    const items = applyInMemoryFilters(Array.from(tableData.values()), filters);
+    return items.length;
+  }
+  async insert(table, data) {
+    const tableData = this.getOrCreateTable(table);
+    const id = data["id"] || generateId();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const record = { ...data, id, created_at: now, updated_at: now };
+    tableData.set(id, record);
+    return record;
+  }
+  async update(table, id, data) {
+    const tableData = this.tables.get(table);
+    if (!tableData) throw new Error(`Table "${table}" not found`);
+    const existing = tableData.get(id);
+    if (!existing) throw new Error(`Record "${id}" not found in table "${table}"`);
+    const updated = {
+      ...existing,
+      ...data,
+      id,
+      created_at: existing.created_at,
+      updated_at: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    tableData.set(id, updated);
+    return updated;
+  }
+  async delete(table, id) {
+    const tableData = this.tables.get(table);
+    if (!tableData) return false;
+    return tableData.delete(id);
+  }
+  async transaction(fn) {
+    return fn(this);
+  }
+  // ---- TTL Methods ----
+  getTtlKey(table, id) {
+    return `${table}:${id}`;
+  }
+  async insertWithTtl(table, data, ttlSeconds) {
+    const tableData = this.getOrCreateTable(table);
+    const id = data["id"] || generateId();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const expires_at = new Date(Date.now() + ttlSeconds * 1e3).toISOString();
+    const record = { ...data, id, created_at: now, updated_at: now, expires_at };
+    tableData.set(id, record);
+    const ttlKey = this.getTtlKey(table, id);
+    const timerId = setTimeout(() => this.deleteWithTtlCleanup(table, id), ttlSeconds * 1e3);
+    this.ttlMap.set(ttlKey, { expiresAt: Date.now() + ttlSeconds * 1e3, timerId });
+    return record;
+  }
+  deleteWithTtlCleanup(table, id) {
+    const tableData = this.tables.get(table);
+    if (tableData) tableData.delete(id);
+    const ttlKey = this.getTtlKey(table, id);
+    const metadata = this.ttlMap.get(ttlKey);
+    if (metadata) {
+      clearTimeout(metadata.timerId);
+      this.ttlMap.delete(ttlKey);
+    }
+  }
+  async setTtl(table, id, ttlSeconds) {
+    const tableData = this.tables.get(table);
+    if (!tableData) return false;
+    const record = tableData.get(id);
+    if (!record) return false;
+    record["expires_at"] = new Date(Date.now() + ttlSeconds * 1e3).toISOString();
+    record["updated_at"] = (/* @__PURE__ */ new Date()).toISOString();
+    const ttlKey = this.getTtlKey(table, id);
+    const existing = this.ttlMap.get(ttlKey);
+    if (existing) clearTimeout(existing.timerId);
+    const timerId = setTimeout(() => this.deleteWithTtlCleanup(table, id), ttlSeconds * 1e3);
+    this.ttlMap.set(ttlKey, { expiresAt: Date.now() + ttlSeconds * 1e3, timerId });
+    return true;
+  }
+  async getTtl(table, id) {
+    const tableData = this.tables.get(table);
+    if (!tableData || !tableData.has(id)) return -2;
+    const ttlKey = this.getTtlKey(table, id);
+    const metadata = this.ttlMap.get(ttlKey);
+    if (!metadata) return -1;
+    const remainingMs = metadata.expiresAt - Date.now();
+    return remainingMs <= 0 ? -2 : Math.ceil(remainingMs / 1e3);
+  }
+  async cleanupExpiredIds(_table) {
+    return 0;
+  }
+};
+function createInMemoryAdapter() {
+  return new InMemoryAdapter();
+}
+
+// src/core/cache/lru-cache.ts
+var LRUCache = class {
+  cache;
+  maxEntries;
+  defaultTTL;
+  hits = 0;
+  misses = 0;
+  constructor(options) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxEntries = options?.maxEntries ?? 100;
+    this.defaultTTL = options?.defaultTTL ?? 60;
+  }
+  /**
+   * Get value from cache
+   * Returns null if not found or expired
+   * Moves entry to end (most recently used)
+   */
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      this.misses++;
+      return null;
+    }
+    if (entry.expires > 0 && entry.expires < Date.now()) {
+      this.cache.delete(key);
+      this.misses++;
+      return null;
+    }
+    this.cache.delete(key);
+    this.cache.set(key, entry);
+    this.hits++;
+    return entry.data;
+  }
+  /**
+   * Set value in cache
+   * Evicts oldest entry if max entries reached
+   * @param ttl TTL in seconds (0 = no expiration, undefined = use default)
+   */
+  set(key, data, ttl) {
+    this.cache.delete(key);
+    if (this.cache.size >= this.maxEntries) {
+      const oldestKey = this.cache.keys().next().value;
+      if (oldestKey) {
+        this.cache.delete(oldestKey);
+      }
+    }
+    const actualTTL = ttl ?? this.defaultTTL;
+    const expires = actualTTL > 0 ? Date.now() + actualTTL * 1e3 : 0;
+    this.cache.set(key, { data, expires });
+  }
+  /**
+   * Delete specific key
+   */
+  delete(key) {
+    return this.cache.delete(key);
+  }
+  /**
+   * Delete all keys matching prefix
+   * @returns Number of deleted entries
+   */
+  deleteByPrefix(prefix) {
+    let deleted = 0;
+    for (const key of this.cache.keys()) {
+      if (key.startsWith(prefix)) {
+        this.cache.delete(key);
+        deleted++;
+      }
+    }
+    return deleted;
+  }
+  /**
+   * Clear all entries
+   */
+  clear() {
+    this.cache.clear();
+  }
+  /**
+   * Check if key exists and is not expired
+   */
+  has(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return false;
+    if (entry.expires > 0 && entry.expires < Date.now()) {
+      this.cache.delete(key);
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Get current size
+   */
+  get size() {
+    return this.cache.size;
+  }
+  /**
+   * Get cache statistics
+   */
+  getStats() {
+    const total = this.hits + this.misses;
+    return {
+      hits: this.hits,
+      misses: this.misses,
+      hitRate: total > 0 ? this.hits / total : 0,
+      size: this.cache.size,
+      maxEntries: this.maxEntries
+    };
+  }
+  /**
+   * Reset statistics
+   */
+  resetStats() {
+    this.hits = 0;
+    this.misses = 0;
+  }
+  /**
+   * Prune expired entries
+   * Call periodically to clean up memory
+   */
+  prune() {
+    const now = Date.now();
+    let pruned = 0;
+    for (const [key, entry] of this.cache.entries()) {
+      if (entry.expires > 0 && entry.expires < now) {
+        this.cache.delete(key);
+        pruned++;
+      }
+    }
+    return pruned;
+  }
+};
+
+// src/core/cache/managed-cache.ts
+var ManagedCacheImpl = class {
+  constructor(name, options, onAddRules) {
+    this.name = name;
+    this.cache = new LRUCache({
+      maxEntries: options?.maxEntries,
+      defaultTTL: options?.defaultTTL
+    });
+    this.onAddRules = onAddRules;
+  }
+  cache;
+  onAddRules;
+  async get(key) {
+    return this.cache.get(key);
+  }
+  async set(key, value, ttl) {
+    this.cache.set(key, value, ttl);
+  }
+  async delete(key) {
+    return this.cache.delete(key);
+  }
+  async deleteByPrefix(prefix) {
+    return this.cache.deleteByPrefix(prefix);
+  }
+  async has(key) {
+    return this.cache.has(key);
+  }
+  async clear() {
+    this.cache.clear();
+  }
+  getStats() {
+    return this.cache.getStats();
+  }
+  resetStats() {
+    this.cache.resetStats();
+  }
+  addInvalidationRules(events) {
+    this.onAddRules?.(events);
+  }
+  async prune() {
+    return this.cache.prune();
+  }
+  async getSize() {
+    return this.cache.size;
+  }
+};
+
+// src/db/query-helpers.ts
+var DEFAULT_PAGE2 = 1;
+var DEFAULT_LIMIT2 = 20;
+var DEFAULT_MAX_LIMIT2 = 100;
+function getPagination(query) {
+  const maxLimit = query?.maxLimit ?? DEFAULT_MAX_LIMIT2;
+  const page = Math.max(1, query?.page ?? DEFAULT_PAGE2);
+  const limit = Math.min(maxLimit, Math.max(1, query?.limit ?? DEFAULT_LIMIT2));
+  const offset = (page - 1) * limit;
+  return { page, limit, offset };
+}
+function buildPaginatedResult(items, total, pagination) {
+  const { page, limit } = pagination;
+  const totalPages = Math.ceil(total / limit);
+  return {
+    items,
+    total,
+    page,
+    limit,
+    totalPages,
+    hasNext: page < totalPages
+  };
+}
+function getSearchableFields(definition) {
+  return Object.entries(definition.fields ?? {}).filter(([_, f]) => f.meta?.searchable === true).map(([name]) => name);
+}
+function applySearchFilter(qb, definition, search) {
+  const searchableFields = getSearchableFields(definition);
+  if (searchableFields.length === 0 && "labelField" in definition && definition.labelField) {
+    searchableFields.push(definition.labelField);
+  }
+  if (searchableFields.length > 0) {
+    const searchPattern = `%${search}%`;
+    qb.where(function() {
+      for (const field of searchableFields) {
+        this.orWhere(field, "like", searchPattern);
+      }
+    });
+  }
+  return qb;
+}
+
+// src/core/errors/error-codes.ts
+var ErrorCodes = {
+  // Auth
+  AUTH_INVALID_CREDENTIALS: "AUTH_INVALID_CREDENTIALS",
+  AUTH_TOKEN_EXPIRED: "AUTH_TOKEN_EXPIRED",
+  AUTH_TOKEN_INVALID: "AUTH_TOKEN_INVALID",
+  AUTH_TOKEN_REQUIRED: "AUTH_TOKEN_REQUIRED",
+  AUTH_OTP_REQUIRED: "AUTH_OTP_REQUIRED",
+  AUTH_OTP_INVALID: "AUTH_OTP_INVALID",
+  AUTH_REFRESH_TOKEN_REQUIRED: "AUTH_REFRESH_TOKEN_REQUIRED",
+  AUTH_REFRESH_TOKEN_INVALID: "AUTH_REFRESH_TOKEN_INVALID",
+  AUTH_REFRESH_TOKEN_EXPIRED: "AUTH_REFRESH_TOKEN_EXPIRED",
+  AUTH_SESSION_NOT_FOUND: "AUTH_SESSION_NOT_FOUND",
+  AUTH_SESSION_SELF_REVOKE: "AUTH_SESSION_SELF_REVOKE",
+  AUTH_VERIFICATION_CODE_INVALID: "AUTH_VERIFICATION_CODE_INVALID",
+  AUTH_REGISTRATION_DISABLED: "AUTH_REGISTRATION_DISABLED",
+  AUTH_AUTO_CREATE_DISABLED: "AUTH_AUTO_CREATE_DISABLED",
+  // User
+  USER_NOT_FOUND: "USER_NOT_FOUND",
+  USER_EMAIL_EXISTS: "USER_EMAIL_EXISTS",
+  USER_NOT_AUTHENTICATED: "USER_NOT_AUTHENTICATED",
+  // Role
+  ROLE_NOT_FOUND: "ROLE_NOT_FOUND",
+  ROLE_NAME_EXISTS: "ROLE_NAME_EXISTS",
+  ROLE_SYSTEM_PROTECTED: "ROLE_SYSTEM_PROTECTED",
+  ROLE_HAS_USERS: "ROLE_HAS_USERS",
+  ROLE_DEFAULT_NOT_FOUND: "ROLE_DEFAULT_NOT_FOUND",
+  // Permission
+  PERMISSION_DENIED: "PERMISSION_DENIED",
+  // Validation
+  VALIDATION_ERROR: "VALIDATION_ERROR",
+  VALIDATION_FIELD_REQUIRED: "VALIDATION_FIELD_REQUIRED",
+  VALIDATION_FIELD_INVALID: "VALIDATION_FIELD_INVALID",
+  VALIDATION_JSON_MALFORMED: "VALIDATION_JSON_MALFORMED",
+  // Storage
+  STORAGE_FILE_NOT_FOUND: "STORAGE_FILE_NOT_FOUND",
+  STORAGE_FILE_TOO_LARGE: "STORAGE_FILE_TOO_LARGE",
+  STORAGE_FILE_TYPE_NOT_ALLOWED: "STORAGE_FILE_TYPE_NOT_ALLOWED",
+  STORAGE_PAYLOAD_TOO_LARGE: "STORAGE_PAYLOAD_TOO_LARGE",
+  // Resource (generic)
+  RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
+  RESOURCE_CONFLICT: "RESOURCE_CONFLICT",
+  RESOURCE_CREATE_NOT_SUPPORTED: "RESOURCE_CREATE_NOT_SUPPORTED",
+  RESOURCE_UPDATE_NOT_SUPPORTED: "RESOURCE_UPDATE_NOT_SUPPORTED",
+  RESOURCE_DELETE_NOT_SUPPORTED: "RESOURCE_DELETE_NOT_SUPPORTED",
+  // Module
+  MODULE_NOT_FOUND: "MODULE_NOT_FOUND",
+  // HTTP standard
+  NOT_FOUND: "NOT_FOUND",
+  AUTH_UNAUTHORIZED: "AUTH_UNAUTHORIZED",
+  // Database
+  DB_CONSTRAINT_UNIQUE: "DB_CONSTRAINT_UNIQUE",
+  DB_CONSTRAINT_FK: "DB_CONSTRAINT_FK",
+  DB_CONNECTION_ERROR: "DB_CONNECTION_ERROR",
+  DATABASE_NOT_READY: "DATABASE_NOT_READY",
+  // System
+  SYSTEM_INTERNAL_ERROR: "SYSTEM_INTERNAL_ERROR"
+};
+
+// src/testing/test-helpers.ts
+var AppError = class extends Error {
+  constructor(message, statusCode = 500) {
+    super(message);
+    this.statusCode = statusCode;
+    this.name = "AppError";
+  }
+};
+var NotFoundError = class extends Error {
+  constructor(resource = "Resource") {
+    super(`${resource} not found`);
+    this.name = "NotFoundError";
+  }
+};
+var UnauthorizedError = class extends Error {
+  constructor(message = "Unauthorized") {
+    super(message);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends Error {
+  constructor(message = "Forbidden") {
+    super(message);
+    this.name = "ForbiddenError";
+  }
+};
+var ConflictError = class extends Error {
+  constructor(message = "Conflict") {
+    super(message);
+    this.name = "ConflictError";
+  }
+};
+var ValidationError = class extends Error {
+  details;
+  constructor(message = "Validation failed", details = []) {
+    super(message);
+    this.name = "ValidationError";
+    this.details = details;
+  }
+};
+function createMockQueryBuilder(data = []) {
+  const mockQb = {
+    _data: [...data],
+    _whereClauses: [],
+    _whereInClauses: [],
+    _whereNotInClauses: [],
+    _whereNotClauses: [],
+    _whereNullClauses: [],
+    _whereNotNullClauses: [],
+    _orderBy: null,
+    _limit: null,
+    _offset: null,
+    _insertData: null,
+    _updateData: null,
+    _deleted: false,
+    where(column, operatorOrValue, value) {
+      if (value !== void 0) {
+        mockQb._whereClauses = [...mockQb._whereClauses, { column, operator: operatorOrValue, value }];
+      } else {
+        mockQb._whereClauses = [...mockQb._whereClauses, { column, value: operatorOrValue }];
+      }
+      return mockQb;
+    },
+    whereNot(column, value) {
+      mockQb._whereNotClauses = [...mockQb._whereNotClauses, { column, value }];
+      return mockQb;
+    },
+    whereIn(column, values) {
+      mockQb._whereInClauses = [...mockQb._whereInClauses, { column, values }];
+      return mockQb;
+    },
+    whereNotIn(column, values) {
+      mockQb._whereNotInClauses = [...mockQb._whereNotInClauses, { column, values }];
+      return mockQb;
+    },
+    whereNull(column) {
+      mockQb._whereNullClauses = [...mockQb._whereNullClauses, column];
+      return mockQb;
+    },
+    whereNotNull(column) {
+      mockQb._whereNotNullClauses = [...mockQb._whereNotNullClauses, column];
+      return mockQb;
+    },
+    whereBetween() {
+      return mockQb;
+    },
+    orderBy(column, direction = "asc") {
+      mockQb._orderBy = { column, direction };
+      return mockQb;
+    },
+    limit(n) {
+      mockQb._limit = n;
+      return mockQb;
+    },
+    offset(n) {
+      mockQb._offset = n;
+      return mockQb;
+    },
+    select() {
+      return mockQb;
+    },
+    join() {
+      return mockQb;
+    },
+    leftJoin() {
+      return mockQb;
+    },
+    groupBy() {
+      return mockQb;
+    },
+    andWhere() {
+      return mockQb;
+    },
+    orWhere() {
+      return mockQb;
+    },
+    returning() {
+      return mockQb;
+    },
+    clone() {
+      return createMockQueryBuilder(mockQb._data);
+    },
+    count() {
+      return {
+        first: vi.fn().mockResolvedValue({ count: mockQb._data.length })
+      };
+    },
+    async first() {
+      let result = applyFilters(mockQb._data, mockQb);
+      if (mockQb._orderBy) {
+        const { column, direction } = mockQb._orderBy;
+        result = [...result].sort((a, b) => {
+          const aVal = String(a[column] ?? "");
+          const bVal = String(b[column] ?? "");
+          return direction === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+        });
+      }
+      return result[0] ?? void 0;
+    },
+    async insert(data2) {
+      mockQb._insertData = data2;
+      return [1];
+    },
+    async update(data2) {
+      mockQb._updateData = data2;
+      return 1;
+    },
+    async delete() {
+      mockQb._deleted = true;
+      return 1;
+    },
+    then(resolve) {
+      const filtered = applyFilters(mockQb._data, mockQb);
+      let result = filtered;
+      if (mockQb._orderBy) {
+        const { column, direction } = mockQb._orderBy;
+        result = [...result].sort((a, b) => {
+          const aVal = String(a[column] ?? "");
+          const bVal = String(b[column] ?? "");
+          return direction === "asc" ? aVal.localeCompare(bVal) : bVal.localeCompare(aVal);
+        });
+      }
+      if (mockQb._offset !== null) {
+        result = result.slice(mockQb._offset);
+      }
+      if (mockQb._limit !== null) {
+        result = result.slice(0, mockQb._limit);
+      }
+      resolve(result);
+    }
+  };
+  return mockQb;
+}
+function applyFilters(data, qb) {
+  let result = [...data];
+  for (const clause of qb._whereClauses) {
+    if (clause.operator) {
+      result = result.filter((item) => {
+        const itemVal = item[clause.column];
+        switch (clause.operator) {
+          case ">":
+            return itemVal > clause.value;
+          case ">=":
+            return itemVal >= clause.value;
+          case "<":
+            return itemVal < clause.value;
+          case "<=":
+            return itemVal <= clause.value;
+          case "like": {
+            const pattern = String(clause.value);
+            const str = String(itemVal ?? "");
+            if (pattern.startsWith("%") && pattern.endsWith("%"))
+              return str.toLowerCase().includes(pattern.slice(1, -1).toLowerCase());
+            if (pattern.startsWith("%"))
+              return str.toLowerCase().endsWith(pattern.slice(1).toLowerCase());
+            if (pattern.endsWith("%"))
+              return str.toLowerCase().startsWith(pattern.slice(0, -1).toLowerCase());
+            return str === pattern;
+          }
+          default:
+            return itemVal === clause.value;
+        }
+      });
+    } else {
+      result = result.filter((item) => item[clause.column] === clause.value);
+    }
+  }
+  for (const clause of qb._whereNotClauses) {
+    result = result.filter((item) => item[clause.column] !== clause.value);
+  }
+  for (const clause of qb._whereInClauses) {
+    result = result.filter((item) => clause.values.includes(item[clause.column]));
+  }
+  for (const clause of qb._whereNotInClauses) {
+    result = result.filter((item) => !clause.values.includes(item[clause.column]));
+  }
+  for (const column of qb._whereNullClauses) {
+    result = result.filter((item) => item[column] === null || item[column] === void 0);
+  }
+  for (const column of qb._whereNotNullClauses) {
+    result = result.filter((item) => item[column] !== null && item[column] !== void 0);
+  }
+  return result;
+}
+function createMockDb(tableData = {}) {
+  const mockDb = vi.fn((table) => {
+    return createMockQueryBuilder(tableData[table] ?? []);
+  });
+  mockDb["schema"] = {
+    hasTable: vi.fn().mockResolvedValue(false),
+    createTable: vi.fn().mockResolvedValue(void 0)
+  };
+  mockDb["raw"] = vi.fn().mockReturnValue({
+    then: (resolve) => resolve([])
+  });
+  mockDb["transaction"] = vi.fn().mockImplementation(async (callback) => {
+    const trxMock = vi.fn((table) => {
+      return createMockQueryBuilder(tableData[table] ?? []);
+    });
+    await callback(trxMock);
+  });
+  return mockDb;
+}
+function createMockDbContext(tableData = {}) {
+  const mockKnex = createMockDb(tableData);
+  return {
+    knex: mockKnex,
+    adapter: {
+      findMany: vi.fn().mockResolvedValue({ items: [], total: 0, page: 1, limit: 20, totalPages: 0, hasNext: false }),
+      findOne: vi.fn().mockResolvedValue(null),
+      findById: vi.fn().mockResolvedValue(null),
+      count: vi.fn().mockResolvedValue(0),
+      insert: vi.fn().mockResolvedValue({}),
+      update: vi.fn().mockResolvedValue({}),
+      delete: vi.fn().mockResolvedValue(true),
+      transaction: vi.fn().mockImplementation(async (fn) => fn({}))
+    },
+    schema: {
+      hasTable: vi.fn().mockResolvedValue(false),
+      hasColumn: vi.fn().mockResolvedValue(false),
+      getColumns: vi.fn().mockResolvedValue([]),
+      createTable: vi.fn().mockResolvedValue(void 0),
+      alterTable: vi.fn().mockResolvedValue(void 0),
+      dropTable: vi.fn().mockResolvedValue(void 0),
+      addTimestamps: vi.fn().mockResolvedValue(void 0),
+      addAuditFields: vi.fn().mockResolvedValue(void 0),
+      addColumnIfMissing: vi.fn().mockResolvedValue(false),
+      raw: {}
+    },
+    t: (name) => name,
+    addTimestamps: vi.fn(),
+    addAuditFieldsIfMissing: vi.fn(),
+    addSoftDeleteFieldIfMissing: vi.fn(),
+    addConfigDefaultField: vi.fn(),
+    addColumnIfMissing: vi.fn(),
+    nowTimestamp: () => (/* @__PURE__ */ new Date()).toISOString(),
+    formatTimestamp: (_db, date) => (date ?? /* @__PURE__ */ new Date()).toISOString(),
+    applySearchFilter,
+    getPagination,
+    buildPaginatedResult,
+    getSearchableFields
+  };
+}
+function createMockContext(overrides = {}) {
+  let idCounter = 0;
+  const { pluginCode, ...rest } = overrides;
+  const t = pluginCode ? (name) => `${pluginCode}_${name}` : (name) => name;
+  const services = {};
+  const tempAdapter = createInMemoryAdapter();
+  const adapters = {
+    temp: { data: tempAdapter }
+  };
+  let processedOverrides = { ...rest };
+  if (rest.db && typeof rest.db === "function") {
+    const knexMock = rest.db;
+    processedOverrides = {
+      ...rest,
+      db: {
+        knex: knexMock,
+        adapter: {
+          findMany: vi.fn().mockResolvedValue({ items: [], total: 0, page: 1, limit: 20, totalPages: 0, hasNext: false }),
+          findOne: vi.fn().mockResolvedValue(null),
+          findById: vi.fn().mockResolvedValue(null),
+          count: vi.fn().mockResolvedValue(0),
+          insert: vi.fn().mockResolvedValue({}),
+          update: vi.fn().mockResolvedValue({}),
+          delete: vi.fn().mockResolvedValue(true),
+          transaction: vi.fn().mockImplementation(async (fn) => fn({}))
+        },
+        schema: {
+          hasTable: vi.fn().mockResolvedValue(false),
+          hasColumn: vi.fn().mockResolvedValue(false),
+          getColumns: vi.fn().mockResolvedValue([]),
+          createTable: vi.fn().mockResolvedValue(void 0),
+          alterTable: vi.fn().mockResolvedValue(void 0),
+          dropTable: vi.fn().mockResolvedValue(void 0),
+          addTimestamps: vi.fn().mockResolvedValue(void 0),
+          addAuditFields: vi.fn().mockResolvedValue(void 0),
+          addColumnIfMissing: vi.fn().mockResolvedValue(false),
+          raw: {}
+        },
+        t,
+        addTimestamps: vi.fn(),
+        addAuditFieldsIfMissing: vi.fn(),
+        addSoftDeleteFieldIfMissing: vi.fn(),
+        addConfigDefaultField: vi.fn(),
+        addColumnIfMissing: vi.fn(),
+        nowTimestamp: () => (/* @__PURE__ */ new Date()).toISOString(),
+        formatTimestamp: (_db, date) => (date ?? /* @__PURE__ */ new Date()).toISOString(),
+        applySearchFilter,
+        getPagination,
+        buildPaginatedResult,
+        getSearchableFields,
+        getKnex: () => knexMock,
+        // Legacy: ctx.db.raw → now ctx.db.knex.raw
+        raw: knexMock.raw
+      }
+    };
+  }
+  const mockKnex = createMockDb();
+  const mockLogger = {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+    trace: vi.fn(),
+    fatal: vi.fn(),
+    child: vi.fn().mockReturnThis()
+  };
+  const mockSchemaAdapter = {
+    hasTable: vi.fn().mockResolvedValue(false),
+    hasColumn: vi.fn().mockResolvedValue(false),
+    getColumns: vi.fn().mockResolvedValue([]),
+    createTable: vi.fn().mockResolvedValue(void 0),
+    alterTable: vi.fn().mockResolvedValue(void 0),
+    dropTable: vi.fn().mockResolvedValue(void 0),
+    addTimestamps: vi.fn().mockResolvedValue(void 0),
+    addAuditFields: vi.fn().mockResolvedValue(void 0),
+    addColumnIfMissing: vi.fn().mockResolvedValue(false),
+    raw: {}
+  };
+  const mockDbAdapter = {
+    findMany: vi.fn().mockResolvedValue({ items: [], total: 0, page: 1, limit: 20, totalPages: 0, hasNext: false }),
+    findOne: vi.fn().mockResolvedValue(null),
+    findById: vi.fn().mockResolvedValue(null),
+    count: vi.fn().mockResolvedValue(0),
+    insert: vi.fn().mockResolvedValue({}),
+    update: vi.fn().mockResolvedValue({}),
+    delete: vi.fn().mockResolvedValue(true),
+    transaction: vi.fn().mockImplementation(async (fn) => fn({}))
+  };
+  return {
+    // =========================================================================
+    // Core Context: logger, errors, crypto, socket, events, middleware
+    // =========================================================================
+    core: {
+      logger: mockLogger,
+      errors: {
+        AppError,
+        NotFoundError,
+        UnauthorizedError,
+        ForbiddenError,
+        ConflictError,
+        ValidationError,
+        codes: ErrorCodes
+      },
+      crypto: {
+        hashPassword: vi.fn().mockResolvedValue("$2b$12$mockhash"),
+        verifyPassword: vi.fn().mockResolvedValue(true),
+        DUMMY_HASH: "$2b$12$dummyhashfordummypasswordcheck"
+      },
+      socket: {
+        getIO: vi.fn().mockReturnValue({}),
+        isInitialized: vi.fn().mockReturnValue(false),
+        isUserConnected: vi.fn().mockReturnValue(false),
+        getUserSocketCount: vi.fn().mockReturnValue(0),
+        getConnectedUsers: vi.fn().mockReturnValue([])
+      },
+      sse: {
+        sendEvent: vi.fn(),
+        close: vi.fn()
+      },
+      abilities: {},
+      events: {
+        emit: vi.fn(),
+        emitEvent: vi.fn(),
+        emitAsync: vi.fn().mockResolvedValue(void 0),
+        on: vi.fn(),
+        off: vi.fn()
+      },
+      middleware: {},
+      createRouter: vi.fn(),
+      generateId: () => `test-id-${++idCounter}`,
+      generateIdByType: (type) => {
+        if (type === "auto" || type === "custom" || type === "pattern") return void 0;
+        return `test-id-${++idCounter}`;
+      },
+      getLibPath: () => "/tmp",
+      getProjectPath: () => "/tmp",
+      cache: (() => {
+        const caches = /* @__PURE__ */ new Map();
+        return {
+          create: vi.fn().mockImplementation((name, opts) => {
+            const cache = new ManagedCacheImpl(name, opts);
+            caches.set(name, cache);
+            return cache;
+          }),
+          getOrCreate: vi.fn().mockImplementation((name, opts) => {
+            if (caches.has(name)) return caches.get(name);
+            const cache = new ManagedCacheImpl(name, opts);
+            caches.set(name, cache);
+            return cache;
+          }),
+          get: vi.fn().mockImplementation((name) => caches.get(name)),
+          clearAll: vi.fn(),
+          stats: vi.fn().mockReturnValue({}),
+          destroy: vi.fn()
+        };
+      })(),
+      safeJsonParse: (jsonString, fallback) => {
+        try {
+          return JSON.parse(jsonString);
+        } catch {
+          return fallback;
+        }
+      }
+    },
+    // =========================================================================
+    // Database Context: knex, adapter, schema, helper functions
+    // =========================================================================
+    db: {
+      knex: mockKnex,
+      adapter: mockDbAdapter,
+      schema: mockSchemaAdapter,
+      t,
+      addTimestamps: vi.fn(),
+      addAuditFieldsIfMissing: vi.fn(),
+      addSoftDeleteFieldIfMissing: vi.fn(),
+      addConfigDefaultField: vi.fn(),
+      addColumnIfMissing: vi.fn(),
+      nowTimestamp: () => (/* @__PURE__ */ new Date()).toISOString(),
+      formatTimestamp: (_db, date) => (date ?? /* @__PURE__ */ new Date()).toISOString(),
+      applySearchFilter,
+      getPagination,
+      buildPaginatedResult,
+      getSearchableFields,
+      getKnex: () => mockKnex,
+      // Legacy: ctx.db.raw → now ctx.db.knex.raw
+      raw: mockKnex.raw
+    },
+    // =========================================================================
+    // Runtime Context: entity service/controller/router factories
+    // =========================================================================
+    runtime: {
+      createEntityService: vi.fn(),
+      createEntityController: vi.fn(),
+      createEntityRouter: vi.fn()
+    },
+    // =========================================================================
+    // Config Context: env vars and resolved NexusConfig
+    // =========================================================================
+    config: {},
+    // =========================================================================
+    // Engine Context: module/plugin introspection
+    // =========================================================================
+    engine: {
+      getModules: vi.fn().mockReturnValue([]),
+      getPlugins: vi.fn().mockReturnValue([]),
+      getModuleSubjects: vi.fn().mockReturnValue([]),
+      getRegisteredSubjects: vi.fn().mockReturnValue([])
+    },
+    // =========================================================================
+    // Services Context: inter-module service registry
+    // =========================================================================
+    services: {
+      register(name, service) {
+        services[name] = service;
+      },
+      get(serviceName) {
+        const service = services[serviceName];
+        if (!service) {
+          throw new Error(`Service "${serviceName}" not initialized.`);
+        }
+        return service;
+      },
+      getOptional(serviceName) {
+        return services[serviceName];
+      },
+      has(serviceName) {
+        return !!services[serviceName];
+      }
+    },
+    // =========================================================================
+    // Adapters Context: external data source adapters
+    // =========================================================================
+    adapters: {
+      register(name, dataAdapter, schemaAdapter) {
+        adapters[name] = { data: dataAdapter, schema: schemaAdapter };
+      },
+      get(name) {
+        const pair = adapters[name];
+        if (!pair) {
+          throw new Error(`Adapter "${name}" not found`);
+        }
+        return pair.data;
+      },
+      getSchema(name) {
+        const pair = adapters[name];
+        return pair?.schema;
+      },
+      has(name) {
+        return name in adapters;
+      }
+    },
+    // =========================================================================
+    // Root-level shortcut
+    // =========================================================================
+    createRouter: vi.fn(),
+    // Semantic events API (NEX-161)
+    events: {
+      notify: vi.fn(),
+      query: vi.fn().mockResolvedValue([]),
+      command: vi.fn().mockResolvedValue(void 0),
+      on: vi.fn(),
+      off: vi.fn(),
+      once: vi.fn(),
+      onAny: vi.fn()
+    },
+    // =========================================================================
+    // Legacy API compatibility - deprecated, use new API instead
+    // =========================================================================
+    // Legacy: ctx.logger → now ctx.core.logger
+    logger: mockLogger,
+    // Legacy: ctx.errors → now ctx.core.errors
+    errors: {
+      AppError,
+      NotFoundError,
+      UnauthorizedError,
+      ForbiddenError,
+      ConflictError,
+      ValidationError,
+      codes: ErrorCodes
+    },
+    // Legacy: ctx.registerService → now ctx.services.register
+    registerService(name, service) {
+      services[name] = service;
+    },
+    getService(serviceName) {
+      const service = services[serviceName];
+      if (!service) {
+        throw new Error(`Service "${serviceName}" not initialized.`);
+      }
+      return service;
+    },
+    getOptionalService(serviceName) {
+      return services[serviceName];
+    },
+    hasService(serviceName) {
+      return !!services[serviceName];
+    },
+    registerAdapter(name, dataAdapter, schemaAdapter) {
+      adapters[name] = { data: dataAdapter, schema: schemaAdapter };
+    },
+    getAdapter(name) {
+      const pair = adapters[name];
+      if (!pair) {
+        throw new Error(`Adapter "${name}" not found`);
+      }
+      return pair.data;
+    },
+    hasAdapter(name) {
+      return name in adapters;
+    },
+    ...processedOverrides
+  };
+}
+function createCollectionDefinition(overrides = {}) {
+  return {
+    type: "collection",
+    table: "test_items",
+    label: "Test Items",
+    labelField: "name",
+    timestamps: true,
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      name: {
+        label: "Name",
+        input: "text",
+        db: { type: "string", size: 100, nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createSingleDefinition(overrides = {}) {
+  return {
+    type: "single",
+    key: "test_settings",
+    label: "Test Settings",
+    defaults: { theme: "light", language: "en" },
+    fields: {
+      theme: {
+        label: "Theme",
+        input: "select",
+        db: { type: "string", size: 20, nullable: false }
+      },
+      language: {
+        label: "Language",
+        input: "select",
+        db: { type: "string", size: 10, nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createReferenceDefinition(overrides = {}) {
+  return {
+    type: "collection",
+    table: "ref_countries",
+    label: "Countries",
+    labelField: "name",
+    seed: [
+      { id: "ES", code: "ES", name: "Spain" },
+      { id: "US", code: "US", name: "United States" },
+      { id: "MX", code: "MX", name: "Mexico" }
+    ],
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 10, nullable: false }
+      },
+      code: {
+        label: "Code",
+        input: "text",
+        db: { type: "string", size: 10, nullable: false }
+      },
+      name: {
+        label: "Name",
+        input: "text",
+        db: { type: "string", size: 100, nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createEventDefinition(overrides = {}) {
+  return {
+    type: "event",
+    table: "evt_audit_logs",
+    label: "Audit Logs",
+    labelField: "action",
+    immutable: true,
+    defaultSort: { field: "created_at", order: "desc" },
+    retention: { days: 90, maxRows: 1e4 },
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      action: {
+        label: "Action",
+        input: "text",
+        db: { type: "string", size: 50, nullable: false }
+      },
+      user_id: {
+        label: "User",
+        input: "text",
+        db: { type: "string", size: 26, nullable: true }
+      },
+      created_at: {
+        label: "Created At",
+        input: "datetime",
+        db: { type: "datetime", nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createConfigDefinition(overrides = {}) {
+  return {
+    type: "config",
+    key: "cfg_module_settings",
+    label: "Module Settings",
+    scopeField: "module_name",
+    defaults: { enabled: true, maxItems: 100 },
+    fields: {
+      module_name: {
+        label: "Module",
+        input: "text",
+        db: { type: "string", size: 50, nullable: false }
+      },
+      enabled: {
+        label: "Enabled",
+        input: "checkbox",
+        db: { type: "boolean", nullable: false }
+      },
+      maxItems: {
+        label: "Max Items",
+        input: "number",
+        db: { type: "integer", nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createTempDefinition(overrides = {}) {
+  return {
+    type: "temp",
+    table: "tmp_sessions",
+    label: "Sessions",
+    labelField: "token",
+    retention: { seconds: 3600, expiresField: "expires_at" },
+    // 1 hour
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      token: {
+        label: "Token",
+        input: "text",
+        db: { type: "string", size: 256, nullable: false }
+      },
+      expires_at: {
+        label: "Expires At",
+        input: "datetime",
+        db: { type: "datetime", nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createViewDefinition(overrides = {}) {
+  return {
+    type: "view",
+    table: "vw_user_stats",
+    label: "User Stats",
+    labelField: "user_id",
+    query: "SELECT user_id, COUNT(*) as count FROM posts GROUP BY user_id",
+    fields: {
+      user_id: {
+        label: "User",
+        input: "text",
+        db: { type: "string", size: 26, nullable: false }
+      },
+      count: {
+        label: "Count",
+        input: "number",
+        db: { type: "integer", nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createExternalDefinition(overrides = {}) {
+  return {
+    type: "external",
+    adapter: "test-api",
+    table: "external_items",
+    // Resource ID in external system
+    label: "External Items",
+    labelField: "title",
+    cache: { ttl: 300 },
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      title: {
+        label: "Title",
+        input: "text",
+        db: { type: "string", size: 200, nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createVirtualDefinition(overrides = {}) {
+  return createComputedDefinition({
+    sources: ["source_a", "source_b"],
+    resolver: (sources) => {
+      const combined = [
+        ...sources["source_a"] ?? [],
+        ...sources["source_b"] ?? []
+      ];
+      return combined;
+    },
+    compute: void 0,
+    ...overrides
+  });
+}
+function createComputedDefinition(overrides = {}) {
+  return {
+    type: "computed",
+    label: "Computed Stats",
+    compute: vi.fn().mockResolvedValue([
+      { id: "1", metric: "users", value: 100 },
+      { id: "2", metric: "posts", value: 500 }
+    ]),
+    cache: { ttl: 60 },
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      metric: {
+        label: "Metric",
+        input: "text",
+        db: { type: "string", size: 50, nullable: false }
+      },
+      value: {
+        label: "Value",
+        input: "number",
+        db: { type: "integer", nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createMockDatabaseAdapter(overrides = {}) {
+  return {
+    findMany: vi.fn().mockResolvedValue({
+      items: [
+        { id: "ext-1", title: "External Item 1" },
+        { id: "ext-2", title: "External Item 2" }
+      ],
+      total: 2,
+      page: 1,
+      limit: 20,
+      totalPages: 1,
+      hasNext: false
+    }),
+    findOne: vi.fn().mockResolvedValue(null),
+    findById: vi.fn().mockResolvedValue({ id: "ext-1", title: "External Item 1" }),
+    count: vi.fn().mockResolvedValue(2),
+    insert: vi.fn().mockResolvedValue({ id: "ext-new", title: "Created" }),
+    update: vi.fn().mockResolvedValue({ id: "ext-1", title: "Updated" }),
+    delete: vi.fn().mockResolvedValue(true),
+    transaction: vi.fn().mockImplementation(async (fn) => fn({})),
+    raw: vi.fn().mockResolvedValue([]),
+    ...overrides
+  };
+}
+function createTreeDefinition(overrides = {}) {
+  return {
+    type: "tree",
+    table: "tree_categories",
+    label: "Categories",
+    labelField: "name",
+    timestamps: true,
+    seed: [
+      { id: "root", name: "Root Category", parent_id: null }
+    ],
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      name: {
+        label: "Name",
+        input: "text",
+        db: { type: "string", size: 100, nullable: false }
+      }
+      // parent_id is auto-injected by TreeService
+    },
+    ...overrides
+  };
+}
+function createDagDefinition(overrides = {}) {
+  return {
+    type: "dag",
+    table: "dag_tags",
+    label: "Tags",
+    labelField: "name",
+    timestamps: true,
+    seed: [
+      { id: "root", name: "Root Tag" }
+    ],
+    fields: {
+      id: {
+        label: "ID",
+        input: "text",
+        hidden: true,
+        db: { type: "string", size: 26, nullable: false }
+      },
+      name: {
+        label: "Name",
+        input: "text",
+        db: { type: "string", size: 100, nullable: false }
+      }
+    },
+    ...overrides
+  };
+}
+function createActionDefinition(overrides = {}) {
+  return {
+    key: "test_action",
+    label: "Test Action",
+    scope: "row",
+    method: "POST",
+    handler: async () => ({ success: true }),
+    ...overrides
+  };
+}
+
+// src/testing/core-tables.ts
+async function createCoreTables(db) {
+  if (!await db.schema.hasTable("users")) {
+    await db.schema.createTable("users", (t) => {
+      t.string("id", 26).primary();
+      t.string("name", 100).notNullable();
+      t.string("email", 255).notNullable();
+      t.string("role", 20).notNullable().defaultTo("user");
+      t.timestamps(true, true);
+    });
+  }
+  if (!await db.schema.hasTable("roles")) {
+    await db.schema.createTable("roles", (t) => {
+      t.string("id", 26).primary();
+      t.string("name", 50).notNullable();
+    });
+  }
+}
+
+// src/core/errors/app-error.ts
+var AppError2 = class extends Error {
+  statusCode;
+  code;
+  interpolation;
+  details;
+  constructor(params, statusCode = 400, details) {
+    if (typeof params === "string") {
+      super(params);
+      this.code = ErrorCodes.SYSTEM_INTERNAL_ERROR;
+    } else {
+      super(params.message || params.code);
+      this.code = params.code;
+      this.interpolation = params.interpolation;
+    }
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "AppError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+};
+var NotFoundError2 = class extends AppError2 {
+  constructor(resource = "Resource") {
+    super({
+      code: ErrorCodes.RESOURCE_NOT_FOUND,
+      message: `${resource} not found`,
+      interpolation: { resource }
+    }, 404);
+    this.name = "NotFoundError";
+  }
+};
+var UnauthorizedError2 = class extends AppError2 {
+  constructor(codeOrMessage = ErrorCodes.AUTH_TOKEN_REQUIRED, message) {
+    const isCode = Object.values(ErrorCodes).includes(codeOrMessage);
+    if (isCode) {
+      super({
+        code: codeOrMessage,
+        message: message || "Unauthorized"
+      }, 401);
+    } else {
+      super({
+        code: ErrorCodes.AUTH_TOKEN_REQUIRED,
+        message: codeOrMessage
+      }, 401);
+    }
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError2 = class extends AppError2 {
+  constructor(codeOrMessage = ErrorCodes.PERMISSION_DENIED, message) {
+    const isCode = Object.values(ErrorCodes).includes(codeOrMessage);
+    if (isCode) {
+      super({
+        code: codeOrMessage,
+        message: message || "Access denied"
+      }, 403);
+    } else {
+      super({
+        code: ErrorCodes.PERMISSION_DENIED,
+        message: codeOrMessage
+      }, 403);
+    }
+    this.name = "ForbiddenError";
+  }
+};
+var ConflictError2 = class extends AppError2 {
+  constructor(codeOrMessage = ErrorCodes.RESOURCE_CONFLICT, message) {
+    const isCode = Object.values(ErrorCodes).includes(codeOrMessage);
+    if (isCode) {
+      super({
+        code: codeOrMessage,
+        message: message || "Conflict"
+      }, 409);
+    } else {
+      super({
+        code: ErrorCodes.RESOURCE_CONFLICT,
+        message: codeOrMessage
+      }, 409);
+    }
+    this.name = "ConflictError";
+  }
+};
+var ValidationError2 = class extends AppError2 {
+  details;
+  constructor(messageOrCode = ErrorCodes.VALIDATION_ERROR, details = []) {
+    const isCode = Object.values(ErrorCodes).includes(messageOrCode);
+    if (isCode) {
+      super({
+        code: messageOrCode,
+        message: "Validation error"
+      }, 400);
+    } else {
+      super({
+        code: ErrorCodes.VALIDATION_ERROR,
+        message: messageOrCode
+      }, 400);
+    }
+    this.name = "ValidationError";
+    this.details = details;
+  }
+};
+
+// src/testing/test-db.ts
+import knex from "knex";
+function createTestDb() {
+  return knex({
+    client: "better-sqlite3",
+    connection: ":memory:",
+    useNullAsDefault: true
+  });
+}
+export {
+  AppError2 as AppError,
+  ConflictError2 as ConflictError,
+  ErrorCodes,
+  ForbiddenError2 as ForbiddenError,
+  NotFoundError2 as NotFoundError,
+  UnauthorizedError2 as UnauthorizedError,
+  ValidationError2 as ValidationError,
+  createActionDefinition,
+  createCollectionDefinition,
+  createComputedDefinition,
+  createConfigDefinition,
+  createCoreTables,
+  createDagDefinition,
+  createEventDefinition,
+  createExternalDefinition,
+  createMockContext,
+  createMockDatabaseAdapter,
+  createMockDb,
+  createMockDbContext,
+  createMockQueryBuilder,
+  createReferenceDefinition,
+  createSingleDefinition,
+  createTempDefinition,
+  createTestDb,
+  createTreeDefinition,
+  createViewDefinition,
+  createVirtualDefinition
+};
+//# sourceMappingURL=index.js.map