@commercetools/checkout-payments-processor-fastify 0.0.6

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @commercetools/checkout-payments-processor-sdk
+
+## 0.0.2
+
+### Patch Changes
+
+- af90f7f: Sample change for all the packages
+- Updated dependencies [af90f7f]
+  - @commercetools/checkout-payments-processor-sdk@0.0.2
+
+## 0.0.1
+
+### Patch Changes
+
+- Initialising repository

package/README.md

@@ -0,0 +1,42 @@
+# @commercetools/checkout-payments-processor-sdk
+
+The Processor Module acts as the middleware between commercetools and the payment service provider, handling transaction processing and payment updates. It handles key operations such as payment authorization, capture, refund, and cancellation directly with the payment service provider while ensuring transactions are processed and saved accurately in commercetools composable commerce.
+
+## Key Responsibilities
+* Receives payment requests from the enabler.
+* Communicates with the PSP for authorization, capture, refund, and cancellation.
+* Updates commercetools payment objects based on PSP responses.
+* Ensures secure and idempotent transaction handling.
+
+## Prerequisites
+
+commercetools Checkout has support for two component integration types (payment components and drop-in components)
+
+The payment connector requires:
+
+* A commercetools Composable Commerce API Client with permissions for:
+  * `manage_payments`
+  * `manage_orders`
+  * `view_sessions`
+  * `view_api_clients`
+  * `manage_checkout_payment_intents`
+  * `introspect_oauth_tokens`
+
+* Additional API credentials  capable of managing connnector-related operations. This includes tasks like:
+  * Installing the connector
+  * Deploying and updating the connector
+  * Performing connector-related maintenance operations
+
+For more details on setting up and managing connectors, refer to the commercetools Connector Deployment Documentation.
+
+# Access & Authentication
+The integration uses several authentication methods to ensure secure communication between different components. These include:
+
+## Session Authentication
+The integration will use session-based authentication for frontend-to-backend communication. The session information is passed via the X-Session-Id header, which is validated by the Processor to ensure the request is trusted and associated with the correct session.
+
+## JWT Validation
+JSON Web Tokens (JWT) are used to validate operations performed within the commercetools Merchant Center. The Processor supports JWT validation to authenticate and authorize requests for internal operations.
+
+## OAuth Authentication
+OAuth 2.0 is used for server-to-server communication to manage secure operations such as capture, cancel, and refund of payments. The OAuth credentials are validated via the introspect_oauth_tokens scope to ensure that the Processor has the necessary permissions for these operations.

package/biome.json

@@ -0,0 +1,38 @@
+{
+	"$schema": "https://biomejs.dev/schemas/2.2.4/schema.json",
+	"vcs": {
+		"enabled": false,
+		"clientKind": "git",
+		"useIgnoreFile": false
+	},
+	"files": {
+		"ignoreUnknown": false
+	},
+	"formatter": {
+		"enabled": true,
+		"indentStyle": "space",
+		"indentWidth": 2
+	},
+	"linter": {
+		"enabled": true,
+		"rules": {
+			"recommended": true,
+			"style": {
+				"useImportType": "error"
+			}
+		}
+	},
+	"javascript": {
+		"formatter": {
+			"quoteStyle": "single"
+		}
+	},
+	"assist": {
+		"enabled": true,
+		"actions": {
+			"source": {
+				"organizeImports": "on"
+			}
+		}
+	}
+}

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@commercetools/checkout-payments-processor-fastify",
+  "version": "0.0.6",
+  "description": "Checkout payments SDK for processor",
+  "type": "module",
+  "main": "dist/plugin.js",
+  "types": "dist/plugin.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [],
+  "author": "commercetools",
+  "license": "ISC",
+  "devDependencies": {
+    "@biomejs/biome": "2.2.5",
+    "@tsconfig/node24": "24.0.1",
+    "@types/node": "24.7.0",
+    "@vitest/coverage-istanbul": "^3.2.4",
+    "tsc-alias": "1.8.16",
+    "tsx": "4.20.6",
+    "typedoc": "0.28.13",
+    "typescript": "5.9.3",
+    "vite-tsconfig-paths": "5.1.4",
+    "vitest": "3.2.4"
+  },
+  "dependencies": {
+    "@fastify/request-context": "6.2.1",
+    "@sinclair/typebox": "0.34.41",
+    "fastify": "5.7.3",
+    "fastify-plugin": "5.1.0",
+    "schema": "link:fastify/types/schema",
+    "@commercetools/checkout-payments-processor-sdk": "0.0.6"
+  },
+  "scripts": {
+    "build": "rm -rf ./dist && tsc -p tsconfig.prod.json && tsc-alias",
+    "clean": "rm -rf ./dist ./coverage ./node_modules",
+    "format": "biome check --write ./src",
+    "lint": "biome check ./src",
+    "test": "vitest run --coverage",
+    "test:watch": "vitest",
+    "doc": "typedoc --options typedoc.json"
+  }
+}

