The rewrite

packages/api/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@make-api/api",
+  "type": "module"
+}

packages/api/src/Api.ts

@@ -0,0 +1,148 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Schema as S } from "@effect/schema";
+import type { Field } from "./Field";
+import type { Method } from "./Method";
+import type { MimeTypePredicate } from "./MimeType";
+import { QueryEmpty, type Query } from "./Query";
+import { RequestBodyFile, RequestBodyJson, RequestBodyMultipart, RequestBodyNone, RequestBodyText, RequestBodyUrlEncoded, type RequestBody } from "./RequestBody";
+import { ResponseBodyFile, ResponseBodyJson, ResponseBodyText, ResponseEmpty, type ResponseBody } from "./ResponseBody";
+import { Route, RouteLiteral, RouteParam } from "./Route";
+
+export interface Api<Props extends Api.PropsAny> {
+	readonly method: Method;
+	readonly props: Props;
+}
+
+export namespace Api {
+	export type Any = Api<PropsAny>;
+
+	export type Props<T extends Api.Any> = T extends Api<infer Props> ? Props : never;
+
+	export type PropsAny = {
+		readonly route: Route.Any;
+		readonly request: RequestBody.Any;
+		readonly response: { readonly [_: number]: ResponseBody.Any };
+		readonly query: Query.Any;
+	};
+}
+
+export const Api = <const Props extends Api.PropsAny>(method: Method, props: Props): Api<Props> => Object.freeze<Api<Props>>({
+	method,
+	props,
+});
+
+// --- BUILDERS ----------------------------------------------------------------
+
+export type RouteInputLiteral<Literal extends string> = Literal;
+
+export type RouteInputParam<Name extends string, Schema extends S.Schema<any, string, unknown>> = readonly [Name, Schema];
+
+export namespace RouteInputLiteral {
+	export type Any = RouteInputLiteral<string>;
+}
+
+export namespace RouteInputParam {
+	export type Any = RouteInputParam<string, S.Schema<any, string, unknown>>;
+}
+
+export namespace RouteInput {
+	export type Any = readonly (
+		| RouteInputLiteral.Any
+		| RouteInputParam.Any
+	)[];
+
+	export type Route<R extends RouteInput.Any> = { readonly [K in keyof R]:
+		R[K] extends RouteInputLiteral<infer Literal> ? RouteLiteral<Literal>
+		: R[K] extends RouteInputParam<infer Name, infer Schema> ? RouteParam<Name, Schema>
+		: never;
+	};
+}
+
+export const make = <const R extends RouteInput.Any>(method: Method, ...routeInput: R): Api<{
+	readonly route: RouteInput.Route<R>,
+	readonly request: RequestBodyNone,
+	readonly response: {},
+	readonly query: {},
+}> => Api(method, {
+	route: Route(...routeInput.map((r) => typeof r === "string" ? RouteLiteral(r) : RouteParam(r[0], r[1])) as RouteInput.Route<R>),
+	request: RequestBodyNone,
+	response: ResponseEmpty,
+	query: QueryEmpty,
+});
+
+export const requestBodyText = <const Schema extends S.Schema<any, string, unknown>>(schema: Schema) =>
+	<const T extends Api.Any>({ method, props }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: RequestBodyText<Schema>,
+		readonly response: T["props"]["response"],
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, request: RequestBodyText(schema) });
+
+export const requestBodyJson = <const Schema extends S.Schema.Any>(schema: Schema) =>
+	<const T extends Api.Any>({ method, props }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: RequestBodyJson<Schema>,
+		readonly response: T["props"]["response"],
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, request: RequestBodyJson(schema) });
+
+export const requestBodyUrlEncoded = <const Fields extends { readonly [_: string]: Field.AnyUrlEncoded }>(fields: Fields) =>
+	<const T extends Api.Any>({ method, props }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: RequestBodyUrlEncoded<Fields>,
+		readonly response: T["props"]["response"],
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, request: RequestBodyUrlEncoded(fields) });
+
+export const requestBodyMultipart = <const Fields extends { readonly [_: string]: Field.Any }>(fields: Fields) =>
+	<const T extends Api.Any>({ method, props }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: RequestBodyMultipart<Fields>,
+		readonly response: T["props"]["response"],
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, request: RequestBodyMultipart(fields) });
+
+export const requestBodyFile = <const MimeType extends string>(mimeType: MimeTypePredicate<MimeType>) =>
+	<const T extends Api.Any>({ method, props }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: RequestBodyFile<MimeType>,
+		readonly response: T["props"]["response"],
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, request: RequestBodyFile(mimeType) });
+
+export const responseBodyText = <const Status extends number, const Schema extends S.Schema<any, string, unknown>>(status: Status, schema: Schema) =>
+	<const T extends Api.Any>({ method, props: { response, ...props } }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: T["props"]["request"],
+		readonly response: { readonly [K in keyof T["props"]["response"] | Status]: K extends Status ? ResponseBodyText<Schema> : T["props"]["response"][K] },
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, response: Object.freeze<any>({ ...response, [status]: ResponseBodyText(schema) }) });
+
+export const responseBodyJson = <const Status extends number, const Schema extends S.Schema.Any>(status: Status, schema: Schema) =>
+	<const T extends Api.Any>({ method, props: { response, ...props } }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: T["props"]["request"],
+		readonly response: { readonly [K in keyof T["props"]["response"] | Status]: K extends Status ? ResponseBodyJson<Schema> : T["props"]["response"][K] },
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, response: Object.freeze<any>({ ...response, [status]: ResponseBodyJson(schema) }) });
+
+export const responseBodyFile = <const Status extends number, const MimeType extends string>(status: Status, mimeType: MimeTypePredicate<MimeType>) =>
+	<const T extends Api.Any>({ method, props: { response, ...props } }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: T["props"]["request"],
+		readonly response: { readonly [K in keyof T["props"]["response"] | Status]: K extends Status ? ResponseBodyFile<MimeType> : T["props"]["response"][K] },
+		readonly query: T["props"]["query"],
+	}> => Api(method, { ...props, response: Object.freeze<any>({ ...response, [status]: ResponseBodyFile(mimeType) }) });
+
+export const query = <const Query extends Query.Any>(query: Query) =>
+	<const T extends Api.Any>({ method, props: { query: _, ...props } }: T): Api<{
+		readonly route: T["props"]["route"],
+		readonly request: T["props"]["request"],
+		readonly response: T["props"]["response"],
+		readonly query: Query,
+	}> => Api(method, { ...props, query });

