rouzer 1.0.0-beta.2 → 1.0.0-beta.3

package/dist/client/index.d.ts

@@ -0,0 +1,35 @@
+export declare function createClient(config: {
+    /**
+     * Base URL to use for all requests.
+     */
+    baseURL: string;
+    /**
+     * Default headers to send with every request.
+     */
+    headers?: Record<string, string>;
+    /**
+     * Custom handler for non-200 response to a `.json()` request. By default, the
+     * response is always parsed as JSON, regardless of the HTTP status code.
+     */
+    onJsonError?: (response: Response) => Response;
+}): {
+    config: {
+        /**
+         * Base URL to use for all requests.
+         */
+        baseURL: string;
+        /**
+         * Default headers to send with every request.
+         */
+        headers?: Record<string, string>;
+        /**
+         * Custom handler for non-200 response to a `.json()` request. By default, the
+         * response is always parsed as JSON, regardless of the HTTP status code.
+         */
+        onJsonError?: (response: Response) => Response;
+    };
+    request<T extends RouteRequest>({ pathPattern, method, args: { path, query, body, headers }, route, }: T): Promise<Response & {
+        json(): Promise<T["$result"]>;
+    }>;
+    json<T extends RouteRequest>(request: T): Promise<T["$result"]>;
+};

package/dist/client/index.js

@@ -0,0 +1,46 @@
+import { shake } from '../common';
+export function createClient(config) {
+    return {
+        config,
+        request({ pathPattern, method, args: { path, query, body, headers }, route, }) {
+            if (route.path) {
+                path = route.path.parse(path);
+            }
+            const url = new URL(pathPattern.href(path), config.baseURL);
+            if (route.query) {
+                query = route.query.parse(query ?? {});
+                url.search = new URLSearchParams(query).toString();
+            }
+            else if (query) {
+                throw new Error('Unexpected query parameters');
+            }
+            if (route.body) {
+                body = route.body.parse(body !== undefined ? body : {});
+            }
+            else if (body !== undefined) {
+                throw new Error('Unexpected body');
+            }
+            if (config.headers || headers) {
+                headers = {
+                    ...config.headers,
+                    ...(headers && shake(headers)),
+                };
+            }
+            if (route.headers) {
+                headers = route.headers.parse(headers);
+            }
+            return fetch(url, {
+                method,
+                body: body !== undefined ? JSON.stringify(body) : undefined,
+                headers,
+            });
+        },
+        async json(request) {
+            const response = await this.request(request);
+            if (!response.ok && config.onJsonError) {
+                return config.onJsonError(response);
+            }
+            return response.json();
+        },
+    };
+}

package/dist/common.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Map over all the keys to create a new object.
+ *
+ * @see https://radashi.js.org/reference/object/mapEntries
+ * @example
+ * ```ts
+ * const a = { a: 1, b: 2, c: 3 }
+ * mapEntries(a, (key, value) => [value, key])
+ * // => { 1: 'a', 2: 'b', 3: 'c' }
+ * ```
+ * @version 12.1.0
+ */
+export declare function mapEntries<TKey extends string | number | symbol, TValue, TNewKey extends string | number | symbol, TNewValue>(obj: Record<TKey, TValue>, toEntry: (key: TKey, value: TValue) => [TNewKey, TNewValue]): Record<TNewKey, TNewValue>;
+/**
+ * Removes (shakes out) undefined entries from an object. Optional
+ * second argument shakes out values by custom evaluation.
+ *
+ * Note that non-enumerable keys are never shaken out.
+ *
+ * @see https://radashi.js.org/reference/object/shake
+ * @example
+ * ```ts
+ * const a = { a: 1, b: undefined, c: 3 }
+ * shake(a)
+ * // => { a: 1, c: 3 }
+ * ```
+ * @version 12.1.0
+ */
+export declare function shake<T extends object>(obj: T): {
+    [K in keyof T]: Exclude<T[K], undefined>;
+};
+export declare function shake<T extends object>(obj: T, filter: ((value: unknown) => boolean) | undefined): T;
+/**
+ * Map over all the keys to create a new object.
+ *
+ * @see https://radashi.js.org/reference/object/mapValues
+ * @example
+ * ```ts
+ * const a = { a: 1, b: 2, c: 3 }
+ * mapValues(a, (value, key) => value * 2)
+ * // => { a: 2, b: 4, c: 6 }
+ * ```
+ * @version 12.1.0
+ */
+export declare function mapValues<T extends object, U>(obj: T, mapFunc: (value: Required<T>[keyof T], key: keyof T) => U): {
+    [K in keyof T]: U;
+};