package/src/context/context.ts

@@ -0,0 +1,69 @@
+import * as paymentSdk from '@commercetools/checkout-payments-processor-sdk';
+import { requestContext } from '@fastify/request-context';
+
+export type ContextData = {
+  anonymousId?: string;
+  customerId?: string;
+  path?: string;
+  pathTemplate?: string;
+  // biome-ignore lint/suspicious/noExplicitAny: path params is any
+  pathParams?: any;
+  // biome-ignore lint/suspicious/noExplicitAny: query is any
+  query?: any;
+  correlationId: string;
+  requestId: string;
+  authentication?: paymentSdk.Authentication;
+};
+
+export const getRequestContext = (): Partial<ContextData> => {
+  return requestContext.get('request') ?? {};
+};
+
+export const setRequestContext = (ctx: ContextData) => {
+  requestContext.set('request', ctx);
+};
+
+export const updateRequestContext = (ctx: Partial<ContextData>) => {
+  const currentContext = getRequestContext();
+  setRequestContext({
+    ...(currentContext as ContextData),
+    ...ctx,
+  });
+};
+
+export const getCtSessionIdFromContext = (): string => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getCtSessionIdFromContext(contextData) as string;
+};
+
+export const getCartIdFromContext = (): string => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getCartIdFromContext(contextData) as string;
+};
+
+export const getAllowedPaymentMethodsFromContext = (): string[] => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getAllowedPaymentMethodsFromContext(
+    contextData,
+  ) as string[];
+};
+
+export const getPaymentInterfaceFromContext = (): string | undefined => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getPaymentInterfaceFromContext(contextData);
+};
+
+export const getProcessorUrlFromContext = (): string => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getProcessorUrlFromContext(contextData) as string;
+};
+
+export const getMerchantReturnUrlFromContext = (): string | undefined => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getMerchantReturnUrlFromContext(contextData);
+};
+
+export const getFutureOrderNumberFromContext = (): string | undefined => {
+  const contextData = getRequestContext() as ContextData;
+  return paymentSdk.getFutureOrderNumberFromContext(contextData);
+};

package/src/dtos/error.dto.ts

@@ -0,0 +1,36 @@
+import { type Static, Type } from '@sinclair/typebox';
+
+/**
+ * Represents https://docs.commercetools.com/api/errors#errorobject
+ */
+export const ErrorObject = Type.Object(
+  {
+    code: Type.String(),
+    message: Type.String(),
+  },
+  { additionalProperties: true },
+);
+
+/**
+ * Represents https://docs.commercetools.com/api/errors#errorresponse
+ */
+export const ErrorResponse = Type.Object({
+  statusCode: Type.Integer(),
+  message: Type.String(),
+  errors: Type.Array(ErrorObject),
+});
+
+/**
+ * Represents https://docs.commercetools.com/api/errors#autherrorresponse
+ */
+export const AuthErrorResponse = Type.Composite([
+  ErrorResponse,
+  Type.Object({
+    error: Type.String(),
+    error_description: Type.Optional(Type.String()),
+  }),
+]);
+
+export type TErrorObject = Static<typeof ErrorObject>;
+export type TErrorResponse = Static<typeof ErrorResponse>;
+export type TAuthErrorResponse = Static<typeof AuthErrorResponse>;

