fossyl 0.1.1

package/dist/index.d.mts

@@ -0,0 +1,204 @@
+type ExtractUrlParams<Path extends string> = Path extends `${string}/:${infer Param}/${infer Rest}` ? Param | ExtractUrlParams<Rest> : Path extends `${string}/:${infer Param}` ? Param : never;
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type Params<Path extends string> = Expand<{
+    [K in ExtractUrlParams<Path>]: string;
+}>;
+
+declare const authBrand: unique symbol;
+type Authentication = {
+    readonly [authBrand]: "Auth";
+};
+declare function authWrapper<T>(auth: T): T & Authentication;
+type RestMethod = "GET" | "POST" | "PUT" | "DELETE";
+type OpenRoute<Path extends string, Method extends RestMethod, Res extends unknown, Query extends unknown | undefined = undefined> = {
+    type: "open";
+    path: Path;
+    method: Method;
+    validator?: never;
+    authenticator?: never;
+    handler: (params: {
+        url: Params<Path>;
+        query: Query;
+    }) => Promise<Res>;
+};
+type AuthenticatedRoute<Path extends string, Method extends RestMethod, Res extends unknown, Auth extends Authentication, Query extends unknown | undefined = undefined> = {
+    type: "authenticated";
+    path: Path;
+    method: Method;
+    validator?: never;
+    authenticator: AuthenticationFunction<Auth>;
+    handler: (params: {
+        url: Params<Path>;
+        query: Query;
+    }, auth: Auth) => Promise<Res>;
+};
+type ValidatedRoute<Path extends string, Method extends RestMethod, Res extends unknown, RequestBody extends unknown, Query extends unknown | undefined = undefined> = {
+    type: "validated";
+    path: Path;
+    method: Method;
+    validator: ValidatorFunction<RequestBody>;
+    authenticator?: never;
+    handler: (params: {
+        url: Params<Path>;
+        query: Query;
+    }, body: RequestBody) => Promise<Res>;
+};
+type FullRoute<Path extends string, Method extends RestMethod, Res extends unknown, RequestBody extends unknown, Auth extends Authentication, Query extends unknown | undefined = undefined> = {
+    type: "full";
+    path: Path;
+    method: Method;
+    validator: ValidatorFunction<RequestBody>;
+    authenticator: AuthenticationFunction<Auth>;
+    handler: Query extends undefined ? (params: {
+        url: Params<Path>;
+    }, auth: Authentication, body: RequestBody) => Promise<Res> : (params: {
+        url: Params<Path>;
+        query: Query;
+    }, auth: Authentication, body: RequestBody) => Promise<Res>;
+};
+
+type ValidatorFunction<T extends unknown = unknown> = (data: unknown) => T;
+type AuthenticationFunction<T extends Authentication> = (headers: Record<string, string>) => T;
+/**
+ * This is the most confusing part of the type system, but also key.
+ * This type is used to force type inferenece when creating your endpoints.
+ * This is the structure to provide `function overload`s. This is so you can have the same function
+ * (in our case get,put,post,delete) but allow differnt configurations.
+ *
+ * These configurations need to be strongly typed force the developers into using the tools.
+ *
+ * Want to allow Auth? - Gotta pass in authenticator and the type system handles it
+ *
+ * Also, this is where the core of the Zod system is. We force the body to be a zod validated input.
+ * Luckily, this is pretty easy to replace.
+ * PART of me wanted to further abstract it such that you needed a translation function but
+ * that seemed overengineerd
+ *
+ */
+/**
+ * Configuration type for POST/PUT/DELETE endpoints.
+ * These methods require a request body, so they always need a validator.
+ *
+ * Four variants (with/without auth × with/without query):
+ * 1. Validated only, no query: validator + handler(params, body)
+ * 2. Validated only, with query: validator + queryValidator + handler(params, body)
+ * 3. Full (auth + validated), no query: authenticator + validator + handler(params, auth, body)
+ * 4. Full (auth + validated), with query: authenticator + validator + queryValidator + handler(params, auth, body)
+ */
+type EndpointCreationFunction<Path extends string, Method extends RestMethod> = {
+    <Res extends unknown, RequestBody extends unknown>(config: {
+        authenticator?: never;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }, body: RequestBody) => Promise<Res>;
+    }): ValidatedRoute<Path, Method, Res, RequestBody, undefined>;
+    <Res extends unknown, RequestBody extends unknown, Query extends unknown>(config: {
+        authenticator?: never;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }, body: RequestBody) => Promise<Res>;
+    }): ValidatedRoute<Path, Method, Res, RequestBody, Query>;
+    <Res extends unknown, RequestBody extends unknown, Auth extends Authentication>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }, auth: Auth, body: RequestBody) => Promise<Res>;
+    }): FullRoute<Path, Method, Res, RequestBody, Auth, undefined>;
+    <Res extends unknown, RequestBody extends unknown, Auth extends Authentication, Query extends unknown>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }, auth: Auth, body: RequestBody) => Promise<Res>;
+    }): FullRoute<Path, Method, Res, RequestBody, Auth, Query>;
+};
+/**
+ * Configuration type for GET/DELETE endpoints.
+ * These methods cannot have a request body, so no validator.
+ *
+ * Four variants (with/without auth × with/without query):
+ * 1. Open, no query: just handler(params)
+ * 2. Open, with query: queryValidator + handler(params)
+ * 3. Authenticated, no query: authenticator + handler(params, auth)
+ * 4. Authenticated, with query: authenticator + queryValidator + handler(params, auth)
+ */
+type GetEndpointCreationFunction<Path extends string, Method extends RestMethod> = {
+    <Res extends unknown>(config: {
+        authenticator?: never;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }) => Promise<Res>;
+    }): OpenRoute<Path, Method, Res, undefined>;
+    <Res extends unknown, Query extends unknown>(config: {
+        authenticator?: never;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }) => Promise<Res>;
+    }): OpenRoute<Path, Method, Res, Query>;
+    <Res extends unknown, Auth extends Authentication>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }, auth: Auth) => Promise<Res>;
+    }): AuthenticatedRoute<Path, Method, Res, Auth, undefined>;
+    <Res extends unknown, Auth extends Authentication, Query extends unknown>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }, auth: Auth) => Promise<Res>;
+    }): AuthenticatedRoute<Path, Method, Res, Auth, Query>;
+};
+
+type Endpoint<Path extends string> = {
+    get: GetEndpointCreationFunction<Path, "GET">;
+    post: EndpointCreationFunction<Path, "POST">;
+    put: EndpointCreationFunction<Path, "PUT">;
+    delete: GetEndpointCreationFunction<Path, "DELETE">;
+};
+/**
+ * Creates a router that ensures all endpoints extend the route.
+ * IDK if this is actually useful, but I kinda like it.
+ *
+ * There def was a part of me that thought about pure generator functions.
+ * In fact... they're provided!
+ *
+ * We can discuss that.
+ */
+type Router<BasePath extends string> = {
+    /**
+     * Creates an endpoint
+     * @param path string, must extend Router's string
+     */
+    createEndpoint: <Path extends `${BasePath}${string}`>(path: Path) => Endpoint<Path>;
+    /**
+     * Creates a subrouter
+     * @param path string, must extend Router's string
+     */
+    createSubrouter: <Path extends `${BasePath}${string}`>(path: Path) => Router<Path>;
+};
+
+/**
+ * Provides an Ednpoint creater. Would maybe like some other internal stuff? Lowkey... I think we
+ * all might just end up using the helper functions of get and del and such.
+ * @param _ - this param is still needed because the type is determined at compile time.
+ */
+declare function createRouter<BasePath extends string>(_: BasePath): Router<BasePath>;
+
+export { type AuthenticatedRoute, type Authentication, type AuthenticationFunction, type Endpoint, type FullRoute, type OpenRoute, type RestMethod, type Router, type ValidatedRoute, type ValidatorFunction, authWrapper, createRouter };

