migrate to new indexer

Author: thelostone-mc

.env.example

@@ -3,6 +3,7 @@ SYNCHRONIZE=false
 LOGGING=true
 PORT=4000
 INDEXER_URL=https://grants-stack-indexer-v2.gitcoin.co/
+INDEXER_ADMIN_SECRET=your_indexer_admin_secret
 OPENAI_API_KEY=your_openai_api_key
 NODE_ENV=development
 # Performance tuning

src/controllers/evaluationController.ts

@@ -108,13 +108,27 @@ export const recreateEvaluationQuestions = async (
     return;
   }
 
-  await evaluationQuestionService.resetEvaluationQuestions(
-    chainId,
-    alloPoolId,
-    evaluationQuestions
+  const [errorReset] = await catchError(
+    evaluationQuestionService.resetEvaluationQuestions(
+      chainId,
+      alloPoolId,
+      evaluationQuestions
+    )
   );
 
-  await evaluationService.cleanEvaluations();
+  if (errorReset !== undefined) {
+    logger.error('Failed to reset evaluation questions', { errorReset });
+    res.status(500).json({ message: 'Failed to reset evaluation questions' });
+    return;
+  }
+
+  const [errorClean] = await catchError(evaluationService.cleanEvaluations());
+
+  if (errorClean !== undefined) {
+    logger.error('Failed to clean evaluations', { errorClean });
+    res.status(500).json({ message: 'Failed to clean evaluations' });
+    return;
+  }
 
   res.status(200).json(evaluationQuestions);
 };
@@ -150,14 +164,16 @@ export const evaluateApplication = async (
     summaryInput,
   };
 
