@unchainedshop/plugins 4.0.0-rc.5 → 4.0.0-rc.6

package/src/payment/paypal-checkout.ts

@@ -17,7 +17,7 @@ try {
   /* */
 }
 
-const logger = createLogger('unchained:core-payment');
+const logger = createLogger('unchained:core-payment:paypal-checkout');
 
 const { PAYPAL_CLIENT_ID, PAYPAL_SECRET, PAYPAL_ENVIRONMENT = 'sandbox' } = process.env;
 
@@ -79,7 +79,6 @@ const PaypalCheckout: IPaymentAdapter = {
         const { order } = context;
 
         if (!orderID) {
-          logger.warn('Paypal Native Plugin: PRICE MATCH');
           throw new Error('You have to provide orderID in paymentContext');
         }
 
@@ -96,21 +95,17 @@ const PaypalCheckout: IPaymentAdapter = {
           const paypalTotal = paypalOrder.result.purchase_units[0].amount.value;
 
           if (ourTotal === paypalTotal) {
-            logger.info('Paypal Native Plugin: PRICE MATCH');
             return order;
           }
 
-          logger.warn(
-            'Paypal Native Plugin: Missmatch PAYPAL ORDER',
-            JSON.stringify(paypalOrder.result, null, 2),
-          );
+          logger.warn('Missmatch PAYPAL ORDER', JSON.stringify(paypalOrder.result, null, 2));
 
-          logger.debug('Paypal Native Plugin: OUR ORDER', order);
-          logger.debug('Paypal Native Plugin: OUR PRICE', pricing);
+          logger.debug('OUR ORDER', order);
+          logger.debug('OUR PRICE', pricing);
 
           throw new Error(`Payment mismatch`);
         } catch (e) {
-          logger.warn('Paypal Native Plugin: Failed', e);
+          logger.warn(e);
           throw new Error(e);
         }
       },

package/src/payment/postfinance-checkout/api-client.ts

@@ -0,0 +1,106 @@
+import crypto from 'crypto';
+
+const API_BASE_URL = 'https://checkout.postfinance.ch/api';
+
+interface ApiConfig {
+  spaceId: number;
+  userId: number;
+  apiSecret: string;
+}
+
+interface MacHeaders {
+  'x-mac-version': string;
+  'x-mac-userid': string;
+  'x-mac-timestamp': string;
+  'x-mac-value': string;
+}
+
+export class PostFinanceApiClient {
+  private config: ApiConfig;
+
+  constructor(config: ApiConfig) {
+    this.config = config;
+  }
+
+  private generateMacHeaders(method: string, path: string): MacHeaders {
+    const version = '1';
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const userId = this.config.userId.toString();
+
+    // Use path as-is since it already includes /api from the URL
+    const resourcePath = path;
+
+    const dataToSign = [version, userId, timestamp, method, resourcePath].join('|');
+
+    const macValue = crypto
+      .createHmac('sha512', Buffer.from(this.config.apiSecret, 'base64'))
+      .update(dataToSign, 'utf8')
+      .digest('base64');
+
+    return {
+      'x-mac-version': version,
+      'x-mac-userid': userId,
+      'x-mac-timestamp': timestamp,
+      'x-mac-value': macValue,
+    };
+  }
+
+  async request<T>(method: string, endpoint: string, body?: any): Promise<T> {
+    const url = `${API_BASE_URL}${endpoint}`;
+    const urlObj = new URL(url);
+    // Include both pathname and search (query parameters) for MAC signature
+    const pathWithQuery = urlObj.pathname + urlObj.search;
+    const macHeaders = this.generateMacHeaders(method, pathWithQuery);
+
+    const headers: Record<string, string> = {
+      ...macHeaders,
+      'Content-Type': 'application/json',
+      Accept: 'application/json',
+    };
+
+    const options: RequestInit = {
+      method,
+      headers,
+    };
+
+    if (body && method !== 'GET') {
+      options.body = JSON.stringify(body);
+    }
+
+    const response = await fetch(url, options);
+
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      throw new Error(
+        `PostFinance API error: ${response.status} ${response.statusText} ${JSON.stringify(errorData)}`,
+      );
+    }
+
+    const responseText = await response.text();
+    const contentType = response.headers.get('content-type');
+
+    if (contentType && contentType.includes('application/json')) {
+      try {
+        return JSON.parse(responseText);
+      } catch {
+        // If JSON parsing fails but content-type is json, return as text
+        // This handles PostFinance's payment-page-url endpoint that returns plain text with json content-type
+        return responseText as any;
+      }
+    } else {
+      return responseText as any;
+    }
+  }
+
+  get<T>(endpoint: string): Promise<T> {
+    return this.request<T>('GET', endpoint);
+  }
+
+  post<T>(endpoint: string, body: any): Promise<T> {
+    return this.request<T>('POST', endpoint, body);
+  }
+
+  patch<T>(endpoint: string, body: any): Promise<T> {
+    return this.request<T>('PATCH', endpoint, body);
+  }
+}

