@mstuercke/api-utils 5.2.2 → 6.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mstuercke/api-utils",
-  "version": "5.2.2",
+  "version": "6.0.1",
   "type": "module",
   "main": "src/index.ts",
   "files": [
@@ -39,8 +39,6 @@
     }
   },
   "scripts": {
-    "lint": "eslint ./src --max-warnings 0",
-    "lint:fix": "eslint ./src --fix",
     "test:unit": "bun test",
     "compile": "tsc",
     "bump:major": "npm version major --git-tag-version false",
@@ -49,7 +47,7 @@
     "release": "bun run scripts/release.ts"
   },
   "dependencies": {
-    "path-to-regexp": "^6.2.2"
+    "path-to-regexp": "^7.0.0"
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.438.0",
@@ -57,7 +55,7 @@
     "@types/aws-lambda": "^8.10.138"
   },
   "devDependencies": {
-    "@mstuercke/bun-utils": "6.0.2",
+    "@mstuercke/bun-utils": "6.1.0",
     "@trpc/server": "^11.0.0-rc.390",
     "@types/aws-lambda": "^8.10.138",
     "@types/bun": "^1.1.3",

package/src/__mocks__/ignoreConsoleErrors.ts

@@ -1,19 +1,17 @@
-import {afterEach, beforeEach} from 'bun:test';
-
+import {afterEach, beforeEach} from 'bun:test'
 
 export const ignoreConsoleErrors = (...messagesToIgnore: string[]) => {
-  let consoleError_original: typeof console.error;
+  let consoleError_original: typeof console.error
   beforeEach(() => {
-    consoleError_original = console.error;
+    consoleError_original = console.error
     console.error = (...data) => {
-      if (data.length === 1 && messagesToIgnore.includes(data[0]))
-        return;
+      if (data.length === 1 && messagesToIgnore.includes(data[0])) return
 
-      consoleError_original(...data);
-    };
-  });
+      consoleError_original(...data)
+    }
+  })
 
   afterEach(() => {
-    console.error = consoleError_original;
-  });
-};
+    console.error = consoleError_original
+  })
+}

package/src/rest/client/fetchRestApi.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   RestApiRequest,
   RestApiRoute,
   RestPathParams,
@@ -8,40 +8,42 @@ import {
   RestRequestHeadersWithAuthorization,
   RestRequireAuthentication,
   RestResponseBody,
-} from '../types';
-import {OmitNever} from '../types/internal';
-
+} from '../types'
+import type {OmitNever} from '../types/internal'
 
 export async function fetchRestApi<