package/dist/index.d.ts

@@ -0,0 +1,204 @@
+type ExtractUrlParams<Path extends string> = Path extends `${string}/:${infer Param}/${infer Rest}` ? Param | ExtractUrlParams<Rest> : Path extends `${string}/:${infer Param}` ? Param : never;
+type Expand<T> = T extends infer O ? {
+    [K in keyof O]: O[K];
+} : never;
+type Params<Path extends string> = Expand<{
+    [K in ExtractUrlParams<Path>]: string;
+}>;
+
+declare const authBrand: unique symbol;
+type Authentication = {
+    readonly [authBrand]: "Auth";
+};
+declare function authWrapper<T>(auth: T): T & Authentication;
+type RestMethod = "GET" | "POST" | "PUT" | "DELETE";
+type OpenRoute<Path extends string, Method extends RestMethod, Res extends unknown, Query extends unknown | undefined = undefined> = {
+    type: "open";
+    path: Path;
+    method: Method;
+    validator?: never;
+    authenticator?: never;
+    handler: (params: {
+        url: Params<Path>;
+        query: Query;
+    }) => Promise<Res>;
+};
+type AuthenticatedRoute<Path extends string, Method extends RestMethod, Res extends unknown, Auth extends Authentication, Query extends unknown | undefined = undefined> = {
+    type: "authenticated";
+    path: Path;
+    method: Method;
+    validator?: never;
+    authenticator: AuthenticationFunction<Auth>;
+    handler: (params: {
+        url: Params<Path>;
+        query: Query;
+    }, auth: Auth) => Promise<Res>;
+};
+type ValidatedRoute<Path extends string, Method extends RestMethod, Res extends unknown, RequestBody extends unknown, Query extends unknown | undefined = undefined> = {
+    type: "validated";
+    path: Path;
+    method: Method;
+    validator: ValidatorFunction<RequestBody>;
+    authenticator?: never;
+    handler: (params: {
+        url: Params<Path>;
+        query: Query;
+    }, body: RequestBody) => Promise<Res>;
+};
+type FullRoute<Path extends string, Method extends RestMethod, Res extends unknown, RequestBody extends unknown, Auth extends Authentication, Query extends unknown | undefined = undefined> = {
+    type: "full";
+    path: Path;
+    method: Method;
+    validator: ValidatorFunction<RequestBody>;
+    authenticator: AuthenticationFunction<Auth>;
+    handler: Query extends undefined ? (params: {
+        url: Params<Path>;
+    }, auth: Authentication, body: RequestBody) => Promise<Res> : (params: {
+        url: Params<Path>;
+        query: Query;
+    }, auth: Authentication, body: RequestBody) => Promise<Res>;
+};
+
+type ValidatorFunction<T extends unknown = unknown> = (data: unknown) => T;
+type AuthenticationFunction<T extends Authentication> = (headers: Record<string, string>) => T;
+/**
+ * This is the most confusing part of the type system, but also key.
+ * This type is used to force type inferenece when creating your endpoints.
+ * This is the structure to provide `function overload`s. This is so you can have the same function
+ * (in our case get,put,post,delete) but allow differnt configurations.
+ *
+ * These configurations need to be strongly typed force the developers into using the tools.
+ *
+ * Want to allow Auth? - Gotta pass in authenticator and the type system handles it
+ *
+ * Also, this is where the core of the Zod system is. We force the body to be a zod validated input.
+ * Luckily, this is pretty easy to replace.
+ * PART of me wanted to further abstract it such that you needed a translation function but
+ * that seemed overengineerd
+ *
+ */
+/**
+ * Configuration type for POST/PUT/DELETE endpoints.
+ * These methods require a request body, so they always need a validator.
+ *
+ * Four variants (with/without auth × with/without query):
+ * 1. Validated only, no query: validator + handler(params, body)
+ * 2. Validated only, with query: validator + queryValidator + handler(params, body)
+ * 3. Full (auth + validated), no query: authenticator + validator + handler(params, auth, body)
+ * 4. Full (auth + validated), with query: authenticator + validator + queryValidator + handler(params, auth, body)
+ */
+type EndpointCreationFunction<Path extends string, Method extends RestMethod> = {
+    <Res extends unknown, RequestBody extends unknown>(config: {
+        authenticator?: never;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }, body: RequestBody) => Promise<Res>;
+    }): ValidatedRoute<Path, Method, Res, RequestBody, undefined>;
+    <Res extends unknown, RequestBody extends unknown, Query extends unknown>(config: {
+        authenticator?: never;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }, body: RequestBody) => Promise<Res>;
+    }): ValidatedRoute<Path, Method, Res, RequestBody, Query>;
+    <Res extends unknown, RequestBody extends unknown, Auth extends Authentication>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }, auth: Auth, body: RequestBody) => Promise<Res>;
+    }): FullRoute<Path, Method, Res, RequestBody, Auth, undefined>;
+    <Res extends unknown, RequestBody extends unknown, Auth extends Authentication, Query extends unknown>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        validator: ValidatorFunction<RequestBody>;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }, auth: Auth, body: RequestBody) => Promise<Res>;
+    }): FullRoute<Path, Method, Res, RequestBody, Auth, Query>;
+};
+/**
+ * Configuration type for GET/DELETE endpoints.
+ * These methods cannot have a request body, so no validator.
+ *
+ * Four variants (with/without auth × with/without query):
+ * 1. Open, no query: just handler(params)
+ * 2. Open, with query: queryValidator + handler(params)
+ * 3. Authenticated, no query: authenticator + handler(params, auth)
+ * 4. Authenticated, with query: authenticator + queryValidator + handler(params, auth)
+ */
+type GetEndpointCreationFunction<Path extends string, Method extends RestMethod> = {
+    <Res extends unknown>(config: {
+        authenticator?: never;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }) => Promise<Res>;
+    }): OpenRoute<Path, Method, Res, undefined>;
+    <Res extends unknown, Query extends unknown>(config: {
+        authenticator?: never;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }) => Promise<Res>;
+    }): OpenRoute<Path, Method, Res, Query>;
+    <Res extends unknown, Auth extends Authentication>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        queryValidator?: never;
+        handler: (params: {
+            url: Params<Path>;
+        }, auth: Auth) => Promise<Res>;
+    }): AuthenticatedRoute<Path, Method, Res, Auth, undefined>;
+    <Res extends unknown, Auth extends Authentication, Query extends unknown>(config: {
+        authenticator: AuthenticationFunction<Auth>;
+        queryValidator: ValidatorFunction<Query>;
+        handler: (params: {
+            url: Params<Path>;
+            query: Query;
+        }, auth: Auth) => Promise<Res>;
+    }): AuthenticatedRoute<Path, Method, Res, Auth, Query>;
+};
+
+type Endpoint<Path extends string> = {
+    get: GetEndpointCreationFunction<Path, "GET">;
+    post: EndpointCreationFunction<Path, "POST">;
+    put: EndpointCreationFunction<Path, "PUT">;
+    delete: GetEndpointCreationFunction<Path, "DELETE">;
+};
+/**
+ * Creates a router that ensures all endpoints extend the route.
+ * IDK if this is actually useful, but I kinda like it.
+ *
+ * There def was a part of me that thought about pure generator functions.
+ * In fact... they're provided!
+ *
+ * We can discuss that.
+ */
+type Router<BasePath extends string> = {
+    /**
+     * Creates an endpoint
+     * @param path string, must extend Router's string
+     */
+    createEndpoint: <Path extends `${BasePath}${string}`>(path: Path) => Endpoint<Path>;
+    /**
+     * Creates a subrouter
+     * @param path string, must extend Router's string
+     */
+    createSubrouter: <Path extends `${BasePath}${string}`>(path: Path) => Router<Path>;
+};
+
+/**
+ * Provides an Ednpoint creater. Would maybe like some other internal stuff? Lowkey... I think we
+ * all might just end up using the helper functions of get and del and such.
+ * @param _ - this param is still needed because the type is determined at compile time.
+ */
+declare function createRouter<BasePath extends string>(_: BasePath): Router<BasePath>;
+
+export { type AuthenticatedRoute, type Authentication, type AuthenticationFunction, type Endpoint, type FullRoute, type OpenRoute, type RestMethod, type Router, type ValidatedRoute, type ValidatorFunction, authWrapper, createRouter };

