@terreno/ui 0.13.0 → 0.14.0

package/src/useConsentHistory.test.ts

@@ -0,0 +1,99 @@
+import {describe, expect, it, mock} from "bun:test";
+import {renderHook} from "@testing-library/react-native";
+
+import type {ConsentHistoryEntry} from "./useConsentHistory";
+import {useConsentHistory} from "./useConsentHistory";
+
+type ConsentHistoryApi = Parameters<typeof useConsentHistory>[0];
+
+interface MockQueryDef {
+  query: () => string;
+  providesTags: string[];
+}
+
+interface MockInjectOpts {
+  endpoints: (build: {query: (def: MockQueryDef) => string}) => Record<string, unknown>;
+}
+
+describe("useConsentHistory", () => {
+  const buildApi = (queryResult: {data?: unknown; error?: unknown; isLoading?: boolean}) => {
+    const refetch = mock(() => {});
+    const useGetMyConsentsQuery = mock(() => ({
+      data: queryResult.data,
+      error: queryResult.error,
+      isLoading: queryResult.isLoading ?? false,
+      refetch,
+    }));
+    const api = {
+      injectEndpoints: mock((opts: MockInjectOpts) => {
+        const build = {
+          query: mock((def: MockQueryDef) => {
+            // Exercise the URL builder so the closure captures `base`
+            const url = def.query();
+            expect(url).toContain("/consents/my");
+            return "my-consents-query";
+          }),
+        };
+        opts.endpoints(build);
+        return {useGetMyConsentsQuery};
+      }),
+    };
+    return {api, refetch};
+  };
+
+  it("returns an array of entries when response is an array", () => {
+    const {api} = buildApi({
+      data: [{_id: "1", agreed: true} as unknown as ConsentHistoryEntry],
+    });
+    const {result} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    expect(Array.isArray(result.current.entries)).toBe(true);
+    expect(result.current.entries).toHaveLength(1);
+  });
+
+  it("unwraps .data property when response is object shape", () => {
+    const {api} = buildApi({
+      data: {data: [{_id: "2", agreed: false} as unknown as ConsentHistoryEntry]},
+    });
+    const {result} = renderHook(() =>
+      useConsentHistory(api as unknown as ConsentHistoryApi, "/api")
+    );
+    expect(Array.isArray(result.current.entries)).toBe(true);
+    expect(result.current.entries).toHaveLength(1);
+  });
+
+  it("returns empty array when no data is present", () => {
+    const {api} = buildApi({data: undefined, isLoading: true});
+    const {result} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    expect(result.current.entries).toEqual([]);
+    expect(result.current.isLoading).toBe(true);
+  });
+
+  it("surfaces error from the query hook", () => {
+    const {api} = buildApi({data: undefined, error: "boom"});
+    const {result} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    expect(result.current.error).toBe("boom");
+  });
+
+  it("injects the my-consents endpoint only once per (api, baseUrl)", () => {
+    let injectCallCount = 0;
+    const refetch = mock(() => {});
+    const useGetMyConsentsQuery = mock(() => ({
+      data: undefined,
+      error: undefined,
+      isLoading: false,
+      refetch,
+    }));
+    const api = {
+      injectEndpoints: () => {
+        injectCallCount += 1;
+        return {useGetMyConsentsQuery};
+      },
+    };
+    const {rerender} = renderHook(() => useConsentHistory(api as unknown as ConsentHistoryApi));
+    rerender(undefined);
+    rerender(undefined);
+    // The hook reuses the cached enhanced api after the first render so the
+    // dev-mode RTK warning about re-injecting endpoints never fires.
+    expect(injectCallCount).toBe(1);
+  });
+});

package/src/useConsentHistory.ts

@@ -35,19 +35,37 @@ interface ConsentHistoryHookState {
   refetch: () => void | Promise<void>;
 }
 
+interface ConsentHistoryEnhancedApi {
+  useGetMyConsentsQuery: () => ConsentHistoryHookState;
+}
+
 interface ConsentHistoryApi {
   injectEndpoints: (options: {
     endpoints: (build: ConsentHistoryQueryBuilder) => {getMyConsents: unknown};
     overrideExisting: boolean;
-  }) => {
-    useGetMyConsentsQuery: () => ConsentHistoryHookState;
-  };
+  }) => ConsentHistoryEnhancedApi;
 }
 
-export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
-  const base = baseUrl || "";
+/**
+ * Cache the enhanced api per (api, baseUrl). `injectEndpoints` logs a console
+ * error in development whenever an endpoint with the same name is re-injected
+ * (with `overrideExisting: false`), so calling it on every render of every
+ * consumer would flood the console. WeakMap-by-api lets the GC reclaim entries
+ * when the api object is unreachable.
+ */
+const enhancedApiCache = new WeakMap<ConsentHistoryApi, Map<string, ConsentHistoryEnhancedApi>>();
 