package/dist/common.js

@@ -0,0 +1,51 @@
+/**
+ * Map over all the keys to create a new object.
+ *
+ * @see https://radashi.js.org/reference/object/mapEntries
+ * @example
+ * ```ts
+ * const a = { a: 1, b: 2, c: 3 }
+ * mapEntries(a, (key, value) => [value, key])
+ * // => { 1: 'a', 2: 'b', 3: 'c' }
+ * ```
+ * @version 12.1.0
+ */
+export function mapEntries(obj, toEntry) {
+    if (!obj) {
+        return {};
+    }
+    return Object.entries(obj).reduce((acc, [key, value]) => {
+        const [newKey, newValue] = toEntry(key, value);
+        acc[newKey] = newValue;
+        return acc;
+    }, {});
+}
+export function shake(obj, filter = value => value === undefined) {
+    if (!obj) {
+        return {};
+    }
+    return Object.keys(obj).reduce((acc, key) => {
+        if (!filter(obj[key])) {
+            acc[key] = obj[key];
+        }
+        return acc;
+    }, {});
+}
+/**
+ * Map over all the keys to create a new object.
+ *
+ * @see https://radashi.js.org/reference/object/mapValues
+ * @example
+ * ```ts
+ * const a = { a: 1, b: 2, c: 3 }
+ * mapValues(a, (value, key) => value * 2)
+ * // => { a: 2, b: 4, c: 6 }
+ * ```
+ * @version 12.1.0
+ */
+export function mapValues(obj, mapFunc) {
+    return Object.keys(obj).reduce((acc, key) => {
+        acc[key] = mapFunc(obj[key], key);
+        return acc;
+    }, {});
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from './route';
+export * from './server/router';
+export * from './client/index';
+export type * from './types';
+export * from 'alien-middleware';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './route';
+export * from './server/router';
+export * from './client/index';
+export * from 'alien-middleware';

package/dist/route.d.ts

@@ -0,0 +1,8 @@
+import { RoutePattern } from '@remix-run/route-pattern';
+import type { Routes } from './types';
+export declare function $type<T>(): Unchecked<T>;
+export declare function route<P extends string, T extends Routes>(path: P, routes: T): {
+    path: P;
+    pathPattern: RoutePattern<string>;
+    routes: T;
+} & { [K in keyof T]: RouteFunction<any>; };

package/dist/route.js

@@ -0,0 +1,18 @@
+import { RoutePattern } from '@remix-run/route-pattern';
+import { mapEntries } from './common';
+export function $type() {
+    return null;
+}
+export function route(path, routes) {
+    const pathPattern = new RoutePattern(path);
+    const createFetch = (method, route) => (args) => {
+        return {
+            route,
+            pathPattern,
+            method,
+            args,
+            $result: undefined,
+        };
+    };
+    return Object.assign({ path, pathPattern, routes }, mapEntries(routes, (method, route) => [method, createFetch(method, route)]));
+}

package/dist/server/router.d.ts

@@ -0,0 +1,54 @@
+import type { AdapterRequestContext } from '@hattip/core';
+import { type Params } from '@remix-run/route-pattern';
+import { chain, MiddlewareChain, type MiddlewareContext } from 'alien-middleware';
+import * as z from 'zod/mini';
+import type { Routes } from '../types';
+export { chain };
+type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
+    initial: {
+        env: {};
+        properties: {};
+    };
+    current: {
+        env: {};
+        properties: {};
+    };
+    platform: TPlatform;
+}>;
+export type RouterConfig<TRoutes extends Record<string, {
+    path: string;
+    routes: Routes;
+}> = any, TMiddleware extends MiddlewareChain = any> = {
+    routes: TRoutes;
+    middlewares?: TMiddleware;
+    debug?: boolean;
+};
+export declare function createRouter<TRoutes extends Record<string, {
+    path: string;
+    routes: Routes;
+}>, TMiddleware extends MiddlewareChain = EmptyMiddlewareChain>(config: {
+    routes: TRoutes;
+    middlewares?: TMiddleware;
+    debug?: boolean;
+}): (handlers: { [K in keyof TRoutes]: { [M in keyof TRoutes[K]["routes"]]: TRoutes[K]["routes"][M] extends infer T ? T extends TRoutes[K]["routes"][M] ? T extends QueryRoute ? (context: MiddlewareContext<TMiddleware> & {
+    query: z.infer<T["query"]>;
+    params: Params<TRoutes[K]["path"]>;
+    headers: z.infer<T["headers"]>;
+}) => Promisable<TResult | Response> : T extends MutationRoute ? (context: MiddlewareContext<TMiddleware> & {
+    body: z.infer<T["body"]>;
+    params: Params<TRoutes[K]["path"]>;
+    headers: z.infer<T["headers"]>;
+}) => Promisable<TResult | Response> : never : never : never; }; }) => import("alien-middleware").ApplyMiddleware<TMiddleware, (context: AdapterRequestContext<TMiddleware extends MiddlewareChain<infer T extends {
+    initial: {
+        env: object;
+        properties: object;
+    };
+    current: {
+        env: object;
+        properties: object;
+    };
+    platform: unknown;
+}> ? T["platform"] : never> & {
+    url?: URL;
+    params?: {};
+}) => Promise<Response>>;

