serverless-simple-middleware 0.0.57 → 0.0.59

package/dist/middleware/trace.js

@@ -1,62 +1,13 @@
-"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 (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    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) : new P(function (resolve) { resolve(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 (_) 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 };
-    }
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var AWS = require("aws-sdk"); // tslint:disable-line
-var uuid_1 = require("uuid");
-var aws_1 = require("../aws");
-var utils_1 = require("../utils");
-var ts_enum_util_1 = require("ts-enum-util");
-var base_1 = require("./base");
-var logger = utils_1.getLogger(__filename);
-var TracerLog = /** @class */ (function () {
-    function TracerLog(route, key, system, action, attribute, body, error, client, version) {
+import * as AWS from 'aws-sdk'; // tslint:disable-line
+import { v4 as uuid4 } from 'uuid';
+import { AWSComponent, loadAWSConfig, SimpleAWS, } from '../aws/index.js';
+import { getLogger } from '../utils/index.js';
+import { stringifyError } from '../utils/index.js';
+import { $enum } from 'ts-enum-util';
+import { HandlerPluginBase } from './base.js';
+const logger = getLogger(__filename);
+export class TracerLog {
+    constructor(route, key, system, action, attribute, body, error, client, version) {
         this.route = route;
         this.key = key;
         this.system = system;
@@ -66,83 +17,56 @@ var TracerLog = /** @class */ (function () {
         this.error = error;
         this.client = client;
         this.version = version;
-        this.uuid = uuid_1.v4();
+        this.uuid = uuid4();
         this.timestamp = Date.now();
     }
-    return TracerLog;
-}());
-exports.TracerLog = TracerLog;
-var Tracer = /** @class */ (function () {
-    function Tracer(queueName, sqs) {
-        var _this = this;
-        this.push = function (log) { return _this.buffer.push(log); };
-        this.flush = function () { return __awaiter(_this, void 0, void 0, function () {
-            var urlResult, eventQueueUrl, chunkSize, begin, end, subset, sendBatchResult, error_1;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.buffer.length === 0) {
-                            return [2 /*return*/];
-                        }
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 7, , 8]);
-                        return [4 /*yield*/, this.sqs
-                                .getQueueUrl({
-                                QueueName: this.queueName,
-                            })
-                                .promise()];
-                    case 2:
-                        urlResult = _a.sent();
-                        logger.stupid("urlResult", urlResult);
-                        if (!urlResult.QueueUrl) {
-                            throw new Error("No queue url with name[" + this.queueName + "]");
-                        }
-                        eventQueueUrl = urlResult.QueueUrl;
-                        chunkSize = 10;
-                        begin = 0;
-                        _a.label = 3;
-                    case 3:
-                        if (!(begin < this.buffer.length)) return [3 /*break*/, 6];
-                        end = Math.min(this.buffer.length, begin + chunkSize);
-                        subset = this.buffer.slice(begin, end);
-                        return [4 /*yield*/, this.sqs
-                                .sendMessageBatch({
-                                QueueUrl: eventQueueUrl,
-                                Entries: subset.map(function (each) { return ({
-                                    Id: each.key + "_" + each.uuid,
-                                    MessageBody: JSON.stringify(each),
-                                }); }),
-                            })
-                                .promise()];
-                    case 4:
-                        sendBatchResult = _a.sent();
-                        logger.stupid("sendBatchResult", sendBatchResult);
-                        _a.label = 5;
-                    case 5:
-                        begin += chunkSize;
-                        return [3 /*break*/, 3];
-                    case 6:
-                        this.buffer = [];
-                        return [3 /*break*/, 8];
-                    case 7:
-                        error_1 = _a.sent();
-                        logger.warn("Error in eventSource: " + error_1);
-                        return [3 /*break*/, 8];
-                    case 8: return [2 /*return*/];
+}
+export class Tracer {
+    constructor(queueName, sqs) {
+        this.push = (log) => this.buffer.push(log);
+        this.flush = async () => {
+            if (this.buffer.length === 0) {
+                return;
+            }
+            try {
+                const urlResult = await this.sqs
+                    .getQueueUrl({
+                    QueueName: this.queueName,
+                })
+                    .promise();
+                logger.stupid(`urlResult`, urlResult);
+                if (!urlResult.QueueUrl) {
+                    throw new Error(`No queue url with name[${this.queueName}]`);
+                }
+                const eventQueueUrl = urlResult.QueueUrl;
+                const chunkSize = 10;
+                for (let begin = 0; begin < this.buffer.length; begin += chunkSize) {
+                    const end = Math.min(this.buffer.length, begin + chunkSize);
+                    const subset = this.buffer.slice(begin, end);
+                    const sendBatchResult = await this.sqs
+                        .sendMessageBatch({
+                        QueueUrl: eventQueueUrl,
+                        Entries: subset.map(each => ({
+                            Id: `${each.key}_${each.uuid}`,
+                            MessageBody: JSON.stringify(each),
+                        })),
+                    })
+                        .promise();
+                    logger.stupid(`sendBatchResult`, sendBatchResult);
                 }
-            });
-        }); };
+                this.buffer = [];
+            }
+            catch (error) {
+                logger.warn(`Error in eventSource: ${error}`);
+            }
+        };
         this.queueName = queueName;
         this.sqs = sqs;
         this.buffer = [];
     }
-    return Tracer;
-}());
-exports.Tracer = Tracer;
-var TracerWrapper = /** @class */ (function () {
-    function TracerWrapper(tracer, route, system, key, action, client, version) {
-        var _this = this;
+}
+export class TracerWrapper {
+    constructor(tracer, route, system, key, action, client, version) {
         this.tracer = tracer;
         this.route = route;
         this.system = system;
@@ -150,65 +74,46 @@ var TracerWrapper = /** @class */ (function () {
         this.action = action;
         this.client = client;
         this.version = version;
-        this.push = function (attribute, body, error) {
-            if (error === void 0) { error = false; }
-            _this.tracer.push(new TracerLog(_this.route, _this.key, _this.system, _this.action, attribute, body, error, _this.client, _this.version));
+        this.push = (attribute, body, error = false) => {
+            this.tracer.push(new TracerLog(this.route, this.key, this.system, this.action, attribute, body, error, this.client, this.version));
         };
-        this.send = function (log) {
-            _this.tracer.push(new TracerLog(log.route || _this.route, log.key || _this.key, log.system || _this.system, log.action || _this.action, log.attribute, log.body, log.error || false, log.client || _this.client, log.version || _this.version));
+        this.send = (log) => {
+            this.tracer.push(new TracerLog(log.route || this.route, log.key || this.key, log.system || this.system, log.action || this.action, log.attribute, log.body, log.error || false, log.client || this.client, log.version || this.version));
         };
     }
-    return TracerWrapper;
-}());
-exports.TracerWrapper = TracerWrapper;
-var TracerPlugin = /** @class */ (function (_super) {
-    __extends(TracerPlugin, _super);
-    function TracerPlugin(options) {
-        var _this = _super.call(this) || this;
-        _this.create = function () { return __awaiter(_this, void 0, void 0, function () {
-            var awsConfig, _a, sqs, tracer;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        if (!this.options.awsConfig) return [3 /*break*/, 2];
-                        return [4 /*yield*/, aws_1.loadAWSConfig(this.options.awsConfig)];
-                    case 1:
-                        _a = _b.sent();
-                        return [3 /*break*/, 3];
-                    case 2:
-                        _a = undefined;
-                        _b.label = 3;
-                    case 3:
-                        awsConfig = _a;
-                        sqs = (function () {
-                            if (!awsConfig) {
-                                return new AWS.SQS({
-                                    region: _this.options.region,
-                                });
-                            }
-                            ts_enum_util_1.$enum(aws_1.AWSComponent).forEach(function (eachComponent) {
-                                var config = awsConfig.get(eachComponent);
-                                if (config) {
-                                    config.region = _this.options.region;
-                                }
-                            });
-                            return new aws_1.SimpleAWS(awsConfig).sqs;
-                        })();
-                        this.tracer = new Tracer(this.options.queueName, sqs);
-                        tracer = function (key, action) {
-                            _this.last = { key: key, action: action };
-                            return new TracerWrapper(_this.tracer, _this.options.route, _this.options.system, key, action, _this.client.agent, _this.client.version);
-                        };
-                        return [2 /*return*/, { tracer: tracer }];
+}
+export class TracerPlugin extends HandlerPluginBase {
+    constructor(options) {
+        super();
+        this.create = async () => {
+            const awsConfig = this.options.awsConfig
+                ? await loadAWSConfig(this.options.awsConfig)
+                : undefined;
+            const sqs = (() => {
+                if (!awsConfig) {
+                    return new AWS.SQS({
+                        region: this.options.region,
+                    });
                 }
-            });
-        }); };
-        _this.begin = function (_a) {
-            var request = _a.request;
-            _this.client.version = request.header('X-Version') || '0.0.0';
-            _this.client.agent = (function () {
-                var fromHeader = request.header('User-Agent');
+                $enum(AWSComponent).forEach(eachComponent => {
+                    const config = awsConfig.get(eachComponent);
+                    if (config) {
+                        config.region = this.options.region;
+                    }
+                });
+                return new SimpleAWS(awsConfig).sqs;
+            })();
+            this.tracer = new Tracer(this.options.queueName, sqs);
+            const tracer = (key, action) => {
+                this.last = { key, action };
+                return new TracerWrapper(this.tracer, this.options.route, this.options.system, key, action, this.client.agent, this.client.version);
+            };
+            return { tracer };
+        };
+        this.begin = ({ request }) => {
+            this.client.version = request.header('X-Version') || '0.0.0';
+            this.client.agent = (() => {
+                const fromHeader = request.header('User-Agent');
                 if (fromHeader) {
                     return fromHeader;
                 }
@@ -220,9 +125,8 @@ var TracerPlugin = /** @class */ (function (_super) {
                 return '';
             })();
         };
-        _this.end = function () { return _this.tracer.flush(); };
-        _this.error = function (_a) {
-            var request = _a.request, aux = _a.aux;
+        this.end = () => this.tracer.flush();
+        this.error = ({ request, aux }) => {
             if (!aux) {
                 console.warn('Aux is not initialized');
                 return;
@@ -230,26 +134,23 @@ var TracerPlugin = /** @class */ (function (_super) {
             if (!request.lastError) {
                 return;
             }
-            var _b = _this.last, key = _b.key, action = _b.action;
+            const { key, action } = this.last;
             aux
                 .tracer(key, action)
                 .push('error', typeof request.lastError === 'string'
                 ? request.lastError
-                : utils_1.stringifyError(request.lastError), true);
+                : stringifyError(request.lastError), true);
         };
-        _this.options = options;
-        _this.last = {
+        this.options = options;
+        this.last = {
             key: 'nothing',
             action: 'unknown',
         };
-        _this.client = {
+        this.client = {
             agent: '',
             version: '',
         };
-        return _this;
     }
-    return TracerPlugin;
-}(base_1.HandlerPluginBase));
-exports.TracerPlugin = TracerPlugin;
-var build = function (options) { return new TracerPlugin(options); };
-exports.default = build;
+}
+const build = (options) => new TracerPlugin(options);
+export default build;

package/dist/utils/index.d.ts

@@ -1,2 +1,2 @@
-export * from './logger';
-export * from './misc';
+export * from './logger.js';
+export * from './misc.js';

package/dist/utils/index.js

@@ -1,7 +1,2 @@
-"use strict";
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(require("./logger"));
-__export(require("./misc"));
+export * from './logger.js';
+export * from './misc.js';

package/dist/utils/logger.d.ts

@@ -8,7 +8,7 @@ export declare enum LogLevel {
     Stupid = "stupid"
 }
 export declare const currentLogLevel: LogLevel;
-declare type LogMessage = string | Error;
+type LogMessage = string | Error;
 export declare class Logger {
     private name;
     private severity;
@@ -22,5 +22,5 @@ export declare class Logger {
     silly: (message: LogMessage) => LogMessage;
     stupid: <T>(message: string, object: T, replacer?: ((key: string, value: T) => T) | undefined) => T;
 }
-export declare const getLogger: (fileName: string, level?: LogLevel | undefined) => Logger;
+export declare const getLogger: (fileName: string, level?: LogLevel) => Logger;
 export {};

package/dist/utils/logger.js

@@ -1,10 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-var path_1 = require("path");
-var simple_staging_1 = require("simple-staging");
-var ts_enum_util_1 = require("ts-enum-util");
-var misc_1 = require("./misc");
-var LogLevel;
+import { basename } from 'path';
+import { envDefault as currentStage, StagingLevel } from 'simple-staging';
+import { $enum } from 'ts-enum-util';
+import { stringifyError } from './misc.js';
+export var LogLevel;
 (function (LogLevel) {
     LogLevel["Error"] = "error";
     LogLevel["Warn"] = "warn";
@@ -13,8 +11,8 @@ var LogLevel;
     LogLevel["Verbose"] = "verbose";
     LogLevel["Silly"] = "silly";
     LogLevel["Stupid"] = "stupid";
-})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
-var severity = function (level) {
+})(LogLevel || (LogLevel = {}));
+const severity = (level) => {
     switch (level) {
         case LogLevel.Error:
             return 100;
@@ -34,38 +32,34 @@ var severity = function (level) {
             return 1000;
     }
 };
-exports.currentLogLevel = ts_enum_util_1.$enum(LogLevel).asValueOrDefault(process.env.LOG_LEVEL, simple_staging_1.envDefault.level !== simple_staging_1.StagingLevel.Release
+export const currentLogLevel = $enum(LogLevel).asValueOrDefault(process.env.LOG_LEVEL, currentStage.level !== StagingLevel.Release
     ? LogLevel.Verbose
     : LogLevel.Debug);
-var Logger = /** @class */ (function () {
-    function Logger(name, level) {
-        var _this = this;
-        if (level === void 0) { level = exports.currentLogLevel; }
-        this.log = function (level, message) {
-            if (_this.severity >= severity(level)) {
-                console.log("[" + new Date().toISOString() + "][" + level.toUpperCase() + "][" + _this.name + "] " + (message instanceof Error ? misc_1.stringifyError(message) : message));
+export class Logger {
+    constructor(name, level = currentLogLevel) {
+        this.log = (level, message) => {
+            if (this.severity >= severity(level)) {
+                console.log(`[${new Date().toISOString()}][${level.toUpperCase()}][${this.name}] ${message instanceof Error ? stringifyError(message) : message}`);
             }
             return message;
         };
-        this.error = function (message) { return _this.log(LogLevel.Error, message); };
-        this.warn = function (message) { return _this.log(LogLevel.Warn, message); };
-        this.info = function (message) { return _this.log(LogLevel.Info, message); };
-        this.debug = function (message) { return _this.log(LogLevel.Debug, message); };
-        this.verbose = function (message) { return _this.log(LogLevel.Verbose, message); };
-        this.silly = function (message) { return _this.log(LogLevel.Silly, message); };
-        this.stupid = function (message, object, replacer) {
-            _this.log(LogLevel.Stupid, message + ": " + JSON.stringify(object, replacer));
+        this.error = (message) => this.log(LogLevel.Error, message);
+        this.warn = (message) => this.log(LogLevel.Warn, message);
+        this.info = (message) => this.log(LogLevel.Info, message);
+        this.debug = (message) => this.log(LogLevel.Debug, message);
+        this.verbose = (message) => this.log(LogLevel.Verbose, message);
+        this.silly = (message) => this.log(LogLevel.Silly, message);
+        this.stupid = (message, object, replacer) => {
+            this.log(LogLevel.Stupid, `${message}: ${JSON.stringify(object, replacer)}`);
             return object;
         };
         this.name = name;
         this.severity = severity(level);
     }
-    return Logger;
-}());
-exports.Logger = Logger;
-var loggers = {};
-exports.getLogger = function (fileName, level) {
-    var name = path_1.basename(fileName);
+}
+const loggers = {};
+export const getLogger = (fileName, level) => {
+    const name = basename(fileName);
     if (loggers[name] === undefined) {
         loggers[name] = new Logger(name, level);
     }

package/dist/utils/misc.d.ts

@@ -1 +1 @@
-export declare const stringifyError: (err: any, replacer?: ((key: string, value: any) => any) | undefined, space?: string | number | undefined) => string;
+export declare const stringifyError: (err: any, replacer?: ((key: string, value: any) => any) | undefined, space?: string | number) => string;

package/dist/utils/misc.js

@@ -1,8 +1,6 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.stringifyError = function (err, replacer, space) {
-    var plainObject = {};
-    Object.getOwnPropertyNames(err).forEach(function (key) {
+export const stringifyError = (err, replacer, space) => {
+    const plainObject = {};
+    Object.getOwnPropertyNames(err).forEach(key => {
         plainObject[key] = err[key];
     });
     return JSON.stringify(plainObject, replacer, space);

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "serverless-simple-middleware",
   "description": "Simple middleware to translate the interface of lambda's handler to request => response",
-  "version": "0.0.57",
+  "version": "0.0.59",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "type": "module",
   "author": "VoyagerX",
   "license": "MIT",
   "repository": {
@@ -19,6 +20,7 @@
   "homepage": "https://github.com/v6x/serverless-simple-middleware#readme",
   "scripts": {
     "lint": "tslint --project tsconfig.json",
+    "clean": "rm -rf node_modules && yarn",
     "build": "tsc --project tsconfig.json",
     "build:watch": "tsc --project tsconfig.json --watch",
     "test": "jest --config jest.config.js",
@@ -29,12 +31,13 @@
     "@types/aws-lambda": "8",
     "@types/mysql": "^2.15.5",
     "cross-fetch": "^2.2.2",
+    "kysely": "^0.27.6",
     "mysql": "^2.16.0",
     "nanoid": "4.0.2",
     "p-limit": "^2.0.0",
     "simple-staging": "^0.0.12",
     "ts-enum-util": "^3.1.0",
-    "typescript": "^3.0.1",
+    "typescript": "5.3.3",
     "uuid": "^3.3.2"
   },
   "optionalDependencies": {
@@ -58,4 +61,4 @@
     "singleQuote": true,
     "trailingComma": "all"
   }
-}
+}

package/src/aws/config.ts

@@ -1,7 +1,7 @@
 import fetch from 'cross-fetch';
 import * as fs from 'fs';
 
-import { AWSComponent } from './define';
+import { AWSComponent } from './index.js';
 
 export interface AWSConfig {
   [key: string]: string | boolean | number | undefined;

package/src/aws/index.ts

@@ -1,3 +1,3 @@
-export * from './define';
-export * from './config';
-export * from './simple';
+export * from './define.js';
+export * from './config.js';
+export * from './simple.js';

package/src/aws/simple.ts

@@ -3,15 +3,16 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { nanoid } from 'nanoid/non-secure';
 
-import { getLogger, stringifyError } from '../utils';
-import { SimpleAWSConfig } from './config';
+import { getLogger } from '../utils/index.js';
+import { SimpleAWSConfig } from './config.js';
 
 import {
   AWSComponent,
   S3SignedUrlParams,
   S3SignedUrlResult,
   SQSMessageBody,
-} from './define';
+} from './define.js';
+import { stringifyError } from '../utils/index.js';
 
 const logger = getLogger(__filename);
 
@@ -313,6 +314,23 @@ export class SimpleAWS {
     return key;
   };
 
+  public uploadFromBuffer = async (
+    bucket: string,
+    key: string,
+    buffer: Buffer,
+  ): Promise<string> => {
+    logger.debug(`Upload item[${key}] into bucket[${bucket}]`);
+    const putResult = await this.s3
+      .upload({
+        Bucket: bucket,
+        Key: key,
+        Body: buffer,
+      })
+      .promise();
+    logger.stupid(`putResult`, putResult);
+    return key;
+  };
+
   public writeFile = async (
     bucket: string,
     key: string,

package/src/index.ts

@@ -1,3 +1,3 @@
-export * from './aws';
-export * from './middleware';
-export * from './utils';
+export * from './aws/index.js';
+export * from './middleware/index.js';
+export * from './utils/index.js';

package/src/middleware/aws.ts

@@ -3,9 +3,9 @@ import {
   SimpleAWS,
   SimpleAWSConfig,
   SimpleAWSConfigLoadParam,
-} from '../aws';
-import { getLogger } from '../utils';
-import { HandlerAuxBase, HandlerPluginBase } from './base';
+} from '../aws/index.js';
+import { getLogger } from '../utils/index.js';
+import { HandlerAuxBase, HandlerPluginBase } from './base.js';
 
 const logger = getLogger(__filename);
 

package/src/middleware/base.ts

@@ -1,5 +1,5 @@
 import * as awsTypes from 'aws-lambda'; // tslint:disable-line:no-implicit-dependencies
-import { getLogger } from '../utils/logger';
+import { getLogger } from '../utils/index.js';
 
 const logger = getLogger(__filename);
 
@@ -8,7 +8,7 @@ export interface RequestAuxBase {
 }
 
 export class HandlerRequest {
-  public event: awsTypes.APIGatewayEvent;
+  public event: awsTypes.APIGatewayProxyEvent;
   public context: awsTypes.APIGatewayEventRequestContext;
   public lastError: Error | string | undefined;
 
@@ -30,11 +30,11 @@ export class HandlerRequest {
     return this.lazyBody || {};
   }
 
-  get path(): { [key: string]: string } {
+  get path(): { [key: string]: string | undefined } {
     return this.event.pathParameters || {};
   }
 
-  get query(): { [key: string]: string } {
+  get query(): { [key: string]: string | undefined } {
     return this.event.queryStringParameters || {};
   }