@controller-contract/server 0.2.1 → 0.2.4

package/dist/index.d.mts

@@ -1,7 +1,7 @@
-import { ExitOutput, FailOutput, InputChannel, Method, NextOutput, Output, ParamsFrom, PassOutput } from "@controller-contract/core";
+import { ControllerContractProduct, ExitOutput, FailOutput, InputChannel, Method, NextOutput, NoInput, Output, ParamsFrom, PassOutput } from "@controller-contract/core";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/classes/ControllerContractSpec.d.ts
+//#region src/interfaces/ControllerContractSpec.d.ts
 interface NullaryControllerContractSpec<TContext, TInject> {
   readonly type: 'nullary';
   readonly injectable: TInject;
@@ -54,6 +54,7 @@ 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 Prettify<T> = { [K in keyof T]: T[K] } & {};
 type OutputFn<TContext, TPath extends string, TOutput> = (context: Prettify<TContext & {
   params: ParamsFrom<TPath>;
@@ -64,15 +65,15 @@ type SanitizedOutputFn<TContext, TPath extends string, TInput, TOutput> = Output
 }, TPath, TOutput>;
 //#endregion
 //#region src/classes/PostInputStep.d.ts
-declare class PostInputStep<TContext, TInject, TProduct, const TMethod extends Method, const TPath extends string, TInput, TOutputFromInput extends Output> {
+declare class PostInputStep<TContext, TInject, TProduct, 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: InputChannel, schema: StandardSchemaV1<TInput>);
-  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TContext, TPath, TInput, TOutputFromInput | TOutput>): TProduct;
+  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>;
 }
 //#endregion
 //#region src/classes/PostEndpointStep.d.ts
@@ -82,8 +83,8 @@ declare class PostEndpointStep<TContext, TInject, TProduct, const TMethod extend
   private readonly method;
   private readonly path;
   constructor(injectable: TInject, integrator: IntegratorFn<TContext, TInject, TProduct>, method: TMethod, path: TPath);
-  input<TInput>(channel: InputChannel, schema: StandardSchemaV1<TInput>): PostInputStep<TContext, TInject, TProduct, TMethod, TPath, TInput, FailOutput<Extract<keyof TInput, string>>>;
-  output<TOutput extends Output>(outputFn: OutputFn<TContext, TPath, TOutput>): TProduct;
+  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>;
 }
 //#endregion
 //#region src/classes/PostInjectStep.d.ts
@@ -103,17 +104,17 @@ declare class ControllerContractBuilder<TContext, TInject, TProduct> {
   endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath): PostEndpointStep<TContext, TInject, TProduct, TMethod, TPath>;
 }
 //#endregion
-//#region src/classes/ControllerContractBuilderFactory.d.ts
-declare class ControllerContractBuilderFactory<TContext, TInject> {
-  private readonly injectableDefaultValue;
-  constructor(injectableDefaultValue: TInject);
-  /**
-   * This factory function provides the inteface for you to write the integration between
-   * `contract-controller` and your http library/framework of choice.
-   *
-   * When youre done writing your adaptor you can use the product in your code base.
-   */
-  createBuilder<TProduct>(integrator: IntegratorFn<TContext, TInject, TProduct>): ControllerContractBuilder<TContext, TInject, TProduct>;
+//#region src/classes/ControllerContractRouter.d.ts
+declare class ControllerContractRouter<TProduct> {
+  private readonly routerAdapterFn;
+  constructor(routerAdapterFn: RouterAdapterFn<TProduct>);
+  getRouter(routes: Record<string, TProduct>): TProduct;
+}
+//#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>;
 }
 //#endregion
-export { ControllerContractBuilderFactory, StandardOutputs, outputs, rootOnly };
+export { ControllerContractAdapterFactory, StandardOutputs, outputs, rootOnly };

package/dist/index.mjs

@@ -82,20 +82,24 @@ var ControllerContractBuilder = class {
 	}
 };
 //#endregion