package/dist/server/router.js

@@ -0,0 +1,115 @@
+import { RoutePattern } from '@remix-run/route-pattern';
+import { chain, } from 'alien-middleware';
+import { mapValues } from '../common';
+import * as z from 'zod/mini';
+export { chain };
+export function createRouter(config) {
+    const keys = Object.keys(config.routes);
+    const middlewares = config.middlewares ?? chain();
+    const patterns = mapValues(config.routes, ({ path }) => new RoutePattern(path));
+    return (handlers) => middlewares.use(async function (context) {
+        const request = context.request;
+        const method = request.method.toUpperCase();
+        const url = (context.url ??= new URL(request.url));
+        for (let i = 0; i < keys.length; i++) {
+            const pattern = patterns[keys[i]];
+            const match = pattern.match(url);
+            if (!match) {
+                continue;
+            }
+            const route = config.routes[keys[i]].routes[method];
+            if (!route) {
+                continue;
+            }
+            if (route.headers) {
+                const error = parseHeaders(context, enableStringParsing(route.headers));
+                if (error) {
+                    return httpClientError(error, 'Invalid request headers', config);
+                }
+            }
+            if (route.query) {
+                const error = parseQueryString(context, enableStringParsing(route.query));
+                if (error) {
+                    return httpClientError(error, 'Invalid query string', config);
+                }
+            }
+            if (route.body) {
+                const error = await parseRequestBody(context, route.body);
+                if (error) {
+                    return httpClientError(error, 'Invalid request body', config);
+                }
+            }
+            const handler = handlers[keys[i]][method];
+            if (!handler) {
+                continue;
+            }
+            context.params = match.params;
+            const result = await handler(context);
+            if (result instanceof Response) {
+                return result;
+            }
+            return Response.json(result);
+        }
+    });
+}
+function httpClientError(error, message, config) {
+    return Response.json({
+        ...error,
+        message: config.debug ? `${message}: ${error.message}` : message,
+    }, { status: 400 });
+}
+function parseHeaders(context, schema) {
+    const headers = Object.fromEntries(context.request.headers);
+    const result = schema.safeParse(headers);
+    if (!result.success) {
+        return result.error;
+    }
+    context.headers = result.data;
+    return null;
+}
+function parseQueryString(context, schema) {
+    const result = schema.safeParse(Object.fromEntries(context.url.searchParams));
+    if (!result.success) {
+        return result.error;
+    }
+    context.query = result.data;
+    return null;
+}
+async function parseRequestBody(context, schema) {
+    const result = await context.request.json().then(body => schema.safeParse(body), error => ({ success: false, error }));
+    if (!result.success) {
+        return result.error;
+    }
+    context.body = result.data;
+    return null;
+}
+const seen = new WeakMap();
+/**
+ * Traverse object and array schemas, finding schemas that expect a number or
+ * boolean, and replace those schemas with a new schema that parses the input
+ * value as a number or boolean.
+ */
+function enableStringParsing(schema) {
+    if (schema.type === 'number') {
+        return z.pipe(z.transform(Number), schema);
+    }
+    if (schema.type === 'boolean') {
+        return z.pipe(z.transform(toBooleanStrict), schema);
+    }
+    if (schema.type === 'object') {
+        const cached = seen.get(schema);
+        if (cached) {
+            return cached;
+        }
+        const modified = z.object(mapValues(schema.def.shape, enableStringParsing));
+        seen.set(schema, modified);
+        return modified;
+    }
+    if (schema.type === 'array') {
+        return z.array(enableStringParsing(schema.def.element));
+    }
+    return schema;
+}
+function toBooleanStrict(value) {
+    return value === 'true' || (value === 'false' ? false : value);
+}