packages/api/src/Field.ts

@@ -0,0 +1,74 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Schema as S } from "@effect/schema";
+import type { MimeTypePredicate } from "./MimeType";
+import type { Multiplicity } from "./Multiplicity";
+
+// --- INTERFACES --------------------------------------------------------------
+
+export interface FieldText<M extends Multiplicity, Schema extends S.Schema<any, string, unknown>> {
+	readonly _tag: "Text";
+	readonly multiplicity: M;
+	readonly schema: Schema;
+}
+
+export interface FieldJson<M extends Multiplicity, Schema extends S.Schema.Any> {
+	readonly _tag: "Json";
+	readonly multiplicity: M;
+	readonly schema: Schema;
+}
+
+export interface FieldFile<M extends Multiplicity, MimeType extends string> {
+	readonly _tag: "File";
+	readonly multiplicity: M;
+	readonly mimeType: MimeTypePredicate<MimeType>;
+}
+
+export namespace FieldText {
+	export type Any = FieldText<Multiplicity, S.Schema<any, string, unknown>>;
+}
+
+export namespace FieldJson {
+	export type Any = FieldJson<Multiplicity, S.Schema.Any>;
+}
+
+export namespace FieldFile {
+	export type Any = FieldFile<Multiplicity, string>;
+}
+
+export namespace Field {
+	export type Any =
+		| FieldText.Any
+		| FieldJson.Any
+		| FieldFile.Any
+		;
+
+	export type AnyUrlEncoded =
+		| FieldText.Any
+		| FieldJson.Any
+		;
+}
+
+// --- CONSTRUCTORS ------------------------------------------------------------
+
+export const FieldText = <const M extends Multiplicity, const Schema extends S.Schema<any, string, unknown>>(multiplicity: M, schema: Schema): FieldText<M, Schema> => Object.freeze<FieldText<M, Schema>>({
+	_tag: "Text",
+	multiplicity,
+	schema,
+});
+
+export const FieldJson = <const M extends Multiplicity, const Schema extends S.Schema.Any>(multiplicity: M, schema: Schema): FieldJson<M, Schema> => Object.freeze<FieldJson<M, Schema>>({
+	_tag: "Json",
+	multiplicity,
+	schema,
+});
+
+export const FieldFile = <const M extends Multiplicity, const MimeType extends string>(multiplicity: M, mimeType: MimeTypePredicate<MimeType>): FieldFile<M, MimeType> => Object.freeze<FieldFile<M, MimeType>>({
+	_tag: "File",
+	multiplicity,
+	mimeType,
+});

