@controller-contract/server 0.3.3 → 0.4.0

package/src/classes/controller-builder/steps/output-step.ts

@@ -0,0 +1,70 @@
+import type {
+  ExitOutput,
+  FailOutput,
+  Method,
+  PassOutput,
+  PathParams,
+} from '@controller-contract/core';
+
+import type { ControllerBlueprintSchemas } from '../../../interfaces/controller-blueprint';
+import type {
+  CreateRouteFn,
+  FailOutputFrom,
+  OutputFn,
+  Prettify,
+  ResolvedParams,
+} from '../../../types';
+import type { Controller } from '../../../types/controller';
+
+export class OutputStep<
+  TFrameworkContext,
+  TFrameworkInjectable,
+  TFrameworkRouter,
+  const TMethod extends Method,
+  const TPath extends string,
+  TParams,
+  TQuery,
+  TBody,
+> {
+  constructor(
+    private readonly injectable: TFrameworkInjectable,
+    private readonly createRoute: CreateRouteFn<
+      TFrameworkContext,
+      TFrameworkInjectable,
+      TFrameworkRouter
+    >,
+    private readonly method: TMethod,
+    private readonly path: TPath,
+    private readonly schemas: ControllerBlueprintSchemas<TParams, TQuery, TBody>,
+  ) {}
+
+  output<TOutput extends PassOutput<any> | FailOutput<any> | ExitOutput>(
+    outputFn: OutputFn<
+      TFrameworkContext,
+      Prettify<ResolvedParams<TParams, TPath>>,
+      TQuery,
+      TBody,
+      TOutput
+    >,
+  ) {
+    const route = this.createRoute({
+      injectable: this.injectable,
+      method: this.method,
+      path: this.path,
+      schemas: this.schemas,
+      outputFn,
+    });
+
+    return <
+      Controller<
+        TMethod,
+        TPath,
+        Prettify<PathParams<TPath>>,
+        TQuery,
+        TBody,
+        FailOutputFrom<TParams> | FailOutputFrom<TQuery> | FailOutputFrom<TBody> | TOutput,
+        TFrameworkRouter
+      >
+    >(() => route);
+  }
+}

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

@@ -0,0 +1,31 @@
+import type { CombineRoutesFn } from '../types';
+import type { Controller } from '../types/controller';
+import { ControllerRouter } from './controller-router';
+
+type ControllerRouterRecord<TFrameworkRouter> = Record<
+  string,
+  Controller<any, any, any, any, any, any, TFrameworkRouter>
+>;
+
+export class ControllerRouterFactory<TFrameworkRouter> {
+  constructor(private readonly combineRoutes: CombineRoutesFn<TFrameworkRouter>) {}
+
+  /**
+   * @example
+   * const getUser = builder
+   *   .endpoint('get', '/api/users/:id')
+   *   .output(async ({ inputs, outputs }) => outputs.pass({ id: inputs.params.id }));
+   *
+   * const createUser = builder
+   *   .endpoint('post', '/api/users')
+   *   .input((s) => s.body(z.object({ name: z.string() })))
+   *   .output(async ({ inputs, outputs }) => outputs.pass({ name: inputs.body.name }, 201));
+   *
+   * const usersRouter = controllerRouterFactory.createControllerRouter({ getUser, createUser });
+   */
+  createControllerRouter<TRoutes extends ControllerRouterRecord<TFrameworkRouter>>(
+    routes: TRoutes,
+  ) {
+    return new ControllerRouter(this.combineRoutes, routes);
+  }
+}

package/src/classes/controller-router.ts

@@ -0,0 +1,25 @@
+import type { CombineRoutesFn } from '../types';
+import type { Controller } from '../types/controller';
+
+export class ControllerRouter<
+  TFrameworkRouter,
+  TRoutes extends Record<any, Controller<any, any, any, any, any, any, TFrameworkRouter>>,
+> {
+  constructor(
+    private readonly combineRoutes: CombineRoutesFn<TFrameworkRouter>,
+    private readonly routes: TRoutes,
+  ) {}
+
+  /**
+   * @example
+   * const usersRouter = controllerRouterFactory.createControllerRouter({ getUser, createUser });
+   *
+   * const app = express();
+   * app.use(express.json());
+   * app.use(usersRouter.toRouter());
+   * app.listen(3000);
+   */
+  toRouter() {
+    return this.combineRoutes(this.routes);
+  }
+}

package/src/classes/framework-setup.ts

