add query config

Author: nikgraf

packages/hypergraph/src/entity/types.ts

@@ -2,7 +2,16 @@ import type * as Schema from 'effect/Schema';
 
 type SchemaKey<S extends Schema.Schema.AnyNoContext> = Extract<keyof Schema.Schema.Type<S>, string>;
 
+export type RelationSpacesOverride = 'all' | readonly string[];
+
+export type RelationIncludeConfig = {
+  relationSpaces?: RelationSpacesOverride;
+  valueSpaces?: RelationSpacesOverride;
+};
+
 export type RelationIncludeBranch = {
+  _config?: RelationIncludeConfig;
+} & {
   [key: string]: RelationIncludeBranch | boolean | undefined;
 };
 

packages/hypergraph/src/utils/get-relation-type-ids.ts

@@ -2,7 +2,7 @@ import { Constants, Utils } from '@graphprotocol/hypergraph';
 import * as Option from 'effect/Option';
 import type * as Schema from 'effect/Schema';
 import * as SchemaAST from 'effect/SchemaAST';
-import type { EntityInclude, RelationIncludeBranch } from '../entity/types.js';
+import type { EntityInclude, RelationIncludeBranch, RelationSpacesOverride } from '../entity/types.js';
 
 export type RelationListField = 'relations' | 'backlinks';
 
@@ -12,6 +12,8 @@ export type RelationTypeIdInfo = {
   listField: RelationListField;
   includeNodes: boolean;
   includeTotalCount: boolean;
+  relationSpaces?: RelationSpacesOverride;
+  valueSpaces?: RelationSpacesOverride;
   children?: RelationTypeIdInfo[];
 };
 