packages/api/src/Method.ts

@@ -0,0 +1,13 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+export type Method =
+	| "GET"
+	| "POST"
+	| "PUT"
+	| "DELETE"
+	| "PATCH"
+	;

packages/api/src/MimeType.ts

@@ -0,0 +1,9 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Predicate } from "effect"
+
+export type MimeTypePredicate<T extends string> = T | readonly T[] | Predicate.Refinement<string, T>;

packages/api/src/Multiplicity.ts

@@ -0,0 +1,23 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import type { Option as O } from "effect";
+
+export type Multiplicity =
+	| "single"
+	| "optional"
+	| "multiple"
+	| "any"
+	;
+
+export namespace Multiplicity {
+	export type With<M extends Multiplicity, T> = {
+		single: T,
+		optional: O.Option<T>,
+		multiple: readonly [T, ...T[]],
+		any: readonly T[],
+	}[M];
+}

packages/api/src/Query.ts

@@ -0,0 +1,13 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import type { Field } from "./Field";
+
+export namespace Query {
+	export type Any = { readonly [_: string]: Field.AnyUrlEncoded };
+}
+
+export const QueryEmpty: {} = Object.freeze<{}>({});

packages/api/src/RequestBody.ts

@@ -0,0 +1,102 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Schema as S } from "@effect/schema";
+import type { Field } from "./Field";
+import type { MimeTypePredicate } from "./MimeType";
+
+// --- INTERFACES --------------------------------------------------------------
+
+export interface RequestBodyNone {
+	readonly _tag: "None";
+}
+
+export interface RequestBodyText<Schema extends S.Schema<any, string, unknown>> {
+	readonly _tag: "Text";
+	readonly schema: Schema;
+}
+
+export interface RequestBodyJson<Schema extends S.Schema.Any> {
+	readonly _tag: "Json";
+	readonly schema: Schema;
+}
+
+export interface RequestBodyUrlEncoded<Fields extends { readonly [_: string]: Field.AnyUrlEncoded }> {
+	readonly _tag: "UrlEncoded";
+	readonly fields: Readonly<Fields>;
+}
+
+export interface RequestBodyMultipart<Fields extends { readonly [_: string]: Field.Any }> {
+	readonly _tag: "Multipart";
+	readonly fields: Readonly<Fields>;
+}
+
+export interface RequestBodyFile<MimeType extends string> {
+	readonly _tag: "File";
+	readonly mimeType: MimeTypePredicate<MimeType>;
+}
+
+export namespace RequestBodyText {
+	export type Any = RequestBodyText<S.Schema<any, string, unknown>>;
+}
+
+export namespace RequestBodyJson {
+	export type Any = RequestBodyJson<S.Schema.Any>;
+}
+
+export namespace RequestBodyUrlEncoded {
+	export type Any = RequestBodyUrlEncoded<{}>;
+}
+
+export namespace RequestBodyMultipart {
+	export type Any = RequestBodyMultipart<{}>;
+}
+
+export namespace RequestBodyFile {
+	export type Any = RequestBodyFile<string>;
+}
+
+export namespace RequestBody {
+	export type Any =
+		| RequestBodyNone
+		| RequestBodyText.Any
+		| RequestBodyJson.Any
+		| RequestBodyUrlEncoded.Any
+		| RequestBodyMultipart.Any
+		| RequestBodyFile.Any
+		;
+}
+
+// --- CONSTRUCTORS ------------------------------------------------------------
+
+export const RequestBodyNone: RequestBodyNone = Object.freeze<RequestBodyNone>({
+	_tag: "None",
+});
+
+export const RequestBodyText = <const Schema extends S.Schema<any, string, unknown>>(schema: Schema): RequestBodyText<Schema> => Object.freeze<RequestBodyText<Schema>>({
+	_tag: "Text",
+	schema,
+});
+
+export const RequestBodyJson = <const Schema extends S.Schema.Any>(schema: Schema): RequestBodyJson<Schema> => Object.freeze<RequestBodyJson<Schema>>({
+	_tag: "Json",
+	schema,
+});
+
+export const RequestBodyUrlEncoded = <const Fields extends { readonly [_: string]: Field.AnyUrlEncoded }>(fields: Fields): RequestBodyUrlEncoded<Fields> => Object.freeze<RequestBodyUrlEncoded<Fields>>({
+	_tag: "UrlEncoded",
+	fields,
+});
+
+export const RequestBodyMultipart = <const Fields extends { readonly [_: string]: Field.Any }>(fields: Fields): RequestBodyMultipart<Fields> => Object.freeze<RequestBodyMultipart<Fields>>({
+	_tag: "Multipart",
+	fields,
+});
+
+export const RequestBodyFile = <const MimeType extends string>(mimeType: MimeTypePredicate<MimeType>): RequestBodyFile<MimeType> => Object.freeze<RequestBodyFile<MimeType>>({
+	_tag: "File",
+	mimeType,
+});

