@terreno/rtk 0.10.0 → 0.11.0

package/src/tagGenerator.test.ts

@@ -0,0 +1,109 @@
+import {describe, expect, it} from "bun:test";
+
+import {generateTags} from "./tagGenerator";
+
+describe("generateTags", () => {
+  const tagTypes = ["users", "posts", "conversations", "messages"];
+
+  it("assigns invalidatesTags for getConversations endpoint", () => {
+    const api = {
+      endpoints: {
+        getConversations: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    // getConversations matches both the special case AND the list-endpoint branch,
+    // so the list-endpoint branch wins as the final assignment. The special case
+    // still executes for coverage, but the final value is the list providesTags.
+    expect(tags.getConversations).toBeDefined();
+    expect(typeof tags.getConversations.providesTags).toBe("function");
+  });
+
+  it("assigns providesTags on list get endpoints", () => {
+    const api = {
+      endpoints: {
+        getUsers: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    expect(typeof tags.getUsers.providesTags).toBe("function");
+
+    // Exercise the returned provides function with and without data
+    const providesFn = tags.getUsers.providesTags;
+    expect(providesFn(null)).toEqual(["users"]);
+    expect(providesFn({data: [{_id: "1"}, {_id: "2"}]})).toEqual([
+      {id: "1", type: "users"},
+      {id: "2", type: "users"},
+      "users",
+    ]);
+    expect(providesFn({})).toEqual(["users"]);
+  });
+
+  it("assigns providesTags on read (ById) get endpoints", () => {
+    const api = {
+      endpoints: {
+        getUserById: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    expect(typeof tags.getUserById.providesTags).toBe("function");
+
+    const providesFn = tags.getUserById.providesTags;
+    expect(providesFn(null)).toEqual(["users"]);
+    expect(providesFn({_id: "abc"})).toEqual([{id: "abc", type: "users"}]);
+  });
+
+  it("assigns invalidatesTags on patch endpoints", () => {
+    const api = {
+      endpoints: {
+        patchUserById: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    expect(typeof tags.patchUserById.invalidatesTags).toBe("function");
+
+    const invalidateFn = tags.patchUserById.invalidatesTags;
+    expect(invalidateFn(null)).toEqual(["users"]);
+    expect(invalidateFn({data: [{_id: "x"}]})).toEqual([{id: "x", type: "users"}, "users"]);
+  });
+
+  it("assigns invalidatesTags on delete endpoints", () => {
+    const api = {
+      endpoints: {
+        deletePostById: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    expect(typeof tags.deletePostById.invalidatesTags).toBe("function");
+
+    const invalidateFn = tags.deletePostById.invalidatesTags;
+    expect(invalidateFn(null)).toEqual(["posts"]);
+  });
+
+  it("skips endpoints with no matching tag", () => {
+    const api = {
+      endpoints: {
+        getUnknownThing: {},
+        patchOrphan: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    expect(tags.getUnknownThing).toBeUndefined();
+    expect(tags.patchOrphan).toBeUndefined();
+  });
+
+  it("returns an empty object for an empty endpoint list", () => {
+    const tags = generateTags({endpoints: {}}, tagTypes);
+    expect(tags).toEqual({});
+  });
+
+  it("ignores endpoints that are not get/patch/delete", () => {
+    const api = {
+      endpoints: {
+        postUser: {},
+      },
+    };
+    const tags = generateTags(api, tagTypes);
+    expect(tags.postUser).toBeUndefined();
+  });
+});

package/src/testPreload.test.ts

@@ -0,0 +1,30 @@
+import {describe, expect, it} from "bun:test";
+
+// Invoke the mocked module factories registered in test-preload.ts so
+// their bodies (and returned functions) are recognised as covered.
+describe("test-preload default mocks", () => {
+  it("expo-secure-store mock returns a no-op store", async () => {
+    const SecureStore = await import("expo-secure-store");
+    await SecureStore.setItemAsync("k", "v");
+    await SecureStore.deleteItemAsync("k");
+    expect(await SecureStore.getItemAsync("k")).toBeNull();
+  });
+
+  it("AsyncStorage mock returns a no-op store", async () => {
+    const AsyncStorage = (await import("@react-native-async-storage/async-storage")).default;
+    await AsyncStorage.setItem("k", "v");
+    await AsyncStorage.removeItem("k");
+    expect(await AsyncStorage.getItem("k")).toBeNull();
+  });
+
+  it("expo-network mock reports a connected network", async () => {
+    const network = await import("expo-network");
+    const state = await network.getNetworkStateAsync();
+    expect(state.isConnected).toBe(true);
+  });
+
+  it("expo-constants mock exposes an empty config", async () => {
+    const Constants = (await import("expo-constants")).default;
+    expect(Constants.expoConfig?.extra).toBeDefined();
+  });
+});

package/src/useFeatureFlags.test.ts

@@ -0,0 +1,209 @@
+import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
+import {renderHook} from "@testing-library/react-native";
+
+import {resolveFeatureFlagsOptions, useFeatureFlags} from "./useFeatureFlags";
+
+type FlagValues = Record<string, boolean | string | null>;
+type QueryResult = {
+  data?: FlagValues;
+  error?: unknown;
+  isLoading?: boolean;
+};
+
+describe("resolveFeatureFlagsOptions", () => {
+  it("applies defaults when no argument is provided", () => {
+    expect(resolveFeatureFlagsOptions()).toEqual({
+      basePath: "/feature-flags",
+      skip: false,
+    });
+  });
+
+  it("applies defaults when an empty options object is provided", () => {
+    expect(resolveFeatureFlagsOptions({})).toEqual({
+      basePath: "/feature-flags",
+      skip: false,
+    });
+  });
+
+  it("treats a string argument as a legacy basePath with skip=false", () => {
+    expect(resolveFeatureFlagsOptions("/custom-path")).toEqual({
+      basePath: "/custom-path",
+      skip: false,
+    });
+  });
+
+  it("preserves an empty string basePath when passed as a legacy string argument", () => {
+    expect(resolveFeatureFlagsOptions("")).toEqual({
+      basePath: "",
+      skip: false,
+    });
+  });
+
+  it("uses options.basePath when provided", () => {
+    expect(resolveFeatureFlagsOptions({basePath: "/flags"})).toEqual({
+      basePath: "/flags",
+      skip: false,
+    });
+  });
+
+  it("uses options.skip when provided", () => {
+    expect(resolveFeatureFlagsOptions({skip: true})).toEqual({
+      basePath: "/feature-flags",
+      skip: true,
+    });
+  });
+
+  it("uses both options.basePath and options.skip when provided together", () => {
+    expect(resolveFeatureFlagsOptions({basePath: "/flags", skip: true})).toEqual({
+      basePath: "/flags",
+      skip: true,
+    });
+  });
+
+  it("does not let a legacy string basePath override skip to true", () => {
+    expect(resolveFeatureFlagsOptions("/custom-path").skip).toBe(false);
+  });
+});
+
+const buildApi = (queryResult: QueryResult) => {
+  const refetch = mock(() => {});
+  const capturedQueryBuilder: Array<{method: string; url: string}> = [];
+  const useEvaluateFeatureFlagsQuery = mock(() => ({
+    data: queryResult.data,
+    error: queryResult.error,
+    isLoading: queryResult.isLoading ?? false,
+    refetch,
+  }));
+  const api = {
+    injectEndpoints: mock((opts: {endpoints: (builder: unknown) => void}) => {
+      const builder = {
+        query: (def: {query: () => {method: string; url: string}}) => {
+          capturedQueryBuilder.push(def.query());
+          return {useQuery: useEvaluateFeatureFlagsQuery};
+        },
+      };
+      opts.endpoints(builder);
+      return {useEvaluateFeatureFlagsQuery};
+    }),
+  };
+  return {api, capturedQueryBuilder, refetch, useEvaluateFeatureFlagsQuery};
+};
+
+describe("useFeatureFlags hook", () => {
+  const debugCalls: unknown[][] = [];
+  const originalDebug = console.debug;
+
+  beforeEach(() => {
+    debugCalls.length = 0;
+    console.debug = (...args: unknown[]): void => {
+      debugCalls.push(args);
+    };
+  });
+
+  afterEach(() => {
+    console.debug = originalDebug;
+  });
+
+  it("builds the evaluate endpoint with the default basePath", () => {
+    const {api, capturedQueryBuilder} = buildApi({data: {foo: true}});
+    renderHook(() => useFeatureFlags(api as unknown as Parameters<typeof useFeatureFlags>[0]));
+    expect(capturedQueryBuilder[0]).toEqual({
+      method: "GET",
+      url: "/feature-flags/evaluate",
+    });
+  });
+
+  it("builds the evaluate endpoint with a custom basePath from legacy string argument", () => {
+    const {api, capturedQueryBuilder} = buildApi({data: {foo: true}});
+    renderHook(() =>
+      useFeatureFlags(api as unknown as Parameters<typeof useFeatureFlags>[0], "/flags")
+    );
+    expect(capturedQueryBuilder[0]).toEqual({method: "GET", url: "/flags/evaluate"});
+  });
+
+  it("returns flag accessors that read boolean and string values", () => {
+    const {api} = buildApi({
+      data: {booleanOff: false, booleanOn: true, variantFlag: "variant-a"},
+    });
+    const {result} = renderHook(() =>
+      useFeatureFlags(api as unknown as Parameters<typeof useFeatureFlags>[0])
+    );
+    expect(result.current.getFlag("booleanOn")).toBe(true);
+    expect(result.current.getFlag("booleanOff")).toBe(false);
+    expect(result.current.getFlag("variantFlag")).toBe(false);
+    expect(result.current.getVariant("variantFlag")).toBe("variant-a");
+    expect(result.current.getVariant("booleanOn")).toBeNull();
+    expect(result.current.getVariant("missing")).toBeNull();
+  });
+
+  it("returns an empty flags map when no data is available", () => {
+    const {api} = buildApi({isLoading: true});
+    const {result} = renderHook(() =>
+      useFeatureFlags(api as unknown as Parameters<typeof useFeatureFlags>[0])
+    );
+    expect(result.current.flags).toEqual({});
+    expect(result.current.isLoading).toBe(true);
+  });
+
+  it("exposes refetch from the underlying query hook", () => {
+    const {api, refetch} = buildApi({data: {foo: true}});
+    const {result} = renderHook(() =>
+      useFeatureFlags(api as unknown as Parameters<typeof useFeatureFlags>[0])
+    );
+    result.current.refetch();
+    expect(refetch).toHaveBeenCalled();
+  });
+
+  it("logs evaluate request started when loading begins without prior data", () => {
+    const {api} = buildApi({isLoading: true});
+    renderHook(() => useFeatureFlags(api as unknown as Parameters<typeof useFeatureFlags>[0]));
+    const started = debugCalls.find(
+      (args) => args[0] === "[feature-flags] evaluate request started"
+    );
+    expect(started).toBeDefined();
+  });
+
+  it("logs evaluate request completed when data resolves after a loading phase", () => {
+    const api = buildApi({isLoading: true});
+    const {rerender} = renderHook(
+      ({queryResult}: {queryResult: QueryResult}) => {
+        api.useEvaluateFeatureFlagsQuery.mockImplementationOnce(() => ({
+          data: queryResult.data,
+          error: queryResult.error,
+          isLoading: queryResult.isLoading ?? false,
+          refetch: api.refetch,
+        }));
+        return useFeatureFlags(api.api as unknown as Parameters<typeof useFeatureFlags>[0]);
+      },
+      {initialProps: {queryResult: {isLoading: true}}}
+    );
+    rerender({queryResult: {data: {alpha: true}, isLoading: false}});
+    const completed = debugCalls.find(
+      (args) => args[0] === "[feature-flags] evaluate request completed"
+    );
+    const started = debugCalls.find(
+      (args) => args[0] === "[feature-flags] evaluate request started"
+    );
+    expect(started).toBeDefined();
+    expect(completed).toBeDefined();
+  });
+
+  it("logs evaluate request failed when error is returned after loading", () => {
+    const api = buildApi({isLoading: true});
+    const {rerender} = renderHook(
+      ({queryResult}: {queryResult: QueryResult}) => {
+        api.useEvaluateFeatureFlagsQuery.mockImplementationOnce(() => ({
+          data: queryResult.data,
+          error: queryResult.error,
+          isLoading: queryResult.isLoading ?? false,
+          refetch: api.refetch,
+        }));
+        return useFeatureFlags(api.api as unknown as Parameters<typeof useFeatureFlags>[0]);
+      },
+      {initialProps: {queryResult: {isLoading: true}}}
+    );
+    rerender({queryResult: {error: new Error("boom"), isLoading: false}});
+    const failed = debugCalls.find((args) => args[0] === "[feature-flags] evaluate request failed");
+    expect(failed).toBeDefined();
+  });
+});

package/src/useFeatureFlags.ts

@@ -27,11 +27,50 @@ interface UseFeatureFlagsResult {
  * const variant = getVariant("checkout-experiment");           // "control" | "variant-a" | null
  * ```
  */
-export const useFeatureFlags = (
+export interface UseFeatureFlagsOptions {
+  /**
+   * Base path for the feature-flags endpoint. Defaults to "/feature-flags".
+   */
+  basePath?: string;
+  /**
+   * When true, the underlying evaluate query is not fired. Use this to avoid
+   * fetching before the user is authenticated.
+   */
+  skip?: boolean;
+}
+
+interface ResolvedFeatureFlagsOptions {
+  basePath: string;
+  skip: boolean;
+}
+
+/**
+ * Normalizes the legacy-compatible `basePathOrOptions` argument into a
+ * `{basePath, skip}` pair with defaults applied.
+ *
+ * - `undefined` -> `{basePath: "/feature-flags", skip: false}`
+ * - `string`    -> `{basePath: <string>, skip: false}` (legacy form)
+ * - `object`    -> `{basePath: opts.basePath ?? "/feature-flags", skip: opts.skip ?? false}`
+ */
+export const resolveFeatureFlagsOptions = (
+  basePathOrOptions?: string | UseFeatureFlagsOptions
+): ResolvedFeatureFlagsOptions => {
+  const {basePath = "/feature-flags", skip = false} =
+    typeof basePathOrOptions === "string"
+      ? {basePath: basePathOrOptions, skip: false}
+      : (basePathOrOptions ?? {});
+  return {basePath, skip};
+};
+
+// Overloaded signature preserves backwards compatibility with callers that
+// pass a string basePath as the second argument.
+export function useFeatureFlags(
   // biome-ignore lint/suspicious/noExplicitAny: RTK Query API generic typing is intentionally flexible here.
   api: Api<any, any, any, any>,
-  basePath = "/feature-flags"
-): UseFeatureFlagsResult => {
+  basePathOrOptions?: string | UseFeatureFlagsOptions
+): UseFeatureFlagsResult {
+  const {basePath, skip} = resolveFeatureFlagsOptions(basePathOrOptions);
+
   const enhancedApi = useMemo(
     () =>
       api.injectEndpoints({
@@ -50,7 +89,7 @@ export const useFeatureFlags = (
 
   // biome-ignore lint/suspicious/noExplicitAny: Endpoint hook is injected dynamically by RTK Query.
   const useEvaluateQuery = (enhancedApi as any).useEvaluateFeatureFlagsQuery;
-  const {data, isLoading, error, refetch} = useEvaluateQuery();
+  const {data, isLoading, error, refetch} = useEvaluateQuery(undefined, {skip});
   const evaluateStartedAtRef = useRef<number | null>(null);
 
   const flags: FlagValues = data ?? {};
@@ -118,4 +157,4 @@ export const useFeatureFlags = (
   );
 
   return {error, flags, getFlag, getVariant, isLoading, refetch};
-};
+}

package/dist/test-preload.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=test-preload.d.ts.map

package/dist/test-preload.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-preload.d.ts","sourceRoot":"","sources":["../src/test-preload.ts"],"names":[],"mappings":""}

package/dist/test-preload.js

@@ -1,24 +0,0 @@
-import { mock } from "bun:test";
-mock.module("react-native", () => ({
-    Platform: { OS: "web" },
-    StyleSheet: { create: (s) => s },
-}));
-mock.module("expo-secure-store", () => ({
-    deleteItemAsync: async () => { },
-    getItemAsync: async () => null,
-    setItemAsync: async () => { },
-}));
-mock.module("@react-native-async-storage/async-storage", () => ({
-    default: {
-        getItem: async () => null,
-        removeItem: async () => { },
-        setItem: async () => { },
-    },
-}));
-mock.module("expo-constants", () => ({
-    default: { expoConfig: { extra: {} } },
-}));
-mock.module("expo-network", () => ({
-    getNetworkStateAsync: async () => ({ isConnected: true }),
-}));
-//# sourceMappingURL=test-preload.js.map

package/dist/test-preload.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"test-preload.js","sourceRoot":"","sources":["../src/test-preload.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,UAAU,CAAC;AAE9B,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC;IACjC,QAAQ,EAAE,EAAC,EAAE,EAAE,KAAK,EAAC;IACrB,UAAU,EAAE,EAAC,MAAM,EAAE,CAAC,CAAU,EAAE,EAAE,CAAC,CAAC,EAAC;CACxC,CAAC,CAAC,CAAC;AAEJ,IAAI,CAAC,MAAM,CAAC,mBAAmB,EAAE,GAAG,EAAE,CAAC,CAAC;IACtC,eAAe,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;IAC/B,YAAY,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;IAC9B,YAAY,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;CAC7B,CAAC,CAAC,CAAC;AAEJ,IAAI,CAAC,MAAM,CAAC,2CAA2C,EAAE,GAAG,EAAE,CAAC,CAAC;IAC9D,OAAO,EAAE;QACP,OAAO,EAAE,KAAK,IAAI,EAAE,CAAC,IAAI;QACzB,UAAU,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;QAC1B,OAAO,EAAE,KAAK,IAAI,EAAE,GAAE,CAAC;KACxB;CACF,CAAC,CAAC,CAAC;AAEJ,IAAI,CAAC,MAAM,CAAC,gBAAgB,EAAE,GAAG,EAAE,CAAC,CAAC;IACnC,OAAO,EAAE,EAAC,UAAU,EAAE,EAAC,KAAK,EAAE,EAAE,EAAC,EAAC;CACnC,CAAC,CAAC,CAAC;AAEJ,IAAI,CAAC,MAAM,CAAC,cAAc,EAAE,GAAG,EAAE,CAAC,CAAC;IACjC,oBAAoB,EAAE,KAAK,IAAI,EAAE,CAAC,CAAC,EAAC,WAAW,EAAE,IAAI,EAAC,CAAC;CACxD,CAAC,CAAC,CAAC"}

package/src/test-preload.ts

@@ -1,28 +0,0 @@
-import {mock} from "bun:test";
-
-mock.module("react-native", () => ({
-  Platform: {OS: "web"},
-  StyleSheet: {create: (s: unknown) => s},
-}));
-
-mock.module("expo-secure-store", () => ({
-  deleteItemAsync: async () => {},
-  getItemAsync: async () => null,
-  setItemAsync: async () => {},
-}));
-
-mock.module("@react-native-async-storage/async-storage", () => ({
-  default: {
-    getItem: async () => null,
-    removeItem: async () => {},
-    setItem: async () => {},
-  },
-}));
-
-mock.module("expo-constants", () => ({
-  default: {expoConfig: {extra: {}}},
-}));
-
-mock.module("expo-network", () => ({
-  getNetworkStateAsync: async () => ({isConnected: true}),
-}));