package/dist/types.d.ts

@@ -0,0 +1,79 @@
+import { Params, RoutePattern } from '@remix-run/route-pattern';
+import * as z from 'zod/mini';
+export type Promisable<T> = T | Promise<T>;
+export type Unchecked<T> = {
+    __unchecked__: T;
+};
+export type QueryRoute = {
+    path?: z.ZodMiniObject<any>;
+    query?: z.ZodMiniObject<any>;
+    body?: never;
+    headers?: z.ZodMiniObject<any>;
+    response: Unchecked<any>;
+};
+export type MutationRoute = {
+    path?: z.ZodMiniObject<any>;
+    query?: never;
+    body: z.ZodMiniType<any, any>;
+    headers?: z.ZodMiniObject<any>;
+    response?: Unchecked<any>;
+};
+export type Routes = {
+    GET?: QueryRoute;
+    POST?: MutationRoute;
+    PUT?: MutationRoute;
+    PATCH?: MutationRoute;
+    DELETE?: MutationRoute;
+};
+declare class Any {
+    private isAny;
+}
+type PathArgs<T> = T extends {
+    path: infer TPath extends string;
+} ? Params<TPath> extends infer TParams ? {} extends TParams ? {
+    path?: TParams;
+} : {
+    path: TParams;
+} : unknown : unknown;
+type QueryArgs<T> = T extends QueryRoute & {
+    query: infer TQuery;
+} ? {} extends z.infer<TQuery> ? {
+    query?: z.infer<TQuery>;
+} : {
+    query: z.infer<TQuery>;
+} : unknown;
+type MutationArgs<T> = T extends MutationRoute & {
+    body: infer TBody;
+} ? {} extends z.infer<TBody> ? {
+    body?: z.infer<TBody>;
+} : {
+    body: z.infer<TBody>;
+} : unknown;
+export type RouteArgs<T extends QueryRoute | MutationRoute = any> = ([
+    T
+] extends [Any] ? {
+    query?: any;
+    body?: any;
+    path?: any;
+} : QueryArgs<T> & MutationArgs<T> & PathArgs<T>) & Omit<RequestInit, 'method' | 'body' | 'headers'> & {
+    headers?: Record<string, string | undefined>;
+};
+export type RouteRequest<TResult = any> = {
+    route: QueryRoute | MutationRoute;
+    pathPattern: RoutePattern;
+    method: string;
+    args: RouteArgs;
+    $result: TResult;
+};
+export type RouteResponse<TResult = any> = Response & {
+    json(): Promise<TResult>;
+};
+export type InferRouteResponse<T extends QueryRoute | MutationRoute> = T extends {
+    response: Unchecked<infer TResponse>;
+} ? TResponse : void;
+export type RouteFunction<T extends QueryRoute | MutationRoute> = {
+    (args: RouteArgs<T>): RouteRequest<InferRouteResponse<T>>;
+    $args: RouteArgs<T>;
+    $response: InferRouteResponse<T>;
+};
+export {};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "rouzer",
-  "version": "1.0.0-beta.2",
+  "version": "1.0.0-beta.3",
+  "type": "module",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -27,6 +28,10 @@
     "type": "git",
     "url": "https://github.com/alloc/rouzer.git"
   },
+  "files": [
+    "dist",
+    "!*.tsbuildinfo"
+  ],
   "scripts": {
     "build": "tsgo -b tsconfig.json"
   }

