8970661844

Committed 06 May 2024 02:19PM UTC coverage: 93.079% (+0.01%) from 93.069%

Build # 8970661844

Build Type

Pull #1504

github

Committed by

hectorgomezv

Commit Message

Mark v1 endpoints as deprecated

Pull Request Pull Request #1504: Implement DELETE /v2/chains/:chainId/delegates/:delegateAddress

Run Details

1970 of 2386 branches covered (82.56%)

Branch coverage included in aggregate %.

37 of 40 new or added lines in 7 files covered. (92.5%)

12 existing lines in 3 files now uncovered.

7068 of 7324 relevant lines covered (96.5%)

311.43 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.74

/src/routes/delegates/v2/delegates.v2.service.ts

import { Delegate } from '@/domain/delegate/entities/delegate.entity';
import { IDelegatesV2Repository } from '@/domain/delegate/v2/delegates.v2.repository.interface';
import { Page } from '@/domain/entities/page.entity';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import {
  PaginationData,
  cursorUrlFromLimitAndOffset,
} from '@/routes/common/pagination/pagination.data';
import { CreateDelegateDto } from '@/routes/delegates/entities/create-delegate.dto.entity';
import { GetDelegateDto } from '@/routes/delegates/entities/get-delegate.dto.entity';
import { DeleteDelegateV2Dto } from '@/routes/delegates/v2/entities/delete-delegate.v2.dto.entity';
import { Inject, Injectable, NotFoundException } from '@nestjs/common';

@Injectable()
export class DelegatesV2Service {
  constructor(
    @Inject(IDelegatesV2Repository)
    private readonly repository: IDelegatesV2Repository,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
  ) {}

  async getDelegates(args: {
    chainId: string;
    routeUrl: Readonly<URL>;
    getDelegateDto: GetDelegateDto;
    paginationData: PaginationData;
  }): Promise<Page<Delegate>> {
    const delegates = await this.repository.getDelegates({
      chainId: args.chainId,
      safeAddress: args.getDelegateDto.safe,
      delegate: args.getDelegateDto.delegate,
      delegator: args.getDelegateDto.delegator,
      label: args.getDelegateDto.label,
      limit: args.paginationData.limit,
      offset: args.paginationData.offset,
    });

    const nextURL = cursorUrlFromLimitAndOffset(args.routeUrl, delegates.next);
    const previousURL = cursorUrlFromLimitAndOffset(
      args.routeUrl,
      delegates.previous,
    );

    return {
      count: delegates.count,
      next: nextURL?.toString() ?? null,
      previous: previousURL?.toString() ?? null,
      results: delegates.results,
    };
  }

  async postDelegate(args: {
    chainId: string;
    createDelegateDto: CreateDelegateDto;
  }): Promise<void> {
    await this.repository.postDelegate({
      chainId: args.chainId,
      safeAddress: args.createDelegateDto.safe,
      delegate: args.createDelegateDto.delegate,
      delegator: args.createDelegateDto.delegator,
      signature: args.createDelegateDto.signature,
      label: args.createDelegateDto.label,
    });
  }

  async deleteDelegate(args: {
    chainId: string;
    delegateAddress: `0x${string}`;
    deleteDelegateV2Dto: DeleteDelegateV2Dto;
  }): Promise<unknown> {
    const { deleteDelegateV2Dto } = args;
    let { delegator } = deleteDelegateV2Dto;

    if (!delegator) {
      if (!deleteDelegateV2Dto.safe) {
        // Note: this point shouldn't be reached, schema validation should cover it
        throw Error(
          'Either safe or delegator should be non-null when deleting a delegate',
        );
      }
      delegator = await this._getDelegatorForDelegateAndSafe(
        args.chainId,
        args.delegateAddress,
        deleteDelegateV2Dto.safe,
      );
    }

    return await this.repository.deleteDelegate({
      chainId: args.chainId,
      delegate: args.delegateAddress,
      delegator,
      safeAddress: deleteDelegateV2Dto.safe,
      signature: deleteDelegateV2Dto.signature,
    });
  }

  private async _getDelegatorForDelegateAndSafe(
    chainId: string,
    delegate: `0x${string}`,
    safeAddress: `0x${string}`,
  ): Promise<`0x${string}`> {
    const response = await this.repository.getDelegates({
      chainId,
      delegate,
      safeAddress,
    });

    if (!response.results.length) {
      this.loggingService.warn(
        `Delegator for delegate ${delegate} and Safe ${safeAddress} not found`,
      );
      throw new NotFoundException();
    }

    return response.results[0].delegator;
  }
}

