fossyl 0.1.5 → 0.9.0

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

@@ -1,143 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,124 +0,0 @@
-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;