@controller-contract/server 0.1.1 → 0.2.1

package/dist/index.d.mts

@@ -1,67 +1,119 @@
-import { n as output } from "./index-CgtO_soW.mjs";
-import { ControllerContract, InputChannel, Method, NoInput, OutputFail, OutputMonads, ParamsFrom, Prettify } from "@controller-contract/core";
+import { ExitOutput, FailOutput, InputChannel, Method, NextOutput, Output, ParamsFrom, PassOutput } from "@controller-contract/core";
 import { StandardSchemaV1 } from "@standard-schema/spec";
 
-//#region src/types/builder-step.d.ts
-/**
- * All the possible steps are defined below.
- */
-declare namespace BuilderStep {
-  /**
-   * Always the first step
-   */
-  interface Endpoint<TContext> {
-    endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath): BuilderStep.Output<TContext, TMethod, TPath, NoInput, never> & BuilderStep.Input<TContext, TMethod, TPath>;
-  }
-  interface Input<TContext, TMethod extends Method, TPath extends string> {
-    input<TInput>(channel: InputChannel, schema: StandardSchemaV1<TInput>): BuilderStep.Output<TContext, TMethod, TPath, TInput, OutputFail<Extract<keyof TInput, string>>>;
-  }
-  /**
-   * Always the last step
-   */
-  interface Output<TContext, TMethod extends Method, TPath extends string, TInput, TOutput extends OutputMonads> {
-    output<TFnOutput extends OutputMonads>(handler: OutputHandler<TContext, TPath, TInput, TFnOutput>): ControllerContract<TMethod, TPath, TInput, TOutput | TFnOutput>;
-  }
-}
-type OutputHandler<TContext, TPath extends string, TInput, TOutput extends OutputMonads> = (context: Prettify<TContext & {
-  params: ParamsFrom<TPath>;
-  input: TInput;
-  output: typeof output;
-}>) => TOutput | Promise<TOutput>;
-//#endregion
-//#region src/types/adapter.d.ts
-type AdaptorFn<TContext> = (blueprint: AdapterBlueprint<TContext> | AdapterWithSchemaBlueprint<TContext>) => void;
-declare class AdapterBlueprint<TContext> {
+//#region src/classes/ControllerContractSpec.d.ts
+interface NullaryControllerContractSpec<TContext, TInject> {
+  readonly type: 'nullary';
+  readonly injectable: TInject;
   readonly method: Method;
   readonly path: string;
-  readonly handler: OutputHandler<TContext, string, any, OutputMonads>;
-  constructor(method: Method, path: string, handler: OutputHandler<TContext, string, any, OutputMonads>);
+  readonly outputFn: OutputFn<TContext, string, Output>;
 }
-declare class AdapterWithSchemaBlueprint<TContext> {
+interface SanitizedControllerContractSpec<TContext, TInject> {
+  readonly type: 'sanitized';
+  readonly injectable: TInject;
   readonly method: Method;
   readonly path: string;
   readonly channel: InputChannel;
   readonly schema: StandardSchemaV1;
-  readonly handler: OutputHandler<TContext, string, any, OutputMonads>;
-  constructor(method: Method, path: string, channel: InputChannel, schema: StandardSchemaV1, handler: OutputHandler<TContext, string, any, OutputMonads>);
+  readonly outputFn: SanitizedOutputFn<TContext, string, unknown, Output>;
+}
+type ControllerContractSpec<TContext, TInject> = NullaryControllerContractSpec<TContext, TInject> | SanitizedControllerContractSpec<TContext, TInject>;
+//#endregion
+//#region src/utils/outputs.d.ts
+declare namespace outputs {
+  function next<T>(data: T, code?: number): NextOutput<T>;
+  function pass<T>(data: T, code?: number): PassOutput<T>;
+  function fail<const T extends string>(data: FailOutput<T>['data'], code?: number): FailOutput<T>;
+  /**
+   * Used to escape the controller contract state machine, useful for redirects.
+   */
+  function exit(): ExitOutput;
+}
+declare function rootOnly(message: string): FailOutput<'root'>['data'];
+declare const StandardOutputs: Readonly<{
+  OK: PassOutput<{
+    key: "root";
+    message: string;
+  }[]>;
+  Created: PassOutput<{
+    key: "root";
+    message: string;
+  }[]>;
+  Accepted: PassOutput<{
+    key: "root";
+    message: string;
+  }[]>;
+  BadRequest: FailOutput<"root">;
+  Unauthorized: FailOutput<"root">;
+  Forbidden: FailOutput<"root">;
+  NotFound: FailOutput<"root">;
+  InternalServerError: FailOutput<"root">;
+  BadGateway: FailOutput<"root">;
+}>;
+//#endregion
+//#region src/types/index.d.ts
+type IntegratorFn<TContext, TInject, TProduct> = (spec: ControllerContractSpec<TContext, TInject>) => TProduct;
+type Prettify<T> = { [K in keyof T]: T[K] } & {};
+type OutputFn<TContext, TPath extends string, TOutput> = (context: Prettify<TContext & {
+  params: ParamsFrom<TPath>;
+  outputs: typeof outputs;
+}>) => Promise<TOutput>;
+type SanitizedOutputFn<TContext, TPath extends string, TInput, TOutput> = OutputFn<TContext & {
+  input: TInput;
+}, 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> {
+  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;
 }
 //#endregion
-//#region src/index.d.ts
-/**
- * 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.
- *
- * @example
- * // lib/cc.ts
- * export const cc = controllerContractFactory(() => {
- *  // your code
- * })
- *
- * // api/users.ts
- * export const getUsers = cc.endpoint().input('...', ...).output(() => { ... });
- */
-declare function controllerContractBuilderFactory<TContext>(adaptor: AdaptorFn<TContext>): BuilderStep.Endpoint<TContext>;
+//#region src/classes/PostEndpointStep.d.ts
+declare class PostEndpointStep<TContext, TInject, TProduct, 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<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;
+}
+//#endregion
+//#region src/classes/PostInjectStep.d.ts
+declare class PostInjectStep<TContext, TInject, TProduct> {
+  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>;
+}
+//#endregion
+//#region src/classes/ControllerContractBuilder.d.ts
+declare class ControllerContractBuilder<TContext, TInject, TProduct> {
+  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>;
+}
+//#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>;
+}
 //#endregion
