@commercetools/connect-payments-sdk 0.0.1 → 0.0.4

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @commercetools/connect-payments-sdk
 
+## 0.0.4
+
+### Patch Changes
+
+- ab6200f: Support jwt, oauth2 authentication and support for authority based authorization
+
+## 0.0.3
+
+### Patch Changes
+
+- f3f238f: Authentication and authorization layer via session API
+
 ## 0.0.1
 
 ### Patch Changes

package/dist/api/context/types/request-context.type.d.ts

@@ -1,4 +1,4 @@
-import { PaymentSessionData } from '../../../security';
+import { Authentication } from '../../../security';
 /**
  * Context provider interface
  */
@@ -12,5 +12,5 @@ export interface ContextProvider<T> {
 export type RequestContextData = {
     correlationId: string;
     requestId: string;
-    sessionData?: PaymentSessionData;
+    authentication?: Authentication;
 };

package/dist/api/handlers/config.handler.d.ts

@@ -1,4 +1,4 @@
 import { HandlerResponse } from './types/handler.type';
 export declare const configHandler: (options: {
     configuration: () => Promise<object> | object;
-}) => () => Promise<HandlerResponse>;
+}) => () => Promise<HandlerResponse<object>>;

package/dist/api/handlers/status.handler.d.ts

@@ -1,5 +1,12 @@
-import { Oauth2Service } from '../../security/types/oauth2.type';
+import { CommercetoolsAuthorizationService } from '../../commercetools';
 import { HandlerResponse } from './types/handler.type';
+type HealthCheckStatus = {
+    status: 'OK' | 'Partially Available' | 'Unavailable';
+    timestamp: string;
+    checks: HealthCheckResult[];
+    version: string;
+    metadata?: object;
+};
 export type HealthCheckResult = {
     name: string;
     status: 'UP' | 'DOWN';
@@ -10,16 +17,15 @@ export declare const statusHandler: (options: {
     timeout: number;
     checks: HealthCheck[];
     metadataFn?: () => Promise<object> | object;
-}) => () => Promise<HandlerResponse>;
+}) => () => Promise<HandlerResponse<HealthCheckStatus>>;
 /**
  * Check if CoCo permissions are available
  * @param opts
  * @returns
  */
