@commercetools/checkout-payments-processor-sdk 0.0.6

package/src/api/hooks/oauth2-auth.hook.test.ts

@@ -0,0 +1,173 @@
+import type { Logger } from '@logger-types';
+import {
+  HeaderBasedAuthentication,
+  Oauth2Authentication,
+  type Oauth2AuthenticationManager,
+} from '@security';
+import type {
+  ContextProvider,
+  RequestContextData,
+} from '@/api/context/types/request-context.type.js';
+import { Oauth2AuthenticationHook } from '@/api/hooks/oauth2-auth.hook.js';
+
+describe('Oauth2AuthenticationHook', () => {
+  const authenticationManager = {
+    authenticate: vi.fn(),
+  };
+  const contextProvider = {
+    updateContextData: vi.fn(),
+  };
+  const logger = vi.fn() as unknown as Logger;
+  const authenticationHook = new Oauth2AuthenticationHook({
+    authenticationManager:
+      authenticationManager as unknown as Oauth2AuthenticationManager,
+    contextProvider:
+      contextProvider as unknown as ContextProvider<RequestContextData>,
+    logger,
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  test('authenticate should update the context data with authentication', async () => {
+    // Arrange
+    const authorizationHeader = 'Bearer <oauth2-token>';
+    const request = {
+      headers: {
+        authorization: authorizationHeader,
+      },
+    };
+    const oauth2Authentication = new Oauth2Authentication('<oauth2-token>', {
+      scope: 'manage_project:test-project customer_id:123',
+      clientId: 'test-client',
+      customerId: '123',
+      anonymousId: undefined,
+    });
+
+    // Act
+    authenticationManager.authenticate.mockResolvedValue(oauth2Authentication);
+    const authenticateFn = authenticationHook.authenticate();
+    await authenticateFn(request);
+
+    // Assert
+    expect(contextProvider.updateContextData).toHaveBeenCalledWith({
+      authentication: oauth2Authentication,
+    });
+    expect(authenticationManager.authenticate).toHaveBeenCalledWith(
+      expect.any(HeaderBasedAuthentication),
+    );
+    const capturedArg = authenticationManager.authenticate.mock
+      .calls[0][0] as HeaderBasedAuthentication;
+    expect(capturedArg.getCredentials()).toBe(authorizationHeader);
+  });
+
+  test('authenticate should handle requests without authorization header', async () => {
+    // Arrange
+    const request = {
+      headers: {},
+    };
+    const oauth2Authentication = new Oauth2Authentication('<oauth2-token>', {
+      scope: 'manage_project:test-project',
+      clientId: 'test-client',
+      customerId: undefined,
+      anonymousId: undefined,
+    });
+
+    // Act
+    authenticationManager.authenticate.mockResolvedValue(oauth2Authentication);
+    const authenticateFn = authenticationHook.authenticate();
+    await authenticateFn(request);
+
+    // Assert
+    expect(contextProvider.updateContextData).toHaveBeenCalledWith({
+      authentication: oauth2Authentication,
+    });
+    expect(authenticationManager.authenticate).toHaveBeenCalledWith(
+      expect.any(HeaderBasedAuthentication),
+    );
+    const capturedArg = authenticationManager.authenticate.mock
+      .calls[0][0] as HeaderBasedAuthentication;
+    expect(capturedArg.getCredentials()).toBeUndefined();
+  });
+
+  test('authenticate should handle authentication with anonymous user', async () => {
+    // Arrange
+    const authorizationHeader = 'Bearer <oauth2-token>';
+    const request = {
+      headers: {
+        authorization: authorizationHeader,
+      },
+    };
+    const oauth2Authentication = new Oauth2Authentication('<oauth2-token>', {
+      scope: 'manage_project:test-project anonymous_id:456',
+      clientId: 'test-client',
+      customerId: undefined,
+      anonymousId: '456',
+    });
+
+    // Act
+    authenticationManager.authenticate.mockResolvedValue(oauth2Authentication);
+    const authenticateFn = authenticationHook.authenticate();
+    await authenticateFn(request);
+
+    // Assert
+    expect(contextProvider.updateContextData).toHaveBeenCalledWith({
+      authentication: oauth2Authentication,
+    });
+    expect(authenticationManager.authenticate).toHaveBeenCalledWith(
+      expect.any(HeaderBasedAuthentication),
+    );
+  });
+
+  test('authenticate should propagate authentication manager errors', async () => {
+    // Arrange
+    const authorizationHeader = 'Bearer invalid-token';
+    const request = {
+      headers: {
+        authorization: authorizationHeader,
+      },
+    };
+    const error = new Error('Invalid token');
+
+    // Act
+    authenticationManager.authenticate.mockRejectedValue(error);
+    const authenticateFn = authenticationHook.authenticate();
+
+    // Assert
+    await expect(authenticateFn(request)).rejects.toThrow('Invalid token');
+    expect(contextProvider.updateContextData).not.toHaveBeenCalled();
+  });
+
+  test('authenticate should handle requests with query parameters', async () => {
+    // Arrange
+    const authorizationHeader = 'Bearer <oauth2-token>';
+    const request = {
+      headers: {
+        authorization: authorizationHeader,
+      },
+      query: {
+        someParam: 'someValue',
+      },
+    };
+    const oauth2Authentication = new Oauth2Authentication('<oauth2-token>', {
+      scope: 'manage_project:test-project',
+      clientId: 'test-client',
+      customerId: undefined,
+      anonymousId: undefined,
+    });
+
+    // Act
+    authenticationManager.authenticate.mockResolvedValue(oauth2Authentication);
+    const authenticateFn = authenticationHook.authenticate();
+    await authenticateFn(request);
+
+    // Assert
+    expect(contextProvider.updateContextData).toHaveBeenCalledWith({
+      authentication: oauth2Authentication,
+    });
+    expect(authenticationManager.authenticate).toHaveBeenCalledWith(
+      expect.any(HeaderBasedAuthentication),
+    );
+  });
+});

package/src/api/hooks/oauth2-auth.hook.ts

@@ -0,0 +1,46 @@
+import type { IncomingHttpHeaders } from 'node:http';
+import type { Logger } from '@logger-types';
+import {
+  HeaderBasedAuthentication,
+  type Oauth2AuthenticationManager,
+} from '@security';
+import type {
+  ContextProvider,
+  RequestContextData,
+} from '@/api/context/types/request-context.type.js';
+import type { AuthenticationHook } from '@/api/hooks/types/hook.type.js';
+
+export class Oauth2AuthenticationHook implements AuthenticationHook {
+  private authenticationManager: Oauth2AuthenticationManager;
+  private contextProvider: ContextProvider<RequestContextData>;
+  private logger: Logger;
+
+  constructor(opts: {
+    authenticationManager: Oauth2AuthenticationManager;
+    contextProvider: ContextProvider<RequestContextData>;
+    logger: Logger;
+  }) {
+    this.authenticationManager = opts.authenticationManager;
+    this.contextProvider = opts.contextProvider;
+    this.logger = opts.logger;
+  }
+
+  authenticate() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return async (request: {
+      headers: IncomingHttpHeaders;
+      query?: unknown;
+    }) => {
+      const authorizationHeader = new HeaderBasedAuthentication(
+        request.headers.authorization as string,
+      );
+
+      const authn =
+        await this.authenticationManager.authenticate(authorizationHeader);
+
+      this.contextProvider.updateContextData({
+        authentication: authn,
+      });
+    };
+  }
+}

package/src/api/hooks/session-header-auth.hook.ts

@@ -0,0 +1,47 @@
+import type { IncomingHttpHeaders } from 'node:http';
+import type { Logger } from '@logger-types';
+import {
+  HeaderBasedAuthentication,
+  type SessionHeaderAuthenticationManager,
+} from '@security';
+import type {
+  ContextProvider,
+  RequestContextData,
+} from '@/api/context/types/request-context.type.js';
+import type { AuthenticationHook } from '@/api/hooks/types/hook.type.js';
+
+export class SessionHeaderAuthenticationHook implements AuthenticationHook {
+  private authenticationManager: SessionHeaderAuthenticationManager;
+  private contextProvider: ContextProvider<RequestContextData>;
+  private logger: Logger;
+
+  constructor(opts: {
+    authenticationManager: SessionHeaderAuthenticationManager;
+    contextProvider: ContextProvider<RequestContextData>;
+    logger: Logger;
+  }) {
+    this.authenticationManager = opts.authenticationManager;
+    this.contextProvider = opts.contextProvider;
+    this.logger = opts.logger;
+  }
+
+  authenticate() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return async (request: {
+      headers: IncomingHttpHeaders;
+      query?: unknown;
+    }) => {
+      const sessionIdAuthn = new HeaderBasedAuthentication(
+        request.headers['x-session-id'] as string,
+      );
+      const authn =
+        await this.authenticationManager.authenticate(sessionIdAuthn);
+      const correlationId = authn.getPrincipal().correlationId;
+
+      this.contextProvider.updateContextData({
+        authentication: authn,
+        ...(correlationId && { correlationId }),
+      });
+    };
+  }
+}

