@merkl/api 0.9.15

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

@@ -0,0 +1,430 @@
+import { ProtocolService } from "@/modules/v4/protocol/protocol.service";
+import { apiDbClient } from "@db";
+import { Status } from "@db/api";
+import moment from "moment";
+import { AprService } from "../apr";
+import { RewardService } from "../reward";
+import { TvlService } from "../tvl";
+export class OpportunityRepository {
+    static #transformQueryToPrismaFilters(query) {
+        const { page: _page, items: _items, ...filters } = query;
+        //TODO: abstract away query to not be strictly equal to controller
+        const chainIds = query.chainId?.split(",").map(n => Number.parseInt(n));
+        const actions = query.action?.split(",");
+        const status = query.status?.split(",");
+        const tokens = query.tokens?.split(",");
+        const rewardTokenSymbol = query.rewardTokenSymbol;
+        const types = query.type?.split(",");
+        const protocols = query.mainProtocolId?.split(",");
+        const identifiers = query.identifier?.split(",");
+        const sort = (query.sort === "rewards" ? "dailyRewards" : query.sort) ?? "dailyRewards";
+        const order = query.order ?? "desc";
+        const test = query.test ?? false;
+        const point = query.point ?? false;
+        const creatorAddress = query.creatorAddress ?? null;
+        const identifier = query.identifier ?? null;
+        const orderBy = {
+            [sort]: order,
+        };
+        return {
+            orderBy,
+            where: {
+                tags: !filters.tags ? undefined : { has: filters.tags },
+                type: !filters.type ? undefined : { in: types },
+                tvl: filters.minimumTvl ? { gte: filters.minimumTvl } : undefined,
+                chainId: !chainIds ? undefined : { in: chainIds },
+                name: !filters.name ? undefined : { contains: filters.name, mode: "insensitive" },
+                action: !actions ? undefined : { in: actions },
+                status: !status ? undefined : { in: status },
+                mainProtocolId: !protocols ? undefined : { in: protocols, mode: "insensitive" },
+                identifier: !identifier ? undefined : { in: identifiers, mode: "insensitive" },
+                Campaigns: test && !creatorAddress && !rewardTokenSymbol
+                    ? undefined
+                    : {
+                        some: {
+                            RewardToken: test && !rewardTokenSymbol
+                                ? undefined
+                                : {
+                                    isTest: !test ? false : undefined,
+                                    isPoint: point,
+                                    symbol: rewardTokenSymbol ? { equals: rewardTokenSymbol, mode: "insensitive" } : undefined,
+                                },
+                            creatorAddress: creatorAddress ? creatorAddress : undefined,
+                        },
+                    },
+                Tokens: { some: { symbol: { in: tokens } } },
+            },
+        };
+    }
+    static #getRecordInclusion(withTest = true, withPoints = true) {
+        return {
+            AprRecords: {
+                take: 1,
+                orderBy: { timestamp: "desc" },
+                include: { AprBreakdown: true },
+            },
+            TvlRecords: {
+                take: 1,
+                orderBy: { timestamp: "desc" },
+                include: { TvlBreakdown: true },
+            },
+            DailyRewardsRecords: {
+                take: 1,
+                orderBy: { timestamp: "desc" },
+                include: {
+                    DailyRewardsBreakdown: {
+                        where: {
+                            Campaign: {
+                                RewardToken: withTest ? undefined : { isTest: false, isPoint: withPoints },
+                            },
+                        },
+                        include: {
+                            Campaign: {
+                                select: {
+                                    startTimestamp: true,
+                                    endTimestamp: true,
+                                    amount: true,
+                                    RewardToken: true,
+                                    CampaignStatus: true,
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        };
+    }
+    static #getCampaignInclusion(withTest = true, withPoints = true) {
+        return {
+            orderBy: {
+                endTimestamp: "desc",
+            },
+            where: withTest
+                ? undefined
+                : {
+                    RewardToken: {
+                        isTest: false,
+                        isPoint: withPoints,
+                    },
+                },
+            include: {
+                RewardToken: true,
+                ComputeChain: true,
+                DistributionChain: {
+                    include: {
+                        Explorer: true,
+                    },
+                },
+                Creator: true,
+                CampaignStatus: true, // [][0]
+            },
+        };
+    }
+    static async create(newOpp, upsert = false) {
+        if (!!newOpp.mainProtocol) {
+            let mainProtocol = await apiDbClient.protocol.findUnique({ where: { id: newOpp.mainProtocol } });
+            if (!mainProtocol) {
+                mainProtocol = await ProtocolService.create({
+                    id: newOpp.mainProtocol,
+                    name: newOpp.mainProtocol,
+                    tags: [newOpp.action],
+                    url: "",
+                    icon: "",
+                    description: "",
+                });
+            }
+            // Override action with the protocol's action if it differs
+            if (mainProtocol.tags.includes("AMM"))
+                newOpp.action = "POOL";
+            if (mainProtocol.tags.includes("DEX"))
+                newOpp.action = "POOL";
+            if (mainProtocol.tags.includes("BORROWING"))
+                newOpp.action = "BORROW";
+            if (mainProtocol.tags.includes("LENDING") && !!newOpp.name && newOpp.name.includes("Supply"))
+                newOpp.action = "LEND";
+        }
+        const data = {
+            id: newOpp.id,
+            action: newOpp.action ?? "HOLD",
+            identifier: newOpp.identifier,
+            name: newOpp.name,
+            status: newOpp.status,
+            type: newOpp.type,
+            Chain: { connect: { id: newOpp.chainId } },
+            MainProtocol: !!newOpp.mainProtocol ? { connect: { id: newOpp.mainProtocol } } : undefined,
+            Protocols: {
+                connect: (newOpp.protocols ?? []).map((protocol) => {
+                    return { id: protocol };
+                }),
+            },
+            Tokens: {
+                connect: newOpp.tokens.map((token) => {
+                    return {
+                        chainId_address: {
+                            chainId: token.chainId,
+                            address: token.address,
+                        },
+                    };
+                }),
+            },
+        };
+        if (upsert) {
+            await apiDbClient.opportunity.upsert({
+                where: { id: newOpp.id },
+                create: data,
+                update: data,
+            });
+        }
+        else {
+            const opportunity = await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });
+            if (!!opportunity) {
+                return opportunity;
+            }
+            await apiDbClient.opportunity.create({ data });
+        }
+        return await apiDbClient.opportunity.findUnique({ where: { id: newOpp.id } });
+    }
+    static async findUnique(id) {
+        return await apiDbClient.opportunity.findUnique({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Chain: true,
+                Campaigns: {
+                    include: {
+                        RewardToken: true,
+                    },
+                },
+                MainProtocol: true,
+                Protocols: true,
+                Tokens: true,
+            },
+            where: { id },
+        });
+    }
+    static async findUniqueOrThrow(id, withTest = true, withPoints = true, withCampaigns = false) {
+        return await apiDbClient.opportunity.findUniqueOrThrow({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(withTest, withPoints),
+                Campaigns: withCampaigns ? OpportunityRepository.#getCampaignInclusion(withTest, withPoints) : undefined,
+                Chain: { include: { Explorer: true } },
+                MainProtocol: true,
+                Protocols: true,
+                Tokens: {
+                    where: !withTest ? { isTest: false, isPoint: withPoints } : undefined,
+                },
+            },
+            where: { id },
+        });
+    }
+    /**
+     * Gets opportunities and campaigns for which filtered on campaigns
+     * @param filters
+     * @returns
+     */
+    static async findManyByCampaigns(where) {
+        return await apiDbClient.opportunity.findMany({
+            where: {
+                Campaigns: {
+                    some: where,
+                },
+            },
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Campaigns: OpportunityRepository.#getCampaignInclusion(true),
+                Chain: {
+                    include: {
+                        Explorer: true,
+                    },
+                },
+                MainProtocol: true,
+                Protocols: true,
+                Tokens: true,
+            },
+        });
+    }
+    static async findMany(query) {
+        // pagination by offset; might have to change to cursor based for performance
+        const { page: _page, items: _items } = query;
+        const page = _page ? _page : 0;
+        const items = _items ? _items : 20;
+        const withTest = query.test ?? false;
+        const withPoints = query.point ?? false;
+        const withCampaigns = query.campaigns ?? false;
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.opportunity.findMany({
+            take: items,
+            skip: page * items,
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(withTest, withPoints),
+                Campaigns: withCampaigns ? OpportunityRepository.#getCampaignInclusion(withTest, withPoints) : undefined,
+                MainProtocol: true,
+                Chain: {
+                    include: {
+                        Explorer: true,
+                    },
+                },
+                Protocols: true,
+                Tokens: {
+                    where: !withTest ? { isTest: false, isPoint: withPoints } : undefined,
+                },
+            },
+            ...args,
+        });
+    }
+    static async findLiveWithCampaigns(chainId, take) {
+        const now = moment().unix();
+        return await apiDbClient.opportunity.findMany({
+            include: {
+                ...OpportunityRepository.#getRecordInclusion(),
+                Campaigns: {
+                    include: {
+                        RewardToken: true,
+                        ComputeChain: true,
+                        DistributionChain: {
+                            include: {
+                                Explorer: true,
+                            },
+                        },
+                        CampaignStatus: true,
+                        Creator: true,
+                    },
+                    take: take ? take : undefined,
+                    orderBy: { endTimestamp: "desc" },
+                },
+                MainProtocol: true,
+                Chain: {
+                    include: {
+                        Explorer: true,
+                    },
+                },
+                Protocols: true,
+                Tokens: true,
+            },
+            where: {
+                status: "LIVE",
+                Chain: { id: chainId },
+                Campaigns: {
+                    some: {
+                        endTimestamp: {
+                            gt: now,
+                        },
+                    },
+                },
+            },
+        });
+    }
+    static async countMany(query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        return await apiDbClient.opportunity.count(args);
+    }
+    static async getAllIdsForDynamicOpp() {
+        return await apiDbClient.opportunity.findMany({
+            where: { type: { notIn: ["ERC20_SNAPSHOT", "JSON_AIRDROP"] } },
+            select: { id: true },
+        });
+    }
+    /**
+     * Updates Apr, Tvl and DailyRewards record
+     * @param opportunityId
+     * @param apr
+     * @param tvl
+     * @returns
+     */
+    static async updateRecords(opportunityId, apr, tvl, dailyRewards) {
+        const aprRecord = await apiDbClient.aprRecord.create({
+            data: {
+                id: AprService.hashId(opportunityId, apr.timestamp),
+                timestamp: apr.timestamp,
+                cumulated: apr.cumulated,
+                Opportunity: { connect: { id: opportunityId } },
+                AprBreakdown: { createMany: { data: apr.breakdowns } },
+            },
+        });
+        const tvlRecord = await apiDbClient.tVLRecord.create({
+            data: {
+                id: TvlService.hashId(opportunityId, tvl.timestamp),
+                timestamp: tvl.timestamp,
+                Opportunity: { connect: { id: opportunityId } },
+                total: tvl.total,
+                TvlBreakdown: { createMany: { data: tvl.breakdowns } },
+            },
+            include: { TvlBreakdown: true },
+        });
+        const dailyRewardsRecord = await apiDbClient.dailyRewardsRecord.create({
+            data: {
+                id: RewardService.hashDailyRewardsRecordId(opportunityId, dailyRewards.timestamp),
+                timestamp: dailyRewards.timestamp,
+                Opportunity: { connect: { id: opportunityId } },
+                total: dailyRewards.total,
+                DailyRewardsBreakdown: {
+                    createMany: {
+                        data: dailyRewards.breakdowns.map(breakdown => {
+                            return {
+                                campaignId: breakdown.campaignId,
+                                value: breakdown.value,
+                            };
+                        }),
+                    },
+                },
+            },
+            include: { DailyRewardsBreakdown: true },
+        });
+        const opportunity = await apiDbClient.opportunity.update({
+            where: { id: opportunityId },
+            data: { apr: apr.cumulated, tvl: tvl.total, dailyRewards: dailyRewards.total },
+        });
+        return {
+            aprRecord,
+            tvlRecord,
+            dailyRewardsRecord,
+            opportunity,
+        };
+    }
+    static async updateStatus(id, status) {
+        if (status === Status.PAST)
+            return await apiDbClient.opportunity.update({ where: { id }, data: { status, apr: 0, dailyRewards: 0 } });
+        return await apiDbClient.opportunity.update({ where: { id }, data: { status } });
+    }
+    static async updateName(id, name) {
+        return await apiDbClient.opportunity.update({ where: { id }, data: { name } });
+    }
+    static async updateChainId(id, chainId) {
+        return await apiDbClient.opportunity.update({ where: { id }, data: { chainId } });
+    }
+    static async aggregateSum(field, query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        const result = await apiDbClient.opportunity.aggregate({
+            _sum: {
+                [field]: true,
+            },
+            ...args,
+        });
+        return { sum: result._sum[field] ?? null };
+    }
+    static async aggregateMin(field, query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        const result = await apiDbClient.opportunity.aggregate({
+            _min: {
+                [field]: true,
+            },
+            ...args,
+        });
+        return { min: result._min[field] ?? null };
+    }
+    static async aggregateMax(field, query) {
+        const args = OpportunityRepository.#transformQueryToPrismaFilters(query);
+        const result = await apiDbClient.opportunity.aggregate({
+            _max: {
+                [field]: true,
+            },
+            ...args,
+        });
+        return { max: result._max[field] ?? null };
+    }
+    static async update(id, data) {
+        return await apiDbClient.opportunity.update({ where: { id }, data });
+    }
+    static async updateMany(ids, data) {
+        return await apiDbClient.opportunity.updateMany({ where: { id: { in: ids } }, data });
+    }
+}