11974499337

Committed 22 Nov 2024 02:28PM UTC coverage: 89.5% (-0.004%) from 89.504%

Build # 11974499337

Build Type

Pull #2149

github

Committed by

hectorgomezv

Commit Message

Add DTO schema tests

Pull Request Pull Request #2149: Implement AddressBookItem update

Run Details

2762 of 3430 branches covered (80.52%)

Branch coverage included in aggregate %.

20 of 32 new or added lines in 6 files covered. (62.5%)

2 existing lines in 1 file now uncovered.

9402 of 10161 relevant lines covered (92.53%)

425.85 hits per line

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

83.33

/src/domain/accounts/address-books/address-books.repository.ts

import { IAccountsRepository } from '@/domain/accounts/accounts.repository.interface';
import type { IAddressBooksRepository } from '@/domain/accounts/address-books/address-books.repository.interface';
import type {
  AddressBook,
  AddressBookItem,
} from '@/domain/accounts/address-books/entities/address-book.entity';
import { CreateAddressBookItemDto } from '@/domain/accounts/address-books/entities/create-address-book-item.dto.entity';
import { UpdateAddressBookItemDto } from '@/domain/accounts/address-books/entities/update-address-book-item.dto.entity';
import {
  AccountDataType,
  AccountDataTypeNames,
} from '@/domain/accounts/entities/account-data-type.entity';
import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
import { IAddressBooksDatasource } from '@/domain/interfaces/address-books.datasource.interface';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import {
  GoneException,
  Inject,
  Injectable,
  UnauthorizedException,
} from '@nestjs/common';

@Injectable()
export class AddressBooksRepository implements IAddressBooksRepository {
  constructor(
    @Inject(IAddressBooksDatasource)
    private readonly datasource: IAddressBooksDatasource,
    @Inject(IAccountsRepository)
    private readonly accountsRepository: IAccountsRepository,
    @Inject(LoggingService) private readonly loggingService: ILoggingService,
  ) {}

  /**
   * Gets an AddressBook.
   * Checks that the account has the AddressBooks Data Setting enabled.
   */
  async getAddressBook(args: {
    authPayload: AuthPayload;
    address: `0x${string}`;
    chainId: string;
  }): Promise<AddressBook> {
    if (!args.authPayload.isForSigner(args.address)) {
      throw new UnauthorizedException();
    }
    await this.checkAddressBooksIsEnabled({
      authPayload: args.authPayload,
      address: args.address,
    });
    const account = await this.accountsRepository.getAccount({
      authPayload: args.authPayload,
      address: args.address,
    });
    return await this.datasource.getAddressBook({
      account,
      chainId: args.chainId,
    });
  }

  /**
   * Creates an AddressBookItem.
   * Checks that the account has the AddressBooks Data Setting enabled.
   *
   * If an AddressBook for the Account and chainId does not exist, it's created.
   */
  async createAddressBookItem(args: {
    authPayload: AuthPayload;
    address: `0x${string}`;
    chainId: string;
    createAddressBookItemDto: CreateAddressBookItemDto;
  }): Promise<AddressBookItem> {
    if (!args.authPayload.isForSigner(args.address)) {
      throw new UnauthorizedException();
    }
    await this.checkAddressBooksIsEnabled({
      authPayload: args.authPayload,
      address: args.address,
    });
    const account = await this.accountsRepository.getAccount({
      authPayload: args.authPayload,
      address: args.address,
    });
    // TODO: implement a configurable MAX_ADDRESS_BOOK_ITEMS limitation.
    return this.datasource.createAddressBookItem({
      account,
      chainId: args.chainId,
      createAddressBookItemDto: args.createAddressBookItemDto,
    });
  }

