@mstuercke/api-utils 7.0.2 → 7.0.3

package/package.json

@@ -1,19 +1,14 @@
 {
   "name": "@mstuercke/api-utils",
-  "version": "7.0.2",
+  "version": "7.0.3",
   "type": "module",
-  "main": "src/index.ts",
   "files": [
     "src/**/!(*.test|*.fixture).ts",
     "README.md"
   ],
   "exports": {
     "./src": null,
-    "./rest/types": "./src/rest/types/index.ts",
-    "./rest/client": "./src/rest/client/index.ts",
-    "./rest/server": "./src/rest/server/index.ts",
     "./ws/types": "./src/ws/types/index.ts",
-    "./ws/client": "./src/ws/client/index.ts",
     "./ws/server": "./src/ws/server/index.ts"
   },
   "typesVersions": {
@@ -39,26 +34,26 @@
     }
   },
   "scripts": {
-    "test:unit": "bun test",
+    "test:unit": "vitest run --coverage",
     "typeCheck": "tsc",
     "bump:major": "npm version major --git-tag-version false",
     "bump:minor": "npm version minor --git-tag-version false",
     "bump:patch": "npm version patch --git-tag-version false",
-    "release": "bun run scripts/release.ts"
+    "release": "dotenv -- node --no-warnings --trace-uncaught --loader ts-node/esm scripts/release.ts"
   },
   "dependencies": {
     "path-to-regexp": "^8.0.0"
   },
   "peerDependencies": {
     "@aws-sdk/client-apigatewaymanagementapi": "^3.438.0",
-    "@trpc/server": "^11.0.0-rc.748",
+    "@trpc/server": "^11.0.0-rc.795",
     "@types/aws-lambda": "8.10.147"
   },
   "devDependencies": {
-    "@mstuercke/bun-utils": "7.0.6",
-    "@trpc/server": "^11.0.0-rc.748",
+    "@aws-sdk/client-apigatewaymanagementapi": "^3.438.0",
+    "@mstuercke/node-utils": "0.0.1",
+    "@trpc/server": "^11.0.0-rc.795",
     "@types/aws-lambda": "8.10.147",
-    "@types/bun": "1.2.2",
     "@types/path-to-regexp": "1.7.0",
     "@types/react": "19.0.8",
     "aws-sdk-client-mock": "4.1.0",

package/src/__mocks__/ignoreConsoleErrors.ts

@@ -1,5 +1,3 @@
-import {afterEach, beforeEach} from 'bun:test'
-
 export const ignoreConsoleErrors = (...messagesToIgnore: string[]) => {
   let consoleError_original: typeof console.error
   beforeEach(() => {

package/src/ws/server/WsApi.ts

@@ -6,9 +6,9 @@ import type {
   WsApiRequestHandler,
   WsApiResponse,
   WsApiRouteHandler,
-} from '../types'
-import {closeConnection} from './closeConnection'
-import {sendResponse} from './sendResponse'
+} from '../types/index.ts'
+import {closeConnection} from './closeConnection.ts'
+import {sendResponse} from './sendResponse.ts'
 
 export class WsApi {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/src/ws/server/buildWsApiRouteHandler.ts

@@ -5,7 +5,7 @@ import type {
   WsApiResponse,
   WsApiRoute,
   WsApiRouteHandler,
-} from '../types'
+} from '../types/index.ts'
 
 export const buildWsApiRouteHandler = <
   Action extends WsApiAction,

package/src/ws/server/closeConnection.ts

@@ -1,6 +1,6 @@
 import {DeleteConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi'
-import type {WsApiConnection} from '../types'
-import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient'
+import type {WsApiConnection} from '../types/index.ts'
+import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient.ts'
 
 export const closeConnection = async ({endpoint, connectionId}: WsApiConnection) => {
   try {

package/src/ws/server/getConnection.ts

@@ -1,5 +1,5 @@
 import type {APIGatewayProxyEvent} from 'aws-lambda'
-import type {WsApiConnection} from '../types'
+import type {WsApiConnection} from '../types/index.ts'
 
 export const getConnection = (event: APIGatewayProxyEvent): WsApiConnection => {
   if (!event.requestContext.connectionId) throw 'no connectionId'

package/src/ws/server/index.ts

@@ -1,8 +1,8 @@
-export * from './trpc/TrpcSubscriptionRequest'
-export * from './trpc/TrpcSubscriptionResponse'
-export * from './trpc/awsLambdaTrpcSubscriptionRequestHandler'
-export * from './buildWsApiRouteHandler'
-export * from './closeConnection'
-export * from './getConnection'
-export * from './sendResponse'
-export * from './WsApi'
+export * from './trpc/TrpcSubscriptionRequest.ts'
+export * from './trpc/TrpcSubscriptionResponse.ts'
+export * from './trpc/awsLambdaTrpcSubscriptionRequestHandler.ts'
+export * from './buildWsApiRouteHandler.ts'
+export * from './closeConnection.ts'
+export * from './getConnection.ts'
+export * from './sendResponse.ts'
+export * from './WsApi.ts'

package/src/ws/server/sendResponse.ts

@@ -1,6 +1,6 @@
 import {PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi'
-import type {WsApiConnection, WsApiResponse} from '../types'
-import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient'
+import type {WsApiConnection, WsApiResponse} from '../types/index.ts'
+import {getApiGatewayManagementApiClient} from './getApiGatewayManagementApiClient.ts'
 
 export const sendResponse = async <Response extends WsApiResponse>(
   {endpoint, connectionId}: WsApiConnection,

package/src/ws/server/trpc/awsLambdaTrpcSubscriptionRequestHandler.ts

@@ -1,10 +1,10 @@
 import {GetConnectionCommand, GoneException, PostToConnectionCommand} from '@aws-sdk/client-apigatewaymanagementapi'
 import {type AnyTRPCRouter, callTRPCProcedure, type inferRouterContext} from '@trpc/server'
 import type {APIGatewayProxyEvent, APIGatewayProxyResult, Context} from 'aws-lambda'
-import {getApiGatewayManagementApiClient} from '../getApiGatewayManagementApiClient'
-import {getConnection} from '../getConnection'
-import type {TrpcSubscriptionRequest} from './TrpcSubscriptionRequest'
-import type {TrpcSubscriptionResponse} from './TrpcSubscriptionResponse'
+import {getApiGatewayManagementApiClient} from '../getApiGatewayManagementApiClient.ts'
+import {getConnection} from '../getConnection.ts'
+import type {TrpcSubscriptionRequest} from './TrpcSubscriptionRequest.ts'
+import type {TrpcSubscriptionResponse} from './TrpcSubscriptionResponse.ts'
 
 export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRouter>(opts: {
   router: Router
@@ -57,7 +57,7 @@ export const awsLambdaTrpcSubscriptionRequestHandler = <Router extends AnyTRPCRo
             })
 
             const procedure: AsyncGenerator = await callTRPCProcedure({
-              _def: router._def,
+              router,
               path: request.params.path,
               type: 'subscription',
               ctx: (await createContext?.(event)) || {},

package/src/ws/types/WsApiRequestHandler.ts

@@ -1,6 +1,6 @@
-import type {OmitNever} from '../../types/OmitNever'
-import type {WsApiConnection} from './WsApiConnection'
-import type {WsApiAction, WsApiRequest, WsApiResponse} from './common'
+import type {OmitNever} from '../../types/OmitNever.ts'
+import type {WsApiConnection} from './WsApiConnection.ts'
+import type {WsApiAction, WsApiRequest, WsApiResponse} from './common/index.ts'
 
 export type WsApiRequestHandler<
   Action extends WsApiAction,

package/src/ws/types/WsApiRoute.ts

@@ -1,4 +1,4 @@
-import type {WsApiAction, WsApiRequest, WsApiResponse} from './common'
+import type {WsApiAction, WsApiRequest, WsApiResponse} from './common/index.ts'
 
 export type WsApiRoute<
   Action extends WsApiAction,

package/src/ws/types/WsApiRouteHandler.ts

@@ -1,6 +1,6 @@
-import type {WsApiRequestHandler} from './WsApiRequestHandler'
-import type {WsApiRoute} from './WsApiRoute'
-import type {WsApiAction, WsApiRequest, WsApiResponse} from './common'
+import type {WsApiRequestHandler} from './WsApiRequestHandler.ts'
+import type {WsApiRoute} from './WsApiRoute.ts'
+import type {WsApiAction, WsApiRequest, WsApiResponse} from './common/index.ts'
 
 export type WsApiRouteHandler<
   Action extends WsApiAction,

package/src/ws/types/common/WsApiRequest.ts

@@ -1,3 +1,3 @@
-import type {WsApiAction} from './WsApiAction'
+import type {WsApiAction} from './WsApiAction.ts'
 
 export type WsApiRequest<Action extends WsApiAction> = {action: Action}

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

@@ -1,3 +1,3 @@
-export * from './WsApiRequest'
-export * from './WsApiResponse'
-export * from './WsApiAction'
+export * from './WsApiRequest.ts'
+export * from './WsApiResponse.ts'
+export * from './WsApiAction.ts'

package/src/ws/types/index.ts

@@ -1,5 +1,5 @@
-export * from './common'
-export * from './WsApiConnection'
-export * from './WsApiRequestHandler'
-export * from './WsApiRoute'
-export * from './WsApiRouteHandler'
+export * from './common/index.ts'
+export * from './WsApiConnection.ts'
+export * from './WsApiRequestHandler.ts'
+export * from './WsApiRoute.ts'
+export * from './WsApiRouteHandler.ts'

package/src/rest/client/fetchRestApi.ts

@@ -1,49 +0,0 @@
-import type {
-  RestApiRequest,
-  RestApiRoute,
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequestHeadersWithAuthorization,
-  RestRequireAuthentication,
-  RestResponseBody,
-} 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
-    >
-  >,
-): 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 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`
-
-  const text = (await response.text()).trim()
-  return response.ok && response.status !== 204 ? (text ? JSON.parse(text) : null) : null
-}

package/src/rest/client/index.ts

@@ -1 +0,0 @@
-export * from './fetchRestApi'

package/src/rest/server/RestApi.ts

@@ -1,153 +0,0 @@
-import type {APIGatewayProxyEvent, APIGatewayProxyResult} from 'aws-lambda'
-import {URL} from 'node:url'
-import {match} from 'path-to-regexp'
-import type {
-  RestApiRouteHandler,
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequireAuthentication,
-  RestResponseBody,
-} 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
-
-export type AnyRestApiRouteHandler = RestApiRouteHandler<
-  RestPathParams,
-  RestQueryParams,
-  RestRequestHeaders,
-  RestRequestBody,
-  RestResponseBody,
-  RestRequireAuthentication
->
-
-type MatchingRouteHandler = {
-  routeHandler: AnyRestApiRouteHandler
-  pathParams: RestPathParams
-}
-
-export class RestApi {
-  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
-  }
-
-  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)
-      if (!routeHandler && proxyEvent.httpMethod === 'OPTIONS') {
-        const allowedHttpMethods = this.getMatchingRouteHandlers(url).map(({routeHandler}) => routeHandler.route.method)
-        return {
-          statusCode: 200,
-          body: '',
-          headers: {
-            ...DEFAULT_RESPONSE_HEADERS,
-            'Access-Control-Allow-Methods': allowedHttpMethods.join(','),
-          },
-        }
-      }
-
-      if (!routeHandler)
-        return {
-          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 responseBody = await requestHandler({
-        pathParams,
-        queryParams: this.extractQueryParams(proxyEvent),
-        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) : '',
-        headers: {
-          ...DEFAULT_RESPONSE_HEADERS,
-          ...(responseBody.headers || {}),
-        },
-      }
-    } catch (error) {
-      if (onError) await onError(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 matchingRouteHandler: MatchingRouteHandler = {
-        routeHandler,
-        pathParams,
-      }
-      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)
-  }
-
-  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
-  }
-
-  private extractQueryParams(proxyEvent: APIGatewayProxyEvent): object {
-    const keys = new Set([
-      ...Object.keys(proxyEvent.queryStringParameters || {}),
-      ...Object.keys(proxyEvent.multiValueQueryStringParameters || {}),
-    ])
-
-    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
-    }
-    return queryParams
-  }
-}

package/src/rest/server/buildRestApiRouteHandler.ts

@@ -1,33 +0,0 @@
-import type {
-  RestApiRequestHandler,
-  RestApiRoute,
-  RestApiRouteHandler,
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequireAuthentication,
-  RestResponseBody,
-} 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,
->(
-  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 +0,0 @@
-export * from './buildRestApiRouteHandler'
-export * from './RestApi'

package/src/rest/types/RestApiRequest.ts

@@ -1,14 +0,0 @@
-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
-  body: RequestBody
-}>

package/src/rest/types/RestApiRequestHandler.ts

@@ -1,21 +0,0 @@
-import type {RestApiResponse} from './RestApiResponse'
-import type {
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequireAuthentication,
-  RestResponseBody,
-} 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>>

package/src/rest/types/RestApiRequestHandlerWithAuthentication.ts

@@ -1,10 +0,0 @@
-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,
-> = RestApiRequestHandler<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, true>

package/src/rest/types/RestApiResponse.ts

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

package/src/rest/types/RestApiRoute.ts

@@ -1,32 +0,0 @@
-import type {
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequireAuthentication,
-  RestResponseBody,
-} 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,
-> = {
-  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,29 +0,0 @@
-import type {RestApiRequestHandler} from './RestApiRequestHandler'
-import type {RestApiRoute} from './RestApiRoute'
-import type {
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequireAuthentication,
-  RestResponseBody,
-} 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
-  >
-}

package/src/rest/types/RestApiRouteWithAuthentication.ts

@@ -1,10 +0,0 @@
-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,
-> = RestApiRoute<PathParams, QueryParams, RequestHeaders, RequestBody, ResponseBody, true>

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

@@ -1 +0,0 @@
-export type BearerToken = `Bearer ${string}`

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

@@ -1 +0,0 @@
-export type RestPathParams = object | never

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

@@ -1 +0,0 @@
-export type RestQueryParams = object | never

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

@@ -1 +0,0 @@
-export type RestRequestBody = object | never

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

@@ -1 +0,0 @@
-export type RestRequestHeaders = Record<string, string> | never

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

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

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

@@ -1 +0,0 @@
-export type RestRequireAuthentication = boolean

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

@@ -1 +0,0 @@
-export type RestResponseBody = object | object[] | null | never

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

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

package/src/rest/types/index.ts

@@ -1,8 +0,0 @@
-export * from './common'
-export * from './RestApiRequest'
-export * from './RestApiRequestHandler'
-export * from './RestApiRequestHandlerWithAuthentication'
-export * from './RestApiResponse'
-export * from './RestApiRoute'
-export * from './RestApiRouteHandler'
-export * from './RestApiRouteWithAuthentication'

package/src/rest/types/internal/InternalRestApiRequest.ts

@@ -1,21 +0,0 @@
-import type {OmitNever} from '../../../types/OmitNever'
-import type {RestApiRequest} from '../RestApiRequest'
-import type {
-  RestPathParams,
-  RestQueryParams,
-  RestRequestBody,
-  RestRequestHeaders,
-  RestRequireAuthentication,
-} from '../common'
-
-export type InternalRestApiRequest<
-  PathParams extends RestPathParams = never,
-  QueryParams extends RestQueryParams = never,
-  RequestHeaders extends RestRequestHeaders = never,
-  RequestBody extends RestRequestBody = never,
-  RequireAuthentication extends RestRequireAuthentication = false,
-> = OmitNever<
-  RestApiRequest<PathParams, QueryParams, RequestHeaders, RequestBody> & {
-    userId: RequireAuthentication extends true ? string : never
-  }
->

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

@@ -1,2 +0,0 @@
-export * from './InternalRestApiRequest'
-export * from '../../../types/OmitNever'

package/src/ws/client/index.ts

@@ -1 +0,0 @@
-export * from './useWsApi'

package/src/ws/client/useWsApi.ts

@@ -1,99 +0,0 @@
-import {useCallback, useMemo, useRef, useState} from 'react'
-import type {WsApiAction, WsApiRequest, WsApiResponse, WsApiRoute} from '../types'
-
-type WsApiConnection<Action extends WsApiAction, Request extends WsApiRequest<Action>> = {
-  disconnect: () => void
-  sendRequest: (request: Request) => void
-}
-
-export type WsApiOptions<
-  Action extends WsApiAction,
-  Request extends WsApiRequest<Action>,
-  Response extends WsApiResponse,
-> = {
-  onConnected?: (connection: WsApiConnection<Action, Request>) => void
-  onResponse?: (response: Response, connection: WsApiConnection<Action, Request>) => void
-  onError?: (error: unknown, connection: WsApiConnection<Action, Request>) => void
-  onDisconnected?: () => void
-}
-export const useWsApi = <
-  Action extends WsApiAction,
-  Request extends WsApiRequest<Action>,
-  Response extends WsApiResponse,
->(
-  wsApiUrl: string,
-  route: WsApiRoute<Action, Request, Response> | undefined,
-) => {
-  const [error, setError] = useState<boolean>(false)
-  const [connected, setConnected] = useState<boolean>(false)
-  const webSocket = useRef<WebSocket>(undefined)
-
-  const sendRequest = useCallback(
-    (request: Omit<Request, 'action'>) => {
-      if (!route) throw 'Not route'
-      if (!webSocket.current) throw 'Not connected'
-
-      webSocket.current.send(
-        JSON.stringify({
-          ...request,
-          action: route.action,
-        }),
-      )
-    },
-    [route],
-  )
-  const disconnect = useCallback(() => webSocket.current?.close(), [])
-  const connection: WsApiConnection<Action, Request> = useMemo(() => {
-    return {
-      disconnect,
-      sendRequest,
-    }
-  }, [disconnect, sendRequest])
-
-  const connect = useCallback(
-    async (options: WsApiOptions<Action, Request, Response>) => {
-      return new Promise<void>((resolve) => {
-        if (
-          webSocket.current &&
-          (webSocket.current.readyState === WebSocket.CONNECTING || webSocket.current.readyState === WebSocket.OPEN)
-        )
-          throw 'Already connected'
-
-        webSocket.current = new WebSocket(wsApiUrl)
-
-        webSocket.current.onopen = () => {
-          setConnected(true)
-          setError(false)
-          options?.onConnected?.(connection)
-        }
-
-        webSocket.current.onmessage = (ev) => {
-          if (!ev.data || ev.data === '{}') return
-          setError(false)
-          options?.onResponse?.(JSON.parse(ev.data as string), connection)
-        }
-
-        webSocket.current.onerror = (error) => {
-          setError(false)
-          options?.onError?.(error, connection)
-        }
-
-        webSocket.current.onclose = () => {
-          setConnected(false)
-          options?.onDisconnected?.()
-          webSocket.current = undefined
-          resolve()
-        }
-      })
-    },
-    [wsApiUrl, connection],
-  )
-
-  return {
-    connect,
-    connected,
-    connection,
-    error,
-    disconnect,
-  }
-}