@@ -0,0 +1,28 @@
+import type { CombineRoutesFn, CreateRouteFn } from '../types';
+import { ControllerBuilder } from './controller-builder/controller-builder';
+import { ControllerRouterFactory } from './controller-router-factory';
+
+/**
+ * @example
+ * const setup = new FrameworkSetup<Request, RequestHandler[], Router>();
+ */
+export class FrameworkSetup<TFrameworkContext, TFrameworkInjectable, TFrameworkRouter> {
+  /**
+   * @example
+   * const builder = setup.createControllerBuilder([], (blueprint) => { ... });
+   */
+  createControllerBuilder(
+    defaultInjectable: TFrameworkInjectable,
+    createRoute: CreateRouteFn<TFrameworkContext, TFrameworkInjectable, TFrameworkRouter>,
+  ) {
+    return new ControllerBuilder(defaultInjectable, createRoute);
+  }
+
+  /**
+   * @example
+   * const routerFactory = setup.createControllerRouterFactory((routes) => { ... });
+   */
+  createControllerRouterFactory(combineRoutes: CombineRoutesFn<TFrameworkRouter>) {
+    return new ControllerRouterFactory(combineRoutes);
+  }
+}

package/src/index.ts

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

package/src/interfaces/controller-blueprint.ts

@@ -0,0 +1,34 @@
+import type { ExitOutput, FailOutput, Method, PassOutput } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import type { OutputFnOutputs, Prettify } from '../types';
+
+/**
+ * The true shapes aren't needed at this level. We only need a broad description.
+ */
+export interface ControllerBlueprintSchemas<TParams, TQuery, TBody> {
+  params: StandardSchemaV1<any, TParams> | null;
+  query: StandardSchemaV1<any, TQuery> | null;
+  body: StandardSchemaV1<any, TBody> | null;
+}
+
+type OutputFnBlueprint<TFrameworkContext> = (
+  context: Prettify<
+    TFrameworkContext & {
+      inputs: {
+        params: any;
+        query: any;
+        body: any;
+      };
+      outputs: OutputFnOutputs;
+    }
+  >,
+) => Promise<PassOutput<any> | FailOutput<any> | ExitOutput>;
+
+export interface ControllerBlueprint<TFrameworkContext, TFrameworkInjectable> {
+  readonly injectable: TFrameworkInjectable;
+  readonly method: Method;
+  readonly path: string;
+  readonly schemas: ControllerBlueprintSchemas<unknown, unknown, unknown>;
+  readonly outputFn: OutputFnBlueprint<TFrameworkContext>;
+}

package/src/interfaces/endable.ts

@@ -0,0 +1,5 @@
+import type { ControllerBlueprintSchemas } from './controller-blueprint';
+
+export interface Endable<TParams, TQuery, TBody> {
+  getSchemas(): ControllerBlueprintSchemas<TParams, TQuery, TBody>;
+}

package/src/interfaces/index.ts

@@ -0,0 +1,2 @@
+export * from './controller-blueprint';
+export * from './endable';

package/src/types/combine-routes-fn.ts

@@ -0,0 +1,7 @@
+import type { Controller } from './controller';
+
+export type CombineRoutesFn<TFrameworkRouter> = <
+  TRoutes extends Record<any, Controller<any, any, any, any, any, any, TFrameworkRouter>>,
+>(
+  routes: TRoutes,
+) => TFrameworkRouter;

package/src/{classes/controller-contract-controller/controller-contract-controller.ts → types/controller.ts}

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

package/src/types/create-route-fn.ts

@@ -0,0 +1,5 @@
+import type { ControllerBlueprint } from '../interfaces/controller-blueprint';
+
+export type CreateRouteFn<TFrameworkContext, TFrameworkInjectable, TFrameworkRouter> = (
+  blueprint: ControllerBlueprint<TFrameworkContext, TFrameworkInjectable>,
+) => TFrameworkRouter;

package/src/types/fail-output-from.ts

@@ -0,0 +1,8 @@
+import type { FailOutput, NoInput } from '@controller-contract/core';
+
+/**
+ * The fail output a validated input can produce. Skipped inputs are `NoInput` and produce none.
+ */
+export type FailOutputFrom<T> = [T] extends [NoInput]
+  ? never
+  : FailOutput<Extract<keyof T, string>>;

package/src/types/index.ts

