serverless-simple-middleware 0.0.59 → 0.0.60

package/dist/middleware/trace.js

@@ -1,13 +1,62 @@
-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) {
+"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) {
         this.route = route;
         this.key = key;
         this.system = system;
@@ -17,56 +66,83 @@ export class TracerLog {
         this.error = error;
         this.client = client;
         this.version = version;
-        this.uuid = uuid4();
+        this.uuid = uuid_1.v4();
         this.timestamp = Date.now();
     }
-}
-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);
+    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*/];
                 }
-                this.buffer = [];
-            }
-            catch (error) {
-                logger.warn(`Error in eventSource: ${error}`);
-            }
-        };
+            });
+        }); };
         this.queueName = queueName;
         this.sqs = sqs;
         this.buffer = [];
     }
-}
-export class TracerWrapper {
-    constructor(tracer, route, system, key, action, client, version) {
+    return Tracer;
+}());
+exports.Tracer = Tracer;
+var TracerWrapper = /** @class */ (function () {
+    function TracerWrapper(tracer, route, system, key, action, client, version) {
+        var _this = this;
         this.tracer = tracer;
         this.route = route;
         this.system = system;
@@ -74,46 +150,65 @@ export class TracerWrapper {
         this.action = action;
         this.client = client;
         this.version = 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.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.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));
+        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));
         };
     }
-}
-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,
-                    });
+    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 }];
                 }
-                $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');
+            });
+        }); };
+        _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');
                 if (fromHeader) {
                     return fromHeader;
                 }
@@ -125,8 +220,9 @@ export class TracerPlugin extends HandlerPluginBase {
                 return '';
             })();
         };
-        this.end = () => this.tracer.flush();
-        this.error = ({ request, aux }) => {
+        _this.end = function () { return _this.tracer.flush(); };
+        _this.error = function (_a) {
+            var request = _a.request, aux = _a.aux;
             if (!aux) {
                 console.warn('Aux is not initialized');
                 return;
@@ -134,23 +230,26 @@ export class TracerPlugin extends HandlerPluginBase {
             if (!request.lastError) {
                 return;
             }
-            const { key, action } = this.last;
+            var _b = _this.last, key = _b.key, action = _b.action;
             aux
                 .tracer(key, action)
                 .push('error', typeof request.lastError === 'string'
                 ? request.lastError
-                : stringifyError(request.lastError), true);
+                : utils_1.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;
     }
-}
-const build = (options) => new TracerPlugin(options);
-export default build;
+    return TracerPlugin;
+}(base_1.HandlerPluginBase));
+exports.TracerPlugin = TracerPlugin;
+var build = function (options) { return new TracerPlugin(options); };
+exports.default = build;

package/dist/utils/index.d.ts

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

package/dist/utils/index.js

@@ -1,2 +1,7 @@
-export * from './logger.js';
-export * from './misc.js';
+"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"));

package/dist/utils/logger.d.ts

@@ -8,7 +8,7 @@ export declare enum LogLevel {
     Stupid = "stupid"
 }
 export declare const currentLogLevel: LogLevel;
-type LogMessage = string | Error;
+declare 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) => Logger;
+export declare const getLogger: (fileName: string, level?: LogLevel | undefined) => Logger;
 export {};

package/dist/utils/logger.js

@@ -1,8 +1,10 @@
-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;
+"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;
 (function (LogLevel) {
     LogLevel["Error"] = "error";
     LogLevel["Warn"] = "warn";
@@ -11,8 +13,8 @@ export var LogLevel;
     LogLevel["Verbose"] = "verbose";
     LogLevel["Silly"] = "silly";
     LogLevel["Stupid"] = "stupid";
-})(LogLevel || (LogLevel = {}));
-const severity = (level) => {
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+var severity = function (level) {
     switch (level) {
         case LogLevel.Error:
             return 100;
@@ -32,34 +34,38 @@ const severity = (level) => {
             return 1000;
     }
 };
-export const currentLogLevel = $enum(LogLevel).asValueOrDefault(process.env.LOG_LEVEL, currentStage.level !== StagingLevel.Release
+exports.currentLogLevel = ts_enum_util_1.$enum(LogLevel).asValueOrDefault(process.env.LOG_LEVEL, simple_staging_1.envDefault.level !== simple_staging_1.StagingLevel.Release
     ? LogLevel.Verbose
     : LogLevel.Debug);
-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}`);
+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));
             }
             return message;
         };
-        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)}`);
+        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));
             return object;
         };
         this.name = name;
         this.severity = severity(level);
     }
-}
-const loggers = {};
-export const getLogger = (fileName, level) => {
-    const name = basename(fileName);
+    return Logger;
+}());
+exports.Logger = Logger;
+var loggers = {};
+exports.getLogger = function (fileName, level) {
+    var name = path_1.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) => string;
+export declare const stringifyError: (err: any, replacer?: ((key: string, value: any) => any) | undefined, space?: string | number | undefined) => string;

package/dist/utils/misc.js

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

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "serverless-simple-middleware",
   "description": "Simple middleware to translate the interface of lambda's handler to request => response",
-  "version": "0.0.59",
+  "version": "0.0.60",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "type": "module",
   "author": "VoyagerX",
   "license": "MIT",
   "repository": {
@@ -20,7 +19,6 @@
   "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",
@@ -31,13 +29,12 @@
     "@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": "5.3.3",
+    "typescript": "^3.0.1",
     "uuid": "^3.3.2"
   },
   "optionalDependencies": {
@@ -61,4 +58,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 './index.js';
+import { AWSComponent } from './define';
 
 export interface AWSConfig {
   [key: string]: string | boolean | number | undefined;

package/src/aws/index.ts

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

package/src/aws/simple.ts

@@ -3,16 +3,15 @@ import * as fs from 'fs';
 import * as os from 'os';
 import { nanoid } from 'nanoid/non-secure';
 
-import { getLogger } from '../utils/index.js';
-import { SimpleAWSConfig } from './config.js';
+import { getLogger, stringifyError } from '../utils';
+import { SimpleAWSConfig } from './config';
 
 import {
   AWSComponent,
   S3SignedUrlParams,
   S3SignedUrlResult,
   SQSMessageBody,
-} from './define.js';
-import { stringifyError } from '../utils/index.js';
+} from './define';
 
 const logger = getLogger(__filename);
 

package/src/index.ts

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

package/src/middleware/aws.ts

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