@controller-contract/server 0.2.1 → 0.2.3

package/dist/index.d.mts

@@ -1,4 +1,4 @@
-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
@@ -64,15 +64,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 +82,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
@@ -107,12 +107,6 @@ declare class ControllerContractBuilder<TContext, TInject, TProduct> {
 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>;
 }
 //#endregion

package/dist/index.mjs

@@ -15,7 +15,7 @@ var PostInputStep = class {
 		this.schema = schema;
 	}
 	output(outputFn) {
-		return this.integrator({
+		this.integrator({
 			type: "sanitized",
 			injectable: this.injectable,
 			method: this.method,
@@ -24,6 +24,7 @@ var PostInputStep = class {
 			schema: this.schema,
 			outputFn
 		});
+		return {};
 	}
 };
 //#endregion
@@ -43,13 +44,14 @@ var PostEndpointStep = class {
 		return new PostInputStep(this.injectable, this.integrator, this.method, this.path, channel, schema);
 	}
 	output(outputFn) {
-		return this.integrator({
+		this.integrator({
 			type: "nullary",
 			method: this.method,
 			path: this.path,
 			injectable: this.injectable,
 			outputFn
 		});
+		return {};
 	}
 };
 //#endregion
@@ -88,12 +90,6 @@ var ControllerContractBuilderFactory = class {
 	constructor(injectableDefaultValue) {
 		this.injectableDefaultValue = injectableDefaultValue;
 	}
-	/**
-	* 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);
 	}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@controller-contract/server",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "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.7",
     "@standard-schema/spec": "1.1.0"
   },
   "scripts": {

package/src/classes/ControllerContractBuilderFactory.ts

@@ -4,12 +4,6 @@ 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);
   }

package/src/classes/PostEndpointStep.ts

@@ -1,4 +1,12 @@
-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 { IntegratorFn, OutputFn } from '../types';
 import type { NullaryControllerContractSpec } from './ControllerContractSpec';
@@ -12,25 +20,30 @@ 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,4 +1,11 @@
-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 { IntegratorFn, SanitizedOutputFn } from '../types';
 import type { SanitizedControllerContractSpec } from './ControllerContractSpec';
@@ -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,19 @@ 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,
+    };
   }
 }