packages/api/src/ResponseBody.ts

@@ -0,0 +1,90 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Schema as S } from "@effect/schema";
+import type { MimeTypePredicate } from "./MimeType";
+
+// --- INTERFACES --------------------------------------------------------------
+
+export interface ResponseBodyNone {
+	readonly _tag: "None";
+}
+
+export interface ResponseBodyText<Schema extends S.Schema<any, string, unknown>> {
+	readonly _tag: "Text";
+	readonly schema: Schema;
+}
+
+export interface ResponseBodyJson<Schema extends S.Schema.Any> {
+	readonly _tag: "Json";
+	readonly schema: Schema;
+}
+
+export interface ResponseBodyFile<MimeType extends string> {
+	readonly _tag: "File";
+	readonly mimeType: MimeTypePredicate<MimeType>;
+}
+
+export namespace ResponseBodyText {
+	export type Any = ResponseBodyText<S.Schema<any, string, unknown>>;
+}
+
+export namespace ResponseBodyJson {
+	export type Any = ResponseBodyJson<S.Schema.Any>;
+}
+
+export namespace ResponseBodyFile {
+	export type Any = ResponseBodyFile<string>;
+}
+
+export namespace ResponseBody {
+	export type Any =
+		| ResponseBodyNone
+		| ResponseBodyText.Any
+		| ResponseBodyJson.Any
+		| ResponseBodyFile.Any
+		;
+}
+
+// --- CONSTRUCTORS ------------------------------------------------------------
+
+export const ResponseBodyNone: ResponseBodyNone = Object.freeze<ResponseBodyNone>({
+	_tag: "None",
+});
+
+export const ResponseBodyText = <const Schema extends S.Schema<any, string, unknown>>(schema: Schema): ResponseBodyText<Schema> => Object.freeze<ResponseBodyText<Schema>>({
+	_tag: "Text",
+	schema,
+});
+
+export const ResponseBodyJson = <const Schema extends S.Schema.Any>(schema: Schema): ResponseBodyJson<Schema> => Object.freeze<ResponseBodyJson<Schema>>({
+	_tag: "Json",
+	schema,
+});
+
+export const ResponseBodyFile = <const MimeType extends string>(mimeType: MimeTypePredicate<MimeType>): ResponseBodyFile<MimeType> => Object.freeze<ResponseBodyFile<MimeType>>({
+	_tag: "File",
+	mimeType,
+});
+
+export const ResponseEmpty: {} = Object.freeze<{}>({});
+import type { Option as O } from "effect";
+
+export type Multiplicity =
+	| "single"
+	| "optional"
+	| "multiple"
+	| "any"
+	;
+
+export namespace Multiplicity {
+	export type With<M extends Multiplicity, T> = {
+		single: T,
+		optional: O.Option<T>,
+		multiple: readonly [T, ...T[]],
+		any: readonly T[],
+	}[M];
+}

packages/api/src/Route.ts

@@ -0,0 +1,50 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Schema as S } from "@effect/schema";
+
+// --- INTERFACES --------------------------------------------------------------
+
+export interface RouteLiteral<Literal extends string> {
+	readonly _tag: "Literal";
+	readonly literal: Literal;
+}
+
+export interface RouteParam<Name extends string, Schema extends S.Schema<any, string, unknown>> {
+	readonly _tag: "Param";
+	readonly name: Name;
+	readonly schema: Schema;
+}
+
+export namespace RouteLiteral {
+	export type Any = RouteLiteral<string>;
+}
+
+export namespace RouteParam {
+	export type Any = RouteParam<string, S.Schema<any, string, unknown>>;
+}
+
+export namespace Route {
+	export type Any = readonly (
+		| RouteLiteral.Any
+		| RouteParam.Any
+	)[];
+}
+
+// --- CONSTRUCTORS ------------------------------------------------------------
+
+export const RouteLiteral = <const Literal extends string>(literal: Literal): RouteLiteral<Literal> => Object.freeze<RouteLiteral<Literal>>({
+	_tag: "Literal",
+	literal,
+});
+
+export const RouteParam = <const Name extends string, const Schema extends S.Schema<any, string, unknown>>(name: Name, schema: Schema): RouteParam<Name, Schema> => Object.freeze<RouteParam<Name, Schema>>({
+	_tag: "Param",
+	name,
+	schema,
+});
+
+export const Route = <const Route extends Route.Any>(...route: Route): Route => Object.freeze<Route>(route);

