@terreno/rtk 0.10.0 → 0.11.1

package/src/constants.test.ts

@@ -1,189 +1,228 @@
 import {afterEach, beforeEach, describe, expect, it, mock} from "bun:test";
 
-type ConstantsModule = typeof import("./constants");
-
-type ExpoConstantsMock = {
-  experienceUrl?: string;
-  expoConfig?: {
-    extra?: Record<string, string>;
-    hostUri?: string;
-  };
-  expoGoConfig?: {
-    debuggerHost?: string;
-  };
-};
-
-const loadConstantsModule = async ({
-  apiUrl,
-  constantsMock,
-  isDev = false,
-}: {
-  apiUrl?: string;
-  constantsMock: ExpoConstantsMock;
-  isDev?: boolean;
-}): Promise<ConstantsModule> => {
-  const hasApiUrl = "EXPO_PUBLIC_API_URL" in process.env;
-  const previousApiUrl = process.env.EXPO_PUBLIC_API_URL;
-  const previousDev = (globalThis as {__DEV__?: boolean}).__DEV__;
-
-  if (apiUrl) {
-    process.env.EXPO_PUBLIC_API_URL = apiUrl;
-  } else {
-    delete process.env.EXPO_PUBLIC_API_URL;
-  }
-
-  (globalThis as {__DEV__?: boolean}).__DEV__ = isDev;
-
-  mock.module("expo-constants", () => ({
-    default: constantsMock,
-  }));
-
-  const testCaseId = `${Date.now()}-${Math.random()}`;
-  const module = (await import(`./constants?testCase=${testCaseId}`)) as ConstantsModule;
-
-  if (hasApiUrl) {
-    process.env.EXPO_PUBLIC_API_URL = previousApiUrl;
-  } else {
-    delete process.env.EXPO_PUBLIC_API_URL;
-  }
-
-  if (typeof previousDev === "undefined") {
-    delete (globalThis as {__DEV__?: boolean}).__DEV__;
-  } else {
-    (globalThis as {__DEV__?: boolean}).__DEV__ = previousDev;
-  }
-
-  return module;
-};
-
-describe("constants", () => {
-  const originalDebug = console.debug;
-  const originalError = console.error;
-
-  beforeEach(() => {
-    console.debug = mock(() => {});
-    console.error = mock(() => {});
+import {
+  AUTH_DEBUG,
+  baseTasksUrl,
+  baseUrl,
+  baseWebsocketsUrl,
+  logAuth,
+  logSocket,
+  resolveBaseUrls,
+} from "./constants";
+
+describe("resolveBaseUrls", () => {
+  it("treats an empty envApiUrl as unset and falls back to localhost", () => {
+    const urls = resolveBaseUrls({
+      envApiUrl: "",
+      expoConstants: {expoConfig: {extra: {}}},
+      isDev: false,
+    });
+    expect(urls.baseUrl).toBe("http://localhost:4000");
+    expect(urls.baseWebsocketsUrl).toBe("ws://localhost:4000/");
+    expect(urls.baseTasksUrl).toBe("http://localhost:4000/tasks");
   });
 
-  afterEach(() => {
-    console.debug = originalDebug;
-    console.error = originalError;
-  });
-
-  it("uses EXPO_PUBLIC_API_URL override and enables debug logs", async () => {
-    const constants = await loadConstantsModule({
-      apiUrl: "https://api.example.com",
-      constantsMock: {
-        expoConfig: {
-          extra: {
-            APP_ENV: "production",
-            AUTH_DEBUG: "true",
-            WEBSOCKETS_DEBUG: "true",
-          },
-        },
-      },
+  it("treats an empty BASE_URL extra as unset and falls back to localhost in non-dev", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {expoConfig: {extra: {BASE_URL: ""}}},
       isDev: false,
     });
+    expect(urls.baseUrl).toBe("http://localhost:4000");
+  });
 
-    expect(constants.baseUrl).toBe("https://api.example.com");
-    expect(constants.baseWebsocketsUrl).toBe("https://ws.example.com/");
-    expect(constants.baseTasksUrl).toBe("https://tasks.example.com/tasks");
-    expect(constants.AUTH_DEBUG).toBe(true);
-
-    constants.logAuth("auth message");
-    constants.logSocket(undefined, "socket message");
-
-    expect(console.debug).toHaveBeenCalledWith("auth message");
-    expect(console.debug).toHaveBeenCalledWith("[websocket]", "socket message");
+  it("uses env override when provided", () => {
+    const urls = resolveBaseUrls({
+      envApiUrl: "https://api.example.com",
+      expoConstants: {expoConfig: {extra: {}}},
+      isDev: false,
+    });
+    expect(urls.baseUrl).toBe("https://api.example.com");
+    expect(urls.baseWebsocketsUrl).toBe("https://ws.example.com/");
+    expect(urls.baseTasksUrl).toBe("https://tasks.example.com/tasks");
   });
 
-  it("resolves dev hostUri URLs when __DEV__ is true", async () => {
-    const constants = await loadConstantsModule({
-      constantsMock: {
-        expoConfig: {
-          extra: {},
-          hostUri: "10.0.0.12:8081",
-        },
-      },
+  it("uses hostUri in dev mode", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {expoConfig: {extra: {}, hostUri: "10.0.0.12:8081"}},
       isDev: true,
     });
-
-    expect(constants.baseUrl).toBe("http://10.0.0.12:4000");
-    expect(constants.baseWebsocketsUrl).toBe("ws://10.0.0.12:4000/");
-    expect(constants.baseTasksUrl).toBe("http://10.0.0.12:4000/tasks");
+    expect(urls.baseUrl).toBe("http://10.0.0.12:4000");
+    expect(urls.baseWebsocketsUrl).toBe("ws://10.0.0.12:4000/");
+    expect(urls.baseTasksUrl).toBe("http://10.0.0.12:4000/tasks");
   });
 
-  it("resolves dev experienceUrl URLs when hostUri is unavailable", async () => {
-    const constants = await loadConstantsModule({
-      constantsMock: {
+  it("falls back to experienceUrl in dev mode when hostUri missing", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {
         experienceUrl: "exp://192.168.1.20:19000",
-        expoConfig: {
-          extra: {},
-        },
+        expoConfig: {extra: {}},
       },
       isDev: true,
     });
+    expect(urls.baseUrl).toBe("http://192.168.1.20:4000");
+    expect(urls.baseWebsocketsUrl).toBe("ws://192.168.1.20:4000/");
+    expect(urls.baseTasksUrl).toBe("http://192.168.1.20:4000/tasks");
+  });
 
-    expect(constants.baseUrl).toBe("http://192.168.1.20:4000");
-    expect(constants.baseWebsocketsUrl).toBe("ws://192.168.1.20:4000/");
-    expect(constants.baseTasksUrl).toBe("http://192.168.1.20:4000/tasks");
+  it("falls back to localhost in dev mode when nothing else is available", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {expoConfig: {extra: {}}},
+      isDev: true,
+    });
+    expect(urls.baseUrl).toBe("http://localhost:4000");
+    expect(urls.baseWebsocketsUrl).toBe("ws://localhost:4000/");
+    expect(urls.baseTasksUrl).toBe("http://localhost:4000/tasks");
   });
 
-  it("uses BASE_URL outside dev mode and allows user websocket debug flag", async () => {
-    const constants = await loadConstantsModule({
-      constantsMock: {
-        expoConfig: {
-          extra: {
-            BASE_URL: "https://api.prod.com",
-            WEBSOCKETS_DEBUG: "false",
-          },
-        },
-      },
+  it("uses BASE_URL from extra when not in dev mode", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {expoConfig: {extra: {BASE_URL: "https://api.prod.com"}}},
       isDev: false,
     });
+    expect(urls.baseUrl).toBe("https://api.prod.com");
+    expect(urls.baseWebsocketsUrl).toBe("https://ws.prod.com/");
+    expect(urls.baseTasksUrl).toBe("https://tasks.prod.com/tasks");
+  });
 
-    expect(constants.baseUrl).toBe("https://api.prod.com");
-    expect(constants.baseWebsocketsUrl).toBe("https://ws.prod.com/");
-    expect(constants.baseTasksUrl).toBe("https://tasks.prod.com/tasks");
-
-    constants.logSocket({featureFlags: {debugWebsockets: {enabled: true}}}, "enabled");
-    expect(console.debug).toHaveBeenCalledWith("[websocket]", "enabled");
+  it("falls back to hostUri when BASE_URL absent in non-dev", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {expoConfig: {extra: {}, hostUri: "172.16.0.3:8081"}},
+      isDev: false,
+    });
+    expect(urls.baseUrl).toBe("http://172.16.0.3:4000");
+    expect(urls.baseWebsocketsUrl).toBe("ws://172.16.0.3:4000/");
+    expect(urls.baseTasksUrl).toBe("http://172.16.0.3:4000/tasks");
   });
 
-  it("falls back to non-dev hostUri when BASE_URL is missing", async () => {
-    const constants = await loadConstantsModule({
-      constantsMock: {
-        expoConfig: {
-          extra: {},
-          hostUri: "172.16.0.3:8081",
-        },
+  it("falls back to experienceUrl in non-dev when hostUri absent", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {
+        experienceUrl: "exp://10.1.2.3:19000",
+        expoConfig: {extra: {}},
       },
       isDev: false,
     });
-
-    expect(constants.baseUrl).toBe("http://172.16.0.3:4000");
-    expect(constants.baseWebsocketsUrl).toBe("ws://172.16.0.3:4000/");
-    expect(constants.baseTasksUrl).toBe("http://172.16.0.3:4000/tasks");
+    expect(urls.baseUrl).toBe("http://10.1.2.3:4000");
   });
 
-  it("warns for exp.direct tunnels and falls back to localhost", async () => {
-    const constants = await loadConstantsModule({
-      constantsMock: {
-        expoConfig: {
-          extra: {},
-        },
-        expoGoConfig: {
-          debuggerHost: "abc.exp.direct:80",
-        },
-      },
+  it("defaults to localhost in non-dev when nothing is configured", () => {
+    const urls = resolveBaseUrls({
+      expoConstants: {expoConfig: {extra: {}}},
       isDev: false,
     });
+    expect(urls.baseUrl).toBe("http://localhost:4000");
+  });
+});
+
+describe("module-level exports", () => {
+  it("exports baseUrl / websockets / tasks URLs that resolve to localhost with default mocks", () => {
+    expect(baseUrl).toBe("http://localhost:4000");
+    expect(baseWebsocketsUrl).toBe("ws://localhost:4000/");
+    expect(baseTasksUrl).toBe("http://localhost:4000/tasks");
+  });
+
+  it("AUTH_DEBUG is false by default with test-preload mocks", () => {
+    expect(AUTH_DEBUG).toBe(false);
+  });
+});
+
+describe("logAuth / logSocket", () => {
+  const originalDebug = console.debug;
+  const calls: unknown[][] = [];
+
+  beforeEach(() => {
+    calls.length = 0;
+    console.debug = (...args: unknown[]): void => {
+      calls.push(args);
+    };
+  });
+
+  afterEach(() => {
+    console.debug = originalDebug;
+  });
+
+  it("logAuth is a no-op when AUTH_DEBUG is disabled", () => {
+    logAuth("auth message");
+    expect(calls).toEqual([]);
+  });
+
+  it("logSocket logs when passed boolean true", () => {
+    logSocket(true, "socket message");
+    expect(calls).toEqual([["[websocket]", "socket message"]]);
+  });
+
+  it("logSocket does not log when passed boolean false", () => {
+    logSocket(false, "suppressed");
+    expect(calls).toEqual([]);
+  });
+
+  it("logSocket logs when user has debugWebsockets feature flag enabled", () => {
+    logSocket({featureFlags: {debugWebsockets: {enabled: true}}}, "enabled");
+    expect(calls).toEqual([["[websocket]", "enabled"]]);
+  });
+
+  it("logSocket does not log when user has debugWebsockets disabled", () => {
+    logSocket({featureFlags: {debugWebsockets: {enabled: false}}}, "disabled");
+    expect(calls).toEqual([]);
+  });
+
+  it("logSocket does not log with undefined user", () => {
+    logSocket(undefined, "no user");
+    expect(calls).toEqual([]);
+  });
+});
+
+describe("expo tunnel warning", () => {
+  it("warns when expoGoConfig.debuggerHost contains exp.direct", async () => {
+    const errorCalls: unknown[][] = [];
+    const originalError = console.error;
+    console.error = (...args: unknown[]): void => {
+      errorCalls.push(args);
+    };
+    mock.module("expo-constants", () => ({
+      default: {
+        expoConfig: {extra: {}},
+        expoGoConfig: {debuggerHost: "abc.exp.direct"},
+      },
+    }));
+    try {
+      const testId = `${Date.now()}-${Math.random()}`;
+      await import(`./constants?case=${testId}`);
+      const warning = errorCalls.find((args) =>
+        args.some((v) => typeof v === "string" && v.includes("Expo Tunnel is not currently"))
+      );
+      expect(warning).toBeDefined();
+    } finally {
+      console.error = originalError;
+      mock.module("expo-constants", () => ({default: {expoConfig: {extra: {}}}}));
+    }
+  });
+});
 
-    expect(console.error).toHaveBeenCalledWith(
-      "Expo Tunnel is not currently supported for connecting to the API, please use LAN or Local mode."
-    );
-    expect(constants.baseUrl).toBe("http://localhost:4000");
-    expect(constants.baseWebsocketsUrl).toBe("ws://localhost:4000/");
-    expect(constants.baseTasksUrl).toBe("http://localhost:4000/tasks");
+describe("AUTH_DEBUG enabled path", () => {
+  it("logs debug messages from logAuth when AUTH_DEBUG is true on module load", async () => {
+    const debugCalls: unknown[][] = [];
+    const originalDebug = console.debug;
+    console.debug = (...args: unknown[]): void => {
+      debugCalls.push(args);
+    };
+    mock.module("expo-constants", () => ({
+      default: {expoConfig: {extra: {AUTH_DEBUG: "true", WEBSOCKETS_DEBUG: "true"}}},
+    }));
+    try {
+      const testId = `${Date.now()}-${Math.random()}`;
+      const loaded = (await import(`./constants?case=${testId}`)) as typeof import("./constants");
+      expect(loaded.AUTH_DEBUG).toBe(true);
+      const preLength = debugCalls.length;
+      loaded.logAuth("hello");
+      expect(debugCalls.length).toBe(preLength + 1);
+      loaded.logSocket(undefined, "ws on");
+      expect(debugCalls.some((args) => args[0] === "[websocket]" && args[1] === "ws on")).toBe(
+        true
+      );
+    } finally {
+      console.debug = originalDebug;
+      mock.module("expo-constants", () => ({default: {expoConfig: {extra: {}}}}));
+    }
   });
 });

package/src/constants.ts

@@ -37,6 +37,65 @@ export const logSocket = (
   }
 };
 
+export interface ExpoConstantsShape {
+  experienceUrl?: string;
+  expoConfig?: {
+    extra?: Record<string, string | undefined>;
+    hostUri?: string;
+  };
+  expoGoConfig?: {
+    debuggerHost?: string;
+  };
+}
+
+export interface BaseUrls {
+  baseUrl: string;
+  baseWebsocketsUrl: string;
+  baseTasksUrl: string;
+}
+
+const LOCALHOST: BaseUrls = {
+  baseTasksUrl: "http://localhost:4000/tasks",
+  baseUrl: "http://localhost:4000",
+  baseWebsocketsUrl: "ws://localhost:4000/",
+};
+
+/**
+ * Pure resolver for the base URLs used throughout the RTK package.
+ * Decoupled from the Expo-constants module so it can be unit tested.
+ */
+export const resolveBaseUrls = (args: {
+  envApiUrl?: string;
+  expoConstants: ExpoConstantsShape;
+  isDev: boolean;
+}): BaseUrls => {
+  const hostUriPrefix = args.expoConstants.expoConfig?.hostUri?.split(":").shift();
+  const experiencePrefix = args.expoConstants.experienceUrl?.split(":")[1];
+  const baseFromExtra = args.expoConstants.expoConfig?.extra?.BASE_URL;
+  const base = args.envApiUrl || (!args.isDev ? baseFromExtra : undefined);
+  const host = args.isDev ? hostUriPrefix : !base ? hostUriPrefix : undefined;
+  const experience = !base && !host ? experiencePrefix : undefined;
+  if (base)
+    return {
+      baseTasksUrl: `${base.replace("api.", "tasks.")}/tasks`,
+      baseUrl: base,
+      baseWebsocketsUrl: `${base.replace("api.", "ws.")}/`,
+    };
+  if (host)
+    return {
+      baseTasksUrl: `http://${host}:4000/tasks`,
+      baseUrl: `http://${host}:4000`,
+      baseWebsocketsUrl: `ws://${host}:4000/`,
+    };
+  if (experience)
+    return {
+      baseTasksUrl: `http:${experience}:4000/tasks`,
+      baseUrl: `http:${experience}:4000`,
+      baseWebsocketsUrl: `ws:${experience}:4000/`,
+    };
+  return LOCALHOST;
+};
+
 // When we use "expo publish", we want to point the API at the prod API. In the future,
 // we'll want to point at the staging API, and probably have a development release channel.
 if (Constants.expoGoConfig?.debuggerHost?.includes("exp.direct")) {
@@ -45,77 +104,20 @@ if (Constants.expoGoConfig?.debuggerHost?.includes("exp.direct")) {
   );
 }
 
-export let baseUrl: string;
-export let baseWebsocketsUrl: string;
-export let baseTasksUrl: string;
-
 const isDev = typeof __DEV__ !== "undefined" && __DEV__;
 
-if (process.env.EXPO_PUBLIC_API_URL) {
-  // Explicit override (e.g. .env)
-  baseUrl = process.env.EXPO_PUBLIC_API_URL;
-  baseWebsocketsUrl = `${baseUrl.replace("api.", "ws.")}/`;
-  baseTasksUrl = `${baseUrl.replace("api.", "tasks.")}/tasks`;
+const resolved = resolveBaseUrls({
+  envApiUrl: process.env.EXPO_PUBLIC_API_URL,
+  expoConstants: Constants as ExpoConstantsShape,
+  isDev,
+});
 
-  console.debug(
-    `Base URL set to apiUrl ${baseUrl} for env ${
-      Constants.expoConfig?.extra?.APP_ENV ?? "unknown"
-    }, websocket to ${baseWebsocketsUrl}, tasks to ${baseTasksUrl}`
-  );
-} else if (isDev && Constants.expoConfig?.hostUri) {
-  // Dev simulator/device
-  baseUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}`;
-  baseWebsocketsUrl = `ws://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/`;
-  baseTasksUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/tasks`;
-  console.debug(
-    `Base URL set to hostUri ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
-    Constants.expoConfig?.hostUri
-  );
-} else if (isDev && Constants.experienceUrl) {
-  // Dev web (experienceUrl)
-  baseUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}`;
-  baseWebsocketsUrl = `ws:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/`;
-  baseTasksUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/tasks`;
-  console.debug(
-    `Base URL set to experienceUrl ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
-    Constants.expoConfig?.hostUri
-  );
-} else if (isDev) {
-  // Dev web fallback
-  baseUrl = `http://localhost:4000`;
-  baseWebsocketsUrl = `ws://localhost:4000/`;
-  baseTasksUrl = `http://localhost:4000/tasks`;
-  console.debug(`Base URL set to localhost ${baseUrl}, websocket to ${baseWebsocketsUrl}`);
-} else if (Constants.expoConfig?.extra?.BASE_URL) {
-  // Prod/staging
-  baseUrl = Constants.expoConfig?.extra?.BASE_URL;
-  baseWebsocketsUrl = `${baseUrl.replace("api.", "ws.")}/`;
-  baseTasksUrl = `${baseUrl.replace("api.", "tasks.")}/tasks`;
+export const baseUrl = resolved.baseUrl;
+export const baseWebsocketsUrl = resolved.baseWebsocketsUrl;
+export const baseTasksUrl = resolved.baseTasksUrl;
 
-  console.debug(
-    `Base URL set to apiUrl ${baseUrl} for env ${
-      Constants.expoConfig?.extra?.APP_ENV ?? "unknown"
-    }, websocket to ${baseWebsocketsUrl}, tasks to ${baseTasksUrl}`
-  );
-} else if (Constants.expoConfig?.hostUri) {
-  baseUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}`;
-  baseWebsocketsUrl = `ws://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/`;
-  baseTasksUrl = `http://${Constants.expoConfig?.hostUri?.split(`:`).shift()?.concat(":4000")}/tasks`;
-  console.debug(
-    `Base URL set to hostUri ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
-    Constants.expoConfig?.hostUri
-  );
-} else if (Constants.experienceUrl) {
-  baseUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}`;
-  baseWebsocketsUrl = `ws:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/`;
-  baseTasksUrl = `http:${Constants.experienceUrl?.split(`:`)[1]?.concat(":4000")}/tasks`;
-  console.debug(
-    `Base URL set to experienceUrl ${baseUrl}, websocket to ${baseWebsocketsUrl}`,
-    Constants.expoConfig?.hostUri
-  );
-} else {
-  baseUrl = `http://localhost:4000`;
-  baseWebsocketsUrl = `ws://localhost:4000/`;
-  baseTasksUrl = `http://localhost:4000/tasks`;
-  console.debug(`Base URL set to localhost ${baseUrl}, websocket to ${baseWebsocketsUrl}`);
-}
+console.debug(
+  `Base URL set to ${baseUrl} for env ${
+    Constants.expoConfig?.extra?.APP_ENV ?? "unknown"
+  }, websocket to ${baseWebsocketsUrl}, tasks to ${baseTasksUrl}`
+);