package/dist/index.js

@@ -0,0 +1,103 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  authWrapper: () => authWrapper,
+  createRouter: () => createRouter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/router/router.ts
+function createEndpoint(path) {
+  function get(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), { type: "authenticated", path, method: "GET" });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "open", path, method: "GET" });
+    }
+  }
+  function put(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), { type: "full", path, method: "PUT" });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "validated", path, method: "PUT" });
+    }
+  }
+  function post(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), { type: "full", path, method: "POST" });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "validated", path, method: "POST" });
+    }
+  }
+  function del(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), {
+        type: "authenticated",
+        path,
+        method: "DELETE"
+      });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "open", path, method: "DELETE" });
+    }
+  }
+  return {
+    get,
+    post,
+    put,
+    delete: del
+  };
+}
+function createRouter(_) {
+  return {
+    createEndpoint: (path) => createEndpoint(path),
+    createSubrouter: (path) => createRouter(path)
+  };
+}
+
+// src/router/types/routes.types.ts
+function authWrapper(auth) {
+  return __spreadProps(__spreadValues({}, auth), {
+    [authBrand]: "Auth"
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authWrapper,
+  createRouter
+});

package/dist/index.mjs

@@ -0,0 +1,78 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+
+// src/router/router.ts
+function createEndpoint(path) {
+  function get(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), { type: "authenticated", path, method: "GET" });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "open", path, method: "GET" });
+    }
+  }
+  function put(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), { type: "full", path, method: "PUT" });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "validated", path, method: "PUT" });
+    }
+  }
+  function post(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), { type: "full", path, method: "POST" });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "validated", path, method: "POST" });
+    }
+  }
+  function del(config) {
+    if ("authenticator" in config) {
+      return __spreadProps(__spreadValues({}, config), {
+        type: "authenticated",
+        path,
+        method: "DELETE"
+      });
+    } else {
+      return __spreadProps(__spreadValues({}, config), { type: "open", path, method: "DELETE" });
+    }
+  }
+  return {
+    get,
+    post,
+    put,
+    delete: del
+  };
+}
+function createRouter(_) {
+  return {
+    createEndpoint: (path) => createEndpoint(path),
+    createSubrouter: (path) => createRouter(path)
+  };
+}
+
+// src/router/types/routes.types.ts
+function authWrapper(auth) {
+  return __spreadProps(__spreadValues({}, auth), {
+    [authBrand]: "Auth"
+  });
+}
+export {
+  authWrapper,
+  createRouter
+};

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "fossyl",
+  "version": "0.1.1",
+  "description": "Type-safe REST API framework core - designed for AI-assisted development",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "CLAUDE.md",
+    "README.md"
+  ],
+  "keywords": [
+    "typescript",
+    "rest-api",
+    "type-safe",
+    "router",
+    "framework",
+    "ai-assisted",
+    "functional"
+  ],
+  "author": "YoyoSaur",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "clean": "rm -rf dist",
+    "typecheck": "tsc --noEmit"
+  }
+}