package/.vscode/settings.json

@@ -1,5 +0,0 @@
-{
-  "editor.formatOnSave": true,
-  "editor.defaultFormatter": "esbenp.prettier-vscode",
-  "rewrap.wrappingColumn": 80
-}

package/src/client/index.ts

@@ -1,70 +0,0 @@
-import { shake } from '../common'
-import type { RouteRequest } from '../types'
-
-export function createClient(config: {
-  /**
-   * Base URL to use for all requests.
-   */
-  baseURL: string
-  /**
-   * Default headers to send with every request.
-   */
-  headers?: Record<string, string>
-  /**
-   * Custom handler for non-200 response to a `.json()` request. By default, the
-   * response is always parsed as JSON, regardless of the HTTP status code.
-   */
-  onJsonError?: (response: Response) => Response
-}) {
-  return {
-    config,
-    request<T extends RouteRequest>({
-      pathPattern,
-      method,
-      args: { path, query, body, headers },
-      route,
-    }: T) {
-      if (route.path) {
-        path = route.path.parse(path)
-      }
-
-      const url = new URL(pathPattern.href(path), config.baseURL)
-
-      if (route.query) {
-        query = route.query.parse(query ?? {})
-        url.search = new URLSearchParams(query).toString()
-      } else if (query) {
-        throw new Error('Unexpected query parameters')
-      }
-      if (route.body) {
-        body = route.body.parse(body !== undefined ? body : {})
-      } else if (body !== undefined) {
-        throw new Error('Unexpected body')
-      }
-
-      if (config.headers || headers) {
-        headers = {
-          ...config.headers,
-          ...(headers && shake(headers)),
-        }
-      }
-
-      if (route.headers) {
-        headers = route.headers.parse(headers) as any
-      }
-
-      return fetch(url, {
-        method,
-        body: body !== undefined ? JSON.stringify(body) : undefined,
-        headers,
-      }) as Promise<Response & { json(): Promise<T['$result']> }>
-    },
-    async json<T extends RouteRequest>(request: T): Promise<T['$result']> {
-      const response = await this.request(request)
-      if (!response.ok && config.onJsonError) {
-        return config.onJsonError(response)
-      }
-      return response.json()
-    },
-  }
-}

package/src/common.ts

@@ -1,99 +0,0 @@
-/**
- * Map over all the keys to create a new object.
- *
- * @see https://radashi.js.org/reference/object/mapEntries
- * @example
- * ```ts
- * const a = { a: 1, b: 2, c: 3 }
- * mapEntries(a, (key, value) => [value, key])
- * // => { 1: 'a', 2: 'b', 3: 'c' }
- * ```
- * @version 12.1.0
- */
-export function mapEntries<
-  TKey extends string | number | symbol,
-  TValue,
-  TNewKey extends string | number | symbol,
-  TNewValue,
->(
-  obj: Record<TKey, TValue>,
-  toEntry: (key: TKey, value: TValue) => [TNewKey, TNewValue]
-): Record<TNewKey, TNewValue> {
-  if (!obj) {
-    return {} as Record<TNewKey, TNewValue>
-  }
-  return Object.entries(obj).reduce(
-    (acc, [key, value]) => {
-      const [newKey, newValue] = toEntry(key as TKey, value as TValue)
-      acc[newKey] = newValue
-      return acc
-    },
-    {} as Record<TNewKey, TNewValue>
-  )
-}
-
-/**
- * Removes (shakes out) undefined entries from an object. Optional
- * second argument shakes out values by custom evaluation.
- *
- * Note that non-enumerable keys are never shaken out.
- *
- * @see https://radashi.js.org/reference/object/shake
- * @example
- * ```ts
- * const a = { a: 1, b: undefined, c: 3 }
- * shake(a)
- * // => { a: 1, c: 3 }
- * ```
- * @version 12.1.0
- */
-export function shake<T extends object>(
-  obj: T
-): {
-  [K in keyof T]: Exclude<T[K], undefined>
-}
-
-export function shake<T extends object>(
-  obj: T,
-  filter: ((value: unknown) => boolean) | undefined
-): T
-
-export function shake<T extends object>(
-  obj: T,
-  filter: (value: unknown) => boolean = value => value === undefined
-): T {
-  if (!obj) {
-    return {} as T
-  }
-  return (Object.keys(obj) as (keyof T)[]).reduce((acc, key) => {
-    if (!filter(obj[key])) {
-      acc[key] = obj[key]
-    }
-    return acc
-  }, {} as T)
-}
-
-/**
- * Map over all the keys to create a new object.
- *
- * @see https://radashi.js.org/reference/object/mapValues
- * @example
- * ```ts
- * const a = { a: 1, b: 2, c: 3 }
- * mapValues(a, (value, key) => value * 2)
- * // => { a: 2, b: 4, c: 6 }
- * ```
- * @version 12.1.0
- */
-export function mapValues<T extends object, U>(
-  obj: T,
-  mapFunc: (value: Required<T>[keyof T], key: keyof T) => U
-): { [K in keyof T]: U } {
-  return (Object.keys(obj) as (keyof T)[]).reduce(
-    (acc, key) => {
-      acc[key] = mapFunc(obj[key], key)
-      return acc
-    },
-    {} as { [K in keyof T]: U }
-  )
-}

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './route'
-export * from './server/router'
-export * from './client/index'
-export type * from './types'
-
-export * from 'alien-middleware'

