7338219020

Committed 27 Dec 2023 12:18PM UTC coverage: 90.448% (+0.02%) from 90.429%

Build # 7338219020

Build Type

Pull #970

github

Committed by

hectorgomezv

Commit Message

PR comments

Pull Request Pull Request #970: Check datasources request lifespan before caching its response

Run Details

1439 of 1716 branches covered (0.0%)

Branch coverage included in aggregate %.

18 of 20 new or added lines in 4 files covered. (90.0%)

3 existing lines in 2 files now uncovered.

5407 of 5853 relevant lines covered (92.38%)

152.36 hits per line

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

91.11

/src/datasources/config-api/config-api.service.ts

import { Inject, Injectable } from '@nestjs/common';
import { IConfigurationService } from '@/config/configuration.service.interface';
import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
import { CacheRouter } from '@/datasources/cache/cache.router';
import {
  CacheService,
  ICacheService,
} from '@/datasources/cache/cache.service.interface';
import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
import { Chain } from '@/domain/chains/entities/chain.entity';
import { Page } from '@/domain/entities/page.entity';
import { IConfigApi } from '@/domain/interfaces/config-api.interface';
import { SafeApp } from '@/domain/safe-apps/entities/safe-app.entity';

@Injectable()
export class ConfigApi implements IConfigApi {
  private readonly baseUri: string;
  private readonly defaultExpirationTimeInSeconds: number;
  private readonly defaultNotFoundExpirationTimeSeconds: number;

