[LWDM] chore(aggregated-assets): move domain layer behind shims (LIVE-35226)

.changeset/quiet-comets-relocate.md

@@ -0,0 +1,8 @@
+---
+"@domain/entity-aggregated-asset": minor
+"@domain/entity-interest-rate": minor
+"@domain/api-aggregated-assets": minor
+"@ledgerhq/live-common": patch
+---
+
+Move the dada-client domain layer into the aggregated-assets DDD packages, leaving re-export shims at the old paths so no consumer changes

domain/api/aggregated-assets/package.json

@@ -7,14 +7,17 @@
   "types": "src/index.ts",
   "exports": {
     ".": "./src/index.ts",
+    "./mock": "./src/assetsData.mock.ts",
+    "./mock/stocks": "./src/stocks.mock.ts",
+    "./mock/stablecoins": "./src/stablecoins.mock.ts",
     "./package.json": "./package.json"
   },
   "sideEffects": false,
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test": "jest --passWithNoTests",
+    "test": "jest",
     "test:watch": "jest --watch",
-    "coverage": "jest --coverage --passWithNoTests",
+    "coverage": "jest --coverage",
     "unimported": "pnpm knip --directory ../../.. -W domain/api/aggregated-assets"
   },
   "devDependencies": {
@@ -24,6 +27,23 @@
     "@types/jest": "catalog:",
     "@types/node": "catalog:",
     "jest": "catalog:",
+    "react": "catalog:",
+    "react-redux": "catalog:",
     "typescript": "catalog:"
+  },
+  "dependencies": {
+    "@domain/api-currency-token": "workspace:^",
+    "@domain/entity-aggregated-asset": "workspace:*",
+    "@domain/entity-currency": "workspace:^",
+    "@domain/entity-currency-crypto": "workspace:^",
+    "@domain/entity-currency-token": "workspace:^",
+    "@domain/entity-interest-rate": "workspace:*",
+    "@reduxjs/toolkit": "catalog:",
+    "@shared/api-services": "workspace:*",
+    "@shared/env": "workspace:*"
+  },
+  "peerDependencies": {
+    "react": ">=19.0.0",
+    "react-redux": ">=9.0.0"
   }
 }

domain/api/aggregated-assets/src/accessors.ts

@@ -0,0 +1,16 @@
+import { collectAllByCategory } from "./internals/collectAllByCategory";
+import type { GetAssetsByCategoryParams } from "./types";
+
+/** Every ticker in a category, across all pages. */
+export function fetchAllAssetsByCategory(queryArg: GetAssetsByCategoryParams) {
+  return collectAllByCategory(queryArg, data =>
+    Object.values(data.cryptoAssets).map(a => a.ticker),
+  );
+}
+
+/** Every per-network currency id in a category, across all pages. */
+export function fetchAllAssetCurrencyIdsByCategory(queryArg: GetAssetsByCategoryParams) {
+  return collectAllByCategory(queryArg, data =>
+    Object.values(data.cryptoAssets).flatMap(meta => Object.values(meta.assetsIds)),
+  );
+}

domain/api/aggregated-assets/src/api.test.ts

@@ -0,0 +1,21 @@
+/*
+ * The Domain Test CI job installs only ./domain/** and ./shared/**, so @shared/env's transitive
+ * @ledgerhq/live-env (a libs/ package) is absent. Mock it with a factory so the real module is
+ * never resolved — this test only reads a static property.
+ */
+jest.mock("@shared/env", () => ({
+  getEnv: jest.fn().mockReturnValue("https://dada.api.ledger.com/v1"),
+}));
+
+import { assetsDataApi } from "./api";
+
+describe("assetsDataApi", () => {
+  /*
+   * createCurrencyDataSelector hand-scans state.assetsDataApi.queries by string, and Storybook
+   * stories preload this exact key. A rename produces no type error and silently returns
+   * undefined for every market and interest-rate lookup, so pin the literal.
+   */
+  it("keeps the frozen reducerPath", () => {
+    expect(assetsDataApi.reducerPath).toBe("assetsDataApi");
+  });
+});

domain/api/aggregated-assets/src/api.ts

