fix: Revert/decoder service integration (#2589)

This PR reverts the decoder service integration.

Author: PooyaRaki

src/datasources/cache/cache.first.data.source.spec.ts

@@ -71,71 +71,12 @@ export class CacheFirstDataSource {
     notFoundExpireTimeSeconds: number;
     networkRequest?: NetworkRequest;
     expireTimeSeconds?: number;
-  }): Promise<Raw<T>> {
-    return await this.tryCache({
-      ...args,
-      queryFn: () => {
-        return this._getFromNetworkAndWriteCache({
-          ...args,
-          method: 'get',
-        });
-      },
-    });
-  }
-
-  /**
-   * Gets the cached value behind {@link CacheDir}.
-   * If the value is not present, it tries to get the respective JSON
-   * payload from {@link url}.
-   * 404 errors are cached with {@link notFoundExpireTimeSeconds} seconds expiration time.
-   *
-   * @param args.cacheDir - {@link CacheDir} containing the key and field to be used to retrieve from cache
-   * @param args.url - the HTTP endpoint to retrieve the JSON payload
-   * @param args.networkRequest - the HTTP request to be used if there is a cache miss
-   * @param args.expireTimeSeconds - the time to live in seconds for the payload behind {@link CacheDir}
-   * @param args.notFoundExpireTimeSeconds - the time to live in seconds for the error when the item is not found
-   * @param args.data - the data to be sent in the body of the request
-   */
-  async post<T>(args: {
-    cacheDir: CacheDir;
-    url: string;
-    notFoundExpireTimeSeconds: number;
-    networkRequest?: NetworkRequest;
-    expireTimeSeconds?: number;
-    data: object;
-  }): Promise<Raw<T>> {
-    return await this.tryCache({
-      ...args,
-      queryFn: () => {
-        return this._getFromNetworkAndWriteCache({
-          ...args,
-          method: 'post',
-        });
-      },
-    });
-  }
-
-  /**
-   * Gets the cached value behind {@link CacheDir}.
-   * If the value is not present, it tries to get the respective JSON
-   * payload from {@link queryFn}.
-   * 404 errors are cached with {@link notFoundExpireTimeSeconds} seconds expiration time.
-   *
-   * @param args.cacheDir - {@link CacheDir} containing the key and field to be used to retrieve from cache
-   * @param args.notFoundExpireTimeSeconds - the time to live in seconds for the error when the item is not found
-   * @param args.fn - the function to be executed if the cache entry is not found
-   * @returns the cached value or the result of the function
-   */
-  private async tryCache<T>(args: {
-    cacheDir: CacheDir;
-    notFoundExpireTimeSeconds: number;
-    queryFn: () => Promise<Raw<T>>;
   }): Promise<Raw<T>> {
     const cached = await this.cacheService.hGet(args.cacheDir);
     if (cached != null) return this._getFromCachedData(args.cacheDir, cached);
 
     try {
-      return await args.queryFn();
+      return await this._getFromNetworkAndWriteCache(args);
     } catch (error) {
       if (
         error instanceof NetworkResponseError &&
@@ -170,34 +111,20 @@ export class CacheFirstDataSource {
   }
 
   /**
-   * Gets/posts the data from the network and caches the result.
+   * Gets the data from the network and caches the result.
    */
-  private async _getFromNetworkAndWriteCache<T>(
-    args:
-      | {
-          cacheDir: CacheDir;
-          url: string;
-          networkRequest?: NetworkRequest;
-          expireTimeSeconds?: number;
-          method: 'get';
-          data?: never;
-        }
-      | {
-          cacheDir: CacheDir;
-          url: string;
-          networkRequest?: NetworkRequest;
-          expireTimeSeconds?: number;
-          method: 'post';
-          data: object;
-        },
-  ): Promise<Raw<T>> {
+  private async _getFromNetworkAndWriteCache<T>(args: {
+    cacheDir: CacheDir;
+    url: string;
+    networkRequest?: NetworkRequest;
+    expireTimeSeconds?: number;
+  }): Promise<Raw<T>> {
     const { key, field } = args.cacheDir;
     this.loggingService.debug({ type: LogType.CacheMiss, key, field });
     const startTimeMs = Date.now();
-    const { data } = await this.networkService[args.method]<T>({
+    const { data } = await this.networkService.get<T>({
       url: args.url,
       networkRequest: args.networkRequest,
-      data: args.data,
     });
 
     const shouldBeCached = await this._shouldBeCached(key, startTimeMs);

src/datasources/cache/cache.first.data.source.ts

@@ -16,8 +16,6 @@ export class CacheRouter {
   private static readonly COUNTERFACTUAL_SAFE_KEY = 'counterfactual_safe';
   private static readonly COUNTERFACTUAL_SAFES_KEY = 'counterfactual_safes';
   private static readonly CREATION_TRANSACTION_KEY = 'creation_transaction';
-  private static readonly DECODED_DATA_KEY = 'decoded_data';
-  private static readonly DECODED_DATA_CONTRACTS_KEY = 'decoded_data_contracts';
   private static readonly DELEGATES_KEY = 'delegates';
   private static readonly FIREBASE_OAUTH2_TOKEN_KEY = 'firebase_oauth2_token';
   private static readonly INCOMING_TRANSFERS_KEY = 'incoming_transfers';
@@ -389,43 +387,6 @@ export class CacheRouter {
     );
   }
 
-  static getDecodedDataCacheKey(args: {
-    chainId: string;
-    data: `0x${string}`;
-    to: `0x${string}`;
-  }): string {
-    return `${args.chainId}_${CacheRouter.DECODED_DATA_KEY}_${args.data}_${args.to}`;
-  }
-
-  static getDecodedDataCacheDir(args: {
-    chainId: string;
-    data: `0x${string}`;
-    to: `0x${string}`;
-  }): CacheDir {
-    return new CacheDir(CacheRouter.getDecodedDataCacheKey(args), '');
-  }
-
-  static getDecodedDataContractsCacheKey(args: {
-    chainIds: Array<string>;
-    address: `0x${string}`;
-    limit?: number;
-    offset?: number;
-  }): string {
-    return `${args.chainIds.sort().join('_')}_${CacheRouter.DECODED_DATA_CONTRACTS_KEY}_${args.address}`;
-  }
-
-  static getDecodedDataContractsCacheDir(args: {
-    chainIds: Array<string>;
-    address: `0x${string}`;
-    limit?: number;
-    offset?: number;
-  }): CacheDir {
-    return new CacheDir(
-      CacheRouter.getDecodedDataContractsCacheKey(args),
-      `${args.limit}_${args.offset}`,
-    );
-  }
-
   static getAllTransactionsCacheDir(args: {
     chainId: string;
     safeAddress: `0x${string}`;

src/datasources/cache/cache.router.ts

@@ -2,10 +2,8 @@ import { Module } from '@nestjs/common';
 import { DataDecoderApi } from '@/datasources/data-decoder-api/data-decoder-api.service';
 import { HttpErrorFactory } from '@/datasources/errors/http-error-factory';
 import { IDataDecoderApi } from '@/domain/interfaces/data-decoder-api.interface';
-import { CacheFirstDataSourceModule } from '@/datasources/cache/cache.first.data.source.module';
 
 @Module({
-  imports: [CacheFirstDataSourceModule],
   providers: [
     HttpErrorFactory,
     { provide: IDataDecoderApi, useClass: DataDecoderApi },

src/datasources/data-decoder-api/data-decoder-api.module.ts

@@ -9,20 +9,19 @@ import { DataSourceError } from '@/domain/errors/data-source.error';
 import { NetworkResponseError } from '@/datasources/network/entities/network.error.entity';
 import { rawify } from '@/validation/entities/raw.entity';
 import type { IConfigurationService } from '@/config/configuration.service.interface';
-import type { CacheFirstDataSource } from '@/datasources/cache/cache.first.data.source';
+import type { INetworkService } from '@/datasources/network/network.service.interface';
 
 const mockConfigurationService = jest.mocked({
   getOrThrow: jest.fn(),
 } as jest.MockedObjectDeep<IConfigurationService>);
 
-const mockCacheFirstDataSource = jest.mocked({
+const mockNetworkService = jest.mocked({
   get: jest.fn(),
   post: jest.fn(),
-} as jest.MockedObjectDeep<CacheFirstDataSource>);
+} as jest.MockedObjectDeep<INetworkService>);
 
 describe('DataDecoderApi', () => {
   const baseUrl = faker.internet.url({ appendSlash: false });
-  const notFoundExpireTimeSeconds = faker.number.int();
   let target: DataDecoderApi;
 
   beforeEach(() => {
@@ -32,15 +31,12 @@ describe('DataDecoderApi', () => {
       if (key === 'safeDataDecoder.baseUri') {
         return baseUrl;
       }
-      if (key === 'expirationTimeInSeconds.notFound.default') {
-        return notFoundExpireTimeSeconds;
-      }
       throw new Error('Unexpected key');
     });
     const httpErrorFactory = new HttpErrorFactory();
     target = new DataDecoderApi(
       mockConfigurationService,
-      mockCacheFirstDataSource,
+      mockNetworkService,
       httpErrorFactory,
     );
   });
@@ -52,24 +48,19 @@ describe('DataDecoderApi', () => {
       const chainId = faker.string.numeric();
       const data = faker.string.hexadecimal() as `0x${string}`;
       const getDataDecodedUrl = `${baseUrl}/api/v1/data-decoder`;
-      mockCacheFirstDataSource.post.mockImplementation(({ url }) => {
+      mockNetworkService.post.mockImplementation(({ url }) => {
         if (url === getDataDecodedUrl) {
-          return Promise.resolve(rawify(dataDecoded));
+          return Promise.resolve({ status: 200, data: rawify(dataDecoded) });
         }
         throw new Error('Unexpected URL');
       });
 
       const actual = await target.getDecodedData({ data, to, chainId });
 
       expect(actual).toStrictEqual(dataDecoded);
-      expect(mockCacheFirstDataSource.post).toHaveBeenCalledTimes(1);
-      expect(mockCacheFirstDataSource.post).toHaveBeenCalledWith({
-        cacheDir: {
-          field: '',
-          key: `${chainId}_decoded_data_${data}_${to}`,
-        },
+      expect(mockNetworkService.post).toHaveBeenCalledTimes(1);
+      expect(mockNetworkService.post).toHaveBeenCalledWith({
         url: getDataDecodedUrl,
-        notFoundExpireTimeSeconds,
         data: { chainId, to, data },
       });
     });
@@ -84,7 +75,7 @@ describe('DataDecoderApi', () => {
       });
       const expected = new DataSourceError(errorMessage, statusCode);
       const getDataDecodedUrl = `${baseUrl}/api/v1/data-decoder`;
-      mockCacheFirstDataSource.post.mockImplementation(({ url }) => {
+      mockNetworkService.post.mockImplementation(({ url }) => {
         if (url === getDataDecodedUrl) {
           return Promise.reject(
             new NetworkResponseError(
@@ -103,14 +94,9 @@ describe('DataDecoderApi', () => {
         target.getDecodedData({ data, to, chainId }),
       ).rejects.toThrow(expected);
 
-      expect(mockCacheFirstDataSource.post).toHaveBeenCalledTimes(1);
-      expect(mockCacheFirstDataSource.post).toHaveBeenCalledWith({
-        cacheDir: {
-          field: '',
-          key: `${chainId}_decoded_data_${data}_${to}`,
-        },
+      expect(mockNetworkService.post).toHaveBeenCalledTimes(1);
+      expect(mockNetworkService.post).toHaveBeenCalledWith({
         url: getDataDecodedUrl,
-        notFoundExpireTimeSeconds,
         data: { chainId, to, data },
       });
     });
@@ -121,9 +107,9 @@ describe('DataDecoderApi', () => {
       const contract = contractBuilder().build();
       const contractPage = pageBuilder().with('results', [contract]).build();
       const getContractsUrl = `${baseUrl}/api/v1/contracts/${contract.address}`;
-      mockCacheFirstDataSource.get.mockImplementation(({ url }) => {
+      mockNetworkService.get.mockImplementation(({ url }) => {
         if (url === getContractsUrl) {
-          return Promise.resolve(rawify(contractPage));
+          return Promise.resolve({ status: 200, data: rawify(contractPage) });
         }
         throw new Error('Unexpected URL');
       });
@@ -134,14 +120,9 @@ describe('DataDecoderApi', () => {
       });
 
       expect(actual).toStrictEqual(contractPage);
-      expect(mockCacheFirstDataSource.get).toHaveBeenCalledTimes(1);
-      expect(mockCacheFirstDataSource.get).toHaveBeenCalledWith({
-        cacheDir: {
-          field: 'undefined_undefined',
-          key: `${contract.chainId}_decoded_data_contracts_${contract.address}`,
-        },
+      expect(mockNetworkService.get).toHaveBeenCalledTimes(1);
+      expect(mockNetworkService.get).toHaveBeenCalledWith({
         url: getContractsUrl,
-        notFoundExpireTimeSeconds,
         networkRequest: {
           params: {
             chain_ids: contract.chainId.toString(),
@@ -161,9 +142,9 @@ describe('DataDecoderApi', () => {
       ];
       const contractPage = pageBuilder().with('results', [contract]).build();
       const getContractsUrl = `${baseUrl}/api/v1/contracts/${contract.address}`;
-      mockCacheFirstDataSource.get.mockImplementation(({ url }) => {
+      mockNetworkService.get.mockImplementation(({ url }) => {
         if (url === getContractsUrl) {
-          return Promise.resolve(rawify(contractPage));
+          return Promise.resolve({ status: 200, data: rawify(contractPage) });
         }
         throw new Error('Unexpected URL');
       });
@@ -174,14 +155,9 @@ describe('DataDecoderApi', () => {
       });
 
       expect(actual).toStrictEqual(contractPage);
-      expect(mockCacheFirstDataSource.get).toHaveBeenCalledTimes(1);
-      expect(mockCacheFirstDataSource.get).toHaveBeenCalledWith({
-        cacheDir: {
-          field: 'undefined_undefined',
-          key: `${chainIds.sort().join('_')}_decoded_data_contracts_${contract.address}`,
-        },
+      expect(mockNetworkService.get).toHaveBeenCalledTimes(1);
+      expect(mockNetworkService.get).toHaveBeenCalledWith({
         url: getContractsUrl,
-        notFoundExpireTimeSeconds,
         networkRequest: {
           params: {
             chain_ids: `${chainIds[0]}&chain_ids=${chainIds[1]}&chain_ids=${chainIds[2]}`,
@@ -200,7 +176,7 @@ describe('DataDecoderApi', () => {
       });
       const expected = new DataSourceError(errorMessage, statusCode);
       const getContractsUrl = `${baseUrl}/api/v1/contracts/${contract.address}`;
-      mockCacheFirstDataSource.get.mockImplementation(({ url }) => {
+      mockNetworkService.get.mockImplementation(({ url }) => {
         if (url === getContractsUrl) {
           return Promise.reject(
             new NetworkResponseError(
@@ -222,14 +198,9 @@ describe('DataDecoderApi', () => {
         }),
       ).rejects.toThrow(expected);
 
-      expect(mockCacheFirstDataSource.get).toHaveBeenCalledTimes(1);
-      expect(mockCacheFirstDataSource.get).toHaveBeenCalledWith({
-        cacheDir: {
-          field: 'undefined_undefined',
-          key: `${contract.chainId}_decoded_data_contracts_${contract.address}`,
-        },
+      expect(mockNetworkService.get).toHaveBeenCalledTimes(1);
+      expect(mockNetworkService.get).toHaveBeenCalledWith({
         url: getContractsUrl,
-        notFoundExpireTimeSeconds,
         networkRequest: {
           params: {
             chain_ids: contract.chainId.toString(),