package/src/dtos/payment-componets.dto.ts

@@ -0,0 +1,24 @@
+import { type Static, Type } from '@sinclair/typebox';
+
+const DropinType = Type.Enum({
+  EMBEDDED: 'embedded',
+  HPP: 'hpp',
+});
+
+export const SupportedPaymentDropinsData = Type.Object({
+  type: DropinType,
+});
+
+export const SupportedPaymentComponentsData = Type.Object({
+  type: Type.String(),
+  subtypes: Type.Optional(Type.Array(Type.String())),
+});
+
+export const SupportedPaymentComponentsSchema = Type.Object({
+  dropins: Type.Array(SupportedPaymentDropinsData),
+  components: Type.Array(SupportedPaymentComponentsData),
+});
+
+export type SupportedPaymentComponentsSchemaDTO = Static<
+  typeof SupportedPaymentComponentsSchema
+>;

package/src/dtos/payment-intents.dto.ts

@@ -0,0 +1,74 @@
+import { type Static, Type } from '@sinclair/typebox';
+
+export const AmountSchema = Type.Object({
+  centAmount: Type.Integer(),
+  currencyCode: Type.String(),
+});
+
+export const ActionCapturePaymentSchema = Type.Composite([
+  Type.Object({
+    action: Type.Literal('capturePayment'),
+  }),
+  Type.Object({
+    amount: AmountSchema,
+    merchantReference: Type.Optional(Type.String()),
+  }),
+]);
+
+export const ActionRefundPaymentSchema = Type.Composite([
+  Type.Object({
+    action: Type.Literal('refundPayment'),
+  }),
+  Type.Object({
+    amount: AmountSchema,
+    merchantReference: Type.Optional(Type.String()),
+    transactionId: Type.Optional(Type.String()),
+  }),
+]);
+
+export const ActionCancelPaymentSchema = Type.Composite([
+  Type.Object({
+    action: Type.Literal('cancelPayment'),
+    merchantReference: Type.Optional(Type.String()),
+  }),
+]);
+
+export const ActionReversePaymentSchema = Type.Composite([
+  Type.Object({
+    action: Type.Literal('reversePayment'),
+    merchantReference: Type.Optional(Type.String()),
+  }),
+]);
+
+export const PaymentIntentRequestSchema = Type.Object({
+  actions: Type.Array(
+    Type.Union([
+      ActionCapturePaymentSchema,
+      ActionRefundPaymentSchema,
+      ActionCancelPaymentSchema,
+      ActionReversePaymentSchema,
+    ]),
+    {
+      maxItems: 1,
+    },
+  ),
+});
+
+export enum PaymentModificationStatus {
+  APPROVED = 'approved',
+  REJECTED = 'rejected',
+  RECEIVED = 'received',
+}
+const PaymentModificationSchema = Type.Enum(PaymentModificationStatus);
+
+export const PaymentIntentResponseSchema = Type.Object({
+  outcome: PaymentModificationSchema,
+});
+
+export type PaymentIntentRequestSchemaDTO = Static<
+  typeof PaymentIntentRequestSchema
+>;
+export type PaymentIntentResponseSchemaDTO = Static<
+  typeof PaymentIntentResponseSchema
+>;
+export type AmountSchemaDTO = Static<typeof AmountSchema>;

package/src/dtos/status.dto.ts

@@ -0,0 +1,18 @@
+import { type Static, Type } from '@sinclair/typebox';
+
+export const StatusResponseSchema = Type.Object({
+  status: Type.String(),
+  timestamp: Type.String(),
+  version: Type.String(),
+  metadata: Type.Optional(Type.Any()),
+  checks: Type.Array(
+    Type.Object({
+      name: Type.String(),
+      status: Type.String(),
+      details: Type.Optional(Type.Any()),
+      message: Type.Optional(Type.String()),
+    }),
+  ),
+});
+
+export type StatusResponseSchemaDTO = Static<typeof StatusResponseSchema>;