-    PathParams extends RestPathParams,
-    QueryParams extends RestQueryParams,
-    RequestHeaders extends RestRequestHeaders,
-    RequestBody extends RestRequestBody,
-    ResponseBody extends RestResponseBody,
-    RequireAuthentication extends RestRequireAuthentication>(
-    restApiUrl: string,
-    route: RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
-    request: OmitNever<RestApiRequest<PathParams, QueryParams, RestRequestHeadersWithAuthorization<RequestHeaders, RequireAuthentication>, RequestBody>>,
+  PathParams extends RestPathParams,
+  QueryParams extends RestQueryParams,
+  RequestHeaders extends RestRequestHeaders,
+  RequestBody extends RestRequestBody,
+  ResponseBody extends RestResponseBody,
+  RequireAuthentication extends RestRequireAuthentication,
+>(
+  restApiUrl: string,
+  route: RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
+  request: OmitNever<
+    RestApiRequest<
+      PathParams,
+      QueryParams,
+      RestRequestHeadersWithAuthorization<RequestHeaders, RequireAuthentication>,
+      RequestBody
+    >
+  >,
 ): Promise<ResponseBody> {
-  const pathParams = 'pathParams' in request ? request.pathParams as PathParams : undefined as never;
-  const queryParams = 'queryParams' in request ? request.queryParams as QueryParams : undefined as never;
-  const headers = 'headers' in request ? request.headers as RequestHeaders : undefined as never;
-  const body = 'body' in request ? request.body as RequestBody : undefined as never;
+  const pathParams = 'pathParams' in request ? (request.pathParams as PathParams) : (undefined as never)
+  const queryParams = 'queryParams' in request ? (request.queryParams as QueryParams) : (undefined as never)
+  const headers = 'headers' in request ? (request.headers as RequestHeaders) : (undefined as never)
+  const body = 'body' in request ? (request.body as RequestBody) : (undefined as never)
 
-  const url = `${restApiUrl}${route.buildUrl(pathParams, queryParams)}`;
-  const response = await fetch(
-      url,
-      {
-        method: route.method,
-        headers: headers,
-        body: body ? JSON.stringify(body) : null,
-      });
+  const url = `${restApiUrl}${route.buildUrl(pathParams, queryParams)}`
+  const response = await fetch(url, {
+    method: route.method,
+    headers: headers,
+    body: body ? JSON.stringify(body) : null,
+  })
 
-  if (!response.ok && response.status !== 404)
-    throw `Request ${route.method} ${url} failed`;
+  if (!response.ok && response.status !== 404) throw `Request ${route.method} ${url} failed`
 
-  const text = (await response.text()).trim();
-  return response.ok && response.status !== 204
-      ? text ? JSON.parse(text) : null
-      : null;
+  const text = (await response.text()).trim()
+  return response.ok && response.status !== 204 ? (text ? JSON.parse(text) : null) : null
 }

package/src/rest/server/RestApi.ts

@@ -1,7 +1,7 @@
-import {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda';
-import {URL} from 'node:url';
-import {match} from 'path-to-regexp';
-import {
+import type {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda'
+import {URL} from 'node:url'
+import {match} from 'path-to-regexp'
+import type {
   RestApiRouteHandler,
   RestPathParams,
   RestQueryParams,
@@ -9,51 +9,62 @@ import {
   RestRequestHeaders,
   RestRequireAuthentication,
   RestResponseBody,
-} from '../types';
-
+} from '../types'
 
 const DEFAULT_RESPONSE_HEADERS = {
   'Content-Type': 'application/json; charset=utf-8',
   'Access-Control-Allow-Origin': '*',
   'Access-Control-Allow-Methods': '*',
   'Access-Control-Allow-Headers': '*',
-} as const;
+} as const
 
 export type AnyRestApiRouteHandler = RestApiRouteHandler<
-    RestPathParams,
-    RestQueryParams,
-    RestRequestHeaders,
-    RestRequestBody,
-    RestResponseBody,
-    RestRequireAuthentication
+  RestPathParams,
+  RestQueryParams,
+  RestRequestHeaders,
+  RestRequestBody,
+  RestResponseBody,
+  RestRequireAuthentication
 >
 
 type MatchingRouteHandler = {
-  routeHandler: AnyRestApiRouteHandler,
-  pathParams: RestPathParams,
+  routeHandler: AnyRestApiRouteHandler
+  pathParams: RestPathParams
 }
 
 export class RestApi {
-  private routeHandlers: AnyRestApiRouteHandler[] = [];
+  private routeHandlers: AnyRestApiRouteHandler[] = []
 
   addRouteHandler<
-      PathParams extends RestPathParams,
-      QueryParams extends RestQueryParams,
-      RequestHeaders extends RestRequestHeaders,
-      RequestBody extends RestRequestBody,
-      ResponseBody extends RestResponseBody,
-      RequireAuthentication extends RestRequireAuthentication>(
-      routeHandler: RestApiRouteHandler<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>) {
-    this.routeHandlers = [...this.routeHandlers, routeHandler as unknown as AnyRestApiRouteHandler];
-    return this;
+    PathParams extends RestPathParams,
+    QueryParams extends RestQueryParams,
+    RequestHeaders extends RestRequestHeaders,
+    RequestBody extends RestRequestBody,
+    ResponseBody extends RestResponseBody,
+    RequireAuthentication extends RestRequireAuthentication,
+  >(
+    routeHandler: RestApiRouteHandler<
+      PathParams,
+      QueryParams,
+      RequestHeaders,
+      RequestBody,
+      ResponseBody,
+      RequireAuthentication
+    >,
+  ) {
+    this.routeHandlers = [...this.routeHandlers, routeHandler as unknown as AnyRestApiRouteHandler]
+    return this
   }
 
-  async handleRequest(proxyEvent: APIGatewayProxyEvent, onError?: (error: unknown) => Promise<void>): Promise<APIGatewayProxyResult> {
+  async handleRequest(
+    proxyEvent: APIGatewayProxyEvent,
+    onError?: (error: unknown) => Promise<void>,
+  ): Promise<APIGatewayProxyResult> {
     try {
-      const url = new URL(`${proxyEvent.headers?.['origin'] || 'https://no-origin'}${proxyEvent.path}`);
-      const routeHandler = this.getMatchingRouteHandler(url, proxyEvent.httpMethod);
+      const url = new URL(`${proxyEvent.headers?.['origin'] || 'https://no-origin'}${proxyEvent.path}`)
+      const routeHandler = this.getMatchingRouteHandler(url, proxyEvent.httpMethod)
       if (!routeHandler && proxyEvent.httpMethod === 'OPTIONS') {
-        const allowedHttpMethods = this.getMatchingRouteHandlers(url).map(({routeHandler}) => routeHandler.route.method);
+        const allowedHttpMethods = this.getMatchingRouteHandlers(url).map(({routeHandler}) => routeHandler.route.method)
         return {
           statusCode: 200,
           body: '',
@@ -61,7 +72,7 @@ export class RestApi {
             ...DEFAULT_RESPONSE_HEADERS,
             'Access-Control-Allow-Methods': allowedHttpMethods.join(','),
           },
-        };
+        }
       }
 
       if (!routeHandler)
@@ -69,12 +80,14 @@ export class RestApi {
           statusCode: 405,
           headers: DEFAULT_RESPONSE_HEADERS,
           body: `Method ${proxyEvent.httpMethod} not allowed on ${proxyEvent.path}`,
-        };
+        }
 
-      const {routeHandler: {requestHandler, route}, pathParams} = routeHandler;
-      const userId = proxyEvent.requestContext.authorizer?.principalId;
-      if (route.requireAuthentication && !userId)
-        return {statusCode: 401, body: ''};
+      const {
+        routeHandler: {requestHandler, route},
+        pathParams,
+      } = routeHandler
+      const userId = proxyEvent.requestContext.authorizer?.principalId
+      if (route.requireAuthentication && !userId) return {statusCode: 401, body: ''}
 
       const responseBody = await requestHandler({
         pathParams,
@@ -82,7 +95,7 @@ export class RestApi {
         headers: proxyEvent.headers as Record<string, string>,
         body: proxyEvent.body && JSON.parse(proxyEvent.body),
         userId,
-      });
+      })
       return {
         statusCode: responseBody.status,
         body: responseBody.body ? JSON.stringify(responseBody.body) : '',
@@ -90,55 +103,51 @@ export class RestApi {
           ...DEFAULT_RESPONSE_HEADERS,
           ...(responseBody.headers || {}),
         },
-      };
+      }
     } catch (error) {
-      if (onError)
-        await onError(error);
+      if (onError) await onError(error)
 
-      console.error(error);
+      console.error(error)
       return {
         statusCode: 500,
         headers: DEFAULT_RESPONSE_HEADERS,
         body: JSON.stringify({error}),
-      };
+      }
     }
   }
 
   private getMatchingRouteHandlers(url: URL): MatchingRouteHandler[] {
     return this.routeHandlers.reduce((matchingRouteHandlers, routeHandler) => {
-      const pathParams = this.extractPathParams(routeHandler, url);
+      const pathParams = this.extractPathParams(routeHandler, url)
       const matchingRouteHandler: MatchingRouteHandler = {
         routeHandler,
         pathParams,
-      };
-      return pathParams
-          ? [...matchingRouteHandlers, matchingRouteHandler]
-          : matchingRouteHandlers;
-    }, [] as MatchingRouteHandler[]);
+      }
+      return pathParams ? [...matchingRouteHandlers, matchingRouteHandler] : matchingRouteHandlers
+    }, [] as MatchingRouteHandler[])
   }
 
   private getMatchingRouteHandler(url: URL, httpMethod: string): MatchingRouteHandler | undefined {
-    return this.getMatchingRouteHandlers(url)
-        .find(({routeHandler}) => routeHandler.route.method === httpMethod);
+    return this.getMatchingRouteHandlers(url).find(({routeHandler}) => routeHandler.route.method === httpMethod)
   }
 
   private extractPathParams(routeHandler: AnyRestApiRouteHandler, url: URL): object | never {
-    const matcher = match(routeHandler.route.path, {decode: decodeURIComponent});
-    return (matcher(url.pathname) || null)?.params as object | never;
+    const matcher = match(routeHandler.route.path, {decode: decodeURIComponent})
+    return (matcher(url.pathname) || null)?.params as object | never
   }
 
   private extractQueryParams(proxyEvent: APIGatewayProxyEvent): object {
     const keys = new Set([
       ...Object.keys(proxyEvent.queryStringParameters || {}),
       ...Object.keys(proxyEvent.multiValueQueryStringParameters || {}),
-    ]);
+    ])
 