  /**
   * Updates an AddressBookItem.
   * Checks that the account has the AddressBooks Data Setting enabled.
   *
   * If an AddressBook for the Account and chainId does not exist,
   * an AddressBookNotFound error is thrown.
   */
  async updateAddressBookItem(args: {
    authPayload: AuthPayload;
    address: `0x${string}`;
    chainId: string;
    updateAddressBookItemDto: UpdateAddressBookItemDto;
  }): Promise<AddressBookItem> {
    if (!args.authPayload.isForSigner(args.address)) {
      throw new UnauthorizedException();
    }
    await this.checkAddressBooksIsEnabled({
      authPayload: args.authPayload,
      address: args.address,
    });
    const account = await this.accountsRepository.getAccount({
      authPayload: args.authPayload,
      address: args.address,
    });
    const addressBook = await this.datasource.getAddressBook({
      account,
      chainId: args.chainId,
    });
    return this.datasource.updateAddressBookItem({
      addressBook,
      updateAddressBookItemDto: args.updateAddressBookItemDto,
    });
  }

  async deleteAddressBook(args: {
    authPayload: AuthPayload;
    address: `0x${string}`;
    chainId: string;
  }): Promise<void> {
    if (!args.authPayload.isForSigner(args.address)) {
      throw new UnauthorizedException();
    }
    await this.checkAddressBooksIsEnabled({
      authPayload: args.authPayload,
      address: args.address,
    });
    const account = await this.accountsRepository.getAccount({
      authPayload: args.authPayload,
      address: args.address,
    });
    const addressBook = await this.datasource.getAddressBook({
      account,
      chainId: args.chainId,
    });
    return this.datasource.deleteAddressBook(addressBook);
  }

  async deleteAddressBookItem(args: {
    authPayload: AuthPayload;
    address: `0x${string}`;
    chainId: string;
    addressBookItemId: number;
  }): Promise<void> {
    if (!args.authPayload.isForSigner(args.address)) {
      throw new UnauthorizedException();
    }
    await this.checkAddressBooksIsEnabled({
      authPayload: args.authPayload,
      address: args.address,
    });
    const account = await this.accountsRepository.getAccount({
      authPayload: args.authPayload,
      address: args.address,
    });
    const addressBook = await this.datasource.getAddressBook({
      account,
      chainId: args.chainId,
    });
    return this.datasource.deleteAddressBookItem({
      addressBook,
      id: args.addressBookItemId,
    });
  }

  // TODO: Extract this functionality in AccountsRepository['checkIsEnabled(DataType, Account)']
  private async checkAddressBooksIsEnabled(args: {
    authPayload: AuthPayload;
    address: `0x${string}`;
  }): Promise<void> {
    const addressBookDataType = await this.checkAddressBookDataTypeIsActive();
    const accountDataSettings =
      await this.accountsRepository.getAccountDataSettings({
        authPayload: args.authPayload,
        address: args.address,
      });
    const addressBookSetting = accountDataSettings.find(
      (setting) => setting.account_data_type_id === addressBookDataType.id,
    );
    if (!addressBookSetting?.enabled) {
      this.loggingService.warn({
        message: `Account ${args.address} does not have AddressBooks enabled`,
      });
      throw new GoneException();
    }
  }

  // TODO: Extract this functionality in AccountsRepository['checkIsActive(DataType)']
  private async checkAddressBookDataTypeIsActive(): Promise<AccountDataType> {
    const dataTypes = await this.accountsRepository.getDataTypes();
    const addressBookDataType = dataTypes.find(
      (dataType) => dataType.name === AccountDataTypeNames.AddressBook,
    );
    if (!addressBookDataType?.is_active) {
      this.loggingService.warn({
        message: `${AccountDataTypeNames.AddressBook} data type is not active`,
      });
      throw new GoneException();
    }
    return addressBookDataType;
  }
}

