@unchainedshop/plugins 4.3.4 → 4.4.0

package/src/payment/payrexx/index.ts

@@ -1,248 +0,0 @@
-import { createLogger } from '@unchainedshop/logger';
-import { mapOrderDataToGatewayObject, mapUserToGatewayObject } from './payrexx.js';
-import createPayrexxAPI, { GatewayObjectStatus } from './api/index.js';
-import {
-  OrderPricingSheet,
-  IPaymentAdapter,
-  PaymentAdapter,
-  PaymentDirector,
-  PaymentError,
-} from '@unchainedshop/core';
-
-const logger = createLogger('unchained:payrexx');
-
-const Payrexx: IPaymentAdapter = {
-  ...PaymentAdapter,
-
-  key: 'shop.unchained.payment.payrexx',
-  label: 'Payrexx',
-  version: '1.0.0',
-
-  typeSupported(type) {
-    return type === 'GENERIC';
-  },
-
-  actions: (config, context) => {
-    const { modules } = context;
-
-    const instance = config.find((c) => c.key === 'instance')?.value;
-
-    const adapterActions = {
-      ...PaymentAdapter.actions(config, context),
-
-      configurationError() {
-        if (!process.env.PAYREXX_SECRET) {
-          return PaymentError.INCOMPLETE_CONFIGURATION;
-        }
-        if (!instance) {
-          return PaymentError.INCOMPLETE_CONFIGURATION;
-        }
-        return null;
-      },
-
-      isActive: () => {
-        if (adapterActions.configurationError() === null) return true;
-        return false;
-      },
-
-      isPayLaterAllowed() {
-        return false;
-      },
-
-      sign: async (transactionContext = {}) => {
-        const { orderPayment, userId, order } = context;
-
-        if (!order) throw new Error('No order in context, can only sign with order context');
-
-        const api = createPayrexxAPI(instance!, process.env.PAYREXX_SECRET!);
-
-        if (orderPayment) {
-          // Order Checkout signing (One-time payment)
-          const pricing = OrderPricingSheet({
-            calculation: order.calculation,
-            currencyCode: order.currencyCode,
-          });
-          const gatewayObject = mapOrderDataToGatewayObject(
-            { order, orderPayment, pricing },
-            transactionContext,
-          );
-          const gateway = await api.createGateway(gatewayObject);
-          return JSON.stringify(gateway);
-        }
-
-        // Payment Credential Registration signing
-
-        const user = userId && (await modules.users.findUserById(userId));
-        if (!user) throw new Error('User not found, can only sign registrations with user context');
-
-        const emailAddress = modules.users.primaryEmail(user)?.address;
-        const gateway = await api.createGateway(
-          mapUserToGatewayObject({
-            userId,
-            emailAddress,
-            currencyCode: order?.currencyCode,
-          }),
-        );
-        return JSON.stringify(gateway);
-      },
-
-      // async validate(credentials) {
-      //   if (!credentials.meta) return false;
-      //   const { objectKey, currency } = credentials.meta;
-      //   const result = await api().validate({
-      //     refno: Buffer.from(`valid-${new Date().getTime()}`, 'hex').toString('base64'),
-      //     currency,
-      //     [objectKey]: JSON.parse(credentials.token),
-      //   });
-      //   return Boolean((result as ValidateResponseSuccess)?.transactionId);
-      // },
-
-      async register(/* transactionResponse */) {
-        // const { transactionId } = transactionResponse;
-        throw new Error('Not implemented');
-        // const result = (await api().status({
-        //   transactionId,
-        // })) as StatusResponseSuccess;
-        // if (result.transactionId) {
-        //   return await parseRegistrationData(result);
-        // }
-        return null;
-      },
-
-      async confirm() {
-        const { orderPayment } = context;
-
-        if (!orderPayment?.transactionId) {
-          return false;
-        }
-        const { transactionId } = orderPayment;
-
-        const api = createPayrexxAPI(instance!, process.env.PAYREXX_SECRET!);
-
-        const gatewayObject = await api.getGateway(transactionId);
-
-        if (!gatewayObject) {
-          return false;
-        }
-
-        if (
-          // gatewayObject.status === GatewayObjectStatus.authorized || // authorized is only used for tokenization!
-          gatewayObject.status === GatewayObjectStatus.reserved
-        ) {
-          const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
-          await Promise.all(
-            allTransactions.map(async (transaction) =>
-              api.chargePreAuthorized(transaction.id, { referenceId: '__IGNORE_WEBHOOK__' }),
-            ),
-          );
-          return true;
-        }
-
-        if (gatewayObject.status === GatewayObjectStatus.confirmed) {
-          return true; // already confirmed, no need to confirm
-        }
-        return false; // some other status with refund or anything, can't confirm!
-      },
-
-      async cancel() {
-        const { orderPayment } = context;
-        if (!orderPayment?.transactionId) {
-          return false;
-        }
-        const { transactionId } = orderPayment;
-
-        const api = createPayrexxAPI(instance!, process.env.PAYREXX_SECRET!);
-
-        const gatewayObject = await api.getGateway(transactionId);
-
-        if (!gatewayObject) {
-          return false;
-        }
-
-        if (gatewayObject.status === GatewayObjectStatus.reserved) {
-          const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
-          await Promise.all(
-            allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)),
-          );
-          return true;
-        }
-
-        if (gatewayObject.status === GatewayObjectStatus.confirmed) {
-          return false; // already confirmed, can't cancel anymore
-        }
-        return true; // some other status with refund or anything, no need to cancel
-      },
-
-      charge: async ({ gatewayId, paymentCredentials }) => {
-        if (!gatewayId && !paymentCredentials) {
-          throw new Error('You have to provide gatewayId or paymentCredentials');
-        }
-
-        const { order, orderPayment } = context;
-
-        if (!order) throw new Error('No order in context, can only charge with order context');
-        if (!orderPayment) throw new Error('Order payment not found');
-
-        const api = createPayrexxAPI(instance!, process.env.PAYREXX_SECRET!);
-
-        const gatewayObject = await api.getGateway(gatewayId);
-
-        if (!gatewayObject) {
-          throw new Error('Could not load gateway from the Payrexx API');
-        }
-
-        const pricing = OrderPricingSheet({
-          calculation: order.calculation,
-          currencyCode: order.currencyCode,
-        });
-        const { currencyCode, amount } = pricing.total({ useNetPrice: false });
-
-        if (
-          // gatewayObject.status === 'authorized' || // authorized is only used for tokenization!
-          gatewayObject.status === 'reserved' ||
-          gatewayObject.status === 'confirmed'
-        ) {
-          try {
-            if (
-              gatewayObject.currency !== currencyCode.toUpperCase() ||
-              gatewayObject.amount !== Math.round(amount)
-            ) {
-              throw new Error('The price has changed since the intent has been created');
-            }
-            if (gatewayObject.referenceId !== orderPayment?._id) {
-              throw new Error('The order payment is different from the initiating intent');
-            }
-
-            // confirm will do the transition, to do a checkout those stati above are fine
-            logger.info(`Mark as charged, status is ${gatewayObject.status}`, {
-              orderPaymentId: gatewayObject.referenceId,
-            });
-            return {
-              transactionId: gatewayId,
-              gatewayObject,
-            };
-          } catch (e) {
-            if (gatewayObject.status === GatewayObjectStatus.reserved) {
-              // Cancel the reservation if it's reserved and the order has been manipulated
-              const allTransactions = gatewayObject.invoices?.flatMap((invoice) => invoice.transactions);
-              await Promise.all(
-                allTransactions.map(async (transaction) => api.deleteReservation(transaction.id)),
-              );
-            }
-            throw e;
-          }
-        }
-
-        logger.info('Charge not possible', {
-          orderPaymentId: gatewayObject.referenceId,
-          status: gatewayObject.status,
-        });
-        throw new Error(`Gateway Status ${gatewayObject.status} does not allow checkout`);
-      },
-    };
-
-    return adapterActions;
-  },
-};
-
-PaymentDirector.registerAdapter(Payrexx);