-    const queryParams: { [key: string]: string | string[] | undefined } = {};
+    const queryParams: {[key: string]: string | string[] | undefined} = {}
     for (const key of keys.values()) {
-      const singleValue = proxyEvent.queryStringParameters?.[key];
-      const multiValues = proxyEvent.multiValueQueryStringParameters?.[key] || [];
-      queryParams[key] = multiValues.length > 1 ? multiValues : singleValue;
+      const singleValue = proxyEvent.queryStringParameters?.[key]
+      const multiValues = proxyEvent.multiValueQueryStringParameters?.[key] || []
+      queryParams[key] = multiValues.length > 1 ? multiValues : singleValue
     }
-    return queryParams;
+    return queryParams
   }
 }

package/src/rest/server/buildRestApiRouteHandler.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   RestApiRequestHandler,
   RestApiRoute,
   RestApiRouteHandler,
@@ -8,19 +8,26 @@ import {
   RestRequestHeaders,
   RestRequireAuthentication,
   RestResponseBody,
-} from '../types';
+} from '../types'
 
 export const buildRestApiRouteHandler = <
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    ResponseBody extends RestResponseBody = never,
-    RequireAuthentication extends RestRequireAuthentication = false
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  ResponseBody extends RestResponseBody = never,
+  RequireAuthentication extends RestRequireAuthentication = false,
 >(
-    route: RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
-    requestHandler: RestApiRequestHandler<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
+  route: RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
+  requestHandler: RestApiRequestHandler<
+    PathParams,
+    QueryParams,
+    RequestHeaders,
+    RequestBody,
+    ResponseBody,
+    RequireAuthentication
+  >,
 ): RestApiRouteHandler<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication> => ({
   route,
   requestHandler,
-});
+})