package/src/example.ts

@@ -0,0 +1,31 @@
+import { createRouter } from "./router/router";
+import { authWrapper } from "./router/types/routes.types";
+
+const authenticationMiddleware = (headers: Record<string, string>) => {
+  return authWrapper({
+    status: headers.authorization,
+  });
+};
+
+const baseRouter = createRouter("/status");
+const endpoint = baseRouter.createEndpoint("/status");
+
+const getter = endpoint.get({
+  authenticator: authenticationMiddleware,
+  handler: async (params, auth) => {
+    return {
+      status: "ok",
+    };
+  },
+});
+
+const poster = endpoint.post({
+  validator: (): { a: string } => ({ a: "hello" }),
+  queryValidator: (): {b: string} => ({b: "OKAY"}),
+  handler: async (params, body) => {
+    return {
+      status: "ok",
+    };
+  },
+});
+

package/src/index.ts

@@ -0,0 +1,22 @@
+// Router creation
+export { createRouter } from "./router/router";
+
+// Type exports
+export type {
+  Authentication,
+  OpenRoute,
+  AuthenticatedRoute,
+  ValidatedRoute,
+  FullRoute,
+  RestMethod,
+} from "./router/types/routes.types";
+
+export type {
+  ValidatorFunction,
+  AuthenticationFunction,
+} from "./router/types/configuration.types";
+
+export type { Endpoint, Router } from "./router/types/router-creation.types";
+
+// Utility exports
+export { authWrapper } from "./router/types/routes.types";

package/src/router/router.ts