@@ -0,0 +1,136 @@
+import { dadaApi } from "@shared/api-services";
+import {
+  AssetsDataTags,
+  ONE_DAY_IN_SECONDS,
+  type AssetsData,
+  type AssetsDataWithPagination,
+  type GetAssetsByCategoryParams,
+  type GetAssetsDataParams,
+  type PageParam,
+} from "./types";
+import { transformAssetsResponse } from "./transforms";
+import { fetchAllAssetCurrencyIdsByCategory, fetchAllAssetsByCategory } from "./accessors";
+import { buildAssetsQueryParams, fetchAssetsPage, resolveBaseUrl } from "./requests";
+import { chunkCurrencyIds } from "./internals/chunkCurrencyIds";
+import { deepMergeCryptoAssets } from "./internals/deepMergeCryptoAssets";
+import { emptyAssetsData } from "./internals/emptyAssetsData";
+import { allSettled } from "./internals/allSettled";
+
+/*
+ * `injectEndpoints` adds this use case's endpoints to the shared DADA service api, and
+ * `enhanceEndpoints` widens its tag union in place — `injectEndpoints` does not accept `tagTypes`.
+ * Both mutate and return the same object, so one reducer, one middleware and one cache slice serve
+ * every use case on this backend.
+ *
+ * That single slice is load-bearing: `createCurrencyDataSelector` hand-scans
+ * `state.assetsDataApi.queries` across every cache entry, which is how interest rates and market
+ * trend fetched by one query reach a caller that ran a different one.
+ */
+export const assetsDataApi = dadaApi
+  .enhanceEndpoints({ addTagTypes: [AssetsDataTags.Assets] })
+  .injectEndpoints({
+    endpoints: build => ({
+      getAssetsData: build.infiniteQuery<AssetsDataWithPagination, GetAssetsDataParams, PageParam>({
+        query: ({ pageParam, queryArg }) => ({
+          url: `${resolveBaseUrl(queryArg)}/assets`,
+          params: buildAssetsQueryParams(queryArg, { cursor: pageParam?.cursor }),
+        }),
+        providesTags: [AssetsDataTags.Assets],
+        transformResponse: transformAssetsResponse,
+        infiniteQueryOptions: {
+          initialPageParam: {
+            cursor: "",
+          },
+          getNextPageParam: lastPage => {
+            if (lastPage.pagination.nextCursor) {
+              return {
+                cursor: lastPage.pagination.nextCursor,
+              };
+            } else {
+              return undefined;
+            }
+          },
+        },
+      }),
+      getAssetData: build.query<AssetsDataWithPagination, GetAssetsDataParams>({
+        query: queryArg => ({
+          url: `${resolveBaseUrl(queryArg)}/assets`,
+          params: buildAssetsQueryParams(queryArg, { pageSize: 1 }),
+        }),
+        providesTags: [AssetsDataTags.Assets],
+        transformResponse: transformAssetsResponse,
+      }),
+      getAssetsByCategory: build.query<string[], GetAssetsByCategoryParams>({
+        queryFn: async queryArg => {
+          return fetchAllAssetsByCategory(queryArg);
+        },
+        keepUnusedDataFor: ONE_DAY_IN_SECONDS,
+      }),
+      getAssetCurrencyIdsByCategory: build.query<string[], GetAssetsByCategoryParams>({
+        queryFn: async queryArg => {
+          return fetchAllAssetCurrencyIdsByCategory(queryArg);
+        },
+        keepUnusedDataFor: ONE_DAY_IN_SECONDS,
+      }),
+      getChunkedAssetsData: build.query<AssetsData, GetAssetsDataParams>({
+        queryFn: async queryArg => {
+          try {
+            const chunks = chunkCurrencyIds(queryArg.currencyIds ?? []);
+            const baseUrl = resolveBaseUrl(queryArg);
+
+            if (chunks.length === 0) {
+              return { data: emptyAssetsData() };
+            }
+
+            const results = await allSettled(
+              chunks.map(chunkIds =>
+                fetchAssetsPage(baseUrl, { ...queryArg, currencyIds: chunkIds }),
+              ),
+            );
+
+            const responses = results.flatMap(r => (r.status === "fulfilled" ? [r.value] : []));
+
+            if (responses.length === 0) {
+              const firstError = results.find(r => r.status === "rejected");
+              const reason = firstError?.status === "rejected" ? firstError.reason : undefined;
+              return {
+                error: {
+                  status: "FETCH_ERROR",
+                  error: reason instanceof Error ? reason.message : "All DADA chunks failed",
+                },
+              };
+            }
+
+            const merged = responses.reduce<AssetsData>((acc, res) => {
+              deepMergeCryptoAssets(acc.cryptoAssets, res.cryptoAssets);
+              Object.assign(acc.networks, res.networks);
+              Object.assign(acc.cryptoOrTokenCurrencies, res.cryptoOrTokenCurrencies);
+              Object.assign(acc.interestRates, res.interestRates);
+              Object.assign(acc.markets, res.markets);
+              acc.currenciesOrder.metaCurrencyIds.push(...res.currenciesOrder.metaCurrencyIds);
+              return acc;
+            }, emptyAssetsData());
+
+            return { data: merged };
+          } catch (error) {
+            return {
+              error: {
+                status: "FETCH_ERROR",
+                error: error instanceof Error ? error.message : "Unknown error",
+              },
+            };
+          }
+        },
+        providesTags: [AssetsDataTags.Assets],
+        keepUnusedDataFor: ONE_DAY_IN_SECONDS,
+      }),
+    }),
+  });
+
+export const {
+  useGetAssetsDataInfiniteQuery,
+  useGetAssetDataQuery,
+  useGetAssetsByCategoryQuery,
+  useGetAssetCurrencyIdsByCategoryQuery,
+  useGetChunkedAssetsDataQuery,
+} = assetsDataApi;