akanjs 2.2.4 → 2.2.6

package/client/client.router.test.ts

@@ -1,290 +0,0 @@
-import { afterEach, beforeAll, describe, expect, mock, test } from "bun:test";
-
-type Side = "server" | "client";
-
-const envState = {
-  side: "client" as Side,
-  operationMode: "local",
-  basePaths: "admin,console",
-};
-const requestState = {
-  request: undefined as Request | undefined,
-  headers: new Map<string, string>(),
-};
-const messages: unknown[] = [];
-const timeoutCallbacks: Array<() => void> = [];
-
-beforeAll(() => {
-  mock.module("akanjs/base", () => ({
-    getEnv: () => ({
-      side: envState.side,
-      renderMode: "csr",
-      appName: "test-app",
-      environment: "debug",
-      operationMode: envState.operationMode,
-    }),
-  }));
-  mock.module("akanjs/common", () => ({
-    Logger: { log: () => undefined, verbose: () => undefined },
-    parseAkanI18nEnv: () => ({ locales: ["en", "ko"], defaultLocale: "en" }),
-    parseBasePaths: (value?: string) => (value ? value.split(",").filter(Boolean) : []),
-    pathGet: (path: string, obj: Record<string, unknown>, separator = ".", fallback?: unknown) =>
-      path.split(separator).reduce<unknown>((acc, key) => {
-        if (!acc || typeof acc !== "object") return fallback;
-        return (acc as Record<string, unknown>)[key] ?? fallback;
-      }, obj),
-    getBasePathFromPathname: (
-      pathname: string,
-      opts: { basePaths: Set<string>; i18n: { locales: string[] }; headerBasePath?: string },
-    ) => {
-      if (opts.headerBasePath) return opts.headerBasePath;
-      const [, lang, base] = pathname.split("/");
-      return opts.i18n.locales.includes(lang ?? "") && base && opts.basePaths.has(base) ? base : null;
-    },
-  }));
-  mock.module("akanjs/fetch", () => ({
-    FetchClient: {
-      build: () => ({ fetch: { setJwt: () => undefined }, sig: {} }),
-    },
-    defaultAccount: { appName: "test-app", environment: "debug" },
-    requestStorage: {
-      getStore: () => requestState.request,
-    },
-    getRequest: () => requestState.request,
-    headers: () => requestState.headers,
-  }));
-});
-
-const installClientWindow = (pathname = "/en/admin/current", search = "", hash = "") => {
-  Object.defineProperty(globalThis, "window", {
-    value: {
-      location: { pathname, search, hash },
-      parent: { postMessage: (message: unknown) => messages.push(message) },
-    },
-    configurable: true,
-  });
-  Object.defineProperty(globalThis, "document", {
-    value: { referrer: "https://example.test/en/admin/previous" },
-    configurable: true,
-  });
-  Object.defineProperty(globalThis, "location", {
-    value: { pathname, search, hash },
-    configurable: true,
-  });
-};
-
-afterEach(() => {
-  envState.side = "client";
-  envState.operationMode = "local";
-  envState.basePaths = "admin,console";
-  process.env.AKAN_PUBLIC_BASE_PATHS = envState.basePaths;
-  requestState.request = undefined;
-  requestState.headers = new Map();
-  messages.length = 0;
-  timeoutCallbacks.length = 0;
-  globalThis.__AKAN_ROUTER__ = undefined;
-  Object.defineProperty(globalThis, "window", { value: undefined, configurable: true });
-  Object.defineProperty(globalThis, "document", { value: undefined, configurable: true });
-  Object.defineProperty(globalThis, "location", { value: undefined, configurable: true });
-});
-
-describe("router", () => {
-  test("normalizes paths with language, prefix, query, hash, root, and absolute hrefs", async () => {
-    const { getPathInfo } = await import("./router");
-
-    expect(getPathInfo("/en/admin/users?tab=a#bio", "en", "admin")).toEqual({
-      path: "/users",
-      pathname: "/en/admin/users",
-      search: "tab=a",
-      hash: "bio",
-      href: "/en/admin/users?tab=a#bio",
-    });
-    expect(getPathInfo("/en/admin", "en", "admin").path).toBe("/");
-    expect(getPathInfo("/users", "ko", "").href).toBe("/ko/users");
-    expect(getPathInfo("https://external.test/path", "en", "admin").pathname).toBe("https://external.test/path");
-  });
-
-  test("client router init wraps push, replace, back, refresh, and path helpers", async () => {
-    envState.side = "client";
-    installClientWindow();
-    const originalSetTimeout = globalThis.setTimeout;
-    const mockSetTimeout = ((handler: TimerHandler) => {
-      timeoutCallbacks.push(() => {
-        if (typeof handler === "function") handler();
-      });
-      return timeoutCallbacks.length as unknown as ReturnType<typeof setTimeout>;
-    }) as unknown as typeof setTimeout;
-    globalThis.setTimeout = mockSetTimeout;
-    const calls: unknown[] = [];
-    const { router } = await import("./router");
-
-    router.init({
-      type: "csr",
-      lang: "en",
-      prefix: "admin",
-      router: {
-        push: (href, options) => calls.push(["push", href, options]),
-        replace: (href, options) => calls.push(["replace", href, options]),
-        back: (options) => calls.push(["back", options]),
-        refresh: () => calls.push(["refresh"]),
-      },
-    });
-
-    router.push("/users", { scrollToTop: true });
-    router.replace("/settings");
-    expect(calls).toEqual([["push", "/en/admin/users", { scrollToTop: true }]]);
-    timeoutCallbacks.splice(0).forEach((callback) => {
-      callback();
-    });
-    expect(calls).toEqual([
-      ["push", "/en/admin/users", { scrollToTop: true }],
-      ["replace", "/en/admin/settings", undefined],
-    ]);
-    router.back({ scrollToTop: false });
-    router.refresh();
-    expect(calls.at(-2)).toEqual(["back", { scrollToTop: false }]);
-    expect(calls.at(-1)).toEqual(["refresh"]);
-    expect(messages[0]).toMatchObject({ type: "pathChange", path: "/users", pathname: "/en/admin/users" });
-    expect(router.getPath("/en/admin/current")).toBe("/current");
-    expect(router.getFullPath()).toBe("/en/admin/current");
-    expect(router.getPrefixedPath("/next")).toBe("/en/admin/next");
-
-    router.setLang("ko");
-    timeoutCallbacks.splice(0).forEach((callback) => {
-      callback();
-    });
-    expect(calls.at(-1)).toEqual(["replace", "/ko/admin/current", undefined]);
-    globalThis.setTimeout = originalSetTimeout;
-  });
-
-  test("csr navigation preserves csr runtime search params", async () => {
-    envState.side = "client";
-    installClientWindow("/en/admin/current", "?csr=true&akanMobileTarget=default&akanMobileBasePath=admin");
-    const originalSetTimeout = globalThis.setTimeout;
-    const mockSetTimeout = ((handler: TimerHandler) => {
-      timeoutCallbacks.push(() => {
-        if (typeof handler === "function") handler();
-      });
-      return timeoutCallbacks.length as unknown as ReturnType<typeof setTimeout>;
-    }) as unknown as typeof setTimeout;
-    globalThis.setTimeout = mockSetTimeout;
-    const calls: unknown[] = [];
-    const { router } = await import("./router");
-
-    router.init({
-      type: "csr",
-      lang: "en",
-      prefix: "admin",
-      router: {
-        push: (href, options) => calls.push(["push", href, options]),
-        replace: (href, options) => calls.push(["replace", href, options]),
-        back: (options) => calls.push(["back", options]),
-        refresh: () => calls.push(["refresh"]),
-      },
-    });
-
-    router.push("/users?tab=a#bio");
-    router.replace("/settings?csr=false");
-    timeoutCallbacks.splice(0).forEach((callback) => {
-      callback();
-    });
-
-    expect(calls).toEqual([
-      ["push", "/en/admin/users?tab=a&csr=true&akanMobileTarget=default&akanMobileBasePath=admin#bio", undefined],
-      ["replace", "/en/admin/settings?csr=false&akanMobileTarget=default&akanMobileBasePath=admin", undefined],
-    ]);
-    globalThis.setTimeout = originalSetTimeout;
-  });
-
-  test("ssr client navigation hides base path outside local mode", async () => {
-    envState.side = "client";
-    envState.operationMode = "main";
-    installClientWindow("/en/current");
-    const calls: unknown[] = [];
-    const { router } = await import("./router");
-
-    router.init({
-      type: "ssr",
-      side: "client",
-      lang: "en",
-      prefix: "admin",
-      router: {
-        push: (href, options) => calls.push(["push", href, options]),
-        replace: (href, options) => calls.push(["replace", href, options]),
-        back: (options) => calls.push(["back", options]),
-        refresh: () => calls.push(["refresh"]),
-      },
-    });
-
-    router.push("/", { scrollToTop: true });
-    router.replace("/users?tab=a#bio");
-
-    expect(calls).toEqual([
-      ["push", "/en", { scrollToTop: true }],
-      ["replace", "/en/users?tab=a#bio", undefined],
-    ]);
-    expect(messages[0]).toMatchObject({ type: "pathChange", path: "/", pathname: "/en/admin" });
-  });
-
-  test("ssr setLang preserves production public paths while switching locale", async () => {
-    envState.side = "client";
-    envState.operationMode = "main";
-    installClientWindow("/ko/docs/intro/fundamentals", "?from=nav", "#section");
-    const calls: unknown[] = [];
-    const { router } = await import("./router");
-
-    router.init({
-      type: "ssr",
-      side: "client",
-      lang: "en",
-      prefix: "akanjs",
-      router: {
-        push: (href, options) => calls.push(["push", href, options]),
-        replace: (href, options) => calls.push(["replace", href, options]),
-        back: (options) => calls.push(["back", options]),
-        refresh: () => calls.push(["refresh"]),
-      },
-    });
-
-    router.setLang("ko");
-
-    expect(calls).toEqual([["replace", "/ko/docs/intro/fundamentals?from=nav#section", undefined]]);
-    expect(messages[0]).toMatchObject({
-      type: "pathChange",
-      path: "/docs/intro/fundamentals",
-      pathname: "/ko/akanjs/docs/intro/fundamentals",
-      hash: "section",
-    });
-  });
-
-  test("throws initialized guard before init and server redirect/notFound errors", async () => {
-    envState.side = "client";
-    installClientWindow();
-    const { AkanNotFoundError, AkanRedirectError, router } = await import("./router");
-
-    envState.side = "server";
-    process.env.AKAN_PUBLIC_BASE_PATHS = "admin,console";
-    requestState.request = new Request("https://example.test/en/admin/current");
-    requestState.headers = new Map([
-      ["x-locale", "en"],
-      ["x-base-path", "admin"],
-    ]);
-    expect(() => router.redirect("/users?tab=a")).toThrow(AkanRedirectError);
-    try {
-      router.redirect("/users?tab=a");
-    } catch (error) {
-      expect(error).toBeInstanceOf(AkanRedirectError);
-      expect((error as Error & { location: string; method: string }).location).toBe("/en/admin/users?tab=a");
-      expect((error as Error & { method: string }).method).toBe("replace");
-    }
-    envState.operationMode = "main";
-    expect(() => router.redirect("/users?tab=a")).toThrow(AkanRedirectError);
-    try {
-      router.redirect("/users?tab=a");
-    } catch (error) {
-      expect(error).toBeInstanceOf(AkanRedirectError);
-      expect((error as Error & { location: string; method: string }).location).toBe("/en/users?tab=a");
-    }
-    expect(() => router.notFound()).toThrow(AkanNotFoundError);
-  });
-});