package/src/rest/server/index.ts

@@ -1,2 +1,2 @@
-export * from './buildRestApiRouteHandler';
-export * from './RestApi';
+export * from './buildRestApiRouteHandler'
+export * from './RestApi'

package/src/rest/types/RestApiRequest.ts

@@ -1,14 +1,14 @@
-import {RestPathParams, RestQueryParams, RestRequestBody, RestRequestHeaders} from './common';
-import {OmitNever} from './internal';
+import type {RestPathParams, RestQueryParams, RestRequestBody, RestRequestHeaders} from './common'
+import type {OmitNever} from './internal'
 
 export type RestApiRequest<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never> = OmitNever<{
-  pathParams: PathParams,
-  queryParams: QueryParams,
-  headers: RequestHeaders,
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+> = OmitNever<{
+  pathParams: PathParams
+  queryParams: QueryParams
+  headers: RequestHeaders
   body: RequestBody
 }>
-

package/src/rest/types/RestApiRequestHandler.ts

@@ -1,21 +1,21 @@
-import {RestApiResponse} from './RestApiResponse';
-import {
+import type {RestApiResponse} from './RestApiResponse'
+import type {
   RestPathParams,
   RestQueryParams,
   RestRequestBody,
   RestRequestHeaders,
   RestRequireAuthentication,
   RestResponseBody,
-} from './common';
-import {InternalRestApiRequest} from './internal';
+} from './common'
+import type {InternalRestApiRequest} from './internal'
 
 export type RestApiRequestHandler<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    ResponseBody extends RestResponseBody = never,
-    RequireAuthentication extends RestRequireAuthentication = false
-> = (request: InternalRestApiRequest<PathParams, QueryParams, RequestHeaders, RequestBody, RequireAuthentication>) => Promise<RestApiResponse<ResponseBody>>;
-
-
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  ResponseBody extends RestResponseBody = never,
+  RequireAuthentication extends RestRequireAuthentication = false,
+> = (
+  request: InternalRestApiRequest<PathParams, QueryParams, RequestHeaders, RequestBody, RequireAuthentication>,
+) => Promise<RestApiResponse<ResponseBody>>

package/src/rest/types/RestApiRequestHandlerWithAuthentication.ts

@@ -1,12 +1,10 @@
-import {RestApiRequestHandler} from './RestApiRequestHandler';
-import {RestPathParams, RestQueryParams, RestRequestBody, RestRequestHeaders, RestResponseBody} from './common';
+import type {RestApiRequestHandler} from './RestApiRequestHandler'
+import type {RestPathParams, RestQueryParams, RestRequestBody, RestRequestHeaders, RestResponseBody} from './common'
 
 export type RestApiRequestHandlerWithAuthentication<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    ResponseBody extends RestResponseBody = never,
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  ResponseBody extends RestResponseBody = never,
 > = RestApiRequestHandler<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, true>
-
-

package/src/rest/types/RestApiResponse.ts

@@ -1,5 +1,5 @@
 export interface RestApiResponse<ResponseBody> {
-  status: number;
-  headers?: Record<string, string>;
-  body?: ResponseBody;
+  status: number
+  headers?: Record<string, string>
+  body?: ResponseBody
 }

package/src/rest/types/RestApiRoute.ts

@@ -1,34 +1,32 @@
-import {
+import type {
   RestPathParams,
   RestQueryParams,
   RestRequestBody,
   RestRequestHeaders,
   RestRequireAuthentication,
   RestResponseBody,
-} from './common';
+} from './common'
 
 export type RestHttpMethod = 'GET' | 'POST' | 'DELETE' | 'PATCH' | 'PUT' | 'OPTIONS'
 export type RestRoutePath = `/${string}`
 
 export type RestApiRoute<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    ResponseBody extends RestResponseBody = never,
-    RequireAuthentication extends RestRequireAuthentication = false
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  ResponseBody extends RestResponseBody = never,
+  RequireAuthentication extends RestRequireAuthentication = false,
 > = {
-  method: RestHttpMethod;
-  path: RestRoutePath;
-  buildUrl: (pathParams: PathParams, queryParams: QueryParams) => RestRoutePath;
-  requireAuthentication: RequireAuthentication;
+  method: RestHttpMethod
+  path: RestRoutePath
+  buildUrl: (pathParams: PathParams, queryParams: QueryParams) => RestRoutePath
+  requireAuthentication: RequireAuthentication
 
   // this is a workaround to force optional generics to be typesafe
   __types?: {
     RequestHeaders: RequestHeaders
     RequestBody: RequestBody
     ResponseBody: ResponseBody
-  };
+  }
 }
