@paakd/api 0.0.1

package/src/interceptors.ts

@@ -0,0 +1,224 @@
+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)
+  }
+}