11340871916

Committed 15 Oct 2024 06:58AM UTC coverage: 46.83% (-45.0%) from 91.836%

Build # 11340871916

Build Type

push

github

Committed by

web-flow

Commit Message

Bump typescript from 5.6.2 to 5.6.3 (#2015)

Bumps [typescript](https://github.com/microsoft/TypeScript) from 5.6.2 to 5.6.3.
- [Release notes](https://github.com/microsoft/TypeScript/releases)
- [Changelog](https://github.com/microsoft/TypeScript/blob/main/azure-pipelines.release.yml)
- [Commits](https://github.com/microsoft/TypeScript/compare/v5.6.2...v5.6.3)

---
updated-dependencies:
- dependency-name: typescript
  dependency-type: direct:development
  update-type: version-update:semver-patch
...

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>

Run Details

500 of 3096 branches covered (16.15%)

Branch coverage included in aggregate %.

5092 of 8845 relevant lines covered (57.57%)

12.16 hits per line

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

50.6

/src/datasources/network/fetch.network.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { ILoggingService, LoggingService } from '@/logging/logging.interface';
import { NetworkRequest } from '@/datasources/network/entities/network.request.entity';
import { NetworkResponse } from '@/datasources/network/entities/network.response.entity';
import { INetworkService } from '@/datasources/network/network.service.interface';
import { FetchClient } from '@/datasources/network/network.module';
import { NetworkResponseError } from '@/datasources/network/entities/network.error.entity';

/**
 * A {@link INetworkService} which uses fetch as the main HTTP client
 */
@Injectable()
export class FetchNetworkService implements INetworkService {
  constructor(
    @Inject('FetchClient')
    private readonly client: FetchClient,
    @Inject(LoggingService)
    private readonly loggingService: ILoggingService,
  ) {}

  async get<T>(args: {
    url: string;
    networkRequest?: NetworkRequest;
  }): Promise<NetworkResponse<T>> {
    const url = this.buildUrl(args.url, args.networkRequest?.params);
    const startTimeMs = performance.now();
    try {
      return await this.client<T>(url, {
        method: 'GET',
        headers: args.networkRequest?.headers,
      });
    } catch (error) {
      this.logErrorResponse(error, performance.now() - startTimeMs);
      throw error;
    }
  }

  async post<T>(args: {
    url: string;
    data: object;
    networkRequest?: NetworkRequest;
  }): Promise<NetworkResponse<T>> {
    const url = this.buildUrl(args.url, args.networkRequest?.params);
    const startTimeMs = performance.now();
    try {
      return await this.client<T>(url, {
        method: 'POST',
        body: JSON.stringify(args.data),
        headers: {
          'Content-Type': 'application/json',
          ...(args.networkRequest?.headers ?? {}),
        },
      });
    } catch (error) {
      this.logErrorResponse(error, performance.now() - startTimeMs);
      throw error;
    }
  }

  async delete<T>(args: {
    url: string;
    data?: object;
    networkRequest?: NetworkRequest;
  }): Promise<NetworkResponse<T>> {
    const url = this.buildUrl(args.url, args.networkRequest?.params);
    const startTimeMs = performance.now();

    let headers = args.networkRequest?.headers;

    if (args.data) {
      headers ??= {};
      headers['Content-Type'] = 'application/json';
    }

    try {
      return await this.client<T>(url, {
        method: 'DELETE',
        ...(args.data && {
          body: JSON.stringify(args.data),
        }),
        headers,
      });
    } catch (error) {
      this.logErrorResponse(error, performance.now() - startTimeMs);
      throw error;
    }
  }

  private buildUrl(baseUrl: string, params = {}): string {
    const urlObject = new URL(baseUrl);

    for (const [key, value] of Object.entries(params)) {
      if (value != null && value !== '') {
        urlObject.searchParams.append(key, String(value));
      }
    }

    return urlObject.toString();
  }

  private logErrorResponse(error: unknown, responseTimeMs: number): void {
    if (!(error instanceof NetworkResponseError)) {
      return;
    }

    this.loggingService.debug({
      type: 'external_request',
      protocol: error.url.protocol,
      target_host: error.url.host,
      path: error.url.pathname,
      request_status: error.response.status,
      detail: error.response.statusText,
      response_time_ms: responseTimeMs,
    });
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	18✔
2	import { ILoggingService, LoggingService } from '@/logging/logging.interface';	18✔
3	import { NetworkRequest } from '@/datasources/network/entities/network.request.entity';
4	import { NetworkResponse } from '@/datasources/network/entities/network.response.entity';
5	import { INetworkService } from '@/datasources/network/network.service.interface';
6	import { FetchClient } from '@/datasources/network/network.module';
7	import { NetworkResponseError } from '@/datasources/network/entities/network.error.entity';	18✔
8
9	/**
10	* A {@link INetworkService} which uses fetch as the main HTTP client
11	*/
12	@Injectable()
13	export class FetchNetworkService implements INetworkService {	18✔
14	constructor(
15	@Inject('FetchClient')
16	private readonly client: FetchClient,	18✔
17	@Inject(LoggingService)
18	private readonly loggingService: ILoggingService,	18✔
19	) {}
20
21	async get<T>(args: {
22	url: string;
23	networkRequest?: NetworkRequest;
24	}): Promise<NetworkResponse<T>> {
25	const url = this.buildUrl(args.url, args.networkRequest?.params);	20✔
26	const startTimeMs = performance.now();	20✔
27	try {	20✔
28	return await this.client<T>(url, {	20✔
29	method: 'GET',
30	headers: args.networkRequest?.headers,	30✔
31	});
32	} catch (error) {
33	this.logErrorResponse(error, performance.now() - startTimeMs);	×
34	throw error;	×
35	}
36	}
37
38	async post<T>(args: {
39	url: string;
40	data: object;
41	networkRequest?: NetworkRequest;
42	}): Promise<NetworkResponse<T>> {
43	const url = this.buildUrl(args.url, args.networkRequest?.params);	2!
44	const startTimeMs = performance.now();	2✔
45	try {	2✔
46	return await this.client<T>(url, {	2✔
47	method: 'POST',
48	body: JSON.stringify(args.data),
49	headers: {
50	'Content-Type': 'application/json',
51	...(args.networkRequest?.headers ?? {}),	6!
52	},
53	});
54	} catch (error) {
55	this.logErrorResponse(error, performance.now() - startTimeMs);	×
56	throw error;	×
57	}
58	}
59
60	async delete<T>(args: {
61	url: string;
62	data?: object;
63	networkRequest?: NetworkRequest;
64	}): Promise<NetworkResponse<T>> {
65	const url = this.buildUrl(args.url, args.networkRequest?.params);	×
66	const startTimeMs = performance.now();	×
67
68	let headers = args.networkRequest?.headers;	×
69
70	if (args.data) {	×
71	headers ??= {};	×
72	headers['Content-Type'] = 'application/json';	×
73	}
74
75	try {	×
76	return await this.client<T>(url, {	×
77	method: 'DELETE',
78	...(args.data && {	×
79	body: JSON.stringify(args.data),
80	}),
81	headers,
82	});
83	} catch (error) {
84	this.logErrorResponse(error, performance.now() - startTimeMs);	×
85	throw error;	×
86	}
87	}
88
89	private buildUrl(baseUrl: string, params = {}): string {	9✔
90	const urlObject = new URL(baseUrl);	22✔
91
92	for (const [key, value] of Object.entries(params)) {	22✔
93	if (value != null && value !== '') {	16✔
94	urlObject.searchParams.append(key, String(value));	10✔
95	}
96	}
97
98	return urlObject.toString();	22✔
99	}
100
101	private logErrorResponse(error: unknown, responseTimeMs: number): void {
102	if (!(error instanceof NetworkResponseError)) {	×
103	return;	×
104	}
105
106	this.loggingService.debug({	×
107	type: 'external_request',
108	protocol: error.url.protocol,
109	target_host: error.url.host,
110	path: error.url.pathname,
111	request_status: error.response.status,
112	detail: error.response.statusText,
113	response_time_ms: responseTimeMs,
114	});
115	}
116	}

safe-global / safe-client-gateway / 11340871916

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