package/src/payment/postfinance-checkout/api-types.ts

@@ -0,0 +1,111 @@
+// PostFinance Checkout API Types
+
+export enum TransactionState {
+  CREATE = 'CREATE',
+  PENDING = 'PENDING',
+  CONFIRMED = 'CONFIRMED',
+  PROCESSING = 'PROCESSING',
+  FAILED = 'FAILED',
+  AUTHORIZED = 'AUTHORIZED',
+  VOIDED = 'VOIDED',
+  COMPLETED = 'COMPLETED',
+  FULFILL = 'FULFILL',
+  DECLINE = 'DECLINE',
+}
+
+export enum TokenizationMode {
+  FORCE_UPDATE = 'FORCE_UPDATE',
+  ALLOW = 'ALLOW',
+  ALLOW_ONE_CLICK_PAYMENT = 'ALLOW_ONE_CLICK_PAYMENT',
+  DENY = 'DENY',
+}
+
+export enum TransactionCompletionBehavior {
+  COMPLETE_IMMEDIATELY = 'COMPLETE_IMMEDIATELY',
+  COMPLETE_DEFERRED = 'COMPLETE_DEFERRED',
+  USE_CONFIGURATION = 'USE_CONFIGURATION',
+}
+
+export enum LineItemType {
+  SHIPPING = 'SHIPPING',
+  DISCOUNT = 'DISCOUNT',
+  FEE = 'FEE',
+  PRODUCT = 'PRODUCT',
+  TIP = 'TIP',
+}
+
+export enum RefundType {
+  MERCHANT_INITIATED_ONLINE = 'MERCHANT_INITIATED_ONLINE',
+  MERCHANT_INITIATED_OFFLINE = 'MERCHANT_INITIATED_OFFLINE',
+  CUSTOMER_INITIATED_AUTOMATIC = 'CUSTOMER_INITIATED_AUTOMATIC',
+  CUSTOMER_INITIATED_MANUAL = 'CUSTOMER_INITIATED_MANUAL',
+}
+
+export enum CreationEntityState {
+  CREATE = 'CREATE',
+  ACTIVE = 'ACTIVE',
+  INACTIVE = 'INACTIVE',
+  DELETING = 'DELETING',
+  DELETED = 'DELETED',
+}
+
+export interface LineItem {
+  name: string;
+  type: LineItemType;
+  quantity: number;
+  uniqueId: string;
+  amountIncludingTax: number;
+}
+
+export interface TransactionCreate {
+  currency: string;
+  customerId?: string;
+  tokenizationMode?: TokenizationMode;
+  completionBehavior?: TransactionCompletionBehavior;
+  lineItems?: LineItem[];
+  successUrl?: string;
+  failedUrl?: string;
+  metaData?: Record<string, any>;
+}
+
+export interface Transaction {
+  id: number;
+  state: TransactionState;
+  currency: string;
+  completedAmount?: number;
+  authorizationAmount?: number;
+  metaData?: Record<string, any>;
+  token?: {
+    id: number;
+    [key: string]: any;
+  };
+}
+
+export interface TransactionCompletion {
+  id: number;
+  state: string;
+  transaction: number;
+  linkedTransaction?: number;
+}
+
+export interface Token {
+  id: number;
+  state: CreationEntityState;
+  name?: string;
+  customerId?: string;
+  enabledForOneClickPayment?: boolean;
+}
+
+export interface RefundCreate {
+  transaction: number;
+  externalId: string;
+  amount: number;
+  type: RefundType;
+}
+
+export interface Refund {
+  id: number;
+  state: string;
+  amount: number;
+  transaction: number;
+}

