@graphprotocol/hypergraph 0.4.2 → 0.5.0-alpha.1

package/src/entity/findMany.ts

@@ -255,20 +255,11 @@ 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);
+    if ('not' in fieldFilter || 'or' in fieldFilter) {
+      throw new Error("Logical operators 'not', 'or' are only allowed at the root (cross-field) level.");
     }
 
-    // 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));
-      }
-    }
-
-    // Handle basic filters
+    // handle basic filters
     if ('is' in fieldFilter) {
       if (typeof fieldValue === 'boolean') {
         return fieldValue === fieldFilter.is;
@@ -324,14 +315,28 @@ 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) {
+      if (fieldName === 'or' || fieldName === 'not') continue;
       const fieldFilter = crossFieldFilter[fieldName];
+      if (!fieldFilter) continue;
       const fieldValue = entity[fieldName];
-
-      if (fieldFilter && !evaluateFilter(fieldFilter, fieldValue)) {
+      if (!evaluateFilter(fieldFilter, fieldValue)) {
         return false;
       }
     }
+
+    // evaluate nested OR at cross-field level (if present)
+    if (Array.isArray(crossFieldFilter.or)) {
+      const orSatisfied = crossFieldFilter.or.some((orFilter) => evaluateCrossFieldFilter(orFilter, entity));
+      if (!orSatisfied) return false;
+    }
+
+    // evaluate nested NOT at cross-field level (if present)
+    if (crossFieldFilter.not && evaluateCrossFieldFilter(crossFieldFilter.not, entity)) {
+      return false;
+    }
+
     return true;
   };
 
@@ -367,7 +372,14 @@ export function findMany<const S extends AnyNoContext>(
           decoded.__schema = type;
           filtered.push(decoded);
         }
-      } catch (_error) {
+      } catch (error) {
+        // rethrow in case it's filter error
+        if (
+          error instanceof Error &&
+          error.message.includes("Logical operators 'not', 'or' are only allowed at the root (cross-field) level")
+        ) {
+          throw error;
+        }
         corruptEntityIds.push(id);
       }
     }

package/src/entity/types.ts

@@ -55,8 +55,6 @@ export type EntityNumberFilter = {
   is?: number;
   greaterThan?: number;
   lessThan?: number;
-  not?: EntityNumberFilter;
-  or?: EntityNumberFilter[];
 };
 
 export type EntityStringFilter = {
@@ -64,8 +62,6 @@ export type EntityStringFilter = {
   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;

package/src/index.ts

@@ -1,4 +1,5 @@
 export { Id } from '@graphprotocol/grc-20';
+export * as Typesync from './cli/services/Model.js';
 export * as Connect from './connect/index.js';
 export * as Entity from './entity/index.js';
 export * as Identity from './identity/index.js';

package/src/mapping/Mapping.ts

@@ -129,12 +129,21 @@ export function getDataType(val: string): SchemaDataType {
   }
   throw new Error(`Passed dataType ${val} is not supported`);
 }
+
+const BaseSchemaTypeProperty = EffectSchema.Struct({
+  name: EffectSchema.NonEmptyTrimmedString,
+  knowledgeGraphId: EffectSchema.NullOr(EffectSchema.UUID),
+  /**
+   * @since 0.4.0
+   */
+  optional: EffectSchema.optional(EffectSchema.NullishOr(EffectSchema.Boolean)),
+});
+
 /**
  * @since 0.2.0
  */
 export const SchemaTypePropertyRelation = EffectSchema.Struct({
-  name: EffectSchema.NonEmptyTrimmedString,
-  knowledgeGraphId: EffectSchema.NullOr(EffectSchema.UUID),
+  ...BaseSchemaTypeProperty.fields,
   dataType: SchemaDataTypeRelation,
   relationType: EffectSchema.NonEmptyTrimmedString.annotations({
     identifier: 'SchemaTypePropertyRelation.relationType',
@@ -150,8 +159,7 @@ export type SchemaTypePropertyRelation = typeof SchemaTypePropertyRelation.Type;
  * @since 0.2.0
  */
 export const SchemaTypePropertyPrimitive = EffectSchema.Struct({
-  name: EffectSchema.NonEmptyTrimmedString,
-  knowledgeGraphId: EffectSchema.NullOr(EffectSchema.UUID),
+  ...BaseSchemaTypeProperty.fields,
   dataType: SchemaDataTypePrimitive,
 });
 /**
@@ -217,7 +225,7 @@ export const Schema = EffectSchema.Struct({
         {
           name: 'Account',
           knowledgeGraphId: null,
-          properties: [{ name: 'username', knowledgeGraphId: null, dataType: 'String' }],
+          properties: [{ name: 'username', optional: null, knowledgeGraphId: null, dataType: 'String' }],
         },
       ],
     },
@@ -226,7 +234,14 @@ export const Schema = EffectSchema.Struct({
         {
           name: 'Account',
           knowledgeGraphId: 'a5fd07b1-120f-46c6-b46f-387ef98396a6',
-          properties: [{ name: 'name', knowledgeGraphId: 'a126ca53-0c8e-48d5-b888-82c734c38935', dataType: 'String' }],
+          properties: [
+            {
+              name: 'name',
+              optional: true,
+              knowledgeGraphId: 'a126ca53-0c8e-48d5-b888-82c734c38935',
+              dataType: 'String',
+            },
+          ],
         },
       ],
     },