@fragno-dev/core 0.1.2 → 0.1.4

package/dist/test/test.js

@@ -0,0 +1,155 @@
+import "../api-DngJDcmO.js";
+import { a as RequestOutputContext, o as RequestInputContext, r as resolveRouteFactories } from "../route-D1MZR6JL.js";
+
+//#region src/test/test.ts
+/**
+* Parse a Response object into a TestResponse discriminated union
+*/
+async function parseResponse(response) {
+	const status = response.status;
+	const headers = response.headers;
+	if ((headers.get("content-type") || "").includes("application/x-ndjson")) return {
+		type: "jsonStream",
+		status,
+		headers,
+		stream: parseNDJSONStream(response)
+	};
+	const text = await response.text();
+	if (!text || text === "null") return {
+		type: "empty",
+		status,
+		headers
+	};
+	const data = JSON.parse(text);
+	if (data && typeof data === "object" && "message" in data && "code" in data) return {
+		type: "error",
+		status,
+		headers,
+		error: {
+			message: data.message,
+			code: data.code
+		}
+	};
+	return {
+		type: "json",
+		status,
+		headers,
+		data
+	};
+}
+/**
+* Parse an NDJSON stream into an async generator
+*/
+async function* parseNDJSONStream(response) {
+	if (!response.body) return;
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() || "";
+			for (const line of lines) if (line.trim()) yield JSON.parse(line);
+		}
+		if (buffer.trim()) yield JSON.parse(buffer);
+	} finally {
+		reader.releaseLock();
+	}
+}
+/**
+* Create a fragment instance for testing with optional dependency and service overrides
+*
+* @param fragmentBuilder - The fragment builder with definition and required options
+* @param options - Configuration and optional overrides for deps/services
+* @returns A fragment test instance with a type-safe handler method
+*
+* @example
+* ```typescript
+* const fragment = createFragmentForTest(chatnoDefinition, {
+*   config: { openaiApiKey: "test-key" },
+*   options: { mountRoute: "/api/chatno" },
+*   services: {
+*     generateStreamMessages: mockGenerator
+*   }
+* });
+*
+* // Initialize routes with fragment's config/deps/services
+* const [route] = fragment.initRoutes(routes);
+*
+* // Or override specific config/deps/services for certain routes
+* const [route] = fragment.initRoutes(routes, {
+*   services: { mockService: mockImplementation }
+* });
+*
+* const response = await fragment.handler(route, {
+*   pathParams: { id: "123" },
+*   body: { message: "Hello" }
+* });
+*
+* if (response.type === 'json') {
+*   expect(response.data).toEqual({...});
+* }
+* ```
+*/
+function createFragmentForTest(fragmentBuilder, options) {
+	const { config, options: fragmentOptions = {}, deps: depsOverride, services: servicesOverride, additionalContext: additionalContextOverride } = options;
+	const definition = fragmentBuilder.definition;
+	const deps = {
+		...definition.dependencies ? definition.dependencies(config, fragmentOptions) : {},
+		...depsOverride
+	};
+	const services = {
+		...definition.services ? definition.services(config, fragmentOptions, deps) : {},
+		...servicesOverride
+	};
+	return {
+		config,
+		deps,
+		services,
+		additionalContext: {
+			...definition.additionalContext,
+			...fragmentOptions,
+			...additionalContextOverride
+		},
+		initRoutes: (routesOrFactories, overrides) => {
+			return resolveRouteFactories({
+				config: {
+					...config,
+					...overrides?.config
+				},
+				deps: {
+					...deps,
+					...overrides?.deps
+				},
+				services: {
+					...services,
+					...overrides?.services
+				}
+			}, routesOrFactories);
+		},
+		handler: async (route, inputOptions) => {
+			const { pathParams = {}, body, query, headers } = inputOptions || {};
+			const searchParams = query instanceof URLSearchParams ? query : query ? new URLSearchParams(query) : new URLSearchParams();
+			const requestHeaders = headers instanceof Headers ? headers : headers ? new Headers(headers) : new Headers();
+			const inputContext = new RequestInputContext({
+				path: route.path,
+				method: route.method,
+				pathParams,
+				searchParams,
+				headers: requestHeaders,
+				body,
+				inputSchema: route.inputSchema,
+				shouldValidateInput: false
+			});
+			const outputContext = new RequestOutputContext(route.outputSchema);
+			return parseResponse(await route.handler(inputContext, outputContext));
+		}
+	};
+}
+
+//#endregion
+export { createFragmentForTest };
+//# sourceMappingURL=test.js.map