package/src/dummy.test.ts

@@ -0,0 +1,3 @@
+test('dummy test', () => {
+  expect(true).toBe(true);
+});

package/src/error-handler.ts

@@ -0,0 +1,149 @@
+import type { Logger } from '@commercetools/checkout-payments-processor-sdk';
+import {
+  ErrorAuthErrorResponse,
+  ErrorGeneral,
+  ErrorInvalidField,
+  ErrorInvalidJsonInput,
+  ErrorRequiredField,
+  Errorx,
+  MultiErrorx,
+} from '@commercetools/checkout-payments-processor-sdk';
+import type { FastifyError, FastifyReply, FastifyRequest } from 'fastify';
+import type { FastifySchemaValidationError } from 'fastify/types/schema.js';
+import type {
+  TAuthErrorResponse,
+  TErrorObject,
+  TErrorResponse,
+} from './dtos/error.dto.js';
+
+export const errorHandler = ({ logger }: { logger: Logger }) => {
+  function isFastifyValidationError(error: Error): error is FastifyError {
+    return (error as unknown as FastifyError).validation !== undefined;
+  }
+
+  const handleAuthError = (
+    error: ErrorAuthErrorResponse,
+    reply: FastifyReply,
+  ) => {
+    const transformedErrors: TErrorObject[] = transformErrorxToHTTPModel([
+      error,
+    ]);
+
+    const response: TAuthErrorResponse = {
+      message: error.message,
+      statusCode: error.httpErrorStatus,
+      errors: transformedErrors,
+      error: transformedErrors[0].code,
+      error_description: transformedErrors[0].message,
+    };
+
+    return reply.code(error.httpErrorStatus).send(response);
+  };
+
+  const handleErrors = (errorxList: Errorx[], reply: FastifyReply) => {
+    const transformedErrors: TErrorObject[] =
+      transformErrorxToHTTPModel(errorxList);
+
+    // Based on CoCo specs, the root level message attribute is always set to the values from the first error. MultiErrorx enforces the same HTTP status code.
+    const response: TErrorResponse = {
+      message: errorxList[0].message,
+      statusCode: errorxList[0].httpErrorStatus,
+      errors: transformedErrors,
+    };
+
+    return reply.code(errorxList[0].httpErrorStatus).send(response);
+  };
+
+  const transformErrorxToHTTPModel = (errors: Errorx[]): TErrorObject[] => {
+    const errorObjectList: TErrorObject[] = [];
+
+    for (const err of errors) {
+      if (err.skipLog) {
+        logger.debug({ err }, err.message);
+      } else {
+        logger.error({ err }, err.message);
+      }
+
+      const tErrObj: TErrorObject = {
+        code: err.code,
+        message: err.message,
+        ...(err.fields ? err.fields : {}), // Add any additional field to the response object (which will differ per type of error)
+      };
+
+      errorObjectList.push(tErrObj);
+    }
+
+    return errorObjectList;
+  };
+
+  const transformValidationErrors = (
+    errors: FastifySchemaValidationError[],
+    req: FastifyRequest,
+  ): Errorx[] => {
+    const errorxList: Errorx[] = [];
+
+    for (const err of errors) {
+      switch (err.keyword) {
+        case 'required':
+          errorxList.push(
+            new ErrorRequiredField(err.params.missingProperty as string),
+          );
+          break;
+        case 'enum':
+          errorxList.push(
+            new ErrorInvalidField(
+              getKeys(err.instancePath).join('.'),
+              getPropertyFromPath(err.instancePath, req.body),
+              err.params.allowedValues as string,
+            ),
+          );
+          break;
+      }
+    }
+
+    // If we cannot map the validation error to a CoCo error then return a general InvalidJsonError
+    if (errorxList.length === 0) {
+      errorxList.push(new ErrorInvalidJsonInput());
+    }
+
+    return errorxList;
+  };
+
+  const getKeys = (path: string) => path.replace(/^\//, '').split('/');
+
+  // biome-ignore lint/suspicious/noExplicitAny: obj is any
+  const getPropertyFromPath = (path: string, obj: any): any => {
+    const keys = getKeys(path);
+    let value = obj;
+    for (const key of keys) {
+      value = value[key];
+    }
+    return value;
+  };
+
+  return (error: Error, req: FastifyRequest, reply: FastifyReply) => {
+    if (isFastifyValidationError(error) && error.validation) {
+      return handleErrors(
+        transformValidationErrors(error.validation, req),
+        reply,
+      );
+    } else if (error instanceof ErrorAuthErrorResponse) {
+      return handleAuthError(error, reply);
+    } else if (error instanceof Errorx) {
+      return handleErrors([error], reply);
+    } else if (error instanceof MultiErrorx) {
+      return handleErrors(error.errors, reply);
+    }
+
+    // If it isn't any of the cases above (for example a normal Error is thrown) then fallback to a general 500 internal server error
+    return handleErrors(
+      [
+        new ErrorGeneral('Internal server error.', {
+          cause: error,
+          skipLog: false,
+        }),
+      ],
+      reply,
+    );
+  };
+};

package/src/global.d.ts

@@ -0,0 +1,23 @@
+import '@fastify/request-context';
+import {
+  ContextData,
+  SessionContextData,
+} from './libs/fastify/context/context';
+
+declare module '@fastify/request-context' {
+  interface RequestContextData {
+    request: ContextData;
+    session?: SessionContextData;
+  }
+}
+
+declare module 'fastify' {
+  interface FastifyInstance {
+    // biome-ignore lint/suspicious/noExplicitAny: vite is any
+    vite: any;
+  }
+
+  export interface FastifyRequest {
+    correlationId?: string;
+  }
+}

package/src/ip/ip.ts

@@ -0,0 +1,56 @@
+import type { FastifyInstance } from 'fastify';
+import fp from 'fastify-plugin';
+
+const HEADERS_ORDER = [
+  'x-client-ip', // Most common
+  'x-forwarded-for', // Mostly used by proxies
+  'cf-connecting-ip', // Cloudflare
+  'Cf-Pseudo-IPv4', // Cloudflare
+  'fastly-client-ip',
+  'true-client-ip', // Akamai and Cloudflare
+  'x-real-ip', // Nginx
+  'x-cluser-client-ip', // Rackspace LB
+  'forwarded-for',
+  'x-forwarded',
+  'forwarded',
+  'x-appengine-user-ip', // GCP App Engine
+];
+
+type HeaderKey = (typeof HEADERS_ORDER)[number];
+
+declare module 'fastify' {
+  interface FastifyRequest {
+    clientIp: string;
+  }
+}
+
+function extractIpFromHeader(
+  value: string | string[] | undefined,
+): string | null {
+  if (!value) return null;
+  if (Array.isArray(value)) value = value[0];
+  return value.split(',')[0].trim();
+}
+
+export const requestIpPlugin = fp(async (fastify: FastifyInstance) => {
+  fastify.decorateRequest('clientIp', '');
+
+  fastify.addHook('onRequest', async (request) => {
+    let ip = '';
+
+    for (const header of HEADERS_ORDER) {
+      const value = request.headers[header as HeaderKey] as string | undefined;
+      const extracted = extractIpFromHeader(value);
+      if (extracted) {
+        ip = extracted;
+        break;
+      }
+    }
+
+    if (!ip) {
+      ip = request.ip;
+    }
+
+    request.clientIp = ip;
+  });
+});

package/src/plugin.ts

@@ -0,0 +1,201 @@
+import { randomUUID } from 'node:crypto';
+import type {
+  AuthType,
+  CheckoutPaymentsProcessor,
+  PaymentComponentsHandler,
+  PaymentComponentsIncomingHttpHeaders,
+  PaymentComponentsRequest,
+  PaymentComponentsResponse,
+  PaymentIntentsHandler,
+  PaymentIntentsRequest,
+  PaymentIntentsResponse,
+  StatusHandler,
+  StatusIncomingHttpHeaders,
+  StatusRequest,
+  StatusResponse,
+  TransactionHandler,
+  TransactionIncomingHttpHeaders,
+  TransactionRequest,
+  TransactionResponse,
+} from '@commercetools/checkout-payments-processor-sdk';
+
+import fastifyRequestContext from '@fastify/request-context';
+import { Type } from '@sinclair/typebox';
+import type { FastifyPluginAsync, FastifyReply, FastifyRequest } from 'fastify';
+import { SupportedPaymentComponentsSchema } from './dtos/payment-componets.dto.js';
+import {
+  PaymentIntentRequestSchema,
+  PaymentIntentResponseSchema,
+} from './dtos/payment-intents.dto.js';
+import { StatusResponseSchema } from './dtos/status.dto.js';
+import { errorHandler } from './error-handler.js';
+
+interface CheckoutPaymentsProcessorFastifyPluginOptions {
+  processorSDK: CheckoutPaymentsProcessor;
+  paymentComponentsHandler: PaymentComponentsHandler;
+  paymentIntentsHandler: PaymentIntentsHandler;
+  statusHandler: StatusHandler;
+  transactionHandler: TransactionHandler;
+}
+
+type HookFn<Request, Response> = (
+  request: FastifyRequest<{ Body: Request; Reply: Response }>,
+  reply: FastifyReply,
+) => Promise<void>;
+
+export const CheckoutPaymentsProcessorFastifyPluginOptions: FastifyPluginAsync<
+  CheckoutPaymentsProcessorFastifyPluginOptions
+> = async (fastify, options) => {
+  const {
+    processorSDK,
+    statusHandler,
+    paymentComponentsHandler,
+    paymentIntentsHandler,
+    transactionHandler,
+  } = options;
+
+  fastify.setErrorHandler(errorHandler({ logger: processorSDK.getLogger() }));
+
+  fastify.decorateRequest('correlationId', '');
+
+  // Propagate the correlationId from the request header to the request object
+  fastify.addHook('onRequest', (req, _reply, done) => {
+    req.correlationId = req.headers['x-correlation-id']
+      ? (req.headers['x-correlation-id'] as string)
+      : undefined;
+    done();
+  });
+
+  // Register the request context
+  await fastify.register(fastifyRequestContext, {
+    defaultStoreValues: (req: FastifyRequest) => ({
+      request: {
+        path: req.url,
+        pathTemplate: req.routeOptions.url,
+        pathParams: req.params,
+        query: req.query,
+        correlationId: req.correlationId || randomUUID().toString(),
+        requestId: req.id,
+      },
+    }),
+    hook: 'onRequest',
+  });
+
+  const preHandlersMapper = <Request, Response>(
+    auths: AuthType[],
+  ): HookFn<Request, Response>[] => {
+    const result: HookFn<Request, Response>[] = [];
+    for (const auth of auths) {
+      if (auth.type === 'jwt') {
+        result.push(processorSDK.getJwtAuthHookFn().authenticate());
+      } else if (auth.type === 'oauth2') {
+        result.push(processorSDK.getOauth2AuthHookFn().authenticate());
+        result.push(
+          processorSDK
+            .getAuthorityAuthorizationHookFn()
+            .authorize(...auth.allowedScopes),
+        );
+      } else if (auth.type === 'session') {
+        result.push(processorSDK.getSessionHeaderAuthHookFn().authenticate());
+      }
+    }
+    return result;
+  };
+
+  fastify.route<{ Body: StatusRequest; Reply: StatusResponse }>({
+    method: statusHandler.method(),
+    url: statusHandler.endpoint(),
+    preHandler: preHandlersMapper<StatusRequest, StatusResponse>(
+      statusHandler.auth(),
+    ),
+    schema: {
+      response: {
+        200: StatusResponseSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const response = await statusHandler.handler({
+        request: request.body as StatusRequest,
+        headers: request.headers as StatusIncomingHttpHeaders,
+      });
+      reply.code(200).send(response.body);
+    },
+  });
+
+  fastify.route<{
+    Body: PaymentIntentsRequest;
+    Reply: PaymentIntentsResponse;
+    Params: { id: string };
+  }>({
+    method: paymentIntentsHandler.method(),
+    url: paymentIntentsHandler.endpoint(),
+    preHandler: preHandlersMapper<
+      PaymentIntentsRequest,
+      PaymentIntentsResponse
+    >(paymentIntentsHandler.auth()),
+    schema: {
+      params: {
+        $id: 'paramsSchema',
+        type: 'object',
+        properties: {
+          id: Type.String(),
+        },
+        required: ['id'],
+      },
+      body: PaymentIntentRequestSchema,
+      response: {
+        200: PaymentIntentResponseSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const { id } = request.params;
+      const body = request.body as PaymentIntentsRequest;
+      const response = await paymentIntentsHandler.handler({
+        request: {
+          id,
+          actions: body.actions,
+        },
+      });
+      reply.code(200).send(response.body);
+    },
+  });
+
+  fastify.route<{
+    Body: PaymentComponentsRequest;
+    Reply: PaymentComponentsResponse;
+  }>({
+    method: paymentComponentsHandler.method(),
+    url: paymentComponentsHandler.endpoint(),
+    preHandler: preHandlersMapper<
+      PaymentComponentsRequest,
+      PaymentComponentsResponse
+    >(paymentComponentsHandler.auth()),
+    schema: {
+      response: {
+        200: SupportedPaymentComponentsSchema,
+      },
+    },
+    handler: async (request, reply) => {
+      const response = await paymentComponentsHandler.handler({
+        request: request.body as PaymentComponentsRequest,
+        headers: request.headers as PaymentComponentsIncomingHttpHeaders,
+      });
+      reply.code(200).send(response.body);
+    },
+  });
+
+  fastify.route<{ Body: TransactionRequest; Reply: TransactionResponse }>({
+    method: transactionHandler.method(),
+    url: transactionHandler.endpoint(),
+    preHandler: preHandlersMapper<TransactionRequest, TransactionResponse>(
+      transactionHandler.auth(),
+    ),
+    handler: async (request, reply) => {
+      const response = await transactionHandler.handler({
+        request: request.body as TransactionRequest,
+        headers: request.headers as TransactionIncomingHttpHeaders,
+      });
+      reply.code(response.status).send(response.body);
+    },
+  });
+};

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "extends": "@tsconfig/node24/tsconfig.json",
+  "compilerOptions": {
+    "types": ["vitest/globals"],
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "paths": {
+      "@/*": ["./src/*"],
+    }
+  },
+  "exclude": ["src/**/*.[test|spec|mock].ts"],
+  "include": ["src/**/*.ts"]
+}

package/tsconfig.prod.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": false
+  },
+  "exclude": ["./src/**/*.test.ts", "./src/**/*.spec.ts"],
+  "include": ["./src/**/*.ts"]
+}

package/typedoc.json

@@ -0,0 +1,6 @@
+{
+    "entryPoints": ["src/index.ts"],
+    "out": "../../generated-doc/checkout-payments-processor-sdk",
+    "tsconfig": "tsconfig.json",
+    "projectDocuments": ["wiki/*.md", "CHANGELOG.md"]
+  }

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import tsconfigPaths from "vite-tsconfig-paths";
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  plugins: [tsconfigPaths()],
+  test: {
+    globals: true,
+    coverage: {
+      provider: "istanbul", // or 'v8'
+      reporter: ["text", "json-summary"],
+      exclude: ["./generated-doc/**/*", "./dist/**/*", "./src/**/*.test.ts", "./src/**/*.spec.ts"],
+    },
+    include: ["./src/**/*.test.ts", "./src/**/*.spec.ts"],
+  },
+});

package/wiki/getting-started.md

@@ -0,0 +1,13 @@
+---
+title: Getting started
+group: Documents
+category: Guides
+---
+
+# Payment enabler
+
+```bash
+npm install @commercerools/checkout-payments-enabler-sdk
+```
+
+