@controller-contract/server 0.2.6 → 0.3.0

package/dist/index.d.mts

@@ -1,24 +1,29 @@
-import { ControllerContractProduct, ExitOutput, FailOutput, InputChannel, Method, NextOutput, NoInput, Output, ParamsFrom, PassOutput } from "@controller-contract/core";
+import { ControllerContract, ExitOutput, FailOutput, InputChannel, Method, NextOutput, NoInput, Output, ParamsFrom, PassOutput } from "@controller-contract/core";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
+//#region src/classes/controller-contract-controller/controller-contract-controller.d.ts
+type ControllerContractController<TMethod extends Method, TPath extends string, TParamsInput, TQueryInput, TBodyInput, TOuput extends Output, TRouter> = (() => TRouter) & {
+  '~cc'?: TMethod | TPath | TParamsInput | TQueryInput | TBodyInput | TOuput;
+};
+//#endregion
 //#region src/interfaces/ControllerContractSpec.d.ts
-interface NullaryControllerContractSpec<TContext, TInject> {
+interface NullaryControllerContractSpec<TFrameworkContext, TInject> {
   readonly type: 'nullary';
   readonly injectable: TInject;
   readonly method: Method;
   readonly path: string;
-  readonly outputFn: OutputFn<TContext, string, Output>;
+  readonly outputFn: OutputFn<TFrameworkContext, string, Output>;
 }
-interface SanitizedControllerContractSpec<TContext, TInject> {
+interface SanitizedControllerContractSpec<TFrameworkContext, TInject> {
   readonly type: 'sanitized';
   readonly injectable: TInject;
   readonly method: Method;
   readonly path: string;
   readonly channel: InputChannel;
   readonly schema: StandardSchemaV1;
-  readonly outputFn: SanitizedOutputFn<TContext, string, unknown, Output>;
+  readonly outputFn: SanitizedOutputFn<TFrameworkContext, string, unknown, Output>;
 }
-type ControllerContractSpec<TContext, TInject> = NullaryControllerContractSpec<TContext, TInject> | SanitizedControllerContractSpec<TContext, TInject>;
+type ControllerContractSpec<TFrameworkContext, TInject> = NullaryControllerContractSpec<TFrameworkContext, TInject> | SanitizedControllerContractSpec<TFrameworkContext, TInject>;
 //#endregion
 //#region src/utils/outputs.d.ts
 declare namespace outputs {
@@ -53,68 +58,81 @@ declare const StandardOutputs: Readonly<{
 }>;
 //#endregion
 //#region src/types/index.d.ts
-type IntegratorFn<TContext, TInject, TProduct> = (spec: ControllerContractSpec<TContext, TInject>) => TProduct;
-type RouterAdapterFn<TProduct> = (routes: Record<string, TProduct>) => TProduct;
+type BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter> = (spec: ControllerContractSpec<TFrameworkContext, TFrameworkInject>) => TFrameworkRouter;
+type RouterIntegratorFn<TRouter> = <TRoutes extends Record<any, ControllerContractController<any, any, any, any, any, any, TRouter>>>(routes: TRoutes) => TRouter;
 type Prettify<T> = { [K in keyof T]: T[K] } & {};
-type OutputFn<TContext, TPath extends string, TOutput> = (context: Prettify<TContext & {
+type OutputFn<TFrameworkContext, TPath extends string, TOutput> = (context: Prettify<TFrameworkContext & {
   params: ParamsFrom<TPath>;
   outputs: typeof outputs;
 }>) => Promise<TOutput>;
-type SanitizedOutputFn<TContext, TPath extends string, TInput, TOutput> = OutputFn<TContext & {
+type SanitizedOutputFn<TFrameworkContext, TPath extends string, TInput, TOutput> = OutputFn<TFrameworkContext & {
   input: TInput;
 }, TPath, TOutput>;
+type InferControllerContract<T> = T extends ControllerContractController<infer M, infer P, any, infer Q, infer B, infer O, any> ? ControllerContract<M, P, ParamsFrom<P>, Q, B, O> : never;
+type MapToControllerContract<TRoutes> = { [TRouteName in Extract<keyof TRoutes, string> as Capitalize<TRouteName>]: InferControllerContract<TRoutes[TRouteName]> };
 //#endregion
-//#region src/classes/PostInputStep.d.ts
-declare class PostInputStep<TContext, TInject, TProduct, const TMethod extends Method, const TPath extends string, const TChannel extends InputChannel, TInput, TOutputFromInput extends Output> {
+//#region src/classes/controller-contract-controller-builder/builder-steps/post-input-step.d.ts
+declare class PostInputStep<TFrameworkContext, TFrameworkInject, TRouter, const TMethod extends Method, const TPath extends string, const TChannel extends InputChannel, TInput, TOutputFromInput extends Output> {
   private readonly injectable;
   private readonly integrator;
   private readonly method;
   private readonly path;
   private readonly channel;
   private readonly schema;
-  constructor(injectable: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>, method: TMethod, path: TPath, channel: TChannel, schema: StandardSchemaV1<TInput>);
-  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TContext, TPath, TInput, TOutput>): ControllerContractProduct<TMethod, TPath, ParamsFrom<TPath>, TChannel extends "query" ? TInput : NoInput, TChannel extends "body" ? TInput : NoInput, TOutputFromInput | TOutput, TProduct>;
+  constructor(injectable: TFrameworkInject, integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TRouter>, method: TMethod, path: TPath, channel: TChannel, schema: StandardSchemaV1<TInput>);
+  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TFrameworkContext, TPath, TInput, TOutput>): ControllerContractController<TMethod, TPath, ParamsFrom<TPath>, TChannel extends "query" ? TInput : NoInput, TChannel extends "body" ? TInput : NoInput, TOutputFromInput | TOutput, TRouter>;
 }
 //#endregion
-//#region src/classes/PostEndpointStep.d.ts
-declare class PostEndpointStep<TContext, TInject, TProduct, const TMethod extends Method, const TPath extends string> {
+//#region src/classes/controller-contract-controller-builder/builder-steps/post-endpoint-step.d.ts
+declare class PostEndpointStep<TFrameworkContext, TFrameworkInject, TRouter, const TMethod extends Method, const TPath extends string> {
   private readonly injectable;
   private readonly integrator;
   private readonly method;
   private readonly path;
-  constructor(injectable: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>, method: TMethod, path: TPath);
-  input<const TChannel extends InputChannel, TInput>(channel: TChannel, schema: StandardSchemaV1<TInput>): PostInputStep<TContext, TInject, TProduct, TMethod, TPath, TChannel, TInput, FailOutput<Extract<keyof TInput, string>>>;
-  output<TOutput extends Output>(outputFn: OutputFn<TContext, TPath, TOutput>): ControllerContractProduct<TMethod, TPath, ParamsFrom<TPath>, NoInput, NoInput, TOutput, TProduct>;
+  constructor(injectable: TFrameworkInject, integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TRouter>, method: TMethod, path: TPath);
+  input<const TChannel extends InputChannel, TInput>(channel: TChannel, schema: StandardSchemaV1<TInput>): PostInputStep<TFrameworkContext, TFrameworkInject, TRouter, TMethod, TPath, TChannel, TInput, FailOutput<Extract<keyof TInput, string>>>;
+  output<TOutput extends Output>(outputFn: OutputFn<TFrameworkContext, TPath, TOutput>): ControllerContractController<TMethod, TPath, ParamsFrom<TPath>, NoInput, NoInput, TOutput, TRouter>;
 }
 //#endregion
-//#region src/classes/PostInjectStep.d.ts
-declare class PostInjectStep<TContext, TInject, TProduct> {
+//#region src/classes/controller-contract-controller-builder/builder-steps/post-inject-step.d.ts
+declare class PostInjectStep<TFrameworkContext, TFrameworkInject, TRouter> {
   private readonly injectable;
   private readonly integrator;
-  constructor(injectable: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>);
-  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath): PostEndpointStep<TContext, TInject, TProduct, TMethod, TPath>;
+  constructor(injectable: TFrameworkInject, integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TRouter>);
+  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath): PostEndpointStep<TFrameworkContext, TFrameworkInject, TRouter, TMethod, TPath>;
 }
 //#endregion
-//#region src/classes/ControllerContractBuilder.d.ts
-declare class ControllerContractBuilder<TContext, TInject, TProduct> {
+//#region src/classes/controller-contract-controller-builder/controller-contract-controller-builder.d.ts
+declare class ControllerContractControllerBuilder<TFrameworkContext, TFrameworkInject, TFrameworkRouter> {
   private readonly injectableDefaultValue;
   private readonly integrator;
-  constructor(injectableDefaultValue: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>);
-  inject(injectable: TInject): PostInjectStep<TContext, TInject, TProduct>;
-  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath): PostEndpointStep<TContext, TInject, TProduct, TMethod, TPath>;
+  constructor(injectableDefaultValue: TFrameworkInject, integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter>);
+  inject(injectable: TFrameworkInject): PostInjectStep<TFrameworkContext, TFrameworkInject, TFrameworkRouter>;
+  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath): PostEndpointStep<TFrameworkContext, TFrameworkInject, TFrameworkRouter, TMethod, TPath>;
+}
+//#endregion
+//#region src/classes/controller-contract-controller-router/controller-contract-controller-router.d.ts
+declare class ControllerContractControllerRouter<TRouter, TRoutes extends Record<any, ControllerContractController<any, any, any, any, any, any, TRouter>>> {
+  private readonly integrator;
+  private readonly routes;
+  constructor(integrator: RouterIntegratorFn<TRouter>, routes: TRoutes);
+  getIntegratedRouter(): TRouter;
 }
 //#endregion
-//#region src/classes/ControllerContractRouter.d.ts
-declare class ControllerContractRouter<TProduct> {
-  private readonly routerAdapterFn;
-  constructor(routerAdapterFn: RouterAdapterFn<TProduct>);
-  getRouter(routes: Record<string, TProduct>): TProduct;
+//#region src/classes/controller-contract-controller-router/controller-contract-controller-router-factory.d.ts
+declare class ControllerContractControllerRouterFactory<TRouter> {
+  private readonly integrator;
+  constructor(integrator: RouterIntegratorFn<TRouter>);
+  createControllerContractControllerRouter<TRoutes extends Record<any, ControllerContractController<any, any, any, any, any, any, TRouter>>>(routes: TRoutes): ControllerContractControllerRouter<TRouter, TRoutes>;
 }
 //#endregion
-//#region src/classes/ControllerContractAdapterFactory.d.ts
-declare class ControllerContractAdapterFactory<TContext, TInject, TProduct> {
-  createBuilder(injectableDefaultValue: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>): ControllerContractBuilder<TContext, TInject, TProduct>;
-  createRouter(routerAdapterFn: RouterAdapterFn<TProduct>): ControllerContractRouter<TProduct>;
+//#region src/classes/framework-integration-factory.d.ts
+declare class FrameworkIntegrationFactory<TFrameworkContext, TFrameworkInject, TFrameworkRouter> {
+  createControllerContractControllerBuilder(injectableDefaultValue: TFrameworkInject, integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter>): ControllerContractControllerBuilder<TFrameworkContext, TFrameworkInject, TFrameworkRouter>;
+  createControllerContractControllerRouterFactory(integrator: RouterIntegratorFn<TFrameworkRouter>): ControllerContractControllerRouterFactory<TFrameworkRouter>;
 }
 //#endregion
-export { ControllerContractAdapterFactory, StandardOutputs, outputs, rootOnly };
+//#region src/types/infer-controller-contracts-from-router.d.ts
+type InferControllerContractsFromRouter<T> = T extends ControllerContractControllerRouter<any, infer TRoutes> ? MapToControllerContract<TRoutes> : never;
+//#endregion
+export { FrameworkIntegrationFactory, InferControllerContractsFromRouter, StandardOutputs, outputs, rootOnly };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-//#region src/classes/PostInputStep.ts
+//#region src/classes/controller-contract-controller-builder/builder-steps/post-input-step.ts
 var PostInputStep = class {
 	injectable;
 	integrator;
@@ -15,7 +15,7 @@ var PostInputStep = class {
 		this.schema = schema;
 	}
 	output(outputFn) {
-		this.integrator({
+		const product = this.integrator({
 			type: "sanitized",
 			injectable: this.injectable,
 			method: this.method,
@@ -24,11 +24,11 @@ var PostInputStep = class {
 			schema: this.schema,
 			outputFn
 		});
-		return {};
+		return (() => product);
 	}
 };
 //#endregion
-//#region src/classes/PostEndpointStep.ts
+//#region src/classes/controller-contract-controller-builder/builder-steps/post-endpoint-step.ts
 var PostEndpointStep = class {
 	injectable;
 	integrator;
@@ -44,18 +44,18 @@ var PostEndpointStep = class {
 		return new PostInputStep(this.injectable, this.integrator, this.method, this.path, channel, schema);
 	}
 	output(outputFn) {
-		this.integrator({
+		const product = this.integrator({
 			type: "nullary",
 			method: this.method,
 			path: this.path,
 			injectable: this.injectable,
 			outputFn
 		});
-		return {};
+		return (() => product);
 	}
 };
 //#endregion
-//#region src/classes/PostInjectStep.ts
+//#region src/classes/controller-contract-controller-builder/builder-steps/post-inject-step.ts
 var PostInjectStep = class {
 	injectable;
 	integrator;
@@ -68,8 +68,8 @@ var PostInjectStep = class {
 	}
 };
 //#endregion
-//#region src/classes/ControllerContractBuilder.ts
-var ControllerContractBuilder = class {
+//#region src/classes/controller-contract-controller-builder/controller-contract-controller-builder.ts
+var ControllerContractControllerBuilder = class {
 	injectableDefaultValue;
 	integrator;
 	constructor(injectableDefaultValue, integrator) {
@@ -84,24 +84,37 @@ var ControllerContractBuilder = class {
 	}
 };
 //#endregion
-//#region src/classes/ControllerContractRouter.ts
-var ControllerContractRouter = class {
-	routerAdapterFn;
-	constructor(routerAdapterFn) {
-		this.routerAdapterFn = routerAdapterFn;
+//#region src/classes/controller-contract-controller-router/controller-contract-controller-router.ts
+var ControllerContractControllerRouter = class {
+	integrator;
+	routes;
+	constructor(integrator, routes) {
+		this.integrator = integrator;
+		this.routes = routes;
+	}
+	getIntegratedRouter() {
+		return this.integrator(this.routes);
+	}
+};
+//#endregion
+//#region src/classes/controller-contract-controller-router/controller-contract-controller-router-factory.ts
+var ControllerContractControllerRouterFactory = class {
+	integrator;
+	constructor(integrator) {
+		this.integrator = integrator;
 	}
-	getRouter(routes) {
-		return this.routerAdapterFn(routes);
+	createControllerContractControllerRouter(routes) {
+		return new ControllerContractControllerRouter(this.integrator, routes);
 	}
 };
 //#endregion
-//#region src/classes/ControllerContractAdapterFactory.ts
-var ControllerContractAdapterFactory = class {
-	createBuilder(injectableDefaultValue, integrator) {
-		return new ControllerContractBuilder(injectableDefaultValue, integrator);
+//#region src/classes/framework-integration-factory.ts
+var FrameworkIntegrationFactory = class {
+	createControllerContractControllerBuilder(injectableDefaultValue, integrator) {
+		return new ControllerContractControllerBuilder(injectableDefaultValue, integrator);
 	}
-	createRouter(routerAdapterFn) {
-		return new ControllerContractRouter(routerAdapterFn);
+	createControllerContractControllerRouterFactory(integrator) {
+		return new ControllerContractControllerRouterFactory(integrator);
 	}
 };
 //#endregion
@@ -155,4 +168,4 @@ const StandardOutputs = Object.freeze({
 	BadGateway: outputs.fail(rootOnly("Bad Gateway"), 502)
 });
 //#endregion
-export { ControllerContractAdapterFactory, StandardOutputs, outputs, rootOnly };
+export { FrameworkIntegrationFactory, StandardOutputs, outputs, rootOnly };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@controller-contract/server",
   "type": "module",
-  "version": "0.2.6",
+  "version": "0.3.0",
   "author": "kennychulo",
   "license": "MIT",
   "files": [

package/src/classes/controller-contract-controller/controller-contract-controller.ts

@@ -0,0 +1,14 @@
+import type { Method, Output } from '@controller-contract/core';
+
+export type ControllerContractController<
+  TMethod extends Method,
+  TPath extends string,
+  TParamsInput,
+  TQueryInput,
+  TBodyInput,
+  TOuput extends Output,
+  TRouter,
+> = (() => TRouter) & {
+  // Suppresses the linter warning about unused variables
+  '~cc'?: TMethod | TPath | TParamsInput | TQueryInput | TBodyInput | TOuput;
+};

package/src/classes/controller-contract-controller-builder/builder-steps/post-endpoint-step.ts

@@ -0,0 +1,48 @@
+import type { FailOutput, InputChannel, Method, NoInput, Output, ParamsFrom } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { NullaryControllerContractSpec } from '../../../interfaces/ControllerContractSpec';
+import type { BuilderIntegratorFn, OutputFn } from '../../../types';
+import type { ControllerContractController } from '../../controller-contract-controller/controller-contract-controller';
+import { PostInputStep } from './post-input-step';
+
+export class PostEndpointStep<
+  TFrameworkContext,
+  TFrameworkInject,
+  TRouter,
+  const TMethod extends Method,
+  const TPath extends string,
+> {
+  constructor(
+    private readonly injectable: TFrameworkInject,
+    private readonly integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TRouter>,
+    private readonly method: TMethod,
+    private readonly path: TPath,
+  ) {}
+
+  input<const TChannel extends InputChannel, TInput>(channel: TChannel, schema: StandardSchemaV1<TInput>) {
+    return new PostInputStep<
+      TFrameworkContext,
+      TFrameworkInject,
+      TRouter,
+      TMethod,
+      TPath,
+      TChannel,
+      TInput,
+      FailOutput<Extract<keyof TInput, string>>
+    >(this.injectable, this.integrator, this.method, this.path, channel, schema);
+  }
+
+  output<TOutput extends Output>(outputFn: OutputFn<TFrameworkContext, TPath, TOutput>) {
+    const product = this.integrator(<NullaryControllerContractSpec<TFrameworkContext, TFrameworkInject>>{
+      type: 'nullary',
+      method: this.method,
+      path: this.path,
+      injectable: this.injectable,
+      outputFn,
+    });
+
+    return <ControllerContractController<TMethod, TPath, ParamsFrom<TPath>, NoInput, NoInput, TOutput, TRouter>>(
+      (() => product)
+    );
+  }
+}

package/src/classes/controller-contract-controller-builder/builder-steps/post-inject-step.ts

@@ -0,0 +1,19 @@
+import type { Method } from '@controller-contract/core';
+import type { BuilderIntegratorFn } from '../../../types';
+import { PostEndpointStep } from './post-endpoint-step';
+
+export class PostInjectStep<TFrameworkContext, TFrameworkInject, TRouter> {
+  constructor(
+    private readonly injectable: TFrameworkInject,
+    private readonly integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TRouter>,
+  ) {}
+
+  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath) {
+    return new PostEndpointStep<TFrameworkContext, TFrameworkInject, TRouter, TMethod, TPath>(
+      this.injectable,
+      this.integrator,
+      method,
+      path,
+    );
+  }
+}

package/src/classes/{PostInputStep.ts → controller-contract-controller-builder/builder-steps/post-input-step.ts}

@@ -1,19 +1,13 @@
-import type {
-  ControllerContractProduct,
-  InputChannel,
-  Method,
-  NoInput,
-  Output,
-  ParamsFrom,
-} from '@controller-contract/core';
+import type { InputChannel, Method, NoInput, Output, ParamsFrom } from '@controller-contract/core';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { SanitizedControllerContractSpec } from '../interfaces/ControllerContractSpec';
-import type { IntegratorFn, SanitizedOutputFn } from '../types';
+import type { SanitizedControllerContractSpec } from '../../../interfaces/ControllerContractSpec';
+import type { BuilderIntegratorFn, SanitizedOutputFn } from '../../../types';
+import type { ControllerContractController } from '../../controller-contract-controller/controller-contract-controller';
 
 export class PostInputStep<
-  TContext,
-  TInject,
-  TProduct,
+  TFrameworkContext,
+  TFrameworkInject,
+  TRouter,
   const TMethod extends Method,
   const TPath extends string,
   const TChannel extends InputChannel,
@@ -21,16 +15,16 @@ export class PostInputStep<
   TOutputFromInput extends Output,
 > {
   constructor(
-    private readonly injectable: TInject,
-    private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
+    private readonly injectable: TFrameworkInject,
+    private readonly integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TRouter>,
     private readonly method: TMethod,
     private readonly path: TPath,
     private readonly channel: TChannel,
     private readonly schema: StandardSchemaV1<TInput>,
   ) {}
 
-  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TContext, TPath, TInput, TOutput>) {
-    const product = this.integrator(<SanitizedControllerContractSpec<TContext, TInject>>{
+  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TFrameworkContext, TPath, TInput, TOutput>) {
+    const product = this.integrator(<SanitizedControllerContractSpec<TFrameworkContext, TFrameworkInject>>{
       type: 'sanitized',
       injectable: this.injectable,
       method: this.method,
@@ -41,15 +35,15 @@ export class PostInputStep<
     });
 
     return <
-      ControllerContractProduct<
+      ControllerContractController<
         TMethod,
         TPath,
         ParamsFrom<TPath>,
         TChannel extends 'query' ? TInput : NoInput,
         TChannel extends 'body' ? TInput : NoInput,
         TOutputFromInput | TOutput,
-        TProduct
+        TRouter
       >
-    >{ ...() => product };
+    >(() => product);
   }
 }

package/src/classes/controller-contract-controller-builder/controller-contract-controller-builder.ts

@@ -0,0 +1,24 @@
+import type { Method } from '@controller-contract/core';
+import type { BuilderIntegratorFn } from '../../types';
+import { PostEndpointStep } from './builder-steps/post-endpoint-step';
+import { PostInjectStep } from './builder-steps/post-inject-step';
+
+export class ControllerContractControllerBuilder<TFrameworkContext, TFrameworkInject, TFrameworkRouter> {
+  constructor(
+    private readonly injectableDefaultValue: TFrameworkInject,
+    private readonly integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter>,
+  ) {}
+
+  inject(injectable: TFrameworkInject) {
+    return new PostInjectStep<TFrameworkContext, TFrameworkInject, TFrameworkRouter>(injectable, this.integrator);
+  }
+
+  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath) {
+    return new PostEndpointStep<TFrameworkContext, TFrameworkInject, TFrameworkRouter, TMethod, TPath>(
+      this.injectableDefaultValue,
+      this.integrator,
+      method,
+      path,
+    );
+  }
+}

package/src/classes/controller-contract-controller-router/controller-contract-controller-router-factory.ts

@@ -0,0 +1,13 @@
+import type { RouterIntegratorFn } from '../../types';
+import type { ControllerContractController } from '../controller-contract-controller/controller-contract-controller';
+import { ControllerContractControllerRouter } from './controller-contract-controller-router';
+
+export class ControllerContractControllerRouterFactory<TRouter> {
+  constructor(private readonly integrator: RouterIntegratorFn<TRouter>) {}
+
+  createControllerContractControllerRouter<
+    TRoutes extends Record<any, ControllerContractController<any, any, any, any, any, any, TRouter>>,
+  >(routes: TRoutes) {
+    return new ControllerContractControllerRouter(this.integrator, routes);
+  }
+}

package/src/classes/controller-contract-controller-router/controller-contract-controller-router.ts

@@ -0,0 +1,16 @@
+import type { RouterIntegratorFn } from '../../types';
+import type { ControllerContractController } from '../controller-contract-controller/controller-contract-controller';
+
+export class ControllerContractControllerRouter<
+  TRouter,
+  TRoutes extends Record<any, ControllerContractController<any, any, any, any, any, any, TRouter>>,
+> {
+  constructor(
+    private readonly integrator: RouterIntegratorFn<TRouter>,
+    private readonly routes: TRoutes,
+  ) {}
+
+  getIntegratedRouter(): TRouter {
+    return this.integrator(this.routes);
+  }
+}

package/src/classes/framework-integration-factory.ts

@@ -0,0 +1,19 @@
+import type { BuilderIntegratorFn, RouterIntegratorFn } from '../types';
+import { ControllerContractControllerBuilder } from './controller-contract-controller-builder/controller-contract-controller-builder';
+import { ControllerContractControllerRouterFactory } from './controller-contract-controller-router/controller-contract-controller-router-factory';
+
+export class FrameworkIntegrationFactory<TFrameworkContext, TFrameworkInject, TFrameworkRouter> {
+  createControllerContractControllerBuilder(
+    injectableDefaultValue: TFrameworkInject,
+    integrator: BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter>,
+  ) {
+    return new ControllerContractControllerBuilder<TFrameworkContext, TFrameworkInject, TFrameworkRouter>(
+      injectableDefaultValue,
+      integrator,
+    );
+  }
+
+  createControllerContractControllerRouterFactory(integrator: RouterIntegratorFn<TFrameworkRouter>) {
+    return new ControllerContractControllerRouterFactory<TFrameworkRouter>(integrator);
+  }
+}

package/src/index.ts

@@ -1,2 +1,3 @@
-export * from './classes/ControllerContractAdapterFactory';
+export * from './classes/framework-integration-factory';
+export * from './types/infer-controller-contracts-from-router';
 export * from './utils';

package/src/interfaces/ControllerContractSpec.ts

@@ -2,24 +2,24 @@ import type { InputChannel, Method, Output } from '@controller-contract/core';
 import type { StandardSchemaV1 } from '@standard-schema/spec';
 import type { OutputFn, SanitizedOutputFn } from '../types';
 
-export interface NullaryControllerContractSpec<TContext, TInject> {
+export interface NullaryControllerContractSpec<TFrameworkContext, TInject> {
   readonly type: 'nullary';
   readonly injectable: TInject;
   readonly method: Method;
   readonly path: string;
-  readonly outputFn: OutputFn<TContext, string, Output>;
+  readonly outputFn: OutputFn<TFrameworkContext, string, Output>;
 }
 
-export interface SanitizedControllerContractSpec<TContext, TInject> {
+export interface SanitizedControllerContractSpec<TFrameworkContext, TInject> {
   readonly type: 'sanitized';
   readonly injectable: TInject;
   readonly method: Method;
   readonly path: string;
   readonly channel: InputChannel;
   readonly schema: StandardSchemaV1;
-  readonly outputFn: SanitizedOutputFn<TContext, string, unknown, Output>;
+  readonly outputFn: SanitizedOutputFn<TFrameworkContext, string, unknown, Output>;
 }
 
-export type ControllerContractSpec<TContext, TInject> =
-  | NullaryControllerContractSpec<TContext, TInject>
-  | SanitizedControllerContractSpec<TContext, TInject>;
+export type ControllerContractSpec<TFrameworkContext, TInject> =
+  | NullaryControllerContractSpec<TFrameworkContext, TInject>
+  | SanitizedControllerContractSpec<TFrameworkContext, TInject>;

package/src/types/index.ts

@@ -1,26 +1,44 @@
-import type { ParamsFrom } from '@controller-contract/core';
+import type { ControllerContract, ParamsFrom } from '@controller-contract/core';
+import type { ControllerContractController } from '../classes/controller-contract-controller/controller-contract-controller';
 import type { ControllerContractSpec } from '../interfaces/ControllerContractSpec';
 import type { outputs } from '../utils';
 
-export type IntegratorFn<TContext, TInject, TProduct> = (spec: ControllerContractSpec<TContext, TInject>) => TProduct;
+export type BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter> = (
+  spec: ControllerContractSpec<TFrameworkContext, TFrameworkInject>,
+) => TFrameworkRouter;
 
-export type RouterAdapterFn<TProduct> = (routes: Record<string, TProduct>) => TProduct;
+export type RouterIntegratorFn<TRouter> = <
+  TRoutes extends Record<any, ControllerContractController<any, any, any, any, any, any, TRouter>>,
+>(
+  routes: TRoutes,
+) => TRouter;
 
 export type Prettify<T> = {
   [K in keyof T]: T[K];
 } & {};
 
-export type OutputFn<TContext, TPath extends string, TOutput> = (
+export type OutputFn<TFrameworkContext, TPath extends string, TOutput> = (
   context: Prettify<
-    TContext & {
+    TFrameworkContext & {
       params: ParamsFrom<TPath>;
       outputs: typeof outputs;
     }
   >,
 ) => Promise<TOutput>;
 
-export type SanitizedOutputFn<TContext, TPath extends string, TInput, TOutput> = OutputFn<
-  TContext & { input: TInput },
+export type SanitizedOutputFn<TFrameworkContext, TPath extends string, TInput, TOutput> = OutputFn<
+  TFrameworkContext & { input: TInput },
   TPath,
   TOutput
 >;
+
+export type InferControllerContract<T> =
+  T extends ControllerContractController<infer M, infer P, any, infer Q, infer B, infer O, any>
+    ? ControllerContract<M, P, ParamsFrom<P>, Q, B, O>
+    : never;
+
+export type MapToControllerContract<TRoutes> = {
+  [TRouteName in Extract<keyof TRoutes, string> as Capitalize<TRouteName>]: InferControllerContract<
+    TRoutes[TRouteName]
+  >;
+};

package/src/types/infer-controller-contracts-from-router.ts

@@ -0,0 +1,5 @@
+import type { ControllerContractControllerRouter } from '../classes/controller-contract-controller-router/controller-contract-controller-router';
+import type { MapToControllerContract } from './index';
+
+export type InferControllerContractsFromRouter<T> =
+  T extends ControllerContractControllerRouter<any, infer TRoutes> ? MapToControllerContract<TRoutes> : never;

package/src/classes/ControllerContractAdapterFactory.ts

@@ -1,13 +0,0 @@
-import type { IntegratorFn, RouterAdapterFn } from '../types';
-import { ControllerContractBuilder } from './ControllerContractBuilder';
-import { ControllerContractRouter } from './ControllerContractRouter';
-
-export class ControllerContractAdapterFactory<TContext, TInject, TProduct> {
-  createBuilder(injectableDefaultValue: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>) {
-    return new ControllerContractBuilder<TContext, TInject, TProduct>(injectableDefaultValue, integrator);
-  }
-
-  createRouter(routerAdapterFn: RouterAdapterFn<TProduct>) {
-    return new ControllerContractRouter<TProduct>(routerAdapterFn);
-  }
-}

package/src/classes/ControllerContractBuilder.ts

@@ -1,24 +0,0 @@
-import type { Method } from '@controller-contract/core';
-import type { IntegratorFn } from '../types';
-import { PostEndpointStep } from './PostEndpointStep';
-import { PostInjectStep } from './PostInjectStep';
-
-export class ControllerContractBuilder<TContext, TInject, TProduct> {
-  constructor(
-    private readonly injectableDefaultValue: TInject,
-    private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
-  ) {}
-
-  inject(injectable: TInject) {
-    return new PostInjectStep<TContext, TInject, TProduct>(injectable, this.integrator);
-  }
-
-  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath) {
-    return new PostEndpointStep<TContext, TInject, TProduct, TMethod, TPath>(
-      this.injectableDefaultValue,
-      this.integrator,
-      method,
-      path,
-    );
-  }
-}

package/src/classes/ControllerContractRouter.ts

@@ -1,9 +0,0 @@
-import type { RouterAdapterFn } from '../types';
-
-export class ControllerContractRouter<TProduct> {
-  constructor(private readonly routerAdapterFn: RouterAdapterFn<TProduct>) {}
-
-  getRouter(routes: Record<string, TProduct>): TProduct {
-    return this.routerAdapterFn(routes);
-  }
-}

package/src/classes/PostEndpointStep.ts

@@ -1,49 +0,0 @@
-import type {
-  ControllerContractProduct,
-  FailOutput,
-  InputChannel,
-  Method,
-  NoInput,
-  Output,
-  ParamsFrom,
-} from '@controller-contract/core';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { NullaryControllerContractSpec } from '../interfaces/ControllerContractSpec';
-import type { IntegratorFn, OutputFn } from '../types';
-import { PostInputStep } from './PostInputStep';
-
-export class PostEndpointStep<TContext, TInject, TProduct, const TMethod extends Method, const TPath extends string> {
-  constructor(
-    private readonly injectable: TInject,
-    private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
-    private readonly method: TMethod,
-    private readonly path: TPath,
-  ) {}
-
-  input<const TChannel extends InputChannel, TInput>(channel: TChannel, schema: StandardSchemaV1<TInput>) {
-    return new PostInputStep<
-      TContext,
-      TInject,
-      TProduct,
-      TMethod,
-      TPath,
-      TChannel,
-      TInput,
-      FailOutput<Extract<keyof TInput, string>>
-    >(this.injectable, this.integrator, this.method, this.path, channel, schema);
-  }
-
-  output<TOutput extends Output>(outputFn: OutputFn<TContext, TPath, TOutput>) {
-    const product = this.integrator(<NullaryControllerContractSpec<TContext, TInject>>{
-      type: 'nullary',
-      method: this.method,
-      path: this.path,
-      injectable: this.injectable,
-      outputFn,
-    });
-
-    return <ControllerContractProduct<TMethod, TPath, ParamsFrom<TPath>, NoInput, NoInput, TOutput, TProduct>>{
-      ...() => product,
-    };
-  }
-}

package/src/classes/PostInjectStep.ts

@@ -1,19 +0,0 @@
-import type { Method } from '@controller-contract/core';
-import type { IntegratorFn } from '../types';
-import { PostEndpointStep } from './PostEndpointStep';
-
-export class PostInjectStep<TContext, TInject, TProduct> {
-  constructor(
-    private readonly injectable: TInject,
-    private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
-  ) {}
-
-  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath) {
-    return new PostEndpointStep<TContext, TInject, TProduct, TMethod, TPath>(
-      this.injectable,
-      this.integrator,
-      method,
-      path,
-    );
-  }
-}