fix: pass dataType for orderBy entity queries

Ordered entity queries started returning empty results on testnet because entitiesOrderedByProperty now requires a dataType argument. The SDK was forwarding propertyId and sortDirection but not dataType, so orderBy calls silently returned no rows.

This infers the GraphQL dataType from the schema property metadata, passes it with orderBy queries, and throws a clear error when an unsupported field is used for ordering. It also adds coverage for property-type to dataType mapping.

Author: baiirun

packages/hypergraph/src/entity/find-many-public.ts

@@ -50,6 +50,7 @@ const buildEntitiesQuery = (
         : undefined,
     '$typeIds: [UUID!]!',
     useOrderBy ? '$propertyId: UUID!' : undefined,
+    useOrderBy ? '$dataType: String!' : undefined,
     useOrderBy ? '$sortDirection: SortOrder!' : undefined,
     '$first: Int',
     '$filter: EntityFilter!',
@@ -68,7 +69,7 @@ const buildEntitiesQuery = (
   // entitiesOrderedByProperty doesn't support the native typeIds filter yet,
   // so we fall back to the relation-based filter for orderBy queries
   if (useOrderBy) {
-    const orderByArgs = 'propertyId: $propertyId\n    sortDirection: $sortDirection\n    ';
+    const orderByArgs = 'propertyId: $propertyId\n    dataType: $dataType\n    sortDirection: $sortDirection\n    ';
     const entitySpaceFilter =
       spaceSelection.mode === 'single'
         ? 'spaceIds: {in: [$spaceId]},'
@@ -282,6 +283,7 @@ export const findManyPublic = async <
   );
 
   let orderByPropertyId: string | undefined;
+  let orderByDataType: Utils.OrderByDataType | undefined;
   let sortDirection: GraphSortDirection | undefined;
 
   if (orderBy) {
@@ -304,6 +306,11 @@ export const findManyPublic = async <
       throw new Error(`Property "${String(orderBy.property)}" is missing a propertyId annotation`);
     }
 
+    orderByDataType = Utils.getOrderByDataType(propertyType);
+    if (!orderByDataType) {
+      throw new Error(`Property "${String(orderBy.property)}" cannot be used in orderBy`);
+    }
+
     orderByPropertyId = propertyIdAnnotation.value;
     sortDirection = orderBy.direction === 'asc' ? 'ASC' : 'DESC';
   }
@@ -329,8 +336,9 @@ export const findManyPublic = async <
     queryVariables.spaceIds = spaceSelection.spaceIds;
   }
 
