akanjs 2.2.4-rc.4 → 2.2.4

package/store/store.test.ts

@@ -0,0 +1,427 @@
+import { describe, expect, mock, test } from "bun:test";
+import { ACTION_META, DataList, Int, SLICE_META, STATE_DERIVED_META, STATE_INIT_META, STATE_META } from "akanjs/base";
+import { ConstantRegistry, via } from "akanjs/constant";
+import type { ClientSignal } from "akanjs/fetch";
+import type { SerializedSignal } from "akanjs/signal";
+import type { RootStoreCls } from "./rootStore";
+import { type StoreCls, store } from "./store";
+import { StoreInstance } from "./storeInstance";
+import { StoreRegistry } from "./storeRegistry";
+
+const StoreTestInput = via((f) => ({
+  title: f(String),
+  count: f(Int, { default: 0 }),
+  tags: f([String]),
+}));
+const StoreTestObject = via(StoreTestInput, (f) => ({
+  memo: f(String).optional(),
+}));
+const StoreTestLight = via(StoreTestObject, ["title"] as const, () => ({}));
+const StoreTestFull = via(StoreTestObject, StoreTestLight, () => ({}));
+const StoreTestInsight = via(StoreTestFull, (f) => ({
+  count: f(Int, { default: 0 }),
+}));
+const storeTestConstant = ConstantRegistry.buildModel(
+  "storeTestItem",
+  StoreTestInput,
+  StoreTestObject,
+  StoreTestFull,
+  StoreTestLight,
+  StoreTestInsight,
+  { StoreTestInput, StoreTestObject, StoreTestFull, StoreTestLight, StoreTestInsight },
+);
+const setupEnv = () => {
+  process.env.AKAN_PUBLIC_APP_NAME = "storetest";
+  process.env.AKAN_PUBLIC_REPO_NAME = "storetest";
+  process.env.AKAN_PUBLIC_SERVE_DOMAIN = "localhost";
+  process.env.AKAN_PUBLIC_ENV = "testing";
+};
+
+class MemoryStorage implements Storage {
+  #values = new Map<string, string>();
+  get length() {
+    return this.#values.size;
+  }
+  clear() {
+    this.#values.clear();
+  }
+  getItem(key: string) {
+    return this.#values.get(key) ?? null;
+  }
+  key(index: number) {
+    return [...this.#values.keys()][index] ?? null;
+  }
+  removeItem(key: string) {
+    this.#values.delete(key);
+  }
+  setItem(key: string, value: string) {
+    this.#values.set(key, value);
+  }
+}
+
+const installBrowser = (searchParams: Record<string, string | string[]> = {}) => {
+  const localStorage = new MemoryStorage();
+  const sessionStorage = new MemoryStorage();
+  const win = {
+    localStorage,
+    sessionStorage,
+    location: { pathname: "/store-test", protocol: "http:", hostname: "localhost", host: "localhost" },
+  };
+  Object.defineProperty(globalThis, "window", { value: win, configurable: true });
+  Object.defineProperty(globalThis, "localStorage", { value: localStorage, configurable: true });
+  Object.defineProperty(globalThis, "sessionStorage", { value: sessionStorage, configurable: true });
+  return { localStorage, sessionStorage, searchParams };
+};
+
+const uninstallBrowser = () => {
+  Reflect.deleteProperty(globalThis, "window");
+  Reflect.deleteProperty(globalThis, "localStorage");
+  Reflect.deleteProperty(globalThis, "sessionStorage");
+};
+
+const makeRoot = (refName: string, ...stores: (StoreCls | RootStoreCls)[]) => StoreRegistry.merge(refName, ...stores);
+
+const makeSignal = () => {
+  const calls: Record<string, ReturnType<typeof mock>> = {
+    createStoreTestItem: mock(
+      async (data: Record<string, unknown>) => new StoreTestFull({ id: "aaaaaaaaaaaaaaaaaaaaaaaa", ...data }),
+    ),
+    updateStoreTestItem: mock(async (id: string, data: Record<string, unknown>) => new StoreTestFull({ id, ...data })),
+    removeStoreTestItem: mock(
+      async (id: string) => new StoreTestFull({ id, title: "removed", removedAt: new Date() } as never),
+    ),
+    storeTestItem: mock(async (id: string) => new StoreTestFull({ id, title: "loaded" })),
+    storeTestItemList: mock(async () => [
+      new StoreTestLight({ id: "aaaaaaaaaaaaaaaaaaaaaaaa", title: "Ada" }),
+      new StoreTestLight({ id: "bbbbbbbbbbbbbbbbbbbbbbbb", title: "Ben" }),
+    ]),
+    storeTestItemInsight: mock(async () => new StoreTestInsight({ count: 2 })),
+    storeTestItemListByTitle: mock(async () => [
+      new StoreTestLight({ id: "aaaaaaaaaaaaaaaaaaaaaaaa", title: "Ada" }),
+      new StoreTestLight({ id: "bbbbbbbbbbbbbbbbbbbbbbbb", title: "Ben" }),
+    ]),
+    storeTestItemInsightByTitle: mock(async () => new StoreTestInsight({ count: 2 })),
+  };
+  const fetch = new Proxy(calls, {
+    get(target, key: string) {
+      target[key] ??= mock(async () => null);
+      return target[key];
+    },
+  });
+  const serializedSignal: SerializedSignal = {
+    prefix: "storeTestItem",
+    endpoint: {},
+    slice: {
+      "": { args: [{ type: "search", name: "query", refName: "String", nullable: true }] },
+      byTitle: { args: [{ type: "param", name: "title", refName: "String" }] },
+      byTags: { args: [{ type: "search", name: "tags", refName: "String", arrDepth: 1, nullable: true }] },
+    },
+  };
+  return {
+    refName: "storeTestItem",
+    _slice: { [SLICE_META]: {} },
+    cnst: storeTestConstant,
+    fetch,
+    serializedSignal,
+    slices: [],
+    calls,
+  } as unknown as ClientSignal<"storeTestItem"> & { calls: typeof calls };
+};
+
+describe("store factory", () => {
+  test("creates state metadata, initializer metadata, action metadata, and derived metadata", () => {
+    setupEnv();
+    class PreferenceStore extends store(
+      "preference" as const,
+      ({ persist, session }) => ({
+        count: persist(Int, { default: 1 }),
+        draft: session(String, { default: "hello" }),
+        flag: false,
+      }),
+      ({ computed, search }) => ({
+        countLabel: computed(["count"], (count) => `count:${count}`),
+        query: search("q", String, { default: "" }),
+      }),
+    ) {
+      increment() {
+        const { count } = this.get();
+        this.set({ count: count + 1 });
+      }
+    }
+    StoreRegistry.register(PreferenceStore);
+
+    expect(PreferenceStore.refName).toBe("preference");
+    expect(PreferenceStore[STATE_META]).toMatchObject({ count: 1, draft: "hello", flag: false, query: "" });
+    expect(PreferenceStore[STATE_INIT_META].count()).toBe(1);
+    expect(PreferenceStore[STATE_DERIVED_META].persistSession.count.kind).toBe("persist");
+    expect(PreferenceStore[STATE_DERIVED_META].persistSession.draft.kind).toBe("session");
+    expect(PreferenceStore[STATE_DERIVED_META].computed.countLabel.selector(3)).toBe("count:3");
+    expect(PreferenceStore[ACTION_META].increment).toBeInstanceOf(Function);
+  });
+
+  test("merges lib store state, actions, and derived metadata while rejecting duplicate derived keys", () => {
+    setupEnv();
+    class LibStore extends store(
+      "storeLib" as const,
+      () => ({ libCount: 1 }),
+      ({ computed }) => ({ libLabel: computed(["libCount"], (count) => `lib:${count}`) }),
+    ) {
+      setLibCount(value: number) {
+        this.set({ libCount: value });
+      }
+    }
+    StoreRegistry.register(LibStore);
+
+    class MainStore extends store("storeMain" as const, () => ({ mainCount: 2 }), LibStore) {}
+
+    expect(MainStore[STATE_META]).toMatchObject({ libCount: 1, mainCount: 2 });
+    expect(MainStore[STATE_DERIVED_META].computed.libLabel.selector(4)).toBe("lib:4");
+    expect(MainStore[ACTION_META].setLibCount).toBeInstanceOf(Function);
+
+    expect(() =>
+      store(
+        "storeDuplicate" as const,
+        () => ({ value: 1 }),
+        ({ computed }) => ({ libLabel: computed(["value"], (value) => value) }),
+        LibStore,
+      ),
+    ).toThrow("Derived state key conflicts with writable state: libLabel");
+  });
+
+  test("rejects the old non-factory state shape", () => {
+    setupEnv();
+
+    expect(() => store("legacy" as const, { count: 1 } as never)).toThrow(
+      "store() now requires a state factory: store(sig, ({ persist, session }) => ({ ... }))",
+    );
+  });
+});
+
+describe("StoreInstance runtime", () => {
+  test("supports get, set, immer updates, pick, subscriptions, selector subscriptions, and derived protection", async () => {
+    setupEnv();
+    class RuntimeStore extends store(
+      "runtime" as const,
+      () => ({
+        count: 1,
+        countCopy: 0,
+        nested: { value: "a" },
+      }),
+      ({ computed }) => ({
+        label: computed(["count"], (count) => `count:${count}`),
+      }),
+    ) {
+      copyCount() {
+        this.set({ countCopy: this.pick("count").count as number });
+      }
+    }
+    StoreRegistry.register(RuntimeStore);
+    const instance = new StoreInstance(makeRoot("runtimeRoot", RuntimeStore));
+    const rootEvents: [unknown, unknown][] = [];
+    const selectorEvents: [unknown, unknown][] = [];
+    const unsubscribeRoot = instance.sub((state, prev) => rootEvents.push([state.count, prev.count]));
+    const unsubscribeSelector = instance.sub(
+      (state) => state.count,
+      (count, prev) => selectorEvents.push([count, prev]),
+      {
+        fireImmediately: true,
+      },
+    );
+
+    expect(instance.get()).toMatchObject({ count: 1, label: "count:1" });
+    instance.set({ count: 2 });
+    instance.set((state) => {
+      (state.nested as { value: string }).value = "b";
+      state.count = 3;
+    });
+
+    expect(instance.get()).toMatchObject({ count: 3, nested: { value: "b" }, label: "count:3" });
+    await instance.do.copyCount();
+    expect(instance.get().countCopy).toBe(3);
+    expect(rootEvents.map(([count, prev]) => [count, prev])).toEqual([
+      [2, 1],
+      [3, 2],
+      [3, 3],
+    ]);
+    expect(selectorEvents).toEqual([
+      [1, 1],
+      [2, 1],
+      [3, 2],
+    ]);
+
+    unsubscribeRoot();
+    unsubscribeSelector();
+    instance.set({ count: 4 });
+    expect(rootEvents).toHaveLength(3);
+    expect(selectorEvents).toHaveLength(3);
+    expect(() => instance.set({ label: "manual" })).toThrow("Cannot set derived state directly: label");
+  });
+
+  test("hydrates and syncs persist/session storage and materializes search params only in browser", () => {
+    setupEnv();
+    const browser = installBrowser();
+    class BrowserStore extends store(
+      "browser" as const,
+      ({ persist, session }) => ({
+        count: persist(Int, { default: 1, key: "count" }),
+        draft: session(String, { default: "empty", key: "draft" }),
+        searchParams: {} as Record<string, string | string[]>,
+      }),
+      ({ search }) => ({
+        q: search("q", String, { default: "default" }),
+      }),
+    ) {}
+    const countKey = BrowserStore[STATE_DERIVED_META].persistSession.count.storageKey;
+    const draftKey = BrowserStore[STATE_DERIVED_META].persistSession.draft.storageKey;
+    browser.localStorage.setItem(countKey, JSON.stringify(5));
+    browser.sessionStorage.setItem(draftKey, JSON.stringify("saved"));
+
+    const instance = new StoreInstance(makeRoot("browserRoot", BrowserStore));
+    expect(instance.get()).toMatchObject({ count: 5, draft: "saved", q: "default" });
+    instance.set({ count: 6, draft: "next", searchParams: { q: "from-url" } });
+    expect(browser.localStorage.getItem(countKey)).toBe("6");
+    expect(browser.sessionStorage.getItem(draftKey)).toBe('"next"');
+    expect(instance.get().q).toBe("from-url");
+
+    uninstallBrowser();
+    const serverInstance = new StoreInstance(makeRoot("serverBrowserRoot", BrowserStore));
+    serverInstance.set({ searchParams: { q: "ignored" } });
+    expect(serverInstance.get().q).toBe("default");
+  });
+});
+
+describe("signal generated store contract", () => {
+  test("injects model and slice state, form setters, model actions, and slice actions", async () => {
+    setupEnv();
+    const signal = makeSignal();
+    class ItemStore extends store(signal, () => ({ customReady: true })) {}
+    StoreRegistry.register(ItemStore);
+    const instance = new StoreInstance(makeRoot("itemRoot", ItemStore));
+
+    expect(ItemStore[STATE_META]).toHaveProperty("storeTestItemForm");
+    expect(ItemStore[STATE_META]).toHaveProperty("storeTestItemListByTitle");
+    expect(ItemStore[ACTION_META]).toHaveProperty("newStoreTestItem");
+    expect(ItemStore[ACTION_META]).toHaveProperty("initStoreTestItemByTitle");
+    expect(instance.get().storeTestItemForm).toBeInstanceOf(StoreTestInput);
+    expect(instance.get().storeTestItemListByTitle).toBeInstanceOf(DataList);
+    expect(instance.get()).toMatchObject({
+      queryArgsOfStoreTestItem: [],
+      queryArgsOfStoreTestItemByTitle: [],
+      queryArgsOfStoreTestItemByTags: [],
+    });
+    expect(instance.slice.storeTestItemByTitle).toMatchObject({
+      sliceName: "storeTestItemByTitle",
+      refName: "storeTestItem",
+      argLength: 1,
+    });
+
+    await instance.do.newStoreTestItem({ title: "draft", tags: ["x"] }, { modal: "edit", setDefault: true });
+    expect(instance.get()).toMatchObject({ storeTestItem: null, storeTestItemModal: "edit" });
+    expect(instance.get().storeTestItemForm).toMatchObject({ title: "draft", tags: ["x"] });
+    await instance.do.setTitleOnStoreTestItem("patched");
+    expect(instance.get().storeTestItemForm).toMatchObject({ title: "patched" });
+    await instance.do.addTagsOnStoreTestItem("y");
+    expect(instance.get().storeTestItemForm).toMatchObject({ tags: ["x", "y"] });
+    await instance.do.subTagsOnStoreTestItem(0);
+    expect(instance.get().storeTestItemForm).toMatchObject({ tags: ["y"] });
+    await instance.do.writeOnStoreTestItem("memo", "note");
+    expect(instance.get().storeTestItemForm).toMatchObject({ memo: "note" });
+
+    await instance.do.createStoreTestItem({ title: "created", count: 0, tags: [] });
+    expect(signal.calls.createStoreTestItem).toHaveBeenCalled();
+    expect(instance.get().storeTestItem).toBeInstanceOf(StoreTestFull);
+    expect(instance.get().storeTestItemList).toBeInstanceOf(DataList);
+
+    await instance.do.updateStoreTestItem("aaaaaaaaaaaaaaaaaaaaaaaa", { title: "updated", count: 0, tags: [] });
+    expect(signal.calls.updateStoreTestItem).toHaveBeenCalled();
+    await instance.do.removeStoreTestItem("aaaaaaaaaaaaaaaaaaaaaaaa");
+    expect(signal.calls.removeStoreTestItem).toHaveBeenCalled();
+    await instance.do.resetStoreTestItem();
+    expect(instance.get()).toMatchObject({ storeTestItem: null, storeTestItemModal: null });
+
+    await instance.do.initStoreTestItemByTitle("Ada", { default: { title: "base" } });
+    expect(signal.calls.storeTestItemListByTitle).toHaveBeenCalledWith("Ada", 0, 20, "latest", expect.any(Object));
+    expect(instance.get()).toMatchObject({
+      queryArgsOfStoreTestItemByTitle: ["Ada"],
+      pageOfStoreTestItemByTitle: 1,
+      limitOfStoreTestItemByTitle: 20,
+      lastPageOfStoreTestItemByTitle: 1,
+    });
+    expect(instance.get().storeTestItemListByTitle).toBeInstanceOf(DataList);
+
+    await instance.do.selectStoreTestItemByTitle(new StoreTestLight({ id: "aaaaaaaaaaaaaaaaaaaaaaaa", title: "Ada" }));
+    expect(instance.get().storeTestItemSelectionByTitle).toBeInstanceOf(DataList);
+    await instance.do.setPageOfStoreTestItemByTitle(2);
+    await instance.do.addPageOfStoreTestItemByTitle(3);
+    await instance.do.setLimitOfStoreTestItemByTitle(10);
+    await instance.do.setQueryArgsOfStoreTestItemByTitle("Ben");
+    await instance.do.setQueryArgsOfStoreTestItemByTitle((prev: string) => [`${prev}!`]);
+    await instance.do.setSortOfStoreTestItemByTitle("titleAsc");
+    expect(instance.get()).toMatchObject({
+      pageOfStoreTestItemByTitle: 1,
+      limitOfStoreTestItemByTitle: 10,
+      queryArgsOfStoreTestItemByTitle: ["Ben!"],
+      sortOfStoreTestItemByTitle: "titleAsc",
+    });
+  });
+});
+
+describe("StoreRegistry and root assembly", () => {
+  test("registers prototype actions, merges roots, and builds a singleton with use/do/slice facades", async () => {
+    setupEnv();
+    class FirstStore extends store("firstStore" as const, () => ({ firstValue: 1 })) {
+      setFirstToTwo() {
+        this.set({ firstValue: 2 });
+      }
+    }
+    class SecondStore extends store("secondStore" as const, () => ({ secondValue: "a" })) {
+      setSecond(value: string) {
+        this.set({ secondValue: value });
+      }
+    }
+    StoreRegistry.register(FirstStore);
+    StoreRegistry.register(SecondStore);
+    const FirstRoot = StoreRegistry.merge("firstRoot" as const, FirstStore);
+    const Root = StoreRegistry.merge("combinedRoot" as const, FirstRoot, SecondStore);
+
+    expect(StoreRegistry.get("firstStore")).toBe(FirstStore);
+    expect(FirstStore[ACTION_META].setFirstToTwo).toBeInstanceOf(Function);
+    expect(Root[STATE_META]).toMatchObject({ firstValue: 1, secondValue: "a" });
+    expect(Root[ACTION_META]).toHaveProperty("setFirstToTwo");
+    expect(Root[ACTION_META]).toHaveProperty("setSecond");
+
+    const built = StoreRegistry.build(Root);
+    const same = StoreRegistry.build(Root);
+    expect(same).toBe(built);
+    await built.do.setFirstToTwo();
+    await built.do.setSecond("b");
+    expect(built.get()).toMatchObject({ firstValue: 2, secondValue: "b" });
+    await built.do.setFirstValue(3);
+    expect(built.get().firstValue).toBe(3);
+    expect(built.use).toHaveProperty("firstValue");
+  });
+
+  test("builds slice facades from root slice metadata", async () => {
+    setupEnv();
+    const signal = makeSignal();
+    class SliceStore extends store(signal, () => ({})) {}
+    StoreRegistry.register(SliceStore);
+    const instance = new StoreInstance(makeRoot("sliceRoot", SliceStore));
+    const slice = instance.slice.storeTestItemByTitle as {
+      do: Record<string, (...args: unknown[]) => Promise<void>>;
+      get: () => Record<string, unknown>;
+      use: Record<string, () => unknown>;
+    };
+
+    expect(slice.get()).toMatchObject({
+      pageOfStoreTestItem: 1,
+      limitOfStoreTestItem: 20,
+      sortOfStoreTestItem: "latest",
+    });
+    await slice.do.initStoreTestItem("Ada");
+    expect(signal.calls.storeTestItemListByTitle).toHaveBeenCalled();
+    await slice.do.setPageOfStoreTestItem(2);
+    expect(instance.get().pageOfStoreTestItemByTitle).toBe(2);
+    expect(slice.use).toHaveProperty("pageOfStoreTestItem");
+  });
+});

package/store/types.ts

@@ -16,7 +16,7 @@ type PickFunc<
   F extends keyof State = IsAny<State> extends true ? any : keyof State extends never ? any : keyof State,
 > = (...fields: F[]) => {
   [K in (typeof fields)[number]]: Exclude<State[K], null | undefined | "loading">;
-}; 
+}; // & { [K in keyof T as T[K] extends (...args: any) => any ? K : never]: T[K] };
 export interface SetGet<State = any> {
   set: (setState: Partial<State> | ((state: State) => void)) => void;
   get: () => State;

package/test/playwright.config.base.ts

@@ -1,7 +1,8 @@
-
-
+// import { workspaceRoot } from "@nx/devkit";
+// import { nxE2EPreset } from "@nx/playwright/preset";
 import { defineConfig, devices, type PlaywrightTestConfig } from "@playwright/test";
 
+// For CI, you may want to set BASE_URL to the deployed application.
 const baseURL = process.env.BASE_URL ?? "http://127.0.0.1:4200";
 const projectName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
 
@@ -9,23 +10,26 @@ const projectName = process.env.AKAN_PUBLIC_APP_NAME ?? "unknown";
  * Read environment variables from file.
  * https://github.com/motdotla/dotenv
  */
+// require('dotenv').config();
 
 /**
  * See https://playwright.dev/docs/test-configuration.
  */
 export const withBase = (filename: string, config: PlaywrightTestConfig = {}) =>
   defineConfig({
-
+    // ...nxE2EPreset(filename, { testDir: "./app" }),
+    /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
     use: {
       baseURL,
-      
+      /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
       trace: "on-first-retry",
     },
-    
+    /* Run your local dev server before starting the tests */
     webServer: {
       command: `akan serve ${projectName}`,
       url: "http://127.0.0.1:4200",
       reuseExistingServer: !process.env.CI,
+      // cwd: workspaceRoot,
     },
     projects: [
       {
@@ -43,6 +47,25 @@ export const withBase = (filename: string, config: PlaywrightTestConfig = {}) =>
         use: { ...devices["Desktop Safari"] },
       },
 
+      // Uncomment for mobile browsers support
+      /* {
+      name: 'Mobile Chrome',
+      use: { ...devices['Pixel 5'] },
+    },
+    {
+      name: 'Mobile Safari',
+      use: { ...devices['iPhone 12'] },
+    }, */
+
+      // Uncomment for branded browsers
+      /* {
+      name: 'Microsoft Edge',
+      use: { ...devices['Desktop Edge'], channel: 'msedge' },
+    },
+    {
+      name: 'Google Chrome',
+      use: { ...devices['Desktop Chrome'], channel: 'chrome' },
+    } */
     ],
     ...config,
   });

package/test/playwright.pageAgent.ts

@@ -13,7 +13,7 @@ export class PageAgent {
   async goto(path: string) {
     await Promise.all([this.page.goto(path), this.waitForPathChange(path)]);
     if (!this.#isInitialized) {
-      
+      // await this.page.waitForEvent("websocket");
       this.#isInitialized = true;
     }
   }

package/test/sampleOf.ts

@@ -60,7 +60,7 @@ export type SampleOf<Model> = DocumentModel<{
 export const sampleOf = <Model>(
   modelRef: ConstantCls<Model>,
 ): DocumentModel<{ [K in keyof Model as Model[K] extends BaseObject ? never : K]: NonNullable<Model[K]> }> => {
-  
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-return
   return Object.fromEntries(
     Object.entries(modelRef[FIELD_META]).map(([key, field]) => [
       key,

package/test/testServer.ts

@@ -149,7 +149,7 @@ export class TestServer {
   async terminate() {
     const now = Date.now();
     const elapsed = now - this.#startAt;
-    await sleep(50); 
+    await sleep(50); // cooldown
     await this.#server?.stop();
     this.#server = undefined;
     if (this.#tempDir) {

package/tsconfig.json

@@ -0,0 +1,5 @@
+{
+  "extends": "../../tsconfig.json",
+  "files": [],
+  "include": ["**/*.ts", "**/*.tsx"]
+}

package/ui/BottomSheet.tsx

@@ -27,7 +27,7 @@ export const BottomSheet = forwardRef<BottomSheetRef, BottomSheetProps>(
     const [{ y, opacity }, api] = useSpring(() => ({ y: window.innerHeight, opacity: 0 }));
 
     const openModal = async () => {
-      
+      //rubber band
       await Promise.all(api.start({ y: 0, opacity: 100, immediate: false, config: config.default }));
     };
     const closeModal = async () => {

package/ui/Clipboard.tsx

@@ -21,7 +21,7 @@ export const Clipboard = ({ text, className }: ClipboardProps): ReactElement =>
 
   const handleCopy = async () => {
     if (!text) return;
-    
+    // 예시로 "복사할 텍스트"를 복사합니다
     await navigator.clipboard.writeText(text);
     setIsCopied(true);
   };

package/ui/Constant/schemaDoc.test.ts

@@ -0,0 +1,113 @@
+import { describe, expect, test } from "bun:test";
+import { enumOf, FIELD_META, Int } from "akanjs/base";
+import { type ConstantCls, type ConstantField, ConstantRegistry, type FieldInfoObject, field } from "akanjs/constant";
+
+import { databaseModelVariants, getConstantSchemaDoc } from "./schemaDoc";
+
+const ConstantDocRole = enumOf("constantDocRole", ["admin", "user"] as const);
+ConstantRegistry.enum.set("constantDocRole", ConstantDocRole);
+
+const makeRef = (fields: FieldInfoObject | Record<string, ConstantField>): ConstantCls => {
+  class TestConstant {}
+  Object.assign(TestConstant, {
+    [FIELD_META]: Object.fromEntries(
+      Object.entries(fields).map(([key, fieldInfo]) => [key, "toField" in fieldInfo ? fieldInfo.toField() : fieldInfo]),
+    ),
+    children: new Set(),
+    relations: new Set(),
+    enums: new Set(),
+    text: { search: new Set(), filter: new Set(), children: { search: new Set(), filter: new Set() } },
+  });
+  return TestConstant as ConstantCls;
+};
+
+const ConstantDocAddress = makeRef({
+  city: field(String),
+  zip: field(Int, { default: 10000, min: 10000 }),
+});
+ConstantRegistry.buildScalar("constantDocAddress", ConstantDocAddress, { ConstantDocAddress });
+
+const ConstantDocUserInput = makeRef({
+  name: field(String, { minlength: 2 }),
+  role: field(String, { enum: ConstantDocRole } as never),
+  metadata: field(Map, { of: String }),
+  password: field.secret(String),
+});
+const ConstantDocUserObject = makeRef({
+  ...ConstantDocUserInput[FIELD_META],
+  organizationId: field(String, { ref: "organization", refType: "relation" }).toField(),
+});
+const LightConstantDocUser = makeRef({
+  name: field(String, { minlength: 2 }),
+  role: field(String, { enum: ConstantDocRole } as never),
+});
+const ConstantDocUser = makeRef({
+  ...ConstantDocUserObject[FIELD_META],
+  displayName: field(String, { text: "search" }).toField(),
+});
+const ConstantDocUserInsight = makeRef({
+  ...ConstantDocUser[FIELD_META],
+  total: field(Int, { default: 0, accumulate: {} }).toField(),
+});
+
+ConstantRegistry.buildModel(
+  "constantDocUser",
+  ConstantDocUserInput,
+  ConstantDocUserObject,
+  ConstantDocUser,
+  LightConstantDocUser,
+  ConstantDocUserInsight,
+  {
+    ConstantDocUserInput,
+    ConstantDocUserObject,
+    ConstantDocUser,
+    LightConstantDocUser,
+    ConstantDocUserInsight,
+    ConstantDocRole,
+  },
+);
+
+describe("constant schema docs", () => {
+  test("builds selected database, scalar, and enum schemas", () => {
+    const doc = getConstantSchemaDoc({
+      models: ["constantDocUser"],
+      scalars: ["constantDocAddress"],
+      enums: ["constantDocRole"],
+    });
+
+    expect(doc.databases.map((database) => database.refName)).toEqual(["constantDocUser"]);
+    expect(doc.scalars.map((scalar) => scalar.refName)).toEqual(["constantDocAddress"]);
+    expect(doc.enums.map((enumSchema) => enumSchema.refName)).toEqual(["constantDocRole"]);
+    expect(Object.keys(doc.databases[0].variants)).toEqual([...databaseModelVariants]);
+  });
+
+  test("normalizes field metadata for tables", () => {
+    const doc = getConstantSchemaDoc({ models: ["constantDocUser"], scalars: ["constantDocAddress"] });
+    const fullFields = doc.databases[0].variants.full.fields;
+    const role = fullFields.find((field) => field.key === "role");
+    const password = fullFields.find((field) => field.key === "password");
+    const metadata = fullFields.find((field) => field.key === "metadata");
+    const displayName = fullFields.find((field) => field.key === "displayName");
+
+    expect(role?.enumValues).toEqual(["admin", "user"]);
+    expect(password?.fieldType).toBe("hidden");
+    expect(password?.select).toBe(false);
+    expect(metadata?.typeLabel).toBe("Map<String, String>");
+    expect(displayName?.constraints).toContain("text:search");
+  });
+
+  test("collects enum usages and scalar fields", () => {
+    const doc = getConstantSchemaDoc({
+      models: ["constantDocUser"],
+      scalars: ["constantDocAddress"],
+      enums: ["constantDocRole"],
+    });
+    const roleEnum = doc.enums[0];
+    const zipField = doc.scalars[0].fields.find((field) => field.key === "zip");
+
+    expect(roleEnum.usedBy.some((usage) => usage.refName === "constantDocUser" && usage.fieldKey === "role")).toBe(
+      true,
+    );
+    expect(zipField?.constraints).toContain("min 10000");
+  });
+});