package/dist/test/test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"test.js","names":[],"sources":["../../src/test/test.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport type { FragmentDefinition } from \"../api/fragment-builder\";\nimport type { FragnoRouteConfig, HTTPMethod } from \"../api/api\";\nimport type { ExtractPathParams } from \"../api/internal/path\";\nimport { RequestInputContext } from \"../api/request-input-context\";\nimport { RequestOutputContext } from \"../api/request-output-context\";\nimport type { AnyRouteOrFactory, FlattenRouteFactories } from \"../api/route\";\nimport { resolveRouteFactories } from \"../api/route\";\nimport type { FragnoPublicConfig } from \"../api/fragment-instantiation\";\n\n/**\n * Discriminated union representing all possible test response types\n */\nexport type TestResponse<T> =\n  | {\n      type: \"empty\";\n      status: number;\n      headers: Headers;\n    }\n  | {\n      type: \"error\";\n      status: number;\n      headers: Headers;\n      error: { message: string; code: string };\n    }\n  | {\n      type: \"json\";\n      status: number;\n      headers: Headers;\n      data: T;\n    }\n  | {\n      type: \"jsonStream\";\n      status: number;\n      headers: Headers;\n      stream: AsyncGenerator<T>;\n    };\n\n/**\n * Parse a Response object into a TestResponse discriminated union\n */\nasync function parseResponse<T>(response: Response): Promise<TestResponse<T>> {\n  const status = response.status;\n  const headers = response.headers;\n  const contentType = headers.get(\"content-type\") || \"\";\n\n  // Check for streaming response\n  if (contentType.includes(\"application/x-ndjson\")) {\n    return {\n      type: \"jsonStream\",\n      status,\n      headers,\n      stream: parseNDJSONStream<T>(response),\n    };\n  }\n\n  // Parse JSON body\n  const text = await response.text();\n\n  // Empty response\n  if (!text || text === \"null\") {\n    return {\n      type: \"empty\",\n      status,\n      headers,\n    };\n  }\n\n  const data = JSON.parse(text);\n\n  // Error response (has message and code)\n  if (data && typeof data === \"object\" && \"message\" in data && \"code\" in data) {\n    return {\n      type: \"error\",\n      status,\n      headers,\n      error: { message: data.message, code: data.code },\n    };\n  }\n\n  // JSON response\n  return {\n    type: \"json\",\n    status,\n    headers,\n    data: data as T,\n  };\n}\n\n/**\n * Parse an NDJSON stream into an async generator\n */\nasync function* parseNDJSONStream<T>(response: Response): AsyncGenerator<T> {\n  if (!response.body) {\n    return;\n  }\n\n  const reader = response.body.getReader();\n  const decoder = new TextDecoder();\n  let buffer = \"\";\n\n  try {\n    while (true) {\n      const { done, value } = await reader.read();\n\n      if (done) {\n        break;\n      }\n\n      buffer += decoder.decode(value, { stream: true });\n      const lines = buffer.split(\"\\n\");\n\n      // Keep the last incomplete line in the buffer\n      buffer = lines.pop() || \"\";\n\n      for (const line of lines) {\n        if (line.trim()) {\n          yield JSON.parse(line) as T;\n        }\n      }\n    }\n\n    // Process any remaining data in the buffer\n    if (buffer.trim()) {\n      yield JSON.parse(buffer) as T;\n    }\n  } finally {\n    reader.releaseLock();\n  }\n}\n\n/**\n * Options for creating a test fragment\n */\nexport interface CreateFragmentForTestOptions<\n  TConfig,\n  TDeps,\n  TServices,\n  TAdditionalContext extends Record<string, unknown>,\n  TOptions extends FragnoPublicConfig,\n> {\n  config: TConfig;\n  options?: Partial<TOptions>;\n  deps?: Partial<TDeps>;\n  services?: Partial<TServices>;\n  additionalContext?: Partial<TAdditionalContext>;\n}\n\n/**\n * Options for calling a route handler\n */\nexport interface RouteHandlerInputOptions<\n  TPath extends string,\n  TInputSchema extends StandardSchemaV1 | undefined,\n> {\n  pathParams?: ExtractPathParams<TPath>;\n  body?: TInputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferInput<TInputSchema> : never;\n  query?: URLSearchParams | Record<string, string>;\n  headers?: Headers | Record<string, string>;\n}\n\n/**\n * Options for overriding config/deps/services when initializing routes\n */\nexport interface InitRoutesOverrides<TConfig, TDeps, TServices> {\n  config?: Partial<TConfig>;\n  deps?: Partial<TDeps>;\n  services?: Partial<TServices>;\n}\n\n/**\n * Fragment test instance with type-safe handler method\n */\nexport interface FragmentForTest<\n  TConfig,\n  TDeps,\n  TServices,\n  TAdditionalContext extends Record<string, unknown>,\n  TOptions extends FragnoPublicConfig,\n> {\n  config: TConfig;\n  deps: TDeps;\n  services: TServices;\n  additionalContext: TAdditionalContext & TOptions;\n  handler: <\n    TMethod extends HTTPMethod,\n    TPath extends string,\n    TInputSchema extends StandardSchemaV1 | undefined,\n    TOutputSchema extends StandardSchemaV1 | undefined,\n    TErrorCode extends string,\n    TQueryParameters extends string,\n  >(\n    route: FragnoRouteConfig<\n      TMethod,\n      TPath,\n      TInputSchema,\n      TOutputSchema,\n      TErrorCode,\n      TQueryParameters\n    >,\n    inputOptions?: RouteHandlerInputOptions<TPath, TInputSchema>,\n  ) => Promise<\n    TestResponse<\n      TOutputSchema extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<TOutputSchema> : unknown\n    >\n  >;\n  initRoutes: <const TRoutesOrFactories extends readonly AnyRouteOrFactory[]>(\n    routesOrFactories: TRoutesOrFactories,\n    overrides?: InitRoutesOverrides<TConfig, TDeps, TServices>,\n  ) => FlattenRouteFactories<TRoutesOrFactories>;\n}\n\n/**\n * Create a fragment instance for testing with optional dependency and service overrides\n *\n * @param fragmentBuilder - The fragment builder with definition and required options\n * @param options - Configuration and optional overrides for deps/services\n * @returns A fragment test instance with a type-safe handler method\n *\n * @example\n * ```typescript\n * const fragment = createFragmentForTest(chatnoDefinition, {\n *   config: { openaiApiKey: \"test-key\" },\n *   options: { mountRoute: \"/api/chatno\" },\n *   services: {\n *     generateStreamMessages: mockGenerator\n *   }\n * });\n *\n * // Initialize routes with fragment's config/deps/services\n * const [route] = fragment.initRoutes(routes);\n *\n * // Or override specific config/deps/services for certain routes\n * const [route] = fragment.initRoutes(routes, {\n *   services: { mockService: mockImplementation }\n * });\n *\n * const response = await fragment.handler(route, {\n *   pathParams: { id: \"123\" },\n *   body: { message: \"Hello\" }\n * });\n *\n * if (response.type === 'json') {\n *   expect(response.data).toEqual({...});\n * }\n * ```\n */\nexport function createFragmentForTest<\n  TConfig,\n  TDeps,\n  TServices extends Record<string, unknown>,\n  TAdditionalContext extends Record<string, unknown>,\n  TOptions extends FragnoPublicConfig,\n>(\n  fragmentBuilder: {\n    definition: FragmentDefinition<TConfig, TDeps, TServices, TAdditionalContext>;\n    $requiredOptions: TOptions;\n  },\n  options: CreateFragmentForTestOptions<TConfig, TDeps, TServices, TAdditionalContext, TOptions>,\n): FragmentForTest<TConfig, TDeps, TServices, TAdditionalContext, TOptions> {\n  const {\n    config,\n    options: fragmentOptions = {} as TOptions,\n    deps: depsOverride,\n    services: servicesOverride,\n    additionalContext: additionalContextOverride,\n  } = options;\n\n  // Create deps from definition or use empty object\n  const definition = fragmentBuilder.definition;\n  const baseDeps = definition.dependencies\n    ? definition.dependencies(config, fragmentOptions)\n    : ({} as TDeps);\n\n  // Merge deps with overrides\n  const deps = { ...baseDeps, ...depsOverride } as TDeps;\n\n  // Create services from definition or use empty object\n  const baseServices = definition.services\n    ? definition.services(config, fragmentOptions, deps)\n    : ({} as TServices);\n\n  // Merge services with overrides\n  const services = { ...baseServices, ...servicesOverride } as TServices;\n\n  // Merge additional context with options\n  const additionalContext = {\n    ...definition.additionalContext,\n    ...fragmentOptions,\n    ...additionalContextOverride,\n  } as TAdditionalContext & TOptions;\n\n  return {\n    config,\n    deps,\n    services,\n    additionalContext,\n    initRoutes: <const TRoutesOrFactories extends readonly AnyRouteOrFactory[]>(\n      routesOrFactories: TRoutesOrFactories,\n      overrides?: InitRoutesOverrides<TConfig, TDeps, TServices>,\n    ): FlattenRouteFactories<TRoutesOrFactories> => {\n      // Merge overrides with base config/deps/services\n      const routeContext = {\n        config: { ...config, ...overrides?.config } as TConfig,\n        deps: { ...deps, ...overrides?.deps } as TDeps,\n        services: { ...services, ...overrides?.services } as TServices,\n      };\n      return resolveRouteFactories(routeContext, routesOrFactories);\n    },\n    handler: async <\n      TMethod extends HTTPMethod,\n      TPath extends string,\n      TInputSchema extends StandardSchemaV1 | undefined,\n      TOutputSchema extends StandardSchemaV1 | undefined,\n      TErrorCode extends string,\n      TQueryParameters extends string,\n    >(\n      route: FragnoRouteConfig<\n        TMethod,\n        TPath,\n        TInputSchema,\n        TOutputSchema,\n        TErrorCode,\n        TQueryParameters\n      >,\n      inputOptions?: RouteHandlerInputOptions<TPath, TInputSchema>,\n    ): Promise<\n      TestResponse<\n        TOutputSchema extends StandardSchemaV1\n          ? StandardSchemaV1.InferOutput<TOutputSchema>\n          : unknown\n      >\n    > => {\n      const {\n        pathParams = {} as ExtractPathParams<TPath>,\n        body,\n        query,\n        headers,\n      } = inputOptions || {};\n\n      // Convert query to URLSearchParams if needed\n      const searchParams =\n        query instanceof URLSearchParams\n          ? query\n          : query\n            ? new URLSearchParams(query)\n            : new URLSearchParams();\n\n      // Convert headers to Headers if needed\n      const requestHeaders =\n        headers instanceof Headers ? headers : headers ? new Headers(headers) : new Headers();\n\n      // Construct RequestInputContext\n      const inputContext = new RequestInputContext<TPath, TInputSchema>({\n        path: route.path,\n        method: route.method,\n        pathParams,\n        searchParams,\n        headers: requestHeaders,\n        body,\n        inputSchema: route.inputSchema,\n        shouldValidateInput: false, // Skip validation in tests\n      });\n\n      // Construct RequestOutputContext\n      const outputContext = new RequestOutputContext(route.outputSchema);\n\n      // Call the route handler\n      const response = await route.handler(inputContext, outputContext);\n\n      // Parse and return the response\n      return parseResponse<\n        TOutputSchema extends StandardSchemaV1\n          ? StandardSchemaV1.InferOutput<TOutputSchema>\n          : unknown\n      >(response);\n    },\n  };\n}\n"],"mappings":";;;;;;;AAyCA,eAAe,cAAiB,UAA8C;CAC5E,MAAM,SAAS,SAAS;CACxB,MAAM,UAAU,SAAS;AAIzB,MAHoB,QAAQ,IAAI,eAAe,IAAI,IAGnC,SAAS,uBAAuB,CAC9C,QAAO;EACL,MAAM;EACN;EACA;EACA,QAAQ,kBAAqB,SAAS;EACvC;CAIH,MAAM,OAAO,MAAM,SAAS,MAAM;AAGlC,KAAI,CAAC,QAAQ,SAAS,OACpB,QAAO;EACL,MAAM;EACN;EACA;EACD;CAGH,MAAM,OAAO,KAAK,MAAM,KAAK;AAG7B,KAAI,QAAQ,OAAO,SAAS,YAAY,aAAa,QAAQ,UAAU,KACrE,QAAO;EACL,MAAM;EACN;EACA;EACA,OAAO;GAAE,SAAS,KAAK;GAAS,MAAM,KAAK;GAAM;EAClD;AAIH,QAAO;EACL,MAAM;EACN;EACA;EACM;EACP;;;;;AAMH,gBAAgB,kBAAqB,UAAuC;AAC1E,KAAI,CAAC,SAAS,KACZ;CAGF,MAAM,SAAS,SAAS,KAAK,WAAW;CACxC,MAAM,UAAU,IAAI,aAAa;CACjC,IAAI,SAAS;AAEb,KAAI;AACF,SAAO,MAAM;GACX,MAAM,EAAE,MAAM,UAAU,MAAM,OAAO,MAAM;AAE3C,OAAI,KACF;AAGF,aAAU,QAAQ,OAAO,OAAO,EAAE,QAAQ,MAAM,CAAC;GACjD,MAAM,QAAQ,OAAO,MAAM,KAAK;AAGhC,YAAS,MAAM,KAAK,IAAI;AAExB,QAAK,MAAM,QAAQ,MACjB,KAAI,KAAK,MAAM,CACb,OAAM,KAAK,MAAM,KAAK;;AAM5B,MAAI,OAAO,MAAM,CACf,OAAM,KAAK,MAAM,OAAO;WAElB;AACR,SAAO,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwHxB,SAAgB,sBAOd,iBAIA,SAC0E;CAC1E,MAAM,EACJ,QACA,SAAS,kBAAkB,EAAE,EAC7B,MAAM,cACN,UAAU,kBACV,mBAAmB,8BACjB;CAGJ,MAAM,aAAa,gBAAgB;CAMnC,MAAM,OAAO;EAAE,GALE,WAAW,eACxB,WAAW,aAAa,QAAQ,gBAAgB,GAC/C,EAAE;EAGqB,GAAG;EAAc;CAQ7C,MAAM,WAAW;EAAE,GALE,WAAW,WAC5B,WAAW,SAAS,QAAQ,iBAAiB,KAAK,GACjD,EAAE;EAG6B,GAAG;EAAkB;AASzD,QAAO;EACL;EACA;EACA;EACA,mBAVwB;GACxB,GAAG,WAAW;GACd,GAAG;GACH,GAAG;GACJ;EAOC,aACE,mBACA,cAC8C;AAO9C,UAAO,sBALc;IACnB,QAAQ;KAAE,GAAG;KAAQ,GAAG,WAAW;KAAQ;IAC3C,MAAM;KAAE,GAAG;KAAM,GAAG,WAAW;KAAM;IACrC,UAAU;KAAE,GAAG;KAAU,GAAG,WAAW;KAAU;IAClD,EAC0C,kBAAkB;;EAE/D,SAAS,OAQP,OAQA,iBAOG;GACH,MAAM,EACJ,aAAa,EAAE,EACf,MACA,OACA,YACE,gBAAgB,EAAE;GAGtB,MAAM,eACJ,iBAAiB,kBACb,QACA,QACE,IAAI,gBAAgB,MAAM,GAC1B,IAAI,iBAAiB;GAG7B,MAAM,iBACJ,mBAAmB,UAAU,UAAU,UAAU,IAAI,QAAQ,QAAQ,GAAG,IAAI,SAAS;GAGvF,MAAM,eAAe,IAAI,oBAAyC;IAChE,MAAM,MAAM;IACZ,QAAQ,MAAM;IACd;IACA;IACA,SAAS;IACT;IACA,aAAa,MAAM;IACnB,qBAAqB;IACtB,CAAC;GAGF,MAAM,gBAAgB,IAAI,qBAAqB,MAAM,aAAa;AAMlE,UAAO,cAHU,MAAM,MAAM,QAAQ,cAAc,cAAc,CAOtD;;EAEd"}

