feat(core): tighten filter types per (breaking)

packages/hypergraph/src/entity/findMany.ts

@@ -255,17 +255,9 @@ export function findMany<const S extends AnyNoContext>(
   const filtered: Array<Entity<S>> = [];
 
   const evaluateFilter = <T>(fieldFilter: EntityFieldFilter<T>, fieldValue: T): boolean => {
-    // Handle NOT operator
-    if ('not' in fieldFilter && fieldFilter.not) {
-      return !evaluateFilter(fieldFilter.not, fieldValue);
-    }
-
-    // Handle OR operator
-    if ('or' in fieldFilter) {
-      const orFilters = fieldFilter.or;
-      if (Array.isArray(orFilters)) {
-        return orFilters.some((orFilter) => evaluateFilter(orFilter as EntityFieldFilter<T>, fieldValue));
-      }
+    const ff = fieldFilter as unknown as Record<string, unknown>;
+    if ('not' in ff || 'or' in ff || 'and' in ff) {
+      throw new Error("Logical operators 'not', 'or', 'and' are only allowed at the root (cross-field) level.");
     }
 
     // Handle basic filters
@@ -324,14 +316,35 @@ export function findMany<const S extends AnyNoContext>(
     crossFieldFilter: CrossFieldFilter<Schema.Schema.Type<S>>,
     entity: Entity<S>,
   ): boolean => {
+    // Evaluate regular field filters with AND semantics
     for (const fieldName in crossFieldFilter) {
-      const fieldFilter = crossFieldFilter[fieldName];
-      const fieldValue = entity[fieldName];
+      if (fieldName === 'or' || fieldName === 'not') continue;
+      const fieldFilter = crossFieldFilter[fieldName] as unknown as EntityFieldFilter<unknown> | undefined;
+      if (!fieldFilter) continue;
+      const fieldValue = (entity as unknown as Record<string, unknown>)[fieldName] as unknown;
+      if (!evaluateFilter(fieldFilter, fieldValue)) {
+        return false;
+      }
+    }
+
+    // Evaluate nested OR at cross-field level (if present)
+    const cf = crossFieldFilter as unknown as Record<string, unknown>;
+    const maybeOr = cf.or;
+    if (Array.isArray(maybeOr)) {
+      const orFilters = maybeOr as Array<CrossFieldFilter<Schema.Schema.Type<S>>>;
+      const orSatisfied = orFilters.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
+      if (!orSatisfied) return false;
+    }
 
-      if (fieldFilter && !evaluateFilter(fieldFilter, fieldValue)) {
+    // Evaluate nested NOT at cross-field level (if present)
+    const maybeNot = cf.not;
+    if (maybeNot) {
+      const notFilter = maybeNot as CrossFieldFilter<Schema.Schema.Type<S>>;
+      if (evaluateCrossFieldFilter(notFilter, entity)) {
         return false;
       }
     }
+
     return true;
   };
 

packages/hypergraph/src/entity/types.ts

@@ -55,17 +55,13 @@ export type EntityNumberFilter = {
   is?: number;
   greaterThan?: number;
   lessThan?: number;
-  not?: EntityNumberFilter;
-  or?: EntityNumberFilter[];
 };
 
 export type EntityStringFilter = {
   is?: string;
   startsWith?: string;
   endsWith?: string;
   contains?: string;
-  not?: EntityStringFilter;
-  or?: EntityStringFilter[];
 };
 
 export type CrossFieldFilter<T> = {
@@ -77,8 +73,6 @@ export type CrossFieldFilter<T> = {
 
 export type EntityFieldFilter<T> = {
   is?: T;
-  not?: EntityFieldFilter<T>;
-  or?: Array<EntityFieldFilter<T>>;
 } & (T extends boolean
   ? {
       is?: boolean;

packages/hypergraph/test/entity/findMany.test.ts

@@ -193,7 +193,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          name: { not: { is: 'John' } },
+          not: { name: { is: 'John' } },
         },
         undefined,
       );
@@ -212,7 +212,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          age: { not: { is: 30 } },
+          not: { age: { is: 30 } },
         },
         undefined,
       );
@@ -233,7 +233,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          name: { or: [{ is: 'John' }, { is: 'Jane' }] },
+          or: [{ name: { is: 'John' } }, { name: { is: 'Jane' } }],
         },
         undefined,
       );
@@ -252,7 +252,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          age: { or: [{ is: 25 }, { is: 40 }] },
+          or: [{ age: { is: 25 } }, { age: { is: 40 } }],
         },
         undefined,
       );
@@ -273,7 +273,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          name: { not: { or: [{ is: 'John' }, { is: 'Jane' }] } },
+          not: { or: [{ name: { is: 'John' } }, { name: { is: 'Jane' } }] },
         },
         undefined,
       );
@@ -292,7 +292,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          name: { not: { or: [{ is: 'John' }, { is: 'Jane' }] } },
+          not: { or: [{ name: { is: 'John' } }, { name: { is: 'Jane' } }] },
         },
         undefined,
       );
@@ -384,8 +384,7 @@ describe('findMany with filters', () => {
         handle,
         Person,
         {
-          name: { not: { startsWith: 'J' } },
-          age: { not: { greaterThan: 35 } },
+          not: { or: [{ name: { startsWith: 'J' } }, { age: { greaterThan: 35 } }] },
         },
         undefined,
       );