-  if (orderByPropertyId && sortDirection) {
+  if (orderByPropertyId && orderByDataType && sortDirection) {
     queryVariables.propertyId = orderByPropertyId;
+    queryVariables.dataType = orderByDataType;
     queryVariables.sortDirection = sortDirection;
   }
 

packages/hypergraph/src/utils/convert-property-value.ts

@@ -2,6 +2,37 @@ import { Constants } from '@graphprotocol/hypergraph';
 import * as Option from 'effect/Option';
 import * as SchemaAST from 'effect/SchemaAST';
 
+export type OrderByDataType = 'text' | 'boolean' | 'float' | 'datetime' | 'point' | 'schedule';
+
+const ORDER_BY_DATA_TYPE_BY_PROPERTY_TYPE: Record<string, OrderByDataType | undefined> = {
+  string: 'text',
+  boolean: 'boolean',
+  number: 'float',
+  date: 'datetime',
+  point: 'point',
+  schedule: 'schedule',
+  relation: undefined,
+};
+
+export const getOrderByDataType = (type: SchemaAST.AST): OrderByDataType | undefined => {
+  const propertyType = SchemaAST.getAnnotation<string>(Constants.PropertyTypeSymbol)(type);
+  if (Option.isSome(propertyType)) {
+    return ORDER_BY_DATA_TYPE_BY_PROPERTY_TYPE[propertyType.value];
+  }
+
+  if (SchemaAST.isStringKeyword(type)) {
+    return 'text';
+  }
+  if (SchemaAST.isBooleanKeyword(type)) {
+    return 'boolean';
+  }
+  if (SchemaAST.isNumberKeyword(type)) {
+    return 'float';
+  }
+
+  return undefined;
+};
+
 export const convertPropertyValue = (
   property: {
     propertyId: string;

packages/hypergraph/test/entity/find-many-public.test.ts

@@ -3,12 +3,18 @@ import { describe, expect, it } from 'vitest';
 import { parseResult } from '../../src/entity/find-many-public.js';
 import * as Entity from '../../src/entity/index.js';
 import * as Type from '../../src/type/type.js';
+import { getOrderByDataType } from '../../src/utils/convert-property-value.js';
 import { getRelationTypeIds } from '../../src/utils/get-relation-type-ids.js';
 import { getRelationAlias } from '../../src/utils/relation-query-helpers.js';
 
 const TITLE_PROPERTY_ID = Id('79c1a9510074401087d07501ef9d7b3d');
 const CHILDREN_RELATION_PROPERTY_ID = Id('ca7c7167250249c490b084c147f9b12b');
 const CHILD_NAME_PROPERTY_ID = Id('25584af039414ab986f7a603305b19bb');
+const SCORE_PROPERTY_ID = Id('0f0f62df02194f16983ad2ae5fc43ee5');
+const IS_ACTIVE_PROPERTY_ID = Id('774f4b5dbfaf4af5925ef4c7ef2ebd76');
+const PUBLISHED_AT_PROPERTY_ID = Id('2ece4d97ea964a269f3fee0d0f00de53');
+const LOCATION_PROPERTY_ID = Id('2df8bd4f7bc34aafaa8db20e3ad41657');
+const CADENCE_PROPERTY_ID = Id('0f7952a1f8474b4286d0ef7e6ef8dbb2');
 
 const Child = Entity.Schema(
   {
@@ -36,6 +42,44 @@ const Parent = Entity.Schema(
   },
 );
 
+const OrderableParent = Entity.Schema(
+  {
+    title: Type.String,
+    score: Type.Number,
+    isActive: Type.Boolean,
+    publishedAt: Type.Date,
+    location: Type.Point,
+    cadence: Type.ScheduleString,
+    children: Type.Relation(Child),
+  },
+  {
+    types: [Id('af571d8c06d44add8cfa4c6b50412254')],
+    properties: {
+      title: TITLE_PROPERTY_ID,
+      score: SCORE_PROPERTY_ID,
+      isActive: IS_ACTIVE_PROPERTY_ID,
+      publishedAt: PUBLISHED_AT_PROPERTY_ID,
+      location: LOCATION_PROPERTY_ID,
+      cadence: CADENCE_PROPERTY_ID,
+      children: CHILDREN_RELATION_PROPERTY_ID,
+    },
+  },
+);
+
+const getPropertyTypeAst = (property: string) => {
+  const ast = OrderableParent.ast;
+  if (!('propertySignatures' in ast)) {
+    throw new Error('Expected schema AST to be a TypeLiteral');
+  }
+
+  const signature = ast.propertySignatures.find((prop) => String(prop.name) === property);
+  if (!signature) {
+    throw new Error(`Property ${property} not found in schema`);
+  }
+
+  return signature.type;
+};
+
 const buildValueEntry = (
   propertyId: string,
   value: Partial<{
@@ -57,6 +101,16 @@ const buildValueEntry = (
 });
 
 describe('findManyPublic parseResult', () => {
+  it('maps schema property types to orderBy data types', () => {
+    expect(getOrderByDataType(getPropertyTypeAst('title'))).toBe('text');
+    expect(getOrderByDataType(getPropertyTypeAst('score'))).toBe('float');
+    expect(getOrderByDataType(getPropertyTypeAst('isActive'))).toBe('boolean');
+    expect(getOrderByDataType(getPropertyTypeAst('publishedAt'))).toBe('datetime');
+    expect(getOrderByDataType(getPropertyTypeAst('location'))).toBe('point');
+    expect(getOrderByDataType(getPropertyTypeAst('cadence'))).toBe('schedule');
+    expect(getOrderByDataType(getPropertyTypeAst('children'))).toBeUndefined();
+  });
+
   it('collects invalidEntities when decoding fails', () => {
     const queryData = {
       entities: [