package/src/payment/postfinance-checkout/api.ts

@@ -1,91 +1,55 @@
-import * as pf from 'postfinancecheckout';
+import { PostFinanceApiClient } from './api-client.js';
+import {
+  Transaction,
+  TransactionCreate,
+  TransactionCompletion,
+  Token,
+  RefundCreate,
+  RefundType,
+} from './api-types.js';
 
-const { PostFinanceCheckout } = pf;
 const { PFCHECKOUT_SPACE_ID, PFCHECKOUT_USER_ID, PFCHECKOUT_SECRET } = process.env;
 const SPACE_ID = parseInt(PFCHECKOUT_SPACE_ID as string, 10);
 const USER_ID = parseInt(PFCHECKOUT_USER_ID as string, 10);
 
-const getConfig = () => {
-  return {
-    space_id: SPACE_ID,
-    user_id: USER_ID,
-    api_secret: PFCHECKOUT_SECRET,
-  };
-};
-
-const getTransactionService = () => {
-  return new PostFinanceCheckout.api.TransactionService(getConfig());
-};
-
-const getTransactionCompletionService = () => {
-  return new PostFinanceCheckout.api.TransactionCompletionService(getConfig());
-};
-
-const getTransactionVoidService = () => {
-  return new PostFinanceCheckout.api.TransactionVoidService(getConfig());
-};
-
-const getRefundService = () => {
-  return new PostFinanceCheckout.api.RefundService(getConfig());
-};
-
-const getTransactionPaymentPageService = () => {
-  return new PostFinanceCheckout.api.TransactionPaymentPageService(getConfig());
-};
-
-const getTransactionIframeService = () => {
-  return new PostFinanceCheckout.api.TransactionIframeService(getConfig());
-};
+let apiClient: PostFinanceApiClient;
 
