@fragno-dev/core 0.2.0 → 0.2.2

package/src/client/client.ssr.test.ts

@@ -7,12 +7,14 @@
  */
 
 import { describe, expect, test } from "vitest";
-import { type FragnoPublicClientConfig } from "./client";
-import { createClientBuilder } from "./client";
-import { defineRoute } from "../api/route";
-import { defineFragment } from "../api/fragment-definition-builder";
+
 import { z } from "zod";
+
+import { defineFragment } from "../api/fragment-definition-builder";
+import { defineRoute } from "../api/route";
 import { createAsyncIteratorFromCallback, waitForAsyncIterator } from "../util/async";
+import { type FragnoPublicClientConfig } from "./client";
+import { createClientBuilder } from "./client";
 
 describe("server side rendering", () => {
   const testFragmentDefinition = defineFragment("test-fragment").build();

package/src/client/client.svelte.test.ts

@@ -1,16 +1,19 @@
 import { test, expect, describe, vi, beforeEach, afterEach, assert } from "vitest";
-import { type FragnoPublicClientConfig } from "./client";
-import { createClientBuilder } from "./client";
+
+import { atom, computed } from "nanostores";
+import { writable, readable, get, derived } from "svelte/store";
+import { z } from "zod";
+
 import { render } from "@testing-library/svelte";
-import { defineRoute } from "../api/route";
+
 import { defineFragment } from "../api/fragment-definition-builder";
-import { z } from "zod";
-import { readableToAtom, useFragno } from "./client.svelte";
-import { writable, readable, get, derived } from "svelte/store";
+import { RequestOutputContext } from "../api/request-output-context";
+import { defineRoute } from "../api/route";
+import { type FragnoPublicClientConfig } from "./client";
+import { createClientBuilder } from "./client";
 import { FragnoClientUnknownApiError } from "./client-error";
+import { readableToAtom, useFragno } from "./client.svelte";
 import TestComponent from "./component.test.svelte";
-import { atom, computed } from "nanostores";
-import { RequestOutputContext } from "../api/request-output-context";
 
 function renderHook(
   clientObj: Record<string, unknown>,
@@ -766,7 +769,13 @@ describe("useFragno", () => {
       expect((get(hook.data) as TestData | undefined)?.id).toBe(456);
     });
 
-    expect(fetch).toHaveBeenCalledTimes(2);
+    const requestedIds = vi
+      .mocked(global.fetch)
+      .mock.calls.map(([input]) => String(input).match(/\/users\/([^/]+)/)?.[1])
+      .filter((id): id is string => id !== undefined);
+
+    expect(requestedIds).toContain("123");
+    expect(requestedIds).toContain("456");
   });
 });
 

package/src/client/client.svelte.ts

@@ -1,6 +1,12 @@
-import type { StandardSchemaV1 } from "@standard-schema/spec";
 import { atom, type ReadableAtom } from "nanostores";
+import { onDestroy } from "svelte";
+import { writable, type Readable, get } from "svelte/store";
+
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
 import type { NonGetHTTPMethod } from "../api/api";
+import type { MaybeExtractPathParamsOrWiden, QueryParamsHint } from "../api/internal/path";
+import type { InferOr } from "../util/types-util";
 import {
   isGetHook,
   isMutatorHook,
@@ -8,13 +14,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 { writable, type Readable, get } from "svelte/store";
-import { onDestroy } from "svelte";
 
 export type FragnoSvelteHook<
   _TMethod extends "GET",
@@ -223,10 +226,30 @@ function createSvelteMutator<
   };
 }
 