-
-

package/src/rest/types/RestApiRouteHandler.ts

@@ -1,22 +1,29 @@
-import {RestApiRequestHandler} from './RestApiRequestHandler';
-import {RestApiRoute} from './RestApiRoute';
-import {
+import type {RestApiRequestHandler} from './RestApiRequestHandler'
+import type {RestApiRoute} from './RestApiRoute'
+import type {
   RestPathParams,
   RestQueryParams,
   RestRequestBody,
   RestRequestHeaders,
   RestRequireAuthentication,
   RestResponseBody,
-} from './common';
+} from './common'
 
 export interface RestApiRouteHandler<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    ResponseBody extends RestResponseBody = never,
-    RequireAuthentication extends RestRequireAuthentication = false> {
-  route: RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
-  requestHandler: RestApiRequestHandler<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>,
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  ResponseBody extends RestResponseBody = never,
+  RequireAuthentication extends RestRequireAuthentication = false,
+> {
+  route: RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, RequireAuthentication>
+  requestHandler: RestApiRequestHandler<
+    PathParams,
+    QueryParams,
+    RequestHeaders,
+    RequestBody,
+    ResponseBody,
+    RequireAuthentication
+  >
 }
-

package/src/rest/types/RestApiRouteWithAuthentication.ts

@@ -1,12 +1,10 @@
-import {RestApiRoute} from './RestApiRoute';
-import {RestPathParams, RestQueryParams, RestRequestBody, RestRequestHeaders, RestResponseBody} from './common';
+import type {RestApiRoute} from './RestApiRoute'
+import type {RestPathParams, RestQueryParams, RestRequestBody, RestRequestHeaders, RestResponseBody} from './common'
 
 export type RestApiRouteWithAuthentication<
-    PathParams extends RestPathParams = never,
-    QueryParams extends RestQueryParams = never,
-    RequestHeaders extends RestRequestHeaders = never,
-    RequestBody extends RestRequestBody = never,
-    ResponseBody extends RestResponseBody = never,
+  PathParams extends RestPathParams = never,
+  QueryParams extends RestQueryParams = never,
+  RequestHeaders extends RestRequestHeaders = never,
+  RequestBody extends RestRequestBody = never,
+  ResponseBody extends RestResponseBody = never,
 > = RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, true>
-
-

package/src/rest/types/common/RestRequestHeadersWithAuthorization.ts

@@ -1,11 +1,13 @@
-import {BearerToken} from "./BearerToken";
-import {RestRequestHeaders} from './RestRequestHeaders';
-import {RestRequireAuthentication} from './RestRequireAuthentication';
+import type {BearerToken} from './BearerToken'
+import type {RestRequestHeaders} from './RestRequestHeaders'
+import type {RestRequireAuthentication} from './RestRequireAuthentication'
 
-export type AuthorizationHeader = { Authorization: BearerToken }
+export type AuthorizationHeader = {Authorization: BearerToken}
 export type RestRequestHeadersWithAuthorization<
-    RequestHeaders extends RestRequestHeaders,
-    RequireAuthentication extends RestRequireAuthentication
+  RequestHeaders extends RestRequestHeaders,
+  RequireAuthentication extends RestRequireAuthentication,
 > = RequireAuthentication extends true
-    ? [RequestHeaders] extends [never] ? AuthorizationHeader : RequestHeaders & AuthorizationHeader
-    : RequestHeaders
+  ? [RequestHeaders] extends [never]
+    ? AuthorizationHeader
+    : RequestHeaders & AuthorizationHeader
+  : RequestHeaders

package/src/rest/types/common/index.ts

@@ -1,8 +1,8 @@
-export * from './BearerToken';
-export * from './RestRequestHeadersWithAuthorization';
-export * from './RestPathParams';
-export * from './RestQueryParams';
-export * from './RestRequestBody';
-export * from './RestRequestHeaders';
-export * from './RestRequireAuthentication';
-export * from './RestResponseBody';
+export * from './BearerToken'
+export * from './RestRequestHeadersWithAuthorization'
+export * from './RestPathParams'
+export * from './RestQueryParams'
+export * from './RestRequestBody'
+export * from './RestRequestHeaders'
+export * from './RestRequireAuthentication'
+export * from './RestResponseBody'