@@ -35,8 +37,9 @@ export const getRelationTypeIds = <S extends Schema.Schema.AnyNoContext>(
     const result = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(prop.type);
     if (Option.isSome(result)) {
       const propertyName = String(prop.name);
-      const includeBranch = include?.[propertyName as keyof EntityInclude<S>] as RelationIncludeBranch | undefined;
-      const includeNodes = isRelationIncludeBranch(includeBranch);
+      const includeBranchCandidate = include?.[propertyName as keyof EntityInclude<S>];
+      const includeBranch = isRelationIncludeBranch(includeBranchCandidate) ? includeBranchCandidate : undefined;
+      const includeNodes = Boolean(includeBranch);
       const includeTotalCount = hasTotalCountFlag(include as Record<string, unknown> | undefined, propertyName);
 
       if (!includeNodes && !includeTotalCount) {
@@ -53,6 +56,8 @@ export const getRelationTypeIds = <S extends Schema.Schema.AnyNoContext>(
         listField,
         includeNodes,
         includeTotalCount,
+        relationSpaces: includeBranch?._config?.relationSpaces,
+        valueSpaces: includeBranch?._config?.valueSpaces,
       };
       const nestedRelations: RelationTypeIdInfo[] = [];
 
@@ -78,8 +83,11 @@ export const getRelationTypeIds = <S extends Schema.Schema.AnyNoContext>(
 
           const nestedResult = SchemaAST.getAnnotation<string>(Constants.PropertyIdSymbol)(nestedProp.type);
           const nestedPropertyName = String(nestedProp.name);
-          const nestedIncludeBranch = includeBranch?.[nestedPropertyName];
-          const nestedIncludeNodes = isRelationIncludeBranch(nestedIncludeBranch);
+          const nestedIncludeBranchCandidate = includeBranch?.[nestedPropertyName];
+          const nestedIncludeBranch = isRelationIncludeBranch(nestedIncludeBranchCandidate)
+            ? nestedIncludeBranchCandidate
+            : undefined;
+          const nestedIncludeNodes = Boolean(nestedIncludeBranch);
           const nestedIncludeTotalCount = hasTotalCountFlag(
             includeBranch as Record<string, unknown> | undefined,
             nestedPropertyName,
@@ -96,6 +104,8 @@ export const getRelationTypeIds = <S extends Schema.Schema.AnyNoContext>(
               listField: nestedListField,
               includeNodes: nestedIncludeNodes,
               includeTotalCount: nestedIncludeTotalCount,
+              relationSpaces: nestedIncludeBranch?._config?.relationSpaces,
+              valueSpaces: nestedIncludeBranch?._config?.valueSpaces,
             };
             nestedRelations.push(nestedInfo);
           }

packages/hypergraph/src/utils/relation-query-helpers.ts

@@ -2,24 +2,56 @@ import type { RelationTypeIdInfo } from './get-relation-type-ids.js';
 
 type SpaceSelectionMode = 'single' | 'many' | 'all';
 
-const buildValuesListFilter = (spaceSelectionMode: SpaceSelectionMode) => {
-  if (spaceSelectionMode === 'single') {
-    return '(filter: {spaceId: {is: $spaceId}})';
+const stringifyUuidList = (spaces: readonly string[]) => `[${spaces.map((space) => JSON.stringify(space)).join(', ')}]`;
+
+const buildValuesListFilter = (
+  spaceSelectionMode: SpaceSelectionMode,
+  override?: RelationTypeIdInfo['valueSpaces'],
+) => {
+  if (!override) {
+    if (spaceSelectionMode === 'single') {
+      return '(filter: {spaceId: {is: $spaceId}})';
+    }
+    if (spaceSelectionMode === 'many') {
+      return '(filter: {spaceId: {in: $spaceIds}})';
+    }
+    return '';
+  }
+
+  if (override === 'all') {
+    return '';
   }
-  if (spaceSelectionMode === 'many') {
-    return '(filter: {spaceId: {in: $spaceIds}})';
+
+  if (override.length === 0) {
+    return '';
   }
-  return '';
+
+  return `(filter: {spaceId: {in: ${stringifyUuidList(override)}}})`;
 };
 
-const buildRelationSpaceFilter = (spaceSelectionMode: SpaceSelectionMode) => {
-  if (spaceSelectionMode === 'single') {
-    return 'spaceId: {is: $spaceId}, ';
+const buildRelationSpaceFilter = (
+  spaceSelectionMode: SpaceSelectionMode,
+  override?: RelationTypeIdInfo['relationSpaces'],
+) => {
+  if (!override) {
+    if (spaceSelectionMode === 'single') {
+      return 'spaceId: {is: $spaceId}, ';
+    }
+    if (spaceSelectionMode === 'many') {
+      return 'spaceId: {in: $spaceIds}, ';
+    }
+    return '';
   }
-  if (spaceSelectionMode === 'many') {
-    return 'spaceId: {in: $spaceIds}, ';
+
+  if (override === 'all') {
+    return '';
   }
-  return '';
+
+  if (override.length === 0) {
+    return '';
+  }
+
+  return `spaceId: {in: ${stringifyUuidList(override)}}, `;
 };
 
 export const getRelationAlias = (typeId: string) => `relations_${typeId.replace(/-/g, '_')}`;
@@ -31,8 +63,8 @@ const buildRelationsListFragment = (info: RelationTypeIdInfo, level: 1 | 2, spac
   const connectionField = listField === 'backlinks' ? 'backlinks' : 'relations';
   const toEntityField = listField === 'backlinks' ? 'fromEntity' : 'toEntity';
   const toEntitySelectionHeader = toEntityField === 'toEntity' ? 'toEntity' : `toEntity: ${toEntityField}`;
-  const valuesListFilter = buildValuesListFilter(spaceSelectionMode);
-  const relationSpaceFilter = buildRelationSpaceFilter(spaceSelectionMode);
+  const valuesListFilter = buildValuesListFilter(spaceSelectionMode, info.valueSpaces);
+  const relationSpaceFilter = buildRelationSpaceFilter(spaceSelectionMode, info.relationSpaces);
 
   if (!info.includeNodes && !info.includeTotalCount) {
     return '';

packages/hypergraph/test/utils/relation-config-overrides.test.ts

@@ -0,0 +1,107 @@
+import { Id } from '@graphprotocol/grc-20';
+import { describe, expect, it } from 'vitest';
+import * as Entity from '../../src/entity/index.js';
+import * as Type from '../../src/type/type.js';
+import { getRelationTypeIds } from '../../src/utils/get-relation-type-ids.js';
+import { buildRelationsSelection } from '../../src/utils/relation-query-helpers.js';
+
+const FRIENDS_RELATION_PROPERTY_ID = Id('f44ae32a-2f13-4d3f-875f-19d2338a32b8');
+const CHILDREN_RELATION_PROPERTY_ID = Id('8a6dcb99-9c7b-4ca9-9f7b-98f2f404b405');
+const PARENT_TYPES = [Id('842e8ae0-9904-40a8-9bfe-19e1f4400c5e')];
+const CHILD_TYPES = [Id('cd9a2ae2-831c-4fa2-b714-ad3aa254db7d')];
+const FRIEND_TYPES = [Id('35ac5c3e-4f31-466e-b3da-51fdfbb4b38e')];
+const NAME_PROPERTY_ID = Id('9f5e7ea4-51bb-4c9f-8739-7fa0aa695d02');
+
+const Friend = Entity.Schema(
+  {
+    nickname: Type.String,
+  },
+  {
+    types: FRIEND_TYPES,
+    properties: {
+      nickname: NAME_PROPERTY_ID,
+    },
+  },
+);
+
+const Child = Entity.Schema(
+  {
+    name: Type.String,
+    friends: Type.Relation(Friend),
+  },
+  {
+    types: CHILD_TYPES,
+    properties: {
+      name: NAME_PROPERTY_ID,
+      friends: FRIENDS_RELATION_PROPERTY_ID,
+    },
+  },
+);
+
+const Parent = Entity.Schema(
+  {
+    title: Type.String,
+    children: Type.Relation(Child),
+  },
+  {
+    types: PARENT_TYPES,
+    properties: {
+      title: NAME_PROPERTY_ID,
+      children: CHILDREN_RELATION_PROPERTY_ID,
+    },
+  },
+);
+
+describe('relation include config overrides', () => {
+  it('propagates spaces overrides to query fragments', () => {
+    const include = {
+      children: {
+        _config: {
+          relationSpaces: ['space-rel', 'space-rel-2'],
+          valueSpaces: ['space-values'],
+        },
+        friends: {
+          _config: {
+            relationSpaces: 'all',
+          },
+        },
+      },
+    } satisfies Entity.EntityInclude<typeof Parent>;
+
+    const relationInfo = getRelationTypeIds(Parent, include);
+    expect(relationInfo[0]).toMatchObject({
+      relationSpaces: ['space-rel', 'space-rel-2'],
+      valueSpaces: ['space-values'],
+    });
+    expect(relationInfo[0]?.children?.[0]).toMatchObject({
+      relationSpaces: 'all',
+    });
+
+    const selection = buildRelationsSelection(relationInfo, 'single');
+
+    expect(selection).toContain('spaceId: {in: ["space-rel", "space-rel-2"]}');
+    expect(selection).toContain('valuesList(filter: {spaceId: {in: ["space-values"]}})');
+    expect(selection.split('relations_f44ae32a_2f13_4d3f_875f_19d2338a32b8')[0]).not.toContain(
+      'spaceId: {is: $spaceId}',
+    );
+  });
+
+  it('omits filters entirely when overrides use "all"', () => {
+    const include = {
+      children: {
+        _config: {
+          relationSpaces: 'all',
+          valueSpaces: 'all',
+        },
+      },
+    } satisfies Entity.EntityInclude<typeof Parent>;
+
+    const relationInfo = getRelationTypeIds(Parent, include);
+    const selection = buildRelationsSelection(relationInfo, 'single');
+
+    expect(selection).not.toContain('spaceId: {is: $spaceId}');
+    expect(selection).not.toContain('spaceId: {in: $spaceIds}');
+    expect(selection).not.toContain('valuesList(filter: {spaceId: {is: $spaceId}})');
+    expect(selection).not.toContain('valuesList(filter: {spaceId: {in: $spaceIds}})');
+  });
+});