Merge pull request #64 from hypercerts-org/feature/expose-orders-in-g…

…raph

Feature/expose orders in graph

schema.graphql

@@ -142,6 +142,11 @@ input BasicMetadataWhereInput {
   work_timeframe_to: NumberSearchOptions
 }
 
+input BasicOrderWhereInput {
+  chain_id: NumberSearchOptions
+  id: IdSearchOptions
+}
+
 """
 The `BigInt` scalar type represents non-fractional signed whole numeric values.
 """
@@ -187,6 +192,7 @@ type Fraction {
   hypercert_id: ID
   id: ID!
   last_block_update_timestamp: BigInt
+  orders: GetOrdersResponse
   owner_address: String
   units: EthBigInt
 }
@@ -238,6 +244,11 @@ type GetHypercertsResponse {
   data: [Hypercert!]
 }
 
+type GetOrdersResponse {
+  count: Int
+  data: [Order!]
+}
+
 type Hypercert {
   attestations: GetAttestationsResponse
   contract: Contract
@@ -248,6 +259,7 @@ type Hypercert {
   id: ID!
   last_block_update_timestamp: BigInt
   metadata: Metadata
+  orders: GetOrdersResponse
   owner_address: String
   token_id: EthBigInt
   units: EthBigInt
@@ -346,13 +358,40 @@ input NumberSearchOptions {
   lte: BigInt
 }
 
+type Order {
+  additionalParameters: String!
+  amounts: [Float!]!
+  chainId: BigInt!
+  collection: String!
+  collectionType: Float!
+  createdAt: String!
+  currency: String!
+  endTime: Float!
+  globalNonce: String!
+  id: ID!
+  itemIds: [String!]!
+  orderNonce: String!
+  price: String!
+  quoteType: Float!
+  signature: String!
+  signer: String!
+  startTime: Float!
+  strategyId: Float!
+  subsetNonce: Float!
+}
+
+input OrderFetchInput {
+  by: ContractSortOptions
+}
+
 type Query {
   attestationSchemas(count: CountKeys, first: Int, offset: Int, sort: AttestationSchemaFetchInput, where: AttestationSchemaWhereInput): GetAttestationsSchemaResponse!
   attestations(count: CountKeys, first: Int, offset: Int, sort: AttestationFetchInput, where: AttestationWhereInput): GetAttestationsResponse!
   contracts(count: CountKeys, first: Int, offset: Int, sort: ContractFetchInput, where: BasicContractWhereInput): GetContractsResponse!
   fractions(count: CountKeys, first: Int, offset: Int, sort: FractionFetchInput, where: FractionWhereInput): GetFractionsResponse!
   hypercerts(count: CountKeys, first: Int, offset: Int, sort: HypercertFetchInput, where: HypercertsWhereInput): GetHypercertsResponse!
   metadata(count: CountKeys, first: Int, offset: Int, sort: MetadataFetchInput, where: MetadataWhereInput): [Metadata!]!
+  orders(count: CountKeys, first: Int, offset: Int, sort: OrderFetchInput, where: BasicOrderWhereInput): GetOrdersResponse!
 }
 
 """The direction to sort the query results"""

src/graphql/schemas/args/orderArgs.ts

@@ -0,0 +1,17 @@
+import { ArgsType, Field } from "type-graphql";
+import { PaginationArgs } from "./paginationArgs.js";
+import { BasicOrderWhereInput, OrderFetchInput } from "../inputs/orderInput.js";
+
+@ArgsType()
+export class GetOrdersArgs extends PaginationArgs {
+  @Field({ nullable: true })
+  where?: BasicOrderWhereInput;
+  @Field({ nullable: true })
+  sort?: OrderFetchInput;
+}
+
+@ArgsType()
+export class GetOrderByIdArgs {
+  @Field({ nullable: true })
+  id?: string;
+}

src/graphql/schemas/inputs/orderInput.ts

@@ -0,0 +1,20 @@
+import { Field, InputType } from "type-graphql";
+import type { WhereOptions } from "./whereOptions.js";
+import { IdSearchOptions, NumberSearchOptions } from "./searchOptions.js";
+import type { OrderOptions } from "./orderOptions.js";
+import { ContractSortOptions } from "./sortOptions.js";
+import { Order } from "../typeDefs/orderTypeDefs.js";
+
+@InputType()
+export class BasicOrderWhereInput implements WhereOptions<Order> {
+  @Field((_) => IdSearchOptions, { nullable: true })
+  id?: IdSearchOptions | null;
+  @Field((_) => NumberSearchOptions, { nullable: true })
+  chain_id?: NumberSearchOptions | null;
+}
+
+@InputType()
+export class OrderFetchInput implements OrderOptions<Order> {
+  @Field((_) => ContractSortOptions, { nullable: true })
+  by?: ContractSortOptions;
+}

src/graphql/schemas/resolvers/composed.ts

@@ -1,8 +1,17 @@
-import {HypercertResolver} from "./hypercertResolver.js";
-import {MetadataResolver} from "./metadataResolver.js";
-import {ContractResolver} from "./contractResolver.js";
-import {FractionResolver} from "./fractionResolver.js";
-import {AttestationResolver} from "./attestationResolver.js";
-import {AttestationSchemaResolver} from "./attestationSchemaResolver.js";
+import { HypercertResolver } from "./hypercertResolver.js";
+import { MetadataResolver } from "./metadataResolver.js";
+import { ContractResolver } from "./contractResolver.js";
+import { FractionResolver } from "./fractionResolver.js";
+import { AttestationResolver } from "./attestationResolver.js";
+import { AttestationSchemaResolver } from "./attestationSchemaResolver.js";
+import { OrderResolver } from "./orderResolver.js";
 
-export const resolvers = [ContractResolver, FractionResolver, MetadataResolver, HypercertResolver, AttestationResolver, AttestationSchemaResolver] as const;
+export const resolvers = [
+  ContractResolver,
+  FractionResolver,
+  MetadataResolver,
+  HypercertResolver,
+  AttestationResolver,
+  AttestationSchemaResolver,
+  OrderResolver,
+] as const;

src/graphql/schemas/resolvers/fractionResolver.ts

@@ -1,43 +1,107 @@
-import {Args, Field, Int, ObjectType, Query, Resolver} from "type-graphql";
-import {inject, injectable} from "tsyringe";
-import {SupabaseCachingService} from "../../../services/SupabaseCachingService.js";
-import {Fraction} from "../typeDefs/fractionTypeDefs.js";
-import {GetFractionArgs} from "../args/fractionArgs.js";
+import {
+  Args,
+  Field,
+  FieldResolver,
+  Int,
+  ObjectType,
+  Query,
+  Resolver,
+  Root,
+} from "type-graphql";
+import { inject, injectable } from "tsyringe";
+import { SupabaseCachingService } from "../../../services/SupabaseCachingService.js";
+import { Fraction } from "../typeDefs/fractionTypeDefs.js";
+import { GetFractionArgs } from "../args/fractionArgs.js";
+import { SupabaseDataService } from "../../../services/SupabaseDataService.js";
+import { parseClaimOrFractionId } from "@hypercerts-org/sdk";
 
 @ObjectType()
 export default class GetFractionsResponse {
-    @Field(() => [Fraction], {nullable: true})
-    data?: Fraction[];
+  @Field(() => [Fraction], { nullable: true })
+  data?: Fraction[];
 
-    @Field(() => Int, {nullable: true})
-    count?: number;
+  @Field(() => Int, { nullable: true })
+  count?: number;
 }
 
 @injectable()
-@Resolver(_ => Fraction)
+@Resolver((_) => Fraction)
 class FractionResolver {
+  constructor(
+    @inject(SupabaseCachingService)
+    private readonly supabaseCachingService: SupabaseCachingService,
+    @inject(SupabaseDataService)
+    private readonly supabaseDataService: SupabaseDataService,
+  ) {}
 
-    constructor(
-        @inject(SupabaseCachingService)
-        private readonly supabaseService: SupabaseCachingService) {
+  @Query((_) => GetFractionsResponse)
+  async fractions(@Args() args: GetFractionArgs) {
+    try {
+      const res = await this.supabaseCachingService.getFractions(args);
+
+      const { data, error, count } = res;
+
+      if (error) {
+        console.warn(
+          `[FractionResolver::fractions] Error fetching fractions: `,
+          error,
+        );
+      }
+
+      return { data, count };
+    } catch (e) {
+      throw new Error(
+        `[FractionResolver::fractions] Error fetching fractions: ${(e as Error).message}`,
+      );
+    }
+  }
+
+  @FieldResolver()
+  async orders(@Root() fraction: Partial<Fraction>) {
+    if (!fraction.hypercert_id) {
+      return null;
     }
 
-    @Query(_ => GetFractionsResponse)
-    async fractions(@Args() args: GetFractionArgs) {
-        try {
-            const res = await this.supabaseService.getFractions(args);
+    const { id } = parseClaimOrFractionId(fraction.hypercert_id);
+
+    if (!id) {
+      console.warn(
+        `[FractionResolver::orders] Error parsing hypercert_id for fraction ${fraction.id}`,
+      );
+      return null;
+    }
+
+    try {
+      const res = await this.supabaseDataService.getOrdersForFraction(
+        id.toString(),
+      );
+
+      if (!res) {
+        console.warn(
+          `[FractionResolver::orders] Error fetching orders for fraction ${fraction.id}: `,
+          res,
+        );
+        return { data: [] };
+      }
 
-            const {data, error, count} = res;
+      const { data, error, count } = res;
 
-            if (error) {
-                console.warn(`[FractionResolver::fractions] Error fetching fractions: `, error);
-            }
+      if (error) {
+        console.warn(
+          `[FractionResolver::orders] Error fetching orders for fraction ${fraction.id}: `,
+          error,
+        );
+        return { data: [] };
+      }
 
-            return {data, count};
-        } catch (e) {
-            throw new Error(`[FractionResolver::fractions] Error fetching fractions: ${(e as Error).message}`)
-        }
+      return { data: data || [], count: count || 0 };
+    } catch (e) {
+      const error = e as Error;
+      throw new Error(
+        `[FractionResolver::orders] Error fetching orders for fraction ${fraction.id}: ${error.message}`,
+      );
     }
+  }
 }
 
-export {FractionResolver};
+export { FractionResolver };