package/src/payment/payrexx/payrexx.ts

@@ -1,65 +0,0 @@
-const getRedirects = () => {
-  const {
-    EMAIL_WEBSITE_URL,
-    DATATRANS_SUCCESS_PATH = '/payrexx/success',
-    DATATRANS_ERROR_PATH = '/payrexx/error',
-    DATATRANS_CANCEL_PATH = '/payrexx/cancel',
-  } = process.env;
-
-  return {
-    successRedirectUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_SUCCESS_PATH}`,
-    failedRedirectUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_ERROR_PATH}`,
-    cancelRedirectUrl: `${EMAIL_WEBSITE_URL}${DATATRANS_CANCEL_PATH}`,
-  };
-};
-
-export const mapOrderDataToGatewayObject = ({ order, orderPayment, pricing }, options = {}) => {
-  const { currencyCode, amount } = pricing.total({ useNetPrice: false });
-
-  const customerData = {};
-  if (order.contact?.emailAddress) {
-    customerData['fields[email][value]'] = order.contact?.emailAddress;
-  }
-  if (order.billingAddress?.firstName) {
-    customerData['fields[forename][value]'] = order.billingAddress?.firstName;
-  }
-  if (order.billingAddress?.lastName) {
-    customerData['fields[surname][value]'] = order.billingAddress?.lastName;
-  }
-
-  const gatewayObject = {
-    amount: Math.round(amount),
-    currency: currencyCode.toUpperCase(),
-    purpose: encodeURIComponent(`${process.env.EMAIL_WEBSITE_NAME || 'Unchained'} #${order._id}`),
-    reservation: true,
-    skipResultPage: true,
-    ...getRedirects(),
-    referenceId: orderPayment._id,
-    ...customerData,
-    ...options,
-  };
-  return gatewayObject;
-};
-
-export const mapUserToGatewayObject = ({ userId, emailAddress, currencyCode }, options = {}) => {
-  const customerData = {};
-
-  if (emailAddress) {
-    customerData['fields[email][value]'] = emailAddress;
-  }
-
-  customerData['fields[custom_field_1][name][0]'] = 'userId';
-  customerData['fields[custom_field_1][value]'] = userId;
-
-  const gatewayObject = {
-    amount: Math.round(0),
-    currency: currencyCode,
-    purpose: encodeURIComponent(`${process.env.EMAIL_WEBSITE_NAME || 'Unchained'} ${userId}`),
-    preAuthorization: true,
-    skipResultPage: true,
-    ...getRedirects(),
-    referenceId: userId,
-    ...options,
-  };
-  return gatewayObject;
-};

