@fintalk.ai/lambda-handlers 1.0.3 → 2.1.1

package/lib/errors/precondition-failed-error.d.ts

@@ -0,0 +1,4 @@
+import FintalkError from './fintalk-error';
+export default class PreconditionFailedError extends FintalkError {
+    constructor(message?: string, details?: any[], user_error_code?: string);
+}

package/lib/errors/precondition-failed-error.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fintalk_error_1 = __importDefault(require("./fintalk-error"));
+var PreconditionFailedError = (function (_super) {
+    __extends(PreconditionFailedError, _super);
+    function PreconditionFailedError(message, details, user_error_code) {
+        if (message === void 0) { message = 'Precondition Failed'; }
+        if (details === void 0) { details = []; }
+        if (user_error_code === void 0) { user_error_code = ''; }
+        var _this = _super.call(this, message, 412, details, user_error_code) || this;
+        Object.setPrototypeOf(_this, PreconditionFailedError.prototype);
+        return _this;
+    }
+    return PreconditionFailedError;
+}(fintalk_error_1.default));
+exports.default = PreconditionFailedError;
+//# sourceMappingURL=precondition-failed-error.js.map

package/lib/errors/precondition-failed-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"precondition-failed-error.js","sourceRoot":"","sources":["../../src/errors/precondition-failed-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,kEAA0C;AAE1C;IAAqD,2CAAY;IAC/D,iCACE,OAAuC,EACvC,OAAmB,EACnB,eAA4B;QAF5B,wBAAA,EAAA,+BAAuC;QACvC,wBAAA,EAAA,YAAmB;QACnB,gCAAA,EAAA,oBAA4B;QAH9B,YAKE,kBAAM,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,SAE9C;QADC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,uBAAuB,CAAC,SAAS,CAAC,CAAA;;IAChE,CAAC;IACH,8BAAC;AAAD,CAAC,AATD,CAAqD,uBAAY,GAShE"}

package/lib/errors/service-unavailable-error.d.ts

@@ -0,0 +1,4 @@
+import FintalkError from './fintalk-error';
+export default class ServiceUnavailableError extends FintalkError {
+    constructor(message?: string, details?: any[], user_error_code?: string);
+}

package/lib/errors/service-unavailable-error.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fintalk_error_1 = __importDefault(require("./fintalk-error"));
+var ServiceUnavailableError = (function (_super) {
+    __extends(ServiceUnavailableError, _super);
+    function ServiceUnavailableError(message, details, user_error_code) {
+        if (message === void 0) { message = 'Service Unavailable'; }
+        if (details === void 0) { details = []; }
+        if (user_error_code === void 0) { user_error_code = ''; }
+        var _this = _super.call(this, message, 503, details, user_error_code) || this;
+        Object.setPrototypeOf(_this, ServiceUnavailableError.prototype);
+        return _this;
+    }
+    return ServiceUnavailableError;
+}(fintalk_error_1.default));
+exports.default = ServiceUnavailableError;
+//# sourceMappingURL=service-unavailable-error.js.map

package/lib/errors/service-unavailable-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-unavailable-error.js","sourceRoot":"","sources":["../../src/errors/service-unavailable-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,kEAA0C;AAE1C;IAAqD,2CAAY;IAC/D,iCACE,OAAuC,EACvC,OAAmB,EACnB,eAA4B;QAF5B,wBAAA,EAAA,+BAAuC;QACvC,wBAAA,EAAA,YAAmB;QACnB,gCAAA,EAAA,oBAA4B;QAH9B,YAKE,kBAAM,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,SAE9C;QADC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,uBAAuB,CAAC,SAAS,CAAC,CAAA;;IAChE,CAAC;IACH,8BAAC;AAAD,CAAC,AATD,CAAqD,uBAAY,GAShE"}

package/lib/errors/teapot-error.d.ts

@@ -0,0 +1,4 @@
+import FintalkError from './fintalk-error';
+export default class TeapotError extends FintalkError {
+    constructor(message?: string, details?: any[], user_error_code?: string);
+}