package/package.json

@@ -1,69 +1,63 @@
 {
   "name": "@fragno-dev/core",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "exports": {
     ".": {
-      "bun": "./src/mod.ts",
       "development": "./src/mod.ts",
       "types": "./dist/mod.d.ts",
       "default": "./dist/mod.js"
     },
     "./api": {
-      "bun": "./src/api/api.ts",
       "development": "./src/api/api.ts",
       "types": "./dist/api/api.d.ts",
       "default": "./dist/api/api.js"
     },
+    "./test": {
+      "development": "./src/test/test.ts",
+      "types": "./dist/test/test.d.ts",
+      "default": "./dist/test/test.js"
+    },
     "./api/fragment-builder": {
-      "bun": "./src/api/fragment-builder.ts",
       "development": "./src/api/fragment-builder.ts",
       "types": "./dist/api/fragment-builder.d.ts",
       "default": "./dist/api/fragment-builder.js"
     },
     "./api/fragment-instantiation": {
-      "bun": "./src/api/fragment-instantiation.ts",
       "development": "./src/api/fragment-instantiation.ts",
       "types": "./dist/api/fragment-instantiation.d.ts",
       "default": "./dist/api/fragment-instantiation.js"
     },
     "./client": {
-      "bun": "./src/client/client.ts",
       "development": "./src/client/client.ts",
       "types": "./dist/client/client.d.ts",
       "default": "./dist/client/client.js"
     },
     "./react": {
-      "bun": "./src/client/react.ts",
       "development": "./src/client/react.ts",
       "types": "./dist/client/react.d.ts",
       "default": "./dist/client/react.js"
     },
     "./vanilla": {
-      "bun": "./src/client/vanilla.ts",
       "development": "./src/client/vanilla.ts",
       "types": "./dist/client/vanilla.d.ts",
       "default": "./dist/client/vanilla.js"
     },
     "./vue": {
-      "bun": "./src/client/vue.ts",
       "development": "./src/client/vue.ts",
       "types": "./dist/client/vue.d.ts",
       "default": "./dist/client/vue.js"
     },
     "./svelte": {
-      "bun": "./src/client/client.svelte.ts",
       "development": "./src/client/client.svelte.ts",
       "types": "./dist/client/client.svelte.d.ts",
       "default": "./dist/client/client.svelte.js"
     },
     "./solid": {
-      "bun": "./src/client/solid.ts",
       "development": "./src/client/solid.ts",
       "types": "./dist/client/solid.d.ts",
       "default": "./dist/client/solid.js"
     },
     "./react-ssr": {
-      "bun": "./src/integrations/react-ssr.ts",
       "development": "./src/integrations/react-ssr.ts",
       "types": "./dist/integrations/react-ssr.d.ts",
       "default": "./dist/integrations/react-ssr.js"
@@ -73,13 +67,6 @@
   "main": "./dist/mod.js",
   "module": "./dist/mod.js",
   "types": "./dist/mod.d.ts",
-  "scripts": {
-    "build": "tsdown",
-    "build:watch": "tsdown --watch",
-    "types:check": "tsc --noEmit",
-    "test": "vitest run",
-    "test:watch": "vitest --watch"
-  },
   "type": "module",
   "dependencies": {
     "@nanostores/query": "^0.3.4",
@@ -89,8 +76,6 @@
     "rou3": "^0.7.3"
   },
   "devDependencies": {
-    "@fragno-private/typescript-config": "0.0.1",
-    "@fragno-private/vitest-config": "0.0.0",
     "@sveltejs/vite-plugin-svelte": "^6.2.0",
     "@testing-library/react": "^16.3.0",
     "@testing-library/svelte": "^5.2.8",
@@ -106,7 +91,9 @@
     "solid-js": "^1.9.3",
     "vitest": "^3.2.4",
     "vue": "^3",
-    "zod": "^4.0.5"
+    "zod": "^4.0.5",
+    "@fragno-private/typescript-config": "0.0.1",
+    "@fragno-private/vitest-config": "0.0.0"
   },
   "peerDependencies": {
     "react": "^19.0.0",
@@ -134,5 +121,12 @@
     "directory": "packages/fragno"
   },
   "homepage": "https://fragno.dev",
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "tsdown",
+    "build:watch": "tsdown --watch",
+    "types:check": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest --watch"
+  }
+}

package/src/api/fragment-builder.ts

@@ -73,7 +73,6 @@ export class FragmentBuilder<
     });
   }
 }