-export declare const healthCheckCoCoPermissions: (opts: {
-    oauth2Service: Oauth2Service;
-    clientId: string;
-    clientSecret: string;
+export declare const healthCheckCommercetoolsPermissions: (opts: {
+    ctAuthorizationService: CommercetoolsAuthorizationService;
     projectKey: string;
     requiredPermissions: string[];
 }) => () => Promise<HealthCheckResult>;
+export {};

package/dist/api/handlers/status.handler.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.healthCheckCoCoPermissions = exports.statusHandler = void 0;
+exports.healthCheckCommercetoolsPermissions = exports.statusHandler = void 0;
 const statusHandler = (options) => async () => {
     const status = {
         timestamp: new Date().toISOString(),
@@ -45,11 +45,8 @@ exports.statusHandler = statusHandler;
  * @param opts
  * @returns
  */
-const healthCheckCoCoPermissions = (opts) => async () => {
-    const token = await opts.oauth2Service.getAccessToken({
-        clientId: opts.clientId,
-        clientSecret: opts.clientSecret,
-    });
+const healthCheckCommercetoolsPermissions = (opts) => async () => {
+    const token = await opts.ctAuthorizationService.getAccessToken();
     const foundAll = opts.requiredPermissions.every((currentScope) => token.scope.split(' ').some((scopeInToken) => scopeInToken === `${currentScope}:${opts.projectKey}`));
     if (foundAll) {
         return {
@@ -70,4 +67,4 @@ const healthCheckCoCoPermissions = (opts) => async () => {
         },
     };
 };
-exports.healthCheckCoCoPermissions = healthCheckCoCoPermissions;
+exports.healthCheckCommercetoolsPermissions = healthCheckCommercetoolsPermissions;

package/dist/api/handlers/types/handler.type.d.ts

@@ -1,5 +1,5 @@
-export type HandlerResponse = {
+export type HandlerResponse<T> = {
     status: number;
-    body?: object;
+    body: T;
     headers?: object;
 };

package/dist/api/hooks/jwt-auth.hook.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'node:http';
+import { JWTAuthenticationManager } from '../../security/authn/jwt-authn-manager';
+import { ContextProvider, RequestContextData } from '../context/types/request-context.type';
+import { AuthenticationHook } from './types/hook.type';
+export declare class JWTAuthenticationHook implements AuthenticationHook {
+    private authenticationManager;
+    private contextProvider;
+    constructor(opts: {
+        authenticationManager: JWTAuthenticationManager;
+        contextProvider: ContextProvider<RequestContextData>;
+    });
+    authenticate(): (request: {
+        headers: IncomingHttpHeaders;
+    }) => Promise<void>;
+}

package/dist/api/hooks/jwt-auth.hook.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JWTAuthenticationHook = void 0;
+const security_1 = require("../../security");
+class JWTAuthenticationHook {
+    authenticationManager;
+    contextProvider;
+    constructor(opts) {
+        this.authenticationManager = opts.authenticationManager;
+        this.contextProvider = opts.contextProvider;
+    }
+    authenticate() {
+        return async (request) => {
+            const authorizationHeader = new security_1.HeaderBasedAuthentication(request.headers['authorization']);
+            const authn = await this.authenticationManager.authenticate(authorizationHeader);
+            this.contextProvider.updateContextData({
+                authentication: authn,
+            });
+        };
+    }
+}
+exports.JWTAuthenticationHook = JWTAuthenticationHook;

package/dist/api/hooks/oauth2-auth.hook.d.ts

@@ -0,0 +1,16 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'node:http';
+import { Oauth2AuthenticationManager } from '../../security/authn/oauth2-authn-manager';
+import { ContextProvider, RequestContextData } from '../context/types/request-context.type';
+import { AuthenticationHook } from './types/hook.type';
+export declare class Oauth2AuthenticationHook implements AuthenticationHook {
+    private authenticationManager;
+    private contextProvider;
+    constructor(opts: {
+        authenticationManager: Oauth2AuthenticationManager;
+        contextProvider: ContextProvider<RequestContextData>;
+    });
+    authenticate(): (request: {
+        headers: IncomingHttpHeaders;
+    }) => Promise<void>;
+}

package/dist/api/hooks/oauth2-auth.hook.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Oauth2AuthenticationHook = void 0;
+const security_1 = require("../../security");
+class Oauth2AuthenticationHook {
+    authenticationManager;
+    contextProvider;
+    constructor(opts) {
+        this.authenticationManager = opts.authenticationManager;
+        this.contextProvider = opts.contextProvider;
+    }
+    authenticate() {
+        return async (request) => {
+            const authorizationHeader = new security_1.HeaderBasedAuthentication(request.headers['authorization']);
+            const authn = await this.authenticationManager.authenticate(authorizationHeader);
+            this.contextProvider.updateContextData({
+                authentication: authn,
+            });
+        };
+    }
+}
+exports.Oauth2AuthenticationHook = Oauth2AuthenticationHook;

package/dist/api/hooks/session-auth.hook.d.ts

@@ -1,15 +1,16 @@
+/// <reference types="node" />
 import { IncomingHttpHeaders } from 'node:http';
-import { SessionAuthenticator } from '../../security/types/session.type';
 import { ContextProvider, RequestContextData } from '../context/types/request-context.type';
-export type SessionAuthHookOptions = {
-    sessionAuthenticator: SessionAuthenticator;
-    contextProvider: ContextProvider<RequestContextData>;
-};
-/**
- * Fastify hook to authenticate and getting session information
- * @param opts
- * @returns
- */
-export declare const sessionAuthHook: (opts: SessionAuthHookOptions) => (req: {
-    headers: IncomingHttpHeaders;
-}) => Promise<void>;
+import { SessionAuthenticationManager } from '../../security';
+import { AuthenticationHook } from './types/hook.type';
+export declare class SessionAuthenticationHook implements AuthenticationHook {
+    private authenticationManager;
+    private contextProvider;
+    constructor(opts: {
+        authenticationManager: SessionAuthenticationManager;
+        contextProvider: ContextProvider<RequestContextData>;
+    });
+    authenticate(): (request: {
+        headers: IncomingHttpHeaders;
+    }) => Promise<void>;
+}

package/dist/api/hooks/session-auth.hook.js

@@ -1,31 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.sessionAuthHook = void 0;
-const errorx_1 = require("../../errorx/errorx");
-/**
- * Fastify hook to authenticate and getting session information
- * @param opts
- * @returns
- */
-const sessionAuthHook = (opts) => async (req) => {
-    const sessionId = req.headers['x-session-id'];
-    if (sessionId) {
-        const sessionData = await opts.sessionAuthenticator.introspectSession({
-            sessionId,
-        });
-        opts.contextProvider.updateContextData({
-            sessionData,
-        });
-        //updateSessionContext(sessionData);
+exports.SessionAuthenticationHook = void 0;
+const security_1 = require("../../security");
+class SessionAuthenticationHook {
+    authenticationManager;
+    contextProvider;
+    constructor(opts) {
+        this.authenticationManager = opts.authenticationManager;
+        this.contextProvider = opts.contextProvider;
     }
-    else {
-        //TODO: throw a forbidden error
-        throw new errorx_1.ErrorAuthErrorResponse({
-            privateMessage: 'Session is not valid',
-            fields: {
-                id: sessionId,
-            },
-        });
+    authenticate() {
+        return async (request) => {
+            const sessionIdAuthn = new security_1.HeaderBasedAuthentication(request.headers['x-session-id']);
+            const authn = await this.authenticationManager.authenticate(sessionIdAuthn);
+            this.contextProvider.updateContextData({
+                authentication: authn,
+            });
+        };
     }
-};
-exports.sessionAuthHook = sessionAuthHook;
+}
+exports.SessionAuthenticationHook = SessionAuthenticationHook;

package/dist/api/hooks/types/hook.type.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import { IncomingHttpHeaders } from 'node:http';
+export interface AuthenticationHook {
+    authenticate(): (request: {
+        headers: IncomingHttpHeaders;
+    }) => Promise<void>;
+}
+export interface AuthorizationHook {
+    authorize(...authorities: string[]): () => Promise<void>;
+}

package/dist/api/index.d.ts

@@ -2,4 +2,7 @@ export * from './context/request-context.provider';
 export * from './context/types/request-context.type';
 export * from './handlers/config.handler';
 export * from './handlers/status.handler';
+export * from './hooks/jwt-auth.hook';
+export * from './hooks/oauth2-auth.hook';
 export * from './hooks/session-auth.hook';
+export * from './hooks/types/hook.type';

package/dist/api/index.js

@@ -18,4 +18,7 @@ __exportStar(require("./context/request-context.provider"), exports);
 __exportStar(require("./context/types/request-context.type"), exports);
 __exportStar(require("./handlers/config.handler"), exports);
 __exportStar(require("./handlers/status.handler"), exports);
+__exportStar(require("./hooks/jwt-auth.hook"), exports);
+__exportStar(require("./hooks/oauth2-auth.hook"), exports);
 __exportStar(require("./hooks/session-auth.hook"), exports);
+__exportStar(require("./hooks/types/hook.type"), exports);

package/dist/commercetools/index.d.ts

@@ -1,2 +1,4 @@
 export { CartService as CommercetoolsCartService } from './types/cart.type';
 export { PaymentService as CommercetoolsPaymentService, TransactionData, UpdatePayment } from './types/payment.type';
+export { SessionService as CommercetoolsSessionService, Session } from './types/session.type';
+export { AuthorizationService as CommercetoolsAuthorizationService } from './types/authorization.type';

package/dist/commercetools/services/ct-authorization.service.d.ts

@@ -0,0 +1,18 @@
+import { Fetch } from '../../fetch/types/fetch.type';
+import { Logger } from '../../logger';
+import { AuthorizationService, CommercetoolsToken } from '../types/authorization.type';
+export declare class DefaultAuthorizationService implements AuthorizationService {
+    private authUrl;
+    private clientId;
+    private clientSecret;
+    private fetch;
+    private logger?;
+    constructor(opts: {
+        authUrl: string;
+        clientId: string;
+        clientSecret: string;
+        fetch: Fetch;
+        logger?: Logger;
+    });
+    getAccessToken(): Promise<CommercetoolsToken>;
+}

package/dist/commercetools/services/ct-authorization.service.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultAuthorizationService = void 0;
+const errorx_1 = require("../../errorx/errorx");
+class DefaultAuthorizationService {
+    authUrl;
+    clientId;
+    clientSecret;
+    fetch;
+    logger;
+    constructor(opts) {
+        this.authUrl = opts.authUrl;
+        this.clientId = opts.clientId;
+        this.clientSecret = opts.clientSecret;
+        this.fetch = opts.fetch;
+        this.logger = opts.logger;
+    }
+    async getAccessToken() {
+        const encodedCredentials = btoa(`${this.clientId}:${this.clientSecret}`);
+        const urlencoded = new URLSearchParams();
+        urlencoded.append('grant_type', 'client_credentials');
+        const response = await this.fetch(`${this.authUrl}/oauth/token`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/x-www-form-urlencoded',
+                Authorization: `Basic ${encodedCredentials}`,
+            },
+            body: urlencoded,
+        });
+        if (!response.ok) {
+            throw new errorx_1.ErrorGeneral(undefined, {
+                privateMessage: 'Failed to get auth token',
+                privateFields: {
+                    responseStatus: response.status,
+                    responseText: await response.text(),
+                },
+            });
+        }
+        return (await response.json());
+    }
+}
+exports.DefaultAuthorizationService = DefaultAuthorizationService;

package/dist/commercetools/services/ct-payment.service.d.ts

@@ -1,5 +1,5 @@
 import { Payment, PaymentDraft } from '@commercetools/platform-sdk';
-import { GetPayment, PaymentService, PaymentServiceOptions, UpdatePayment } from '../types/payment.type';
+import { GetPayment, PaymentModificationValidation, PaymentModificationValidationResult, PaymentService, PaymentServiceOptions, UpdatePayment } from '../types/payment.type';
 /**
  * This is the default implementation of the PaymentService interface.
  */
@@ -9,6 +9,7 @@ export declare class DefaultPaymentService implements PaymentService {
     getPayment(opts: GetPayment): Promise<Payment>;
     createPayment(draft: PaymentDraft): Promise<Payment>;
     updatePayment(opts: UpdatePayment): Promise<Payment>;
+    validatePaymentModification(opts: PaymentModificationValidation): PaymentModificationValidationResult;
     private consolidateUpdateActions;
     private populateSetInterfaceIdAction;
     private populateChangeTransactionInteractionId;
@@ -17,4 +18,8 @@ export declare class DefaultPaymentService implements PaymentService {
     private populateSetPaymentMethod;
     private findMatchingTransactions;
     private consolidateTransactionChanges;
+    private validateCancelAuthorization;
+    private validateCapturePayment;
+    private validateRefundPayment;
+    private calculateTotalAmount;
 }

package/dist/commercetools/services/ct-payment.service.js

@@ -44,6 +44,18 @@ class DefaultPaymentService {
         }
         throw err;
     }
+    validatePaymentModification(opts) {
+        switch (opts.type) {
+            case 'cancelAuthorization':
+                return this.validateCancelAuthorization(opts.payment);
+            case 'capturePayment':
+                return this.validateCapturePayment(opts.payment, opts.amount);
+            case 'refundPayment':
+                return this.validateRefundPayment(opts.payment, opts.amount);
+            default:
+                throw new Error(`Invalid payment modification type: ${opts.type}`);
+        }
+    }
     consolidateUpdateActions(payment, updateInfo) {
         const actions = [];
         if (!payment.interfaceId && updateInfo.pspReference) {
@@ -125,5 +137,65 @@ class DefaultPaymentService {
         }
         return actions;
     }
+    validateCancelAuthorization(payment) {
+        const totalAuthorized = this.calculateTotalAmount(payment, 'Authorization', payment.amountPlanned.currencyCode);
+        if (totalAuthorized === 0) {
+            return { isValid: false, reason: `No authorization transaction found for resource ${payment.id}.` };
+        }
+        const totalCaptured = this.calculateTotalAmount(payment, 'Charge', payment.amountPlanned.currencyCode);
+        if (totalCaptured > 0) {
+            return { isValid: false, reason: `Resource ${payment.id} has already been charged.` };
+        }
+        return { isValid: true };
+    }
+    validateCapturePayment(payment, amount) {
+        if (payment.amountPlanned.currencyCode !== amount.currencyCode) {
+            return {
+                isValid: false,
+                reason: `Invalid currency ${amount.currencyCode} for resource ${payment.id}, expected ${payment.amountPlanned.currencyCode}`,
+            };
+        }
+        const totalAuthorized = this.calculateTotalAmount(payment, 'Authorization', amount.currencyCode);
+        if (totalAuthorized === 0) {
+            return { isValid: false, reason: `No authorization transaction found for resource ${payment.id}.` };
+        }
+        const totalCaptured = this.calculateTotalAmount(payment, 'Charge', amount.currencyCode);
+        const allowedAmount = totalAuthorized - totalCaptured;
+        if (amount.centAmount > allowedAmount) {
+            return {
+                isValid: false,
+                reason: `The amount to capture ${amount.centAmount} exceeds the allowed amount [${allowedAmount}]`,
+            };
+        }
+        return { isValid: true };
+    }
+    validateRefundPayment(payment, amount) {
+        if (payment.amountPlanned.currencyCode !== amount.currencyCode) {
+            return {
+                isValid: false,
+                reason: `Invalid currency ${amount.currencyCode} for resource ${payment.id}, expected ${payment.amountPlanned.currencyCode}`,
+            };
+        }
+        const totalCaptured = this.calculateTotalAmount(payment, 'Charge', amount.currencyCode);
+        if (totalCaptured === 0) {
+            return { isValid: false, reason: `No charge transaction found for resource ${payment.id}.` };
+        }
+        const totalRefunded = this.calculateTotalAmount(payment, 'Refund', amount.currencyCode);
+        const allowedAmount = totalCaptured - totalRefunded;
+        if (amount.centAmount > allowedAmount) {
+            return {
+                isValid: false,
+                reason: `The amount to refund ${amount.centAmount} exceeds the allowed amount [${allowedAmount}]`,
+            };
+        }
+        return { isValid: true };
+    }
+    calculateTotalAmount(payment, type, currencyCode) {
+        return payment.transactions
+            .filter((transaction) => transaction.type === type &&
+            transaction.state === 'Success' &&
+            transaction.amount.currencyCode === currencyCode)
+            .reduce((total, transaction) => total + transaction.amount.centAmount, 0);
+    }
 }
 exports.DefaultPaymentService = DefaultPaymentService;

package/dist/commercetools/services/ct-session.service.d.ts

@@ -0,0 +1,16 @@
+import { AuthorizationService, CommercetoolsToken } from '../types/authorization.type';
+import { Session, SessionService } from '../types/session.type';
+export declare class DefaultSessionService implements SessionService {
+    private authorizationService;
+    private sessionUrl;
+    private projectKey;
+    protected token: CommercetoolsToken;
+    constructor(opts: {
+        authorizationService: AuthorizationService;
+        sessionUrl: string;
+        projectKey: string;
+    });
+    verifySession(sessionId: string): Promise<Session>;
+    getCartFromSession(session: Session): string;
+    getAllowedPaymentMethodsFromSession(session: Session): string[];
+}

package/dist/commercetools/services/ct-session.service.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultSessionService = void 0;
+const errorx_1 = require("../../errorx/errorx");
+class DefaultSessionService {
+    authorizationService;
+    sessionUrl;
+    projectKey;
+    token;
+    constructor(opts) {
+        this.authorizationService = opts.authorizationService;
+        this.sessionUrl = opts.sessionUrl;
+        this.projectKey = opts.projectKey;
+    }
+    async verifySession(sessionId) {
+        if (!this.token) {
+            this.token = await this.authorizationService.getAccessToken();
+        }
+        const res = await fetch(`${this.sessionUrl}/${this.projectKey}/sessions/${sessionId}`, {
+            method: 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                Authorization: `Bearer ${this.token.access_token}`,
+            },
+        });
+        if (!res.ok) {
+            throw new errorx_1.ErrorGeneral('Could not get session');
+        }
+        const session = (await res.json());
+        if (session.state !== 'ACTIVE') {
+            throw new errorx_1.ErrorAuthErrorResponse();
+        }
+        return session;
+    }
+    getCartFromSession(session) {
+        if (!session.activeCart?.cartRef?.id) {
+            throw new errorx_1.ErrorAuthErrorResponse();
+        }
+        return session.activeCart.cartRef.id;
+    }
+    getAllowedPaymentMethodsFromSession(session) {
+        return session.metadata?.allowedPaymentMethods || [];
+    }
+}
+exports.DefaultSessionService = DefaultSessionService;

package/dist/commercetools/types/api.type.d.ts

@@ -1,6 +1,7 @@
 import { Cart, Payment, PaymentDraft, PaymentPagedQueryResponse, PaymentUpdateAction } from '@commercetools/platform-sdk';
 import { ByProjectKeyRequestBuilder } from '@commercetools/platform-sdk/dist/declarations/src/generated/client/by-project-key-request-builder';
 export type CommercetoolsClient = ByProjectKeyRequestBuilder;
+export type CommercetoolsSessionClient = ByProjectKeyRequestBuilder;
 export interface APIOpts {
     client: CommercetoolsClient;
 }
@@ -16,6 +17,16 @@ export type UpdatePayment = {
     resource: UpdateResource;
     actions: PaymentUpdateAction[];
 };
+export type OauthToken = {
+    accessToken: string;
+    expiresIn: number;
+    tokenType: string;
+    scope: string;
+    refreshToken?: string;
+};
+export interface AuthorizationAPI {
+    getToken(): Promise<OauthToken>;
+}
 export interface CartAPI {
     getCartById(id: string): Promise<Cart>;
     addPayment(opts: AddPayment): Promise<Cart>;

package/dist/commercetools/types/authorization.type.d.ts

@@ -0,0 +1,9 @@
+export type CommercetoolsToken = {
+    access_token: string;
+    token_type: string;
+    scope: string;
+    expires_in: number;
+};
+export interface AuthorizationService {
+    getAccessToken(): Promise<CommercetoolsToken>;
+}

package/dist/commercetools/types/payment.type.d.ts

@@ -28,6 +28,15 @@ export type UpdatePayment = {
     transaction?: TransactionData;
     paymentMethod?: string;
 };
+export type PaymentModificationValidation = {
+    payment: Payment;
+    amount: Money;
+    type: TransactionType;
+};
+export type PaymentModificationValidationResult = {
+    isValid: boolean;
+    reason?: string;
+};
 /**
  * Payment service interface exposes methods to interact with the commercetools platform API.
  */
@@ -35,4 +44,5 @@ export interface PaymentService {
     getPayment(opts: GetPayment): Promise<Payment>;
     createPayment(draft: PaymentDraft): Promise<Payment>;
     updatePayment(opts: UpdatePayment): Promise<Payment>;
+    validatePaymentModification(opts: PaymentModificationValidation): PaymentModificationValidationResult;
 }

package/dist/commercetools/types/session.type.d.ts

@@ -0,0 +1,28 @@
+export type Session = {
+    id: string;
+    version: number;
+    createdAt: string;
+    lastModifiedAt: string;
+    state: 'ACTIVE' | 'EXPIRED';
+    activeCart?: {
+        cartRef: {
+            id: string;
+        };
+    };
+    customer?: {
+        customerRef: {
+            externalId?: string;
+            id?: string;
+            key?: string;
+        };
+        anonymousId?: string;
+    };
+    metadata?: {
+        [key: string]: unknown;
+    };
+};
+export interface SessionService {
+    verifySession(sessionId: string): Promise<Session>;
+    getCartFromSession(session: Session): string;
+    getAllowedPaymentMethodsFromSession(session: Session): string[];
+}

package/dist/commercetools/types/session.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/errorx/errorx.d.ts

@@ -44,7 +44,7 @@ export declare class MultiErrorx extends Error {
  * }
  */
 export declare class ErrorAuthErrorResponse extends Errorx {
-    constructor(additionalOpts?: ErrorxAdditionalOpts);
+    constructor(message?: string, additionalOpts?: ErrorxAdditionalOpts, code?: string);
 }
 /**
  * General (https://docs.commercetools.com/api/errors#general)
@@ -148,3 +148,6 @@ export declare class ErrorResourceNotFound extends Errorx {
 export declare class ErrorConcurrentModification extends Errorx {
     constructor(resourceId: string, expectedVersion: number, currentVersion: number, additionalOpts?: ErrorxAdditionalOpts);
 }
+export declare class ErrorMissingAuthenticationInfo extends Errorx {
+    constructor(additionalOpts?: ErrorxAdditionalOpts);
+}