package/common/Logger.test.ts

@@ -1,45 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { Logger, type LoggerSinkEntry } from "./Logger";
-
-const resetLoggerLevels = () => {
-  Logger.setLevel("log");
-  Logger.setFileLevel("trace");
-};
-
-describe("Logger sinks", () => {
-  test("emits file sink entries independently from terminal log level", () => {
-    const entries: LoggerSinkEntry[] = [];
-    const removeSink = Logger.addSink((entry) => entries.push(entry));
-
-    try {
-      Logger.setLevel("error");
-      Logger.setFileLevel("trace");
-      Logger.trace("file only", "sink-test", "LoggerTest");
-
-      expect(entries.length).toBe(1);
-      expect(entries[0]?.level).toBe("trace");
-      expect(entries[0]?.plainMessage.includes("file only")).toBe(true);
-    } finally {
-      removeSink();
-      resetLoggerLevels();
-    }
-  });
-
-  test("filters sink entries with AKAN_LOG_FILE_LEVEL semantics", () => {
-    const entries: LoggerSinkEntry[] = [];
-    const removeSink = Logger.addSink((entry) => entries.push(entry));
-
-    try {
-      Logger.setLevel("error");
-      Logger.setFileLevel("warn");
-      Logger.info("skip file", "sink-test", "LoggerTest");
-      Logger.warn("keep file", "sink-test", "LoggerTest");
-
-      expect(entries.map((entry) => entry.level)).toEqual(["warn"]);
-      expect(entries[0]?.plainMessage.includes("keep file")).toBe(true);
-    } finally {
-      removeSink();
-      resetLoggerLevels();
-    }
-  });
-});