package/lib/errors/teapot-error.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fintalk_error_1 = __importDefault(require("./fintalk-error"));
+var TeapotError = (function (_super) {
+    __extends(TeapotError, _super);
+    function TeapotError(message, details, user_error_code) {
+        if (message === void 0) { message = 'ImAHoneyPot'; }
+        if (details === void 0) { details = []; }
+        if (user_error_code === void 0) { user_error_code = ''; }
+        var _this = _super.call(this, message, 418, details, user_error_code) || this;
+        Object.setPrototypeOf(_this, TeapotError.prototype);
+        return _this;
+    }
+    return TeapotError;
+}(fintalk_error_1.default));
+exports.default = TeapotError;
+//# sourceMappingURL=teapot-error.js.map

package/lib/errors/teapot-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"teapot-error.js","sourceRoot":"","sources":["../../src/errors/teapot-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,kEAA0C;AAE1C;IAAyC,+BAAY;IACnD,qBACE,OAA+B,EAC/B,OAAmB,EACnB,eAA4B;QAF5B,wBAAA,EAAA,uBAA+B;QAC/B,wBAAA,EAAA,YAAmB;QACnB,gCAAA,EAAA,oBAA4B;QAH9B,YAKE,kBAAM,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,SAE9C;QADC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,WAAW,CAAC,SAAS,CAAC,CAAA;;IACpD,CAAC;IACH,kBAAC;AAAD,CAAC,AATD,CAAyC,uBAAY,GASpD"}

package/lib/errors/too-many-requests-error.d.ts

@@ -0,0 +1,4 @@
+import FintalkError from './fintalk-error';
+export default class TooManyRequestsError extends FintalkError {
+    constructor(message?: string, details?: any[], user_error_code?: string);
+}

package/lib/errors/too-many-requests-error.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fintalk_error_1 = __importDefault(require("./fintalk-error"));
+var TooManyRequestsError = (function (_super) {
+    __extends(TooManyRequestsError, _super);
+    function TooManyRequestsError(message, details, user_error_code) {
+        if (message === void 0) { message = 'Too Many Requests'; }
+        if (details === void 0) { details = []; }
+        if (user_error_code === void 0) { user_error_code = ''; }
+        var _this = _super.call(this, message, 429, details, user_error_code) || this;
+        Object.setPrototypeOf(_this, TooManyRequestsError.prototype);
+        return _this;
+    }
+    return TooManyRequestsError;
+}(fintalk_error_1.default));
+exports.default = TooManyRequestsError;
+//# sourceMappingURL=too-many-requests-error.js.map

package/lib/errors/too-many-requests-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"too-many-requests-error.js","sourceRoot":"","sources":["../../src/errors/too-many-requests-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,kEAA0C;AAE1C;IAAkD,wCAAY;IAC5D,8BACE,OAAqC,EACrC,OAAmB,EACnB,eAA4B;QAF5B,wBAAA,EAAA,6BAAqC;QACrC,wBAAA,EAAA,YAAmB;QACnB,gCAAA,EAAA,oBAA4B;QAH9B,YAKE,kBAAM,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,SAE9C;QADC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAA;;IAC7D,CAAC;IACH,2BAAC;AAAD,CAAC,AATD,CAAkD,uBAAY,GAS7D"}

package/lib/errors/unauthorized-error.d.ts

@@ -0,0 +1,4 @@
+import FintalkError from './fintalk-error';
+export default class UnauthorizedError extends FintalkError {
+    constructor(message?: string, details?: any[], user_error_code?: string);
+}

package/lib/errors/unauthorized-error.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fintalk_error_1 = __importDefault(require("./fintalk-error"));
+var UnauthorizedError = (function (_super) {
+    __extends(UnauthorizedError, _super);
+    function UnauthorizedError(message, details, user_error_code) {
+        if (message === void 0) { message = 'Unauthorized'; }
+        if (details === void 0) { details = []; }
+        if (user_error_code === void 0) { user_error_code = ''; }
+        var _this = _super.call(this, message, 401, details, user_error_code) || this;
+        Object.setPrototypeOf(_this, UnauthorizedError.prototype);
+        return _this;
+    }
+    return UnauthorizedError;
+}(fintalk_error_1.default));
+exports.default = UnauthorizedError;
+//# sourceMappingURL=unauthorized-error.js.map