package/src/api/hooks/session-query-param-auth.hook.ts

@@ -0,0 +1,46 @@
+import type { IncomingHttpHeaders } from 'node:http';
+import type { Logger } from '@logger-types';
+import type {
+  ContextProvider,
+  RequestContextData,
+} from '@/api/context/types/request-context.type.js';
+import type { AuthenticationHook } from '@/api/hooks/types/hook.type.js';
+import { QueryParamBasedAuthentication } from '@/security/authn/authns.js';
+import type { SessionQueryParamAuthenticationManager } from '@/security/authn/session-query-param-authn-manager.js';
+
+// TODO: This should not be here or at least being more generic
+export class SessionQueryParamAuthenticationHook implements AuthenticationHook {
+  private authenticationManager: SessionQueryParamAuthenticationManager;
+  private contextProvider: ContextProvider<RequestContextData>;
+  private logger: Logger;
+
+  constructor(opts: {
+    authenticationManager: SessionQueryParamAuthenticationManager;
+    contextProvider: ContextProvider<RequestContextData>;
+    logger: Logger;
+  }) {
+    this.authenticationManager = opts.authenticationManager;
+    this.contextProvider = opts.contextProvider;
+    this.logger = opts.logger;
+  }
+
+  authenticate() {
+    return async (request: {
+      headers: IncomingHttpHeaders;
+      query?: unknown;
+    }) => {
+      const query = request.query as { ctsid: string };
+      const sessionIdAuthn = new QueryParamBasedAuthentication(
+        query.ctsid as string,
+      );
+      const authn =
+        await this.authenticationManager.authenticate(sessionIdAuthn);
+      const correlationId = authn.getPrincipal().correlationId;
+
+      this.contextProvider.updateContextData({
+        authentication: authn,
+        ...(correlationId && { correlationId }),
+      });
+    };
+  }
+}

