@fragno-dev/core 0.1.11 → 0.2.2

package/src/client/solid.ts

@@ -1,9 +1,14 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { atom, type ReadableAtom, type Store, type StoreValue } from "nanostores";
-import { useStore } from "@nanostores/solid";
 import type { Accessor } from "solid-js";
-import { createEffect } from "solid-js";
+import { createEffect, onCleanup } from "solid-js";
+
+import { useStore } from "@nanostores/solid";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type { NonGetHTTPMethod } from "../api/api";
+import type { MaybeExtractPathParamsOrWiden, QueryParamsHint } from "../api/internal/path";
+import { isReadableAtom } from "../util/nanostores";
+import type { InferOr } from "../util/types-util";
 import {
   isGetHook,
   isMutatorHook,
@@ -11,11 +16,10 @@ import {
   type FragnoClientHookData,
   type FragnoClientMutatorData,
   type FragnoStoreData,
+  type FragnoStoreFactoryData,
+  type FragnoStoreObjectData,
 } from "./client";
 import type { FragnoClientError } from "./client-error";
-import type { InferOr } from "../util/types-util";
-import type { MaybeExtractPathParamsOrWiden, QueryParamsHint } from "../api/internal/path";
-import { isReadableAtom } from "../util/nanostores";
 
 export type FragnoSolidHook<
   _TMethod extends "GET",
@@ -178,38 +182,72 @@ function createSolidMutator<
   };
 }
 
-export type FragnoSolidStore<T extends object> = T extends Store
+type FragnoSolidStoreValue<T extends object> = T extends Store
+  ? Accessor<StoreValue<T>>
+  : {
+      [K in keyof T]: T[K] extends Store ? Accessor<StoreValue<T[K]>> : T[K];
+    };
+
+type FragnoSolidStaticStore<T extends object> = T extends Store
   ? Accessor<StoreValue<T>>
   : () => {
       [K in keyof T]: T[K] extends Store ? Accessor<StoreValue<T[K]>> : T[K];
     };
 
