@controller-contract/server 0.3.3 → 0.4.0

package/dist/index.mjs

@@ -1,171 +1,229 @@
-//#region src/classes/controller-contract-controller-builder/builder-steps/post-input-step.ts
-var PostInputStep = class {
+//#region src/classes/controller-builder/input-builder/steps/after-body-step.ts
+var AfterBodyStep = class {
+	paramsSchema;
+	querySchema;
+	bodySchema;
+	constructor(paramsSchema, querySchema, bodySchema) {
+		this.paramsSchema = paramsSchema;
+		this.querySchema = querySchema;
+		this.bodySchema = bodySchema;
+	}
+	getSchemas() {
+		return {
+			params: this.paramsSchema,
+			query: this.querySchema,
+			body: this.bodySchema
+		};
+	}
+};
+//#endregion
+//#region src/classes/controller-builder/input-builder/steps/after-query-step.ts
+var AfterQueryStep = class {
+	paramsSchema;
+	querySchema;
+	constructor(paramsSchema, querySchema) {
+		this.paramsSchema = paramsSchema;
+		this.querySchema = querySchema;
+	}
+	body(schema) {
+		return new AfterBodyStep(this.paramsSchema, this.querySchema, schema);
+	}
+	getSchemas() {
+		return {
+			params: this.paramsSchema,
+			query: this.querySchema,
+			body: null
+		};
+	}
+};
+//#endregion
+//#region src/classes/controller-builder/input-builder/steps/after-params-step.ts
+var AfterParamsStep = class {
+	paramsSchema;
+	constructor(paramsSchema) {
+		this.paramsSchema = paramsSchema;
+	}
+	query(schema) {
+		return new AfterQueryStep(this.paramsSchema, schema);
+	}
+	body(schema) {
+		return new AfterBodyStep(this.paramsSchema, null, schema);
+	}
+	getSchemas() {
+		return {
+			params: this.paramsSchema,
+			query: null,
+			body: null
+		};
+	}
+};
+//#endregion
+//#region src/classes/controller-builder/input-builder/input-builder.ts
+var InputBuilder = class {
+	params(schema) {
+		return new AfterParamsStep(schema);
+	}
+	query(schema) {
+		return new AfterQueryStep(null, schema);
+	}
+	body(schema) {
+		return new AfterBodyStep(null, null, schema);
+	}
+};
+//#endregion
+//#region src/classes/controller-builder/steps/output-step.ts
+var OutputStep = class {
 	injectable;
-	integrator;
+	createRoute;
 	method;
 	path;
-	channel;
-	schema;
-	constructor(injectable, integrator, method, path, channel, schema) {
+	schemas;
+	constructor(injectable, createRoute, method, path, schemas) {
 		this.injectable = injectable;
-		this.integrator = integrator;
+		this.createRoute = createRoute;
 		this.method = method;
 		this.path = path;
-		this.channel = channel;
-		this.schema = schema;
+		this.schemas = schemas;
 	}
 	output(outputFn) {
-		const product = this.integrator({
-			type: "sanitized",
+		const route = this.createRoute({
 			injectable: this.injectable,
 			method: this.method,
 			path: this.path,
-			channel: this.channel,
-			schema: this.schema,
+			schemas: this.schemas,
 			outputFn
 		});
-		return (() => product);
+		return (() => route);
 	}
 };
 //#endregion
-//#region src/classes/controller-contract-controller-builder/builder-steps/post-endpoint-step.ts
-var PostEndpointStep = class {
+//#region src/classes/controller-builder/steps/input-step.ts
+var InputStep = class {
 	injectable;
-	integrator;
+	createRoute;
 	method;
 	path;
-	constructor(injectable, integrator, method, path) {
+	constructor(injectable, createRoute, method, path) {
 		this.injectable = injectable;
-		this.integrator = integrator;
+		this.createRoute = createRoute;
 		this.method = method;
 		this.path = path;
 	}
-	input(channel, schema) {
-		return new PostInputStep(this.injectable, this.integrator, this.method, this.path, channel, schema);
+	input(inputBuilderFn) {
+		const schemas = inputBuilderFn(new InputBuilder()).getSchemas();
+		return new OutputStep(this.injectable, this.createRoute, this.method, this.path, schemas);
 	}
 	output(outputFn) {
-		const product = this.integrator({
-			type: "nullary",
+		const route = this.createRoute({
+			injectable: this.injectable,
 			method: this.method,
 			path: this.path,
-			injectable: this.injectable,
+			schemas: {
+				params: null,
+				query: null,
+				body: null
+			},
 			outputFn
 		});
-		return (() => product);
+		return (() => route);
 	}
 };
 //#endregion
-//#region src/classes/controller-contract-controller-builder/builder-steps/post-inject-step.ts
-var PostInjectStep = class {
+//#region src/classes/controller-builder/steps/endpoint-step.ts
+var EndpointStep = class {
 	injectable;
-	integrator;
-	constructor(injectable, integrator) {
+	createRoute;
+	constructor(injectable, createRoute) {
 		this.injectable = injectable;
-		this.integrator = integrator;
+		this.createRoute = createRoute;
 	}
 	endpoint(method, path) {
-		return new PostEndpointStep(this.injectable, this.integrator, method, path);
+		return new InputStep(this.injectable, this.createRoute, method, path);
 	}
 };
 //#endregion
-//#region src/classes/controller-contract-controller-builder/controller-contract-controller-builder.ts
-var ControllerContractControllerBuilder = class {
-	injectableDefaultValue;
-	integrator;
-	constructor(injectableDefaultValue, integrator) {
-		this.injectableDefaultValue = injectableDefaultValue;
-		this.integrator = integrator;
+//#region src/classes/controller-builder/controller-builder.ts
+var ControllerBuilder = class {
+	defaultInjectable;
+	createRoute;
+	constructor(defaultInjectable, createRoute) {
+		this.defaultInjectable = defaultInjectable;
+		this.createRoute = createRoute;
 	}
 	inject(injectable) {
-		return new PostInjectStep(injectable, this.integrator);
+		return new EndpointStep(injectable, this.createRoute);
 	}
 	endpoint(method, path) {
-		return new PostEndpointStep(this.injectableDefaultValue, this.integrator, method, path);
+		return new InputStep(this.defaultInjectable, this.createRoute, method, path);
 	}
 };
 //#endregion
-//#region src/classes/controller-contract-controller-router/controller-contract-controller-router.ts
-var ControllerContractControllerRouter = class {
-	integrator;
+//#region src/classes/controller-router.ts
+var ControllerRouter = class {
+	combineRoutes;
 	routes;
-	constructor(integrator, routes) {
-		this.integrator = integrator;
+	constructor(combineRoutes, routes) {
+		this.combineRoutes = combineRoutes;
 		this.routes = routes;
 	}
-	getIntegratedRouter() {
-		return this.integrator(this.routes);
+	/**
+	* @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);
 	}
 };
 //#endregion
-//#region src/classes/controller-contract-controller-router/controller-contract-controller-router-factory.ts
-var ControllerContractControllerRouterFactory = class {
-	integrator;
-	constructor(integrator) {
-		this.integrator = integrator;
-	}
-	createControllerContractControllerRouter(routes) {
-		return new ControllerContractControllerRouter(this.integrator, routes);
+//#region src/classes/controller-router-factory.ts
+var ControllerRouterFactory = class {
+	combineRoutes;
+	constructor(combineRoutes) {
+		this.combineRoutes = combineRoutes;
+	}
+	/**
+	* @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(routes) {
+		return new ControllerRouter(this.combineRoutes, routes);
 	}
 };
 //#endregion
-//#region src/classes/framework-integration-factory.ts
-var FrameworkIntegrationFactory = class {
-	createControllerContractControllerBuilder(injectableDefaultValue, integrator) {
-		return new ControllerContractControllerBuilder(injectableDefaultValue, integrator);
-	}
-	createControllerContractControllerRouterFactory(integrator) {
-		return new ControllerContractControllerRouterFactory(integrator);
+//#region src/classes/framework-setup.ts
+/**
+* @example
+* const setup = new FrameworkSetup<Request, RequestHandler[], Router>();
+*/
+var FrameworkSetup = class {
+	/**
+	* @example
+	* const builder = setup.createControllerBuilder([], (blueprint) => { ... });
+	*/
+	createControllerBuilder(defaultInjectable, createRoute) {
+		return new ControllerBuilder(defaultInjectable, createRoute);
+	}
+	/**
+	* @example
+	* const routerFactory = setup.createControllerRouterFactory((routes) => { ... });
+	*/
+	createControllerRouterFactory(combineRoutes) {
+		return new ControllerRouterFactory(combineRoutes);
 	}
 };
 //#endregion
-//#region src/utils/outputs.ts
-let outputs;
-(function(_outputs) {
-	function next(data, code = 100) {
-		return {
-			type: "next",
-			code,
-			data
-		};
-	}
-	_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 { FrameworkIntegrationFactory, StandardOutputs, outputs, rootOnly };
+export { FrameworkSetup };

package/dist/utils.d.mts

@@ -0,0 +1,2 @@
+import { n as rootOnly, r as outputs, t as StandardOutputs } from "./index-DvVe6qYj.mjs";
+export { StandardOutputs, outputs, rootOnly };

package/dist/utils.mjs

@@ -0,0 +1,59 @@
+//#region src/utils/outputs.ts
+const outputs = Object.freeze({
+	next(data, code = 100) {
+		return {
+			type: "next",
+			code,
+			data
+		};
+	},
+	pass(data, code = 200) {
+		return {
+			type: "pass",
+			code,
+			data
+		};
+	},
+	fail(data, code = 400) {
+		return {
+			type: "fail",
+			code,
+			data
+		};
+	},
+	/**
+	* Used to escape the controller contract state machine, useful for redirects.
+	*/
+	exit() {
+		return { type: "exit" };
+	}
+});
+//#endregion
+//#region src/utils/root-only.ts
+/**
+* Useful for quickly sending a root level error to the client.
+*/
+function rootOnly(message) {
+	return [{
+		key: "root",
+		message
+	}];
+}
+//#endregion
+//#region src/utils/standard-outputs.ts
+/**
+* Useful for quick http basic responses.
+*/
+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 { StandardOutputs, outputs, rootOnly };

package/package.json

@@ -1,30 +1,34 @@
 {
   "name": "@controller-contract/server",
-  "type": "module",
-  "version": "0.3.3",
-  "author": "kennychulo",
+  "version": "0.4.0",
   "license": "MIT",
+  "author": "kennychulo",
   "files": [
     "dist",
     "src",
     "LICENSE",
     "package.json"
   ],
+  "type": "module",
   "exports": {
     ".": "./dist/index.mjs",
+    "./utils": "./dist/utils.mjs",
     "./package.json": "./package.json"
   },
   "publishConfig": {
     "access": "public"
   },
-  "devDependencies": {
-    "@controller-contract/core": "0.3.2"
-  },
   "dependencies": {
     "@standard-schema/spec": "1.1.0"
   },
+  "devDependencies": {
+    "@controller-contract/core": "0.4.2"
+  },
   "peerDependencies": {
-    "@controller-contract/core": "0.3.2"
+    "@controller-contract/core": "0.4.2"
+  },
+  "engines": {
+    "node": ">=24"
   },
   "scripts": {
     "build": "tsdown",

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

@@ -0,0 +1,24 @@
+import type { Method } from '@controller-contract/core';
+
+import type { CreateRouteFn } from '../../types';
+import { EndpointStep } from './steps/endpoint-step';
+import { InputStep } from './steps/input-step';
+
+export class ControllerBuilder<TFrameworkContext, TFrameworkInjectable, TFrameworkRouter> {
+  constructor(
+    private readonly defaultInjectable: TFrameworkInjectable,
+    private readonly createRoute: CreateRouteFn<
+      TFrameworkContext,
+      TFrameworkInjectable,
+      TFrameworkRouter
+    >,
+  ) {}
+
+  inject(injectable: TFrameworkInjectable) {
+    return new EndpointStep(injectable, this.createRoute);
+  }
+
+  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath) {
+    return new InputStep(this.defaultInjectable, this.createRoute, method, path);
+  }
+}

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

@@ -0,0 +1,20 @@
+import type { NoInput } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import { AfterBodyStep } from './steps/after-body-step';
+import { AfterParamsStep } from './steps/after-params-step';
+import { AfterQueryStep } from './steps/after-query-step';
+
+export class InputBuilder {
+  params<TParams>(schema: StandardSchemaV1<any, TParams>) {
+    return new AfterParamsStep<TParams>(schema);
+  }
+
+  query<TQuery>(schema: StandardSchemaV1<any, TQuery>) {
+    return new AfterQueryStep<NoInput, TQuery>(null, schema);
+  }
+
+  body<TBody>(schema: StandardSchemaV1<any, TBody>) {
+    return new AfterBodyStep<NoInput, NoInput, TBody>(null, null, schema);
+  }
+}

package/src/classes/controller-builder/input-builder/steps/after-body-step.ts

@@ -0,0 +1,19 @@
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import type { ControllerBlueprintSchemas, Endable } from '../../../../interfaces';
+
+export class AfterBodyStep<TParams, TQuery, TBody> implements Endable<TParams, TQuery, TBody> {
+  constructor(
+    private readonly paramsSchema: StandardSchemaV1<any, TParams> | null,
+    private readonly querySchema: StandardSchemaV1<any, TQuery> | null,
+    private readonly bodySchema: StandardSchemaV1<any, TBody>,
+  ) {}
+
+  getSchemas(): ControllerBlueprintSchemas<TParams, TQuery, TBody> {
+    return {
+      params: this.paramsSchema,
+      query: this.querySchema,
+      body: this.bodySchema,
+    };
+  }
+}

package/src/classes/controller-builder/input-builder/steps/after-params-step.ts

@@ -0,0 +1,26 @@
+import type { NoInput } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import type { ControllerBlueprintSchemas, Endable } from '../../../../interfaces';
+import { AfterBodyStep } from './after-body-step';
+import { AfterQueryStep } from './after-query-step';
+
+export class AfterParamsStep<TParams> implements Endable<TParams, NoInput, NoInput> {
+  constructor(private readonly paramsSchema: StandardSchemaV1<any, TParams>) {}
+
+  query<TQuery>(schema: StandardSchemaV1<any, TQuery>) {
+    return new AfterQueryStep<TParams, TQuery>(this.paramsSchema, schema);
+  }
+
+  body<TBody>(schema: StandardSchemaV1<any, TBody>) {
+    return new AfterBodyStep<TParams, NoInput, TBody>(this.paramsSchema, null, schema);
+  }
+
+  getSchemas(): ControllerBlueprintSchemas<TParams, NoInput, NoInput> {
+    return {
+      params: this.paramsSchema,
+      query: null,
+      body: null,
+    };
+  }
+}

package/src/classes/controller-builder/input-builder/steps/after-query-step.ts

@@ -0,0 +1,24 @@
+import type { NoInput } from '@controller-contract/core';
+import type { StandardSchemaV1 } from '@standard-schema/spec';
+
+import type { ControllerBlueprintSchemas, Endable } from '../../../../interfaces';
+import { AfterBodyStep } from './after-body-step';
+
+export class AfterQueryStep<TParams, TQuery> implements Endable<TParams, TQuery, NoInput> {
+  constructor(
+    private readonly paramsSchema: StandardSchemaV1<any, TParams> | null,
+    private readonly querySchema: StandardSchemaV1<any, TQuery>,
+  ) {}
+
+  body<TBody>(schema: StandardSchemaV1<any, TBody>) {
+    return new AfterBodyStep<TParams, TQuery, TBody>(this.paramsSchema, this.querySchema, schema);
+  }
+
+  getSchemas(): ControllerBlueprintSchemas<TParams, TQuery, NoInput> {
+    return {
+      params: this.paramsSchema,
+      query: this.querySchema,
+      body: null,
+    };
+  }
+}

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

@@ -0,0 +1,19 @@
+import type { Method } from '@controller-contract/core';
+
+import type { CreateRouteFn } from '../../../types';
+import { InputStep } from './input-step';
+
+export class EndpointStep<TFrameworkContext, TFrameworkInjectable, TFrameworkRouter> {
+  constructor(
+    private readonly injectable: TFrameworkInjectable,
+    private readonly createRoute: CreateRouteFn<
+      TFrameworkContext,
+      TFrameworkInjectable,
+      TFrameworkRouter
+    >,
+  ) {}
+
+  endpoint<const TMethod extends Method, const TPath extends string>(method: TMethod, path: TPath) {
+    return new InputStep(this.injectable, this.createRoute, method, path);
+  }
+}

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

@@ -0,0 +1,67 @@
+import type {
+  ExitOutput,
+  FailOutput,
+  Method,
+  NoInput,
+  PassOutput,
+  PathParams,
+} from '@controller-contract/core';
+
+import type { Controller, CreateRouteFn, InputBuilderFn, OutputFn, Prettify } from '../../../types';
+import { InputBuilder } from '../input-builder/input-builder';
+import { OutputStep } from './output-step';
+
+export class InputStep<
+  TFrameworkContext,
+  TFrameworkInjectable,
+  TFrameworkRouter,
+  const TMethod extends Method,
+  const TPath extends string,
+> {
+  constructor(
+    private readonly injectable: TFrameworkInjectable,
+    private readonly createRoute: CreateRouteFn<
+      TFrameworkContext,
+      TFrameworkInjectable,
+      TFrameworkRouter
+    >,
+    private readonly method: TMethod,
+    private readonly path: TPath,
+  ) {}
+
+  input<TParams, TQuery, TBody>(inputBuilderFn: InputBuilderFn<TParams, TQuery, TBody>) {
+    const inputBuilder = new InputBuilder();
+
+    const schemas = inputBuilderFn(inputBuilder).getSchemas();
+
+    return new OutputStep(this.injectable, this.createRoute, this.method, this.path, schemas);
+  }
+
+  output<TOutput extends PassOutput<any> | FailOutput<any> | ExitOutput>(
+    outputFn: OutputFn<TFrameworkContext, Prettify<PathParams<TPath>>, NoInput, NoInput, TOutput>,
+  ) {
+    const route = this.createRoute({
+      injectable: this.injectable,
+      method: this.method,
+      path: this.path,
+      schemas: {
+        params: null,
+        query: null,
+        body: null,
+      },
+      outputFn,
+    });
+
+    return <
+      Controller<
+        TMethod,
+        TPath,
+        Prettify<PathParams<TPath>>,
+        NoInput,
+        NoInput,
+        TOutput,
+        TFrameworkRouter
+      >
+    >(() => route);
+  }
+}