package/src/api/hooks/types/hook.type.ts

@@ -0,0 +1,12 @@
+import type { IncomingHttpHeaders } from 'node:http';
+
+export interface AuthenticationHook {
+  authenticate(): (request: {
+    headers: IncomingHttpHeaders;
+    query?: unknown;
+  }) => Promise<void>;
+}
+
+export interface AuthorizationHook {
+  authorize(...authorities: string[]): () => Promise<void>;
+}

package/src/api/index.ts

@@ -0,0 +1,11 @@
+export * from '@/api/context/request-context.helper.js';
+export * from '@/api/context/request-context.provider.js';
+export * from '@/api/handlers/payment-components.handler.js';
+export * from '@/api/handlers/payment-intents.handler.js';
+export * from '@/api/handlers/status.handler.js';
+export * from '@/api/handlers/transaction.handler.js';
+export * from '@/api/hooks/authorize.hook.js';
+export * from '@/api/hooks/jwt-auth.hook.js';
+export * from '@/api/hooks/oauth2-auth.hook.js';
+export * from '@/api/hooks/session-header-auth.hook.js';
+export * from '@/api/hooks/session-query-param-auth.hook.js';

package/src/api/types.ts

@@ -0,0 +1,3 @@
+export * from '@/api/context/types/request-context.type.js';
+export * from '@/api/handlers/types/handler.type.js';
+export * from '@/api/hooks/types/hook.type.js';

package/src/commercetools/api/base-api.ts

@@ -0,0 +1,28 @@
+import type { ClientResponse } from '@commercetools/platform-sdk';
+import {
+  type CocoErrorType,
+  CommercetoolsAPIError,
+} from '@/commercetools/errors/ct-api.error.js';
+import type {
+  APIOpts,
+  CommercetoolsClient,
+} from '@/commercetools/types/api.type.js';
+
+export abstract class CommercetoolsBaseAPI {
+  protected client: CommercetoolsClient;
+
+  constructor(opts: APIOpts) {
+    this.client = opts.client;
+  }
+
+  protected async executeCall<T>(cr: Promise<ClientResponse<T>>): Promise<T> {
+    try {
+      return (await cr).body;
+    } catch (e: unknown) {
+      if (e instanceof Object && 'statusCode' in e) {
+        throw new CommercetoolsAPIError(e as CocoErrorType);
+      }
+      throw e;
+    }
+  }
+}