-function createSolidStore<const T extends object>(
-  hook: FragnoStoreData<T>,
-): Accessor<StoreValue<T>> | (() => Accessor<StoreValue<T>>) {
-  // If the store object itself is a single atom, wrap it with useStore
-  if (isReadableAtom(hook.obj)) {
-    return useStore(hook.obj);
+export type FragnoSolidStore<TStore extends FragnoStoreData<object, unknown[]>> =
+  TStore extends FragnoStoreFactoryData<infer T, infer TArgs>
+    ? (...args: TArgs) => FragnoSolidStoreValue<T>
+    : TStore extends FragnoStoreObjectData<infer T>
+      ? FragnoSolidStaticStore<T>
+      : never;
+
+function unwrapSolidStoreValue<T extends object>(value: T): FragnoSolidStoreValue<T> {
+  if (isReadableAtom(value)) {
+    return useStore(value) as FragnoSolidStoreValue<T>;
   }
 
   // For objects containing atoms, wrap each atom property with useStore
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const result: any = {};
 
-  for (const key in hook.obj) {
-    if (!Object.prototype.hasOwnProperty.call(hook.obj, key)) {
+  for (const key in value) {
+    if (!Object.prototype.hasOwnProperty.call(value, key)) {
       continue;
     }
 
-    const value = hook.obj[key];
-    if (isReadableAtom(value)) {
-      result[key] = useStore(value);
+    const fieldValue = value[key];
+    if (isReadableAtom(fieldValue)) {
+      result[key] = useStore(fieldValue);
     } else {
-      result[key] = value;
+      result[key] = fieldValue;
     }
   }
 
-  return () => result;
+  return result as FragnoSolidStoreValue<T>;
+}
+
+function createSolidStore<const TStore extends FragnoStoreData<object, unknown[]>>(
+  hook: TStore,
+): FragnoSolidStore<TStore> {
+  if ("obj" in hook) {
+    if (isReadableAtom(hook.obj)) {
+      return useStore(hook.obj) as FragnoSolidStore<TStore>;
+    }
+
+    return (() => unwrapSolidStoreValue(hook.obj)) as FragnoSolidStore<TStore>;
+  }
+
+  return ((...args: Parameters<typeof hook.factory>) => {
+    const value = hook.factory(...args);
+    const disposer = (value as { [Symbol.dispose]?: (() => void) | undefined })[Symbol.dispose];
+    if (typeof disposer === "function") {
+      onCleanup(() => {
+        disposer.call(value);
+      });
+    }
+
+    return unwrapSolidStoreValue(value);
+  }) as FragnoSolidStore<TStore>;
 }
 
 export function useFragno<T extends Record<string, unknown>>(
@@ -232,8 +270,8 @@ export function useFragno<T extends Record<string, unknown>>(
           infer TQueryParameters
         >
       ? FragnoSolidMutator<TMethod, TPath, TInput, TOutput, TError, TQueryParameters>
-      : T[K] extends FragnoStoreData<infer TStoreObj>
-        ? FragnoSolidStore<TStoreObj>
+      : T[K] extends FragnoStoreData<object, unknown[]>
+        ? FragnoSolidStore<T[K]>
         : T[K];
 } {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/client/vanilla.test.ts

@@ -1,13 +1,15 @@
-import { test, expect, describe, vi, beforeEach, afterEach } from "vitest";
-import { atom } from "nanostores";
+import { test, expect, describe, vi, beforeEach, afterEach, expectTypeOf } from "vitest";
+
+import { atom, type ReadableAtom } from "nanostores";
 import { z } from "zod";
-import { createClientBuilder } from "./client";
-import { useFragno } from "./vanilla";
-import { defineRoute } from "../api/route";
+
 import { defineFragment } from "../api/fragment-definition-builder";
+import { defineRoute } from "../api/route";
+import { waitForAsyncIterator } from "../util/async";
+import { createClientBuilder } from "./client";
 import type { FragnoPublicClientConfig } from "./client";
 import { FragnoClientFetchNetworkError } from "./client-error";
-import { waitForAsyncIterator } from "../util/async";
+import { useFragno } from "./vanilla";
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -620,6 +622,56 @@ describe("createVanillaMutator", () => {
   });
 });
 
+describe("useFragno - createStore", () => {
+  const clientConfig: FragnoPublicClientConfig = {
+    baseUrl: "http://localhost:3000",
+  };
+
+  test("unwraps store wrappers to the raw store object", () => {
+    const stringAtom = atom("hello");
+    const numberAtom = atom(42);
+    const cb = createClientBuilder(defineFragment("test-fragment-store"), clientConfig, []);
+    const client = {
+      useStore: cb.createStore({
+        message: stringAtom,
+        count: numberAtom,
+        constant: 7,
+      }),
+    };
+
+    const { useStore } = useFragno(client);
+
+    expectTypeOf(useStore).toExtend<{
+      message: typeof stringAtom;
+      count: typeof numberAtom;
+      constant: number;
+    }>();
+
+    if (!("obj" in client.useStore)) {
+      throw new Error("Expected object-backed store");
+    }
+
+    expect(useStore).toBe(client.useStore.obj);
+    expect(useStore.message.get()).toBe("hello");
+    expect(useStore.count.get()).toBe(42);
+    expect(useStore.constant).toBe(7);
+  });
+
+  test("unwraps single-store wrappers to the underlying atom", () => {
+    const singleAtom = atom("single");
+    const cb = createClientBuilder(defineFragment("test-fragment-single-store"), clientConfig, []);
+    const client = {
+      useSingle: cb.createStore(singleAtom),
+    };
+
+    const { useSingle } = useFragno(client);
+
+    expectTypeOf(useSingle).toExtend<typeof singleAtom>();
+    expect(useSingle).toBe(singleAtom);
+    expect(useSingle.get()).toBe("single");
+  });
+});
+
 describe("useFragno", () => {
   const testFragmentDefinition = defineFragment("test-fragment-useFragno");
   const testRoutes = [
@@ -771,6 +823,96 @@ describe("useFragno", () => {
   });
 });
 
+describe("createVanillaStore", () => {
+  const clientConfig: FragnoPublicClientConfig = {
+    baseUrl: "http://localhost:3000",
+  };
+
+  test("should support createStore factory callbacks", () => {
+    const dispose = vi.fn();
+    const builder = createClientBuilder(defineFragment("test-fragment-store"), clientConfig, []);
+    const clientObj = {
+      useSession: builder.createStore(({ path }: { path: { sessionId: string } }) => ({
+        sessionId: atom(path.sessionId),
+        sendMessage: (text: string) => text,
+        [Symbol.dispose]: dispose,
+      })),
+    };
+
+    const { useSession } = useFragno(clientObj);
+    const session = useSession({ path: { sessionId: "abc" } });
+
+    expect(session.sessionId.get()).toBe("abc");
+    expect(session.sendMessage("hello")).toBe("hello");
+    expect(typeof session.destroy).toBe("function");
+
+    session.destroy?.();
+    expect(dispose).toHaveBeenCalledTimes(1);
+  });
+
+  test("should preserve prototype methods when adding destroy to factory store instances", () => {
+    const dispose = vi.fn();
+    const builder = createClientBuilder(
+      defineFragment("test-fragment-store-instance"),
+      clientConfig,
+      [],
+    );
+
+    class SessionStore {
+      sessionId: ReadableAtom<string>;
+
+      constructor(sessionId: string) {
+        this.sessionId = atom(sessionId);
+      }
+
+      sendMessage(text: string) {
+        return `${this.sessionId.get()}:${text}`;
+      }
+
+      [Symbol.dispose]() {
+        dispose();
+      }
+    }
+
+    const clientObj = {
+      useSession: builder.createStore(({ path }: { path: { sessionId: string } }) => {
+        return new SessionStore(path.sessionId);
+      }),
+    };
+
+    const { useSession } = useFragno(clientObj);
+    const session = useSession({ path: { sessionId: "abc" } });
+
+    expect(session).toBeInstanceOf(SessionStore);
+    expect(session.sendMessage("hello")).toBe("abc:hello");
+    expect(typeof session.destroy).toBe("function");
+    expect(Object.keys(session)).not.toContain("destroy");
+
+    session.destroy?.();
+    expect(dispose).toHaveBeenCalledTimes(1);
+  });
+
+  test("should type and return zero-argument factory stores as callable", () => {
+    const builder = createClientBuilder(
+      defineFragment("test-fragment-zero-arg-store"),
+      clientConfig,
+      [],
+    );
+    const countAtom = atom(0);
+    const clientObj = {
+      useCounter: builder.createStore(() => ({
+        count: countAtom,
+      })),
+    };
+
+    const { useCounter } = useFragno(clientObj);
+
+    expectTypeOf(useCounter).toExtend<() => { count: typeof countAtom }>();
+    expect(typeof useCounter).toBe("function");
+    expect(useCounter().count.get()).toBe(0);
+  });
+});
+
 describe("error handling", () => {
   const testFragmentDefinition = defineFragment("test-fragment-errors");
   const testRoutes = [

package/src/client/vanilla.ts

@@ -1,20 +1,26 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { ReadableAtom } from "nanostores";
+
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type { NonGetHTTPMethod } from "../api/api";
+import type {
+  ExtractPathParamsOrWiden,
+  HasPathParams,
+  MaybeExtractPathParamsOrWiden,
+} from "../api/internal/path";
+import { createAsyncIteratorFromCallback } from "../util/async";
+import type { InferOr } from "../util/types-util";
 import {
   isGetHook,
   isMutatorHook,
+  isStore,
   type FragnoClientMutatorData,
   type FragnoClientHookData,
+  type FragnoStoreData,
+  type FragnoStoreFactoryData,
+  type FragnoStoreObjectData,
 } from "./client";
 import type { FragnoClientError } from "./client-error";
-import { createAsyncIteratorFromCallback } from "../util/async";
-import type { InferOr } from "../util/types-util";
-import type {
-  ExtractPathParamsOrWiden,
-  HasPathParams,
-  MaybeExtractPathParamsOrWiden,
-} from "../api/internal/path";
 
 export type StoreData<
   TOutputSchema extends StandardSchemaV1 | undefined,
@@ -213,6 +219,48 @@ function createVanillaMutator<
   };
 }
 
+export type FragnoVanillaStore<T extends object, TArgs extends unknown[] = []> = TArgs extends []
+  ? T
+  : (...args: TArgs) => T & { destroy?: () => void };
+
+export type FragnoVanillaStoreFromData<TStore> = TStore extends {
+  factory: (...args: infer TArgs) => infer TObject extends object;
+}
+  ? (...args: TArgs) => TObject & { destroy?: () => void }
+  : TStore extends { obj: infer TObject extends object }
+    ? TObject
+    : never;
+
+const getStoreDisposer = (value: object): (() => void) | undefined => {
+  const disposer = (value as { [Symbol.dispose]?: (() => void) | undefined })[Symbol.dispose];
+  return typeof disposer === "function" ? disposer.bind(value) : undefined;
+};
+
+function createVanillaStore<const TStore extends FragnoStoreData<object, unknown[]>>(
+  hook: TStore,
+): FragnoVanillaStoreFromData<TStore> {
+  if ("obj" in hook) {
+    return hook.obj as FragnoVanillaStoreFromData<TStore>;
+  }
+
+  return ((...args: Parameters<typeof hook.factory>) => {
+    const value = hook.factory(...args);
+    const disposer = getStoreDisposer(value);
+    if (!disposer) {
+      return value as ReturnType<typeof hook.factory> & { destroy?: () => void };
+    }
+
+    Object.defineProperty(value, "destroy", {
+      value: disposer,
+      enumerable: false,
+      configurable: true,
+      writable: true,
+    });
+
+    return value as ReturnType<typeof hook.factory> & { destroy?: () => void };
+  }) as FragnoVanillaStoreFromData<TStore>;
+}
+
 export function useFragno<T extends Record<string, unknown>>(
   clientObj: T,
 ): {
@@ -240,7 +288,11 @@ export function useFragno<T extends Record<string, unknown>>(
           TErrorCode,
           TQueryParameters
         >
-      : T[K];
+      : T[K] extends FragnoStoreObjectData<infer TStoreObj>
+        ? TStoreObj
+        : T[K] extends FragnoStoreFactoryData<infer TStoreObj, infer TStoreArgs>
+          ? (...args: TStoreArgs) => TStoreObj & { destroy?: () => void }
+          : T[K];
 } {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const result = {} as any; // We need one any cast here due to TypeScript's limitations with mapped types
@@ -255,6 +307,8 @@ export function useFragno<T extends Record<string, unknown>>(
       result[key] = createVanillaListeners(hook);
     } else if (isMutatorHook(hook)) {
       result[key] = createVanillaMutator(hook);
+    } else if (isStore(hook)) {
+      result[key] = createVanillaStore(hook);
     } else {
       // Pass through non-hook values unchanged
       result[key] = hook;