package/common/formatAndValidation.test.ts

@@ -1,61 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import {
-  capitalize,
-  formatNumber,
-  formatPhone,
-  isEmail,
-  isPhoneNumber,
-  isValidDate,
-  lowerlize,
-  mergeVersion,
-  splitVersion,
-} from ".";
-
-describe("format and validation helpers", () => {
-  test("capitalizes and lowerlizes only the first character", () => {
-    expect(capitalize("akan")).toBe("Akan");
-    expect(capitalize("aKan")).toBe("AKan");
-    expect(lowerlize("Akan")).toBe("akan");
-    expect(lowerlize("AKan")).toBe("aKan");
-  });
-
-  test("formats numbers while preserving decimal text", () => {
-    expect(formatNumber("1234567")).toBe("1,234,567");
-    expect(formatNumber("1,234,567.89")).toBe("1,234,567.89");
-    expect(formatNumber("12abc34")).toBe("1,234");
-  });
-
-  test("formats supported phone number lengths", () => {
-    expect(formatPhone("0101234567")).toBe("010-123-4567");
-    expect(formatPhone("010-1234-5678")).toBe("010-1234-5678");
-    expect(formatPhone("0212345678")).toBe("021-234-5678");
-    expect(formatPhone("12345")).toBe("12345");
-    expect(formatPhone("")).toBe("");
-  });
-
-  test("validates email and phone strings", () => {
-    expect(isEmail("user@example.com")).toBe(true);
-    expect(isEmail("user.name@example.co.kr")).toBe(true);
-    expect(isEmail("not-an-email")).toBe(false);
-    expect(isEmail(null)).toBe(false);
-
-    expect(isPhoneNumber("010-1234-5678")).toBe(true);
-    expect(isPhoneNumber("031-123-4567")).toBe(true);
-    expect(isPhoneNumber("01012345678")).toBe(false);
-    expect(isPhoneNumber(undefined)).toBe(false);
-  });
-
-  test("validates dates from strings and Date instances", () => {
-    expect(isValidDate("2025-01-01")).toBe(true);
-    expect(isValidDate("not-a-date")).toBe(false);
-    expect(isValidDate(new Date("2025-01-01T00:00:00.000Z"))).toBe(true);
-    expect(isValidDate(new Date("not-a-date"))).toBe(false);
-  });
-
-  test("splits and merges semantic version parts", () => {
-    expect(splitVersion("1.2.3")).toEqual({ major: "1", minor: "2", patch: "3" });
-    expect(mergeVersion(1, 2, 3)).toBe("1.2.3");
-    expect(() => splitVersion("1.2")).toThrow("Invalid version");
-  });
-});