packages/backend/package.json

@@ -0,0 +1,7 @@
+{
+  "name": "@make-api/backend",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
+}

packages/backend/src/Api.ts

@@ -0,0 +1,107 @@
+/*!
+ * This Source Code Form is subject to the terms of the Mozilla Public License,
+ * v. 2.0. If a copy of the MPL was not distributed with this file, You can
+ * obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+import { Schema as S } from "@effect/schema";
+import * as Api from "@make-api/api/Api";
+import * as Query from "@make-api/api/Query";
+import * as RequestBody from "@make-api/api/RequestBody";
+import * as Route from "@make-api/api/Route";
+import { Array as A, Effect, Match, Option as O, Record as R, pipe } from "effect";
+
+const getUsers = pipe(
+	Api.make("GET", "/users"),
+	Api.responseBodyJson(200, S.Array(S.Struct({
+		userId: S.UUID,
+		username: S.String,
+		email: S.String,
+	}))),
+	Api.responseBodyJson(500, S.Struct({
+		error: S.String,
+		stackTrace: S.optional(S.String, { exact: true }),
+	})),
+);
+
+type RouteParams<T extends Route.Route.Any> = { readonly [_: string]: unknown }; // TODO
+
+const matchesRoute = <T extends Route.Route.Any>(route: T, pathComponents: readonly string[]): boolean => {
+	if (route.length !== pathComponents.length) return false;
+	return pipe(
+		A.zip(route, pathComponents),
+		A.every(([token, pathComponent]) => token._tag !== "Literal" || token.literal === pathComponent),
+	);
+};
+
+const parseRoute = <T extends Route.Route.Any>(route: T) => {
+	const decoder = pipe(
+		route,
+		A.filterMap((r) => r._tag === "Param" ? O.some([r.name, r.schema] as const) : O.none()),
+		R.fromEntries,
+		S.Struct,
+		(_) => S.decode(_, { errors: "all" }),
+	);
+
+	return (pathComponents: readonly string[]) => pipe(
+		pathComponents,
+		A.filterMap((c, i) => {
+			const r = route[i];
+			return r._tag === "Param" ? O.some([r.name, c] as const) : O.none();
+		}),
+		R.fromEntries,
+		decoder,
+	);
+};
+
+const parseQuery = <T extends Query.Query.Any>(query: T) => {
+	const decoder = pipe();
+
+	return (searchParams: URLSearchParams) => pipe();
+};
+
+const parseBody = <T extends RequestBody.RequestBody.Any>(requestBody: T) => {
+	const decoder = pipe(
+		Match.value<RequestBody.RequestBody.Any>(requestBody),
+		Match.tags({
+			None: () => {},
+			Text: () => {},
+			Json: () => {},
+			UrlEncoded: () => {},
+			Multipart: () => {},
+			File: () => {},
+		}),
+	);
+
+	return (req: Request) => pipe();
+};
+
+const routeParser = parseRoute(getUsers.props.route);
+const queryParser = parseQuery(getUsers.props.query);
+const bodyParser = parseBody(getUsers.props.request);
+
+Bun.serve({
+	fetch: (req) => {
+		const url = new URL(req.url);
+
+		const pathname = url.pathname;
+		const pathComponents = pathname.replaceAll(/^\/|\/$/g, "").split("/");
+
+		const searchParams = url.searchParams;
+
+		if (matchesRoute(getUsers.props.route, pathComponents)) {
+			const paramsEffect = routeParser(pathComponents);
+			const queryEffect = queryParser(searchParams);
+			const bodyEffect = bodyParser(req);
+
+			const effect = Effect.all({
+				params: paramsEffect,
+				query: queryEffect,
+				body: bodyEffect,
+			});
+		}
+	},
+	websocket: {
+		message: (ws, message) => {}
+	},
+});