1	import { Delegate } from '@/domain/delegate/entities/delegate.entity';
2	import { IDelegatesV2Repository } from '@/domain/delegate/v2/delegates.v2.repository.interface';	98✔
3	import { Page } from '@/domain/entities/page.entity';
4	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	98✔
5	import {	98✔
6	PaginationData,
7	cursorUrlFromLimitAndOffset,
8	} from '@/routes/common/pagination/pagination.data';
9	import { CreateDelegateDto } from '@/routes/delegates/entities/create-delegate.dto.entity';
10	import { GetDelegateDto } from '@/routes/delegates/entities/get-delegate.dto.entity';
11	import { DeleteDelegateV2Dto } from '@/routes/delegates/v2/entities/delete-delegate.v2.dto.entity';
12	import { Inject, Injectable, NotFoundException } from '@nestjs/common';	98✔
13
14	@Injectable()
15	export class DelegatesV2Service {	98✔
16	constructor(
17	@Inject(IDelegatesV2Repository)
18	private readonly repository: IDelegatesV2Repository,	1,272✔
19	@Inject(LoggingService)
20	private readonly loggingService: ILoggingService,	1,272✔
21	) {}
22
23	async getDelegates(args: {
24	chainId: string;
25	routeUrl: Readonly<URL>;
26	getDelegateDto: GetDelegateDto;
27	paginationData: PaginationData;
28	}): Promise<Page<Delegate>> {
29	const delegates = await this.repository.getDelegates({	6✔
30	chainId: args.chainId,
31	safeAddress: args.getDelegateDto.safe,
32	delegate: args.getDelegateDto.delegate,
33	delegator: args.getDelegateDto.delegator,
34	label: args.getDelegateDto.label,
35	limit: args.paginationData.limit,
36	offset: args.paginationData.offset,
37	});
38
39	const nextURL = cursorUrlFromLimitAndOffset(args.routeUrl, delegates.next);	4✔
40	const previousURL = cursorUrlFromLimitAndOffset(	4✔
41	args.routeUrl,
42	delegates.previous,
43	);
44
45	return {	4✔
46	count: delegates.count,
47	next: nextURL?.toString() ?? null,	10!
48	previous: previousURL?.toString() ?? null,	10!
49	results: delegates.results,
50	};
51	}
52
53	async postDelegate(args: {
54	chainId: string;
55	createDelegateDto: CreateDelegateDto;
56	}): Promise<void> {
57	await this.repository.postDelegate({	8✔
58	chainId: args.chainId,
59	safeAddress: args.createDelegateDto.safe,
60	delegate: args.createDelegateDto.delegate,
61	delegator: args.createDelegateDto.delegator,
62	signature: args.createDelegateDto.signature,
63	label: args.createDelegateDto.label,
64	});
65	}
66
67	async deleteDelegate(args: {
68	chainId: string;
69	delegateAddress: `0x${string}`;
70	deleteDelegateV2Dto: DeleteDelegateV2Dto;
71	}): Promise<unknown> {
72	const { deleteDelegateV2Dto } = args;	10✔
73	let { delegator } = deleteDelegateV2Dto;	10✔
74
75	if (!delegator) {	10✔
76	if (!deleteDelegateV2Dto.safe) {	2!
77	// Note: this point shouldn't be reached, schema validation should cover it
NEW 78	throw Error(	×
79	'Either safe or delegator should be non-null when deleting a delegate',
80	);
81	}
82	delegator = await this._getDelegatorForDelegateAndSafe(	2✔
83	args.chainId,
84	args.delegateAddress,
85	deleteDelegateV2Dto.safe,
86	);
87	}
88
89	return await this.repository.deleteDelegate({	10✔
90	chainId: args.chainId,
91	delegate: args.delegateAddress,
92	delegator,
93	safeAddress: deleteDelegateV2Dto.safe,
94	signature: deleteDelegateV2Dto.signature,
95	});
96	}
97
98	private async _getDelegatorForDelegateAndSafe(
99	chainId: string,
100	delegate: `0x${string}`,
101	safeAddress: `0x${string}`,
102	): Promise<`0x${string}`> {
103	const response = await this.repository.getDelegates({	2✔
104	chainId,
105	delegate,
106	safeAddress,
107	});
108
109	if (!response.results.length) {	2!
NEW 110	this.loggingService.warn(	×
111	`Delegator for delegate ${delegate} and Safe ${safeAddress} not found`,
112	);
NEW 113	throw new NotFoundException();	×
114	}
115
116	return response.results[0].delegator;	2✔
117	}
118	}

safe-global / safe-client-gateway / 8970661844

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous