@fragno-dev/core 0.1.7 → 0.1.9

package/src/api/route.test.ts

@@ -1,5 +1,6 @@
 import { test, expect, expectTypeOf, describe } from "vitest";
-import { defineRoute } from "./route";
+import { defineRoute, defineRoutes } from "./route";
+import { defineFragment } from "./fragment-definition-builder";
 import { z } from "zod";
 
 describe("defineRoute", () => {
@@ -174,3 +175,88 @@ describe("defineRoute", () => {
     // Currently defineRoute doesn't enforce ValidPath constraints
   });
 });
+
+// ExtractFragmentServices tests removed - use ExtractFragmentServices instead
+
+describe("defineRoutes", () => {
+  test("defineRoutes extracts services correctly for route factory", () => {
+    const fragment = defineFragment<{}>("test-fragment")
+      .providesBaseService(({ defineService }) =>
+        defineService({
+          getUserById: async (id: string) => ({ id, name: "John" }),
+          createUser: async (name: string) => ({ id: "123", name }),
+        }),
+      )
+      .build();
+
+    const routeFactory = defineRoutes(fragment).create(({ services, config, deps }) => {
+      // Type check that services are properly extracted
+      expectTypeOf(services).toMatchObjectType<{
+        getUserById: (id: string) => Promise<{ id: string; name: string }>;
+        createUser: (name: string) => Promise<{ id: string; name: string }>;
+      }>();
+
+      expectTypeOf(config).toEqualTypeOf<{}>();
+      expectTypeOf(deps).toEqualTypeOf<{}>();
+
+      return [
+        defineRoute({
+          method: "GET",
+          path: "/users/:id",
+          outputSchema: z.object({ id: z.string(), name: z.string() }),
+          handler: async ({ pathParams }, { json }) => {
+            // Services should be accessible here via closure
+            const user = await services.getUserById(pathParams.id);
+            return json(user);
+          },
+        }),
+      ];
+    });
+
+    // routeFactory is a function that returns routes when called
+    expect(routeFactory).toBeDefined();
+    expect(typeof routeFactory).toBe("function");
+  });
+
+  test("defineRoutes with dependencies and services", () => {
+    const fragment = defineFragment<{ apiKey: string }>("auth-fragment")
+      .withDependencies(({ config }) => ({
+        authClient: { apiKey: config.apiKey },
+      }))
+      .providesBaseService(({ deps, defineService }) =>
+        defineService({
+          validateToken: async (_token: string) => {
+            return { valid: true, apiKey: deps.authClient.apiKey };
+          },
+        }),
+      )
+      .build();
+
+    const routeFactory = defineRoutes(fragment).create(({ services, config, deps }) => {
+      // Type check all context properties
+      expectTypeOf(config).toEqualTypeOf<{ apiKey: string }>();
+      expectTypeOf(deps).toMatchObjectType<{ authClient: { apiKey: string } }>();
+      expectTypeOf(services).toMatchObjectType<{
+        validateToken: (token: string) => Promise<{ valid: boolean; apiKey: string }>;
+      }>();
+
+      return [
+        defineRoute({
+          method: "POST",
+          path: "/auth/validate",
+          inputSchema: z.object({ token: z.string() }),
+          outputSchema: z.object({ valid: z.boolean() }),
+          handler: async ({ input }, { json }) => {
+            const { token } = await input!.valid();
+            const result = await services.validateToken(token);
+            return json({ valid: result.valid });
+          },
+        }),
+      ];
+    });
+
+    // routeFactory is a function that returns routes when called
+    expect(routeFactory).toBeDefined();
+    expect(typeof routeFactory).toBe("function");
+  });
+});

package/src/api/route.ts

@@ -1,53 +1,66 @@
+// oxlint-disable no-explicit-any
+
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { FragnoRouteConfig, HTTPMethod } from "./api";
+import type { FragnoRouteConfig, HTTPMethod, RequestThisContext } from "./api";
+import type { FragmentDefinition } from "./fragment-definition-builder";
+import type { BoundServices } from "./bind-services";
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyFragnoRouteConfig = FragnoRouteConfig<HTTPMethod, string, any, any, any, any>;
+export type AnyFragnoRouteConfig = FragnoRouteConfig<HTTPMethod, string, any, any, any, any, any>;
 