-const getTransactionLightboxService = () => {
-  return new PostFinanceCheckout.api.TransactionLightboxService(getConfig());
+const getApiClient = () => {
+  if (!apiClient) {
+    apiClient = new PostFinanceApiClient({
+      spaceId: SPACE_ID,
+      userId: USER_ID,
+      apiSecret: PFCHECKOUT_SECRET as string,
+    });
+  }
+  return apiClient;
 };
 
-const getTokenService = () => {
-  return new PostFinanceCheckout.api.TokenService(getConfig());
+export const getTransaction = async (transactionId: string): Promise<Transaction> => {
+  const client = getApiClient();
+  return client.get<Transaction>(`/transaction/read?spaceId=${SPACE_ID}&id=${transactionId}`);
 };
 
-export const getTransaction = async (
-  transactionId: string,
-): Promise<pf.PostFinanceCheckout.model.Transaction> => {
-  const transactionService = getTransactionService();
-  const transaction = await transactionService.read(SPACE_ID, parseInt(transactionId, 10));
-  return transaction.body;
+export const getTransactionCompletion = async (id: string): Promise<TransactionCompletion> => {
+  const client = getApiClient();
+  return client.get<TransactionCompletion>(`/transaction-completion/read?spaceId=${SPACE_ID}&id=${id}`);
 };
 
-export const getTransactionCompletion = async (
-  entityId: string,
-): Promise<pf.PostFinanceCheckout.model.TransactionCompletion> => {
-  const transactionCompletionService = getTransactionCompletionService();
-  const transactionCompletion = await transactionCompletionService.read(
-    SPACE_ID,
-    parseInt(entityId, 10),
-  );
-  return transactionCompletion.body;
+export const getToken = async (spaceId: number, tokenId: number): Promise<Token> => {
+  const client = getApiClient();
+  return client.get<Token>(`/token/read?spaceId=${spaceId || SPACE_ID}&id=${tokenId}`);
 };
 
-export const getToken = async (
-  spaceId: number,
-  tokenId: number,
-): Promise<pf.PostFinanceCheckout.model.Token> => {
-  const tokenService = getTokenService();
-  const token = await tokenService.read(spaceId || SPACE_ID, tokenId);
-  return token.body;
-};
-
-export const createTransaction = async (
-  transaction: pf.PostFinanceCheckout.model.TransactionCreate,
-): Promise<number | null> => {
-  const transactionService = getTransactionService();
-  const transactionCreateRes = await transactionService.create(SPACE_ID, transaction);
-  const transactionCreate = transactionCreateRes.body;
-  return transactionCreate.id || null;
+export const createTransaction = async (transaction: TransactionCreate): Promise<number | null> => {
+  const client = getApiClient();
+  const result = await client.post<Transaction>(`/transaction/create?spaceId=${SPACE_ID}`, transaction);
+  return result.id || null;
 };
 
 export const voidTransaction = async (transactionId: string): Promise<boolean> => {
-  const transactionVoidService = getTransactionVoidService();
+  const client = getApiClient();
   try {
-    await transactionVoidService.voidOnline(SPACE_ID, parseInt(transactionId, 10));
+    await client.post(`/transaction-void/voidOnline?spaceId=${SPACE_ID}&id=${transactionId}`, {});
     return true;
   } catch {
     return false;
@@ -97,15 +61,15 @@ export const refundTransaction = async (
   orderId: string,
   amount: number,
 ): Promise<boolean> => {
-  const refundService = getRefundService();
-  const refund: pf.PostFinanceCheckout.model.RefundCreate = {
+  const client = getApiClient();
+  const refund: RefundCreate = {
     transaction: parseInt(transactionId, 10),
     externalId: orderId,
     amount,
-    type: PostFinanceCheckout.model.RefundType.MERCHANT_INITIATED_ONLINE,
+    type: RefundType.MERCHANT_INITIATED_ONLINE,
   };
   try {
-    await refundService.refund(SPACE_ID, refund);
+    await client.post(`/refund/refund?spaceId=${SPACE_ID}`, refund);
     return true;
   } catch {
     return false;
@@ -113,9 +77,12 @@ export const refundTransaction = async (
 };
 
 export const confirmDeferredTransaction = async (transactionId: string): Promise<boolean> => {
-  const transactionCompletionService = getTransactionCompletionService();
+  const client = getApiClient();
   try {
-    await transactionCompletionService.completeOnline(SPACE_ID, parseInt(transactionId, 10));
+    await client.post(
+      `/transaction-completion/completeOnline?spaceId=${SPACE_ID}&transactionId=${transactionId}`,
+      {},
+    );
     return true;
   } catch {
     return false;
@@ -123,19 +90,25 @@ export const confirmDeferredTransaction = async (transactionId: string): Promise
 };
 
 export const getPaymentPageUrl = async (transactionId: number): Promise<string> => {
-  const transactionPaymentPageService = getTransactionPaymentPageService();
-  const paymentPageUrl = await transactionPaymentPageService.paymentPageUrl(SPACE_ID, transactionId);
-  return paymentPageUrl.body;
+  const client = getApiClient();
+  const result = await client.get<string>(
+    `/transaction-payment-page/payment-page-url?spaceId=${SPACE_ID}&id=${transactionId}`,
+  );
+  return result;
 };
 
 export const getLightboxJavascriptUrl = async (transactionId: number): Promise<string> => {
-  const transactionLightboxService = getTransactionLightboxService();
-  const javascriptUrl = await transactionLightboxService.javascriptUrl(SPACE_ID, transactionId);
-  return javascriptUrl.body;
+  const client = getApiClient();
+  const result = await client.get<string>(
+    `/transaction-lightbox/javascript-url?spaceId=${SPACE_ID}&id=${transactionId}`,
+  );
+  return result;
 };
 
 export const getIframeJavascriptUrl = async (transactionId: number): Promise<string> => {
-  const transactionIframeService = getTransactionIframeService();
-  const javascriptUrl = await transactionIframeService.javascriptUrl(SPACE_ID, transactionId);
-  return javascriptUrl.body;
+  const client = getApiClient();
+  const result = await client.get<string>(
+    `/transaction-iframe/javascript-url?spaceId=${SPACE_ID}&id=${transactionId}`,
+  );
+  return result;
 };

package/src/payment/postfinance-checkout/handler-express.ts

@@ -3,7 +3,7 @@ import { createLogger } from '@unchainedshop/logger';
 import { WebhookData } from './types.js';
 import { getTransaction, getTransactionCompletion } from './api.js';
 
-const logger = createLogger('unchained:core-payment:postfinance-checkout');
+const logger = createLogger('unchained:core-payment:postfinance-checkout:handler');
 
 export const postfinanceCheckoutHandler = async (req, res) => {
   const context = req.unchainedContext as Context;
@@ -13,7 +13,7 @@ export const postfinanceCheckoutHandler = async (req, res) => {
     try {
       const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
       const transaction = await getTransaction(
-        transactionCompletion.linkedTransaction as unknown as string,
+        transactionCompletion ? (transactionCompletion as any).linkedTransaction : data.entityId,
       );
       const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
       const orderPayment = await modules.orders.payments.findOrderPayment({
@@ -27,19 +27,17 @@ export const postfinanceCheckoutHandler = async (req, res) => {
         },
       });
       logger.info(
-        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+        `Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
       );
       res.writeHead(200);
       res.end(`Order marked as paid: ${order.orderNumber}`);
     } catch (e) {
-      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+      logger.error(e);
       res.writeHead(500);
       res.end(JSON.stringify({ name: e.name, code: e.code, message: e.message }));
     }
   } else {
-    logger.error(
-      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
-    );
+    logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
     res.writeHead(404);
     res.end();
   }

package/src/payment/postfinance-checkout/handler-fastify.ts

@@ -4,7 +4,7 @@ import { WebhookData } from './types.js';
 import { getTransaction, getTransactionCompletion } from './api.js';
 import { FastifyRequest, RouteHandlerMethod } from 'fastify';
 
-const logger = createLogger('unchained:core-payment:postfinance-checkout');
+const logger = createLogger('unchained:core-payment:postfinance-checkout:handler');
 
 export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
   req: FastifyRequest & {
@@ -19,7 +19,7 @@ export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
     try {
       const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
       const transaction = await getTransaction(
-        transactionCompletion.linkedTransaction as unknown as string,
+        transactionCompletion ? (transactionCompletion as any).linkedTransaction : data.entityId,
       );
       const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
       const orderPayment = await modules.orders.payments.findOrderPayment({
@@ -29,23 +29,21 @@ export const postfinanceCheckoutHandler: RouteHandlerMethod = async (
 
       const order = await services.orders.checkoutOrder(orderPayment.orderId, {
         paymentContext: {
-          transactionId: transactionCompletion.linkedTransaction,
+          transactionId: transaction.id,
         },
       });
       logger.info(
-        `PostFinance Checkout Webhook: Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
+        `Transaction ${transaction.id} marked order payment ID ${transaction.metaData.orderPaymentId} as paid`,
       );
       reply.status(200);
       return reply.send(`Order marked as paid: ${order.orderNumber}`);
     } catch (e) {
-      logger.error(`PostFinance Checkout Webhook: Unchained rejected to checkout with message`, e);
+      logger.error(e);
       reply.status(500);
       return reply.send({ name: e.name, code: e.code, message: e.message });
     }
   } else {
-    logger.error(
-      `PostFinance Checkout Webhook: Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`,
-    );
+    logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
     reply.status(404);
     return reply.send();
   }

package/src/payment/postfinance-checkout/index.ts

@@ -8,7 +8,6 @@ import {
   PaymentDirector,
   PaymentError,
 } from '@unchainedshop/core';
-import * as pf from 'postfinancecheckout';
 
 import {
   confirmDeferredTransaction,
@@ -23,8 +22,15 @@ import {
 } from './api.js';
 import { orderIsPaid } from './utils.js';
 import { CompletionModes, IntegrationModes, SignResponse } from './types.js';
-
-const { PostFinanceCheckout } = pf;
+import {
+  TransactionCreate,
+  LineItem,
+  LineItemType,
+  TokenizationMode,
+  TransactionCompletionBehavior,
+  TransactionState,
+  CreationEntityState,
+} from './api-types.js';
 
 const {
   PFCHECKOUT_SPACE_ID,
@@ -34,7 +40,7 @@ const {
   PFCHECKOUT_FAILED_URL,
 } = process.env;
 
-const logger = createLogger('unchained:core-payment:postfinance');
+const logger = createLogger('unchained:core-payment:postfinance-checkout');
 
 const newError = ({ code, message }: { code: string; message: string }) => {
   const error = new Error(message);
@@ -92,7 +98,7 @@ const PostfinanceCheckout: IPaymentAdapter = {
         if (!credentials.meta) return false;
         const { linkedSpaceId } = credentials.meta;
         const tokenData = await getToken(linkedSpaceId, credentials.token);
-        return tokenData.state === PostFinanceCheckout.model.CreationEntityState.ACTIVE;
+        return tokenData.state === CreationEntityState.ACTIVE;
       },
 
       sign: async (transactionContext: any = {}) => {
@@ -107,37 +113,38 @@ const PostfinanceCheckout: IPaymentAdapter = {
         });
 
         const totalAmount = pricing?.total({ useNetPrice: false }).amount;
-        const transaction = new PostFinanceCheckout.model.TransactionCreate();
-        const userId = order?.userId || context?.userId;
-        transaction.currency = order.currencyCode;
-        transaction.metaData = {
-          orderPaymentId: orderPayment._id,
+        const transaction: TransactionCreate = {
+          currency: order.currencyCode,
+          metaData: {
+            orderPaymentId: orderPayment._id,
+          },
+          successUrl: `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${
+            orderPayment.orderId
+          }`,
+          failedUrl: `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${
+            orderPayment.orderId
+          }`,
+          customerId: order?.userId || context?.userId,
+          tokenizationMode: TokenizationMode.ALLOW_ONE_CLICK_PAYMENT,
         };
-        transaction.successUrl = `${transactionContext?.successUrl || PFCHECKOUT_SUCCESS_URL}?order_id=${
-          orderPayment.orderId
-        }`;
-        transaction.failedUrl = `${transactionContext?.failedUrl || PFCHECKOUT_FAILED_URL}?order_id=${
-          orderPayment.orderId
-        }`;
-        transaction.customerId = userId;
-        transaction.tokenizationMode =
-          PostFinanceCheckout.model.TokenizationMode.ALLOW_ONE_CLICK_PAYMENT;
+
         if (completionMode === CompletionModes.Immediate) {
-          transaction.completionBehavior =
-            PostFinanceCheckout.model.TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
+          transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_IMMEDIATELY;
         } else if (completionMode === CompletionModes.Deferred) {
-          transaction.completionBehavior =
-            PostFinanceCheckout.model.TransactionCompletionBehavior.COMPLETE_DEFERRED;
+          transaction.completionBehavior = TransactionCompletionBehavior.COMPLETE_DEFERRED;
         }
+
         if (totalAmount) {
-          const lineItemSum = new PostFinanceCheckout.model.LineItemCreate();
-          lineItemSum.name = `Bestellung ${orderPayment.orderId}`;
-          lineItemSum.type = PostFinanceCheckout.model.LineItemType.FEE;
-          lineItemSum.quantity = 1;
-          lineItemSum.uniqueId = orderPayment.orderId;
-          lineItemSum.amountIncludingTax = totalAmount / 100;
+          const lineItemSum: LineItem = {
+            name: `Bestellung ${orderPayment.orderId}`,
+            type: LineItemType.FEE,
+            quantity: 1,
+            uniqueId: orderPayment.orderId,
+            amountIncludingTax: totalAmount / 100,
+          };
           transaction.lineItems = [lineItemSum];
         }
+
         const transactionId = await createTransaction(transaction);
         let location = null;
         if (integrationMode === IntegrationModes.PaymentPage) {
@@ -214,7 +221,7 @@ const PostfinanceCheckout: IPaymentAdapter = {
           return false;
         }
         const transaction = await getTransaction(transactionId);
-        const refund = transaction.state === PostFinanceCheckout.model.TransactionState.FULFILL;
+        const refund = transaction.state === TransactionState.FULFILL;
         const pricing = OrderPricingSheet({
           calculation: order.calculation,
           currencyCode: order.currencyCode,
@@ -235,7 +242,7 @@ const PostfinanceCheckout: IPaymentAdapter = {
           return false;
         }
         const transaction = await getTransaction(transactionId);
-        if (transaction.state === PostFinanceCheckout.model.TransactionState.AUTHORIZED) {
+        if (transaction.state === TransactionState.AUTHORIZED) {
           return confirmDeferredTransaction(transactionId);
         }
         return false;
@@ -247,3 +254,6 @@ const PostfinanceCheckout: IPaymentAdapter = {
 };
 
 PaymentDirector.registerAdapter(PostfinanceCheckout);
+
+export * from './types.js';
+export * from './api-types.js';