@@ -0,0 +1,277 @@
+import {
+  Authentication,
+  FullRoute,
+  ValidatedRoute,
+  AuthenticatedRoute,
+  OpenRoute,
+} from "./types/routes.types";
+import { Endpoint, Router } from "./types/router-creation.types";
+import { AuthenticationFunction, ValidatorFunction } from "./types/configuration.types";
+import { Params } from "./types/params.types";
+
+/**
+ * Creates an endpoint which can be used to create final routes from.
+ * Routes must be fully qualified. This is provided as a helper function
+ * @param path
+ */
+
+// Function overloads in TypeScript are only allowed for functions, not for object properties.
+// When you try to declare multiple properties with the same name (like `get`) in an object literal,
+// you get a syntax error: "An object literal cannot have multiple properties with the same name."
+// Additionally, the type signatures for overloaded methods must be declared as overloads on a function, not as separate properties.
+// The correct way is to define a single function for `get` that matches the overload signatures, and then assign it as the property.
+//
+
+function createEndpoint<Path extends string>(path: Path): Endpoint<Path> {
+  // Open route: no auth, no query
+  function get<Res extends unknown>(config: {
+    authenticator?: never;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }) => Promise<Res>;
+  }): OpenRoute<Path, "GET", Res, undefined>;
+
+  // Open route: no auth, with query
+  function get<Res extends unknown, Query extends unknown>(config: {
+    authenticator?: never;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }) => Promise<Res>;
+  }): OpenRoute<Path, "GET", Res, Query>;
+
+  // Authenticated route: auth, no query
+  function get<Res extends unknown, Auth extends Authentication>(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }, auth: Auth) => Promise<Res>;
+  }): AuthenticatedRoute<Path, "GET", Res, Auth, undefined>;
+
+  // Authenticated route: auth, with query
+  function get<Res extends unknown, Auth extends Authentication, Query extends unknown>(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }, auth: Auth) => Promise<Res>;
+  }): AuthenticatedRoute<Path, "GET", Res, Auth, Query>;
+
+  function get(
+    config:
+      | { handler: (params: { url: Params<Path> }) => Promise<any> }
+      | { queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; handler: (params: { url: Params<Path> }, auth: any) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }, auth: any) => Promise<any> }
+  ): OpenRoute<Path, "GET", any, any> | AuthenticatedRoute<Path, "GET", any, any, any> {
+    if ("authenticator" in config) {
+      return { ...config, type: "authenticated", path, method: "GET" } satisfies AuthenticatedRoute<
+        Path,
+        "GET",
+        any,
+        any,
+        any
+      >;
+    } else {
+      return { ...config, type: "open", path, method: "GET" } satisfies OpenRoute<
+        Path,
+        "GET",
+        any,
+        any
+      >;
+    }
+  }
+
+  // Validated route: no auth, no query
+  function put<Res extends unknown, RequestBody extends unknown>(config: {
+    authenticator?: never;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }, body: RequestBody) => Promise<Res>;
+  }): ValidatedRoute<Path, "PUT", Res, RequestBody, undefined>;
+
+  // Validated route: no auth, with query
+  function put<Res extends unknown, RequestBody extends unknown, Query extends unknown>(config: {
+    authenticator?: never;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }, body: RequestBody) => Promise<Res>;
+  }): ValidatedRoute<Path, "PUT", Res, RequestBody, Query>;
+
+  // Full route: auth + body validation, no query
+  function put<Res extends unknown, RequestBody extends unknown, Auth extends Authentication>(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }, auth: Auth, body: RequestBody) => Promise<Res>;
+  }): FullRoute<Path, "PUT", Res, RequestBody, Auth, undefined>;
+
+  // Full route: auth + body validation, with query
+  function put<
+    Res extends unknown,
+    RequestBody extends unknown,
+    Auth extends Authentication,
+    Query extends unknown,
+  >(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }, auth: Auth, body: RequestBody) => Promise<Res>;
+  }): FullRoute<Path, "PUT", Res, RequestBody, Auth, Query>;
+
+  function put(
+    config:
+      | { validator: ValidatorFunction<any>; handler: (params: { url: Params<Path> }, body: any) => Promise<any> }
+      | { validator: ValidatorFunction<any>; queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }, body: any) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; validator: ValidatorFunction<any>; handler: (params: { url: Params<Path> }, auth: any, body: any) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; validator: ValidatorFunction<any>; queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }, auth: any, body: any) => Promise<any> }
+  ): ValidatedRoute<Path, "PUT", any, any, any> | FullRoute<Path, "PUT", any, any, any, any> {
+    if ("authenticator" in config) {
+      return { ...config, type: "full", path, method: "PUT" } satisfies FullRoute<
+        Path,
+        "PUT",
+        any,
+        any,
+        any,
+        any
+      >;
+    } else {
+      return { ...config, type: "validated", path, method: "PUT" } satisfies ValidatedRoute<
+        Path,
+        "PUT",
+        any,
+        any,
+        any
+      >;
+    }
+  }
+
+  // Validated route: no auth, no query
+  function post<Res extends unknown, RequestBody extends unknown>(config: {
+    authenticator?: never;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }, body: RequestBody) => Promise<Res>;
+  }): ValidatedRoute<Path, "POST", Res, RequestBody, undefined>;
+
+  // Validated route: no auth, with query
+  function post<Res extends unknown, RequestBody extends unknown, Query extends unknown>(config: {
+    authenticator?: never;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }, body: RequestBody) => Promise<Res>;
+  }): ValidatedRoute<Path, "POST", Res, RequestBody, Query>;
+
+  // Full route: auth + body validation, no query
+  function post<Res extends unknown, RequestBody extends unknown, Auth extends Authentication>(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }, auth: Auth, body: RequestBody) => Promise<Res>;
+  }): FullRoute<Path, "POST", Res, RequestBody, Auth, undefined>;
+
+  // Full route: auth + body validation, with query
+  function post<
+    Res extends unknown,
+    RequestBody extends unknown,
+    Auth extends Authentication,
+    Query extends unknown,
+  >(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    validator: ValidatorFunction<RequestBody>;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }, auth: Auth, body: RequestBody) => Promise<Res>;
+  }): FullRoute<Path, "POST", Res, RequestBody, Auth, Query>;
+
+  function post(
+    config:
+      | { validator: ValidatorFunction<any>; handler: (params: { url: Params<Path> }, body: any) => Promise<any> }
+      | { validator: ValidatorFunction<any>; queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }, body: any) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; validator: ValidatorFunction<any>; handler: (params: { url: Params<Path> }, auth: any, body: any) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; validator: ValidatorFunction<any>; queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }, auth: any, body: any) => Promise<any> }
+  ): ValidatedRoute<Path, "POST", any, any, any> | FullRoute<Path, "POST", any, any, any, any> {
+    if ("authenticator" in config) {
+      return { ...config, type: "full", path, method: "POST" } satisfies FullRoute<
+        Path,
+        "POST",
+        any,
+        any,
+        any,
+        any
+      >;
+    } else {
+      return { ...config, type: "validated", path, method: "POST" } satisfies ValidatedRoute<
+        Path,
+        "POST",
+        any,
+        any,
+        any
+      >;
+    }
+  }
+
+  // Open route: no auth, no query
+  function del<Res extends unknown>(config: {
+    authenticator?: never;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }) => Promise<Res>;
+  }): OpenRoute<Path, "DELETE", Res, undefined>;
+
+  // Open route: no auth, with query
+  function del<Res extends unknown, Query extends unknown>(config: {
+    authenticator?: never;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }) => Promise<Res>;
+  }): OpenRoute<Path, "DELETE", Res, Query>;
+
+  // Authenticated route: auth, no query
+  function del<Res extends unknown, Auth extends Authentication>(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    queryValidator?: never;
+    handler: (params: { url: Params<Path> }, auth: Auth) => Promise<Res>;
+  }): AuthenticatedRoute<Path, "DELETE", Res, Auth, undefined>;
+
+  // Authenticated route: auth, with query
+  function del<Res extends unknown, Auth extends Authentication, Query extends unknown>(config: {
+    authenticator: AuthenticationFunction<Auth>;
+    queryValidator: ValidatorFunction<Query>;
+    handler: (params: { url: Params<Path>; query: Query }, auth: Auth) => Promise<Res>;
+  }): AuthenticatedRoute<Path, "DELETE", Res, Auth, Query>;
+
+  function del(
+    config:
+      | { handler: (params: { url: Params<Path> }) => Promise<any> }
+      | { queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; handler: (params: { url: Params<Path> }, auth: any) => Promise<any> }
+      | { authenticator: AuthenticationFunction<any>; queryValidator: ValidatorFunction<any>; handler: (params: { url: Params<Path>; query: any }, auth: any) => Promise<any> }
+  ): OpenRoute<Path, "DELETE", any, any> | AuthenticatedRoute<Path, "DELETE", any, any, any> {
+    if ("authenticator" in config) {
+      return {
+        ...config,
+        type: "authenticated",
+        path,
+        method: "DELETE",
+      } satisfies AuthenticatedRoute<Path, "DELETE", any, any, any>;
+    } else {
+      return { ...config, type: "open", path, method: "DELETE" } satisfies OpenRoute<
+        Path,
+        "DELETE",
+        any,
+        any
+      >;
+    }
+  }
+
+  return {
+    get,
+    post,
+    put,
+    delete: del,
+  };
+}
+
+/**
+ * Provides an Ednpoint creater. Would maybe like some other internal stuff? Lowkey... I think we
+ * all might just end up using the helper functions of get and del and such.
+ * @param _ - this param is still needed because the type is determined at compile time.
+ */
+export function createRouter<BasePath extends string>(_: BasePath): Router<BasePath> {
+  return {
+    createEndpoint: <Path extends `${BasePath}${string}`>(path: Path) => createEndpoint(path),
+    createSubrouter: <Path extends `${BasePath}${string}`>(path: Path) => createRouter(path),
+  };
+}