-  const enhancedApi = api.injectEndpoints({
+const getEnhancedApi = (api: ConsentHistoryApi, base: string): ConsentHistoryEnhancedApi => {
+  let byBase = enhancedApiCache.get(api);
+  if (!byBase) {
+    byBase = new Map();
+    enhancedApiCache.set(api, byBase);
+  }
+  const cached = byBase.get(base);
+  if (cached) {
+    return cached;
+  }
+  const enhanced = api.injectEndpoints({
     endpoints: (build) => ({
       getMyConsents: build.query({
         providesTags: ["MyConsents"],
@@ -56,6 +74,13 @@ export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
     }),
     overrideExisting: false,
   });
+  byBase.set(base, enhanced);
+  return enhanced;
+};
+
+export const useConsentHistory = (api: ConsentHistoryApi, baseUrl?: string) => {
+  const base = baseUrl || "";
+  const enhancedApi = getEnhancedApi(api, base);
 
   const {data, isLoading, error, refetch} = enhancedApi.useGetMyConsentsQuery();
   const entries: ConsentHistoryEntry[] = Array.isArray(data) ? data : (data?.data ?? []);

package/src/useSubmitConsent.test.ts

@@ -72,4 +72,28 @@ describe("useSubmitConsent", () => {
     const {result} = renderHook(() => useSubmitConsent(api as unknown as SubmitConsentApi));
     expect(result.current.submit).toBeDefined();
   });
+
+  it("injects the submit endpoint only once per (api, baseUrl)", () => {
+    let injectCallCount = 0;
+    const unwrap = mock(async () => ({}));
+    const submitMutation = mock(() => ({unwrap}));
+    const useSubmitConsentResponseMutation = mock(() => [
+      submitMutation,
+      {error: undefined, isLoading: false},
+    ]);
+    const api = {
+      enhanceEndpoints: () => ({
+        injectEndpoints: () => {
+          injectCallCount += 1;
+          return {useSubmitConsentResponseMutation};
+        },
+      }),
+    };
+    const {rerender} = renderHook(() => useSubmitConsent(api as unknown as SubmitConsentApi));
+    rerender(undefined);
+    rerender(undefined);
+    // The hook reuses the cached enhanced api after the first render so the
+    // dev-mode RTK warning about re-injecting endpoints never fires.
+    expect(injectCallCount).toBe(1);
+  });
 });

package/src/useSubmitConsent.ts

@@ -26,27 +26,45 @@ interface SubmitConsentMutationBuilder {
   }) => unknown;
 }
 
+interface SubmitConsentEnhancedApi {
+  useSubmitConsentResponseMutation: () => [
+    (body: SubmitConsentBody) => SubmitConsentMutationResult,
+    SubmitConsentMutationHookState,
+  ];
+}
+
 interface SubmitConsentApiWithTags {
   injectEndpoints: (options: {
     endpoints: (build: SubmitConsentMutationBuilder) => {submitConsentResponse: unknown};
     overrideExisting: boolean;
-  }) => {
-    useSubmitConsentResponseMutation: () => [
-      (body: SubmitConsentBody) => SubmitConsentMutationResult,
-      SubmitConsentMutationHookState,
-    ];
-  };
+  }) => SubmitConsentEnhancedApi;
 }
 
 interface SubmitConsentApi {
   enhanceEndpoints: (options: {addTagTypes: string[]}) => SubmitConsentApiWithTags;
 }
 
-export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
-  const base = baseUrl || "";
-  const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
+/**
+ * Cache the enhanced api per (api, baseUrl). `injectEndpoints` logs a console
+ * error in development whenever an endpoint with the same name is re-injected
+ * (with `overrideExisting: false`), so calling it on every render of every
+ * consumer would flood the console. WeakMap-by-api lets the GC reclaim entries
+ * when the api object is unreachable.
+ */
+const enhancedApiCache = new WeakMap<SubmitConsentApi, Map<string, SubmitConsentEnhancedApi>>();
 
-  const enhancedApi = apiWithConsentTags.injectEndpoints({
+const getEnhancedApi = (api: SubmitConsentApi, base: string): SubmitConsentEnhancedApi => {
+  let byBase = enhancedApiCache.get(api);
+  if (!byBase) {
+    byBase = new Map();
+    enhancedApiCache.set(api, byBase);
+  }
+  const cached = byBase.get(base);
+  if (cached) {
+    return cached;
+  }
+  const apiWithConsentTags = api.enhanceEndpoints({addTagTypes: ["PendingConsents"]});
+  const enhanced = apiWithConsentTags.injectEndpoints({
     endpoints: (build) => ({
       submitConsentResponse: build.mutation({
         invalidatesTags: ["PendingConsents"],
@@ -59,6 +77,13 @@ export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
     }),
     overrideExisting: false,
   });
+  byBase.set(base, enhanced);
+  return enhanced;
+};
+
+export const useSubmitConsent = (api: SubmitConsentApi, baseUrl?: string) => {
+  const base = baseUrl || "";
+  const enhancedApi = getEnhancedApi(api, base);
 
   const [submitMutation, {isLoading: isSubmitting, error}] =
     enhancedApi.useSubmitConsentResponseMutation();