-//#region src/classes/ControllerContractBuilderFactory.ts
-var ControllerContractBuilderFactory = class {
-	injectableDefaultValue;
-	constructor(injectableDefaultValue) {
-		this.injectableDefaultValue = injectableDefaultValue;
+//#region src/classes/ControllerContractRouter.ts
+var ControllerContractRouter = class {
+	routerAdapterFn;
+	constructor(routerAdapterFn) {
+		this.routerAdapterFn = routerAdapterFn;
+	}
+	getRouter(routes) {
+		return this.routerAdapterFn(routes);
+	}
+};
+//#endregion
+//#region src/classes/ControllerContractAdapterFactory.ts
+var ControllerContractAdapterFactory = class {
+	createBuilder(injectableDefaultValue, integrator) {
+		return new ControllerContractBuilder(injectableDefaultValue, integrator);
 	}
-	/**
-	* This factory function provides the inteface for you to write the integration between
-	* `contract-controller` and your http library/framework of choice.
-	*
-	* When youre done writing your adaptor you can use the product in your code base.
-	*/
-	createBuilder(integrator) {
-		return new ControllerContractBuilder(this.injectableDefaultValue, integrator);
+	createRouter(routerAdapterFn) {
+		return new ControllerContractRouter(routerAdapterFn);
 	}
 };
 //#endregion
@@ -149,4 +153,4 @@ const StandardOutputs = Object.freeze({
 	BadGateway: outputs.fail(rootOnly("Bad Gateway"), 502)
 });
 //#endregion
-export { ControllerContractBuilderFactory, StandardOutputs, outputs, rootOnly };
+export { ControllerContractAdapterFactory, StandardOutputs, outputs, rootOnly };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@controller-contract/server",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.4",
   "author": "kennychulo",
   "license": "MIT",
   "files": [
@@ -23,7 +23,7 @@
     "typescript": "6.0.3"
   },
   "dependencies": {
-    "@controller-contract/core": "0.2.5",
+    "@controller-contract/core": "0.2.9",
     "@standard-schema/spec": "1.1.0"
   },
   "scripts": {

package/src/classes/ControllerContractAdapterFactory.ts

@@ -0,0 +1,13 @@
+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/ControllerContractRouter.ts

@@ -0,0 +1,9 @@
+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,7 +1,15 @@
-import type { FailOutput, InputChannel, Method, Output } from '@controller-contract/core';
+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 type { NullaryControllerContractSpec } from './ControllerContractSpec';
 import { PostInputStep } from './PostInputStep';
 
 export class PostEndpointStep<TContext, TInject, TProduct, const TMethod extends Method, const TPath extends string> {
@@ -12,25 +20,28 @@ export class PostEndpointStep<TContext, TInject, TProduct, const TMethod extends
     private readonly path: TPath,
   ) {}
 
-  input<TInput>(channel: InputChannel, schema: StandardSchemaV1<TInput>) {
+  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>) {
-    return this.integrator(<NullaryControllerContractSpec<TContext, TInject>>{
+    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/PostInputStep.ts

@@ -1,7 +1,14 @@
-import type { InputChannel, Method, Output } from '@controller-contract/core';
+import type {
+  ControllerContractProduct,
+  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 './ControllerContractSpec';
 
 export class PostInputStep<
   TContext,
@@ -9,6 +16,7 @@ export class PostInputStep<
   TProduct,
   const TMethod extends Method,
   const TPath extends string,
+  const TChannel extends InputChannel,
   TInput,
   TOutputFromInput extends Output,
 > {
@@ -17,12 +25,12 @@ export class PostInputStep<
     private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
     private readonly method: TMethod,
     private readonly path: TPath,
-    private readonly channel: InputChannel,
+    private readonly channel: TChannel,
     private readonly schema: StandardSchemaV1<TInput>,
   ) {}
 
-  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TContext, TPath, TInput, TOutputFromInput | TOutput>) {
-    return this.integrator(<SanitizedControllerContractSpec<TContext, TInject>>{
+  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TContext, TPath, TInput, TOutput>) {
+    const product = this.integrator(<SanitizedControllerContractSpec<TContext, TInject>>{
       type: 'sanitized',
       injectable: this.injectable,
       method: this.method,
@@ -31,5 +39,17 @@ export class PostInputStep<
       schema: this.schema,
       outputFn,
     });
+
+    return <
+      ControllerContractProduct<
+        TMethod,
+        TPath,
+        ParamsFrom<TPath>,
+        TChannel extends 'query' ? TInput : NoInput,
+        TChannel extends 'body' ? TInput : NoInput,
+        TOutputFromInput | TOutput,
+        TProduct
+      >
+    >product;
   }
 }

package/src/index.ts

@@ -1,2 +1,2 @@
-export * from './classes/ControllerContractBuilderFactory';
+export * from './classes/ControllerContractAdapterFactory';
 export * from './utils';

package/src/types/index.ts

@@ -1,9 +1,11 @@
 import type { ParamsFrom } from '@controller-contract/core';
-import type { ControllerContractSpec } from '../classes/ControllerContractSpec';
+import type { ControllerContractSpec } from '../interfaces/ControllerContractSpec';
 import type { outputs } from '../utils';
 
 export type IntegratorFn<TContext, TInject, TProduct> = (spec: ControllerContractSpec<TContext, TInject>) => TProduct;
 
+export type RouterAdapterFn<TProduct> = (routes: Record<string, TProduct>) => TProduct;
+
 export type Prettify<T> = {
   [K in keyof T]: T[K];
 } & {};

package/src/classes/ControllerContractBuilderFactory.ts

@@ -1,16 +0,0 @@
-import type { IntegratorFn } from '../types';
-import { ControllerContractBuilder } from './ControllerContractBuilder';
-
-export class ControllerContractBuilderFactory<TContext, TInject> {
-  constructor(private readonly injectableDefaultValue: TInject) {}
-
-  /**
-   * This factory function provides the inteface for you to write the integration between
-   * `contract-controller` and your http library/framework of choice.
-   *
-   * When youre done writing your adaptor you can use the product in your code base.
-   */
-  createBuilder<TProduct>(integrator: IntegratorFn<TContext, TInject, TProduct>) {
-    return new ControllerContractBuilder<TContext, TInject, TProduct>(this.injectableDefaultValue, integrator);
-  }
-}