package/src/router/tmp.sh

@@ -0,0 +1,15 @@
+
+curl \
+--user "euuoxeqo:3351126f-00d2-4964-840f-a8e29fb4f2c5" \
+--digest \
+--header 'Accept: application/vnd.atlas.2024-11-13+json' \
+--header 'Content-Type: application/json' \
+--request GET "https://cloud.mongodb.com/api/atlas/v2/groups/64619e3fea3ebc1bb3d691f3/streams/accountDetails?cloudProvider=aws&regionName=US_EAST_1"
+
+
+{
+    "awsAccountId":"821274765805",
+    "cidrBlock":"192.168.248.0/21",
+    "vpcId":"vpc-04a8f4b80f14357ef",
+    "cloudProvider":"aws"
+    }

package/src/router/types/configuration.types.ts

@@ -0,0 +1,143 @@
+import { Params } from "./params.types";
+import {
+  Authentication,
+  AuthenticatedRoute,
+  FullRoute,
+  OpenRoute,
+  ValidatedRoute,
+} from "./routes.types";
+import { RestMethod } from "./routes.types";
+
+export type ValidatorFunction<T extends unknown = unknown> = (data: unknown) => T;
+export type AuthenticationFunction<T extends Authentication> = (
+  headers: Record<string, string>
+) => T;
+
+/**
+ * This is the most confusing part of the type system, but also key.
+ * This type is used to force type inferenece when creating your endpoints.
+ * This is the structure to provide `function overload`s. This is so you can have the same function
+ * (in our case get,put,post,delete) but allow differnt configurations.
+ *
+ * These configurations need to be strongly typed force the developers into using the tools.
+ *
+ * Want to allow Auth? - Gotta pass in authenticator and the type system handles it
+ *
+ * Also, this is where the core of the Zod system is. We force the body to be a zod validated input.
+ * Luckily, this is pretty easy to replace.
+ * PART of me wanted to further abstract it such that you needed a translation function but
+ * that seemed overengineerd
+ *
+ */
+
+/**
+ * Configuration type for POST/PUT/DELETE endpoints.
+ * These methods require a request body, so they always need a validator.
+ *
+ * Four variants (with/without auth × with/without query):
+ * 1. Validated only, no query: validator + handler(params, body)
+ * 2. Validated only, with query: validator + queryValidator + handler(params, body)
+ * 3. Full (auth + validated), no query: authenticator + validator + handler(params, auth, body)
+ * 4. Full (auth + validated), with query: authenticator + validator + queryValidator + handler(params, auth, body)
+ */
+export type EndpointCreationFunction<Path extends string, Method extends RestMethod> = {
+  // Validated route: no auth, no query
+  <Res extends unknown, RequestBody extends unknown>(
+    config: {
+      authenticator?: never;
+      validator: ValidatorFunction<RequestBody>;
+      queryValidator?: never;
+      handler: (params: { url: Params<Path> }, body: RequestBody) => Promise<Res>;
+    }
+  ): ValidatedRoute<Path, Method, Res, RequestBody, undefined>;
+
+  // Validated route: no auth, with query
+  <Res extends unknown, RequestBody extends unknown, Query extends unknown>(
+    config: {
+      authenticator?: never;
+      validator: ValidatorFunction<RequestBody>;
+      queryValidator: ValidatorFunction<Query>;
+      handler: (
+        params: { url: Params<Path>; query: Query },
+        body: RequestBody
+      ) => Promise<Res>;
+    }
+  ): ValidatedRoute<Path, Method, Res, RequestBody, Query>;
+
+  // Full route: auth + body validation, no query
+  <Res extends unknown, RequestBody extends unknown, Auth extends Authentication>(
+    config: {
+      authenticator: AuthenticationFunction<Auth>;
+      validator: ValidatorFunction<RequestBody>;
+      queryValidator?: never;
+      handler: (params: { url: Params<Path> }, auth: Auth, body: RequestBody) => Promise<Res>;
+    }
+  ): FullRoute<Path, Method, Res, RequestBody, Auth, undefined>;
+
+  // Full route: auth + body validation, with query
+  <
+    Res extends unknown,
+    RequestBody extends unknown,
+    Auth extends Authentication,
+    Query extends unknown,
+  >(
+    config: {
+      authenticator: AuthenticationFunction<Auth>;
+      validator: ValidatorFunction<RequestBody>;
+      queryValidator: ValidatorFunction<Query>;
+      handler: (
+        params: { url: Params<Path>; query: Query },
+        auth: Auth,
+        body: RequestBody
+      ) => Promise<Res>;
+    }
+  ): FullRoute<Path, Method, Res, RequestBody, Auth, Query>;
+};
+
+/**
+ * Configuration type for GET/DELETE endpoints.
+ * These methods cannot have a request body, so no validator.
+ *
+ * Four variants (with/without auth × with/without query):
+ * 1. Open, no query: just handler(params)
+ * 2. Open, with query: queryValidator + handler(params)
+ * 3. Authenticated, no query: authenticator + handler(params, auth)
+ * 4. Authenticated, with query: authenticator + queryValidator + handler(params, auth)
+ */
+export type GetEndpointCreationFunction<Path extends string, Method extends RestMethod> = {
+  // Open route: no auth, no query
+  <Res extends unknown>(
+    config: {
+      authenticator?: never;
+      queryValidator?: never;
+      handler: (params: { url: Params<Path> }) => Promise<Res>;
+    }
+  ): OpenRoute<Path, Method, Res, undefined>;
+
+  // Open route: no auth, with query
+  <Res extends unknown, Query extends unknown>(
+    config: {
+      authenticator?: never;
+      queryValidator: ValidatorFunction<Query>;
+      handler: (params: { url: Params<Path>; query: Query }) => Promise<Res>;
+    }
+  ): OpenRoute<Path, Method, Res, Query>;
+
+  // Authenticated route: auth, no query
+  <Res extends unknown, Auth extends Authentication>(
+    config: {
+      authenticator: AuthenticationFunction<Auth>;
+      queryValidator?: never;
+      handler: (params: { url: Params<Path> }, auth: Auth) => Promise<Res>;
+    }
+  ): AuthenticatedRoute<Path, Method, Res, Auth, undefined>;
+
+  // Authenticated route: auth, with query
+  <Res extends unknown, Auth extends Authentication, Query extends unknown>(
+    config: {
+      authenticator: AuthenticationFunction<Auth>;
+      queryValidator: ValidatorFunction<Query>;
+      handler: (params: { url: Params<Path>; query: Query }, auth: Auth) => Promise<Res>;
+    }
+  ): AuthenticatedRoute<Path, Method, Res, Auth, Query>;
+};