package/lib/errors/unauthorized-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unauthorized-error.js","sourceRoot":"","sources":["../../src/errors/unauthorized-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,kEAA0C;AAE1C;IAA+C,qCAAY;IACzD,2BACE,OAAgC,EAChC,OAAmB,EACnB,eAA4B;QAF5B,wBAAA,EAAA,wBAAgC;QAChC,wBAAA,EAAA,YAAmB;QACnB,gCAAA,EAAA,oBAA4B;QAH9B,YAKE,kBAAM,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,SAE9C;QADC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,iBAAiB,CAAC,SAAS,CAAC,CAAA;;IAC1D,CAAC;IACH,wBAAC;AAAD,CAAC,AATD,CAA+C,uBAAY,GAS1D"}

package/lib/errors/unprocessable-entity-error.d.ts

@@ -0,0 +1,4 @@
+import FintalkError from './fintalk-error';
+export default class UnprocessableEntityError extends FintalkError {
+    constructor(message?: string, details?: any[], user_error_code?: string);
+}

package/lib/errors/unprocessable-entity-error.js

@@ -0,0 +1,35 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var fintalk_error_1 = __importDefault(require("./fintalk-error"));
+var UnprocessableEntityError = (function (_super) {
+    __extends(UnprocessableEntityError, _super);
+    function UnprocessableEntityError(message, details, user_error_code) {
+        if (message === void 0) { message = 'Unprocessable Entity'; }
+        if (details === void 0) { details = []; }
+        if (user_error_code === void 0) { user_error_code = ''; }
+        var _this = _super.call(this, message, 422, details, user_error_code) || this;
+        Object.setPrototypeOf(_this, UnprocessableEntityError.prototype);
+        return _this;
+    }
+    return UnprocessableEntityError;
+}(fintalk_error_1.default));
+exports.default = UnprocessableEntityError;
+//# sourceMappingURL=unprocessable-entity-error.js.map

package/lib/errors/unprocessable-entity-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unprocessable-entity-error.js","sourceRoot":"","sources":["../../src/errors/unprocessable-entity-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA,kEAA0C;AAE1C;IAAsD,4CAAY;IAChE,kCACE,OAAwC,EACxC,OAAmB,EACnB,eAA4B;QAF5B,wBAAA,EAAA,gCAAwC;QACxC,wBAAA,EAAA,YAAmB;QACnB,gCAAA,EAAA,oBAA4B;QAH9B,YAKE,kBAAM,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,eAAe,CAAC,SAE9C;QADC,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,wBAAwB,CAAC,SAAS,CAAC,CAAA;;IACjE,CAAC;IACH,+BAAC;AAAD,CAAC,AATD,CAAsD,uBAAY,GASjE"}

package/lib/errors/websocket-error.d.ts

@@ -0,0 +1,40 @@
+export default class WebsocketError extends Error {
+    isTreated: boolean;
+    code: number;
+    details?: any;
+    constructor(message: string, code?: number, details?: any);
+    getDetails(): {
+        details?: undefined;
+    } | {
+        details: any;
+    };
+    toObject(): {
+        error: boolean;
+        status: number;
+        body: {
+            details?: undefined;
+            code: number;
+            message: string;
+        } | {
+            details: any;
+            code: number;
+            message: string;
+        };
+        details?: undefined;
+        name: string;
+    } | {
+        error: boolean;
+        status: number;
+        body: {
+            details?: undefined;
+            code: number;
+            message: string;
+        } | {
+            details: any;
+            code: number;
+            message: string;
+        };
+        details: any;
+        name: string;
+    };
+}

package/lib/errors/websocket-error.js

@@ -0,0 +1,54 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var WebsocketError = (function (_super) {
+    __extends(WebsocketError, _super);
+    function WebsocketError(message, code, details) {
+        var _this = _super.call(this, message) || this;
+        _this.isTreated = true;
+        _this.message = message;
+        _this.code = code || 400;
+        _this.details = details;
+        Object.setPrototypeOf(_this, WebsocketError.prototype);
+        return _this;
+    }
+    WebsocketError.prototype.getDetails = function () {
+        if (!this.details) {
+            return {};
+        }
+        return {
+            details: this.details,
+        };
+    };
+    WebsocketError.prototype.toObject = function () {
+        return __assign(__assign({ name: this.message }, this.getDetails()), { error: true, status: this.code, body: __assign({ code: this.code, message: this.message }, this.getDetails()) });
+    };
+    return WebsocketError;
+}(Error));
+exports.default = WebsocketError;
+//# sourceMappingURL=websocket-error.js.map