package/common/httpClient.test.ts

@@ -1,91 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import { HttpClient } from ".";
-
-type FetchCall = {
-  url: string | URL | Request;
-  init?: RequestInit;
-};
-
-const withMockFetch = async <T>(
-  handler: (url: string | URL | Request, init?: RequestInit) => Response | Promise<Response>,
-  run: () => Promise<T>,
-) => {
-  const previousFetch = globalThis.fetch;
-  const calls: FetchCall[] = [];
-
-  globalThis.fetch = (async (url: string | URL | Request, init?: RequestInit) => {
-    calls.push({ url, init });
-    return await handler(url, init);
-  }) as typeof fetch;
-
-  try {
-    return { result: await run(), calls };
-  } finally {
-    globalThis.fetch = previousFetch;
-  }
-};
-
-describe("HttpClient", () => {
-  test("builds base URLs, merges headers, and parses JSON responses", async () => {
-    const client = new HttpClient({
-      baseUrl: "https://api.example.com/",
-      headers: { Authorization: "Bearer token" },
-    });
-
-    const { result, calls } = await withMockFetch(
-      async () =>
-        Response.json({
-          ok: true,
-        }),
-      () => client.post<{ ok: boolean }>("/users", { name: "Akan" }, { headers: { "X-Request-Id": "req-1" } }),
-    );
-
-    expect(result).toEqual({ ok: true });
-    expect(calls).toHaveLength(1);
-    expect(calls[0]?.url).toBe("https://api.example.com/users");
-    expect(calls[0]?.init?.method).toBe("POST");
-    expect(calls[0]?.init?.body).toBe(JSON.stringify({ name: "Akan" }));
-    expect(new Headers(calls[0]?.init?.headers).get("authorization")).toBe("Bearer token");
-    expect(new Headers(calls[0]?.init?.headers).get("x-request-id")).toBe("req-1");
-    expect(new Headers(calls[0]?.init?.headers).get("content-type")).toBe("application/json");
-  });
-
-  test("returns text, undefined for 204, and throws response body on failures", async () => {
-    const textClient = new HttpClient("https://api.example.com");
-    const textResult = await withMockFetch(
-      async () => new Response("plain text", { headers: { "content-type": "text/plain" } }),
-      () => textClient.get<string>("health"),
-    );
-
-    expect(textResult.result).toBe("plain text");
-    expect(textResult.calls[0]?.url).toBe("https://api.example.com/health");
-
-    const emptyResult = await withMockFetch(
-      async () => new Response(null, { status: 204 }),
-      () => textClient.delete<undefined>("/users/1"),
-    );
-    expect(emptyResult.result).toBeUndefined();
-
-    await expect(
-      withMockFetch(
-        async () => new Response("failed", { status: 500 }),
-        () => textClient.get("/broken"),
-      ),
-    ).rejects.toThrow("failed");
-  });
-
-  test("passes through body types that should not be JSON encoded", async () => {
-    const client = new HttpClient();
-    const params = new URLSearchParams({ q: "akan" });
-
-    const { calls } = await withMockFetch(
-      async () => Response.json({ ok: true }),
-      () => client.put("/search", params),
-    );
-
-    expect(calls[0]?.url).toBe("/search");
-    expect(calls[0]?.init?.body).toBe(params);
-    expect(new Headers(calls[0]?.init?.headers).get("content-type")).toBeNull();
-  });
-});