package/src/route.ts

@@ -1,44 +0,0 @@
-import { RoutePattern } from '@remix-run/route-pattern'
-import { mapEntries } from './common'
-import type {
-  MutationRoute,
-  QueryRoute,
-  RouteArgs,
-  RouteFunction,
-  RouteRequest,
-  Routes,
-  Unchecked,
-} from './types'
-
-export function $type<T>() {
-  return null as unknown as Unchecked<T>
-}
-
-export function route<P extends string, T extends Routes>(path: P, routes: T) {
-  const pathPattern = new RoutePattern(path)
-  const createFetch =
-    (method: string, route: QueryRoute | MutationRoute) =>
-    (args: RouteArgs): RouteRequest => {
-      return {
-        route,
-        pathPattern,
-        method,
-        args,
-        $result: undefined!,
-      }
-    }
-
-  return Object.assign(
-    { path, pathPattern, routes },
-    mapEntries(
-      routes as Record<string, QueryRoute | MutationRoute>,
-      (method, route) => [method, createFetch(method, route)]
-    )
-  ) as unknown as {
-    path: P
-    pathPattern: RoutePattern
-    routes: T
-  } & {
-    [K in keyof T]: RouteFunction<Extract<T[K], QueryRoute | MutationRoute>>
-  }
-}

package/src/server/router.ts

