common: use protocolNetwork configured, update indexingRules properties in model

Author: dwerner

packages/indexer-common/src/indexer-management/models/indexing-rule.ts

@@ -66,26 +66,26 @@ export class IndexingRule
   extends Model<IndexingRuleAttributes, IndexingRuleCreationAttributes>
   implements IndexingRuleAttributes
 {
-  public id!: number
-  public identifier!: string
-  public identifierType!: SubgraphIdentifierType
-  public allocationAmount!: string | null
-  public allocationLifetime!: number | null
-  public autoRenewal!: boolean
-  public parallelAllocations!: number | null
-  public maxAllocationPercentage!: number | null
-  public minSignal!: string | null
-  public maxSignal!: string | null
-  public minStake!: string | null
-  public minAverageQueryFees!: string | null
-  public custom!: string | null
-  public decisionBasis!: IndexingDecisionBasis
-  public requireSupported!: boolean
-  public safety!: boolean
-  public protocolNetwork!: string
+  public declare id: number
+  public declare identifier: string
+  public declare identifierType: SubgraphIdentifierType
+  public declare allocationAmount: string | null
+  public declare allocationLifetime: number | null
+  public declare autoRenewal: boolean
+  public declare parallelAllocations: number | null
+  public declare maxAllocationPercentage: number | null
+  public declare minSignal: string | null
+  public declare maxSignal: string | null
+  public declare minStake: string | null
+  public declare minAverageQueryFees: string | null
+  public declare custom: string | null
+  public declare decisionBasis: IndexingDecisionBasis
+  public declare requireSupported: boolean
+  public declare safety: boolean
+  public declare protocolNetwork: string
 
-  public createdAt!: Date
-  public updatedAt!: Date
+  public declare createdAt: Date
+  public declare updatedAt: Date
 
   // eslint-disable-next-line @typescript-eslint/ban-types
   public toGraphQL(): object {

packages/indexer-common/src/indexer-management/resolvers/actions.ts

@@ -13,7 +13,6 @@ import {
   IndexerManagementModels,
   OrderDirection,
   validateActionInputs,
-  validateNetworkIdentifier,
 } from '@graphprotocol/indexer-common'
 import { literal, Op, Transaction } from 'sequelize'
 import { ActionManager } from '../actions'
@@ -48,9 +47,7 @@ async function executeQueueOperation(
 
   // Check for duplicated actions
   const duplicateActions = actionsAwaitingExecution.filter(
-    (a) =>
-      a.deploymentID === action.deploymentID &&
-      a.protocolNetwork === action.protocolNetwork,
+    (a) => a.deploymentID === action.deploymentID,
   )
   if (duplicateActions.length === 0) {
     logger.trace('Inserting Action in database', { action })
@@ -158,13 +155,8 @@ export default {
       throw Error('IndexerManagementClient must be in `network` mode to modify actions')
     }
 
-    // Sanitize protocol network identifier
     actions.forEach((action) => {
-      try {
-        action.protocolNetwork = validateNetworkIdentifier(action.protocolNetwork)
-      } catch (e) {
-        throw Error(`Invalid value for the field 'protocolNetwork'. ${e}`)
-      }
+      action.protocolNetwork = network.networkMonitor.networkCAIPID
     })
 
     // Let Network Monitors validate actions based on their protocol networks

packages/indexer-common/src/indexer-management/resolvers/indexing-rules.ts

@@ -10,7 +10,6 @@ import { IndexerManagementDefaults, IndexerManagementResolverContext } from '../
 import { Transaction } from 'sequelize/types'
 import { fetchIndexingRules } from '../rules'
 import { processIdentifier } from '../../'
-import { validateNetworkIdentifier } from '../../parsers'
 import groupBy from 'lodash.groupby'
 
 const resetGlobalRule = async (
@@ -35,17 +34,14 @@ export default {
       identifier: indexingRuleIdentifier,
       merged,
     }: { identifier: IndexingRuleIdentifier; merged: boolean },
-    { models }: IndexerManagementResolverContext,
+    { models, network }: IndexerManagementResolverContext,
   ): Promise<object | null> => {
     const [identifier] = await processIdentifier(indexingRuleIdentifier.identifier, {
       all: false,
       global: true,
     })
 
-    // Sanitize protocol network identifier
-    const protocolNetwork = validateNetworkIdentifier(
-      indexingRuleIdentifier.protocolNetwork,
-    )
+    const protocolNetwork = network.networkMonitor.networkCAIPID
 
     const rule = await models.IndexingRule.findOne({
       where: { identifier, protocolNetwork },
@@ -62,36 +58,22 @@ export default {
   },
 
   indexingRules: async (
-    {
-      merged,
-      protocolNetwork: uncheckedProtocolNetwork,
-    }: { merged: boolean; protocolNetwork: string | undefined },
-    { models }: IndexerManagementResolverContext,
+    { merged }: { merged: boolean; protocolNetwork: string | undefined },
+    { models, network }: IndexerManagementResolverContext,
   ): Promise<object[]> => {
-    // Convert the input `protocolNetwork` value to a CAIP2-ID
-    const protocolNetwork = uncheckedProtocolNetwork
-      ? validateNetworkIdentifier(uncheckedProtocolNetwork)
-      : undefined
+    const protocolNetwork = network.networkMonitor.networkCAIPID
     return await fetchIndexingRules(models, merged, protocolNetwork)
   },
 
   setIndexingRule: async (
     { rule }: { rule: IndexingRuleCreationAttributes },
-    { models }: IndexerManagementResolverContext,
+    { models, network }: IndexerManagementResolverContext,
   ): Promise<object> => {
     if (!rule.identifier) {
       throw Error('Cannot set indexingRule without identifier')
     }
 
-    if (!rule.protocolNetwork) {
-      throw Error("Cannot set an indexing rule without the field 'protocolNetwork'")
-    } else {
-      try {
-        rule.protocolNetwork = validateNetworkIdentifier(rule.protocolNetwork)
-      } catch (e) {
-        throw Error(`Invalid value for the field 'protocolNetwork'. ${e}`)
-      }
-    }
+    rule.protocolNetwork = network.networkMonitor.networkCAIPID
 
     const [identifier] = await processIdentifier(rule.identifier, {
       all: false,
@@ -106,17 +88,14 @@ export default {
 
   deleteIndexingRule: async (
     { identifier: indexingRuleIdentifier }: { identifier: IndexingRuleIdentifier },
-    { models, defaults }: IndexerManagementResolverContext,
+    { models, defaults, network }: IndexerManagementResolverContext,
   ): Promise<boolean> => {
     const [identifier] = await processIdentifier(indexingRuleIdentifier.identifier, {
       all: false,
       global: true,
     })
 
-    // Sanitize protocol network identifier
-    const protocolNetwork = validateNetworkIdentifier(
-      indexingRuleIdentifier.protocolNetwork,
-    )
+    const protocolNetwork = network.networkMonitor.networkCAIPID
 
     const validatedRuleIdentifier = {
       protocolNetwork,
@@ -146,13 +125,13 @@ export default {
 
   deleteIndexingRules: async (
     { identifiers: indexingRuleIdentifiers }: { identifiers: IndexingRuleIdentifier[] },
-    { models, defaults }: IndexerManagementResolverContext,
+    { models, defaults, network }: IndexerManagementResolverContext,
   ): Promise<boolean> => {
     let totalNumDeleted = 0
 
     // Sanitize protocol network identifiers
     for (const identifier of indexingRuleIdentifiers) {
-      identifier.protocolNetwork = validateNetworkIdentifier(identifier.protocolNetwork)
+      identifier.protocolNetwork = network.networkMonitor.networkCAIPID
     }
 
     // Batch deletions by the `IndexingRuleIdentifier.protocolNetwork` attribute .

packages/indexer-common/src/indexer-management/rules.ts

@@ -6,15 +6,17 @@ import {
   IndexingRuleAttributes,
 } from '@graphprotocol/indexer-common'
 import { parseIndexingRule } from '../rules'
-import groupBy from 'lodash.groupby'
 
 export const fetchIndexingRules = async (
   models: IndexerManagementModels,
   merged: boolean,
   protocolNetwork?: string,
 ): Promise<IndexingRuleAttributes[]> => {
   // If unspecified, select indexing rules from all protocol networks
-  const whereClause = protocolNetwork ? { protocolNetwork } : {}
+  const logger = new Logger({ name: 'indexer-common' })
+
+  logger.info(`Fetching indexing rules for network '${protocolNetwork}'`)
+  const whereClause = {} // protocolNetwork ?{ protocolNetwork }: {}
   const rules = await models.IndexingRule.findAll({
     where: whereClause,
     order: [
@@ -23,16 +25,12 @@ export const fetchIndexingRules = async (
     ],
   })
   if (merged) {
-    // Merge rules by protocol network
-    return Object.entries(groupBy(rules, (rule) => rule.protocolNetwork))
-      .map(([protocolNetwork, rules]) => {
-        const global = rules.find((rule) => rule.identifier === INDEXING_RULE_GLOBAL)
-        if (!global) {
-          throw Error(`Could not find global rule for network '${protocolNetwork}'`)
-        }
-        return rules.map((rule) => rule.mergeGlobal(global))
-      })
-      .flat()
+    // Merge global rule into all rules
+    const global = rules.find((rule) => rule.identifier === INDEXING_RULE_GLOBAL)
+    if (!global) {
+      throw Error(`Could not find global rule for network '${protocolNetwork}'`)
+    }
+    return rules.map((rule) => rule.mergeGlobal(global))
   } else {
     return rules
   }