[MEX-698] Remove @Parent decorator from field resolvers

src/modules/auto-router/auto-router.resolver.ts

@@ -15,7 +15,7 @@ export class SwapRouteResolver {
     constructor(protected readonly autoRouterService: AutoRouterService) {}
 
     @ResolveField(() => [String])
-    fees(@Parent() parent: AutoRouteModel): string[] {
+    fees(parent: AutoRouteModel): string[] {
         const fees = this.autoRouterService.getFeesDenom(
             parent.intermediaryAmounts,
             parent.tokenRoute,
@@ -26,7 +26,7 @@ export class SwapRouteResolver {
     }
 
     @ResolveField(() => [String])
-    pricesImpact(@Parent() parent: AutoRouteModel): string[] {
+    pricesImpact(parent: AutoRouteModel): string[] {
         return this.autoRouterService.getPriceImpactPercents(
             parent.intermediaryAmounts,
             parent.tokenRoute,

src/modules/energy/energy.resolver.ts

@@ -1,12 +1,5 @@
 import { UseGuards } from '@nestjs/common';
-import {
-    Args,
-    Int,
-    Parent,
-    Query,
-    ResolveField,
-    Resolver,
-} from '@nestjs/graphql';
+import { Args, Int, Query, ResolveField, Resolver } from '@nestjs/graphql';
 import { leaguesConfig, scAddress } from 'src/config';
 import { AuthUser } from '../auth/auth.user';
 import { UserAuthResult } from '../auth/user.auth.result';
@@ -42,7 +35,7 @@ export class UserEnergyResolver {
     ) {}
 
     @ResolveField()
-    async league(@Parent() parent: UserEnergyModel): Promise<string> {
+    async league(parent: UserEnergyModel): Promise<string> {
         return this.energyCompute.computeLeagueByEnergy(parent.amount);
     }
 

src/modules/farm/base-module/farm.resolver.ts

@@ -1,4 +1,4 @@
-import { Resolver, ResolveField, Parent } from '@nestjs/graphql';
+import { Resolver, ResolveField } from '@nestjs/graphql';
 import { BaseFarmModel } from '../models/farm.model';
 import { PairModel } from '../../pair/models/pair.model';
 import { EsdtToken } from '../../tokens/models/esdtToken.model';
@@ -25,101 +25,89 @@ export class FarmResolver {
     ) {}
 
     @ResolveField()
-    async farmedToken(@Parent() parent: BaseFarmModel): Promise<EsdtToken> {
+    async farmedToken(parent: BaseFarmModel): Promise<EsdtToken> {
         return this.farmAbiLoader.farmedTokenLoader.load(parent.address);
     }
 
     @ResolveField()
-    async farmToken(@Parent() parent: BaseFarmModel): Promise<NftCollection> {
+    async farmToken(parent: BaseFarmModel): Promise<NftCollection> {
         return this.farmAbiLoader.farmTokenLoader.load(parent.address);
     }
 
     @ResolveField()
-    async farmingToken(@Parent() parent: BaseFarmModel): Promise<EsdtToken> {
+    async farmingToken(parent: BaseFarmModel): Promise<EsdtToken> {
         return this.farmAbiLoader.farmingTokenLoader.load(parent.address);
     }
 
     @ResolveField()
-    async produceRewardsEnabled(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<boolean> {
+    async produceRewardsEnabled(parent: BaseFarmModel): Promise<boolean> {
         return this.farmAbiLoader.produceRewardsEnabledLoader.load(
             parent.address,
         );
     }
 
     @ResolveField()
-    async perBlockRewards(@Parent() parent: BaseFarmModel): Promise<string> {
+    async perBlockRewards(parent: BaseFarmModel): Promise<string> {
         return this.farmAbiLoader.perBlockRewardsLoader.load(parent.address);
     }
 
     @ResolveField()
-    async farmTokenSupply(@Parent() parent: BaseFarmModel): Promise<string> {
+    async farmTokenSupply(parent: BaseFarmModel): Promise<string> {
         return this.farmAbiLoader.farmTokenSupplyLoader.load(parent.address);
     }
 
     @ResolveField()
-    async farmedTokenPriceUSD(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<string> {
+    async farmedTokenPriceUSD(parent: BaseFarmModel): Promise<string> {
         return this.farmComputeLoader.farmedTokenPriceUSDLoader.load(
             parent.address,
         );
     }
 
     @ResolveField()
-    async farmTokenPriceUSD(@Parent() parent: BaseFarmModel): Promise<string> {
+    async farmTokenPriceUSD(parent: BaseFarmModel): Promise<string> {
         return this.farmComputeLoader.farmingTokenPriceUSDLoader.load(
             parent.address,
         );
     }
 
     @ResolveField()
-    async farmingTokenPriceUSD(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<string> {
+    async farmingTokenPriceUSD(parent: BaseFarmModel): Promise<string> {
         return this.farmComputeLoader.farmingTokenPriceUSDLoader.load(
             parent.address,
         );
     }
 
     @ResolveField()
-    async penaltyPercent(@Parent() parent: BaseFarmModel): Promise<number> {
+    async penaltyPercent(parent: BaseFarmModel): Promise<number> {
         return this.farmAbiLoader.penaltyPercentLoader.load(parent.address);
     }
 
     @ResolveField()
-    async minimumFarmingEpochs(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<number> {
+    async minimumFarmingEpochs(parent: BaseFarmModel): Promise<number> {
         return this.farmAbiLoader.minimumFarmingEpochsLoader.load(
             parent.address,
         );
     }
 
     @ResolveField()
-    async rewardPerShare(@Parent() parent: BaseFarmModel): Promise<string> {
+    async rewardPerShare(parent: BaseFarmModel): Promise<string> {
         return this.farmAbiLoader.rewardPerShareLoader.load(parent.address);
     }
 
     @ResolveField()
-    async rewardReserve(@Parent() parent: BaseFarmModel): Promise<string> {
+    async rewardReserve(parent: BaseFarmModel): Promise<string> {
         return this.farmAbiLoader.rewardReserveLoader.load(parent.address);
     }
 
     @ResolveField()
-    async lastRewardBlockNonce(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<number> {
+    async lastRewardBlockNonce(parent: BaseFarmModel): Promise<number> {
         return this.farmAbiLoader.lastRewardBlockNonceLoader.load(
             parent.address,
         );
     }
 
     @ResolveField()
-    async divisionSafetyConstant(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<string> {
+    async divisionSafetyConstant(parent: BaseFarmModel): Promise<string> {
         return this.farmAbiLoader.divisionSafetyConstantLoader.load(
             parent.address,
         );
@@ -133,32 +121,30 @@ export class FarmResolver {
     }
 
     @ResolveField()
-    async state(@Parent() parent: BaseFarmModel): Promise<string> {
+    async state(parent: BaseFarmModel): Promise<string> {
         return this.farmAbiLoader.stateLoader.load(parent.address);
     }
 
     @ResolveField()
-    async burnGasLimit(@Parent() parent: BaseFarmModel): Promise<string> {
+    async burnGasLimit(parent: BaseFarmModel): Promise<string> {
         return this.farmAbi.burnGasLimit(parent.address);
     }
 
     @ResolveField()
-    async pair(@Parent() parent: BaseFarmModel): Promise<PairModel> {
+    async pair(parent: BaseFarmModel): Promise<PairModel> {
         const address = await this.farmAbi.pairContractAddress(parent.address);
         return Address.fromString(address).equals(Address.Zero())
             ? undefined
             : new PairModel({ address });
     }
 
     @ResolveField()
-    async transferExecGasLimit(
-        @Parent() parent: BaseFarmModel,
-    ): Promise<string> {
+    async transferExecGasLimit(parent: BaseFarmModel): Promise<string> {
         return this.farmAbi.transferExecGasLimit(parent.address);
     }
 
     @ResolveField()
-    async lastErrorMessage(@Parent() parent: BaseFarmModel): Promise<string> {
+    async lastErrorMessage(parent: BaseFarmModel): Promise<string> {
         return this.farmAbi.lastErrorMessage(parent.address);
     }
 }

src/modules/farm/custom/farm.custom.resolver.ts

@@ -1,4 +1,4 @@
-import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { ResolveField, Resolver } from '@nestjs/graphql';
 import { FarmResolver } from '../base-module/farm.resolver';
 import { FarmCustomModel } from '../models/farm.custom.model';
 import { FarmCustomAbiService } from './services/farm.custom.abi.service';
@@ -31,9 +31,7 @@ export class FarmCustomResolver extends FarmResolver {
     }
 
     @ResolveField()
-    async requireWhitelist(
-        @Parent() parent: FarmCustomModel,
-    ): Promise<boolean> {
+    async requireWhitelist(parent: FarmCustomModel): Promise<boolean> {
         const whitelists = await this.farmAbi.whitelist(parent.address);
         return whitelists ? whitelists.length > 0 : false;
     }

src/modules/farm/v1.2/farm.v1.2.resolver.ts

@@ -1,4 +1,4 @@
-import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { ResolveField, Resolver } from '@nestjs/graphql';
 import { FarmResolver } from '../base-module/farm.resolver';
 import { FarmMigrationConfig } from '../models/farm.model';
 import { FarmModelV1_2 } from '../models/farm.v1.2.model';
@@ -33,44 +33,40 @@ export class FarmResolverV1_2 extends FarmResolver {
     }
 
     @ResolveField()
-    async lockedAssetFactory(
-        @Parent() parent: FarmModelV1_2,
-    ): Promise<LockedAssetModel> {
+    async lockedAssetFactory(parent: FarmModelV1_2): Promise<LockedAssetModel> {
         const address = await this.farmAbi.lockedAssetFactoryAddress(
             parent.address,
         );
         return new LockedAssetModel({ address });
     }
 
     @ResolveField()
-    async farmingTokenReserve(
-        @Parent() parent: FarmModelV1_2,
-    ): Promise<string> {
+    async farmingTokenReserve(parent: FarmModelV1_2): Promise<string> {
         return this.farmAbi.farmingTokenReserve(parent.address);
     }
 
     @ResolveField()
-    async undistributedFees(@Parent() parent: FarmModelV1_2): Promise<string> {
+    async undistributedFees(parent: FarmModelV1_2): Promise<string> {
         return this.farmAbi.undistributedFees(parent.address);
     }
 
     @ResolveField()
-    async currentBlockFee(@Parent() parent: FarmModelV1_2): Promise<string> {
+    async currentBlockFee(parent: FarmModelV1_2): Promise<string> {
         return this.farmAbi.currentBlockFee(parent.address);
     }
 
     @ResolveField()
-    async aprMultiplier(@Parent() parent: FarmModelV1_2): Promise<number> {
+    async aprMultiplier(parent: FarmModelV1_2): Promise<number> {
         return this.farmAbi.lockedRewardAprMuliplier(parent.address);
     }
 
     @ResolveField()
-    async unlockedRewardsAPR(@Parent() parent: FarmModelV1_2): Promise<string> {
+    async unlockedRewardsAPR(parent: FarmModelV1_2): Promise<string> {
         return this.farmCompute.unlockedRewardsAPR(parent.address);
     }
 
     @ResolveField()
-    async lockedRewardsAPR(@Parent() parent: FarmModelV1_2): Promise<string> {
+    async lockedRewardsAPR(parent: FarmModelV1_2): Promise<string> {
         return this.farmCompute.lockedRewardsAPR(parent.address);
     }
 
@@ -97,9 +93,7 @@ export class FarmResolverV1_2 extends FarmResolver {
     }
 
     @ResolveField()
-    async migrationConfig(
-        @Parent() parent: FarmModelV1_2,
-    ): Promise<FarmMigrationConfig> {
+    async migrationConfig(parent: FarmModelV1_2): Promise<FarmMigrationConfig> {
         return this.farmAbi.farmMigrationConfiguration(parent.address);
     }
 }

src/modules/farm/v1.3/farm.v1.3.resolver.ts

@@ -1,4 +1,4 @@
-import { Parent, ResolveField, Resolver } from '@nestjs/graphql';
+import { ResolveField, Resolver } from '@nestjs/graphql';
 import { FarmResolver } from '../base-module/farm.resolver';
 import { FarmModelV1_3 } from '../models/farm.v1.3.model';
 import { FarmServiceV1_3 } from './services/farm.v1.3.service';
@@ -32,14 +32,12 @@ export class FarmResolverV1_3 extends FarmResolver {
     }
 
     @ResolveField()
-    async apr(@Parent() parent: FarmModelV1_3): Promise<string> {
+    async apr(parent: FarmModelV1_3): Promise<string> {
         return this.farmCompute.farmAPR(parent.address);
     }
 
     @ResolveField()
-    async lockedAssetFactory(
-        @Parent() parent: FarmModelV1_3,
-    ): Promise<LockedAssetModel> {
+    async lockedAssetFactory(parent: FarmModelV1_3): Promise<LockedAssetModel> {
         const address = await this.farmAbi.lockedAssetFactoryAddress(
             parent.address,
         );