-  const isAllowed = await isPoolManager<CreateEvaluationParams>(
-    createEvaluationParams,
-    signature,
-    chainId,
-    alloPoolId
+  const [isAllowedError, isAllowed] = await catchError(
+    isPoolManager<CreateEvaluationParams>(
+      createEvaluationParams,
+      signature,
+      chainId,
+      alloPoolId
+    )
   );
 
-  if (!isAllowed) {
+  if (isAllowedError !== undefined || isAllowed === undefined) {
     logger.warn(
       `User with address: ${evaluator} is not allowed to evaluate application`
     );
@@ -301,16 +317,17 @@ export const triggerLLMEvaluation = async (
     questions,
   };
 
-  try {
-    await createLLMEvaluations([data]);
-    res.status(200).json({ message: 'LLM evaluation triggered successfully' });
-  } catch (error) {
+  const [error] = await catchError(createLLMEvaluations([data]));
+  if (error !== undefined) {
     logger.error('Failed to create evaluations:', error);
     res.status(500).json({
       message: 'Failed to create evaluations',
       error: error.message,
     });
   }
+
+  logger.info('LLM evaluation triggered successfully');
+  res.status(200).json({ message: 'LLM evaluation triggered successfully' });
 };
 
 const batchPromises = <T>(array: T[], batchSize: number): T[][] => {

src/controllers/passportValidationController.ts

@@ -1,12 +1,15 @@
 import type { Request, Response } from 'express';
-import { validateRequest } from '@/utils';
+import { catchError, validateRequest } from '@/utils';
 import type { ProjectApplicationForManager } from '@/ext/passport/types';
 import { isVerified } from '@/ext/passport/credentialverification';
+import { createLogger } from '@/logger';
 
 interface SocialCredentialBody {
   application: Partial<ProjectApplicationForManager>;
 }
 
+const logger = createLogger();
+
 export const validateSocialCredential = async (
   req: Request,
   res: Response
@@ -15,13 +18,16 @@ export const validateSocialCredential = async (
 
   const { application } = req.body as SocialCredentialBody;
 
-  try {
-    const result = await isVerified(application);
-    res.json({
-      message: 'Social credential validated',
-      provider: result,
-    });
-  } catch (error) {
+  const [error, result] = await catchError(isVerified(application));
+  if (error !== undefined) {
+    logger.error('Failed to validate social credential:', error);
     res.status(400).json({ message: 'Error validating social credential' });
+    return;
   }
+
+  logger.info('Social credential validated', { result });
+  res.json({
+    message: 'Social credential validated',
+    provider: result,
+  });
 };

src/controllers/poolController.ts

@@ -186,11 +186,17 @@ const handlePoolEvaluationQuestions = async (
   pool: Pool,
   poolMetadata: IndexerRoundMetadata
 ): Promise<PromptEvaluationQuestions> => {
-  const questions =
-    await evaluationQuestionService.getEvaluationQuestionsByAlloPoolId(
+  const [error, questions] = await catchError(
+    evaluationQuestionService.getEvaluationQuestionsByAlloPoolId(
       pool.alloPoolId,
       pool.chainId
-    );
+    )
+  );
+
+  if (error !== undefined || questions === undefined) {
+    logger.error('Failed to get evaluation questions:', error);
+    throw new Error('Failed to get evaluation questions');
+  }
 
   if (questions.length > 0) {
     return questions.map(question => question.question);

src/env.ts

@@ -10,6 +10,7 @@ interface EnvVars {
   SYNCHRONIZE: string;
   LOGGING: string;
   INDEXER_URL: string;
+  INDEXER_ADMIN_SECRET: string;
   OPENAI_API_KEY: string;
   [key: string]: string | number | undefined;
 }
@@ -25,6 +26,7 @@ export const env: EnvVars = {
   SYNCHRONIZE: process.env.SYNCHRONIZE ?? 'false',
   LOGGING: process.env.LOGGING ?? 'false',
   INDEXER_URL: process.env.INDEXER_URL ?? '',
+  INDEXER_ADMIN_SECRET: process.env.INDEXER_ADMIN_SECRET ?? '',
   OPENAI_API_KEY: process.env.OPENAI_API_KEY ?? '',
   ...process.env,
 };

src/ext/indexer/indexer.ts

@@ -85,9 +85,11 @@ class IndexerClient {
       const response: ManagerRolesResponse = await request(
         this.indexerEndpoint,
         getRoundManager,
-        requestVariables
+        requestVariables,
+        {
+          'x-hasura-admin-secret': env.INDEXER_ADMIN_SECRET,
+        }
       );
-
       if (response.rounds.length === 0) {
         this.logger.warn(
           `No round found for poolId: ${alloPoolId} on chainId: ${chainId}`
@@ -97,15 +99,15 @@ class IndexerClient {
 
       const round = response.rounds[0];
 
-      if (round.roles.length === 0) {
+      if (round.roundRoles.length === 0) {
         this.logger.warn(
           `No manager found for poolId: ${alloPoolId} on chainId: ${chainId}`
         );
         return [];
       }
 
       this.logger.info(`Successfully fetched round manager`);
-      return round.roles.map(role => role.address);
+      return round.roundRoles.map(role => role.address);
     } catch (error) {
       this.logger.error(`Failed to fetch round manager: ${error.message}`, {
         error,
@@ -147,7 +149,10 @@ class IndexerClient {
       const response: RoundApplicationsQueryResponse = await request(
         this.indexerEndpoint,
         getRoundWithApplications,
-        requestVariables
+        requestVariables,
+        {
+          'x-hasura-admin-secret': env.INDEXER_ADMIN_SECRET,
+        }
       );
 
       if (response.rounds.length === 0) {
@@ -194,18 +199,21 @@ class IndexerClient {
       const response: ApplicationRoundQueryResponse = await request(
         this.indexerEndpoint,
         getApplicationWithRound,
-        requestVariables
+        requestVariables,
+        {
+          'x-hasura-admin-secret': env.INDEXER_ADMIN_SECRET,
+        }
       );
 
-      const application = response.application;
+      const application = response.applications[0];
 
       if (application == null) {
         this.logger.warn(
           `No application found for applicationId: ${applicationId} in roundId: ${roundId} on chainId: ${chainId}`
         );
         return null;
       }
-      return response.application;
+      return application;
     } catch (error) {
       this.logger.error(
         `Failed to fetch round with single application: ${error.message}`,

src/ext/indexer/queries.ts

@@ -2,10 +2,8 @@ import { gql } from 'graphql-request';
 
 export const getRoundManager = gql`
   query RoundManager($chainId: Int!, $alloPoolId: String!) {
-    rounds(
-      filter: { chainId: { equalTo: $chainId }, id: { equalTo: $alloPoolId } }
-    ) {
-      roles {
+    rounds(where: { chainId: { _eq: $chainId }, id: { _eq: $alloPoolId } }) {
+      roundRoles {
         address
       }
     }
@@ -14,9 +12,7 @@ export const getRoundManager = gql`
 
 export const getRoundWithApplications = gql`
   query RoundApplications($chainId: Int!, $roundId: String!) {
-    rounds(
-      filter: { chainId: { equalTo: $chainId }, id: { equalTo: $roundId } }
-    ) {
+    rounds(where: { chainId: { _eq: $chainId }, id: { _eq: $roundId } }) {
       chainId
       id
       roundMetadata
@@ -27,7 +23,7 @@ export const getRoundWithApplications = gql`
         metadataCid
         status
         projectId
-        project: canonicalProject {
+        project {
           metadata
           metadataCid
         }
@@ -42,7 +38,13 @@ export const getApplicationWithRound = gql`
     $roundId: String!
     $applicationId: String!
   ) {
-    application(chainId: $chainId, roundId: $roundId, id: $applicationId) {
+    applications(
+      where: {
+        chainId: { _eq: $chainId }
+        roundId: { _eq: $roundId }
+        id: { _eq: $applicationId }
+      }
+    ) {
       metadata
       metadataCid
       round {

src/ext/indexer/types.ts

@@ -94,12 +94,12 @@ export interface ApplicationWithRound {
 }
 
 export interface ApplicationRoundQueryResponse {
-  application: ApplicationWithRound;
+  applications: ApplicationWithRound[];
 }
 
 export interface ManagerRolesResponse {
   rounds: Array<{
-    roles: Array<{
+    roundRoles: Array<{
       address: string;
     }>;
   }>;

src/utils.ts

@@ -59,14 +59,23 @@ export async function isPoolManager<T>(
   chainId: number,
   alloPoolId: string
 ): Promise<boolean> {
-  const validAddresses = await indexerClient.getRoundManager({
-    chainId,
-    alloPoolId,
-  });
+  const [error, validAddresses] = await catchError(
+    indexerClient.getRoundManager({
+      chainId,
+      alloPoolId,
+    })
+  );
+
+  if (error !== undefined || validAddresses === undefined) {
+    logger.error('Failed to fetch pool manager', { error });
+    return false;
+  }
+
   if (env.NODE_ENV === 'development' && signature === '0xdeadbeef') {
     logger.info('Skipping signature check in development mode');
     return true;
   }
+
   try {
     const address = await recoverSignerAddress(obj, signature);
     logger.info(`Recovered address: ${address}`);