package/lib/errors/websocket-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"websocket-error.js","sourceRoot":"","sources":["../../src/errors/websocket-error.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;IAA4C,kCAAK;IAK/C,wBAAa,OAAe,EAAE,IAAa,EAAE,OAAa;QAA1D,YACE,kBAAM,OAAO,CAAC,SAQf;QANC,KAAI,CAAC,SAAS,GAAG,IAAI,CAAA;QACrB,KAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QACtB,KAAI,CAAC,IAAI,GAAG,IAAI,IAAI,GAAG,CAAA;QACvB,KAAI,CAAC,OAAO,GAAG,OAAO,CAAA;QAEtB,MAAM,CAAC,cAAc,CAAC,KAAI,EAAE,cAAc,CAAC,SAAS,CAAC,CAAA;;IACvD,CAAC;IAED,mCAAU,GAAV;QACE,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;YACjB,OAAO,EAAE,CAAA;SACV;QAED,OAAO;YACL,OAAO,EAAE,IAAI,CAAC,OAAO;SACtB,CAAA;IACH,CAAC;IAED,iCAAQ,GAAR;QACE,2BACE,IAAI,EAAE,IAAI,CAAC,OAAO,IACf,IAAI,CAAC,UAAU,EAAE,KACpB,KAAK,EAAE,IAAI,EACX,MAAM,EAAE,IAAI,CAAC,IAAI,EACjB,IAAI,aACF,IAAI,EAAE,IAAI,CAAC,IAAI,EACf,OAAO,EAAE,IAAI,CAAC,OAAO,IAClB,IAAI,CAAC,UAAU,EAAE,KAEvB;IACH,CAAC;IACH,qBAAC;AAAD,CAAC,AAvCD,CAA4C,KAAK,GAuChD"}

package/lib/handlers/api-proxy.d.ts

@@ -0,0 +1,13 @@
+import { APIGatewayProxyEvent, APIGatewayProxyResult, Context } from 'aws-lambda';
+import { Options, Route } from '../models';
+export declare class LambdaApiProxyHandler {
+    readonly base: string;
+    readonly routes: Route[];
+    constructor(options?: Options);
+    addRoute(route: Route): void;
+    corsObject(event: APIGatewayProxyEvent, headers: {
+        [key: string]: string;
+    }): APIGatewayProxyResult;
+    findRoute(event: APIGatewayProxyEvent): Route | undefined;
+    handler(event: APIGatewayProxyEvent, context: Context): Promise<APIGatewayProxyResult>;
+}

package/lib/handlers/api-proxy.js

