@lightspeed/online-payments-sdk 0.2.3 → 1.0.0

package/dist/cjs/v1/widget.js

@@ -38,46 +38,58 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mountPaymentWidget = mountPaymentWidget;
 var widget_1 = require("./adyen/widget");
-var common_1 = require("./common");
 var widget_2 = require("./stripe/widget");
 var session_1 = require("./session");
-var widget_error_1 = require("./widget.error");
+var error_1 = require("./error");
 var logger_1 = require("./logging/logger");
-function mountPaymentWidget(session_2, _a) {
-    return __awaiter(this, arguments, void 0, function (session, _b) {
-        var decodedSession, logger, handlers, widgetController, _c;
-        var mountPoint = _b.mountPoint, onComplete = _b.onComplete, onFail = _b.onFail, onReady = _b.onReady, defaultValues = _b.defaultValues;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
+var common_1 = require("./logging/common");
+var EventBroadcaster_1 = require("./EventBroadcaster");
+function mountPaymentWidget(session, config) {
+    return __awaiter(this, void 0, void 0, function () {
+        var eventBroadcaster, decodedSession, logger_2, widgetController, _a, error_2;
+        return __generator(this, function (_b) {
+            switch (_b.label) {
                 case 0:
+                    eventBroadcaster = new EventBroadcaster_1.EventBroadcaster(config.listeners);
+                    _b.label = 1;
+                case 1:
+                    _b.trys.push([1, 8, , 9]);
                     decodedSession = (0, session_1.decodePaymentSessionToContext)(session);
-                    logger = (0, logger_1.getLogger)(decodedSession.logging);
-                    logger.setSessionContext(decodedSession.metadata);
-                    handlers = {
-                        onComplete: (0, common_1.withLogging)(logger, 'complete', onComplete || (function () { })),
-                        onFail: (0, common_1.withLogging)(logger, 'fail', onFail || (function () { })),
-                        onReady: (0, common_1.withLogging)(logger, 'ready', onReady || (function () { })),
-                    };
-                    logger.log('info', 'mount', { sessionContext: decodedSession.context });
-                    _c = decodedSession.psp;
-                    switch (_c) {
-                        case 'ADYEN': return [3 /*break*/, 1];
-                        case 'STRIPE': return [3 /*break*/, 3];
+                    logger_2 = (0, logger_1.getLogger)(decodedSession.logging);
+                    logger_2.setSessionMetadata(decodedSession.metadata);
+                    eventBroadcaster.registerMiddleware(function (event) {
+                        logger_2.log('info', event.status, event);
+                        return event;
+                    });
+                    logger_2.log('info', 'Mount');
+                    widgetController = void 0;
+                    _a = decodedSession.psp;
+                    switch (_a) {
+                        case 'ADYEN': return [3 /*break*/, 2];
+                        case 'STRIPE': return [3 /*break*/, 4];
                     }
-                    return [3 /*break*/, 5];
-                case 1: return [4 /*yield*/, widget_1.AdyenWidget.mount(mountPoint, decodedSession.context, handlers)];
-                case 2:
-                    widgetController = _d.sent();
                     return [3 /*break*/, 6];
-                case 3: return [4 /*yield*/, widget_2.StripeWidget.mount(mountPoint, decodedSession.context, handlers, defaultValues)];
-                case 4:
-                    widgetController = _d.sent();
-                    return [3 /*break*/, 6];
-                case 5: throw new widget_error_1.UnsupportedLocationError();
-                case 6:
-                    widgetController.submit = (0, common_1.withLogging)(logger, 'submit', widgetController.submit);
-                    widgetController.unmount = (0, common_1.withLogging)(logger, 'unmount', widgetController.unmount);
+                case 2: return [4 /*yield*/, widget_1.AdyenWidget.mount(config.mountPoint, decodedSession.context, eventBroadcaster)];
+                case 3:
+                    widgetController = _b.sent();
+                    return [3 /*break*/, 7];
+                case 4: return [4 /*yield*/, widget_2.StripeWidget.mount(config.mountPoint, decodedSession.context, eventBroadcaster, config.defaultValues)];
+                case 5:
+                    widgetController = _b.sent();
+                    return [3 /*break*/, 7];
+                case 6: throw new error_1.UnsupportedLocationError();
+                case 7:
+                    widgetController.submit = (0, common_1.withLogging)(logger_2, 'Submit', widgetController.submit);
+                    widgetController.unmount = (0, common_1.withLogging)(logger_2, 'Unmount', widgetController.unmount);
                     return [2 /*return*/, widgetController];
+                case 8:
+                    error_2 = _b.sent();
+                    eventBroadcaster.publish({
+                        code: 'Unexpected',
+                        status: 'Error',
+                    });
+                    throw error_2;
+                case 9: return [2 /*return*/];
             }
         });
     });

package/dist/v1/EventBroadcaster.d.ts

@@ -0,0 +1,39 @@
+import { SupportedErrorCodes } from './error';
+export type Status = 'Succeeded' | 'Refused' | 'Pending' | 'Error' | 'Ready';
+export type BaseEvent = {
+    loggingEnrichment?: object;
+};
+export type SucceededResultEvent = BaseEvent & {
+    code: 'Authorized';
+    status: 'Succeeded';
+};
+export type PendingResultEvent = BaseEvent & {
+    code: 'Processing';
+    status: 'Pending';
+};
+export type RefusedResultEvent = BaseEvent & {
+    status: 'Refused';
+    code: 'CardValidation' | 'Generic';
+};
+export type ReadyEvent = BaseEvent & {
+    status: 'Ready';
+    code: 'Ready';
+};
+export type ErrorResultEvent = BaseEvent & {
+    code: SupportedErrorCodes;
+    status: 'Error';
+};
+export type InternalEvent = SucceededResultEvent | PendingResultEvent | RefusedResultEvent | ErrorResultEvent | ReadyEvent;
+export type Event = Omit<InternalEvent, 'loggingEnrichment'>;
+export type EventHandler = (result: Event) => void;
+export type EventMiddleware = (event: InternalEvent) => InternalEvent | void;
+export type EventListeners = Partial<Record<`on${Status}`, EventHandler>>;
+export declare class EventBroadcaster {
+    private listenersRegistry;
+    private middleware;
+    constructor(listeners?: EventListeners);
+    private convertInternalEventToExternal;
+    registerMiddleware(middleware: EventMiddleware): void;
+    applyMiddlewares(event: InternalEvent): Event;
+    publish(event: InternalEvent): void;
+}

package/dist/v1/EventBroadcaster.js

@@ -0,0 +1,58 @@
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+var noOpListener = function () { };
+var EventBroadcaster = /** @class */ (function () {
+    function EventBroadcaster(listeners) {
+        this.middleware = [];
+        this.listenersRegistry = {
+            Succeeded: (listeners === null || listeners === void 0 ? void 0 : listeners.onSucceeded) || noOpListener,
+            Refused: (listeners === null || listeners === void 0 ? void 0 : listeners.onRefused) || noOpListener,
+            Pending: (listeners === null || listeners === void 0 ? void 0 : listeners.onPending) || noOpListener,
+            Error: (listeners === null || listeners === void 0 ? void 0 : listeners.onError) || noOpListener,
+            Ready: (listeners === null || listeners === void 0 ? void 0 : listeners.onReady) || noOpListener,
+        };
+    }
+    EventBroadcaster.prototype.convertInternalEventToExternal = function (event) {
+        return { status: event.status, code: event.code };
+    };
+    EventBroadcaster.prototype.registerMiddleware = function (middleware) {
+        this.middleware.push(middleware);
+    };
+    EventBroadcaster.prototype.applyMiddlewares = function (event) {
+        var e_1, _a;
+        var processedEvent = event;
+        try {
+            for (var _b = __values(this.middleware), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var mw = _c.value;
+                var result = mw(processedEvent);
+                if (result !== undefined) {
+                    processedEvent = result;
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        return this.convertInternalEventToExternal(processedEvent);
+    };
+    EventBroadcaster.prototype.publish = function (event) {
+        var processedEvent = this.applyMiddlewares(event);
+        var eventListener = this.listenersRegistry[event.status];
+        eventListener(processedEvent);
+    };
+    return EventBroadcaster;
+}());
+export { EventBroadcaster };

package/dist/v1/adyen/ResultBuilder.d.ts

@@ -0,0 +1,7 @@
+import { ErrorResultEvent, SucceededResultEvent, PendingResultEvent, RefusedResultEvent } from '../EventBroadcaster';
+import { PaymentCompletedData, PaymentFailedData } from '@adyen/adyen-web';
+export declare class ResultBuilder {
+    static fromPaymentCompletedData(paymentCompleteData: PaymentCompletedData): SucceededResultEvent | PendingResultEvent;
+    static fromPaymentFailedData(paymentFailedData: PaymentFailedData): RefusedResultEvent | ErrorResultEvent;
+    static generatePendingEvent(): PendingResultEvent;
+}

package/dist/v1/adyen/ResultBuilder.js

@@ -0,0 +1,44 @@
+var ResultBuilder = /** @class */ (function () {
+    function ResultBuilder() {
+    }
+    ResultBuilder.fromPaymentCompletedData = function (paymentCompleteData) {
+        switch (paymentCompleteData.resultCode) {
+            case 'Authorised':
+                return {
+                    status: 'Succeeded',
+                    code: 'Authorized',
+                };
+            case 'PartiallyAuthorised':
+            case 'Received':
+            case 'Pending':
+            default:
+                return {
+                    status: 'Pending',
+                    code: 'Processing',
+                };
+        }
+    };
+    ResultBuilder.fromPaymentFailedData = function (paymentFailedData) {
+        switch (paymentFailedData.resultCode) {
+            case 'Refused':
+                return {
+                    status: 'Refused',
+                    code: 'Generic',
+                };
+            case 'Error':
+            default:
+                return {
+                    status: 'Error',
+                    code: 'Unexpected',
+                };
+        }
+    };
+    ResultBuilder.generatePendingEvent = function () {
+        return {
+            status: 'Pending',
+            code: 'Processing',
+        };
+    };
+    return ResultBuilder;
+}());
+export { ResultBuilder };

package/dist/v1/adyen/widget.d.ts

@@ -1,5 +1,3 @@
-import type { ResultCode as AdyenResultCode } from '@adyen/adyen-web';
 import { AdyenContext } from './session';
-import { WidgetInterface, ResultCode } from '../common';
-export declare function mapAdyenResultCode(code: AdyenResultCode): ResultCode;
+import { WidgetInterface } from '../common';
 export declare const AdyenWidget: WidgetInterface<AdyenContext>;

package/dist/v1/adyen/widget.js

@@ -35,24 +35,14 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
     }
 };
 import { AdyenCheckout, Dropin, Card, GooglePay, ApplePay, } from '@adyen/adyen-web';
-import { PaymentProcessingError } from '../widget.error';
-export function mapAdyenResultCode(code) {
-    switch (code) {
-        case 'Authorised':
-            return 'Authorized';
-        case 'Refused':
-            return 'Refused';
-        default:
-            return 'Unexpected';
-    }
-}
-function mount(mountElement, context, listeners) {
+import { ResultBuilder } from './ResultBuilder';
+function mount(mountElement, context, eventBroadcaster) {
     return __awaiter(this, void 0, void 0, function () {
         var checkoutConfig, checkout, dropinConfiguration, dropIn;
         return __generator(this, function (_a) {
             switch (_a.label) {
                 case 0:
-                    checkoutConfig = createAdyenConfiguration(context, listeners);
+                    checkoutConfig = createAdyenConfiguration(context, eventBroadcaster);
                     return [4 /*yield*/, AdyenCheckout(checkoutConfig)];
                 case 1:
                     checkout = _a.sent();
@@ -63,10 +53,9 @@ function mount(mountElement, context, listeners) {
                             submit: function () {
                                 return new Promise(function (resolve) {
                                     dropIn.submit();
-                                    resolve({
-                                        status: 'Pending',
-                                        code: 'Success',
-                                    });
+                                    var pendingEvent = ResultBuilder.generatePendingEvent();
+                                    eventBroadcaster.publish(pendingEvent);
+                                    resolve(pendingEvent);
                                 });
                             },
                         }];
@@ -74,7 +63,7 @@ function mount(mountElement, context, listeners) {
         });
     });
 }
-function createAdyenConfiguration(context, listeners) {
+function createAdyenConfiguration(context, eventBroadcaster) {
     return {
         clientKey: context.clientKey,
         session: {
@@ -92,21 +81,17 @@ function createAdyenConfiguration(context, listeners) {
             enabled: false,
         },
         onPaymentCompleted: function (data) {
-            var _a;
-            (_a = listeners === null || listeners === void 0 ? void 0 : listeners.onComplete) === null || _a === void 0 ? void 0 : _a.call(listeners, {
-                code: mapAdyenResultCode(data.resultCode),
-                status: 'Complete',
-            });
+            eventBroadcaster.publish(ResultBuilder.fromPaymentCompletedData(data));
         },
         onPaymentFailed: function (data) {
-            var _a;
-            (_a = listeners === null || listeners === void 0 ? void 0 : listeners.onFail) === null || _a === void 0 ? void 0 : _a.call(listeners, {
-                status: 'Complete',
-                code: mapAdyenResultCode(data.resultCode),
-            });
+            eventBroadcaster.publish(ResultBuilder.fromPaymentFailedData(data));
         },
         onError: function (error) {
-            throw new PaymentProcessingError(error.message);
+            eventBroadcaster.publish({
+                status: 'Error',
+                code: 'Processing',
+                loggingEnrichment: error,
+            });
         },
         paymentMethodsResponse: context.paymentMethods,
     };

package/dist/v1/common.d.ts

@@ -1,24 +1,12 @@
-import { Logger } from './logging/common';
-export type ResultCode = 'Authorized' | 'Success' | 'Failure' | 'Refused' | 'Unexpected';
-export type Status = 'Pending' | 'Complete';
-export type Result = {
-    status: Status;
-    code: ResultCode;
-};
+import { EventBroadcaster, Event } from './EventBroadcaster';
 export type WidgetController = {
     unmount: () => void;
-    submit: () => Promise<Result>;
-};
-export type Callbacks = {
-    onComplete?(result: Result): void;
-    onFail?(result: Result): void;
-    onReady?(): void;
+    submit: () => Promise<Event>;
 };
 export type DefaultValues = {
     country?: string;
     postalCode?: string;
 };
-export type WidgetInterface<T> = {
-    mount: (mountElement: HTMLElement, context: T, listeners: Callbacks, defaultValues?: DefaultValues) => Promise<WidgetController>;
-};
-export declare function withLogging<T extends object, Args extends unknown[], R>(logger: Logger<T>, event: string, handler: (...args: Args) => R): (...args: Args) => R;
+export interface WidgetInterface<T> {
+    mount: (mountElement: HTMLElement, context: T, eventBroadcaster: EventBroadcaster, defaultValues?: DefaultValues) => Promise<WidgetController>;
+}

package/dist/v1/common.js

@@ -1,35 +1 @@
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    return ar;
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
-export function withLogging(logger, event, handler) {
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        logger.log('info', event, { args: args });
-        return handler.apply(void 0, __spreadArray([], __read(args), false));
-    };
-}
+export {};

package/dist/v1/error.d.ts

@@ -1,4 +1,20 @@
+export type SupportedErrorCodes = 'Unexpected' | 'InvalidSession' | 'InvalidSessionPayload' | 'UnsupportedLocation' | 'Processing';
 export declare class BaseError extends Error {
-    code: string;
-    constructor(code: string, message: string);
+    code: SupportedErrorCodes;
+    constructor(code: SupportedErrorCodes, message: string);
+}
+export declare class UnexpectedError extends BaseError {
+    constructor(message?: string);
+}
+export declare class InvalidSessionError extends BaseError {
+    constructor(message?: string);
+}
+export declare class InvalidSessionPayloadError extends BaseError {
+    constructor(message?: string);
+}
+export declare class UnsupportedLocationError extends BaseError {
+    constructor();
+}
+export declare class ProcessingError extends BaseError {
+    constructor(message?: string);
 }

package/dist/v1/error.js

@@ -23,3 +23,47 @@ var BaseError = /** @class */ (function (_super) {
     return BaseError;
 }(Error));
 export { BaseError };
+var UnexpectedError = /** @class */ (function (_super) {
+    __extends(UnexpectedError, _super);
+    function UnexpectedError(message) {
+        if (message === void 0) { message = 'An unexpected error occurred'; }
+        return _super.call(this, 'Unexpected', message) || this;
+    }
+    return UnexpectedError;
+}(BaseError));
+export { UnexpectedError };
+var InvalidSessionError = /** @class */ (function (_super) {
+    __extends(InvalidSessionError, _super);
+    function InvalidSessionError(message) {
+        if (message === void 0) { message = 'The session could not be decoded'; }
+        return _super.call(this, 'InvalidSession', message) || this;
+    }
+    return InvalidSessionError;
+}(BaseError));
+export { InvalidSessionError };
+var InvalidSessionPayloadError = /** @class */ (function (_super) {
+    __extends(InvalidSessionPayloadError, _super);
+    function InvalidSessionPayloadError(message) {
+        if (message === void 0) { message = 'The session was decoded but the payload is invalid'; }
+        return _super.call(this, 'InvalidSessionPayload', message) || this;
+    }
+    return InvalidSessionPayloadError;
+}(BaseError));
+export { InvalidSessionPayloadError };
+var UnsupportedLocationError = /** @class */ (function (_super) {
+    __extends(UnsupportedLocationError, _super);
+    function UnsupportedLocationError() {
+        return _super.call(this, 'UnsupportedLocation', 'The location you are attempting to process with is not supported') || this;
+    }
+    return UnsupportedLocationError;
+}(BaseError));
+export { UnsupportedLocationError };
+var ProcessingError = /** @class */ (function (_super) {
+    __extends(ProcessingError, _super);
+    function ProcessingError(message) {
+        if (message === void 0) { message = 'The PSP experienced an error while processing the payment'; }
+        return _super.call(this, 'Processing', message) || this;
+    }
+    return ProcessingError;
+}(BaseError));
+export { ProcessingError };

package/dist/v1/index.d.ts

@@ -6,9 +6,9 @@
  */
 import { WidgetController } from './common';
 import { PaymentWidgetConfiguration } from './widget';
-export type { Result, WidgetController } from './common';
-export { InvalidSessionStructureError, InvalidSessionError, } from './session.error';
-export { UnsupportedLocationError, PaymentProcessingError } from './widget.error';
+export type { WidgetController } from './common';
+export type { Event } from './EventBroadcaster';
+export { UnsupportedLocationError, InvalidSessionPayloadError, InvalidSessionError, ProcessingError, } from './error';
 export type { PaymentWidgetConfiguration } from './widget';
 export type LightspeedPaymentsV1 = {
     /**
@@ -17,6 +17,6 @@ export type LightspeedPaymentsV1 = {
      * @param {string} session - The session ID for the payment session.
      * @param {PaymentWidgetConfiguration} config - The configuration options for the payment widget.
      */
-    mountPaymentWidget(session: string, { mountPoint, onComplete, onFail, defaultValues }: PaymentWidgetConfiguration): Promise<WidgetController>;
+    mountPaymentWidget(session: string, config: PaymentWidgetConfiguration): Promise<WidgetController>;
 };
 export declare const v1: LightspeedPaymentsV1;

package/dist/v1/index.js

@@ -5,8 +5,7 @@
  * Don't use * for exports. Be specific to prevent leaking internal APIs.
  */
 import { mountPaymentWidget } from './widget';
-export { InvalidSessionStructureError, InvalidSessionError, } from './session.error';
-export { UnsupportedLocationError, PaymentProcessingError } from './widget.error';
+export { UnsupportedLocationError, InvalidSessionPayloadError, InvalidSessionError, ProcessingError, } from './error';
 export var v1 = {
     mountPaymentWidget: mountPaymentWidget,
 };

package/dist/v1/logging/common.d.ts

@@ -9,7 +9,8 @@ export type LoggerConfig<P extends string, C extends object> = {
 };
 export interface Logger<T extends object> {
     init: (config: LoggerConfig<string, T>['params']) => void;
-    setSessionContext: (context: Record<string, string>) => void;
+    setSessionMetadata: (metadata: Record<string, string>) => void;
     log: (status: LogLevel, message: string, context?: Record<string, unknown>) => void;
 }
+export declare function withLogging<T extends object, Args extends unknown[], R>(logger: Logger<T>, event: string, handler: (...args: Args) => R): (...args: Args) => R;
 export {};

package/dist/v1/logging/common.js

@@ -1 +1,36 @@
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 export var SERVICE_NAME = 'lsp-online-payments-sdk';
+export function withLogging(logger, event, handler) {
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        logger.log('info', event, { args: args });
+        return handler.apply(void 0, __spreadArray([], __read(args), false));
+    };
+}

package/dist/v1/logging/datadog/logger.d.ts

@@ -7,7 +7,7 @@ export type DatadogLoggerConfig = LoggerConfig<'datadog', {
 export type LoggerConfigParams = DatadogLoggerConfig['params'];
 export declare class Logger implements ILogger<LoggerConfigParams> {
     init(config: LoggerConfigParams): void;
-    setSessionContext(context: Record<string, string>): void;
+    setSessionMetadata(metadata: Record<string, string>): void;
     log(status: LogLevel, message: string, context?: Record<string, unknown>): void;
 }
 export declare const getLogger: () => Logger;

package/dist/v1/logging/datadog/logger.js

@@ -10,11 +10,14 @@ var Logger = /** @class */ (function () {
             service: 'lsp-online-payments-sdk',
             env: env,
         };
-        datadogLogs.init(logsConfig);
+        var initConfig = datadogLogs.getInitConfiguration();
+        if (!initConfig) {
+            datadogLogs.init(logsConfig);
+        }
     };
-    Logger.prototype.setSessionContext = function (context) {
+    Logger.prototype.setSessionMetadata = function (metadata) {
         // setting global context removes all existing context
-        datadogLogs.setGlobalContext(context);
+        datadogLogs.setGlobalContext({ metadata: metadata });
     };
     Logger.prototype.log = function (status, message, context) {
         datadogLogs.logger.log(message, context, status);

package/dist/v1/logging/noop-logger.d.ts

@@ -1,7 +1,7 @@
 import { Logger } from './common';
 declare class NoopLogger implements Logger<{}> {
     init(): void;
-    setSessionContext(): void;
+    setSessionMetadata(): void;
     log(): void;
 }
 export declare const getLogger: () => NoopLogger;

package/dist/v1/logging/noop-logger.js

@@ -4,7 +4,7 @@ var NoopLogger = /** @class */ (function () {
     NoopLogger.prototype.init = function () {
         // No operation
     };
-    NoopLogger.prototype.setSessionContext = function () {
+    NoopLogger.prototype.setSessionMetadata = function () {
         // No operation
     };
     NoopLogger.prototype.log = function () {

package/dist/v1/session.js

@@ -1,4 +1,4 @@
-import { InvalidSessionStructureError, InvalidSessionError, } from './session.error';
+import { InvalidSessionPayloadError, InvalidSessionError } from './error';
 export function decodePaymentSessionToContext(paymentSession) {
     try {
         var decoded = atob(paymentSession);
@@ -6,7 +6,7 @@ export function decodePaymentSessionToContext(paymentSession) {
         if (jsonToken && isTokenValid(jsonToken)) {
             return jsonToken;
         }
-        throw new InvalidSessionStructureError();
+        throw new InvalidSessionPayloadError();
     }
     catch (e) {
         throw new InvalidSessionError();

package/dist/v1/stripe/ResultBuilder.d.ts

@@ -0,0 +1,7 @@
+import { StripeError, SetupIntent, PaymentIntent } from '@stripe/stripe-js';
+import { ErrorResultEvent, RefusedResultEvent, SucceededResultEvent, PendingResultEvent } from '../EventBroadcaster';
+export declare class EventBuilder {
+    static fromSetupIntent(setupIntent: SetupIntent): SucceededResultEvent | PendingResultEvent;
+    static fromStripeError(stripeError: StripeError): RefusedResultEvent | ErrorResultEvent;
+    static fromPaymentIntent(paymentIntent: PaymentIntent): SucceededResultEvent | PendingResultEvent;
+}