@tsed/platform-serverless 6.88.1 → 6.92.0

package/lib/index-a6c91998.js

@@ -1,955 +0,0 @@
-import { Inject, InjectorService, LazyInject, Injectable, ProviderScope, DIContext, createContainer, setLoggerLevel, DITest } from '@tsed/di';
-import { getStatusMessage, getOperationsRoutes, JsonEntityStore } from '@tsed/schema';
-import { PlatformParams, DeserializerPipe, ValidationPipe } from '@tsed/platform-params';
-import { __decorate, __metadata } from 'tslib';
-import { AnyToPromise, isSerializable, getValue, Env } from '@tsed/core';
-import { serialize } from '@tsed/json-mapper';
-import { $log } from '@tsed/logger';
-import encodeUrl from 'encodeurl';
-import * as mime from 'mime';
-import { v4 } from 'uuid';
-
-function _extends() {
-  _extends = Object.assign || function (target) {
-    for (var i = 1; i < arguments.length; i++) {
-      var source = arguments[i];
-
-      for (var key in source) {
-        if (Object.prototype.hasOwnProperty.call(source, key)) {
-          target[key] = source[key];
-        }
-      }
-    }
-
-    return target;
-  };
-
-  return _extends.apply(this, arguments);
-}
-
-function _objectWithoutPropertiesLoose(source, excluded) {
-  if (source == null) return {};
-  var target = {};
-  var sourceKeys = Object.keys(source);
-  var key, i;
-
-  for (i = 0; i < sourceKeys.length; i++) {
-    key = sourceKeys[i];
-    if (excluded.indexOf(key) >= 0) continue;
-    target[key] = source[key];
-  }
-
-  return target;
-}
-
-var id = 0;
-
-function _classPrivateFieldLooseKey(name) {
-  return "__private_" + id++ + "_" + name;
-}
-
-function _classPrivateFieldLooseBase(receiver, privateKey) {
-  if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) {
-    throw new TypeError("attempted to use private field on non-instance");
-  }
-
-  return receiver;
-}
-
-function mergeHeaders(specHeaders, headers) {
-  return Object.entries(specHeaders).reduce((headers, [key, item]) => {
-    key = key.toLowerCase();
-    return _extends({}, headers, {
-      [key]: headers[key] === undefined ? String(item.example) : headers[key]
-    });
-  }, headers);
-}
-/**
- * @ignore
- */
-
-
-function setResponseHeaders(ctx) {
-  const {
-    response,
-    endpoint
-  } = ctx;
-  const operation = endpoint.operation;
-
-  if (response.isDone()) {
-    return;
-  }
-
-  if (!response.hasStatus()) {
-    // apply status only if the isn't already modified
-    response.status(operation.getStatus());
-  }
-
-  const statusCode = response.statusCode;
-  const headers = operation.getHeadersOf(response.statusCode);
-  const mergedHeaders = mergeHeaders(headers, response.getHeaders());
-  response.setHeaders(mergedHeaders);
-
-  if (operation.isRedirection(statusCode)) {
-    response.redirect(statusCode, String(mergedHeaders["location"]));
-  }
-}
-
-let PlatformServerlessHandler = class PlatformServerlessHandler {
-  createHandler(token, propertyKey) {
-    var _this = this;
-
-    const promisedHandler = this.params.compileHandler({
-      token,
-      propertyKey
-    });
-    return async function ($ctx) {
-      await _this.injector.emit("$onRequest", $ctx);
-      await _this.injector.runInContext($ctx, async function () {
-        try {
-          const resolver = new AnyToPromise();
-          const handler = await promisedHandler;
-          const result = await resolver.call(() => handler({
-            $ctx
-          }));
-
-          _this.processResult(result, $ctx);
-        } catch (er) {
-          $ctx.response.status(500).body(er);
-          const exceptions = await _this.exceptionsManager;
-          await exceptions.catch(er, $ctx);
-        }
-      });
-      await _this.injector.emit("$onResponse", $ctx);
-      return _this.flush($ctx);
-    };
-  }
-
-  flush($ctx) {
-    setResponseHeaders($ctx);
-    let body = $ctx.response.getBody();
-
-    if (isSerializable(body)) {
-      $ctx.response.set("content-type", "application/json");
-      body = JSON.stringify(body);
-    }
-
-    const response = {
-      statusCode: $ctx.response.getStatus(),
-      body: body === undefined ? "" : body,
-      headers: _extends({}, $ctx.response.getHeaders(), {
-        "x-request-id": $ctx.id
-      }),
-      isBase64Encoded: false
-    };
-    $ctx.destroy();
-    return response;
-  }
-
-  processResult({
-    status,
-    headers,
-    data
-  }, $ctx) {
-    if (status) {
-      $ctx.response.status(status);
-    }
-
-    if (headers) {
-      $ctx.response.setHeaders(headers);
-    }
-
-    if (data !== undefined) {
-      data = $ctx.response.getStatus() !== 204 ? data : "";
-
-      if (isSerializable(data)) {
-        data = serialize(data, _extends({}, $ctx.endpoint.getResponseOptions($ctx.response.getStatus()), {
-          useAlias: true,
-          endpoint: true
-        }));
-      }
-
-      $ctx.response.body(data);
-    }
-  }
-
-};
-
-__decorate([Inject(), __metadata("design:type", InjectorService)], PlatformServerlessHandler.prototype, "injector", void 0);
-
-__decorate([Inject(), __metadata("design:type", PlatformParams)], PlatformServerlessHandler.prototype, "params", void 0);
-
-__decorate([LazyInject("PlatformExceptions", () => import('@tsed/platform-exceptions')), __metadata("design:type", Promise)], PlatformServerlessHandler.prototype, "exceptionsManager", void 0);
-
-PlatformServerlessHandler = __decorate([Injectable({
-  scope: ProviderScope.SINGLETON,
-  imports: [DeserializerPipe, ValidationPipe]
-})], PlatformServerlessHandler);
-
-/**
- * @platform
- */
-
-class ServerlessRequest {
-  constructor({
-    event
-  }) {
-    this.raw = event;
-  }
-
-  get secure() {
-    return true;
-  }
-
-  get host() {
-    return this.get("host");
-  }
-
-  get protocol() {
-    return "https";
-  }
-  /**
-   * Get the url of the request.
-   *
-   * Is equivalent of `express.response.originalUrl || express.response.url`.
-   */
-
-
-  get url() {
-    return this.raw.path;
-  }
-
-  get headers() {
-    return this.raw.headers;
-  }
-
-  get method() {
-    return this.raw.httpMethod;
-  }
-  /**
-   * Contains key-value pairs of data submitted in the request body. By default, it is `undefined`, and is populated when you use
-   * `body-parsing` middleware such as `express.json()` or `express.urlencoded()`.
-   */
-
-
-  get body() {
-    try {
-      return this.raw.body ? JSON.parse(this.raw.body) : {};
-    } catch (er) {
-      return this.raw.body;
-    }
-  }
-
-  get rawBody() {
-    return this.raw.body;
-  }
-  /**
-   * This property is an object containing properties mapped to the named route `parameters`.
-   * For example, if you have the route `/user/:name`, then the `name` property is available as `req.params.name`.
-   * This object defaults to `{}`.
-   */
-
-
-  get params() {
-    return this.raw.pathParameters || {};
-  }
-  /**
-   * This property is an object containing a property for each query string parameter in the route.
-   * When query parser is set to disabled, it is an empty object `{}`, otherwise it is the result of the configured query parser.
-   */
-
-
-  get query() {
-    return this.raw.queryStringParameters || {};
-  }
-  /**
-   * Returns the HTTP request header specified by field. The match is case-insensitive.
-   *
-   * ```typescript
-   * request.get('Content-Type') // => "text/plain"
-   * ```
-   *
-   * @param name
-   */
-
-
-  get(name) {
-    return getValue(this.raw.headers, name);
-  }
-
-  destroy() {}
-
-}
-
-/**
- * @platform
- */
-
-var _status = /*#__PURE__*/_classPrivateFieldLooseKey("status");
-
-var _body = /*#__PURE__*/_classPrivateFieldLooseKey("body");
-
-var _headers = /*#__PURE__*/_classPrivateFieldLooseKey("headers");
-
-var _locals = /*#__PURE__*/_classPrivateFieldLooseKey("locals");
-
-var _isHeadersSent = /*#__PURE__*/_classPrivateFieldLooseKey("isHeadersSent");
-
-var _endListeners = /*#__PURE__*/_classPrivateFieldLooseKey("endListeners");
-
-class ServerlessResponse {
-  constructor({
-    event,
-    request
-  }) {
-    Object.defineProperty(this, _status, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _body, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _headers, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _locals, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _isHeadersSent, {
-      writable: true,
-      value: void 0
-    });
-    Object.defineProperty(this, _endListeners, {
-      writable: true,
-      value: void 0
-    });
-    _classPrivateFieldLooseBase(this, _status)[_status] = 200;
-    _classPrivateFieldLooseBase(this, _body)[_body] = undefined;
-    _classPrivateFieldLooseBase(this, _headers)[_headers] = {};
-    _classPrivateFieldLooseBase(this, _locals)[_locals] = {};
-    _classPrivateFieldLooseBase(this, _isHeadersSent)[_isHeadersSent] = false;
-    _classPrivateFieldLooseBase(this, _endListeners)[_endListeners] = [];
-    this.event = event;
-    this.request = request;
-  }
-
-  /**
-   * Get the current statusCode
-   */
-  get statusCode() {
-    return _classPrivateFieldLooseBase(this, _status)[_status];
-  }
-
-  set statusCode(status) {
-    _classPrivateFieldLooseBase(this, _status)[_status] = status;
-  }
-  /**
-   * An object that contains response local variables scoped to the request, and therefore available only to the view(s) rendered during that request / response cycle (if any). Otherwise, this property is identical to app.locals.
-   *
-   * This property is useful for exposing request-level information such as the request path name, authenticated user, user settings, and so on.
-   */
-
-
-  get locals() {
-    return _classPrivateFieldLooseBase(this, _locals)[_locals];
-  }
-
-  get isHeadersSent() {
-    return _classPrivateFieldLooseBase(this, _isHeadersSent)[_isHeadersSent];
-  }
-
-  getStatus() {
-    return _classPrivateFieldLooseBase(this, _status)[_status];
-  }
-  /**
-   * Sets the HTTP status for the response.
-   *
-   * @param status
-   */
-
-
-  status(status) {
-    _classPrivateFieldLooseBase(this, _status)[_status] = status;
-    return this;
-  }
-
-  set(name, value) {
-    return this.setHeader(name, value);
-  }
-  /**
-   * Returns the HTTP response header specified by field. The match is case-insensitive.
-   *
-   * ```typescript
-   * response.get('Content-Type') // => "text/plain"
-   * ```
-   *
-   * @param name
-   */
-
-
-  get(name) {
-    return getValue(_classPrivateFieldLooseBase(this, _headers)[_headers], name.toLowerCase());
-  }
-
-  getHeaders() {
-    return _extends({}, _classPrivateFieldLooseBase(this, _headers)[_headers]);
-  }
-
-  hasStatus() {
-    return _classPrivateFieldLooseBase(this, _status)[_status] !== 200;
-  }
-  /**
-   * Set header `field` to `val`, or pass
-   * an object of header fields.
-   *
-   * Examples:
-   * ```typescript
-   * response.setHeaders({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
-   * ```
-   *
-   * Aliased as `res.header()`.
-   */
-
-
-  setHeaders(headers) {
-    // apply headers
-    Object.entries(headers).forEach(([key, item]) => {
-      this.setHeader(key, item);
-    });
-    return this;
-  }
-
-  setHeader(key, item) {
-    if (item !== null && item !== undefined) {
-      key = key.toLowerCase();
-
-      if (key === "location") {
-        // "back" is an alias for the referrer
-        if (item === "back") {
-          item = this.request.get("Referrer") || "/";
-        }
-
-        item = encodeUrl(String(item));
-      }
-
-      _classPrivateFieldLooseBase(this, _headers)[_headers] = _extends({}, _classPrivateFieldLooseBase(this, _headers)[_headers], {
-        [key.toLowerCase()]: item
-      });
-    }
-
-    return this;
-  }
-  /**
-   * Set `Content-Type` response header with `type` through `mime.lookup()`
-   * when it does not contain "/", or set the Content-Type to `type` otherwise.
-   *
-   * Examples:
-   *
-   *     res.type('.html');
-   *     res.type('html');
-   *     res.type('json');
-   *     res.type('application/json');
-   *     res.type('png');
-   */
-
-
-  contentType(contentType) {
-    this.setHeader("Content-Type", mime.getType(contentType));
-    return this;
-  }
-
-  contentLength(length) {
-    this.setHeader("Content-Length", length);
-    return this;
-  }
-
-  getContentLength() {
-    if (this.get("Content-Length")) {
-      return parseInt(this.get("Content-Length"), 10) || 0;
-    }
-  }
-
-  getContentType() {
-    return String(this.get("Content-Type") || "").split(";")[0];
-  }
-  /**
-   * Redirects to the URL derived from the specified path, with specified status, a positive integer that corresponds to an [HTTP status code](http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html).
-   * If not specified, status defaults to `302 Found`.
-   *
-   * @param status
-   * @param url
-   */
-
-
-  redirect(status, url) {
-    // Set location header
-    const address = this.location(url).get("Location");
-    const body = `${getStatusMessage(status)}. Redirecting to ${address}`;
-    this.status(status).set("Content-Length", Buffer.byteLength(body)).body(body);
-    return this;
-  }
-  /**
-   * Sets the response Location HTTP header to the specified path parameter.
-   *
-   * @param url
-   */
-
-
-  location(url) {
-    return this.set("Location", url);
-  }
-  /**
-   * Send any data to your consumer.
-   *
-   * This method accept a ReadableStream, a plain object, boolean, string, number, null and undefined data.
-   * It choose the better way to send the data.
-   *
-   * @param body
-   */
-
-
-  body(body) {
-    _classPrivateFieldLooseBase(this, _body)[_body] = body;
-    return this;
-  }
-
-  getBody() {
-    return _classPrivateFieldLooseBase(this, _body)[_body];
-  }
-
-  isDone() {
-    return _classPrivateFieldLooseBase(this, _isHeadersSent)[_isHeadersSent];
-  }
-
-  onEnd(cb) {
-    _classPrivateFieldLooseBase(this, _endListeners)[_endListeners].push(cb);
-
-    return this;
-  }
-
-  destroy() {
-    _classPrivateFieldLooseBase(this, _endListeners)[_endListeners].forEach(cb => cb());
-
-    _classPrivateFieldLooseBase(this, _isHeadersSent)[_isHeadersSent] = true;
-  }
-
-}
-
-const _excluded = ["event", "context", "endpoint"];
-class ServerlessContext extends DIContext {
-  constructor(_ref) {
-    let {
-      event,
-      context,
-      endpoint
-    } = _ref,
-        options = _objectWithoutPropertiesLoose(_ref, _excluded);
-
-    super(_extends({}, options, {
-      maxStackSize: 0
-    }));
-    this.context = context;
-    this.event = event;
-    this.request = new ServerlessRequest({
-      event,
-      context
-    });
-    this.response = new ServerlessResponse({
-      event,
-      context,
-      request: this.request
-    });
-    this.endpoint = endpoint;
-  }
-
-  async destroy() {
-    await super.destroy();
-    this.request.destroy();
-    this.response.destroy();
-  }
-
-}
-
-function getRequestId(event, context) {
-  var _event$requestContext;
-
-  if (event != null && event.headers && event.headers["x-request-id"]) {
-    return event.headers["x-request-id"];
-  }
-
-  return (event == null ? void 0 : (_event$requestContext = event.requestContext) == null ? void 0 : _event$requestContext.requestId) || (context == null ? void 0 : context.awsRequestId) || v4().replace(/-/gi, "");
-}
-
-/**
- * @platform
- */
-
-class PlatformServerless {
-  constructor() {
-    this.name = "PlatformServerless";
-  }
-
-  get injector() {
-    return this._injector;
-  }
-
-  get settings() {
-    return this.injector.settings;
-  }
-
-  get promise() {
-    return this._promise;
-  }
-
-  static bootstrap(settings = {}) {
-    const platform = new PlatformServerless();
-    platform.createInjector(settings);
-    return platform;
-  }
-
-  handler() {
-    var _this = this;
-
-    return async function (event, context) {
-      const [router] = await Promise.all([_this.initRouter(), _this.init()]);
-      const result = router.find(event.httpMethod, event.path);
-
-      if (result) {
-        const {
-          handler,
-          params
-        } = result;
-        event.pathParameters = _extends({}, event.pathParameters || {}, params);
-        return handler(event, context);
-      }
-
-      return {
-        statusCode: 404,
-        body: "Not found",
-        headers: {
-          "x-request-id": getRequestId(event, context)
-        },
-        isBase64Encoded: false
-      };
-    };
-  }
-
-  callbacks(tokens = [], callbacks = {}) {
-    return this.settings.get("lambda", []).concat(tokens).reduce((callbacks, token) => {
-      const routes = getOperationsRoutes(token);
-      return routes.reduce((callbacks, operationRoute) => {
-        var _this$_router;
-
-        const {
-          operationId,
-          token,
-          propertyName,
-          method,
-          url
-        } = operationRoute; // istanbul ignore next
-
-        if (method === "USE") {
-          return callbacks;
-        }
-
-        const callback = this.callback(token, propertyName);
-        (_this$_router = this._router) == null ? void 0 : _this$_router.on(method, url, callback);
-        return _extends({}, callbacks, {
-          [operationId]: callback
-        });
-      }, callbacks);
-    }, callbacks);
-  }
-
-  async ready() {
-    await this.injector.emit("$onReady");
-  }
-
-  async stop() {
-    await this.injector.emit("$onDestroy");
-    return this.injector.destroy();
-  }
-
-  async init() {
-    if (!this._promise) {
-      this._promise = this.loadInjector().then(() => this.ready());
-    }
-
-    return this._promise;
-  }
-
-  callback(token, propertyKey) {
-    var _this2 = this;
-
-    const entity = JsonEntityStore.fromMethod(token, propertyKey);
-    let handler;
-    return async function (event, context) {
-      await _this2.init();
-
-      if (!handler) {
-        const platformHandler = _this2.injector.get(PlatformServerlessHandler);
-
-        handler = await platformHandler.createHandler(token, propertyKey);
-      }
-
-      const $ctx = new ServerlessContext({
-        event,
-        context,
-        id: getRequestId(event, context),
-        logger: _this2.injector.logger,
-        injector: _this2.injector,
-        endpoint: entity
-      });
-      return handler($ctx);
-    };
-  }
-
-  async initRouter() {
-    if (!this._router) {
-      const {
-        default: FindMyMay
-      } = await import('./index-b255dcf0.js').then(function (n) { return n.i; });
-      this._router = FindMyMay({
-        caseSensitive: false,
-        ignoreTrailingSlash: true
-      });
-      this.callbacks();
-    }
-
-    return this._router;
-  }
-
-  createInjector(settings) {
-    var _settings$logger;
-
-    this._injector = new InjectorService();
-    this.injector.logger = $log;
-    this.injector.settings.set(settings); // istanbul ignore next
-
-    if (this.injector.settings.get("env") === Env.TEST && !(settings != null && (_settings$logger = settings.logger) != null && _settings$logger.level)) {
-      $log.stop();
-    }
-
-    return this;
-  }
-
-  async loadInjector() {
-    const container = createContainer();
-    setLoggerLevel(this.injector);
-    await this.injector.emit("$beforeInit");
-    await this.injector.load(container);
-    await this.injector.emit("$afterInit");
-  }
-
-}
-
-class LambdaClientRequest extends Promise {
-  constructor() {
-    super(...arguments);
-    this.event = LambdaClientRequest.createFakeEvent();
-    this.context = LambdaClientRequest.createFakeContext();
-  }
-
-  static call(lambdaName) {
-    const resolvers = {};
-    const promise = new LambdaClientRequest((resolve, reject) => {
-      resolvers.resolve = resolve;
-      resolvers.reject = reject;
-    });
-    promise.init(lambdaName, resolvers.resolve, resolvers.reject);
-    return promise;
-  }
-
-  static get(path, options = {}) {
-    return this.call("handler").get(path, options);
-  }
-
-  static post(path, body, options = {}) {
-    return this.call("handler").post(path, body, options);
-  }
-
-  static put(path, body, options = {}) {
-    return this.call("handler").put(path, body, options);
-  }
-
-  static patch(path, body, options = {}) {
-    return this.call("handler").patch(path, body, options);
-  }
-
-  static delete(path, body, options = {}) {
-    return this.call("handler").delete(path, body, options);
-  }
-
-  static createFakeEvent(event = {}) {
-    return _extends({
-      body: "",
-      headers: {},
-      httpMethod: "",
-      isBase64Encoded: false,
-      multiValueHeaders: {},
-      multiValueQueryStringParameters: {},
-      path: event.path || "/",
-      pathParameters: {},
-      queryStringParameters: {},
-      resource: "",
-      stageVariables: {}
-    }, event, {
-      requestContext: _extends({}, event == null ? void 0 : event.requestContext, {
-        accountId: "",
-        apiId: "",
-        protocol: "https",
-        httpMethod: "",
-        identity: {},
-        path: event.path || "/",
-        stage: "",
-        requestId: "requestId",
-        requestTimeEpoch: 0,
-        resourceId: 1,
-        resourcePath: event.path || "/"
-      })
-    });
-  }
-
-  static createFakeContext(context) {
-    return _extends({
-      awsRequestId: "awsRequestId",
-      callbackWaitsForEmptyEventLoop: false,
-      functionName: "",
-      functionVersion: "",
-      invokedFunctionArn: "",
-      logGroupName: "",
-      logStreamName: "",
-      memoryLimitInMB: ""
-    }, context || {});
-  }
-
-  get(path, options = {}) {
-    Object.assign(this.event, options);
-    this.event.path = path;
-    this.event.httpMethod = "GET";
-    return this;
-  }
-
-  post(path, body = {}, options = {}) {
-    Object.assign(this.event, options);
-    this.event.path = path;
-    this.event.httpMethod = "POST";
-    this.body(body);
-    return this;
-  }
-
-  patch(path, body = {}, options = {}) {
-    Object.assign(this.event, options);
-    this.event.path = path;
-    this.event.httpMethod = "PATCH";
-    this.body(body);
-    return this;
-  }
-
-  put(path, body = {}, options = {}) {
-    Object.assign(this.event, options);
-    this.event.path = path;
-    this.event.httpMethod = "PUT";
-    this.body(body);
-    return this;
-  }
-
-  delete(path, body = {}, options = {}) {
-    Object.assign(this.event, options);
-    this.event.path = path;
-    this.event.httpMethod = "DELETE";
-    this.body(body);
-    return this;
-  }
-
-  query(query) {
-    this.event.queryStringParameters = _extends({}, this.event.queryStringParameters, JSON.parse(JSON.stringify(query)));
-    return this;
-  }
-
-  params(pathParameters) {
-    this.event.pathParameters = _extends({}, this.event.pathParameters, JSON.parse(JSON.stringify(pathParameters)));
-    return this;
-  }
-
-  headers(headers) {
-    this.event.headers = _extends({}, this.event.headers, JSON.parse(JSON.stringify(headers)));
-    return this;
-  }
-
-  body(body) {
-    if (body !== undefined) {
-      this.event.headers["content-type"] = "application/json";
-      this.event.body = JSON.stringify(body);
-    }
-
-    return this;
-  }
-
-  init(lambda, resolve, reject) {
-    var _this = this;
-
-    setTimeout(async function () {
-      try {
-        const result = await PlatformServerlessTest.callbacks[lambda](_this.event, _this.context, resolve);
-        resolve(result);
-      } catch (er) {
-        reject(er);
-      }
-    });
-  }
-
-}
-class PlatformServerlessTest extends DITest {
-  static bootstrap(settings = {}) {
-    return async function before() {
-      // @ts-ignore
-      const instance = PlatformServerless.bootstrap(DITest.configure(settings));
-      PlatformServerlessTest.instance = instance;
-      PlatformServerlessTest.callbacks = instance.callbacks();
-      PlatformServerlessTest.callbacks.handler = instance.handler(); // used by inject method
-
-      DITest.injector = instance.injector;
-      return instance.promise;
-    };
-  }
-  /**
-   * Resets the test injector of the test context, so it won't pollute your next test. Call this in your `tearDown` logic.
-   */
-
-
-  static async reset() {
-    if (PlatformServerlessTest.instance) {
-      await PlatformServerlessTest.instance.stop();
-    }
-
-    if (DITest.hasInjector()) {
-      await DITest.injector.destroy();
-      DITest._injector = null;
-    }
-  }
-
-  static createServerlessContext({
-    endpoint
-  }) {
-    const context = LambdaClientRequest.createFakeContext();
-    const event = LambdaClientRequest.createFakeEvent();
-    return new ServerlessContext({
-      event,
-      context,
-      id: context.awsRequestId,
-      logger: PlatformServerlessTest.injector.logger,
-      injector: PlatformServerlessTest.injector,
-      endpoint
-    });
-  }
-
-}
-PlatformServerlessTest.callbacks = {};
-PlatformServerlessTest.request = LambdaClientRequest;
-
-export { LambdaClientRequest as L, PlatformServerlessHandler as P, ServerlessContext as S, _extends as _, PlatformServerless as a, PlatformServerlessTest as b, ServerlessResponse as c };
-//# sourceMappingURL=index-a6c91998.js.map