package/common/objectPath.test.ts

@@ -1,108 +0,0 @@
-import { describe, expect, test } from "bun:test";
-
-import dayjs from "dayjs";
-
-import { applyMixins, deepObjectify, getAllPropertyDescriptors, isQueryEqual, objectify, pathGet, pathSet } from ".";
-
-class ParentFixture {
-  get parentValue() {
-    return "parent";
-  }
-
-  parentMethod() {
-    return "parent method";
-  }
-}
-
-class ChildFixture extends ParentFixture {
-  childMethod() {
-    return "child method";
-  }
-}
-
-class TargetFixture {}
-
-describe("object and path helpers", () => {
-  test("gets nested values with fallback support", () => {
-    const obj = { user: { profile: { name: "Akan" }, tags: ["core"] } };
-
-    expect(pathGet("user.profile.name", obj)).toBe("Akan");
-    expect(pathGet(["user", "tags", 0], obj)).toBe("core");
-    expect(pathGet("user.profile.age", obj, ".", "unknown")).toBe("unknown");
-    expect(pathGet("user.profile.name", null, ".", "unknown")).toBe("unknown");
-  });
-
-  test("sets nested object and array paths in place", () => {
-    const obj: Record<string, unknown> = {};
-
-    expect(pathSet(obj, "user.profile.name", "Akan")).toBe(obj);
-    expect(obj).toEqual({ user: { profile: { name: "Akan" } } });
-
-    pathSet(obj, ["items", 0, "id"], "first");
-    expect(obj).toEqual({
-      user: { profile: { name: "Akan" } },
-      items: [{ id: "first" }],
-    });
-  });
-
-  test("objectifies own data fields and skips functions", () => {
-    const source = {
-      id: "1",
-      name: "Akan",
-      greet() {
-        return "hello";
-      },
-    };
-
-    expect(objectify(source)).toEqual({ id: "1", name: "Akan" });
-    expect(objectify(source, ["name"])).toEqual({ name: "Akan" });
-  });
-
-  test("deep objectifies arrays, dates, dayjs values, and model-like values", () => {
-    const date = new Date("2025-01-01T00:00:00.000Z");
-    const modelLike = { __ModelType__: "User", id: "u1" };
-    const source = {
-      date,
-      day: dayjs(date),
-      nested: [{ id: "a", run: () => "skip" }],
-      modelLike,
-    };
-
-    expect(deepObjectify(source)).toEqual({
-      date,
-      day: dayjs(date),
-      nested: [{ id: "a" }],
-      modelLike,
-    });
-    expect(deepObjectify(source, { serializable: true, convertDate: "string" })).toEqual({
-      date: "2025-01-01T00:00:00.000Z",
-      day: "2025-01-01T00:00:00.000Z",
-      nested: [{ id: "a" }],
-      modelLike: { __ModelType__: "User", id: "u1" },
-    });
-    expect(deepObjectify(date, { convertDate: "number" })).toBe(date.getTime());
-  });
-
-  test("compares query values deeply including dates", () => {
-    expect(isQueryEqual({ a: 1, b: ["x", "y"] }, { a: 1, b: ["x", "y"] })).toBe(true);
-    expect(isQueryEqual({ a: 1 }, { a: 2 })).toBe(false);
-    expect(isQueryEqual([dayjs("2025-01-01")], [new Date("2025-01-01T00:00:00.000Z")])).toBe(true);
-    expect(isQueryEqual(null, null)).toBe(true);
-    expect(isQueryEqual(null, {})).toBe(false);
-  });
-
-  test("collects inherited descriptors and applies mixins", () => {
-    const descriptors = getAllPropertyDescriptors(ChildFixture);
-
-    expect(descriptors.childMethod).toBeDefined();
-    expect(descriptors.parentMethod).toBeDefined();
-    expect(descriptors.parentValue?.get).toBeDefined();
-
-    applyMixins(TargetFixture, [ChildFixture], new Set(["parentMethod"]));
-    const mixed = new TargetFixture() as TargetFixture & ChildFixture;
-
-    expect(mixed.childMethod()).toBe("child method");
-    expect((mixed as TargetFixture & ParentFixture).parentValue).toBe("parent");
-    expect("parentMethod" in mixed).toBe(false);
-  });
-});