package/src/router/types/params.types.ts

@@ -0,0 +1,13 @@
+type ExtractUrlParams<Path extends string> = Path extends `${string}/:${infer Param}/${infer Rest}`
+  ? Param | ExtractUrlParams<Rest>
+  : Path extends `${string}/:${infer Param}`
+    ? Param
+    : never;
+
+// Yields the full object. Otherwise, we end up with a bunch of & during type inference
+type Expand<T> = T extends infer O ? { [K in keyof O]: O[K] } : never;
+
+// Helper to use Expand with Path
+export type Params<Path extends string> = Expand<{
+  [K in ExtractUrlParams<Path>]: string;
+}>;

package/src/router/types/router-creation.types.ts

@@ -0,0 +1,36 @@
+import { GetEndpointCreationFunction } from "./configuration.types";
+import { EndpointCreationFunction } from "./configuration.types";
+
+/* Endpoint seems more complex than it is from its type signature.
+ * It has 4 Major functions on offer. The different HTTP methods
+ *
+ * These use the EndpointCreationFunction
+ */
+export type Endpoint<Path extends string> = {
+  get: GetEndpointCreationFunction<Path, "GET">;
+  post: EndpointCreationFunction<Path, "POST">;
+  put: EndpointCreationFunction<Path, "PUT">;
+  delete: GetEndpointCreationFunction<Path, "DELETE">;
+};
+
+/**
+ * Creates a router that ensures all endpoints extend the route.
+ * IDK if this is actually useful, but I kinda like it.
+ *
+ * There def was a part of me that thought about pure generator functions.
+ * In fact... they're provided!
+ *
+ * We can discuss that.
+ */
+export type Router<BasePath extends string> = {
+  /**
+   * Creates an endpoint
+   * @param path string, must extend Router's string
+   */
+  createEndpoint: <Path extends `${BasePath}${string}`>(path: Path) => Endpoint<Path>;
+  /**
+   * Creates a subrouter
+   * @param path string, must extend Router's string
+   */
+  createSubrouter: <Path extends `${BasePath}${string}`>(path: Path) => Router<Path>;
+};