@@ -1,248 +0,0 @@
-import type { AdapterRequestContext } from '@hattip/core'
-import { RoutePattern, type Params } from '@remix-run/route-pattern'
-import {
-  chain,
-  MiddlewareChain,
-  type MiddlewareContext,
-} from 'alien-middleware'
-import { mapValues } from '../common'
-import * as z from 'zod/mini'
-import type {
-  InferRouteResponse,
-  MutationRoute,
-  Promisable,
-  QueryRoute,
-  Routes,
-} from '../types'
-
-export { chain }
-
-type EmptyMiddlewareChain<TPlatform = unknown> = MiddlewareChain<{
-  initial: {
-    env: {}
-    properties: {}
-  }
-  current: {
-    env: {}
-    properties: {}
-  }
-  platform: TPlatform
-}>
-
-export type RouterConfig<
-  TRoutes extends Record<string, { path: string; routes: Routes }> = any,
-  TMiddleware extends MiddlewareChain = any,
-> = {
-  routes: TRoutes
-  middlewares?: TMiddleware
-  debug?: boolean
-}
-
-export function createRouter<
-  TRoutes extends Record<string, { path: string; routes: Routes }>,
-  TMiddleware extends MiddlewareChain = EmptyMiddlewareChain,
->(config: { routes: TRoutes; middlewares?: TMiddleware; debug?: boolean }) {
-  const keys = Object.keys(config.routes)
-  const middlewares = config.middlewares ?? (chain() as TMiddleware)
-  const patterns = mapValues(
-    config.routes,
-    ({ path }) => new RoutePattern(path)
-  )
-
-  type RequestContext = MiddlewareContext<TMiddleware>
-
-  type RequestHandler<TArgs extends object, TResult> = (
-    context: RequestContext & TArgs
-  ) => Promisable<TResult | Response>
-
-  type InferRequestHandler<T, P extends string> = T extends QueryRoute
-    ? RequestHandler<
-        {
-          query: z.infer<T['query']>
-          params: Params<P>
-          headers: z.infer<T['headers']>
-        },
-        InferRouteResponse<T>
-      >
-    : T extends MutationRoute
-      ? RequestHandler<
-          {
-            body: z.infer<T['body']>
-            params: Params<P>
-            headers: z.infer<T['headers']>
-          },
-          InferRouteResponse<T>
-        >
-      : never
-
-  type RequestHandlers = {
-    [K in keyof TRoutes]: {
-      [M in keyof TRoutes[K]['routes']]: InferRequestHandler<
-        TRoutes[K]['routes'][M],
-        TRoutes[K]['path']
-      >
-    }
-  }
-
-  type TPlatform =
-    TMiddleware extends MiddlewareChain<infer T> ? T['platform'] : never
-
-  return (handlers: RequestHandlers) =>
-    middlewares.use(async function (
-      context: AdapterRequestContext<TPlatform> & {
-        url?: URL
-        params?: {}
-      }
-    ) {
-      const request = context.request as Request
-      const method = request.method.toUpperCase() as keyof Routes
-      const url: URL = (context.url ??= new URL(request.url))
-
-      for (let i = 0; i < keys.length; i++) {
-        const pattern = patterns[keys[i]]
-
-        const match = pattern.match(url)
-        if (!match) {
-          continue
-        }
-
-        const route = config.routes[keys[i]].routes[method]
-        if (!route) {
-          continue
-        }
-
-        if (route.headers) {
-          const error = parseHeaders(
-            context,
-            enableStringParsing(route.headers)
-          )
-          if (error) {
-            return httpClientError(error, 'Invalid request headers', config)
-          }
-        }
-
-        if (route.query) {
-          const error = parseQueryString(
-            context,
-            enableStringParsing(route.query)
-          )
-          if (error) {
-            return httpClientError(error, 'Invalid query string', config)
-          }
-        }
-
-        if (route.body) {
-          const error = await parseRequestBody(context, route.body)
-          if (error) {
-            return httpClientError(error, 'Invalid request body', config)
-          }
-        }
-
-        const handler = handlers[keys[i]][method]
-        if (!handler) {
-          continue
-        }
-
-        context.params = match.params
-
-        const result = await handler(context as any)
-        if (result instanceof Response) {
-          return result
-        }
-        return Response.json(result)
-      }
-    })
-}
-
-function httpClientError(
-  error: any,
-  message: string,
-  config: { debug?: boolean }
-) {
-  return Response.json(
-    {
-      ...error,
-      message: config.debug ? `${message}: ${error.message}` : message,
-    },
-    { status: 400 }
-  )
-}
-
-function parseHeaders(
-  context: AdapterRequestContext & { headers?: {} },
-  schema: z.ZodMiniType<any, any>
-) {
-  const headers = Object.fromEntries(context.request.headers as any)
-  const result = schema.safeParse(headers)
-  if (!result.success) {
-    return result.error
-  }
-  context.headers = result.data
-  return null
-}
-
-function parseQueryString(
-  context: AdapterRequestContext & { url?: URL; query?: {} },
-  schema: z.ZodMiniType<any, any>
-) {
-  const result = schema.safeParse(
-    Object.fromEntries(context.url!.searchParams as any)
-  )
-  if (!result.success) {
-    return result.error
-  }
-  context.query = result.data
-  return null
-}
-
-async function parseRequestBody(
-  context: AdapterRequestContext & { body?: {} },
-  schema: z.ZodMiniType<any, any>
-) {
-  const result = await context.request.json().then(
-    body => schema.safeParse(body),
-    error => ({ success: false, error }) as const
-  )
-  if (!result.success) {
-    return result.error
-  }
-  context.body = result.data
-  return null
-}
-
-const seen = new WeakMap<z.ZodMiniType<any, any>, z.ZodMiniType<any, any>>()
-
-/**
- * Traverse object and array schemas, finding schemas that expect a number or
- * boolean, and replace those schemas with a new schema that parses the input
- * value as a number or boolean.
- */
-function enableStringParsing(schema: z.ZodMiniType<any, any>): typeof schema {
-  if (schema.type === 'number') {
-    return z.pipe(z.transform(Number), schema)
-  }
-  if (schema.type === 'boolean') {
-    return z.pipe(z.transform(toBooleanStrict), schema)
-  }
-  if (schema.type === 'object') {
-    const cached = seen.get(schema)
-    if (cached) {
-      return cached
-    }
-    const modified = z.object(
-      mapValues((schema as z.ZodMiniObject<any>).def.shape, enableStringParsing)
-    )
-    seen.set(schema, modified)
-    return modified
-  }
-  if (schema.type === 'array') {
-    return z.array(
-      enableStringParsing((schema as z.ZodMiniArray<any>).def.element)
-    )
-  }
-  return schema
-}
-
-function toBooleanStrict(value: string) {
-  return value === 'true' || (value === 'false' ? false : value)
-}