-export { AdapterBlueprint, AdapterWithSchemaBlueprint, AdaptorFn, controllerContractBuilderFactory };
+export { ControllerContractBuilderFactory, StandardOutputs, outputs, rootOnly };

package/dist/index.mjs

@@ -1,73 +1,152 @@
-//#region src/types/adapter.ts
-var AdapterBlueprint = class {
+//#region src/classes/PostInputStep.ts
+var PostInputStep = class {
+	injectable;
+	integrator;
 	method;
 	path;
-	handler;
-	constructor(method, path, handler) {
+	channel;
+	schema;
+	constructor(injectable, integrator, method, path, channel, schema) {
+		this.injectable = injectable;
+		this.integrator = integrator;
 		this.method = method;
 		this.path = path;
-		this.handler = handler;
+		this.channel = channel;
+		this.schema = schema;
+	}
+	output(outputFn) {
+		return this.integrator({
+			type: "sanitized",
+			injectable: this.injectable,
+			method: this.method,
+			path: this.path,
+			channel: this.channel,
+			schema: this.schema,
+			outputFn
+		});
 	}
 };
-var AdapterWithSchemaBlueprint = class {
+//#endregion
+//#region src/classes/PostEndpointStep.ts
+var PostEndpointStep = class {
+	injectable;
+	integrator;
 	method;
 	path;
-	channel;
-	schema;
-	handler;
-	constructor(method, path, channel, schema, handler) {
+	constructor(injectable, integrator, method, path) {
+		this.injectable = injectable;
+		this.integrator = integrator;
 		this.method = method;
 		this.path = path;
-		this.channel = channel;
-		this.schema = schema;
-		this.handler = handler;
+	}
+	input(channel, schema) {
+		return new PostInputStep(this.injectable, this.integrator, this.method, this.path, channel, schema);
+	}
+	output(outputFn) {
+		return this.integrator({
+			type: "nullary",
+			method: this.method,
+			path: this.path,
+			injectable: this.injectable,
+			outputFn
+		});
 	}
 };
 //#endregion
-//#region src/steps/output.ts
-function outputStep(adaptor, method, path, channel, schema) {
-	return { output(handler) {
-		if (channel && schema) adaptor(new AdapterWithSchemaBlueprint(method, path, channel, schema, handler));
-		else adaptor(new AdapterBlueprint(method, path, handler));
-		return {};
-	} };
-}
+//#region src/classes/PostInjectStep.ts
+var PostInjectStep = class {
+	injectable;
+	integrator;
+	constructor(injectable, integrator) {
+		this.injectable = injectable;
+		this.integrator = integrator;
+	}
+	endpoint(method, path) {
+		return new PostEndpointStep(this.injectable, this.integrator, method, path);
+	}
+};
 //#endregion
-//#region src/steps/input.ts
-function inputStep(adaptor, method, path) {
-	return { input(channel, schema) {
-		return outputStep(adaptor, method, path, channel, schema);
-	} };
-}
+//#region src/classes/ControllerContractBuilder.ts
+var ControllerContractBuilder = class {
+	injectableDefaultValue;
+	integrator;
+	constructor(injectableDefaultValue, integrator) {
+		this.injectableDefaultValue = injectableDefaultValue;
+		this.integrator = integrator;
+	}
+	inject(injectable) {
+		return new PostInjectStep(injectable, this.integrator);
+	}
+	endpoint(method, path) {
+		return new PostEndpointStep(this.injectableDefaultValue, this.integrator, method, path);
+	}
+};
 //#endregion
-//#region src/steps/endpoint.ts
-function endpointStep(adaptor) {
-	return { endpoint(method, path) {
+//#region src/classes/ControllerContractBuilderFactory.ts
+var ControllerContractBuilderFactory = class {
+	injectableDefaultValue;
+	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);
+	}
+};
+//#endregion
+//#region src/utils/outputs.ts
+let outputs;
+(function(_outputs) {
+	function next(data, code = 100) {
 		return {
-			...outputStep(adaptor, method, path),
-			...inputStep(adaptor, method, path)
+			type: "next",
+			code,
+			data
 		};
-	} };
-}
-//#endregion
-//#region src/index.ts
-/**
-* 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.
-*
-* @example
-* // lib/cc.ts
-* export const cc = controllerContractFactory(() => {
-*  // your code
-* })
-*
-* // api/users.ts
-* export const getUsers = cc.endpoint().input('...', ...).output(() => { ... });
-*/
-function controllerContractBuilderFactory(adaptor) {
-	return endpointStep(adaptor);
+	}
+	_outputs.next = next;
+	function pass(data, code = 200) {
+		return {
+			type: "pass",
+			code,
+			data
+		};
+	}
+	_outputs.pass = pass;
+	function fail(data, code = 400) {
+		return {
+			type: "fail",
+			code,
+			data
+		};
+	}
+	_outputs.fail = fail;
+	function exit() {
+		return { type: "exit" };
+	}
+	_outputs.exit = exit;
+})(outputs || (outputs = {}));
+function rootOnly(message) {
+	return [{
+		key: "root",
+		message
+	}];
 }
+const StandardOutputs = Object.freeze({
+	OK: outputs.pass(rootOnly("ok"), 200),
+	Created: outputs.pass(rootOnly("Created"), 201),
+	Accepted: outputs.pass(rootOnly("Accepted"), 202),
+	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),
+	InternalServerError: outputs.fail(rootOnly("Internal Server Error"), 500),
+	BadGateway: outputs.fail(rootOnly("Bad Gateway"), 502)
+});
 //#endregion
-export { AdapterBlueprint, AdapterWithSchemaBlueprint, controllerContractBuilderFactory };
+export { ControllerContractBuilderFactory, StandardOutputs, outputs, rootOnly };

package/package.json

@@ -1,12 +1,9 @@
 {
   "name": "@controller-contract/server",
   "type": "module",
-  "version": "0.1.1",
+  "version": "0.2.1",
   "author": "kennychulo",
   "license": "MIT",
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "types": "./dist/index.d.ts",
   "files": [
     "dist",
     "src",
@@ -15,7 +12,6 @@
   ],
   "exports": {
     ".": "./dist/index.mjs",
-    "./utils": "./dist/utils/index.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -27,7 +23,7 @@
     "typescript": "6.0.3"
   },
   "dependencies": {
-    "@controller-contract/core": "0.1.1",
+    "@controller-contract/core": "0.2.5",
     "@standard-schema/spec": "1.1.0"
   },
   "scripts": {

package/src/classes/ControllerContractBuilder.ts

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

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

package/src/classes/ControllerContractSpec.ts

@@ -0,0 +1,25 @@
+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> {
+  readonly type: 'nullary';
+  readonly injectable: TInject;
+  readonly method: Method;
+  readonly path: string;
+  readonly outputFn: OutputFn<TContext, string, Output>;
+}
+
+export interface SanitizedControllerContractSpec<TContext, 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>;
+}
+
+export type ControllerContractSpec<TContext, TInject> =
+  | NullaryControllerContractSpec<TContext, TInject>
+  | SanitizedControllerContractSpec<TContext, TInject>;

package/src/classes/PostEndpointStep.ts

@@ -0,0 +1,36 @@
+import type { FailOutput, InputChannel, Method, Output } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+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> {
+  constructor(
+    private readonly injectable: TInject,
+    private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
+    private readonly method: TMethod,
+    private readonly path: TPath,
+  ) {}
+
+  input<TInput>(channel: InputChannel, schema: StandardSchemaV1<TInput>) {
+    return new PostInputStep<
+      TContext,
+      TInject,
+      TProduct,
+      TMethod,
+      TPath,
+      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>>{
+      type: 'nullary',
+      method: this.method,
+      path: this.path,
+      injectable: this.injectable,
+      outputFn,
+    });
+  }
+}

package/src/classes/PostInjectStep.ts

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

package/src/classes/PostInputStep.ts

@@ -0,0 +1,35 @@
+import type { InputChannel, Method, Output } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+import type { IntegratorFn, SanitizedOutputFn } from '../types';
+import type { SanitizedControllerContractSpec } from './ControllerContractSpec';
+
+export class PostInputStep<
+  TContext,
+  TInject,
+  TProduct,
+  const TMethod extends Method,
+  const TPath extends string,
+  TInput,
+  TOutputFromInput extends Output,
+> {
+  constructor(
+    private readonly injectable: TInject,
+    private readonly integrator: IntegratorFn<TContext, TInject, TProduct>,
+    private readonly method: TMethod,
+    private readonly path: TPath,
+    private readonly channel: InputChannel,
+    private readonly schema: StandardSchemaV1<TInput>,
+  ) {}
+
+  output<TOutput extends Output>(outputFn: SanitizedOutputFn<TContext, TPath, TInput, TOutputFromInput | TOutput>) {
+    return this.integrator(<SanitizedControllerContractSpec<TContext, TInject>>{
+      type: 'sanitized',
+      injectable: this.injectable,
+      method: this.method,
+      path: this.path,
+      channel: this.channel,
+      schema: this.schema,
+      outputFn,
+    });
+  }
+}

package/src/index.ts

@@ -1,23 +1,2 @@
-import { endpointStep } from './steps/endpoint';
-import type { AdaptorFn } from './types/adapter';
-
-export * from './types/adapter';
-
-/**
- * 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.
- *
- * @example
- * // lib/cc.ts
- * export const cc = controllerContractFactory(() => {
- *  // your code
- * })
- *
- * // api/users.ts
- * export const getUsers = cc.endpoint().input('...', ...).output(() => { ... });
- */
-export function controllerContractBuilderFactory<TContext>(adaptor: AdaptorFn<TContext>) {
-  return endpointStep<TContext>(adaptor);
-}
+export * from './classes/ControllerContractBuilderFactory';
+export * from './utils';

package/src/types/index.ts

@@ -0,0 +1,24 @@
+import type { ParamsFrom } from '@controller-contract/core';
+import type { ControllerContractSpec } from '../classes/ControllerContractSpec';
+import type { outputs } from '../utils';
+
+export type IntegratorFn<TContext, TInject, TProduct> = (spec: ControllerContractSpec<TContext, TInject>) => TProduct;
+
+export type Prettify<T> = {
+  [K in keyof T]: T[K];
+} & {};
+
+export type OutputFn<TContext, TPath extends string, TOutput> = (
+  context: Prettify<
+    TContext & {
+      params: ParamsFrom<TPath>;
+      outputs: typeof outputs;
+    }
+  >,
+) => Promise<TOutput>;
+
+export type SanitizedOutputFn<TContext, TPath extends string, TInput, TOutput> = OutputFn<
+  TContext & { input: TInput },
+  TPath,
+  TOutput
+>;

package/src/utils/index.ts

@@ -1,2 +1 @@
-export * from './cast';
-export * from './output';
+export * from './outputs';

package/src/utils/outputs.ts

@@ -0,0 +1,55 @@
+import type { ExitOutput, FailOutput, NextOutput, PassOutput } from '@controller-contract/core';
+
+export namespace outputs {
+  export function next<T>(data: T, code = 100): NextOutput<T> {
+    return {
+      type: 'next',
+      code,
+      data,
+    };
+  }
+
+  export function 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> {
+    return {
+      type: 'fail',
+      code,
+      data,
+    };
+  }
+
+  /**
+   * Used to escape the controller contract state machine, useful for redirects.
+   */
+  export function 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/dist/index-CgtO_soW.d.mts

@@ -1,40 +0,0 @@
-import { OutputExit, OutputFail, OutputNext, OutputPass, ParamsFrom } from "@controller-contract/core";
-
-//#region src/utils/cast.d.ts
-declare namespace cast {
-  function params<T>(rawParams: T): ParamsFrom<string>;
-}
-//#endregion
-//#region src/utils/output.d.ts
-declare namespace output {
-  function next<T>(data: T, code?: number): OutputNext<T>;
-  function pass<T>(data: T, code?: number): OutputPass<T>;
-  function fail<const T extends string>(data: OutputFail<T>['data'], code?: number): OutputFail<T>;
-  /**
-   * Used to escape the controller contract state machine, useful for redirects.
-   */
-  function exit(): OutputExit;
-}
-declare function rootOnly(message: string): OutputFail<'root'>['data'];
-declare const StandardOutput: {
-  OK: OutputPass<{
-    key: "root";
-    message: string;
-  }[]>;
-  Created: OutputPass<{
-    key: "root";
-    message: string;
-  }[]>;
-  Accepted: OutputPass<{
-    key: "root";
-    message: string;
-  }[]>;
-  BadRequest: OutputFail<"root">;
-  Unauthorized: OutputFail<"root">;
-  Forbidden: OutputFail<"root">;
-  NotFound: OutputFail<"root">;
-  InternalServerError: OutputFail<"root">;
-  BadGateway: OutputFail<"root">;
-};
-//#endregion
-export { cast as i, output as n, rootOnly as r, StandardOutput as t };

package/dist/utils/index.d.mts

@@ -1,2 +0,0 @@
-import { i as cast, n as output, r as rootOnly, t as StandardOutput } from "../index-CgtO_soW.mjs";
-export { StandardOutput, cast, output, rootOnly };

package/dist/utils/index.mjs

@@ -1,60 +0,0 @@
-//#region src/utils/cast.ts
-let cast;
-(function(_cast) {
-	function params(rawParams) {
-		return rawParams;
-	}
-	_cast.params = params;
-})(cast || (cast = {}));
-//#endregion
-//#region src/utils/output.ts
-let output;
-(function(_output) {
-	function next(data, code = 100) {
-		return {
-			type: "next",
-			code,
-			data
-		};
-	}
-	_output.next = next;
-	function pass(data, code = 200) {
-		return {
-			type: "pass",
-			code,
-			data
-		};
-	}
-	_output.pass = pass;
-	function fail(data, code = 400) {
-		return {
-			type: "fail",
-			code,
-			data
-		};
-	}
-	_output.fail = fail;
-	function exit() {
-		return { type: "exit" };
-	}
-	_output.exit = exit;
-})(output || (output = {}));
-function rootOnly(message) {
-	return [{
-		key: "root",
-		message
-	}];
-}
-const StandardOutput = {
-	OK: output.pass(rootOnly("ok"), 200),
-	Created: output.pass(rootOnly("Created"), 201),
-	Accepted: output.pass(rootOnly("Accepted"), 202),
-	BadRequest: output.fail(rootOnly("Bad Request"), 400),
-	Unauthorized: output.fail(rootOnly("Unauthorized"), 401),
-	Forbidden: output.fail(rootOnly("Forbidden"), 403),
-	NotFound: output.fail(rootOnly("Not Found"), 404),
-	InternalServerError: output.fail(rootOnly("Internal Server Error"), 500),
-	BadGateway: output.fail(rootOnly("Bad Gateway"), 502)
-};
-//#endregion
-export { StandardOutput, cast, output, rootOnly };

package/src/steps/endpoint.ts

@@ -1,15 +0,0 @@
-import type { AdaptorFn } from '../types/adapter';
-import type { BuilderStep } from '../types/builder-step';
-import { inputStep } from './input';
-import { outputStep } from './output';
-
-export function endpointStep<TContext>(adaptor: AdaptorFn<TContext>): BuilderStep.Endpoint<TContext> {
-  return {
-    endpoint(method, path) {
-      return {
-        ...outputStep(adaptor, method, path),
-        ...inputStep(adaptor, method, path),
-      };
-    },
-  };
-}

package/src/steps/input.ts

@@ -1,16 +0,0 @@
-import type { Method } from '@controller-contract/core';
-import type { AdaptorFn } from '../types/adapter';
-import type { BuilderStep } from '../types/builder-step';
-import { outputStep } from './output';
-
-export function inputStep<TContext, const TMethod extends Method, const TPath extends string>(
-  adaptor: AdaptorFn<TContext>,
-  method: TMethod,
-  path: TPath,
-): BuilderStep.Input<TContext, TMethod, TPath> {
-  return {
-    input(channel, schema) {
-      return outputStep(adaptor, method, path, channel, schema);
-    },
-  };
-}

package/src/steps/output.ts

@@ -1,30 +0,0 @@
-import type { InputChannel, Method, OutputMonads } from '@controller-contract/core';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import { AdapterBlueprint, AdapterWithSchemaBlueprint, type AdaptorFn } from '../types/adapter';
-import type { BuilderStep } from '../types/builder-step';
-
-export function outputStep<
-  TContext,
-  const TMethod extends Method,
-  const TPath extends string,
-  TInput,
-  TOutput extends OutputMonads,
->(
-  adaptor: AdaptorFn<TContext>,
-  method: TMethod,
-  path: TPath,
-  channel?: InputChannel,
-  schema?: StandardSchemaV1<TInput>,
-): BuilderStep.Output<TContext, TMethod, TPath, TInput, TOutput> {
-  return {
-    output(handler) {
-      if (channel && schema) {
-        adaptor(new AdapterWithSchemaBlueprint(method, path, channel, schema, handler));
-      } else {
-        adaptor(new AdapterBlueprint(method, path, handler));
-      }
-
-      return {};
-    },
-  };
-}

package/src/types/adapter.ts

@@ -1,25 +0,0 @@
-import type { InputChannel, Method, OutputMonads } from '@controller-contract/core';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { OutputHandler } from './builder-step';
-
-export type AdaptorFn<TContext> = (
-  blueprint: AdapterBlueprint<TContext> | AdapterWithSchemaBlueprint<TContext>,
-) => void;
-
-export class AdapterBlueprint<TContext> {
-  constructor(
-    readonly method: Method,
-    readonly path: string,
-    readonly handler: OutputHandler<TContext, string, any, OutputMonads>,
-  ) {}
-}
-
-export class AdapterWithSchemaBlueprint<TContext> {
-  constructor(
-    readonly method: Method,
-    readonly path: string,
-    readonly channel: InputChannel,
-    readonly schema: StandardSchemaV1,
-    readonly handler: OutputHandler<TContext, string, any, OutputMonads>,
-  ) {}
-}

package/src/types/builder-step.ts

@@ -1,59 +0,0 @@
-import type {
-  ControllerContract,
-  InputChannel,
-  Method,
-  NoInput,
-  OutputFail,
-  OutputMonads,
-  ParamsFrom,
-  Prettify,
-} from '@controller-contract/core';
-import type { StandardSchemaV1 } from '@standard-schema/spec';
-import type { output } from '../utils';
-
-/**
- * All the possible steps are defined below.
- */
-export namespace BuilderStep {
-  /**
-   * Always the first step
-   */
-  export interface Endpoint<TContext> {
-    endpoint<const TMethod extends Method, const TPath extends string>(
-      method: TMethod,
-      path: TPath,
-    ): BuilderStep.Output<TContext, TMethod, TPath, NoInput, never> & BuilderStep.Input<TContext, TMethod, TPath>;
-  }
-
-  export interface Input<TContext, TMethod extends Method, TPath extends string> {
-    input<TInput>(
-      channel: InputChannel,
-      schema: StandardSchemaV1<TInput>,
-    ): BuilderStep.Output<TContext, TMethod, TPath, TInput, OutputFail<Extract<keyof TInput, string>>>;
-  }
-
-  /**
-   * Always the last step
-   */
-  export interface Output<
-    TContext,
-    TMethod extends Method,
-    TPath extends string,
-    TInput,
-    TOutput extends OutputMonads,
-  > {
-    output<TFnOutput extends OutputMonads>(
-      handler: OutputHandler<TContext, TPath, TInput, TFnOutput>,
-    ): ControllerContract<TMethod, TPath, TInput, TOutput | TFnOutput>;
-  }
-}
-
-export type OutputHandler<TContext, TPath extends string, TInput, TOutput extends OutputMonads> = (
-  context: Prettify<
-    TContext & {
-      params: ParamsFrom<TPath>;
-      input: TInput;
-      output: typeof output;
-    }
-  >,
-) => TOutput | Promise<TOutput>;

package/src/utils/cast.ts

@@ -1,7 +0,0 @@
-import type { ParamsFrom } from '@controller-contract/core';
-
-export namespace cast {
-  export function params<T>(rawParams: T) {
-    return rawParams as ParamsFrom<string>;
-  }
-}

package/src/utils/output.ts

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