@fragno-dev/core 0.1.1 → 0.1.3

package/src/api/request-output-context.ts

@@ -19,7 +19,9 @@ function mergeHeaders(...headerSources: (HeadersInit | undefined)[]): HeadersIni
   const mergedHeaders = new Headers();
 
   for (const headerSource of headerSources) {
-    if (!headerSource) continue;
+    if (!headerSource) {
+      continue;
+    }
 
     if (headerSource instanceof Headers) {
       for (const [key, value] of headerSource.entries()) {
@@ -45,11 +47,11 @@ export abstract class OutputContext<const TOutput, const TErrorCode extends stri
    *
    * Shortcut for `throw new FragnoApiError(...)`
    */
-  error(
+  error = (
     { message, code }: { message: string; code: TErrorCode },
     initOrStatus?: ResponseInit | StatusCode,
     headers?: HeadersInit,
-  ): Response {
+  ): Response => {
     if (typeof initOrStatus === "undefined") {
       return Response.json({ message: message, code }, { status: 500, headers });
     }
@@ -63,12 +65,12 @@ export abstract class OutputContext<const TOutput, const TErrorCode extends stri
       { message: message, code },
       { status: initOrStatus.status, headers: mergedHeaders },
     );
-  }
+  };
 
-  empty(
+  empty = (
     initOrStatus?: ResponseInit<ContentlessStatusCode> | ContentlessStatusCode,
     headers?: HeadersInit,
-  ): Response {
+  ): Response => {
     const defaultHeaders = {};
 
     if (typeof initOrStatus === "undefined") {
@@ -92,9 +94,13 @@ export abstract class OutputContext<const TOutput, const TErrorCode extends stri
       status: initOrStatus.status,
       headers: mergedHeaders,
     });
-  }
+  };
 
-  json(object: TOutput, initOrStatus?: ResponseInit | StatusCode, headers?: HeadersInit): Response {
+  json = (
+    object: TOutput,
+    initOrStatus?: ResponseInit | StatusCode,
+    headers?: HeadersInit,
+  ): Response => {
     if (typeof initOrStatus === "undefined") {
       return Response.json(object, {
         status: 200,
@@ -114,7 +120,7 @@ export abstract class OutputContext<const TOutput, const TErrorCode extends stri
       status: initOrStatus.status,
       headers: mergedHeaders,
     });
-  }
+  };
 
   jsonStream = (
     cb: (stream: ResponseStream<TOutput>) => void | Promise<void>,

package/src/client/component.test.svelte

@@ -2,7 +2,9 @@
   import type { Readable } from "svelte/store";
   import { useFragno } from "./client.svelte";
 
+  // oxlint-disable-next-line no-unassigned-vars
   export let clientObj: Record<string, unknown>;
+  // oxlint-disable-next-line no-unassigned-vars
   export let hookName: string;
   export let args: Record<string, unknown> = {};
 

package/src/client/internal/ndjson-streaming.ts

@@ -191,7 +191,9 @@ async function continueStreaming<TOutputSchema extends StandardSchemaV1, TErrorC
         if (buffer.trim()) {
           const lines = buffer.split("\n");
           for (const line of lines) {
-            if (!line.trim()) continue;
+            if (!line.trim()) {
+              continue;
+            }
 
             try {
               const jsonObject = JSON.parse(line) as StandardSchemaV1.InferOutput<TOutputSchema>;
@@ -215,7 +217,9 @@ async function continueStreaming<TOutputSchema extends StandardSchemaV1, TErrorC
       buffer = lines.pop() || ""; // Keep incomplete line in buffer
 
       for (const line of lines) {
-        if (!line.trim()) continue;
+        if (!line.trim()) {
+          continue;
+        }
 
         try {
           const jsonObject = JSON.parse(line) as StandardSchemaV1.InferOutput<TOutputSchema>;

package/src/client/react.ts

@@ -210,7 +210,9 @@ export function useStore<SomeStore extends Store>(
 
   const subscribe = useCallback((onChange: () => void) => {
     const emitChange = (value: StoreValue<SomeStore>) => {
-      if (snapshotRef.current === value) return;
+      if (snapshotRef.current === value) {
+        return;
+      }
       snapshotRef.current = value;
       onChange();
     };

package/src/test/test.test.ts

@@ -0,0 +1,449 @@
+import { describe, it, expect } from "vitest";
+import { createFragmentForTest } from "./test";
+import { defineFragment } from "../api/fragment-builder";
+import { defineRoute } from "../api/route";
+import { z } from "zod";
+
+describe("createFragmentForTest", () => {
+  it("should create a test fragment with config only", () => {
+    const fragment = defineFragment<{ apiKey: string }>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    expect(testFragment.config).toEqual({ apiKey: "test-key" });
+    expect(testFragment.deps).toEqual({});
+    expect(testFragment.services).toEqual({});
+  });
+
+  it("should create deps from fragment definition", () => {
+    const fragment = defineFragment<{ apiKey: string }>("test").withDependencies(({ config }) => ({
+      client: { apiKey: config.apiKey },
+    }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    expect(testFragment.deps).toEqual({ client: { apiKey: "test-key" } });
+  });
+
+  it("should override deps when provided", () => {
+    const fragment = defineFragment<{ apiKey: string }>("test").withDependencies(({ config }) => ({
+      client: { apiKey: config.apiKey },
+    }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+      deps: { client: { apiKey: "override-key" } },
+    });
+
+    expect(testFragment.deps).toEqual({ client: { apiKey: "override-key" } });
+  });
+
+  it("should create services from fragment definition", () => {
+    const fragment = defineFragment<{ apiKey: string }>("test")
+      .withDependencies(({ config }) => ({
+        client: { apiKey: config.apiKey },
+      }))
+      .withServices(({ deps }) => ({
+        getApiKey: () => deps.client.apiKey,
+      }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    expect(testFragment.services.getApiKey()).toBe("test-key");
+  });
+
+  it("should override services when provided", () => {
+    const fragment = defineFragment<{ apiKey: string }>("test")
+      .withDependencies(({ config }) => ({
+        client: { apiKey: config.apiKey },
+      }))
+      .withServices(({ deps }) => ({
+        getApiKey: () => deps.client.apiKey,
+      }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+      services: { getApiKey: () => "override-key" },
+    });
+
+    expect(testFragment.services.getApiKey()).toBe("override-key");
+  });
+
+  it("should initialize routes with fragment context", () => {
+    const fragment = defineFragment<{ multiplier: number }>("test")
+      .withDependencies(() => ({ dep: "value" }))
+      .withServices(({ config }) => ({
+        multiply: (x: number) => x * config.multiplier,
+      }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { multiplier: 2 },
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/test",
+      outputSchema: z.object({ result: z.number() }),
+      handler: async (_ctx, { json }) => {
+        return json({ result: 42 });
+      },
+    });
+
+    const routes = [route] as const;
+    const [initializedRoute] = testFragment.initRoutes(routes);
+
+    expect(initializedRoute).toBe(route);
+    expect(initializedRoute.method).toBe("GET");
+    expect(initializedRoute.path).toBe("/test");
+  });
+
+  it("should initialize route factories with fragment context", async () => {
+    const fragment = defineFragment<{ multiplier: number }>("test")
+      .withDependencies(() => ({ dep: "value" }))
+      .withServices(({ config }) => ({
+        multiply: (x: number) => x * config.multiplier,
+      }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { multiplier: 3 },
+    });
+
+    const routeFactory = ({ services }: { services: { multiply: (x: number) => number } }) => {
+      return [
+        defineRoute({
+          method: "GET",
+          path: "/multiply",
+          outputSchema: z.object({ result: z.number() }),
+          handler: async (_ctx, { json }) => {
+            return json({ result: services.multiply(5) });
+          },
+        }),
+      ];
+    };
+
+    const routes = [routeFactory] as const;
+    const [multiplyRoute] = testFragment.initRoutes(routes);
+
+    expect(multiplyRoute.method).toBe("GET");
+    expect(multiplyRoute.path).toBe("/multiply");
+
+    // Test that the route was initialized with the correct services
+    const response = await testFragment.handler(multiplyRoute);
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({ result: 15 }); // 5 * 3
+    }
+  });
+
+  it("should allow overriding config/deps/services for specific route initialization", async () => {
+    const fragment = defineFragment<{ multiplier: number }>("test")
+      .withDependencies(() => ({ baseUrl: "https://api.example.com" }))
+      .withServices(({ config }) => ({
+        multiply: (x: number) => x * config.multiplier,
+        getMessage: (): string => "original message",
+      }));
+
+    const testFragment = createFragmentForTest(fragment, {
+      config: { multiplier: 2 },
+    });
+
+    const routeFactory = ({
+      config,
+      services,
+    }: {
+      config: { multiplier: number };
+      services: { multiply: (x: number) => number; getMessage: () => string };
+    }) => {
+      return [
+        defineRoute({
+          method: "GET",
+          path: "/test",
+          outputSchema: z.object({
+            result: z.number(),
+            message: z.string(),
+            multiplier: z.number(),
+          }),
+          handler: async (_ctx, { json }) => {
+            return json({
+              result: services.multiply(10),
+              message: services.getMessage(),
+              multiplier: config.multiplier,
+            });
+          },
+        }),
+      ];
+    };
+
+    const routes = [routeFactory] as const;
+
+    // Initialize with overrides - completely replace the multiply service
+    const [overriddenRoute] = testFragment.initRoutes(routes, {
+      config: { multiplier: 5 },
+      services: {
+        multiply: (x: number) => x * 5, // Mock implementation uses hardcoded multiplier
+        getMessage: (): string => "mocked message",
+      },
+    });
+
+    const response = await testFragment.handler(overriddenRoute);
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({
+        result: 50, // 10 * 5 (mocked multiply service)
+        message: "mocked message", // overridden service
+        multiplier: 5, // overridden config
+      });
+    }
+
+    // Verify original fragment config/services are unchanged
+    expect(testFragment.config.multiplier).toBe(2);
+    expect(testFragment.services.multiply(10)).toBe(20); // Original multiplier is 2
+    expect(testFragment.services.getMessage()).toBe("original message");
+  });
+});
+
+describe("fragment.handler", () => {
+  it("should handle JSON response", async () => {
+    const fragment = defineFragment<{ apiKey: string }>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/test",
+      outputSchema: z.object({ message: z.string() }),
+      handler: async (_ctx, { json }) => {
+        return json({ message: "hello" });
+      },
+    });
+
+    const response = await testFragment.handler(route);
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.status).toBe(200);
+      expect(response.data).toEqual({ message: "hello" });
+      expect(response.headers).toBeInstanceOf(Headers);
+    }
+  });
+
+  it("should handle empty response", async () => {
+    const fragment = defineFragment<{ apiKey: string }>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    const route = defineRoute({
+      method: "DELETE",
+      path: "/test",
+      handler: async (_ctx, { empty }) => {
+        return empty(204);
+      },
+    });
+
+    const response = await testFragment.handler(route);
+
+    expect(response.type).toBe("empty");
+    if (response.type === "empty") {
+      expect(response.status).toBe(204);
+      expect(response.headers).toBeInstanceOf(Headers);
+    }
+  });
+
+  it("should handle error response", async () => {
+    const fragment = defineFragment<{ apiKey: string }>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/test",
+      errorCodes: ["NOT_FOUND"] as const,
+      handler: async (_ctx, { error }) => {
+        return error({ message: "Not found", code: "NOT_FOUND" }, 404);
+      },
+    });
+
+    const response = await testFragment.handler(route);
+
+    expect(response.type).toBe("error");
+    if (response.type === "error") {
+      expect(response.status).toBe(404);
+      expect(response.error).toEqual({ message: "Not found", code: "NOT_FOUND" });
+      expect(response.headers).toBeInstanceOf(Headers);
+    }
+  });
+
+  it("should handle JSON stream response", async () => {
+    const fragment = defineFragment<{ apiKey: string }>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: { apiKey: "test-key" },
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/test/stream",
+      outputSchema: z.array(z.object({ value: z.number() })),
+      handler: async (_ctx, { jsonStream }) => {
+        return jsonStream(async (stream) => {
+          for (let i = 1; i <= 5; i++) {
+            await stream.write({ value: i });
+          }
+        });
+      },
+    });
+
+    const response = await testFragment.handler(route);
+
+    expect(response.type).toBe("jsonStream");
+    if (response.type === "jsonStream") {
+      expect(response.status).toBe(200);
+      expect(response.headers).toBeInstanceOf(Headers);
+      expect(response.headers.get("content-type")).toContain("application/x-ndjson");
+
+      const items = [];
+      for await (const item of response.stream) {
+        items.push(item);
+      }
+
+      expect(items).toEqual([{ value: 1 }, { value: 2 }, { value: 3 }, { value: 4 }, { value: 5 }]);
+    }
+  });
+
+  it("should handle path parameters", async () => {
+    const fragment = defineFragment<{}>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: {},
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/users/:id",
+      outputSchema: z.object({ userId: z.string() }),
+      handler: async ({ pathParams }, { json }) => {
+        return json({ userId: pathParams.id });
+      },
+    });
+
+    const response = await testFragment.handler(route, {
+      pathParams: { id: "123" },
+    });
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({ userId: "123" });
+    }
+  });
+
+  it("should handle query parameters", async () => {
+    const fragment = defineFragment<{}>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: {},
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/search",
+      outputSchema: z.object({ query: z.string() }),
+      handler: async ({ query }, { json }) => {
+        return json({ query: query.get("q") || "" });
+      },
+    });
+
+    const response = await testFragment.handler(route, {
+      query: { q: "test" },
+    });
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({ query: "test" });
+    }
+  });
+
+  it("should handle request body", async () => {
+    const fragment = defineFragment<{}>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: {},
+    });
+
+    const route = defineRoute({
+      method: "POST",
+      path: "/users",
+      inputSchema: z.object({ name: z.string(), email: z.string() }),
+      outputSchema: z.object({ id: z.number(), name: z.string(), email: z.string() }),
+      handler: async ({ input }, { json }) => {
+        if (input) {
+          const data = await input.valid();
+          return json({ id: 1, name: data.name, email: data.email });
+        }
+        return json({ id: 1, name: "", email: "" });
+      },
+    });
+
+    const response = await testFragment.handler(route, {
+      body: { name: "John", email: "john@example.com" },
+    });
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({ id: 1, name: "John", email: "john@example.com" });
+    }
+  });
+
+  it("should handle custom headers", async () => {
+    const fragment = defineFragment<{}>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: {},
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/test",
+      outputSchema: z.object({ authHeader: z.string() }),
+      handler: async ({ headers }, { json }) => {
+        return json({ authHeader: headers.get("authorization") || "" });
+      },
+    });
+
+    const response = await testFragment.handler(route, {
+      headers: { authorization: "Bearer token" },
+    });
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({ authHeader: "Bearer token" });
+    }
+  });
+
+  it("should properly type path params", async () => {
+    const fragment = defineFragment<{}>("test");
+    const testFragment = createFragmentForTest(fragment, {
+      config: {},
+    });
+
+    const route = defineRoute({
+      method: "GET",
+      path: "/orgs/:orgId/users/:userId",
+      outputSchema: z.object({ orgId: z.string(), userId: z.string() }),
+      handler: async ({ pathParams }, { json }) => {
+        return json({ orgId: pathParams.orgId, userId: pathParams.userId });
+      },
+    });
+
+    const response = await testFragment.handler(route, {
+      pathParams: { orgId: "123", userId: "456" },
+    });
+
+    expect(response.type).toBe("json");
+    if (response.type === "json") {
+      expect(response.data).toEqual({ orgId: "123", userId: "456" });
+    }
+  });
+});