package/src/commercetools/api/cart-api.test.ts

@@ -0,0 +1,95 @@
+import { RequestContextProvider } from '@api';
+import { CommercetoolsLogger } from '@logger';
+import { HttpResponse, http } from 'msw';
+import { setupServer } from 'msw/node';
+import { DefaultCommercetoolsAPI } from '@/commercetools/api/root-api.js';
+import { authToken } from '@/mocks/auth.mock.js';
+import { cartMock } from '@/mocks/cart.mock.js';
+import { ctAPIErrorMock } from '@/mocks/ct-api-error.mock.js';
+
+const mockServer = setupServer();
+
+describe('commercetools cart API', () => {
+  beforeAll(() =>
+    mockServer.listen({
+      onUnhandledRequest: 'error',
+    }),
+  );
+  afterAll(() => mockServer.close());
+  const projectKey = 'test';
+  const contextProvider = new RequestContextProvider({
+    getContextFn: () => ({
+      correlationId: 'correlation-id',
+      requestId: 'request-id',
+    }),
+    updateContextFn: () => {},
+  });
+  const logger = new CommercetoolsLogger({ contextProvider, projectKey });
+
+  const { cart: cartAPI } = new DefaultCommercetoolsAPI({
+    apiUrl: 'http://api.test.com',
+    authUrl: 'http://auth.test.com',
+    clientId: 'clientId',
+    clientSecret: 'clientSecret',
+    projectKey,
+    contextProvider,
+    logger,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    httpClient: (input: string | URL | Request, init?: RequestInit) => {
+      return fetch(input, init);
+    },
+  });
+
+  describe('getCartById', () => {
+    test('should return a cart', async () => {
+      //given
+      const cartId = '12345';
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetCartById(cartId, 200, cartMock),
+      );
+
+      //when
+      const cart = await cartAPI.getCartById(cartId);
+
+      //then
+      expect(cart).toEqual(cartMock);
+    });
+
+    test('should throw an error when cart is not found', async () => {
+      //given
+      const cartId = '12345';
+      const statusCode = 404;
+      const errorMessage = 'Cart not found';
+      const error = ctAPIErrorMock(statusCode, 'Not Found', errorMessage);
+      mockServer.use(
+        mockGetAuthToken(200, authToken),
+        mockGetCartById(cartId, statusCode, error),
+      );
+
+      //when
+      const cartPromise = cartAPI.getCartById(cartId);
+
+      //then
+      await expect(cartPromise).rejects.toThrow(errorMessage);
+    });
+  });
+});
+
+const mockGetAuthToken = (respCode: number, data?: object) =>
+  http.post(
+    'http://auth.test.com/oauth/token',
+    () => HttpResponse.json(data, { status: respCode }),
+    { once: true },
+  );
+
+const mockGetCartById = (id: string, respCode: number, data?: object) => {
+  return http.get(
+    `http://api.test.com/test/carts/${id}`,
+    () =>
+      HttpResponse.json(data, {
+        status: respCode,
+      }),
+    { once: true },
+  );
+};

package/src/commercetools/api/cart-api.ts

@@ -0,0 +1,55 @@
+import type { Cart, CartPagedQueryResponse } from '@commercetools/platform-sdk';
+import { CommercetoolsBaseAPI } from '@/commercetools/api/base-api.js';
+import type {
+  AddPayment,
+  APIOpts,
+  CartAPI,
+} from '@/commercetools/types/api.type.js';
+
+export class CommercetoolsCartAPI
+  extends CommercetoolsBaseAPI
+  implements CartAPI
+{
+  constructor(opts: APIOpts) {
+    super(opts);
+    Object.setPrototypeOf(this, CommercetoolsCartAPI.prototype);
+  }
+
+  public async find(queryPredicate: string): Promise<CartPagedQueryResponse> {
+    return this.executeCall(
+      this.client
+        .carts()
+        .get({ queryArgs: { where: queryPredicate } })
+        .execute(),
+    );
+  }
+
+  public async getCartById(id: string): Promise<Cart> {
+    return this.executeCall(
+      this.client.carts().withId({ ID: id }).get().execute(),
+    );
+  }
+
+  public async addPayment(opts: AddPayment): Promise<Cart> {
+    return this.executeCall(
+      this.client
+        .carts()
+        .withId({ ID: opts.resource.id })
+        .post({
+          body: {
+            version: opts.resource.version,
+            actions: [
+              {
+                action: 'addPayment',
+                payment: {
+                  id: opts.paymentId,
+                  typeId: 'payment',
+                },
+              },
+            ],
+          },
+        })
+        .execute(),
+    );
+  }
+}