1	import { IAccountsRepository } from '@/domain/accounts/accounts.repository.interface';	108✔
2	import type { IAddressBooksRepository } from '@/domain/accounts/address-books/address-books.repository.interface';
3	import type {
4	AddressBook,
5	AddressBookItem,
6	} from '@/domain/accounts/address-books/entities/address-book.entity';
7	import { CreateAddressBookItemDto } from '@/domain/accounts/address-books/entities/create-address-book-item.dto.entity';
8	import { UpdateAddressBookItemDto } from '@/domain/accounts/address-books/entities/update-address-book-item.dto.entity';
9	import {	108✔
10	AccountDataType,
11	AccountDataTypeNames,
12	} from '@/domain/accounts/entities/account-data-type.entity';
13	import { AuthPayload } from '@/domain/auth/entities/auth-payload.entity';
14	import { IAddressBooksDatasource } from '@/domain/interfaces/address-books.datasource.interface';	108✔
15	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	108✔
16	import {	108✔
17	GoneException,
18	Inject,
19	Injectable,
20	UnauthorizedException,
21	} from '@nestjs/common';
22
23	@Injectable()
24	export class AddressBooksRepository implements IAddressBooksRepository {	108✔
25	constructor(
26	@Inject(IAddressBooksDatasource)
27	private readonly datasource: IAddressBooksDatasource,	178✔
28	@Inject(IAccountsRepository)
29	private readonly accountsRepository: IAccountsRepository,	178✔
30	@Inject(LoggingService) private readonly loggingService: ILoggingService,	178✔
31	) {}
32
33	/**
34	* Gets an AddressBook.
35	* Checks that the account has the AddressBooks Data Setting enabled.
36	*/
37	async getAddressBook(args: {
38	authPayload: AuthPayload;
39	address: `0x${string}`;
40	chainId: string;
41	}): Promise<AddressBook> {
42	if (!args.authPayload.isForSigner(args.address)) {	10✔
43	throw new UnauthorizedException();	2✔
44	}
45	await this.checkAddressBooksIsEnabled({	8✔
46	authPayload: args.authPayload,
47	address: args.address,
48	});
49	const account = await this.accountsRepository.getAccount({	4✔
50	authPayload: args.authPayload,
51	address: args.address,
52	});
53	return await this.datasource.getAddressBook({	4✔
54	account,
55	chainId: args.chainId,
56	});
57	}
58
59	/**
60	* Creates an AddressBookItem.
61	* Checks that the account has the AddressBooks Data Setting enabled.
62	*
63	* If an AddressBook for the Account and chainId does not exist, it's created.
64	*/
65	async createAddressBookItem(args: {
66	authPayload: AuthPayload;
67	address: `0x${string}`;
68	chainId: string;
69	createAddressBookItemDto: CreateAddressBookItemDto;
70	}): Promise<AddressBookItem> {
71	if (!args.authPayload.isForSigner(args.address)) {	8✔
72	throw new UnauthorizedException();	2✔
73	}
74	await this.checkAddressBooksIsEnabled({	6✔
75	authPayload: args.authPayload,
76	address: args.address,
77	});
78	const account = await this.accountsRepository.getAccount({	2✔
79	authPayload: args.authPayload,
80	address: args.address,
81	});
82	// TODO: implement a configurable MAX_ADDRESS_BOOK_ITEMS limitation.
83	return this.datasource.createAddressBookItem({	2✔
84	account,
85	chainId: args.chainId,
86	createAddressBookItemDto: args.createAddressBookItemDto,
87	});
88	}
89
90	/**
91	* Updates an AddressBookItem.
92	* Checks that the account has the AddressBooks Data Setting enabled.
93	*
94	* If an AddressBook for the Account and chainId does not exist,
95	* an AddressBookNotFound error is thrown.
96	*/
97	async updateAddressBookItem(args: {
98	authPayload: AuthPayload;
99	address: `0x${string}`;
100	chainId: string;
101	updateAddressBookItemDto: UpdateAddressBookItemDto;
102	}): Promise<AddressBookItem> {
NEW 103	if (!args.authPayload.isForSigner(args.address)) {	×
NEW 104	throw new UnauthorizedException();	×
105	}
NEW 106	await this.checkAddressBooksIsEnabled({	×
107	authPayload: args.authPayload,
108	address: args.address,
109	});
NEW 110	const account = await this.accountsRepository.getAccount({	×
111	authPayload: args.authPayload,
112	address: args.address,
113	});
NEW 114	const addressBook = await this.datasource.getAddressBook({	×
115	account,
116	chainId: args.chainId,
117	});
NEW 118	return this.datasource.updateAddressBookItem({	×
119	addressBook,
120	updateAddressBookItemDto: args.updateAddressBookItemDto,
121	});
122	}
123
124	async deleteAddressBook(args: {
125	authPayload: AuthPayload;
126	address: `0x${string}`;
127	chainId: string;
128	}): Promise<void> {
129	if (!args.authPayload.isForSigner(args.address)) {	10✔
130	throw new UnauthorizedException();	2✔
131	}
132	await this.checkAddressBooksIsEnabled({	8✔
133	authPayload: args.authPayload,
134	address: args.address,
135	});
136	const account = await this.accountsRepository.getAccount({	4✔
137	authPayload: args.authPayload,
138	address: args.address,
139	});
140	const addressBook = await this.datasource.getAddressBook({	4✔
141	account,
142	chainId: args.chainId,
143	});
144	return this.datasource.deleteAddressBook(addressBook);	2✔
145	}
146
147	async deleteAddressBookItem(args: {
148	authPayload: AuthPayload;
149	address: `0x${string}`;
150	chainId: string;
151	addressBookItemId: number;
152	}): Promise<void> {
153	if (!args.authPayload.isForSigner(args.address)) {	10✔
154	throw new UnauthorizedException();	2✔
155	}
156	await this.checkAddressBooksIsEnabled({	8✔
157	authPayload: args.authPayload,
158	address: args.address,
159	});
160	const account = await this.accountsRepository.getAccount({	4✔
161	authPayload: args.authPayload,
162	address: args.address,
163	});
164	const addressBook = await this.datasource.getAddressBook({	4✔
165	account,
166	chainId: args.chainId,
167	});
168	return this.datasource.deleteAddressBookItem({	2✔
169	addressBook,
170	id: args.addressBookItemId,
171	});
172	}
173
174	// TODO: Extract this functionality in AccountsRepository['checkIsEnabled(DataType, Account)']
175	private async checkAddressBooksIsEnabled(args: {
176	authPayload: AuthPayload;
177	address: `0x${string}`;
178	}): Promise<void> {
179	const addressBookDataType = await this.checkAddressBookDataTypeIsActive();	30✔
180	const accountDataSettings =
181	await this.accountsRepository.getAccountDataSettings({	22✔
182	authPayload: args.authPayload,
183	address: args.address,
184	});
185	const addressBookSetting = accountDataSettings.find(	22✔
186	(setting) => setting.account_data_type_id === addressBookDataType.id,	22✔
187	);
188	if (!addressBookSetting?.enabled) {	22✔
189	this.loggingService.warn({	8✔
190	message: `Account ${args.address} does not have AddressBooks enabled`,
191	});
192	throw new GoneException();	8✔
193	}
194	}
195
196	// TODO: Extract this functionality in AccountsRepository['checkIsActive(DataType)']
197	private async checkAddressBookDataTypeIsActive(): Promise<AccountDataType> {
198	const dataTypes = await this.accountsRepository.getDataTypes();	30✔
199	const addressBookDataType = dataTypes.find(	30✔
200	(dataType) => dataType.name === AccountDataTypeNames.AddressBook,	22✔
201	);
202	if (!addressBookDataType?.is_active) {	22!
UNCOV 203	this.loggingService.warn({	×
204	message: `${AccountDataTypeNames.AddressBook} data type is not active`,
205	});
UNCOV 206	throw new GoneException();	×
207	}
208	return addressBookDataType;	22✔
209	}
210	}

safe-global / safe-client-gateway / 11974499337

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