fix(build): build errors after rebase

bitbeckers · bitbeckers · commit 8ae04bfac178 · 2025-04-08T20:02:06.000+02:00
- Removed metadata image service, this has been split in the resolver
- Updated Order invalidation cron job to use injected marketplace order
service
- Refactored order invalidation cron job to be singleton usin tsyringe
- Updated tests
diff --git a/src/cron/OrderInvalidation.ts b/src/cron/OrderInvalidation.ts
@@ -1,9 +1,10 @@
-import cron from "node-cron";
 import { OrderValidatorCode } from "@hypercerts-org/marketplace-sdk";
-import { SupabaseDataService } from "../services/SupabaseDataService.js";
+import { sql } from "kysely";
 import _ from "lodash";
+import cron from "node-cron";
+import { inject, singleton } from "tsyringe";
 import { kyselyData } from "../client/kysely.js";
-import { sql } from "kysely";
+import { MarketplaceOrdersService } from "../services/database/entities/MarketplaceOrdersEntityService.js";
 
 /**
  * These error codes are considered temporary and should be
@@ -14,18 +15,23 @@ export const TEMPORARILY_INVALID_ERROR_CODES = [
   OrderValidatorCode.TOO_EARLY_TO_EXECUTE_ORDER,
 ];
 
+@singleton()
 export default class OrderInvalidationCronjob {
-  private static instance: OrderInvalidationCronjob;
-  private dataService: SupabaseDataService;
+  private cronJob: cron.ScheduledTask | null = null;
 
-  private constructor() {
-    this.dataService = new SupabaseDataService();
-    this.setupCronJob();
-  }
+  constructor(
+    @inject(MarketplaceOrdersService)
+    private marketplaceOrdersService: MarketplaceOrdersService,
+  ) {}
+
+  public start(): void {
+    if (this.cronJob) {
+      // Already started
+      return;
+    }
 
-  private setupCronJob() {
-    // Run every 30 seconds
-    cron.schedule("*/30 * * * * *", async () => {
+    // Schedule the cron job
+    this.cronJob = cron.schedule("*/30 * * * * *", async () => {
       try {
         await this.invalidateOrders();
       } catch (error) {
@@ -34,9 +40,11 @@ export default class OrderInvalidationCronjob {
     });
   }
 
-  public static start(): void {
-    if (!OrderInvalidationCronjob.instance) {
-      OrderInvalidationCronjob.instance = new OrderInvalidationCronjob();
+  // Stop method is useful for testing or graceful shutdown
+  public stop(): void {
+    if (this.cronJob) {
+      this.cronJob.stop();
+      this.cronJob = null;
     }
   }
 
@@ -64,10 +72,10 @@ export default class OrderInvalidationCronjob {
     for (const chainId in ordersByChain) {
       const ordersForChain = ordersByChain[chainId];
       const tokenIds = _.uniq(ordersForChain.map((order) => order.itemIds[0]));
-      await this.dataService.validateOrdersByTokenIds({
+      await this.marketplaceOrdersService.validateOrdersByTokenIds(
         tokenIds,
-        chainId: parseInt(chainId, 10),
-      });
+        parseInt(chainId, 10),
+      );
     }
   }
 }
diff --git a/src/index.ts b/src/index.ts
@@ -10,6 +10,7 @@ import { RegisterRoutes } from "./__generated__/routes/routes.js";
 import * as Sentry from "@sentry/node";
 import SignatureRequestProcessorCron from "./cron/SignatureRequestProcessing.js";
 import OrderInvalidationCronjob from "./cron/OrderInvalidation.js";
+import { container } from "tsyringe";
 
 // @ts-expect-error BigInt is not supported by JSON
 BigInt.prototype.toJSON = function () {
@@ -47,7 +48,8 @@ Sentry.setupExpressErrorHandler(app);
 
 // Start Safe signature request processing cron job
 SignatureRequestProcessorCron.start();
-OrderInvalidationCronjob.start();
+const cronJob = container.resolve(OrderInvalidationCronjob);
+cronJob.start();
 
 app.listen(PORT, () => {
   console.log(
diff --git a/src/services/MetadataImageService.ts b/src/services/MetadataImageService.ts
diff --git a/src/services/database/entities/MarketplaceOrdersEntityService.ts b/src/services/database/entities/MarketplaceOrdersEntityService.ts
@@ -294,15 +294,22 @@ export class MarketplaceOrdersService {
       );
       const validationResults = await hec.checkOrdersValidity(matchingOrders);
 
-      ordersToUpdate.push(
-        ...validationResults
-          .filter((x) => !x.valid)
-          .map(({ validatorCodes, id }) => ({
-            id,
-            invalidated: true,
-            validator_codes: validatorCodes,
-          })),
-      );
+      // filter all orders that have changed validity or validator codes
+      const _changedOrders = validationResults
+        .filter((x) => {
+          const order = matchingOrders.find((y) => y.id === x.id);
+          return (
+            order?.invalidated !== x.valid ||
+            order?.validator_codes !== x.validatorCodes
+          );
+        })
+        .map((x) => ({
+          id: x.id,
+          invalidated: x.valid,
+          validator_codes: x.validatorCodes,
+        }));
+
+      ordersToUpdate.push(..._changedOrders);
     }
 
     return await this.updateOrders(ordersToUpdate);
diff --git a/src/services/graphql/resolvers/hyperboardResolver.ts b/src/services/graphql/resolvers/hyperboardResolver.ts
@@ -5,10 +5,10 @@ import { Args, FieldResolver, Query, Resolver, Root } from "type-graphql";
 import { DataKyselyService } from "../../../client/kysely.js";
 import { GetHyperboardsArgs } from "../../../graphql/schemas/args/hyperboardArgs.js";
 import {
+  GetHyperboardOwnersResponse,
   GetHyperboardsResponse,
-  Hyperboard,
-  HyperboardOwner,
   GetSectionsResponse,
+  Hyperboard,
 } from "../../../graphql/schemas/typeDefs/hyperboardTypeDefs.js";
 import GetUsersResponse from "../../../graphql/schemas/typeDefs/userTypeDefs.js";
 import { CachingDatabase } from "../../../types/kyselySupabaseCaching.js";
@@ -271,7 +271,7 @@ class HyperboardResolver {
    *          - Array of owners if found
    *          - null if an error occurs
    */
-  @FieldResolver(() => [HyperboardOwner])
+  @FieldResolver(() => GetHyperboardOwnersResponse)
   async owners(@Root() hyperboard: Hyperboard) {
     try {
       const sections = await this.sections(hyperboard);
diff --git a/test/utils/testUtils.ts b/test/utils/testUtils.ts
@@ -628,144 +628,76 @@ export function generateMockOrder(
   } as unknown as MarketplaceOrderSelect;
 }
 
-export function generateMockHyperboard(
-  overrides?: Partial<{
-    id: string;
-    name: string;
-    chain_ids: (bigint | number | string)[];
-    background_image: string;
-    grayscale_images: boolean;
-    tile_border_color: string;
-    admins: { data: ReturnType<typeof generateMockUser>[]; count: number };
-    sections: {
-      data: Array<{
-        label: string;
-        collection: ReturnType<typeof generateMockCollection>;
-        entries: {
-          id: string;
-          is_blueprint: boolean;
-          percentage_of_section: number;
-          display_size: number;
-          name?: string;
-          total_units?: bigint | number | string;
-          owners: {
-            data: Array<
-              ReturnType<typeof generateMockUser> & {
-                percentage: number;
-                units?: bigint | number | string;
-              }
-            >;
-            count: number;
-          };
-        }[];
-        owners: Array<{
-          data: Array<
-            ReturnType<typeof generateMockUser> & { percentage_owned: number }
-          >;
-          count: number;
-        }>;
-      }>;
-      count: number;
-    };
-    owners: {
-      data: Array<
-        ReturnType<typeof generateMockUser> & { percentage_owned: number }
-      >;
-      count: number;
-    };
-  }>,
-) {
+export function generateMockHyperboard() {
   const mockUser = generateMockUser();
   const mockCollection = generateMockCollection();
 
-  const defaultHyperboard = {
+  return {
     id: faker.string.uuid(),
-    name: faker.company.name(),
-    chain_ids: [generateChainId()],
+    name: faker.commerce.productName(),
+    chain_ids: [faker.number.bigInt()],
     background_image: faker.image.url(),
     grayscale_images: faker.datatype.boolean(),
     tile_border_color: faker.color.rgb(),
     admins: {
       data: [mockUser],
       count: 1,
     },
-    sections: [
-      {
-        data: [
-          {
-            label: faker.commerce.department(),
-            collection: mockCollection,
-            entries: [
-              {
-                id: faker.string.uuid(),
-                is_blueprint: faker.datatype.boolean(),
-                percentage_of_section: faker.number.float({
-                  min: 0,
-                  max: 100,
-                  fractionDigits: 2,
-                }),
-                display_size: faker.number.float({
-                  min: 1,
-                  max: 10,
-                  fractionDigits: 2,
-                }),
-                name: faker.commerce.productName(),
-                total_units: faker.number.bigInt({ min: 1000n, max: 1000000n }),
-                owners: {
-                  data: [
-                    {
-                      ...mockUser,
-                      percentage: faker.number.float({
-                        min: 0,
-                        max: 100,
-                        fractionDigits: 2,
-                      }),
-                      units: faker.number.bigInt({ min: 1n, max: 1000n }),
-                    },
-                  ],
-                  count: 1,
-                },
-              },
-            ],
-            owners: [
-              {
+    sections: {
+      data: [
+        {
+          label: faker.commerce.department(),
+          collections: [mockCollection],
+          entries: [
+            {
+              id: faker.string.uuid(),
+              is_blueprint: faker.datatype.boolean(),
+              percentage_of_section: faker.number.float({
+                min: 0,
+                max: 100,
+                fractionDigits: 2,
+              }),
+              display_size: faker.number.float({
+                min: 1,
+                max: 10,
+                fractionDigits: 2,
+              }),
+              name: faker.commerce.productName(),
+              total_units: faker.number.bigInt({ min: 1000n, max: 1000000n }),
+              owners: {
                 data: [
                   {
                     ...mockUser,
-                    percentage_owned: faker.number.float({
+                    percentage: faker.number.float({
                       min: 0,
                       max: 100,
                       fractionDigits: 2,
                     }),
+                    units: faker.number.bigInt({ min: 1n, max: 1000n }),
                   },
                 ],
                 count: 1,
               },
+            },
+          ],
+          owners: {
+            data: [
+              {
+                ...mockUser,
+                percentage_owned: faker.number.float({
+                  min: 0,
+                  max: 100,
+                  fractionDigits: 2,
+                }),
+              },
             ],
+            count: 1,
           },
-        ],
-        count: 1,
-      },
-    ],
-    owners: {
-      data: [
-        {
-          ...mockUser,
-          percentage_owned: faker.number.float({
-            min: 0,
-            max: 100,
-            fractionDigits: 2,
-          }),
         },
       ],
       count: 1,
     },
   };
-
-  return {
-    ...defaultHyperboard,
-    ...overrides,
-  };
 }
 
 // Check similarity of mock and returned object. The createdAt field is a timestamp and will be different. Its value in seconds should be the same.