@@ -1,44 +1,12 @@
-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 BuilderIntegratorFn<TFrameworkContext, TFrameworkInject, TFrameworkRouter> = (
-  spec: ControllerContractSpec<TFrameworkContext, TFrameworkInject>,
-) => TFrameworkRouter;
-
-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<TFrameworkContext, TPath extends string, TOutput> = (
-  context: Prettify<
-    TFrameworkContext & {
-      params: ParamsFrom<TPath>;
-      outputs: typeof outputs;
-    }
-  >,
-) => Promise<TOutput>;
-
-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]
-  >;
-};
+export * from './combine-routes-fn';
+export * from './controller';
+export * from './create-route-fn';
+export * from './fail-output-from';
+export * from './infer-controller-contract';
+export * from './infer-controller-contracts-from-router';
+export * from './input-builder-fn';
+export * from './map-to-controller-contract';
+export * from './output-fn';
+export * from './output-fn-outputs';
+export * from './prettify';
+export * from './resolved-params';

package/src/types/infer-controller-contract.ts

@@ -0,0 +1,8 @@
+import type { ControllerContract, PathParams } from '@controller-contract/core';
+
+import type { Controller } from './controller';
+
+export type InferControllerContract<T> =
+  T extends Controller<infer M, infer P, any, infer Q, infer B, infer O, any>
+    ? ControllerContract<M, P, PathParams<P>, Q, B, O>
+    : never;

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

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

package/src/types/input-builder-fn.ts

@@ -0,0 +1,6 @@
+import type { InputBuilder } from '../classes/controller-builder/input-builder/input-builder';
+import type { Endable } from '../interfaces/endable';
+
+export type InputBuilderFn<TParams, TQuery, TBody> = (
+  inputBuilder: InputBuilder,
+) => Endable<TParams, TQuery, TBody>;

package/src/types/map-to-controller-contract.ts

@@ -0,0 +1,7 @@
+import type { InferControllerContract } from './infer-controller-contract';
+
+export type MapToControllerContract<TRoutes> = {
+  [TRouteName in Extract<keyof TRoutes, string> as Capitalize<TRouteName>]: InferControllerContract<
+    TRoutes[TRouteName]
+  >;
+};

package/src/types/no-output-from-inputs.ts

@@ -0,0 +1 @@
+export type NoOutputFromInputs = never;

package/src/types/output-fn-outputs.ts

@@ -0,0 +1,4 @@
+import type { outputs } from '../utils';
+import type { Prettify } from './prettify';
+
+export type OutputFnOutputs = Prettify<Omit<typeof outputs, 'next'>>;

package/src/types/output-fn.ts

@@ -0,0 +1,23 @@
+import type { ExitOutput, FailOutput, PassOutput } from '@controller-contract/core';
+
+import type { OutputFnOutputs } from './output-fn-outputs';
+import type { Prettify } from './prettify';
+
+export type OutputFn<
+  TFrameworkContext,
+  TParams,
+  TQuery,
+  TBody,
+  TOutput extends PassOutput<any> | FailOutput<any> | ExitOutput,
+> = (
+  context: Prettify<
+    TFrameworkContext & {
+      inputs: {
+        params: TParams;
+        query: TQuery;
+        body: TBody;
+      };
+      outputs: OutputFnOutputs;
+    }
+  >,
+) => Promise<TOutput>;

package/src/types/prettify.ts

@@ -0,0 +1 @@
+export type Prettify<T> = { [K in keyof T]: T[K] } & {};

package/src/types/resolved-params.ts

@@ -0,0 +1,8 @@
+import type { NoInput, PathParams } from '@controller-contract/core';
+
+/**
+ * Falls back to the raw path params when no params schema was given.
+ */
+export type ResolvedParams<TParams, TPath extends string> = [TParams] extends [NoInput]
+  ? PathParams<TPath>
+  : TParams;

package/src/utils/index.ts

@@ -1 +1,3 @@
 export * from './outputs';
+export * from './root-only';
+export * from './standard-outputs';

package/src/utils/outputs.ts

@@ -1,55 +1,36 @@
 import type { ExitOutput, FailOutput, NextOutput, PassOutput } from '@controller-contract/core';
 
