@open-mercato/shared 0.6.1-develop.3276.1.1fcd145078 → 0.6.1-develop.3278.1.a4d26475e4

package/dist/lib/query/join-utils.js

@@ -1,83 +1,129 @@
 import { sql } from "kysely";
+const VALID_OPS = ["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike", "exists"];
+const normalizeField = (key) => key.startsWith("cf_") ? `cf:${key.slice(3)}` : key;
+const MAX_DNF_DISJUNCTS = 1e3;
+class AdvancedFilterComplexityError extends Error {
+  constructor(disjunctCount) {
+    super(
+      `Advanced filter expanded to ${disjunctCount} disjuncts, exceeding the limit of ${MAX_DNF_DISJUNCTS}. Reduce the number of OR branches or simplify nested groups.`
+    );
+    this.code = "ADVANCED_FILTER_TOO_COMPLEX";
+    this.name = "AdvancedFilterComplexityError";
+    this.disjunctCount = disjunctCount;
+  }
+}
+function compileToDnf(filter) {
+  if (filter === null || filter === void 0) return [[]];
+  if (Array.isArray(filter) || typeof filter !== "object") return [[]];
+  const obj = filter;
+  const partialDnfs = [];
+  for (const [rawKey, rawVal] of Object.entries(obj)) {
+    if (rawKey === "$and" && Array.isArray(rawVal)) {
+      partialDnfs.push(cartesianAnd(rawVal.map(compileToDnf)));
+      continue;
+    }
+    if (rawKey === "$or" && Array.isArray(rawVal)) {
+      const expanded = rawVal.flatMap(compileToDnf);
+      if (expanded.length > MAX_DNF_DISJUNCTS) {
+        throw new AdvancedFilterComplexityError(expanded.length);
+      }
+      partialDnfs.push(expanded);
+      continue;
+    }
+    const field = normalizeField(rawKey);
+    if (rawVal !== null && typeof rawVal === "object" && !Array.isArray(rawVal)) {
+      const clauses = [];
+      for (const [opKey, opVal] of Object.entries(rawVal)) {
+        const op = opKey.startsWith("$") ? opKey.slice(1) : opKey;
+        if (VALID_OPS.includes(op)) {
+          clauses.push({ field, op, value: opVal });
+        }
+      }
+      if (clauses.length > 0) partialDnfs.push([clauses]);
+    } else {
+      partialDnfs.push([[{ field, op: "eq", value: rawVal }]]);
+    }
+  }
+  return cartesianAnd(partialDnfs);
+}
+function cartesianAnd(dnfs) {
+  if (dnfs.length === 0) return [[]];
+  let result = [[]];
+  for (const dnf of dnfs) {
+    if (dnf.length === 0) {
+      return [];
+    }
+    const projected = result.length * dnf.length;
+    if (projected > MAX_DNF_DISJUNCTS) {
+      throw new AdvancedFilterComplexityError(projected);
+    }
+    const next = [];
+    for (const left of result) {
+      for (const right of dnf) {
+        next.push([...left, ...right]);
+      }
+    }
+    result = next;
+  }
+  return result;
+}
+function clauseKey(c) {
+  return JSON.stringify([c.field, c.op, c.value]);
+}
+function liftCommonClauses(dnf) {
+  if (dnf.length <= 1) return { common: [], remaining: dnf };
+  const counts = /* @__PURE__ */ new Map();
+  for (const disjunct of dnf) {
+    const seen = /* @__PURE__ */ new Set();
+    for (const c of disjunct) {
+      const key = clauseKey(c);
+      if (seen.has(key)) continue;
+      seen.add(key);
+      const entry = counts.get(key);
+      if (entry) entry.count += 1;
+      else counts.set(key, { clause: c, count: 1 });
+    }
+  }
+  const total = dnf.length;
+  const commonKeys = /* @__PURE__ */ new Set();
+  const common = [];
+  for (const [key, { clause, count }] of counts) {
+    if (count === total) {
+      commonKeys.add(key);
+      common.push(clause);
+    }
+  }
+  if (common.length === 0) return { common: [], remaining: dnf };
+  const remaining = dnf.map((d) => d.filter((c) => !commonKeys.has(clauseKey(c))));
+  return { common, remaining };
+}
 function normalizeFilters(filters) {
   if (!filters) return [];
-  const normalizeField = (key) => key.startsWith("cf_") ? `cf:${key.slice(3)}` : key;
   if (Array.isArray(filters)) {
     return filters.map((f) => ({
       ...f,
       field: normalizeField(String(f.field))
     }));
   }
+  const dnf = compileToDnf(filters);
+  if (dnf.length === 0) return [];
+  const nonEmpty = dnf.filter((disjunct) => disjunct.length > 0);
+  if (nonEmpty.length === 0) return [];
+  if (nonEmpty.length === 1) {
+    return nonEmpty[0].map((c) => ({ field: c.field, op: c.op, value: c.value }));
+  }
+  const { common, remaining } = liftCommonClauses(nonEmpty);
   const out = [];
-  const obj = filters;
-  const push = (field, op, value, orGroup) => {
-    out.push({ field, op, value, orGroup });
-  };
-  if (Array.isArray(obj.$or)) {
-    const clauses = obj.$or;
-    for (let clauseIndex = 0; clauseIndex < clauses.length; clauseIndex++) {
-      const clause = clauses[clauseIndex];
-      const orGroupId = `or_${clauseIndex}`;
-      if (clause && typeof clause === "object") {
-        for (const [rawKey, rawVal] of Object.entries(clause)) {
-          const field = normalizeField(rawKey);
-          if (rawVal !== null && typeof rawVal === "object" && !Array.isArray(rawVal)) {
-            for (const [opKey, opVal] of Object.entries(rawVal)) {
-              const op = opKey.replace("$", "");
-              if (["eq", "ne", "gt", "gte", "lt", "lte", "in", "nin", "like", "ilike", "exists"].includes(op)) {
-                push(field, op, opVal, orGroupId);
-              }
-            }
-          } else {
-            push(field, "eq", rawVal, orGroupId);
-          }
-        }
-      }
-    }
+  for (const c of common) out.push({ field: c.field, op: c.op, value: c.value });
+  const remainingNonEmpty = remaining.filter((d) => d.length > 0);
+  if (remainingNonEmpty.length === 0) return out;
+  if (remainingNonEmpty.length === 1) {
+    for (const c of remainingNonEmpty[0]) out.push({ field: c.field, op: c.op, value: c.value });
+    return out;
   }
-  for (const [rawKey, rawVal] of Object.entries(obj)) {
-    if (rawKey === "$or") continue;
-    const field = normalizeField(rawKey);
-    if (rawVal !== null && typeof rawVal === "object" && !Array.isArray(rawVal)) {
-      for (const [opKey, opVal] of Object.entries(rawVal)) {
-        switch (opKey) {
-          case "$eq":
-            push(field, "eq", opVal);
-            break;
-          case "$ne":
-            push(field, "ne", opVal);
-            break;
-          case "$gt":
-            push(field, "gt", opVal);
-            break;
-          case "$gte":
-            push(field, "gte", opVal);
-            break;
-          case "$lt":
-            push(field, "lt", opVal);
-            break;
-          case "$lte":
-            push(field, "lte", opVal);
-            break;
-          case "$in":
-            push(field, "in", opVal);
-            break;
-          case "$nin":
-            push(field, "nin", opVal);
-            break;
-          case "$like":
-            push(field, "like", opVal);
-            break;
-          case "$ilike":
-            push(field, "ilike", opVal);
-            break;
-          case "$exists":
-            push(field, "exists", opVal);
-            break;
-        }
-      }
-    } else {
-      push(field, "eq", rawVal);
+  for (let i = 0; i < remainingNonEmpty.length; i++) {
+    for (const c of remainingNonEmpty[i]) {
+      out.push({ field: c.field, op: c.op, value: c.value, orGroup: `or_${i}` });
     }
   }
   return out;
@@ -229,6 +275,8 @@ async function applyJoinFilters({
   return nextBuilder;
 }
 export {
+  AdvancedFilterComplexityError,
+  MAX_DNF_DISJUNCTS,
   applyJoinFilters,
   buildJoinChain,
   normalizeFilters,

package/dist/lib/query/join-utils.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../src/lib/query/join-utils.ts"],
-  "sourcesContent": ["import type { Kysely } from 'kysely'\nimport { sql } from 'kysely'\nimport type { QueryOptions, QueryJoinEdge } from './types'\nimport type { FilterOp } from './types'\n\ntype AnyBuilder = any\n\nexport type NormalizedFilter = { field: string; op: FilterOp; value?: unknown; orGroup?: string; qualified?: string | null }\n\nexport function normalizeFilters(filters?: QueryOptions['filters']): NormalizedFilter[] {\n  if (!filters) return []\n  const normalizeField = (key: string) => (key.startsWith('cf_') ? `cf:${key.slice(3)}` : key)\n  if (Array.isArray(filters)) {\n    return (filters as any[]).map((f) => ({\n      ...f,\n      field: normalizeField(String((f as any).field)),\n    }))\n  }\n  const out: NormalizedFilter[] = []\n  const obj = filters as Record<string, unknown>\n  const push = (field: string, op: FilterOp, value?: unknown, orGroup?: string) => {\n    out.push({ field, op, value, orGroup })\n  }\n  // Handle $or at top level \u2014 one group id per disjunct so fields inside a clause are ANDed by the engine.\n  if (Array.isArray(obj.$or)) {\n    const clauses = obj.$or as Record<string, unknown>[]\n    for (let clauseIndex = 0; clauseIndex < clauses.length; clauseIndex++) {\n      const clause = clauses[clauseIndex]\n      const orGroupId = `or_${clauseIndex}`\n      if (clause && typeof clause === 'object') {\n        for (const [rawKey, rawVal] of Object.entries(clause)) {\n          const field = normalizeField(rawKey)\n          if (rawVal !== null && typeof rawVal === 'object' && !Array.isArray(rawVal)) {\n            for (const [opKey, opVal] of Object.entries(rawVal as Record<string, unknown>)) {\n              const op = opKey.replace('$', '') as FilterOp\n              if (['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'ilike', 'exists'].includes(op)) {\n                push(field, op, opVal, orGroupId)\n              }\n            }\n          } else {\n            push(field, 'eq', rawVal, orGroupId)\n          }\n        }\n      }\n    }\n  }\n  for (const [rawKey, rawVal] of Object.entries(obj)) {\n    if (rawKey === '$or') continue\n    const field = normalizeField(rawKey)\n    if (rawVal !== null && typeof rawVal === 'object' && !Array.isArray(rawVal)) {\n      for (const [opKey, opVal] of Object.entries(rawVal as Record<string, unknown>)) {\n        switch (opKey) {\n          case '$eq':\n            push(field, 'eq', opVal)\n            break\n          case '$ne':\n            push(field, 'ne', opVal)\n            break\n          case '$gt':\n            push(field, 'gt', opVal)\n            break\n          case '$gte':\n            push(field, 'gte', opVal)\n            break\n          case '$lt':\n            push(field, 'lt', opVal)\n            break\n          case '$lte':\n            push(field, 'lte', opVal)\n            break\n          case '$in':\n            push(field, 'in', opVal)\n            break\n          case '$nin':\n            push(field, 'nin', opVal)\n            break\n          case '$like':\n            push(field, 'like', opVal)\n            break\n          case '$ilike':\n            push(field, 'ilike', opVal)\n            break\n          case '$exists':\n            push(field, 'exists', opVal)\n            break\n        }\n      }\n    } else {\n      push(field, 'eq', rawVal)\n    }\n  }\n  return out\n}\n\nexport type ResolvedJoin = {\n  alias: string\n  table: string\n  entityId?: string | null\n  fromAlias: string\n  fromField: string\n  toField: string\n  type: 'left' | 'inner'\n}\n\nexport type BaseFilter = NormalizedFilter & { qualified?: string | null }\nexport type JoinFilter = { alias: string; column: string; op: FilterOp; value?: unknown }\n\nexport function resolveJoins(\n  baseTable: string,\n  joins: QueryJoinEdge[] | null | undefined,\n  resolveTable: (entityId: string) => string | null,\n): ResolvedJoin[] {\n  if (!joins || joins.length === 0) return []\n  const resolved: ResolvedJoin[] = []\n  const seen = new Set<string>()\n  for (const entry of joins) {\n    if (!entry || typeof entry !== 'object') continue\n    const alias = typeof entry.alias === 'string' ? entry.alias.trim() : ''\n    if (!alias) continue\n    if (seen.has(alias)) continue\n    const table =\n      entry.table ??\n      (entry.entityId ? resolveTable(String(entry.entityId)) : null)\n    if (!table) continue\n    const fromField = entry.from?.field?.trim()\n    const toField = entry.to?.field?.trim()\n    if (!fromField || !toField) continue\n    const fromAliasRaw = entry.from?.alias?.trim()\n    const fromAlias = fromAliasRaw && fromAliasRaw.length > 0 ? fromAliasRaw : 'base'\n    const type: 'left' | 'inner' = entry.type === 'inner' ? 'inner' : 'left'\n    resolved.push({\n      alias,\n      table,\n      entityId: entry.entityId ? String(entry.entityId) : null,\n      fromAlias,\n      fromField,\n      toField,\n      type,\n    })\n    seen.add(alias)\n  }\n  return resolved\n}\n\nexport function buildJoinChain(\n  alias: string,\n  joinMap: Map<string, ResolvedJoin>,\n  baseTable: string,\n  visited: Set<string> = new Set(),\n): ResolvedJoin[] {\n  if (visited.has(alias)) {\n    throw new Error(`QueryEngine: circular join reference detected for alias ${alias}`)\n  }\n  const cfg = joinMap.get(alias)\n  if (!cfg) return []\n  visited.add(alias)\n  if (!cfg.fromAlias || cfg.fromAlias === 'base' || cfg.fromAlias === baseTable) {\n    return [cfg]\n  }\n  const parentChain = buildJoinChain(cfg.fromAlias, joinMap, baseTable, visited)\n  if (parentChain.length === 0) return []\n  return [...parentChain, cfg]\n}\n\nexport function partitionFilters(\n  baseTable: string,\n  filters: NormalizedFilter[],\n  joinMap: Map<string, ResolvedJoin>,\n): { baseFilters: BaseFilter[]; joinFilters: Map<string, JoinFilter[]> } {\n  const baseFilters: BaseFilter[] = []\n  const joinFilters = new Map<string, JoinFilter[]>()\n  for (const filter of filters) {\n    const field = String(filter.field)\n    if (field.startsWith('cf:')) continue\n    const parts = field.split('.')\n    if (parts.length === 2) {\n      const [aliasNameRaw, column] = parts\n      const aliasName = aliasNameRaw || ''\n      if (joinMap.has(aliasName)) {\n        const list = joinFilters.get(aliasName) ?? []\n        list.push({ alias: aliasName, column, op: filter.op, value: filter.value })\n        joinFilters.set(aliasName, list)\n        continue\n      }\n      if (aliasName === baseTable || aliasName === 'base') {\n        baseFilters.push({\n          field: column,\n          op: filter.op,\n          value: filter.value,\n          qualified: `${baseTable}.${column}`,\n        })\n        continue\n      }\n    }\n    baseFilters.push({ ...filter })\n  }\n  return { baseFilters, joinFilters }\n}\n\ntype ApplyJoinFiltersOptions = {\n  db: Kysely<any>\n  baseTable: string\n  builder: AnyBuilder\n  joinMap: Map<string, ResolvedJoin>\n  joinFilters: Map<string, JoinFilter[]>\n  aliasTables: Map<string, string>\n  qualifyBase: (column: string) => string\n  applyAliasScope: (builder: AnyBuilder, alias: string, table: string) => Promise<AnyBuilder> | AnyBuilder\n  applyFilterOp: (builder: AnyBuilder, column: string, op: FilterOp, value?: unknown) => AnyBuilder\n  applyJoinFilterOp?: (builder: AnyBuilder, filter: JoinFilter, qualified: string, join: ResolvedJoin, table: string) => Promise<{ applied: boolean; builder: AnyBuilder }> | { applied: boolean; builder: AnyBuilder }\n  columnExists?: (table: string, column: string) => Promise<boolean> | boolean\n}\n\nexport async function applyJoinFilters({\n  db,\n  baseTable,\n  builder,\n  joinMap,\n  joinFilters,\n  aliasTables,\n  qualifyBase,\n  applyAliasScope,\n  applyFilterOp,\n  applyJoinFilterOp,\n  columnExists,\n}: ApplyJoinFiltersOptions): Promise<AnyBuilder> {\n  const resolveAliasName = (aliasName?: string | null) => {\n    if (!aliasName || aliasName === 'base') return baseTable\n    return aliasName\n  }\n\n  let nextBuilder = builder\n  for (const [alias, filtersForAlias] of joinFilters.entries()) {\n    const chain = buildJoinChain(alias, joinMap, baseTable)\n    if (!chain.length) continue\n    const first = chain[0]\n    let sub: AnyBuilder = db.selectFrom(`${first.table} as ${first.alias}` as any).select(sql`1`.as('one'))\n    sub = await applyAliasScope(sub, first.alias, first.table)\n    const parentAlias = resolveAliasName(first.fromAlias)\n    const parentRef = parentAlias === baseTable ? qualifyBase(first.fromField) : `${parentAlias}.${first.fromField}`\n    sub = sub.whereRef(`${first.alias}.${first.toField}`, '=', parentRef)\n    for (const cfg of chain.slice(1)) {\n      const parent = resolveAliasName(cfg.fromAlias)\n      const rightRef = parent === baseTable ? qualifyBase(cfg.fromField) : `${parent}.${cfg.fromField}`\n      const joinFn = cfg.type === 'inner' ? 'innerJoin' : 'leftJoin'\n      sub = (sub as any)[joinFn](`${cfg.table} as ${cfg.alias}`, (jb: any) =>\n        jb.onRef(`${cfg.alias}.${cfg.toField}`, '=', rightRef))\n      sub = await applyAliasScope(sub, cfg.alias, cfg.table)\n    }\n    let existsDirective: boolean | null = null\n    for (const filter of filtersForAlias) {\n      if (filter.op === 'exists') {\n        if (filter.value === false) existsDirective = false\n        else if (existsDirective === null) existsDirective = true\n        continue\n      }\n      const join = joinMap.get(filter.alias)\n      if (!join) continue\n      const targetTable = aliasTables.get(filter.alias)\n      if (!targetTable) continue\n      if (columnExists) {\n        const exists = await columnExists(targetTable, filter.column)\n        if (!exists) continue\n      }\n      const qualified = `${filter.alias}.${filter.column}`\n      if (applyJoinFilterOp) {\n        const result = await applyJoinFilterOp(sub, filter, qualified, join, targetTable)\n        if (result && result.applied) {\n          sub = result.builder\n          continue\n        }\n        if (result && result.builder) {\n          sub = result.builder\n        }\n      }\n      sub = applyFilterOp(sub, qualified, filter.op, filter.value)\n    }\n    if (existsDirective === false) {\n      const capturedSub = sub\n      nextBuilder = nextBuilder.where((eb: any) => eb.not(eb.exists(capturedSub)))\n    } else {\n      const capturedSub = sub\n      nextBuilder = nextBuilder.where((eb: any) => eb.exists(capturedSub))\n    }\n  }\n  return nextBuilder\n}\n"],
-  "mappings": "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",
+  "sourcesContent": ["import type { Kysely } from 'kysely'\nimport { sql } from 'kysely'\nimport type { QueryOptions, QueryJoinEdge } from './types'\nimport type { FilterOp } from './types'\n\ntype AnyBuilder = any\n\nexport type NormalizedFilter = { field: string; op: FilterOp; value?: unknown; orGroup?: string; qualified?: string | null }\n\nconst VALID_OPS = ['eq', 'ne', 'gt', 'gte', 'lt', 'lte', 'in', 'nin', 'like', 'ilike', 'exists'] as const\n\nconst normalizeField = (key: string) => (key.startsWith('cf_') ? `cf:${key.slice(3)}` : key)\n\ntype LeafClause = { field: string; op: FilterOp; value?: unknown }\n\n/**\n * Cap on DNF disjunct count to prevent adversarial / pathological filters from\n * exploding the in-memory normalization. `validateTreeLimits` already caps\n * editor input at 50 rules / 15 children per group / 3 levels of nesting, but\n * a hand-crafted URL or buggy preset could still bypass that. The cap mirrors\n * the editor's posture: fail loud, refuse to compile.\n */\nexport const MAX_DNF_DISJUNCTS = 1000\n\nexport class AdvancedFilterComplexityError extends Error {\n  readonly code = 'ADVANCED_FILTER_TOO_COMPLEX'\n  readonly disjunctCount: number\n  constructor(disjunctCount: number) {\n    super(\n      `Advanced filter expanded to ${disjunctCount} disjuncts, exceeding the limit of ${MAX_DNF_DISJUNCTS}. ` +\n      `Reduce the number of OR branches or simplify nested groups.`,\n    )\n    this.name = 'AdvancedFilterComplexityError'\n    this.disjunctCount = disjunctCount\n  }\n}\n\n/**\n * Expand a Mongo-style filter object (with arbitrary nesting of `$and`/`$or` and\n * implicit AND between sibling keys) into Disjunctive Normal Form: `Clause[][]`,\n * where the outer array is OR'd alternatives and each inner array is the AND'd\n * leaves of one alternative.\n *\n * Empty filter -> `[[]]` (one empty disjunct, treated as \"no constraint\").\n * Throws `AdvancedFilterComplexityError` if any intermediate cartesian product\n * exceeds `MAX_DNF_DISJUNCTS`.\n */\nfunction compileToDnf(filter: unknown): LeafClause[][] {\n  if (filter === null || filter === undefined) return [[]]\n  if (Array.isArray(filter) || typeof filter !== 'object') return [[]]\n  const obj = filter as Record<string, unknown>\n  const partialDnfs: LeafClause[][][] = []\n\n  for (const [rawKey, rawVal] of Object.entries(obj)) {\n    if (rawKey === '$and' && Array.isArray(rawVal)) {\n      partialDnfs.push(cartesianAnd((rawVal as unknown[]).map(compileToDnf)))\n      continue\n    }\n    if (rawKey === '$or' && Array.isArray(rawVal)) {\n      const expanded = (rawVal as unknown[]).flatMap(compileToDnf)\n      if (expanded.length > MAX_DNF_DISJUNCTS) {\n        throw new AdvancedFilterComplexityError(expanded.length)\n      }\n      partialDnfs.push(expanded)\n      continue\n    }\n    const field = normalizeField(rawKey)\n    if (rawVal !== null && typeof rawVal === 'object' && !Array.isArray(rawVal)) {\n      const clauses: LeafClause[] = []\n      for (const [opKey, opVal] of Object.entries(rawVal as Record<string, unknown>)) {\n        const op = (opKey.startsWith('$') ? opKey.slice(1) : opKey) as FilterOp\n        if (VALID_OPS.includes(op as (typeof VALID_OPS)[number])) {\n          clauses.push({ field, op, value: opVal })\n        }\n      }\n      if (clauses.length > 0) partialDnfs.push([clauses])\n    } else {\n      partialDnfs.push([[{ field, op: 'eq' as FilterOp, value: rawVal }]])\n    }\n  }\n\n  return cartesianAnd(partialDnfs)\n}\n\nfunction cartesianAnd(dnfs: LeafClause[][][]): LeafClause[][] {\n  if (dnfs.length === 0) return [[]]\n  let result: LeafClause[][] = [[]]\n  for (const dnf of dnfs) {\n    if (dnf.length === 0) {\n      // An empty DNF means an unsatisfiable subexpression; the AND becomes unsatisfiable\n      // too. Represent that as an empty outer array (no disjuncts).\n      return []\n    }\n    // Predict the next size to fail loud before allocating millions of arrays.\n    const projected = result.length * dnf.length\n    if (projected > MAX_DNF_DISJUNCTS) {\n      throw new AdvancedFilterComplexityError(projected)\n    }\n    const next: LeafClause[][] = []\n    for (const left of result) {\n      for (const right of dnf) {\n        next.push([...left, ...right])\n      }\n    }\n    result = next\n  }\n  return result\n}\n\nfunction clauseKey(c: LeafClause): string {\n  return JSON.stringify([c.field, c.op, c.value])\n}\n\n/**\n * Lift clauses that appear in every disjunct into a \"common\" set so the engine\n * can treat them as regular ANDed base filters (preserving the search-tokens\n * optimization for like/ilike clauses) instead of duplicating them across OR\n * groups.\n */\nfunction liftCommonClauses(dnf: LeafClause[][]): { common: LeafClause[]; remaining: LeafClause[][] } {\n  if (dnf.length <= 1) return { common: [], remaining: dnf }\n  const counts = new Map<string, { clause: LeafClause; count: number }>()\n  for (const disjunct of dnf) {\n    const seen = new Set<string>()\n    for (const c of disjunct) {\n      const key = clauseKey(c)\n      if (seen.has(key)) continue // count once per disjunct even if duplicated\n      seen.add(key)\n      const entry = counts.get(key)\n      if (entry) entry.count += 1\n      else counts.set(key, { clause: c, count: 1 })\n    }\n  }\n  const total = dnf.length\n  const commonKeys = new Set<string>()\n  const common: LeafClause[] = []\n  for (const [key, { clause, count }] of counts) {\n    if (count === total) {\n      commonKeys.add(key)\n      common.push(clause)\n    }\n  }\n  if (common.length === 0) return { common: [], remaining: dnf }\n  const remaining = dnf.map((d) => d.filter((c) => !commonKeys.has(clauseKey(c))))\n  return { common, remaining }\n}\n\nexport function normalizeFilters(filters?: QueryOptions['filters']): NormalizedFilter[] {\n  if (!filters) return []\n  if (Array.isArray(filters)) {\n    return (filters as any[]).map((f) => ({\n      ...f,\n      field: normalizeField(String((f as any).field)),\n    }))\n  }\n  const dnf = compileToDnf(filters)\n  if (dnf.length === 0) return []\n  const nonEmpty = dnf.filter((disjunct) => disjunct.length > 0)\n  if (nonEmpty.length === 0) return []\n  if (nonEmpty.length === 1) {\n    return nonEmpty[0].map((c) => ({ field: c.field, op: c.op, value: c.value }))\n  }\n  const { common, remaining } = liftCommonClauses(nonEmpty)\n  const out: NormalizedFilter[] = []\n  for (const c of common) out.push({ field: c.field, op: c.op, value: c.value })\n  // Drop disjuncts that became empty after lifting (they're already represented in `common`).\n  const remainingNonEmpty = remaining.filter((d) => d.length > 0)\n  if (remainingNonEmpty.length === 0) return out\n  if (remainingNonEmpty.length === 1) {\n    for (const c of remainingNonEmpty[0]) out.push({ field: c.field, op: c.op, value: c.value })\n    return out\n  }\n  for (let i = 0; i < remainingNonEmpty.length; i++) {\n    for (const c of remainingNonEmpty[i]) {\n      out.push({ field: c.field, op: c.op, value: c.value, orGroup: `or_${i}` })\n    }\n  }\n  return out\n}\n\nexport type ResolvedJoin = {\n  alias: string\n  table: string\n  entityId?: string | null\n  fromAlias: string\n  fromField: string\n  toField: string\n  type: 'left' | 'inner'\n}\n\nexport type BaseFilter = NormalizedFilter & { qualified?: string | null }\nexport type JoinFilter = { alias: string; column: string; op: FilterOp; value?: unknown }\n\nexport function resolveJoins(\n  baseTable: string,\n  joins: QueryJoinEdge[] | null | undefined,\n  resolveTable: (entityId: string) => string | null,\n): ResolvedJoin[] {\n  if (!joins || joins.length === 0) return []\n  const resolved: ResolvedJoin[] = []\n  const seen = new Set<string>()\n  for (const entry of joins) {\n    if (!entry || typeof entry !== 'object') continue\n    const alias = typeof entry.alias === 'string' ? entry.alias.trim() : ''\n    if (!alias) continue\n    if (seen.has(alias)) continue\n    const table =\n      entry.table ??\n      (entry.entityId ? resolveTable(String(entry.entityId)) : null)\n    if (!table) continue\n    const fromField = entry.from?.field?.trim()\n    const toField = entry.to?.field?.trim()\n    if (!fromField || !toField) continue\n    const fromAliasRaw = entry.from?.alias?.trim()\n    const fromAlias = fromAliasRaw && fromAliasRaw.length > 0 ? fromAliasRaw : 'base'\n    const type: 'left' | 'inner' = entry.type === 'inner' ? 'inner' : 'left'\n    resolved.push({\n      alias,\n      table,\n      entityId: entry.entityId ? String(entry.entityId) : null,\n      fromAlias,\n      fromField,\n      toField,\n      type,\n    })\n    seen.add(alias)\n  }\n  return resolved\n}\n\nexport function buildJoinChain(\n  alias: string,\n  joinMap: Map<string, ResolvedJoin>,\n  baseTable: string,\n  visited: Set<string> = new Set(),\n): ResolvedJoin[] {\n  if (visited.has(alias)) {\n    throw new Error(`QueryEngine: circular join reference detected for alias ${alias}`)\n  }\n  const cfg = joinMap.get(alias)\n  if (!cfg) return []\n  visited.add(alias)\n  if (!cfg.fromAlias || cfg.fromAlias === 'base' || cfg.fromAlias === baseTable) {\n    return [cfg]\n  }\n  const parentChain = buildJoinChain(cfg.fromAlias, joinMap, baseTable, visited)\n  if (parentChain.length === 0) return []\n  return [...parentChain, cfg]\n}\n\nexport function partitionFilters(\n  baseTable: string,\n  filters: NormalizedFilter[],\n  joinMap: Map<string, ResolvedJoin>,\n): { baseFilters: BaseFilter[]; joinFilters: Map<string, JoinFilter[]> } {\n  const baseFilters: BaseFilter[] = []\n  const joinFilters = new Map<string, JoinFilter[]>()\n  for (const filter of filters) {\n    const field = String(filter.field)\n    if (field.startsWith('cf:')) continue\n    const parts = field.split('.')\n    if (parts.length === 2) {\n      const [aliasNameRaw, column] = parts\n      const aliasName = aliasNameRaw || ''\n      if (joinMap.has(aliasName)) {\n        const list = joinFilters.get(aliasName) ?? []\n        list.push({ alias: aliasName, column, op: filter.op, value: filter.value })\n        joinFilters.set(aliasName, list)\n        continue\n      }\n      if (aliasName === baseTable || aliasName === 'base') {\n        baseFilters.push({\n          field: column,\n          op: filter.op,\n          value: filter.value,\n          qualified: `${baseTable}.${column}`,\n        })\n        continue\n      }\n    }\n    baseFilters.push({ ...filter })\n  }\n  return { baseFilters, joinFilters }\n}\n\ntype ApplyJoinFiltersOptions = {\n  db: Kysely<any>\n  baseTable: string\n  builder: AnyBuilder\n  joinMap: Map<string, ResolvedJoin>\n  joinFilters: Map<string, JoinFilter[]>\n  aliasTables: Map<string, string>\n  qualifyBase: (column: string) => string\n  applyAliasScope: (builder: AnyBuilder, alias: string, table: string) => Promise<AnyBuilder> | AnyBuilder\n  applyFilterOp: (builder: AnyBuilder, column: string, op: FilterOp, value?: unknown) => AnyBuilder\n  applyJoinFilterOp?: (builder: AnyBuilder, filter: JoinFilter, qualified: string, join: ResolvedJoin, table: string) => Promise<{ applied: boolean; builder: AnyBuilder }> | { applied: boolean; builder: AnyBuilder }\n  columnExists?: (table: string, column: string) => Promise<boolean> | boolean\n}\n\nexport async function applyJoinFilters({\n  db,\n  baseTable,\n  builder,\n  joinMap,\n  joinFilters,\n  aliasTables,\n  qualifyBase,\n  applyAliasScope,\n  applyFilterOp,\n  applyJoinFilterOp,\n  columnExists,\n}: ApplyJoinFiltersOptions): Promise<AnyBuilder> {\n  const resolveAliasName = (aliasName?: string | null) => {\n    if (!aliasName || aliasName === 'base') return baseTable\n    return aliasName\n  }\n\n  let nextBuilder = builder\n  for (const [alias, filtersForAlias] of joinFilters.entries()) {\n    const chain = buildJoinChain(alias, joinMap, baseTable)\n    if (!chain.length) continue\n    const first = chain[0]\n    let sub: AnyBuilder = db.selectFrom(`${first.table} as ${first.alias}` as any).select(sql`1`.as('one'))\n    sub = await applyAliasScope(sub, first.alias, first.table)\n    const parentAlias = resolveAliasName(first.fromAlias)\n    const parentRef = parentAlias === baseTable ? qualifyBase(first.fromField) : `${parentAlias}.${first.fromField}`\n    sub = sub.whereRef(`${first.alias}.${first.toField}`, '=', parentRef)\n    for (const cfg of chain.slice(1)) {\n      const parent = resolveAliasName(cfg.fromAlias)\n      const rightRef = parent === baseTable ? qualifyBase(cfg.fromField) : `${parent}.${cfg.fromField}`\n      const joinFn = cfg.type === 'inner' ? 'innerJoin' : 'leftJoin'\n      sub = (sub as any)[joinFn](`${cfg.table} as ${cfg.alias}`, (jb: any) =>\n        jb.onRef(`${cfg.alias}.${cfg.toField}`, '=', rightRef))\n      sub = await applyAliasScope(sub, cfg.alias, cfg.table)\n    }\n    let existsDirective: boolean | null = null\n    for (const filter of filtersForAlias) {\n      if (filter.op === 'exists') {\n        if (filter.value === false) existsDirective = false\n        else if (existsDirective === null) existsDirective = true\n        continue\n      }\n      const join = joinMap.get(filter.alias)\n      if (!join) continue\n      const targetTable = aliasTables.get(filter.alias)\n      if (!targetTable) continue\n      if (columnExists) {\n        const exists = await columnExists(targetTable, filter.column)\n        if (!exists) continue\n      }\n      const qualified = `${filter.alias}.${filter.column}`\n      if (applyJoinFilterOp) {\n        const result = await applyJoinFilterOp(sub, filter, qualified, join, targetTable)\n        if (result && result.applied) {\n          sub = result.builder\n          continue\n        }\n        if (result && result.builder) {\n          sub = result.builder\n        }\n      }\n      sub = applyFilterOp(sub, qualified, filter.op, filter.value)\n    }\n    if (existsDirective === false) {\n      const capturedSub = sub\n      nextBuilder = nextBuilder.where((eb: any) => eb.not(eb.exists(capturedSub)))\n    } else {\n      const capturedSub = sub\n      nextBuilder = nextBuilder.where((eb: any) => eb.exists(capturedSub))\n    }\n  }\n  return nextBuilder\n}\n"],
+  "mappings": "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",
   "names": []
 }

package/dist/lib/version.js

@@ -1,4 +1,4 @@
-const APP_VERSION = "0.6.1-develop.3276.1.1fcd145078";
+const APP_VERSION = "0.6.1-develop.3278.1.a4d26475e4";
 const appVersion = APP_VERSION;
 export {
   APP_VERSION,

package/dist/lib/version.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/lib/version.ts"],
-  "sourcesContent": ["// Build-time generated version\nexport const APP_VERSION = '0.6.1-develop.3276.1.1fcd145078'\nexport const appVersion = APP_VERSION\n"],
+  "sourcesContent": ["// Build-time generated version\nexport const APP_VERSION = '0.6.1-develop.3278.1.a4d26475e4'\nexport const appVersion = APP_VERSION\n"],
   "mappings": "AACO,MAAM,cAAc;AACpB,MAAM,aAAa;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/shared",
-  "version": "0.6.1-develop.3276.1.1fcd145078",
+  "version": "0.6.1-develop.3278.1.a4d26475e4",
   "type": "module",
   "main": "./dist/index.js",
   "scripts": {
@@ -92,7 +92,7 @@
     "@mikro-orm/core": "^7.0.15",
     "@mikro-orm/decorators": "^7.0.15",
     "@mikro-orm/postgresql": "^7.0.15",
-    "@open-mercato/cache": "0.6.1-develop.3276.1.1fcd145078",
+    "@open-mercato/cache": "0.6.1-develop.3278.1.a4d26475e4",
     "dotenv": "^17.4.2",
     "rate-limiter-flexible": "^11.1.0",
     "reflect-metadata": "^0.2.2",

package/src/lib/crud/__tests__/advanced-filter-integration.test.ts

@@ -0,0 +1,113 @@
+/** @jest-environment node */
+import { mergeAdvancedFilterTree, mergeAdvancedFiltersFromQuery } from '../advanced-filter-integration'
+import type { AdvancedFilterTree, FilterRule, FilterGroup } from '../../query/advanced-filter-tree'
+import { createEmptyTree } from '../../query/advanced-filter-tree'
+
+const rule = (field: string, value: string): FilterRule => ({
+  id: field, type: 'rule', field, operator: 'contains', value,
+})
+const group = (combinator: 'and' | 'or', children: Array<FilterRule | FilterGroup>): FilterGroup => ({
+  id: combinator, type: 'group', combinator, children,
+})
+const treeOf = (root: FilterGroup): AdvancedFilterTree => ({ root })
+
+describe('mergeAdvancedFilterTree', () => {
+  it('returns route filters unchanged when tree is null', () => {
+    expect(mergeAdvancedFilterTree({ kind: 'person' }, null)).toEqual({ kind: 'person' })
+  })
+
+  it('returns route filters unchanged when tree is empty', () => {
+    expect(mergeAdvancedFilterTree({ kind: 'person' }, createEmptyTree())).toEqual({ kind: 'person' })
+  })
+
+  it('returns the tree where when route filters are empty', () => {
+    const tree = treeOf(group('and', [rule('display_name', 'Daniel')]))
+    expect(mergeAdvancedFilterTree({}, tree)).toEqual({ display_name: { $ilike: '%Daniel%' } })
+  })
+
+  it('AND-combines route filters with tree output via $and', () => {
+    const tree = treeOf(group('and', [
+      rule('display_name', 'Daniel'),
+      rule('display_name', 'Harris'),
+    ]))
+    expect(mergeAdvancedFilterTree({ kind: 'person' }, tree)).toEqual({
+      $and: [
+        { kind: 'person' },
+        { $and: [
+          { display_name: { $ilike: '%Daniel%' } },
+          { display_name: { $ilike: '%Harris%' } },
+        ]},
+      ],
+    })
+  })
+
+  it('preserves nested OR groups in the AND-combined output', () => {
+    const tree = treeOf(group('and', [
+      group('or', [rule('display_name', 'Daniel'), rule('display_name', 'Naomi')]),
+      rule('status', 'Lead'),
+    ]))
+    expect(mergeAdvancedFilterTree({ kind: 'person' }, tree)).toEqual({
+      $and: [
+        { kind: 'person' },
+        { $and: [
+          { $or: [
+            { display_name: { $ilike: '%Daniel%' } },
+            { display_name: { $ilike: '%Naomi%' } },
+          ]},
+          { status: { $ilike: '%Lead%' } },
+        ]},
+      ],
+    })
+  })
+})
+
+describe('mergeAdvancedFiltersFromQuery', () => {
+  it('parses v2 tree URLs', () => {
+    const out = mergeAdvancedFiltersFromQuery(
+      { kind: 'person' },
+      {
+        'filter[v]': '2',
+        'filter[root][combinator]': 'and',
+        'filter[root][children][0][type]': 'rule',
+        'filter[root][children][0][field]': 'display_name',
+        'filter[root][children][0][op]': 'contains',
+        'filter[root][children][0][value]': 'Daniel',
+      },
+    )
+    expect(out).toEqual({
+      $and: [
+        { kind: 'person' },
+        { display_name: { $ilike: '%Daniel%' } },
+      ],
+    })
+  })
+
+  it('upgrades legacy v1 URLs into a tree under SQL precedence', () => {
+    const out = mergeAdvancedFiltersFromQuery(
+      { kind: 'person' },
+      {
+        'filter[logic]': 'and',
+        'filter[conditions][0][field]': 'display_name',
+        'filter[conditions][0][op]': 'contains',
+        'filter[conditions][0][value]': 'Daniel',
+        'filter[conditions][1][field]': 'display_name',
+        'filter[conditions][1][op]': 'contains',
+        'filter[conditions][1][value]': 'Naomi',
+        'filter[conditions][1][join]': 'or',
+      },
+    )
+    expect(out).toEqual({
+      $and: [
+        { kind: 'person' },
+        { $or: [
+          { display_name: { $ilike: '%Daniel%' } },
+          { display_name: { $ilike: '%Naomi%' } },
+        ]},
+      ],
+    })
+  })
+
+  it('returns route filters unchanged when no advanced filter present', () => {
+    expect(mergeAdvancedFiltersFromQuery({ kind: 'person' }, { page: '1' })).toEqual({ kind: 'person' })
+  })
+})

package/src/lib/crud/advanced-filter-integration.ts

@@ -1,4 +1,10 @@
-import { deserializeAdvancedFilter, convertAdvancedFilterToWhere } from '../query/advanced-filter'
+import {
+  deserializeAdvancedFilter,
+  deserializeTree,
+  flatToTree,
+  convertAdvancedFilterToWhere,
+} from '../query/advanced-filter'
+import { compileTreeToWhere, type AdvancedFilterTree } from '../query/advanced-filter-tree'
 
 function splitOrClauses(filters: Record<string, unknown>): {
   directFilters: Record<string, unknown>
@@ -72,3 +78,81 @@ export function mergeAdvancedFilters(
   // AND logic: merge directly
   return { ...existingFilters, ...advancedWhere }
 }
+
+/**
+ * Combine route-side filters with an advanced filter tree by AND.
+ *
+ * The compiled tree may itself contain nested `$and`/`$or` — the query engine's
+ * normalize step (`compileToDnf` in join-utils.ts) expands those into Disjunctive
+ * Normal Form, so the engine sees a single OR group with disjuncts that AND'd
+ * leaves. Common-clause lifting in normalize keeps shared predicates ungrouped
+ * (preserving the search-tokens optimization).
+ */
+export function mergeAdvancedFilterTree(
+  routeFilters: Record<string, unknown>,
+  tree: AdvancedFilterTree | null,
+): Record<string, unknown> {
+  if (!tree) return routeFilters
+  const treeWhere = compileTreeToWhere(tree)
+  if (!treeWhere) return routeFilters
+  if (Object.keys(routeFilters).length === 0) return treeWhere
+  // AND-combine via $and so any nested $and/$or in either side reaches normalize unchanged.
+  return { $and: [routeFilters, treeWhere] }
+}
+
+/**
+ * Read-old-write-new helper: parse the request `query` for either a v2 tree URL
+ * or a legacy v1 flat URL (auto-upgraded via flatToTree under SQL precedence),
+ * and AND-combine the result with the route's existing filters.
+ */
+export function mergeAdvancedFiltersFromQuery(
+  routeFilters: Record<string, unknown>,
+  query: Record<string, unknown>,
+): Record<string, unknown> {
+  const v2 = deserializeTree(query)
+  if (v2) return mergeAdvancedFilterTree(routeFilters, v2)
+  const flat = deserializeAdvancedFilter(query)
+  if (!flat) return routeFilters
+  return mergeAdvancedFilterTree(routeFilters, flatToTree(flat))
+}
+
+/**
+ * Returns the request's advanced filter as a tree, after stripping the
+ * `filter[...]` keys from the query map. Mirrors `mergeAdvancedFiltersFromQuery`
+ * but exposes the tree so callers can apply additional shaping (e.g. mapping to
+ * `query.ids`, narrowing by feature flags, or surfacing the tree to enrichers)
+ * before merging into the route filter.
+ *
+ * - Detects v2 tree URL params first.
+ * - Falls back to legacy v1 flat params, upgraded via `flatToTree` under
+ *   standard SQL precedence (AND binds tighter than OR).
+ * - Mutates `query` in place: every `filter[...]` key is removed after parsing.
+ *
+ * Returns `null` when no advanced-filter query params are present.
+ */
+export function consumeAdvancedFilterState(query: Record<string, unknown>): AdvancedFilterTree | null {
+  let tree: AdvancedFilterTree | null = deserializeTree(query)
+  if (!tree) {
+    const flat = deserializeAdvancedFilter(query)
+    if (flat) {
+      tree = flatToTree(flat)
+      if (process.env.NODE_ENV !== 'production') {
+        const sentinel = '__OM_FILTER_V1_WARNED'
+        const g = globalThis as Record<string, unknown>
+        if (!g[sentinel]) {
+          g[sentinel] = true
+          // eslint-disable-next-line no-console
+          console.warn('[advanced-filter] legacy v1 URL detected; auto-upgraded to v2 tree')
+        }
+      }
+    }
+  }
+
+  for (const key of Object.keys(query)) {
+    if (key.startsWith('filter[')) {
+      delete query[key]
+    }
+  }
+
+  return tree
+}