package/src/types.ts

@@ -1,89 +0,0 @@
-import { Params, RoutePattern } from '@remix-run/route-pattern'
-import * as z from 'zod/mini'
-
-export type Promisable<T> = T | Promise<T>
-
-export type Unchecked<T> = { __unchecked__: T }
-
-export type QueryRoute = {
-  path?: z.ZodMiniObject<any>
-  query?: z.ZodMiniObject<any>
-  body?: never
-  headers?: z.ZodMiniObject<any>
-  response: Unchecked<any>
-}
-
-export type MutationRoute = {
-  path?: z.ZodMiniObject<any>
-  query?: never
-  body: z.ZodMiniType<any, any>
-  headers?: z.ZodMiniObject<any>
-  response?: Unchecked<any>
-}
-
-export type Routes = {
-  GET?: QueryRoute
-  POST?: MutationRoute
-  PUT?: MutationRoute
-  PATCH?: MutationRoute
-  DELETE?: MutationRoute
-}
-
-declare class Any {
-  private isAny: true
-}
-
-type PathArgs<T> = T extends { path: infer TPath extends string }
-  ? Params<TPath> extends infer TParams
-    ? {} extends TParams
-      ? { path?: TParams }
-      : { path: TParams }
-    : unknown
-  : unknown
-
-type QueryArgs<T> = T extends QueryRoute & { query: infer TQuery }
-  ? {} extends z.infer<TQuery>
-    ? { query?: z.infer<TQuery> }
-    : { query: z.infer<TQuery> }
-  : unknown
-
-type MutationArgs<T> = T extends MutationRoute & { body: infer TBody }
-  ? {} extends z.infer<TBody>
-    ? { body?: z.infer<TBody> }
-    : { body: z.infer<TBody> }
-  : unknown
-
-export type RouteArgs<T extends QueryRoute | MutationRoute = any> = ([
-  T,
-] extends [Any]
-  ? { query?: any; body?: any; path?: any }
-  : QueryArgs<T> & MutationArgs<T> & PathArgs<T>) &
-  Omit<RequestInit, 'method' | 'body' | 'headers'> & {
-    headers?: Record<string, string | undefined>
-  }
-
-export type RouteRequest<TResult = any> = {
-  route: QueryRoute | MutationRoute
-  pathPattern: RoutePattern
-  method: string
-  args: RouteArgs
-  $result: TResult
-}
-
-export type RouteResponse<TResult = any> = Response & {
-  json(): Promise<TResult>
-}
-
-export type InferRouteResponse<T extends QueryRoute | MutationRoute> =
-  T extends {
-    response: Unchecked<infer TResponse>
-  }
-    ? TResponse
-    : void
-
-export type RouteFunction<T extends QueryRoute | MutationRoute> = {
-  (args: RouteArgs<T>): RouteRequest<InferRouteResponse<T>>
-
-  $args: RouteArgs<T>
-  $response: InferRouteResponse<T>
-}

package/tsconfig.json

@@ -1,10 +0,0 @@
-{
-  "compilerOptions": {
-    "outDir": "dist",
-    "declaration": true,
-    "module": "nodenext",
-    "moduleResolution": "nodenext",
-    "lib": ["dom", "es2019"],
-    "target": "esnext"
-  }
-}