package/src/commercetools/api/custom-type-api.ts

@@ -0,0 +1,39 @@
+import type { Type, TypePagedQueryResponse } from '@commercetools/platform-sdk';
+import type { APIOpts, CustomTypeAPI } from '../types/api.type.js';
+import { CommercetoolsBaseAPI } from './base-api.js';
+
+export class CommercetoolsCustomTypeAPI
+  extends CommercetoolsBaseAPI
+  implements CustomTypeAPI
+{
+  constructor(opts: APIOpts) {
+    super(opts);
+    Object.setPrototypeOf(this, CommercetoolsCustomTypeAPI.prototype);
+  }
+
+  public async getByKey(key: string): Promise<Type> {
+    return this.executeCall(
+      this.client.types().withKey({ key }).get().execute(),
+    );
+  }
+
+  public async find(queryPredicate: string): Promise<TypePagedQueryResponse> {
+    return this.executeCall(
+      this.client
+        .types()
+        .get({ queryArgs: { where: queryPredicate } })
+        .execute(),
+    );
+  }
+
+  public async create(draft: Type): Promise<Type> {
+    return this.executeCall(
+      this.client
+        .types()
+        .post({
+          body: draft,
+        })
+        .execute(),
+    );
+  }
+}

package/src/commercetools/api/order-api.ts

@@ -0,0 +1,22 @@
+import type { OrderPagedQueryResponse } from '@commercetools/platform-sdk';
+import { CommercetoolsBaseAPI } from '@/commercetools/api/base-api.js';
+import type { APIOpts, OrderAPI } from '@/commercetools/types/api.type.js';
+
+export class CommercetoolsOrderAPI
+  extends CommercetoolsBaseAPI
+  implements OrderAPI
+{
+  constructor(opts: APIOpts) {
+    super(opts);
+    Object.setPrototypeOf(this, CommercetoolsOrderAPI.prototype);
+  }
+
+  public async find(queryPredicate: string): Promise<OrderPagedQueryResponse> {
+    return this.executeCall(
+      this.client
+        .orders()
+        .get({ queryArgs: { where: queryPredicate } })
+        .execute(),
+    );
+  }
+}

package/src/commercetools/api/payment-api.ts

@@ -0,0 +1,64 @@
+import type {
+  Payment,
+  PaymentDraft,
+  PaymentPagedQueryResponse,
+} from '@commercetools/platform-sdk';
+import { CommercetoolsBaseAPI } from '@/commercetools/api/base-api.js';
+import type {
+  APIOpts,
+  PaymentAPI,
+  UpdatePayment,
+} from '@/commercetools/types/api.type.js';
+
+export class CommercetoolsPaymentAPI
+  extends CommercetoolsBaseAPI
+  implements PaymentAPI
+{
+  constructor(opts: APIOpts) {
+    super(opts);
+    Object.setPrototypeOf(this, CommercetoolsPaymentAPI.prototype);
+  }
+
+  public async getPaymentById(id: string): Promise<Payment> {
+    return this.executeCall(
+      this.client.payments().withId({ ID: id }).get().execute(),
+    );
+  }
+
+  public async find(
+    queryPredicate: string,
+  ): Promise<PaymentPagedQueryResponse> {
+    return this.executeCall(
+      this.client
+        .payments()
+        .get({ queryArgs: { where: queryPredicate } })
+        .execute(),
+    );
+  }
+
+  public async createPayment(paymentDraft: PaymentDraft): Promise<Payment> {
+    return this.executeCall(
+      this.client
+        .payments()
+        .post({
+          body: paymentDraft,
+        })
+        .execute(),
+    );
+  }
+
+  public async updatePayment(opts: UpdatePayment): Promise<Payment> {
+    return this.executeCall(
+      this.client
+        .payments()
+        .withId({ ID: opts.resource.id })
+        .post({
+          body: {
+            version: opts.resource.version,
+            actions: opts.actions,
+          },
+        })
+        .execute(),
+    );
+  }
+}