-
 export function defineFragment<TConfig = {}>(name: string): FragmentBuilder<TConfig, {}, {}, {}> {
   return new FragmentBuilder({
     name,

package/src/api/request-middleware.test.ts

@@ -628,4 +628,255 @@ describe("Request Middleware", () => {
       custom: "middleware-value",
     });
   });
+
+  test("ifMatchesRoute properly awaits async handlers", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "POST",
+        path: "/users",
+        inputSchema: z.object({ name: z.string() }),
+        outputSchema: z.object({ id: z.number(), name: z.string(), verified: z.boolean() }),
+        handler: async ({ input }, { json }) => {
+          const body = await input.valid();
+          return json({
+            id: 1,
+            name: body.name,
+            verified: false,
+          });
+        },
+      }),
+    ] as const;
+
+    let asyncOperationCompleted = false;
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute }) => {
+      const result = await ifMatchesRoute("POST", "/users", async ({ input }) => {
+        // Simulate async operation (e.g., database lookup)
+        await new Promise((resolve) => setTimeout(resolve, 10));
+        const body = await input.valid();
+
+        // Verify the async operation completed
+        asyncOperationCompleted = true;
+
+        // Check if user exists
+        if (body.name === "existing-user") {
+          return new Response(
+            JSON.stringify({
+              message: "User already exists",
+              code: "USER_EXISTS",
+            }),
+            { status: 409, headers: { "Content-Type": "application/json" } },
+          );
+        }
+
+        return undefined;
+      });
+
+      return result;
+    });
+
+    // Test with existing user
+    const existingUserReq = new Request("http://localhost/api/users", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "existing-user" }),
+    });
+
+    const existingUserRes = await instance.handler(existingUserReq);
+    expect(asyncOperationCompleted).toBe(true);
+    expect(existingUserRes.status).toBe(409);
+    expect(await existingUserRes.json()).toEqual({
+      message: "User already exists",
+      code: "USER_EXISTS",
+    });
+
+    // Reset flag
+    asyncOperationCompleted = false;
+
+    // Test with new user
+    const newUserReq = new Request("http://localhost/api/users", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ name: "new-user" }),
+    });
+
+    const newUserRes = await instance.handler(newUserReq);
+    expect(asyncOperationCompleted).toBe(true);
+    expect(newUserRes.status).toBe(200);
+    expect(await newUserRes.json()).toEqual({
+      id: 1,
+      name: "new-user",
+      verified: false,
+    });
+  });
+
+  test("ifMatchesRoute handles async errors properly", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "GET",
+        path: "/data",
+        outputSchema: z.object({ data: z.string() }),
+        handler: async (_, { json }) => {
+          return json({ data: "test" });
+        },
+      }),
+    ] as const;
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute }) => {
+      const result = await ifMatchesRoute("GET", "/data", async (_, { error }) => {
+        // Simulate async operation that fails
+        await new Promise((resolve) => setTimeout(resolve, 5));
+
+        // Simulate an error condition (e.g., database unavailable)
+        return error(
+          {
+            message: "Service temporarily unavailable",
+            code: "SERVICE_UNAVAILABLE",
+          },
+          503,
+        );
+      });
+
+      return result;
+    });
+
+    const req = new Request("http://localhost/api/data", {
+      method: "GET",
+    });
+
+    const res = await instance.handler(req);
+    expect(res.status).toBe(503);
+    expect(await res.json()).toEqual({
+      message: "Service temporarily unavailable",
+      code: "SERVICE_UNAVAILABLE",
+    });
+  });
+
+  test("ifMatchesRoute with async body modification", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "POST",
+        path: "/posts",
+        inputSchema: z.object({ title: z.string(), content: z.string() }),
+        outputSchema: z.object({
+          title: z.string(),
+          content: z.string(),
+          slug: z.string(),
+          createdAt: z.number(),
+        }),
+        handler: async ({ input }, { json }) => {
+          const body = await input.valid();
+          return json({
+            title: body.title,
+            content: body.content,
+            slug: body.title.toLowerCase().replace(/\s+/g, "-"),
+            createdAt: Date.now(),
+          });
+        },
+      }),
+    ] as const;
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute, requestState }) => {
+      const result = await ifMatchesRoute("POST", "/posts", async ({ input }) => {
+        // Simulate async operation to enrich the body (e.g., fetching user data)
+        await new Promise((resolve) => setTimeout(resolve, 5));
+
+        const body = await input.valid();
+
+        // Enrich the body with additional data
+        requestState.setBody({
+          ...body,
+          content: `${body.content}\n\n[Enhanced by middleware]`,
+        });
+
+        return undefined;
+      });
+
+      return result;
+    });
+
+    const req = new Request("http://localhost/api/posts", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        title: "Test Post",
+        content: "Original content",
+      }),
+    });
+
+    const res = await instance.handler(req);
+    expect(res.status).toBe(200);
+
+    const responseBody = await res.json();
+    expect(responseBody).toMatchObject({
+      title: "Test Post",
+      content: "Original content\n\n[Enhanced by middleware]",
+      slug: "test-post",
+    });
+    expect(responseBody.createdAt).toBeTypeOf("number");
+  });
+
+  test("multiple async operations in ifMatchesRoute complete in order", async () => {
+    const fragment = defineFragment("test-lib");
+
+    const routes = [
+      defineRoute({
+        method: "GET",
+        path: "/status",
+        outputSchema: z.object({ message: z.string() }),
+        handler: async (_, { json }) => {
+          return json({ message: "OK" });
+        },
+      }),
+    ] as const;
+
+    const executionOrder: string[] = [];
+
+    const instance = createFragment(fragment, {}, routes, {
+      mountRoute: "/api",
+    }).withMiddleware(async ({ ifMatchesRoute }) => {
+      executionOrder.push("start");
+
+      const result = await ifMatchesRoute("GET", "/status", async () => {
+        executionOrder.push("before-first-async");
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        executionOrder.push("after-first-async");
+
+        await new Promise((resolve) => setTimeout(resolve, 5));
+        executionOrder.push("after-second-async");
+
+        return undefined;
+      });
+
+      executionOrder.push("end");
+
+      return result;
+    });
+
+    const req = new Request("http://localhost/api/status", {
+      method: "GET",
+    });
+
+    const res = await instance.handler(req);
+    expect(res.status).toBe(200);
+    expect(executionOrder).toEqual([
+      "start",
+      "before-first-async",
+      "after-first-async",
+      "after-second-async",
+      "end",
+    ]);
+  });
 });

package/src/api/request-middleware.ts

@@ -143,6 +143,6 @@ export class RequestMiddlewareInputContext<const TRoutes extends readonly AnyFra
     const outputContext = new RequestOutputContext(this.#route.outputSchema);
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return (handler as any)(inputContext, outputContext);
+    return await (handler as any)(inputContext, outputContext);
   };
 }