fix(resolver): claims and fractions nested queries

bitbeckers · bitbeckers · commit 911db1b8e0f0 · 2024-09-03T01:49:18.000+02:00
diff --git a/src/graphql/schemas/resolvers/baseTypes.ts b/src/graphql/schemas/resolvers/baseTypes.ts
@@ -103,11 +103,19 @@ export function createBaseResolver<T extends ClassType>(
           return queries.data.executeTakeFirst();
         }
 
+        console.log("got hypercerts queries: ", queries);
+
         return this.supabaseCachingService.db
           .transaction()
           .execute(async (transaction) => {
+            console.log("got transaction: ", transaction);
+            console.log("got transaction execute query: ", queries.data);
             const dataRes = await transaction.executeQuery(queries.data);
+
+            console.log("got hypercerts data: ", dataRes);
             const countRes = await transaction.executeQuery(queries.count);
+
+            console.log("got hypercerts data and count: ", dataRes, countRes);
             return {
               data: dataRes.rows,
               count: countRes.rows[0].count,
diff --git a/src/graphql/schemas/resolvers/fractionResolver.ts b/src/graphql/schemas/resolvers/fractionResolver.ts
@@ -24,7 +24,21 @@ class FractionResolver extends FractionBaseResolver {
   }
 
   @FieldResolver()
-  async orders(@Root() fraction: Partial<Fraction>) {
+  async metadata(@Root() fraction: Fraction) {
+    if (!fraction.claims_id) {
+      return;
+    }
+
+    return await this.getMetadata(
+      {
+        where: { hypercerts: { id: { eq: fraction.claims_id } } },
+      },
+      true,
+    );
+  }
+
+  @FieldResolver()
+  async orders(@Root() fraction: Fraction) {
     if (!fraction.fraction_id) {
       return null;
     }
@@ -71,21 +85,7 @@ class FractionResolver extends FractionBaseResolver {
   }
 
   @FieldResolver()
-  async metadata(@Root() fraction: Partial<Fraction>) {
-    if (!fraction.claims_id) {
-      return;
-    }
-
-    return await this.getMetadata(
-      {
-        where: { hypercerts: { id: { eq: fraction.claims_id } } },
-      },
-      true,
-    );
-  }
-
-  @FieldResolver()
-  async sales(@Root() fraction: Partial<Fraction>) {
+  async sales(@Root() fraction: Fraction) {
     if (!fraction.fraction_id) {
       return null;
     }
diff --git a/src/graphql/schemas/resolvers/hypercertResolver.ts b/src/graphql/schemas/resolvers/hypercertResolver.ts
@@ -73,10 +73,9 @@ class HypercertResolver extends HypercertBaseResolver {
       return;
     }
 
-    return await this.getFractions(
-      { where: { hypercert_id: { eq: hypercert.hypercert_id } } },
-      false,
-    );
+    return await this.getFractions({
+      where: { hypercert_id: { eq: hypercert.hypercert_id } },
+    });
   }
 
   @FieldResolver()
diff --git a/src/graphql/schemas/typeDefs/fractionTypeDefs.ts b/src/graphql/schemas/typeDefs/fractionTypeDefs.ts
@@ -17,6 +17,7 @@ class Fraction extends BasicTypeDef {
     description: "Address of the owner of the fractions",
   })
   owner_address?: string;
+
   @Field(() => EthBigInt, {
     nullable: true,
     description: "Units held by the fraction",
@@ -43,6 +44,7 @@ class Fraction extends BasicTypeDef {
     description: "Marketplace orders related to this fraction",
   })
   orders?: GetOrdersResponse;
+
   @Field(() => Metadata, {
     nullable: true,
     description: "The metadata for the fraction",
diff --git a/src/graphql/schemas/typeDefs/hypercertTypeDefs.ts b/src/graphql/schemas/typeDefs/hypercertTypeDefs.ts
@@ -37,11 +37,13 @@ class Hypercert extends HypercertBaseType {
       "Transferable fractions representing partial ownership of the hypercert",
   })
   fractions?: GetFractionsResponse;
+
   @Field(() => GetAttestationsResponse, {
     nullable: true,
     description: "Attestations for the hypercert or parts of its data",
   })
   attestations?: GetAttestationsResponse;
+
   @Field(() => GetOrdersForHypercertResponse, {
     nullable: true,
     description: "Marketplace orders related to this hypercert",
diff --git a/src/graphql/schemas/utils/filters-kysely.ts b/src/graphql/schemas/utils/filters-kysely.ts
@@ -1,128 +1,49 @@
-import {
-  IdSearchOptions,
-  NumberArraySearchOptions,
-  NumberSearchOptions,
-  StringArraySearchOptions,
-  StringSearchOptions
-} from "../inputs/searchOptions.js";
-
 type OperandType = string | number | bigint | string[] | bigint[];
-type OperatorType = "eq" | "gt" | "gte" | "lt" | "lte" | "ilike" | "contains" | "startsWith" | "endsWith"
+type OperatorType =
+  | "eq"
+  | "gt"
+  | "gte"
+  | "lt"
+  | "lte"
+  | "ilike"
+  | "contains"
+  | "startsWith"
+  | "endsWith";
+
+enum OperatorSymbols {
+  eq = "=",
+  gt = ">",
+  gte = ">=",
+  lt = "<",
+  lte = "<=",
+  ilike = "ilike",
+}
 
-export const generateFilterValues = (column: string, operator: OperatorType, operand: OperandType) => {
+export const generateFilterValues = (
+  column: string,
+  operator: OperatorType,
+  operand: OperandType,
+) => {
   console.log("generateFilterValues", column, operator, operand);
 
   switch (operator) {
     case "eq":
-      return [column, "=", operand];
+      return [column, OperatorSymbols.eq, operand];
     case "gt":
-      return [column, ">", operand];
+      return [column, OperatorSymbols.gt, operand];
     case "gte":
-      return [column, ">=", operand];
+      return [column, OperatorSymbols.gte, operand];
     case "lt":
-      return [column, "<", operand];
+      return [column, OperatorSymbols.lt, operand];
     case "lte":
-      return [column, "<=", operand];
+      return [column, OperatorSymbols.lte, operand];
     case "contains":
-      return [column, "like", `%${operand}%`];
+      return [column, OperatorSymbols.ilike, operand];
     case "startsWith":
-      return [column, "like", `${operand}%`];
+      return [column, OperatorSymbols.ilike, operand];
     case "endsWith":
-      return [column, "like", `%${operand}`];
+      return [column, OperatorSymbols.ilike, operand];
   }
 
   return [];
 };
-
-
-
-const generateArrayFilters = (value: NumberArraySearchOptions | StringArraySearchOptions, column: string) => {
-  const filters: [OperatorType, string, OperandType][] = [];
-  for (const [operator, operand] of Object.entries(value)) {
-    if (!operand) continue;
-
-    // Assert operand is an array of numbers
-    if (!Array.isArray(operand)) {
-      throw new Error(`Expected operand to be an array, but got ${typeof operand}`);
-    }
-
-    switch (operator) {
-      case "contains":
-        filters.push(["contains", column, operand]);
-        break;
-    }
-  }
-  return filters;
-};
-
-function isStringSearchOptions(value: unknown): value is StringSearchOptions {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const possibleStringSearchOptions = value as Partial<StringSearchOptions>;
-
-  // Check for properties unique to StringSearchOptions
-  const keys = ["eq", "contains", "startsWith", "endsWith"];
-  return keys.some(key => key in possibleStringSearchOptions);
-}
-
-function isNumberSearchOptions(value: unknown): value is NumberSearchOptions {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const possibleNumberSearchOptions = value as Partial<NumberSearchOptions>;
-
-  // Check for properties unique to NumberSearchOptions
-  const keys = ["eq", "gt", "gte", "lt", "lte"];
-  return keys.some(key => key in possibleNumberSearchOptions);
-}
-
-function isIdSearchOptions(value: unknown): value is IdSearchOptions {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const possibleIdSearchOptions = value as Partial<NumberSearchOptions>;
-
-  // Check for properties unique to IdSearchOptions
-  const keys = ["eq", "contains", "startsWith", "endsWith"];
-  return keys.some(key => key in possibleIdSearchOptions);
-
-}
-
-function isStringArraySearchOptions(value: unknown): value is StringArraySearchOptions {
-  if (!Array.isArray(value) || value === null) {
-    return false;
-  }
-
-  const possibleStringArraySearchOptions = value as Partial<StringArraySearchOptions>;
-
-  // Check for properties unique to StringArraySearchOptions
-  const keys = ["contains"];
-  return keys.some(key => key in possibleStringArraySearchOptions);
-}
-
-function isNumberArraySearchOptions(value: unknown): value is NumberArraySearchOptions {
-  if (!Array.isArray(value) || value === null) {
-    return false;
-  }
-
-  const possibleNumberArraySearchOptions = value as Partial<NumberArraySearchOptions>;
-
-  // Check for properties unique to NumberArraySearchOptions
-  const keys = ["contains"];
-  return keys.some(key => key in possibleNumberArraySearchOptions);
-}
-
-const buildFilters = (value: unknown, column: string) => {
-
-  if (isStringArraySearchOptions(value) || isNumberArraySearchOptions(value)) {
-    return generateArrayFilters(value, column);
-  }
-
-  return [];
-};
-
-
diff --git a/src/services/SupabaseCachingService.ts b/src/services/SupabaseCachingService.ts
@@ -110,21 +110,23 @@ export class SupabaseCachingService {
       case "claims":
         return this.db
           .selectFrom("claims")
-          .selectAll("claims") // Select all columns from the claims table
           .$if(args.where?.metadata, (qb) =>
             qb.innerJoin("metadata", "metadata.uri", "claims.uri"),
           )
           .$if(args.where?.attestations, (qb) =>
             qb.innerJoin("attestations", "attestations.claims_id", "claims.id"),
           )
           .$if(args.where?.fractions, (qb) =>
-            qb.innerJoin("fractions_view", (join) =>
-              join.on("fractions_view.claims_id", "=", "claims.id"),
+            qb.innerJoin(
+              "fractions_view",
+              "fractions_view.claims_id",
+              "claims.id",
             ),
           )
           .$if(args.where?.contract, (qb) =>
             qb.innerJoin("contracts", "contracts.id", "claims.contracts_id"),
-          );
+          )
+          .selectAll(); // Select all columns from the claims table
       case "contracts":
         return this.db.selectFrom("contracts").selectAll();
       case "fractions":
@@ -193,7 +195,11 @@ export class SupabaseCachingService {
             qb.innerJoin("attestations", "attestations.claims_id", "claims.id"),
           )
           .$if(args.where?.fractions, (qb) =>
-            qb.innerJoin("fractions", "fractions.claims_id", "claims.id"),
+            qb.innerJoin(
+              "fractions_view",
+              "fractions_view.claims_id",
+              "claims.id",
+            ),
           )
           .$if(args.where?.contract, (qb) =>
             qb.innerJoin("contracts", "contracts.id", "claims.contracts_id"),
@@ -262,6 +268,7 @@ export class SupabaseCachingService {
 
                 const res = generateFilterValues(column, _column, _value);
                 if (res.length > 0) {
+                  console.log("got filter values: ", res);
                   return eb(
                     `${tableName.toString()}.${res[0]}`,
                     res[1],
@@ -281,17 +288,39 @@ export class SupabaseCachingService {
                     _table = "contracts";
                   }
 
+                  if (column === "fractions") {
+                    _table = "fractions_view";
+                  }
+
+                  console.log(
+                    "generating nested filter values for: ",
+                    _table,
+                    _column,
+                    operator,
+                    operand,
+                  );
+
                   const [_col, _symbol, _input] = generateFilterValues(
                     `${_table}.${_column}`,
                     operator,
                     operand,
                   );
+
+                  console.log(
+                    "got nested filter values: ",
+                    _col,
+                    _symbol,
+                    _input,
+                  );
+
                   filters.push(eb(_col, _symbol, _input));
                 }
 
                 return filters.flat();
               });
             }
+
+            console.log("returning column and value: ", column, value);
             return column && value ? eb(column, "=", value) : [];
           }),
         ),
@@ -369,6 +398,10 @@ export class SupabaseCachingService {
                     _table = "contracts";
                   }
 
+                  if (column === "fractions") {
+                    _table = "fractions_view";
+                  }
+
                   const [_col, _symbol, _input] = generateFilterValues(
                     `${_table}.${_column}`,
                     operator,

Original file line number	Diff line number	Diff line change
`@@ -73,10 +73,9 @@ class HypercertResolver extends HypercertBaseResolver {`
`73`	`73`	`return;`
`74`	`74`	`}`
`75`	`75`
`76`		`- return await this.getFractions(`
`77`		`- { where: { hypercert_id: { eq: hypercert.hypercert_id } } },`
`78`		`- false,`
`79`		`- );`
	`76`	`+ return await this.getFractions({`
	`77`	`+ where: { hypercert_id: { eq: hypercert.hypercert_id } },`
	`78`	`+ });`
`80`	`79`	`}`
`81`	`80`
`82`	`81`	`@FieldResolver()`