@@ -0,0 +1,257 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaApiProxyHandler = void 0;
+var api_1 = require("@opentelemetry/api");
+var core_1 = require("@opentelemetry/core");
+var semantic_conventions_1 = require("@opentelemetry/semantic-conventions");
+var otlp_1 = require("@stone-ton/otlp");
+var fintalk_logger_1 = __importDefault(require("fintalk-logger"));
+var node_match_path_1 = require("node-match-path");
+var constants_1 = require("../constants");
+var not_found_error_1 = __importDefault(require("../errors/not-found-error"));
+var check_envs_1 = __importDefault(require("../utils/check-envs"));
+var compare_ignore_case_1 = __importDefault(require("../utils/compare-ignore-case"));
+var convert_query_string_1 = __importDefault(require("../utils/convert-query-string"));
+var parse_request_1 = __importDefault(require("../utils/parse-request"));
+var provider_flush_1 = __importDefault(require("../utils/provider-flush"));
+var LambdaApiProxyHandler = (function () {
+    function LambdaApiProxyHandler(options) {
+        this.routes = [];
+        this.base = options
+            && options.base
+            && typeof options.base === 'string'
+            ? options.base.trim()
+            : '';
+    }
+    LambdaApiProxyHandler.prototype.addRoute = function (route) {
+        this.routes.push(__assign(__assign({}, route), { path: "".concat(this.base).concat(route.path) }));
+    };
+    LambdaApiProxyHandler.prototype.corsObject = function (event, headers) {
+        var route = this.routes.find(function (_a) {
+            var path = _a.path;
+            var matches = (0, node_match_path_1.match)(path, event.path).matches;
+            return matches;
+        });
+        if (!route) {
+            fintalk_logger_1.default.warn({
+                message: 'Route not found',
+                path: event.path,
+                method: event.httpMethod,
+            });
+            throw new not_found_error_1.default();
+        }
+        return {
+            headers: headers,
+            statusCode: 200,
+            body: '{}',
+        };
+    };
+    LambdaApiProxyHandler.prototype.findRoute = function (event) {
+        return this.routes.find(function (_a) {
+            var path = _a.path, method = _a.method;
+            var matches = (0, node_match_path_1.match)(path, event.path).matches;
+            return matches && (0, compare_ignore_case_1.default)(method, event.httpMethod);
+        });
+    };
+    LambdaApiProxyHandler.prototype.handler = function (event, context) {
+        return __awaiter(this, void 0, void 0, function () {
+            var activeContext;
+            var _this = this;
+            return __generator(this, function (_a) {
+                (0, check_envs_1.default)(fintalk_logger_1.default);
+                activeContext = api_1.propagation.extract(api_1.context.active(), {
+                    traceparent: event.headers.traceparent,
+                });
+                return [2, otlp_1.tracer.startActiveSpan('handler', {
+                        kind: api_1.SpanKind.SERVER,
+                        startTime: (0, core_1.hrTime)(),
+                    }, activeContext, function (span) { return __awaiter(_this, void 0, void 0, function () {
+                        var remainingTimeInMillis, timeout, spanContext, request, method, route, _a, response, error_1;
+                        var _b;
+                        var _c, _d, _e, _f, _g, _h, _j;
+                        return __generator(this, function (_k) {
+                            switch (_k.label) {
+                                case 0:
+                                    remainingTimeInMillis = context.getRemainingTimeInMillis();
+                                    timeout = setTimeout(function () {
+                                        span.setStatus({
+                                            code: api_1.SpanStatusCode.ERROR,
+                                            message: 'Detected an impending timeout',
+                                        });
+                                        span.end((0, core_1.hrTime)());
+                                        (0, provider_flush_1.default)(otlp_1.tracerProvider);
+                                    }, remainingTimeInMillis - 100);
+                                    _k.label = 1;
+                                case 1:
+                                    _k.trys.push([1, 5, 6, 8]);
+                                    spanContext = span.spanContext();
+                                    fintalk_logger_1.default.setCustomArgs({
+                                        dd: {
+                                            trace_id: spanContext.traceId,
+                                            span_id: spanContext.spanId,
+                                        },
+                                    });
+                                    request = (0, parse_request_1.default)(event, context);
+                                    span.setAttributes((_b = {},
+                                        _b[semantic_conventions_1.SemanticResourceAttributes.CLOUD_REGION] = process.env.AWS_REGION,
+                                        _b[semantic_conventions_1.SemanticResourceAttributes.CLOUD_PLATFORM] = semantic_conventions_1.CloudPlatformValues.AWS_LAMBDA,
+                                        _b['faas.version'] = process.env.AWS_EXECUTION_ENV,
+                                        _b[semantic_conventions_1.SemanticAttributes.FAAS_EXECUTION] = request.id,
+                                        _b[semantic_conventions_1.SemanticResourceAttributes.FAAS_MAX_MEMORY] = process.env.AWS_LAMBDA_FUNCTION_MEMORY_SIZE,
+                                        _b[semantic_conventions_1.SemanticResourceAttributes.FAAS_NAME] = context.functionName,
+                                        _b[semantic_conventions_1.SemanticResourceAttributes.FAAS_ID] = context.invokedFunctionArn,
+                                        _b[semantic_conventions_1.SemanticAttributes.FAAS_TRIGGER] = semantic_conventions_1.FaasTriggerValues.HTTP,
+                                        _b['client.address'] = request.ip,
+                                        _b['server.address'] = event.requestContext.domainName,
+                                        _b['server.port'] = '443',
+                                        _b['http.request.method'] = request.method,
+                                        _b['url.path'] = request.path,
+                                        _b['url.query'] = (0, convert_query_string_1.default)(request.multiValueQuery),
+                                        _b['url.scheme'] = 'https',
+                                        _b['user_agent.original'] = request.userAgent,
+                                        _b));
+                                    method = event.httpMethod.toUpperCase();
+                                    if (method === 'OPTIONS') {
+                                        return [2, this.corsObject(event, constants_1.defaultHeaders)];
+                                    }
+                                    route = this.findRoute(event);
+                                    if (!route) {
+                                        fintalk_logger_1.default.warn({
+                                            message: 'Route not found',
+                                            path: event.path,
+                                            method: method,
+                                        });
+                                        throw new not_found_error_1.default();
+                                    }
+                                    span.setAttribute('http.route', route.path);
+                                    request = (0, parse_request_1.default)(event, context, route.path);
+                                    if (!route.auth) return [3, 3];
+                                    _a = request;
+                                    return [4, route.auth(request)];
+                                case 2:
+                                    _a.auth = _k.sent();
+                                    _k.label = 3;
+                                case 3:
+                                    span.setAttributes({
+                                        user_id: (_c = request.user) === null || _c === void 0 ? void 0 : _c.id,
+                                        email: (_d = request.user) === null || _d === void 0 ? void 0 : _d.email,
+                                    });
+                                    if (process.env.OTLP_LAMBDA_DEBUG === 'true') {
+                                        span.setAttributes({
+                                            'http.request.body': JSON.stringify(request.body),
+                                            'http.request.headers': JSON.stringify(request.headers),
+                                        });
+                                    }
+                                    return [4, route.run(request, context)];
+                                case 4:
+                                    response = _k.sent();
+                                    span.setAttribute('http.response.status_code', (_f = (_e = response.statusCode) === null || _e === void 0 ? void 0 : _e.toString()) !== null && _f !== void 0 ? _f : '200');
+                                    if (process.env.OTLP_LAMBDA_DEBUG === 'true') {
+                                        span.setAttributes({
+                                            'http.response.body': JSON.stringify(response.body),
+                                            'http.response.headers': JSON.stringify(response.headers),
+                                        });
+                                    }
+                                    span.setStatus({ code: api_1.SpanStatusCode.OK });
+                                    return [2, {
+                                            headers: __assign(__assign({}, constants_1.defaultHeaders), response.headers),
+                                            multiValueHeaders: response.multiValueHeaders,
+                                            statusCode: (_g = response.statusCode) !== null && _g !== void 0 ? _g : 200,
+                                            body: JSON.stringify(response.body),
+                                        }];
+                                case 5:
+                                    error_1 = _k.sent();
+                                    span.setAttributes({
+                                        'exception.message': error_1.message,
+                                        'exception.stacktrace': error_1.trace,
+                                        'http.response.status_code': (_j = (_h = error_1.code) === null || _h === void 0 ? void 0 : _h.toString()) !== null && _j !== void 0 ? _j : '500',
+                                    });
+                                    span.setStatus({
+                                        code: api_1.SpanStatusCode.ERROR,
+                                        message: error_1.message,
+                                    });
+                                    if (error_1.isTreated) {
+                                        return [2, {
+                                                headers: constants_1.defaultHeaders,
+                                                statusCode: error_1.code,
+                                                body: JSON.stringify(error_1.toObject()),
+                                            }];
+                                    }
+                                    fintalk_logger_1.default.error(error_1);
+                                    return [2, {
+                                            headers: constants_1.defaultHeaders,
+                                            statusCode: 500,
+                                            body: JSON.stringify({
+                                                error: {
+                                                    message: 'Internal Server Error',
+                                                },
+                                            }),
+                                        }];
+                                case 6:
+                                    clearTimeout(timeout);
+                                    span.end((0, core_1.hrTime)());
+                                    return [4, (0, provider_flush_1.default)(otlp_1.tracerProvider)];
+                                case 7:
+                                    _k.sent();
+                                    return [7];
+                                case 8: return [2];
+                            }
+                        });
+                    }); })];
+            });
+        });
+    };
+    return LambdaApiProxyHandler;
+}());
+exports.LambdaApiProxyHandler = LambdaApiProxyHandler;
+//# sourceMappingURL=api-proxy.js.map