-export namespace outputs {
-  export function next<T>(data: T, code = 100): NextOutput<T> {
+export const outputs = Object.freeze({
+  next<T>(data: T, code = 100): NextOutput<T> {
     return {
       type: 'next',
       code,
       data,
     };
-  }
+  },
 
-  export function pass<T>(data: T, code = 200): PassOutput<T> {
+  pass<T>(data: T, code = 200): PassOutput<T> {
     return {
       type: 'pass',
       code,
       data,
     };
-  }
+  },
 
-  export function fail<const T extends string>(data: FailOutput<T>['data'], code = 400): FailOutput<T> {
+  fail<const T extends string>(data: FailOutput<T>['data'], code = 400): FailOutput<T> {
     return {
       type: 'fail',
       code,
       data,
     };
-  }
+  },
 
   /**
    * Used to escape the controller contract state machine, useful for redirects.
    */
-  export function exit(): ExitOutput {
+  exit(): ExitOutput {
     return {
       type: 'exit',
     };
-  }
-}
-
-export function rootOnly(message: string): FailOutput<'root'>['data'] {
-  return [{ key: 'root', message }];
-}
-
-export const StandardOutputs = Object.freeze({
-  // 200
-  OK: outputs.pass(rootOnly('ok'), 200),
-  Created: outputs.pass(rootOnly('Created'), 201),
-  Accepted: outputs.pass(rootOnly('Accepted'), 202),
-  // 400
-  BadRequest: outputs.fail(rootOnly('Bad Request'), 400),
-  Unauthorized: outputs.fail(rootOnly('Unauthorized'), 401),
-  Forbidden: outputs.fail(rootOnly('Forbidden'), 403),
-  NotFound: outputs.fail(rootOnly('Not Found'), 404),
-  // 500
-  InternalServerError: outputs.fail(rootOnly('Internal Server Error'), 500),
-  BadGateway: outputs.fail(rootOnly('Bad Gateway'), 502),
+  },
 });

package/src/utils/root-only.ts

@@ -0,0 +1,8 @@
+import type { FailOutput } from '@controller-contract/core';
+
+/**
+ * Useful for quickly sending a root level error to the client.
+ */
+export function rootOnly(message: string): FailOutput<'root'>['data'] {
+  return [{ key: 'root', message }];
+}

package/src/utils/standard-outputs.ts

@@ -0,0 +1,20 @@
+import { outputs } from './outputs';
+import { rootOnly } from './root-only';
+
+/**
+ * Useful for quick http basic responses.
+ */
+export const StandardOutputs = Object.freeze({
+  // 200
+  OK: outputs.pass(rootOnly('ok'), 200),
+  Created: outputs.pass(rootOnly('Created'), 201),
+  Accepted: outputs.pass(rootOnly('Accepted'), 202),
+  // 400
+  BadRequest: outputs.fail(rootOnly('Bad Request'), 400),
+  Unauthorized: outputs.fail(rootOnly('Unauthorized'), 401),
+  Forbidden: outputs.fail(rootOnly('Forbidden'), 403),
+  NotFound: outputs.fail(rootOnly('Not Found'), 404),
+  // 500
+  InternalServerError: outputs.fail(rootOnly('Internal Server Error'), 500),
+  BadGateway: outputs.fail(rootOnly('Bad Gateway'), 502),
+});

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

@@ -1,48 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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/controller-contract-controller-builder/builder-steps/post-input-step.ts

@@ -1,49 +0,0 @@
-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 { BuilderIntegratorFn, SanitizedOutputFn } from '../../../types';
-import type { ControllerContractController } from '../../controller-contract-controller/controller-contract-controller';
-
-export class PostInputStep<
-  TFrameworkContext,
-  TFrameworkInject,
-  TRouter,
-  const TMethod extends Method,
-  const TPath extends string,
-  const TChannel extends InputChannel,
-  TInput,
-  TOutputFromInput extends Output,
-> {
-  constructor(
-    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<TFrameworkContext, TPath, TInput, TOutput>) {
-    const product = this.integrator(<SanitizedControllerContractSpec<TFrameworkContext, TFrameworkInject>>{
-      type: 'sanitized',
-      injectable: this.injectable,
-      method: this.method,
-      path: this.path,
-      channel: this.channel,
-      schema: this.schema,
-      outputFn,
-    });
-
-    return <
-      ControllerContractController<
-        TMethod,
-        TPath,
-        ParamsFrom<TPath>,
-        TChannel extends 'query' ? TInput : NoInput,
-        TChannel extends 'body' ? TInput : NoInput,
-        TOutputFromInput | TOutput,
-        TRouter
-      >
-    >(() => product);
-  }
-}

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

@@ -1,24 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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);
-  }
-}