package/src/payment/payrexx/readme.md

@@ -1,4 +0,0 @@
-## Test Webhooks:
-
-```
-```

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

@@ -1,111 +0,0 @@
-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 async generateMacHeaders(method: string, path: string): Promise<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('|');
-
-    // Use Web Crypto API instead of crypto.createHmac
-    const secretBytes = Uint8Array.from(atob(this.config.apiSecret), (c) => c.charCodeAt(0));
-    const key = await crypto.subtle.importKey(
-      'raw',
-      secretBytes,
-      { name: 'HMAC', hash: 'SHA-512' },
-      false,
-      ['sign'],
-    );
-    const signature = await crypto.subtle.sign('HMAC', key, new TextEncoder().encode(dataToSign));
-    const macValue = btoa(String.fromCharCode(...new Uint8Array(signature)));
-
-    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 = await 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

@@ -1,111 +0,0 @@
-// 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,114 +0,0 @@
-import { PostFinanceApiClient } from './api-client.js';
-import {
-  Transaction,
-  TransactionCreate,
-  TransactionCompletion,
-  Token,
-  RefundCreate,
-  RefundType,
-} from './api-types.js';
-
-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);
-
-let apiClient: PostFinanceApiClient;
-
-const getApiClient = () => {
-  if (!apiClient) {
-    apiClient = new PostFinanceApiClient({
-      spaceId: SPACE_ID,
-      userId: USER_ID,
-      apiSecret: PFCHECKOUT_SECRET as string,
-    });
-  }
-  return apiClient;
-};
-
-export const getTransaction = async (transactionId: string): Promise<Transaction> => {
-  const client = getApiClient();
-  return client.get<Transaction>(`/transaction/read?spaceId=${SPACE_ID}&id=${transactionId}`);
-};
-
-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 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 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 client = getApiClient();
-  try {
-    await client.post(`/transaction-void/voidOnline?spaceId=${SPACE_ID}&id=${transactionId}`, {});
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-export const refundTransaction = async (
-  transactionId: string,
-  orderId: string,
-  amount: number,
-): Promise<boolean> => {
-  const client = getApiClient();
-  const refund: RefundCreate = {
-    transaction: parseInt(transactionId, 10),
-    externalId: orderId,
-    amount,
-    type: RefundType.MERCHANT_INITIATED_ONLINE,
-  };
-  try {
-    await client.post(`/refund/refund?spaceId=${SPACE_ID}`, refund);
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-export const confirmDeferredTransaction = async (transactionId: string): Promise<boolean> => {
-  const client = getApiClient();
-  try {
-    await client.post(
-      `/transaction-completion/completeOnline?spaceId=${SPACE_ID}&transactionId=${transactionId}`,
-      {},
-    );
-    return true;
-  } catch {
-    return false;
-  }
-};
-
-export const getPaymentPageUrl = async (transactionId: number): Promise<string> => {
-  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 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 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

@@ -1,44 +0,0 @@
-import { Context } from '@unchainedshop/api';
-import { createLogger } from '@unchainedshop/logger';
-import { WebhookData } from './types.js';
-import { getTransaction, getTransactionCompletion } from './api.js';
-
-const logger = createLogger('unchained:postfinance-checkout:handler');
-
-export const postfinanceCheckoutHandler = async (req, res) => {
-  const context = req.unchainedContext as Context;
-  const { services, modules } = context;
-  const data = req.body as WebhookData;
-  if (data.listenerEntityTechnicalName === 'TransactionCompletion') {
-    try {
-      const transactionCompletion = await getTransactionCompletion(data.entityId as unknown as string);
-      const transaction = await getTransaction(
-        transactionCompletion ? (transactionCompletion as any).linkedTransaction : data.entityId,
-      );
-      const { orderPaymentId } = transaction.metaData as { orderPaymentId: string };
-      const orderPayment = await modules.orders.payments.findOrderPayment({
-        orderPaymentId,
-      });
-      if (!orderPayment) throw new Error('Order Payment not found');
-
-      const order = await services.orders.checkoutOrder(orderPayment.orderId, {
-        paymentContext: {
-          transactionId: transactionCompletion.linkedTransaction,
-        },
-      });
-
-      if (!order) throw new Error(`Order with id ${orderPayment.orderId} not found`);
-
-      logger.info(
-        `Transaction ${transactionCompletion.linkedTransaction} marked order payment ID ${transaction.metaData?.orderPaymentId} as paid`,
-      );
-      res.status(200).send(`Order marked as paid: ${order.orderNumber}`);
-    } catch (e) {
-      logger.error(e);
-      res.status(500).send({ name: e.name, code: e.code, message: e.message });
-    }
-  } else {
-    logger.error(`Received unknown listenerEntityTechnicalName ${data.listenerEntityTechnicalName}`);
-    res.status(404).end();
-  }
-};