testAuthStoresAndErrors.js

import { AsyncAuthStore, LocalAuthStore, ClientResponseError } from "bosbase";

const sleep = (ms = 0) => new Promise((resolve) => setTimeout(resolve, ms));

async function waitForPersist(persisted, count, timeoutMs = 500) {
  const start = Date.now();
  while (persisted.length < count) {
    if (Date.now() - start > timeoutMs) {
      throw new Error(
        `Timed out waiting for ${count} persisted operations (have ${persisted.length})`,
      );
    }
    await sleep(10);
  }
  await sleep(0); // allow the queue microtask to finish
}

async function testAsyncAuthStoreQueueAndInitial() {
  console.log("[INFO] Testing AsyncAuthStore initial load and queue ordering...");

  const persisted = [];
  let clearedCount = 0;

  const store = new AsyncAuthStore({
    save: async (payload) => {
      persisted.push(payload);
    },
    clear: async () => {
      clearedCount += 1;
      persisted.push("CLEARED");
    },
    initial: Promise.resolve(
      JSON.stringify({
        token: "init-token",
        record: { id: "init", collectionName: "users" },
      }),
    ),
  });

  await waitForPersist(persisted, 1);

  if (store.token !== "init-token" || store.record?.id !== "init") {
    throw new Error("AsyncAuthStore did not hydrate the initial payload");
  }

  const parsedInitial = JSON.parse(persisted[0]);
  if (parsedInitial.token !== "init-token" || parsedInitial.record?.id !== "init") {
    throw new Error("Initial payload was not persisted through the save queue");
  }

  store.save("next-token", { id: "next", collectionName: "_superusers" });
  store.save("final-token");

  await waitForPersist(persisted, 3);

  if (!persisted[1].includes("next-token") || !persisted[2].includes("final-token")) {
    throw new Error("AsyncAuthStore save queue did not preserve call order");
  }

  store.clear();
  await waitForPersist(persisted, 4);

  if (clearedCount !== 1 || persisted[3] !== "CLEARED") {
    throw new Error("AsyncAuthStore clear did not call the provided clear function");
  }
  if (store.token !== "" || store.record !== null) {
    throw new Error("AsyncAuthStore clear did not reset the in-memory state");
  }

  console.log(
    "[SUCCESS] AsyncAuthStore initial data, queueing, and custom clear behavior verified",
  );
}

async function testLocalAuthStoreFallbackAndStorageEvents() {
  console.log("[INFO] Testing LocalAuthStore fallback storage and storage events...");

  const originalWindow = global.window;

  try {
    delete global.window;

    const fallbackStore = new LocalAuthStore("local_auth_fallback_test");
    fallbackStore.save("local-token", { id: "loc-1", collectionName: "users" });

    if (fallbackStore.token !== "local-token" || fallbackStore.record?.id !== "loc-1") {
      throw new Error("LocalAuthStore fallback storage did not retain saved state");
    }

    fallbackStore.clear();
    if (fallbackStore.token !== "" || fallbackStore.record !== null) {
      throw new Error("LocalAuthStore clear did not reset fallback storage");
    }

    const mockStorage = {};
    const listeners = {};

    global.window = {
      localStorage: {
        getItem: (key) => (key in mockStorage ? mockStorage[key] : null),
        setItem: (key, value) => {
          mockStorage[key] = String(value);
        },
        removeItem: (key) => {
          delete mockStorage[key];
        },
      },
      addEventListener: (type, cb) => {
        listeners[type] = cb;
      },
      dispatchEvent: (event) => {
        listeners[event.type]?.(event);
      },
    };

    const windowStore = new LocalAuthStore("local_auth_window_test");
    windowStore.save("tab-token", { id: "tab-1", collectionName: "users" });

    if (!mockStorage["local_auth_window_test"]) {
      throw new Error("LocalAuthStore did not persist data to localStorage");
    }

    mockStorage["local_auth_window_test"] = JSON.stringify({
      token: "event-token",
      record: { id: "tab-2", collectionName: "_superusers" },
    });
    window.dispatchEvent({ type: "storage", key: "local_auth_window_test" });

    if (windowStore.token !== "event-token" || windowStore.record?.id !== "tab-2") {
      throw new Error("LocalAuthStore did not react to storage event updates");
    }

    console.log(
      "[SUCCESS] LocalAuthStore fallback behavior and cross-tab sync via storage events verified",
    );
  } finally {
    if (typeof originalWindow === "undefined") {
      delete global.window;
    } else {
      global.window = originalWindow;
    }
  }
}

function testClientResponseErrorNormalization() {
  console.log("[INFO] Testing ClientResponseError normalization and fallbacks...");

  const structured = new ClientResponseError({
    status: 422,
    url: "/demo",
    response: { message: "Invalid payload", data: { field: "name" } },
  });

  if (
    structured.status !== 422 ||
    structured.url !== "/demo" ||
    structured.message !== "Invalid payload" ||
    structured.data !== structured.response ||
    structured.data?.data?.field !== "name"
  ) {
    throw new Error("ClientResponseError did not preserve structured response details");
  }

  const abortInput =
    typeof DOMException !== "undefined"
      ? new DOMException("Aborted", "AbortError")
      : { isAbort: true };
  const aborted = new ClientResponseError(abortInput);

  if (!aborted.isAbort || !String(aborted.message).includes("autocancelled")) {
    throw new Error("ClientResponseError did not normalize aborted requests");
  }
  if (aborted.originalError !== abortInput && aborted.cause !== abortInput) {
    throw new Error("ClientResponseError did not keep the original abort error");
  }

  const upstreamCause = new Error("service offline");
  const wrapped = new ClientResponseError({
    status: 503,
    originalError: upstreamCause,
    data: { foo: "bar" },
  });

  if (wrapped.cause !== upstreamCause || wrapped.message !== "Something went wrong.") {
    throw new Error("ClientResponseError did not wrap arbitrary upstream errors correctly");
  }

  console.log("[SUCCESS] ClientResponseError message and cause handling verified");
}

async function main() {
  try {
    await testAsyncAuthStoreQueueAndInitial();
    await testLocalAuthStoreFallbackAndStorageEvents();
    testClientResponseErrorNormalization();
    console.log("\n========== Auth store and error helper tests completed ==========");
  } catch (error) {
    console.error("[ERROR] Auth store / error helper test failed:");
    console.error(error?.stack || error);
    process.exit(1);
  }
}

main();