-export function createSvelteStore<T extends object>(hook: FragnoStoreData<T>): T {
-  // Since nanostores already implement Svelte's store contract,
-  // we can return the store object directly for use with $ syntax
-  return hook.obj;
+export type FragnoSvelteStore<T extends object, TArgs extends unknown[] = []> = TArgs extends []
+  ? T
+  : (...args: TArgs) => T;
+
+export function createSvelteStore<T extends object, TArgs extends unknown[]>(
+  hook: FragnoStoreData<T, TArgs>,
+): FragnoSvelteStore<T, TArgs> {
+  if ("obj" in hook) {
+    // Since nanostores already implement Svelte's store contract,
+    // we can return the store object directly for use with $ syntax
+    return hook.obj as FragnoSvelteStore<T, TArgs>;
+  }
+
+  return ((...args: TArgs) => {
+    const value = hook.factory(...args);
+    const disposer = value[Symbol.dispose as keyof typeof value];
+    if (typeof disposer === "function") {
+      onDestroy(() => {
+        disposer.call(value);
+      });
+    }
+
+    return value;
+  }) as FragnoSvelteStore<T, TArgs>;
 }
 
 export function useFragno<T extends Record<string, unknown>>(
@@ -249,9 +272,11 @@ export function useFragno<T extends Record<string, unknown>>(
           infer TQueryParameters
         >
       ? FragnoSvelteMutator<M, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters>
-      : T[K] extends FragnoStoreData<infer TStoreObj>
-        ? TStoreObj
-        : T[K];
+      : T[K] extends FragnoStoreObjectData<infer TStoreObj>
+        ? FragnoSvelteStore<TStoreObj, []>
+        : T[K] extends FragnoStoreFactoryData<infer TStoreObj, infer TStoreArgs>
+          ? FragnoSvelteStore<TStoreObj, TStoreArgs>
+          : T[K];
 } {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const result = {} as any;

package/src/client/client.test.ts

@@ -1,14 +1,16 @@
 import { afterEach, assert, beforeEach, describe, expect, test, vi } from "vitest";
+
+import { atom, computed, effect } from "nanostores";
 import { z } from "zod";
+
+import { defineFragment } from "../api/fragment-definition-builder";
+import { RequestOutputContext } from "../api/request-output-context";
 import { defineRoute } from "../api/route";
-import { buildUrl, createClientBuilder, getCacheKey, isGetHook, isMutatorHook } from "./client";
-import { useFragno } from "./vanilla";
 import { createAsyncIteratorFromCallback, waitForAsyncIterator } from "../util/async";
+import { buildUrl, createClientBuilder, getCacheKey, isGetHook, isMutatorHook } from "./client";
 import type { FragnoPublicClientConfig } from "./client";
-import { atom, computed, effect } from "nanostores";
-import { defineFragment } from "../api/fragment-definition-builder";
-import { RequestOutputContext } from "../api/request-output-context";
 import { FragnoClientUnknownApiError } from "./client-error";
+import { useFragno } from "./vanilla";
 
 // Mock fetch globally
 global.fetch = vi.fn();
@@ -1325,6 +1327,32 @@ describe("createMutator", () => {
     expect(result).toBeUndefined();
   });
 
+  test("body is optional when inputSchema allows undefined", async () => {
+    const testFragment = defineFragment("test-fragment").build();
+    const testRoutes = [
+      defineRoute({
+        method: "POST",
+        path: "/sign-out",
+        inputSchema: z.object({ sessionId: z.string().optional() }).optional(),
+        outputSchema: z.object({ success: z.boolean() }),
+        handler: async (_ctx, { empty }) => empty(),
+      }),
+    ] as const;
+
+    vi.mocked(global.fetch).mockImplementation(async () => {
+      return new Response(null, { status: 204 });
+    });
+
+    const cb = createClientBuilder(testFragment, clientConfig, testRoutes);
+    const signOut = cb.createMutator("POST", "/sign-out");
+
+    const result = await signOut.mutateQuery({});
+    expect(result).toBeUndefined();
+
+    const storeResult = await signOut.mutatorStore.mutate({});
+    expect(storeResult).toBeUndefined();
+  });
+
   test("should send octet-stream body without wrapping", async () => {
     const testFragment = defineFragment("test-fragment").build();
     const testRoutes = [
@@ -2208,7 +2236,7 @@ describe("Custom Fetcher Configuration", () => {
     expect(defaultOptions).toBeUndefined();
   });
 
-  test("getFetcher returns default fetch and options", () => {
+  test("getFetcher returns a bound default fetch and options", async () => {
     const client = createClientBuilder(
       testFragment,
       {
@@ -2218,9 +2246,20 @@ describe("Custom Fetcher Configuration", () => {
       testRoutes,
     );
 
-    const { fetcher, defaultOptions } = client.getFetcher();
-    expect(fetcher).toBe(fetch);
-    expect(defaultOptions).toBeDefined();
-    expect(defaultOptions?.credentials).toBe("include");
+    const originalFetch = globalThis.fetch;
+    const fetchSpy = vi.fn<typeof fetch>().mockResolvedValue(new Response(null, { status: 204 }));
+    globalThis.fetch = fetchSpy;
+
+    try {
+      const { fetcher, defaultOptions } = client.getFetcher();
+      expect(fetcher).not.toBe(globalThis.fetch);
+      expect(defaultOptions).toBeDefined();
+      expect(defaultOptions?.credentials).toBe("include");
+
+      await fetcher("https://example.com");
+      expect(fetchSpy).toHaveBeenCalledWith("https://example.com");
+    } finally {
+      globalThis.fetch = originalFetch;
+    }
   });
 });