  constructor(
    private readonly dataSource: CacheFirstDataSource,
    @Inject(CacheService) private readonly cacheService: ICacheService,
    @Inject(IConfigurationService)
    private readonly configurationService: IConfigurationService,
    private readonly httpErrorFactory: HttpErrorFactory,
  ) {
    this.baseUri =
      this.configurationService.getOrThrow<string>('safeConfig.baseUri');
    this.defaultExpirationTimeInSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.default',
      );
    this.defaultNotFoundExpirationTimeSeconds =
      this.configurationService.getOrThrow<number>(
        'expirationTimeInSeconds.notFound.default',
      );
  }

  async getChains(args: {
    limit?: number;
    offset?: number;
  }): Promise<Page<Chain>> {
    try {
      const url = `${this.baseUri}/api/v1/chains`;
      const params = { limit: args.limit, offset: args.offset };
      const cacheDir = CacheRouter.getChainsCacheDir(args);
      return await this.dataSource.get({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: { params },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearChains(): Promise<void> {
    const pattern = CacheRouter.getChainsCachePattern();
    const key = CacheRouter.getChainsCacheKey();
    await Promise.all([
      this.cacheService.deleteByKey(key),
      this.cacheService.deleteByKeyPattern(pattern),
      // TODO: call _setInvalidationTimeForKey for each item matching the pattern
    ]);
  }

  async getChain(chainId: string): Promise<Chain> {
    try {
      const url = `${this.baseUri}/api/v1/chains/${chainId}`;
      const cacheDir = CacheRouter.getChainCacheDir(chainId);
      return await this.dataSource.get({
        cacheDir,
        url,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: undefined,
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearChain(chainId: string): Promise<void> {
    const chainCacheKey = CacheRouter.getChainCacheKey(chainId);
    const chainsCacheKey = CacheRouter.getChainsCacheKey();
    await Promise.all([
      this.cacheService.deleteByKey(chainCacheKey),
      this.cacheService.deleteByKey(chainsCacheKey),
    ]);
  }

  async getSafeApps(args: {
    chainId?: string;
    clientUrl?: string;
    url?: string;
  }): Promise<SafeApp[]> {
    try {
      const providerUrl = `${this.baseUri}/api/v1/safe-apps/`;
      const params = {
        chainId: args.chainId,
        clientUrl: args.clientUrl,
        url: args.url,
      };
      const cacheDir = CacheRouter.getSafeAppsCacheDir(args);
      return await this.dataSource.get({
        cacheDir,
        url: providerUrl,
        notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
        networkRequest: { params },
        expireTimeSeconds: this.defaultExpirationTimeInSeconds,
      });
    } catch (error) {
      throw this.httpErrorFactory.from(error);
    }
  }

  async clearSafeApps(chainId?: string): Promise<void> {
    if (chainId) {
      // if a chain id is provided, delete the safe apps data for that chain id
      const key = CacheRouter.getSafeAppsKey(chainId);
      await this.cacheService.deleteByKey(key);
    } else {
      // if a chain id is not provided, delete all the safe apps data
      const pattern = CacheRouter.getSafeAppsCachePattern();
      await this.cacheService.deleteByKeyPattern(pattern);
      // TODO: call _setInvalidationTimeForKey for each item matching the pattern
    }
  }
}

1	import { Inject, Injectable } from '@nestjs/common';	78✔
2	import { IConfigurationService } from '@/config/configuration.service.interface';	78✔
3	import { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';	78✔
4	import { CacheRouter } from '@/datasources/cache/cache.router';	78✔
5	import {	78✔
6	CacheService,
7	ICacheService,
8	} from '@/datasources/cache/cache.service.interface';
9	import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';	78✔
10	import { Chain } from '@/domain/chains/entities/chain.entity';
11	import { Page } from '@/domain/entities/page.entity';
12	import { IConfigApi } from '@/domain/interfaces/config-api.interface';
13	import { SafeApp } from '@/domain/safe-apps/entities/safe-app.entity';
14
15	@Injectable()
16	export class ConfigApi implements IConfigApi {	78✔
17	private readonly baseUri: string;
18	private readonly defaultExpirationTimeInSeconds: number;
19	private readonly defaultNotFoundExpirationTimeSeconds: number;
20
21	constructor(
22	private readonly dataSource: CacheFirstDataSource,	578✔
23	@Inject(CacheService) private readonly cacheService: ICacheService,	578✔
24	@Inject(IConfigurationService)
25	private readonly configurationService: IConfigurationService,	578✔
26	private readonly httpErrorFactory: HttpErrorFactory,	578✔
27	) {
28	this.baseUri =	578✔
29	this.configurationService.getOrThrow<string>('safeConfig.baseUri');
30	this.defaultExpirationTimeInSeconds =	576✔
31	this.configurationService.getOrThrow<number>(
32	'expirationTimeInSeconds.default',
33	);
34	this.defaultNotFoundExpirationTimeSeconds =	576✔
35	this.configurationService.getOrThrow<number>(
36	'expirationTimeInSeconds.notFound.default',
37	);
38	}
39
40	async getChains(args: {
41	limit?: number;
42	offset?: number;
43	}): Promise<Page<Chain>> {
44	try {	12✔
45	const url = `${this.baseUri}/api/v1/chains`;	12✔
46	const params = { limit: args.limit, offset: args.offset };	12✔
47	const cacheDir = CacheRouter.getChainsCacheDir(args);	12✔
48	return await this.dataSource.get({	12✔
49	cacheDir,
50	url,
51	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
52	networkRequest: { params },
53	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
54	});
55	} catch (error) {
56	throw this.httpErrorFactory.from(error);	4✔
57	}
58	}
59
60	async clearChains(): Promise<void> {
61	const pattern = CacheRouter.getChainsCachePattern();	4✔
62	const key = CacheRouter.getChainsCacheKey();	4✔
63	await Promise.all([	4✔
64	this.cacheService.deleteByKey(key),
65	this.cacheService.deleteByKeyPattern(pattern),
66	// TODO: call _setInvalidationTimeForKey for each item matching the pattern
67	]);
68	}
69
70	async getChain(chainId: string): Promise<Chain> {
71	try {	550✔
72	const url = `${this.baseUri}/api/v1/chains/${chainId}`;	550✔
73	const cacheDir = CacheRouter.getChainCacheDir(chainId);	550✔
74	return await this.dataSource.get({	550✔
75	cacheDir,
76	url,
77	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
78	networkRequest: undefined,
79	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
80	});
81	} catch (error) {
82	throw this.httpErrorFactory.from(error);	50✔
83	}
84	}
85
86	async clearChain(chainId: string): Promise<void> {
NEW 87	const chainCacheKey = CacheRouter.getChainCacheKey(chainId);	×
NEW 88	const chainsCacheKey = CacheRouter.getChainsCacheKey();	×
UNCOV 89	await Promise.all([	×
90	this.cacheService.deleteByKey(chainCacheKey),
91	this.cacheService.deleteByKey(chainsCacheKey),
92	]);
93	}
94
95	async getSafeApps(args: {
96	chainId?: string;
97	clientUrl?: string;
98	url?: string;
99	}): Promise<SafeApp[]> {
100	try {	72✔
101	const providerUrl = `${this.baseUri}/api/v1/safe-apps/`;	72✔
102	const params = {	72✔
103	chainId: args.chainId,
104	clientUrl: args.clientUrl,
105	url: args.url,
106	};
107	const cacheDir = CacheRouter.getSafeAppsCacheDir(args);	72✔
108	return await this.dataSource.get({	72✔
109	cacheDir,
110	url: providerUrl,
111	notFoundExpireTimeSeconds: this.defaultNotFoundExpirationTimeSeconds,
112	networkRequest: { params },
113	expireTimeSeconds: this.defaultExpirationTimeInSeconds,
114	});
115	} catch (error) {
116	throw this.httpErrorFactory.from(error);	×
117	}
118	}
119
120	async clearSafeApps(chainId?: string): Promise<void> {
121	if (chainId) {	6✔
122	// if a chain id is provided, delete the safe apps data for that chain id
123	const key = CacheRouter.getSafeAppsKey(chainId);	2✔
124	await this.cacheService.deleteByKey(key);	2✔
125	} else {
126	// if a chain id is not provided, delete all the safe apps data
127	const pattern = CacheRouter.getSafeAppsCachePattern();	4✔
128	await this.cacheService.deleteByKeyPattern(pattern);	4✔
129	// TODO: call _setInvalidationTimeForKey for each item matching the pattern
130	}
131	}
132	}

safe-global / safe-client-gateway / 7338219020

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