package/src/router/types/routes.types.ts

@@ -0,0 +1,124 @@
+import { AuthenticationFunction, ValidatorFunction } from "./configuration.types";
+import { Params } from "./params.types";
+
+declare const authBrand: unique symbol;
+export type Authentication = { readonly [authBrand]: "Auth" };
+export function authWrapper<T>(auth: T): T & Authentication {
+  return {
+    ...auth,
+    [authBrand]: "Auth",
+  };
+}
+
+export type RestMethod = "GET" | "POST" | "PUT" | "DELETE";
+
+// Combined Route
+export type BaseRoute<Path extends string> = {
+  TRANSACTIONS: boolean;
+  path: Path;
+  logging?: (input: any) => void;
+};
+
+export type OpenRoute<
+  Path extends string,
+  Method extends RestMethod,
+  Res extends unknown,
+  Query extends unknown | undefined = undefined,
+> = {
+  type: "open";
+  path: Path;
+  method: Method;
+  validator?: never;
+  authenticator?: never;
+  handler: (params: { url: Params<Path>; query: Query }) => Promise<Res>;
+};
+
+export type AuthenticatedRoute<
+  Path extends string,
+  Method extends RestMethod,
+  Res extends unknown,
+  Auth extends Authentication,
+  Query extends unknown | undefined = undefined,
+> = {
+  type: "authenticated";
+  path: Path;
+  method: Method;
+  validator?: never;
+  authenticator: AuthenticationFunction<Auth>;
+  handler: (
+    params: {
+      url: Params<Path>;
+      query: Query;
+    },
+    auth: Auth
+  ) => Promise<Res>;
+};
+
+export type ValidatedRoute<
+  Path extends string,
+  Method extends RestMethod,
+  Res extends unknown,
+  RequestBody extends unknown,
+  Query extends unknown | undefined = undefined,
+> = {
+  type: "validated";
+  path: Path;
+  method: Method;
+  validator: ValidatorFunction<RequestBody>;
+  authenticator?: never;
+  handler: (
+    params: {
+      url: Params<Path>;
+      query: Query;
+    },
+    body: RequestBody
+  ) => Promise<Res>;
+};
+
+export type FullRoute<
+  Path extends string,
+  Method extends RestMethod,
+  Res extends unknown,
+  RequestBody extends unknown,
+  Auth extends Authentication,
+  Query extends unknown | undefined = undefined,
+> = {
+  type: "full";
+  path: Path;
+  method: Method;
+  validator: ValidatorFunction<RequestBody>;
+  authenticator: AuthenticationFunction<Auth>;
+  handler: Query extends undefined
+    ? (
+        params: {
+          url: Params<Path>;
+        },
+        auth: Authentication,
+        body: RequestBody
+      ) => Promise<Res>
+    : (
+        params: {
+          url: Params<Path>;
+          query: Query;
+        },
+        auth: Authentication,
+        body: RequestBody
+      ) => Promise<Res>;
+};
+
+export type Route<
+  Path extends string,
+  Res extends unknown,
+  Method extends RestMethod,
+  RequestBody extends unknown | undefined = undefined,
+  Auth extends Authentication | undefined = undefined,
+  Query extends unknown | undefined = undefined,
+> = [RequestBody, Auth] extends [undefined, undefined]
+  ? OpenRoute<Path, Method, Res, Query>
+  : [RequestBody, Auth] extends [undefined, infer A extends Authentication]
+    ? AuthenticatedRoute<Path, Method, Res, A, Query>
+    : [RequestBody, Auth] extends [infer B, undefined]
+      ? ValidatedRoute<Path, Method, Res, B, Query>
+      : [RequestBody, Auth] extends [infer B, infer A extends Authentication]
+        ? FullRoute<Path, Method, Res, B, A, Query>
+        : never;