@fragno-dev/core 0.1.8 → 0.1.9

package/src/api/route.test.ts

@@ -1,6 +1,6 @@
 import { test, expect, expectTypeOf, describe } from "vitest";
-import { defineRoute, defineRoutes, type ExtractFragmentServices } from "./route";
-import { defineFragment } from "./fragment-builder";
+import { defineRoute, defineRoutes } from "./route";
+import { defineFragment } from "./fragment-definition-builder";
 import { z } from "zod";
 
 describe("defineRoute", () => {
@@ -176,43 +176,18 @@ describe("defineRoute", () => {
   });
 });
 
-describe("ExtractFragmentServices", () => {
-  test("extracts services from fragment with .providesService()", () => {
+// ExtractFragmentServices tests removed - use ExtractFragmentServices instead
+
+describe("defineRoutes", () => {
+  test("defineRoutes extracts services correctly for route factory", () => {
     const fragment = defineFragment<{}>("test-fragment")
-      .withDependencies(() => ({ dep: "value" }))
-      .providesService(({ defineService }) =>
+      .providesBaseService(({ defineService }) =>
         defineService({
           getUserById: async (id: string) => ({ id, name: "John" }),
           createUser: async (name: string) => ({ id: "123", name }),
         }),
-      );
-
-    type Services = ExtractFragmentServices<typeof fragment>;
-
-    expectTypeOf<Services>().toMatchObjectType<{
-      getUserById: (id: string) => Promise<{ id: string; name: string }>;
-      createUser: (name: string) => Promise<{ id: string; name: string }>;
-    }>();
-  });
-
-  test("ExtractFragmentServices returns never for fragment without services", () => {
-    const fragment = defineFragment<{}>("test-fragment").withDependencies(() => ({ dep: "value" }));
-
-    type Services = ExtractFragmentServices<typeof fragment>;
-
-    // Fragment with no services should have empty services object
-    expectTypeOf<Services>().toEqualTypeOf<{}>();
-  });
-});
-
-describe("defineRoutes", () => {
-  test("defineRoutes extracts services correctly for route factory", () => {
-    const fragment = defineFragment<{}>("test-fragment").providesService(({ 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
@@ -248,13 +223,14 @@ describe("defineRoutes", () => {
       .withDependencies(({ config }) => ({
         authClient: { apiKey: config.apiKey },
       }))
-      .providesService(({ deps, defineService }) =>
+      .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

package/src/api/route.ts

@@ -1,25 +1,24 @@
+// oxlint-disable no-explicit-any
+
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { FragnoRouteConfig, HTTPMethod, RequestThisContext } from "./api";
-import type { FragmentDefinition } from "./fragment-builder";
+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, any>;
 
-export type AnyFragmentBuilder = {
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  readonly definition: FragmentDefinition<any, any, 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,
@@ -29,32 +28,39 @@ export type RouteFactory<
     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) {
@@ -162,107 +168,111 @@ export function defineRoute<
   return config;
 }
 
-// Type helpers to extract types from FragmentBuilder or DatabaseFragmentBuilder
-// DatabaseFragmentBuilder has 6 type parameters: TSchema, TConfig, TDeps, TServices, TUsedServices, TProvidedServices
-// FragmentBuilder has 6 type parameters: TConfig, TDeps, TServices, TAdditionalContext, TUsedServices, TProvidedServices
+// ============================================================================
+// Type extractors for FragmentDefinition
+// ============================================================================
 
-// Helper to get the return type of the definition getter
-// Use T['definition'] to access the property type
-type GetDefinition<T> = T extends { definition: unknown } ? T["definition"] : never;
+export type AnyFragmentDefinition = FragmentDefinition<
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
 
-// Extract config
+// Extract config from FragmentDefinition
 export type ExtractFragmentConfig<T> =
-  GetDefinition<T> extends FragmentDefinition<
-    infer TConfig,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  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,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any
   >
-    ? TConfig
+    ? BoundServices<TBaseServices & TServices>
     : never;
 
-// Extract deps
-export type ExtractFragmentDeps<T> =
-  GetDefinition<T> extends FragmentDefinition<
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+// Extract service dependencies from FragmentDefinition
+export type ExtractFragmentServiceDeps<T> =
+  T extends FragmentDefinition<
+    any,
+    any,
+    any,
+    any,
+    any,
+    infer TServiceDependencies,
     any,
-    infer TDeps,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    infer TUsedServices,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any
   >
-    ? TDeps & TUsedServices
+    ? TServiceDependencies
     : never;
 
-// Helper to recursively bind services (removes `this` parameter from methods)
-type OmitThisParameter<T> = T extends (this: infer _This, ...args: infer A) => infer R
-  ? (...args: A) => R
-  : T;
-
-type BoundServicesLocal<T> = {
-  [K in keyof T]: T[K] extends (...args: never[]) => unknown
-    ? OmitThisParameter<T[K]>
-    : T[K] extends Record<string, unknown>
-      ? BoundServicesLocal<T[K]>
-      : T[K];
-};
-
-// Extract services (merges both withServices and providesService)
-// First try to extract from $types if available (for DatabaseFragmentBuilder)
-// Otherwise fall back to extracting from definition
-export type ExtractFragmentServices<T> = T extends {
-  $types: { services: infer S; providedServices: infer P };
-}
-  ? BoundServicesLocal<S & P>
-  : GetDefinition<T> extends FragmentDefinition<
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        any,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        any,
-        infer TServices,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        any,
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        any,
-        infer TProvidedServices
-      >
-    ? TServices & TProvidedServices
-    : 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 the this context type from the fragment builder
-export type ExtractThisContext<T> =
-  GetDefinition<T> extends FragmentDefinition<
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+// Extract handler this context from FragmentDefinition (used by route handlers)
+export type ExtractFragmentHandlerThisContext<T> =
+  T extends FragmentDefinition<
+    any,
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     any,
-    infer TThisContext
+    any,
+    infer THandlerThisContext,
+    any
   >
-    ? TThisContext
+    ? THandlerThisContext
     : RequestThisContext;
 
-// Overload that infers types from FragmentBuilder or DatabaseFragmentBuilder (runtime value)
-export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
-  fragmentBuilder: TFragmentBuilder,
+// 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<
@@ -272,14 +282,15 @@ export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
       StandardSchemaV1 | undefined,
       string,
       string,
-      ExtractThisContext<TFragmentBuilder>
+      ExtractFragmentHandlerThisContext<TDefinition>
     >[],
   >(
     fn: (
       context: RouteFactoryContext<
-        ExtractFragmentConfig<TFragmentBuilder>,
-        ExtractFragmentDeps<TFragmentBuilder>,
-        ExtractFragmentServices<TFragmentBuilder>
+        ExtractFragmentConfig<TDefinition>,
+        ExtractFragmentDeps<TDefinition>,
+        ExtractFragmentServices<TDefinition>,
+        ExtractFragmentServiceDeps<TDefinition>
       > & {
         defineRoute: <
           const TMethod extends HTTPMethod,
@@ -296,7 +307,7 @@ export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
             TOutputSchema,
             TErrorCode,
             TQueryParameters,
-            ExtractThisContext<TFragmentBuilder>
+            ExtractFragmentHandlerThisContext<TDefinition>
           >,
         ) => FragnoRouteConfig<
           TMethod,
@@ -305,20 +316,21 @@ export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
           TOutputSchema,
           TErrorCode,
           TQueryParameters,
-          ExtractThisContext<TFragmentBuilder>
+          ExtractFragmentHandlerThisContext<TDefinition>
         >;
       },
     ) => TRoutes,
   ) => RouteFactory<
-    ExtractFragmentConfig<TFragmentBuilder>,
-    ExtractFragmentDeps<TFragmentBuilder>,
-    ExtractFragmentServices<TFragmentBuilder>,
+    ExtractFragmentConfig<TDefinition>,
+    ExtractFragmentDeps<TDefinition>,
+    ExtractFragmentServices<TDefinition>,
+    ExtractFragmentServiceDeps<TDefinition>,
     TRoutes
   >;
 };
 
-// Overload that infers types from FragmentBuilder or DatabaseFragmentBuilder (type parameter)
-export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(): {
+// Overload that infers types from FragmentDefinition (type parameter only)
+export function defineRoutes<const TDefinition extends AnyFragmentDefinition>(): {
   create: <
     const TRoutes extends readonly FragnoRouteConfig<
       HTTPMethod,
@@ -327,14 +339,15 @@ export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
       StandardSchemaV1 | undefined,
       string,
       string,
-      ExtractThisContext<TFragmentBuilder>
+      ExtractFragmentHandlerThisContext<TDefinition>
     >[],
   >(
     fn: (
       context: RouteFactoryContext<
-        ExtractFragmentConfig<TFragmentBuilder>,
-        ExtractFragmentDeps<TFragmentBuilder>,
-        ExtractFragmentServices<TFragmentBuilder>
+        ExtractFragmentConfig<TDefinition>,
+        ExtractFragmentDeps<TDefinition>,
+        ExtractFragmentServices<TDefinition>,
+        ExtractFragmentServiceDeps<TDefinition>
       > & {
         defineRoute: <
           const TMethod extends HTTPMethod,
@@ -351,7 +364,7 @@ export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
             TOutputSchema,
             TErrorCode,
             TQueryParameters,
-            ExtractThisContext<TFragmentBuilder>
+            ExtractFragmentHandlerThisContext<TDefinition>
           >,
         ) => FragnoRouteConfig<
           TMethod,
@@ -360,48 +373,25 @@ export function defineRoutes<const TFragmentBuilder extends AnyFragmentBuilder>(
           TOutputSchema,
           TErrorCode,
           TQueryParameters,
-          ExtractThisContext<TFragmentBuilder>
+          ExtractFragmentHandlerThisContext<TDefinition>
         >;
       },
     ) => TRoutes,
   ) => RouteFactory<
-    ExtractFragmentConfig<TFragmentBuilder>,
-    ExtractFragmentDeps<TFragmentBuilder>,
-    ExtractFragmentServices<TFragmentBuilder>,
+    ExtractFragmentConfig<TDefinition>,
+    ExtractFragmentDeps<TDefinition>,
+    ExtractFragmentServices<TDefinition>,
+    ExtractFragmentServiceDeps<TDefinition>,
     TRoutes
   >;
 };
 
-// Overload that accepts manual type parameters
-export function defineRoutes<TConfig = {}, TDeps = {}, TServices = {}>(): {
-  create: <
-    const TRoutes extends readonly FragnoRouteConfig<
-      HTTPMethod,
-      string,
-      StandardSchemaV1 | undefined,
-      StandardSchemaV1 | undefined,
-      string,
-      string,
-      RequestThisContext
-    >[],
-  >(
-    fn: (
-      context: RouteFactoryContext<TConfig, TDeps, TServices> & {
-        defineRoute: typeof defineRoute;
-      },
-    ) => TRoutes,
-  ) => RouteFactory<TConfig, TDeps, TServices, TRoutes>;
-};
-
 // Implementation
 export function defineRoutes<
-  const TConfig = {},
-  const TDeps = {},
-  const TServices = {},
-  const TFragmentBuilder extends AnyFragmentBuilder | undefined = undefined,
+  const TDefinition extends AnyFragmentDefinition | undefined = undefined,
 >(
   // Parameter is only used for type inference, not runtime
-  _fragmentBuilder?: TFragmentBuilder,
+  _definition?: TDefinition,
 ) {
   return {
     create: <
@@ -412,41 +402,63 @@ export function defineRoutes<
         StandardSchemaV1 | undefined,
         string,
         string,
-        RequestThisContext
+        TDefinition extends AnyFragmentDefinition
+          ? ExtractFragmentThisContext<TDefinition>
+          : RequestThisContext
       >[],
     >(
       fn: (
         context: RouteFactoryContext<
-          TFragmentBuilder extends AnyFragmentBuilder
-            ? ExtractFragmentConfig<TFragmentBuilder>
-            : TConfig,
-          TFragmentBuilder extends AnyFragmentBuilder
-            ? ExtractFragmentDeps<TFragmentBuilder>
-            : TDeps,
-          TFragmentBuilder extends AnyFragmentBuilder
-            ? ExtractFragmentServices<TFragmentBuilder>
-            : TServices
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentConfig<TDefinition> : {},
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentDeps<TDefinition> : {},
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentServices<TDefinition> : {},
+          TDefinition extends AnyFragmentDefinition ? ExtractFragmentServiceDeps<TDefinition> : {}
         > & {
-          defineRoute: typeof defineRoute;
+          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<
-      TFragmentBuilder extends AnyFragmentBuilder
-        ? ExtractFragmentConfig<TFragmentBuilder>
-        : TConfig,
-      TFragmentBuilder extends AnyFragmentBuilder ? ExtractFragmentDeps<TFragmentBuilder> : TDeps,
-      TFragmentBuilder extends AnyFragmentBuilder
-        ? ExtractFragmentServices<TFragmentBuilder>
-        : TServices,
+      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>) => {
+      return (ctx: RouteFactoryContext<unknown, unknown, unknown, unknown>) => {
         const extendedCtx = {
           ...ctx,
           defineRoute,
         };
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         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;
+}