@paakd/api 0.0.1 → 0.0.2

package/src/interceptors.ts

@@ -1,224 +0,0 @@
-import type { Message } from '@bufbuild/protobuf'
-import {
-  Code,
-  ConnectError,
-  type Interceptor,
-  type StreamRequest,
-  type StreamResponse,
-  type UnaryRequest,
-  type UnaryResponse,
-} from '@connectrpc/connect'
-import type { Checkout } from '@paakd/config'
-
-export interface RequestLogger {
-  onRequestHeader?: (header: Headers) => void
-  onRequestMessage?: (message: Message) => void
-  onResponseHeader?: (header: Headers) => void
-  onResponseMessage?: (message: Message) => void
-  onResponseTrailer?: (trailer: Headers) => void
-  onError?: (error: unknown) => void
-}
-
-function defaultRequestLogger(
-  req: UnaryRequest | StreamRequest
-): RequestLogger {
-  const name = `${req.method.methodKind} ${req.method.toString()}`
-  return {
-    onRequestHeader(header: Headers) {
-      console.log(name, 'request header', header)
-    },
-    onRequestMessage(message: Message) {
-      console.log(name, 'request message', message)
-    },
-    onResponseHeader(header: Headers) {
-      console.log(name, 'response header', header)
-    },
-    onResponseMessage(message: Message) {
-      console.log(name, 'response message', message)
-    },
-    onResponseTrailer(trailer: Headers) {
-      console.log(name, 'response trailer', trailer)
-    },
-    onError(error: unknown) {
-      console.log(name, 'error', error)
-    },
-  }
-}
-
-export function createLoggingInterceptor(
-  reqLogger: (
-    request: UnaryRequest | StreamRequest
-  ) => RequestLogger = defaultRequestLogger
-): Interceptor {
-  return next => async req => {
-    const logger = reqLogger(req)
-    const reqIntercepted = interceptRequest(req, logger)
-    let res: UnaryResponse | StreamResponse
-    try {
-      res = await next(reqIntercepted)
-    } catch (e) {
-      logger.onError?.(e)
-      throw e
-    }
-    return interceptResponse(res, logger)
-  }
-}
-
-export function createAuthenticationInterceptor(
-  checkoutConfig: Checkout
-): Interceptor {
-  return next => async req => {
-    req.header.set('X-Store-Key', checkoutConfig.storeAPISecret)
-    req.header.set('X-SA-Key', checkoutConfig.storeAccessKey)
-    req.header.set('X-CH-Key', checkoutConfig.salesChannelAPISecret)
-    req.header.set('X-CHA-Key', checkoutConfig.saleChannelAccessKey)
-
-    return await next(req)
-  }
-}
-
-export function createCustomerAuthenticationInterceptor(
-  jwtKey: string
-): Interceptor {
-  return next => async req => {
-    if (!jwtKey) {
-      throw new ConnectError(
-        'JWT key is required for customer authentication',
-        Code.Unauthenticated
-      )
-    }
-    req.header.set('Authorization', `Bearer ${jwtKey}`)
-
-    return await next(req)
-  }
-}
-
-function interceptRequest<R extends UnaryRequest | StreamRequest>(
-  req: R,
-  logger: RequestLogger
-): R {
-  logger.onRequestHeader?.(req.header)
-  if (req.stream) {
-    return {
-      ...req,
-      message: interceptIterable(
-        req.message,
-        message => logger.onRequestMessage?.(message),
-        () => {},
-        () => {}
-      ),
-    }
-  }
-  logger.onRequestMessage?.(req.message)
-
-  return req
-}
-
-function interceptResponse<R extends UnaryResponse | StreamResponse>(
-  res: R,
-  logger: RequestLogger
-): R {
-  logger.onResponseHeader?.(res.header)
-  if (res.stream) {
-    return {
-      ...res,
-      message: interceptIterable(
-        res.message,
-        message => logger.onResponseMessage?.(message),
-        e => logger.onError?.(e),
-        () => logger.onResponseTrailer?.(res.trailer)
-      ),
-    }
-  }
-  logger.onResponseMessage?.(res.message)
-  logger.onResponseTrailer?.(res.trailer)
-
-  return res
-}
-
-function interceptIterable(
-  original: AsyncIterable<Message>,
-  onNext: (value: Message) => void,
-  onNextReject: (e: unknown) => void,
-  onDone: () => void
-): AsyncIterable<Message> {
-  return {
-    [Symbol.asyncIterator]() {
-      const o = original[Symbol.asyncIterator]()
-      const n: AsyncIterator<Message> = {
-        async next(value: Message): Promise<IteratorResult<Message>> {
-          let result: IteratorResult<Message>
-          try {
-            result = await o.next(value)
-          } catch (e) {
-            onNextReject(e)
-            throw e
-          }
-          if (result.done !== true) {
-            onNext(result.value)
-          } else {
-            onDone()
-          }
-          return result
-        },
-      }
-      if (o.throw) {
-        n.throw = (e: unknown): Promise<IteratorResult<Message>> => {
-          return o.throw!(e)
-        }
-      }
-      if (o.return) {
-        n.return = (value: unknown): Promise<IteratorResult<Message>> => {
-          return o.return!(value)
-        }
-      }
-      return n
-    },
-  }
-}
-
-export function createHeadersInterceptor(
-  headers: Record<string, string | null>
-): Interceptor {
-  return next => async req => {
-    if (!headers['x-original-host']) {
-      throw new ConnectError(
-        'Original host missing from request',
-        Code.InvalidArgument
-      )
-    }
-    if (!headers['x-shop-id']) {
-      throw new ConnectError(
-        'Shop id missing from request',
-        Code.InvalidArgument
-      )
-    }
-    if (!headers['x-sitepath']) {
-      throw new ConnectError(
-        'Sitepath missing from request',
-        Code.InvalidArgument
-      )
-    }
-    if (!headers['x-locale']) {
-      throw new ConnectError(
-        'Locale missing from request',
-        Code.InvalidArgument
-      )
-    }
-
-    if (!headers['x-region']) {
-      throw new ConnectError(
-        'Region missing from request',
-        Code.InvalidArgument
-      )
-    }
-
-    req.header.set('X-Original-Host', headers['x-original-host'])
-    req.header.set('X-shop-id', headers['x-shop-id'])
-    req.header.set('X-Sitepath', headers['x-sitepath'])
-    req.header.set('X-locale', headers['x-locale'])
-    req.header.set('X-Region', headers['x-region'])
-
-    return await next(req)
-  }
-}