-export interface RouteFactoryContext<TConfig, TDeps, TServices> {
+export interface RouteFactoryContext<TConfig, TDeps, TServices, TServiceDeps = {}> {
   config: TConfig;
   deps: TDeps;
   services: TServices;
+  serviceDeps: TServiceDeps;
 }
 
 export type RouteFactory<
   TConfig,
   TDeps,
   TServices,
+  TServiceDeps,
   TRoutes extends readonly FragnoRouteConfig<
     HTTPMethod,
     string,
     StandardSchemaV1 | undefined,
     StandardSchemaV1 | undefined,
     string,
-    string
+    string,
+    RequestThisContext
   >[],
-> = (context: RouteFactoryContext<TConfig, TDeps, TServices>) => TRoutes;
+> = (context: RouteFactoryContext<TConfig, TDeps, TServices, TServiceDeps>) => TRoutes;
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type AnyRouteOrFactory = AnyFragnoRouteConfig | RouteFactory<any, any, any, any>;
+/**
+ * @internal
+ */
+export type AnyRouteOrFactory = AnyFragnoRouteConfig | RouteFactory<any, any, any, any, any>;
 
+/**
+ * @internal
+ */
 export type FlattenRouteFactories<T extends readonly AnyRouteOrFactory[]> = T extends readonly [
   infer First,
   ...infer Rest extends readonly AnyRouteOrFactory[],
 ]
-  ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    First extends RouteFactory<any, any, any, infer TRoutes>
+  ? First extends RouteFactory<any, any, any, any, infer TRoutes>
     ? [...TRoutes, ...FlattenRouteFactories<Rest>]
     : [First, ...FlattenRouteFactories<Rest>]
   : [];
 
-// Helper to resolve route factories into routes
+/**
+ * Helper to resolve route factories into routes
+ * @internal
+ */
 export function resolveRouteFactories<
   TConfig,
   TDeps,
   TServices,
+  TServiceDeps,
   const TRoutesOrFactories extends readonly AnyRouteOrFactory[],
 >(
-  context: RouteFactoryContext<TConfig, TDeps, TServices>,
+  context: RouteFactoryContext<TConfig, TDeps, TServices, TServiceDeps>,
   routesOrFactories: TRoutesOrFactories,
 ): FlattenRouteFactories<TRoutesOrFactories> {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const routes: any[] = [];
 
   for (const item of routesOrFactories) {
@@ -74,6 +87,7 @@ export function defineRoute<
   const TOutputSchema extends StandardSchemaV1 | undefined,
   const TErrorCode extends string = string,
   const TQueryParameters extends string = string,
+  const TThisContext extends RequestThisContext = RequestThisContext,
 >(
   config: FragnoRouteConfig<
     TMethod,
@@ -81,9 +95,18 @@ export function defineRoute<
     undefined,
     TOutputSchema,
     TErrorCode,
-    TQueryParameters
+    TQueryParameters,
+    TThisContext
   > & { inputSchema?: undefined },
-): FragnoRouteConfig<TMethod, TPath, undefined, TOutputSchema, TErrorCode, TQueryParameters>;
+): FragnoRouteConfig<
+  TMethod,
+  TPath,
+  undefined,
+  TOutputSchema,
+  TErrorCode,
+  TQueryParameters,
+  TThisContext
+>;
 
 // Overload for routes with inputSchema
 export function defineRoute<
@@ -93,6 +116,7 @@ export function defineRoute<
   const TOutputSchema extends StandardSchemaV1 | undefined,
   const TErrorCode extends string = string,
   const TQueryParameters extends string = string,
+  const TThisContext extends RequestThisContext = RequestThisContext,
 >(
   config: FragnoRouteConfig<
     TMethod,
@@ -100,9 +124,18 @@ export function defineRoute<
     TInputSchema,
     TOutputSchema,
     TErrorCode,
-    TQueryParameters
+    TQueryParameters,
+    TThisContext
   > & { inputSchema: TInputSchema },
-): FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters>;
+): FragnoRouteConfig<
+  TMethod,
+  TPath,
+  TInputSchema,
+  TOutputSchema,
+  TErrorCode,
+  TQueryParameters,
+  TThisContext
+>;
 
 // implementation
 export function defineRoute<
@@ -112,6 +145,7 @@ export function defineRoute<
   const TOutputSchema extends StandardSchemaV1 | undefined,
   const TErrorCode extends string = string,
   const TQueryParameters extends string = string,
+  const TThisContext extends RequestThisContext = RequestThisContext,
 >(
   config: FragnoRouteConfig<
     TMethod,
@@ -119,13 +153,246 @@ export function defineRoute<
     TInputSchema,
     TOutputSchema,
     TErrorCode,
-    TQueryParameters
+    TQueryParameters,
+    TThisContext
   >,
-): FragnoRouteConfig<TMethod, TPath, TInputSchema, TOutputSchema, TErrorCode, TQueryParameters> {
+): FragnoRouteConfig<
+  TMethod,
+  TPath,
+  TInputSchema,
+  TOutputSchema,
+  TErrorCode,
+  TQueryParameters,
+  TThisContext
+> {
   return config;
 }
 
-export function defineRoutes<TConfig = {}, TDeps = {}, TServices = {}>() {
+// ============================================================================
+// Type extractors for FragmentDefinition
+// ============================================================================
+
+export type AnyFragmentDefinition = FragmentDefinition<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+
+// Extract config from FragmentDefinition
+export type ExtractFragmentConfig<T> =
+  T extends FragmentDefinition<infer TConfig, any, any, any, any, any, any, any, any, any>
+    ? TConfig
+    : never;
+
+// Extract deps from FragmentDefinition
+export type ExtractFragmentDeps<T> =
+  T extends FragmentDefinition<any, any, infer TDeps, any, any, any, any, any, any, any>
+    ? TDeps
+    : never;
+
+// Extract services from FragmentDefinition
+// This extracts both base services (flat) and named services (nested)
+// The result matches the structure of fragment.services at runtime
+export type ExtractFragmentServices<T> =
+  T extends FragmentDefinition<
+    any,
+    any,
+    any,
+    infer TBaseServices,
+    infer TServices,
+    any,
+    any,
+    any,
+    any,
+    any
+  >
+    ? BoundServices<TBaseServices & TServices>
+    : never;
+
+// Extract service dependencies from FragmentDefinition
+export type ExtractFragmentServiceDeps<T> =
+  T extends FragmentDefinition<
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer TServiceDependencies,
+    any,
+    any,
+    any,
+    any
+  >
+    ? TServiceDependencies
+    : never;
+
+// Extract service this context from FragmentDefinition (used by services)
+export type ExtractFragmentServiceThisContext<T> =
+  T extends FragmentDefinition<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer TServiceThisContext,
+    any,
+    any
+  >
+    ? TServiceThisContext
+    : RequestThisContext;
+
+// Extract handler this context from FragmentDefinition (used by route handlers)
+export type ExtractFragmentHandlerThisContext<T> =
+  T extends FragmentDefinition<
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer THandlerThisContext,
+    any
+  >
+    ? THandlerThisContext
+    : RequestThisContext;
+
+// Legacy: Extract this context from FragmentDefinition (defaults to service context for backwards compatibility)
+export type ExtractFragmentThisContext<T> = ExtractFragmentServiceThisContext<T>;
+
+// Overload that infers types from FragmentDefinition (runtime value)
+export function defineRoutes<const TDefinition extends AnyFragmentDefinition>(
+  definition: TDefinition,
+): {
+  create: <
+    const TRoutes extends readonly FragnoRouteConfig<
+      HTTPMethod,
+      string,
+      StandardSchemaV1 | undefined,
+      StandardSchemaV1 | undefined,
+      string,
+      string,
+      ExtractFragmentHandlerThisContext<TDefinition>
+    >[],
+  >(
+    fn: (
+      context: RouteFactoryContext<
+        ExtractFragmentConfig<TDefinition>,
+        ExtractFragmentDeps<TDefinition>,
+        ExtractFragmentServices<TDefinition>,
+        ExtractFragmentServiceDeps<TDefinition>
+      > & {
+        defineRoute: <
+          const TMethod extends HTTPMethod,
+          const TPath extends string,
+          const TInputSchema extends StandardSchemaV1 | undefined,
+          const TOutputSchema extends StandardSchemaV1 | undefined,
+          const TErrorCode extends string = string,
+          const TQueryParameters extends string = string,
+        >(
+          config: FragnoRouteConfig<
+            TMethod,
+            TPath,
+            TInputSchema,
+            TOutputSchema,
+            TErrorCode,
+            TQueryParameters,
+            ExtractFragmentHandlerThisContext<TDefinition>
+          >,
+        ) => FragnoRouteConfig<
+          TMethod,
+          TPath,
+          TInputSchema,
+          TOutputSchema,
+          TErrorCode,
+          TQueryParameters,
+          ExtractFragmentHandlerThisContext<TDefinition>
+        >;
+      },
+    ) => TRoutes,
+  ) => RouteFactory<
+    ExtractFragmentConfig<TDefinition>,
+    ExtractFragmentDeps<TDefinition>,
+    ExtractFragmentServices<TDefinition>,
+    ExtractFragmentServiceDeps<TDefinition>,
+    TRoutes
+  >;
+};
+
+// Overload that infers types from FragmentDefinition (type parameter only)
+export function defineRoutes<const TDefinition extends AnyFragmentDefinition>(): {
+  create: <
+    const TRoutes extends readonly FragnoRouteConfig<
+      HTTPMethod,
+      string,
+      StandardSchemaV1 | undefined,
+      StandardSchemaV1 | undefined,
+      string,
+      string,
+      ExtractFragmentHandlerThisContext<TDefinition>
+    >[],
+  >(
+    fn: (
+      context: RouteFactoryContext<
+        ExtractFragmentConfig<TDefinition>,
+        ExtractFragmentDeps<TDefinition>,
+        ExtractFragmentServices<TDefinition>,
+        ExtractFragmentServiceDeps<TDefinition>
+      > & {
+        defineRoute: <
+          const TMethod extends HTTPMethod,
+          const TPath extends string,
+          const TInputSchema extends StandardSchemaV1 | undefined,
+          const TOutputSchema extends StandardSchemaV1 | undefined,
+          const TErrorCode extends string = string,
+          const TQueryParameters extends string = string,
+        >(
+          config: FragnoRouteConfig<
+            TMethod,
+            TPath,
+            TInputSchema,
+            TOutputSchema,
+            TErrorCode,
+            TQueryParameters,
+            ExtractFragmentHandlerThisContext<TDefinition>
+          >,
+        ) => FragnoRouteConfig<
+          TMethod,
+          TPath,
+          TInputSchema,
+          TOutputSchema,
+          TErrorCode,
+          TQueryParameters,
+          ExtractFragmentHandlerThisContext<TDefinition>
+        >;
+      },
+    ) => TRoutes,
+  ) => RouteFactory<
+    ExtractFragmentConfig<TDefinition>,
+    ExtractFragmentDeps<TDefinition>,
+    ExtractFragmentServices<TDefinition>,
+    ExtractFragmentServiceDeps<TDefinition>,
+    TRoutes
+  >;
+};
+
+// Implementation
+export function defineRoutes<
+  const TDefinition extends AnyFragmentDefinition | undefined = undefined,
+>(
+  // Parameter is only used for type inference, not runtime
+  _definition?: TDefinition,
+) {
   return {
     create: <
       const TRoutes extends readonly FragnoRouteConfig<
@@ -134,12 +401,66 @@ export function defineRoutes<TConfig = {}, TDeps = {}, TServices = {}>() {
         StandardSchemaV1 | undefined,
         StandardSchemaV1 | undefined,
         string,
-        string
+        string,
+        TDefinition extends AnyFragmentDefinition
+          ? ExtractFragmentThisContext<TDefinition>
+          : RequestThisContext
       >[],
     >(
-      fn: (context: RouteFactoryContext<TConfig, TDeps, TServices>) => TRoutes,
-    ): RouteFactory<TConfig, TDeps, TServices, TRoutes> => {
-      return fn;
+      fn: (
+        context: RouteFactoryContext<
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentConfig<TDefinition> : {},
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentDeps<TDefinition> : {},
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentServices<TDefinition> : {},
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentServiceDeps<TDefinition> : {}
+        > & {
+          defineRoute: <
+            const TMethod extends HTTPMethod,
+            const TPath extends string,
+            const TInputSchema extends StandardSchemaV1 | undefined,
+            const TOutputSchema extends StandardSchemaV1 | undefined,
+            const TErrorCode extends string = string,
+            const TQueryParameters extends string = string,
+          >(
+            config: FragnoRouteConfig<
+              TMethod,
+              TPath,
+              TInputSchema,
+              TOutputSchema,
+              TErrorCode,
+              TQueryParameters,
+              TDefinition extends AnyFragmentDefinition
+                ? ExtractFragmentThisContext<TDefinition>
+                : RequestThisContext
+            >,
+          ) => FragnoRouteConfig<
+            TMethod,
+            TPath,
+            TInputSchema,
+            TOutputSchema,
+            TErrorCode,
+            TQueryParameters,
+            TDefinition extends AnyFragmentDefinition
+              ? ExtractFragmentThisContext<TDefinition>
+              : RequestThisContext
+          >;
+        },
+      ) => TRoutes,
+    ): RouteFactory<
+      TDefinition extends AnyFragmentDefinition ? ExtractFragmentConfig<TDefinition> : {},
+      TDefinition extends AnyFragmentDefinition ? ExtractFragmentDeps<TDefinition> : {},
+      TDefinition extends AnyFragmentDefinition ? ExtractFragmentServices<TDefinition> : {},
+      TDefinition extends AnyFragmentDefinition ? ExtractFragmentServiceDeps<TDefinition> : {},
+      TRoutes
+    > => {
+      // Create a wrapper around the callback that adds the defineRoute function
+      return (ctx: RouteFactoryContext<unknown, unknown, unknown, unknown>) => {
+        const extendedCtx = {
+          ...ctx,
+          defineRoute,
+        };
+        return fn(extendedCtx as any);
+      };
     },
   };
 }

package/src/api/shared-types.ts

@@ -0,0 +1,43 @@
+import type { HTTPMethod } from "./api";
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+
+/**
+ * Public configuration for Fragno fragments on the server side.
+ */
+export interface FragnoPublicConfig {
+  mountRoute?: string;
+}
+
+/**
+ * Configuration for custom fetch behavior in client-side fragments.
+ */
+export type FetcherConfig =
+  | { type: "options"; options: RequestInit }
+  | { type: "function"; fetcher: typeof fetch };
+
+/**
+ * Public configuration for Fragno fragments on the client side.
+ */
+export interface FragnoPublicClientConfig {
+  mountRoute?: string;
+  baseUrl?: string;
+  fetcherConfig?: FetcherConfig;
+}
+
+/**
+ * Shared configuration for fragment routes.
+ */
+export interface FragnoFragmentSharedConfig<
+  TRoutes extends readonly {
+    method: HTTPMethod;
+    path: string;
+    inputSchema?: StandardSchemaV1 | undefined;
+    outputSchema?: StandardSchemaV1 | undefined;
+    errorCodes?: readonly string[];
+    queryParameters?: readonly string[];
+    pathParameters?: readonly string[];
+  }[] = [],
+> {
+  name: string;
+  routes: TRoutes;
+}