bunsane 0.5.1 → 0.5.3

package/query/ComponentInclusionNode.ts

@@ -3,6 +3,7 @@ import type { QueryResult } from "./QueryNode";
 import { QueryContext } from "./QueryContext";
 import { shouldUseLateralJoins, shouldUseDirectPartition } from "../core/Config";
 import { FilterBuilderRegistry } from "./FilterBuilderRegistry";
+import { jsonbInListCast } from "./FilterBuilder";
 import { ComponentRegistry } from "../core/components";
 import { getMetadataStorage } from "../core/metadata";
 import { assertIdentifier } from "./SqlIdentifier";
@@ -95,8 +96,9 @@ export class ComponentInclusionNode extends QueryNode {
             return `${jsonPath} ${filter.operator} $${context.addParam(filter.value)}`;
         } else if (filter.operator === 'IN' || filter.operator === 'NOT IN') {
             if (Array.isArray(filter.value) && filter.value.length > 0) {
-                const placeholders = filter.value.map((v: any) => `$${context.addParam(v)}`).join(', ');
-                return `${jsonPath} ${filter.operator} (${placeholders})`;
+                const cast = jsonbInListCast(filter.value);
+                const placeholders = filter.value.map((v: any) => `$${context.addParam(v)}${cast.param}`).join(', ');
+                return `${cast.lhs(jsonPath)} ${filter.operator} (${placeholders})`;
             } else if (Array.isArray(filter.value) && filter.value.length === 0) {
                 return filter.operator === 'IN' ? 'FALSE' : 'TRUE';
             }
@@ -665,8 +667,9 @@ export class ComponentInclusionNode extends QueryNode {
                 condition = `(${jsonPath})::boolean ${filter.operator} $${context.addParam(filter.value)}`;
             } else if (filter.operator === 'IN' || filter.operator === 'NOT IN') {
                 if (Array.isArray(filter.value) && filter.value.length > 0) {
-                    const placeholders = filter.value.map((v: any) => `$${context.addParam(v)}`).join(', ');
-                    condition = `${jsonPath} ${filter.operator} (${placeholders})`;
+                    const cast = jsonbInListCast(filter.value);
+                    const placeholders = filter.value.map((v: any) => `$${context.addParam(v)}${cast.param}`).join(', ');
+                    condition = `${cast.lhs(jsonPath)} ${filter.operator} (${placeholders})`;
                 } else {
                     return null; // Invalid or empty array - fall back to normal path
                 }
@@ -860,14 +863,17 @@ export class ComponentInclusionNode extends QueryNode {
                         // String LIKE/ILIKE comparison - no casting
                         condition = `${jsonPath} ${filter.operator} $${context.addParam(filter.value)}`;
                     } else if (filter.operator === 'IN' || filter.operator === 'NOT IN') {
-                        // IN/NOT IN comparison - handle arrays properly
+                        // IN/NOT IN comparison - handle arrays properly. Numeric/
+                        // boolean lists need a cast on both the JSONB text field
+                        // and each parameter, else `text IN (1, 2)` errors.
                         if (Array.isArray(filter.value) && filter.value.length > 0) {
+                            const cast = jsonbInListCast(filter.value);
                             let placeholders = '';
                             for (let i = 0; i < filter.value.length; i++) {
                                 if (i) placeholders += ', ';
-                                placeholders += '$' + context.addParam(filter.value[i]);
+                                placeholders += '$' + context.addParam(filter.value[i]) + cast.param;
                             }
-                            condition = `${jsonPath} ${filter.operator} (${placeholders})`;
+                            condition = `${cast.lhs(jsonPath)} ${filter.operator} (${placeholders})`;
                         } else if (Array.isArray(filter.value) && filter.value.length === 0) {
                             // Empty array: IN () is always false, NOT IN () is always true
                             condition = filter.operator === 'IN' ? 'FALSE' : 'TRUE';

package/query/FilterBuilder.ts

@@ -90,6 +90,25 @@ export function buildJSONBPath(field: string, alias: string): string {
     return `${alias}.data->'${field}'`;
 }
 
+/**
+ * Determine the type cast for an `IN` / `NOT IN` value list against a JSONB
+ * text-extracted field (`data->>'x'` always yields text). Without a cast a
+ * numeric/boolean list produces `text IN (1, 2)` → PostgreSQL "operator does
+ * not exist: text = integer". When every element is a number (or boolean) we
+ * cast both the field and each parameter, mirroring the scalar `=` path. Mixed
+ * or string lists stay as plain text comparison (the correct default).
+ *
+ * @returns `lhs(path)` wraps the field expression; `param` is the per-parameter
+ *          cast suffix (e.g. `::numeric`), `''` for text.
+ */
+export function jsonbInListCast(values: any[]): { lhs: (path: string) => string; param: string } {
+    const allNumbers = values.length > 0 && values.every(v => typeof v === 'number');
+    if (allNumbers) return { lhs: (p) => `(${p})::numeric`, param: '::numeric' };
+    const allBooleans = values.length > 0 && values.every(v => typeof v === 'boolean');
+    if (allBooleans) return { lhs: (p) => `(${p})::boolean`, param: '::boolean' };
+    return { lhs: (p) => p, param: '' };
+}
+
 /**
  * Compose multiple filter builders into a single builder that applies all conditions
  *

package/query/OrNode.ts

@@ -5,6 +5,7 @@ import { OrQuery } from "./OrQuery";
 import { ComponentRegistry } from "../core/components";
 import { shouldUseDirectPartition } from "../core/Config";
 import { getMembershipTable } from "./membershipSource";
+import { jsonbInListCast } from "./FilterBuilder";
 
 export class OrNode extends QueryNode {
     private orQuery: OrQuery;
@@ -111,15 +112,17 @@ export class OrNode extends QueryNode {
                             break;
                         case "IN":
                             if (Array.isArray(value)) {
-                                const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
-                                branchSql += ` AND ${jsonPath} IN (${placeholders})`;
+                                const cast = jsonbInListCast(value);
+                                const placeholders = value.map(() => `$${paramIndex++}${cast.param}`).join(', ');
+                                branchSql += ` AND ${cast.lhs(jsonPath)} IN (${placeholders})`;
                                 context.params.push(...value);
                             }
                             break;
                         case "NOT IN":
                             if (Array.isArray(value)) {
-                                const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
-                                branchSql += ` AND ${jsonPath} NOT IN (${placeholders})`;
+                                const cast = jsonbInListCast(value);
+                                const placeholders = value.map(() => `$${paramIndex++}${cast.param}`).join(', ');
+                                branchSql += ` AND ${cast.lhs(jsonPath)} NOT IN (${placeholders})`;
                                 context.params.push(...value);
                             }
                             break;
@@ -150,7 +153,7 @@ export class OrNode extends QueryNode {
         if (context.excludedComponentIds.size > 0) {
             const excludedTypes = Array.from(context.excludedComponentIds);
             const placeholders = excludedTypes.map(() => `$${paramIndex++}`).join(', ');
-            conditions.push(`NOT EXISTS (SELECT 1 FROM ${getMembershipTable()} ec_ex WHERE ec_ex.entity_id = or_results.id AND ec_ex.type_id IN (${placeholders}) AND ec_ex.deleted_at IS NULL)`);
+            conditions.push(`NOT EXISTS (SELECT 1 FROM ${getMembershipTable()} ec_ex WHERE ec_ex.entity_id = or_results.entity_id AND ec_ex.type_id IN (${placeholders}) AND ec_ex.deleted_at IS NULL)`);
             context.params.push(...excludedTypes);
         }
 
@@ -232,15 +235,17 @@ export class OrNode extends QueryNode {
                             break;
                         case "IN":
                             if (Array.isArray(value)) {
-                                const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
-                                conditions.push(`${jsonPath} IN (${placeholders})`);
+                                const cast = jsonbInListCast(value);
+                                const placeholders = value.map(() => `$${paramIndex++}${cast.param}`).join(', ');
+                                conditions.push(`${cast.lhs(jsonPath)} IN (${placeholders})`);
                                 context.params.push(...value);
                             }
                             break;
                         case "NOT IN":
                             if (Array.isArray(value)) {
-                                const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
-                                conditions.push(`${jsonPath} NOT IN (${placeholders})`);
+                                const cast = jsonbInListCast(value);
+                                const placeholders = value.map(() => `$${paramIndex++}${cast.param}`).join(', ');
+                                conditions.push(`${cast.lhs(jsonPath)} NOT IN (${placeholders})`);
                                 context.params.push(...value);
                             }
                             break;
@@ -329,10 +334,29 @@ export class OrNode extends QueryNode {
         let baseEntityQuery = "";
 
         if (hasComponentDependency) {
-            // Get base entities from ComponentInclusionNode
+            // Get base entities from ComponentInclusionNode.
+            //
+            // CRITICAL: the base set must be UNBOUNDED. OrNode embeds this SQL
+            // as `FROM (base) WHERE EXISTS (<or filter>)` and applies LIMIT/
+            // OFFSET to the *final* OR-filtered result below. If the base node
+            // bakes the caller's LIMIT/OFFSET into its own SQL, the EXISTS OR
+            // filter only ever sees the first page of base entities (ordered by
+            // entity_id), so any match beyond that page silently vanishes —
+            // e.g. a search whose only hits live on page 2+ returns 0 rows
+            // while count() (which strips pagination) reports them. Null out
+            // pagination around the base build, then restore so the final
+            // pagination below is unaffected. cursorId is left intact: it
+            // constrains the candidate set (entity_id > cursor) which composes
+            // correctly with the final LIMIT.
             const componentNode = this.dependencies[0];
             if (componentNode) {
+                const savedLimit = context.limit;
+                const savedOffset = context.offsetValue;
+                context.limit = null;
+                context.offsetValue = 0;
                 const baseResult = componentNode.execute(context);
+                context.limit = savedLimit;
+                context.offsetValue = savedOffset;
                 baseEntityQuery = baseResult.sql;
                 paramIndex = baseResult.context.paramIndex;
             }
@@ -408,15 +432,17 @@ export class OrNode extends QueryNode {
                             break;
                         case "IN":
                             if (Array.isArray(value)) {
-                                const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
-                                filterConditions.push(`${jsonPath} IN (${placeholders})`);
+                                const cast = jsonbInListCast(value);
+                                const placeholders = value.map(() => `$${paramIndex++}${cast.param}`).join(', ');
+                                filterConditions.push(`${cast.lhs(jsonPath)} IN (${placeholders})`);
                                 context.params.push(...value);
                             }
                             break;
                         case "NOT IN":
                             if (Array.isArray(value)) {
-                                const placeholders = value.map(() => `$${paramIndex++}`).join(', ');
-                                filterConditions.push(`${jsonPath} NOT IN (${placeholders})`);
+                                const cast = jsonbInListCast(value);
+                                const placeholders = value.map(() => `$${paramIndex++}${cast.param}`).join(', ');
+                                filterConditions.push(`${cast.lhs(jsonPath)} NOT IN (${placeholders})`);
                                 context.params.push(...value);
                             }
                             break;
@@ -447,7 +473,7 @@ export class OrNode extends QueryNode {
             for (const componentType of allComponentTypes) {
                 const componentId = ComponentRegistry.getComponentId(componentType);
                 if (componentId) {
-                    componentConditions.push(`EXISTS (SELECT 1 FROM ${getMembershipTable()} ec_all WHERE ec_all.entity_id = or_results.id AND ec_all.type_id = $${paramIndex} AND ec_all.deleted_at IS NULL)`);
+                    componentConditions.push(`EXISTS (SELECT 1 FROM ${getMembershipTable()} ec_all WHERE ec_all.entity_id = or_results.entity_id AND ec_all.type_id = $${paramIndex} AND ec_all.deleted_at IS NULL)`);
                     context.params.push(componentId);
                     paramIndex++;
                 }
@@ -469,7 +495,7 @@ export class OrNode extends QueryNode {
         if (context.excludedComponentIds.size > 0) {
             const excludedTypes = Array.from(context.excludedComponentIds);
             const placeholders = excludedTypes.map(() => `$${paramIndex++}`).join(', ');
-            conditions.push(`NOT EXISTS (SELECT 1 FROM ${getMembershipTable()} ec_ex WHERE ec_ex.entity_id = or_results.id AND ec_ex.type_id IN (${placeholders}) AND ec_ex.deleted_at IS NULL)`);
+            conditions.push(`NOT EXISTS (SELECT 1 FROM ${getMembershipTable()} ec_ex WHERE ec_ex.entity_id = or_results.entity_id AND ec_ex.type_id IN (${placeholders}) AND ec_ex.deleted_at IS NULL)`);
             context.params.push(...excludedTypes);
         }