@merkl/api 0.10.299 → 0.10.301

package/dist/src/modules/v4/reward/reward.repository.d.ts

@@ -126,12 +126,22 @@ export declare abstract class RewardRepository {
         };
     })[]>;
     static updateClaimed(recipient: string, rewardTokenId: string, campaignId: string, reason: string, amount: string): Promise<Prisma.BatchPayload>;
-    static findManyBreakdownUniques(rewardTokenId: string, root: string, campaignId: string): Promise<{
+    static findManyBreakdownUniques(uniques: {
+        rewardId: string;
+        campaignId: string;
         reason: string;
-        Reward: {
-            recipient: string;
-        };
-    }[]>;
+    }[]): Promise<({
+        reason: string;
+        pending: string;
+        id: number;
+        campaignId: string;
+        amount: string;
+        protocolId: string | null;
+        claimed: string;
+        auxiliaryData1: string | null;
+        auxiliaryData2: string | null;
+        rewardId: string;
+    } | null)[]>;
     static upsertPendings(rewardTokenId: string, root: string, campaignId: string, toUpdate: PendingEntity[]): Promise<{
         reason: string;
         pending: string;

package/dist/src/modules/v4/reward/reward.repository.js

@@ -139,24 +139,16 @@ export class RewardRepository {
             },
         });
     }
-    static async findManyBreakdownUniques(rewardTokenId, root, campaignId) {
-        return await apiDbClient.rewardBreakdown.findMany({
+    static async findManyBreakdownUniques(uniques) {
+        return await apiDbClient.$transaction(uniques.map(x => apiDbClient.rewardBreakdown.findUnique({
             where: {
-                Reward: {
-                    root,
-                    rewardTokenId,
-                },
-                campaignId,
-            },
-            select: {
-                Reward: {
-                    select: {
-                        recipient: true,
-                    },
+                rewardId_campaignId_reason: {
+                    rewardId: x.rewardId,
+                    campaignId: x.campaignId,
+                    reason: x.reason,
                 },
-                reason: true,
             },
-        });
+        })));
     }
     static async upsertPendings(rewardTokenId, root, campaignId, toUpdate) {
         const users = toUpdate.map(x => x.recipient);

package/dist/src/modules/v4/reward/reward.service.js

@@ -238,23 +238,30 @@ export class RewardService {
             distributionChain: data.distributionChainId,
             campaignId: data.campaignId,
         });
-        // const ids = (await RewardRepository.findManyBreakdownUniques(rewardTokenId, data.root, campaignId)).map(
-        //   ({ Reward, reason }) => Bun.hash(`${Reward.recipient}${reason}`).toString()
-        // );
-        // const toUpdate = [];
-        // const toCreate = [];
-        // for (const point of data.data) {
-        //   if (ids.includes(Bun.hash(`${point.recipient}${point.reason}`).toString())) {
-        //     toUpdate.push(point);
-        //   } else {
-        //     toCreate.push(point);
-        //   }
-        // }
-        // await RewardRepository.updatePendings(rewardTokenId, data.root, campaignId, toUpdate);
-        // await RewardRepository.createPendings(rewardTokenId, data.root, campaignId, toCreate);
-        // return { created: toCreate.length, updated: toUpdate.length };
-        await RewardRepository.upsertPendings(rewardTokenId, data.root, campaignId, data.data);
-        return { created: data.data.length, updated: 0 };
+        let totalCreated = 0;
+        let totalUpdated = 0;
+        const uniques = await data.data.map(({ recipient, reason }) => {
+            const rewardId = RewardService.hashId(data.root, recipient, rewardTokenId);
+            return { rewardId, reason, campaignId };
+        });
+        for (let i = 0; i < uniques.length; i += 1000) {
+            const toUpdate = [];
+            const toCreate = [];
+            const exists = await RewardRepository.findManyBreakdownUniques(uniques.slice(i, Math.min(i + 1000, uniques.length)));
+            for (const [pointIndex, point] of data.data.slice(i, Math.min(i + 1000, uniques.length)).entries()) {
+                if (!!exists[pointIndex]) {
+                    toUpdate.push(point);
+                }
+                else {
+                    toCreate.push(point);
+                }
+            }
+            await RewardRepository.updatePendings(rewardTokenId, data.root, campaignId, toUpdate);
+            await RewardRepository.createPendings(rewardTokenId, data.root, campaignId, toCreate);
+            totalCreated += toCreate.length;
+            totalUpdated += toUpdate.length;
+        }
+        return { created: totalCreated, updated: totalUpdated };
     }
     static async countAllchains() {
         const rewardPerRewardTokenId = await RewardRepository.countRewardPerRewardTokenIdAndRoot();