@webiny/handler-aws 5.30.0 → 5.31.0-beta.0

package/index.js

@@ -1,40 +1,245 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.createHandler = void 0;
-
-var _handlerClient = _interopRequireDefault(require("@webiny/handler-client"));
-
-var _handlerHttp = _interopRequireDefault(require("@webiny/handler-http"));
-
-var _handlerArgs = _interopRequireDefault(require("@webiny/handler-args"));
-
-var _handler = require("@webiny/handler");
+Object.defineProperty(exports, "CreateApiGatewayHandlerParams", {
+  enumerable: true,
+  get: function () {
+    return _gateway.CreateHandlerParams;
+  }
+});
+Object.defineProperty(exports, "CreateDynamoDBHandlerParams", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.CreateHandlerParams;
+  }
+});
+Object.defineProperty(exports, "CreateEventBridgeHandlerParams", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.CreateHandlerParams;
+  }
+});
+Object.defineProperty(exports, "CreateRawHandlerParams", {
+  enumerable: true,
+  get: function () {
+    return _raw.CreateHandlerParams;
+  }
+});
+Object.defineProperty(exports, "CreateS3HandlerParams", {
+  enumerable: true,
+  get: function () {
+    return _s.CreateHandlerParams;
+  }
+});
+Object.defineProperty(exports, "CreateSQSHandlerParams", {
+  enumerable: true,
+  get: function () {
+    return _sqs.CreateHandlerParams;
+  }
+});
+Object.defineProperty(exports, "DynamoDBEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.DynamoDBEventHandler;
+  }
+});
+Object.defineProperty(exports, "DynamoDBEventHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.DynamoDBEventHandlerCallable;
+  }
+});
+Object.defineProperty(exports, "DynamoDBEventHandlerCallableParams", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.DynamoDBEventHandlerCallableParams;
+  }
+});
+Object.defineProperty(exports, "DynamoDBHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.HandlerCallable;
+  }
+});
+Object.defineProperty(exports, "EventBridgeEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.EventBridgeEventHandler;
+  }
+});
+Object.defineProperty(exports, "EventBridgeEventHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.EventBridgeEventHandlerCallable;
+  }
+});
+Object.defineProperty(exports, "EventBridgeEventHandlerCallableParams", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.EventBridgeEventHandlerCallableParams;
+  }
+});
+Object.defineProperty(exports, "EventBridgeHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.HandlerCallable;
+  }
+});
+Object.defineProperty(exports, "RawEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _raw.RawEventHandler;
+  }
+});
+Object.defineProperty(exports, "RawEventHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _raw.RawEventHandlerCallable;
+  }
+});
+Object.defineProperty(exports, "RawEventHandlerCallableParams", {
+  enumerable: true,
+  get: function () {
+    return _raw.RawEventHandlerCallableParams;
+  }
+});
+Object.defineProperty(exports, "RawHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _raw.HandlerCallable;
+  }
+});
+Object.defineProperty(exports, "RoutePlugin", {
+  enumerable: true,
+  get: function () {
+    return _gateway.RoutePlugin;
+  }
+});
+Object.defineProperty(exports, "S3EventHandler", {
+  enumerable: true,
+  get: function () {
+    return _s.S3EventHandler;
+  }
+});
+Object.defineProperty(exports, "S3EventHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _s.S3EventHandlerCallable;
+  }
+});
+Object.defineProperty(exports, "S3EventHandlerCallableParams", {
+  enumerable: true,
+  get: function () {
+    return _s.S3EventHandlerCallableParams;
+  }
+});
+Object.defineProperty(exports, "SQSEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _sqs.SQSEventHandler;
+  }
+});
+Object.defineProperty(exports, "SQSEventHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _sqs.SQSEventHandlerCallable;
+  }
+});
+Object.defineProperty(exports, "SQSEventHandlerCallableParams", {
+  enumerable: true,
+  get: function () {
+    return _sqs.SQSEventHandlerCallableParams;
+  }
+});
+Object.defineProperty(exports, "SQSHandlerCallable", {
+  enumerable: true,
+  get: function () {
+    return _sqs.HandlerCallable;
+  }
+});
+Object.defineProperty(exports, "createApiGatewayHandler", {
+  enumerable: true,
+  get: function () {
+    return _gateway.createHandler;
+  }
+});
+Object.defineProperty(exports, "createApiGatewayRoute", {
+  enumerable: true,
+  get: function () {
+    return _gateway.createRoute;
+  }
+});
+Object.defineProperty(exports, "createDynamoDBEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.createEventHandler;
+  }
+});
+Object.defineProperty(exports, "createDynamoDBHandler", {
+  enumerable: true,
+  get: function () {
+    return _dynamodb.createHandler;
+  }
+});
+Object.defineProperty(exports, "createEventBridgeEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.createEventHandler;
+  }
+});
+Object.defineProperty(exports, "createEventBridgeHandler", {
+  enumerable: true,
+  get: function () {
+    return _eventBridge.createHandler;
+  }
+});
+Object.defineProperty(exports, "createRawEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _raw.createEventHandler;
+  }
+});
+Object.defineProperty(exports, "createRawHandler", {
+  enumerable: true,
+  get: function () {
+    return _raw.createHandler;
+  }
+});
+Object.defineProperty(exports, "createS3EventHandler", {
+  enumerable: true,
+  get: function () {
+    return _s.createEventHandler;
+  }
+});
+Object.defineProperty(exports, "createS3Handler", {
+  enumerable: true,
+  get: function () {
+    return _s.createHandler;
+  }
+});
+Object.defineProperty(exports, "createSQSEventHandler", {
+  enumerable: true,
+  get: function () {
+    return _sqs.createEventHandler;
+  }
+});
+Object.defineProperty(exports, "createSQSHandler", {
+  enumerable: true,
+  get: function () {
+    return _sqs.createHandler;
+  }
+});
 
-var _handlerClient2 = _interopRequireDefault(require("./plugins/handlerClient"));
+var _gateway = require("./gateway");
 
-var _handlerHttp2 = _interopRequireDefault(require("./plugins/handlerHttp"));
+var _s = require("./s3");
 
-/**
- * To avoid braking changes, the "createHandler" function supports two signature:
- *  1. A list of plugins.       (backwards-compatible)
- *  2. A single argument of type `CreateHandlerOptions`.
- *
- * @param {Array | CreateAwsHandlerOptions} args - The list of plugins or object of type `CreateHandlerOptions`.
- */
-const createHandler = (...args) => {
-  let plugins = args;
-  const createHandlerOptions = args[0];
+var _dynamodb = require("./dynamodb");
 
-  if (createHandlerOptions && Array.isArray(createHandlerOptions.plugins)) {
-    plugins = createHandlerOptions.plugins;
-  }
+var _sqs = require("./sqs");
 
-  return (0, _handler.createHandler)((0, _handlerClient.default)(), (0, _handlerArgs.default)(), (0, _handlerHttp.default)(createHandlerOptions && createHandlerOptions.http), _handlerClient2.default, _handlerHttp2.default, ...plugins);
-};
+var _eventBridge = require("./eventBridge");
 
-exports.createHandler = createHandler;
+var _raw = require("./raw");

package/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["createHandler","args","plugins","createHandlerOptions","Array","isArray","createDefaultHandler","defaultHandlerClient","defaultHandlerArgs","defaultHandlerHttp","http","handlerClient","handlerHttp"],"sources":["index.ts"],"sourcesContent":["import defaultHandlerClient from \"@webiny/handler-client\";\nimport defaultHandlerHttp from \"@webiny/handler-http\";\nimport { HandlerHttpOptions } from \"@webiny/handler-http/types\";\nimport defaultHandlerArgs from \"@webiny/handler-args\";\nimport { createHandler as createDefaultHandler } from \"@webiny/handler\";\nimport { PluginCollection } from \"@webiny/plugins/types\";\nimport handlerClient from \"./plugins/handlerClient\";\nimport handlerHttp from \"./plugins/handlerHttp\";\n\ninterface CreateAwsHandlerOptions {\n    plugins: PluginCollection;\n    http?: HandlerHttpOptions;\n}\n\ninterface CreateAwsHandler {\n    (...plugins: PluginCollection): Function;\n    (params: CreateAwsHandlerOptions): Function;\n}\n\n/**\n * To avoid braking changes, the \"createHandler\" function supports two signature:\n *  1. A list of plugins.       (backwards-compatible)\n *  2. A single argument of type `CreateHandlerOptions`.\n *\n * @param {Array | CreateAwsHandlerOptions} args - The list of plugins or object of type `CreateHandlerOptions`.\n */\nexport const createHandler: CreateAwsHandler = (...args: any) => {\n    let plugins = args;\n\n    const createHandlerOptions: CreateAwsHandlerOptions =\n        args[0] as unknown as CreateAwsHandlerOptions;\n    if (createHandlerOptions && Array.isArray(createHandlerOptions.plugins)) {\n        plugins = createHandlerOptions.plugins;\n    }\n\n    return createDefaultHandler(\n        defaultHandlerClient(),\n        defaultHandlerArgs(),\n        defaultHandlerHttp(createHandlerOptions && createHandlerOptions.http),\n        handlerClient,\n        handlerHttp,\n        ...plugins\n    );\n};\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AAEA;;AACA;;AAEA;;AACA;;AAYA;AACA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,aAA+B,GAAG,CAAC,GAAGC,IAAJ,KAAkB;EAC7D,IAAIC,OAAO,GAAGD,IAAd;EAEA,MAAME,oBAA6C,GAC/CF,IAAI,CAAC,CAAD,CADR;;EAEA,IAAIE,oBAAoB,IAAIC,KAAK,CAACC,OAAN,CAAcF,oBAAoB,CAACD,OAAnC,CAA5B,EAAyE;IACrEA,OAAO,GAAGC,oBAAoB,CAACD,OAA/B;EACH;;EAED,OAAO,IAAAI,sBAAA,EACH,IAAAC,sBAAA,GADG,EAEH,IAAAC,oBAAA,GAFG,EAGH,IAAAC,oBAAA,EAAmBN,oBAAoB,IAAIA,oBAAoB,CAACO,IAAhE,CAHG,EAIHC,uBAJG,EAKHC,qBALG,EAMH,GAAGV,OANA,CAAP;AAQH,CAjBM"}
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export {\n    createHandler as createApiGatewayHandler,\n    CreateHandlerParams as CreateApiGatewayHandlerParams,\n    RoutePlugin,\n    createRoute as createApiGatewayRoute\n} from \"~/gateway\";\n\nexport {\n    createHandler as createS3Handler,\n    CreateHandlerParams as CreateS3HandlerParams,\n    S3EventHandler,\n    S3EventHandlerCallable,\n    S3EventHandlerCallableParams,\n    createEventHandler as createS3EventHandler\n} from \"~/s3\";\n\nexport {\n    createHandler as createDynamoDBHandler,\n    CreateHandlerParams as CreateDynamoDBHandlerParams,\n    DynamoDBEventHandler,\n    DynamoDBEventHandlerCallable,\n    DynamoDBEventHandlerCallableParams,\n    createEventHandler as createDynamoDBEventHandler,\n    HandlerCallable as DynamoDBHandlerCallable\n} from \"~/dynamodb\";\n\nexport {\n    createHandler as createSQSHandler,\n    CreateHandlerParams as CreateSQSHandlerParams,\n    SQSEventHandler,\n    SQSEventHandlerCallable,\n    SQSEventHandlerCallableParams,\n    createEventHandler as createSQSEventHandler,\n    HandlerCallable as SQSHandlerCallable\n} from \"~/sqs\";\n\nexport {\n    createHandler as createEventBridgeHandler,\n    CreateHandlerParams as CreateEventBridgeHandlerParams,\n    EventBridgeEventHandler,\n    EventBridgeEventHandlerCallable,\n    EventBridgeEventHandlerCallableParams,\n    createEventHandler as createEventBridgeEventHandler,\n    HandlerCallable as EventBridgeHandlerCallable\n} from \"~/eventBridge\";\n\nexport {\n    createHandler as createRawHandler,\n    CreateHandlerParams as CreateRawHandlerParams,\n    HandlerCallable as RawHandlerCallable,\n    createEventHandler as createRawEventHandler,\n    RawEventHandlerCallableParams,\n    RawEventHandlerCallable,\n    RawEventHandler\n} from \"~/raw\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAOA;;AASA;;AAUA;;AAUA;;AAUA"}

package/package.json

@@ -1,36 +1,34 @@
 {
 	"name": "@webiny/handler-aws",
-	"version": "5.30.0",
+	"version": "5.31.0-beta.0",
 	"main": "index.js",
 	"repository": {
 		"type": "git",
 		"url": "https://github.com/webiny/webiny-js.git"
 	},
-	"description": "A package that contains plugins for developing Webiny API in the AWS cloud.",
+	"description": "Our small wrapper around fastify to ease handling of http requests for the system.",
 	"contributors": [
-		"Pavel Denisjuk <pavel@webiny.com>",
-		"Sven Al Hamad <sven@webiny.com>",
-		"Adrian Smijulj <adrian@webiny.com>"
+		"Bruno Zorić <bruno@webiny.com>"
 	],
 	"license": "MIT",
 	"dependencies": {
-		"@babel/runtime": "7.18.6",
-		"@webiny/handler": "5.30.0",
-		"@webiny/handler-args": "5.30.0",
-		"@webiny/handler-client": "5.30.0",
-		"@webiny/handler-http": "5.30.0",
-		"@webiny/plugins": "5.30.0"
+		"@babel/runtime": "7.18.9",
+		"@fastify/aws-lambda": "3.1.1",
+		"@webiny/handler": "5.31.0-beta.0",
+		"@webiny/handler-client": "5.31.0-beta.0",
+		"@webiny/plugins": "5.31.0-beta.0",
+		"aws-lambda": "1.0.7",
+		"fastify": "4.3.0"
 	},
 	"devDependencies": {
 		"@babel/cli": "^7.16.0",
 		"@babel/core": "^7.16.0",
 		"@babel/preset-env": "^7.16.4",
 		"@babel/preset-typescript": "^7.16.0",
-		"@webiny/cli": "^5.30.0",
-		"@webiny/project-utils": "^5.30.0",
-		"babel-plugin-lodash": "^3.3.4",
-		"merge": "^1.2.1",
+		"@webiny/cli": "^5.31.0-beta.0",
+		"@webiny/project-utils": "^5.31.0-beta.0",
 		"rimraf": "^3.0.2",
+		"ttypescript": "^1.5.13",
 		"typescript": "4.7.4"
 	},
 	"publishConfig": {
@@ -41,5 +39,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "3cadc5d26e565586b28772afbc18ae554ce7b782"
+	"gitHead": "dea7c56325ff140ef0e2d761f3e65708d46d401e"
 }

package/plugins/handlerClient.d.ts

@@ -1,3 +1,2 @@
-import { HandlerClientPlugin } from "@webiny/handler-client/types";
-declare const plugin: HandlerClientPlugin;
-export default plugin;
+import { HandlerClientPlugin } from "@webiny/handler-client";
+export declare const createHandlerClientPlugin: () => HandlerClientPlugin;

package/plugins/handlerClient.js

@@ -5,36 +5,58 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = void 0;
+exports.createHandlerClientPlugin = void 0;
 
 var _lambda = _interopRequireDefault(require("aws-sdk/clients/lambda"));
 
-const plugin = {
-  type: "handler-client",
-  name: "handler-client",
-
-  async invoke({
-    name,
-    payload,
-    await: useAwait
-  }) {
-    const lambdaClient = new _lambda.default({
-      region: process.env.AWS_REGION
-    });
-    const response = await lambdaClient.invoke({
-      FunctionName: name,
-      InvocationType: useAwait === false ? "Event" : "RequestResponse",
-      Payload: JSON.stringify(payload)
-    }).promise();
-
-    if (useAwait === false) {
-      return null;
+var _handlerClient = require("@webiny/handler-client");
+
+const createHandlerClientPlugin = () => {
+  const plugin = new _handlerClient.HandlerClientPlugin({
+    invoke: async params => {
+      const {
+        await: useAwait,
+        name,
+        payload
+      } = params;
+      const lambdaClient = new _lambda.default({
+        region: process.env.AWS_REGION
+      });
+      const response = await lambdaClient.invoke({
+        FunctionName: name,
+        InvocationType: useAwait === false ? "Event" : "RequestResponse",
+        Payload: JSON.stringify(payload)
+      }).promise();
+
+      if (useAwait === false) {
+        return null;
+      }
+
+      const Payload = response.Payload;
+      return JSON.parse(Payload);
+    },
+    canUse: params => {
+      if (!(params !== null && params !== void 0 && params.name)) {
+        return true;
+      }
+
+      const {
+        name
+      } = params;
+      /**
+       * In case we are invoking currently active lambda, let's use this plugin as well.
+       * When invoking some other lambda, name starts with arn.
+       */
+
+      if (name === process.env.AWS_LAMBDA_FUNCTION_NAME) {
+        return true;
+      }
+
+      return name.match("arn:") !== null;
     }
-
-    const Payload = response.Payload;
-    return JSON.parse(Payload);
-  }
-
+  });
+  plugin.name = "handler-client";
+  return plugin;
 };
-var _default = plugin;
-exports.default = _default;
+
+exports.createHandlerClientPlugin = createHandlerClientPlugin;

package/plugins/handlerClient.js.map

@@ -1 +1 @@
-{"version":3,"names":["plugin","type","name","invoke","payload","await","useAwait","lambdaClient","LambdaClient","region","process","env","AWS_REGION","response","FunctionName","InvocationType","Payload","JSON","stringify","promise","parse"],"sources":["handlerClient.ts"],"sourcesContent":["import LambdaClient from \"aws-sdk/clients/lambda\";\nimport { HandlerClientPlugin } from \"@webiny/handler-client/types\";\n\nconst plugin: HandlerClientPlugin = {\n    type: \"handler-client\",\n    name: \"handler-client\",\n    async invoke({ name, payload, await: useAwait }) {\n        const lambdaClient = new LambdaClient({ region: process.env.AWS_REGION });\n        const response = await lambdaClient\n            .invoke({\n                FunctionName: name,\n                InvocationType: useAwait === false ? \"Event\" : \"RequestResponse\",\n                Payload: JSON.stringify(payload)\n            })\n            .promise();\n\n        if (useAwait === false) {\n            return null;\n        }\n\n        const Payload = response.Payload as string;\n        return JSON.parse(Payload);\n    }\n};\n\nexport default plugin;\n"],"mappings":";;;;;;;;;AAAA;;AAGA,MAAMA,MAA2B,GAAG;EAChCC,IAAI,EAAE,gBAD0B;EAEhCC,IAAI,EAAE,gBAF0B;;EAGhC,MAAMC,MAAN,CAAa;IAAED,IAAF;IAAQE,OAAR;IAAiBC,KAAK,EAAEC;EAAxB,CAAb,EAAiD;IAC7C,MAAMC,YAAY,GAAG,IAAIC,eAAJ,CAAiB;MAAEC,MAAM,EAAEC,OAAO,CAACC,GAAR,CAAYC;IAAtB,CAAjB,CAArB;IACA,MAAMC,QAAQ,GAAG,MAAMN,YAAY,CAC9BJ,MADkB,CACX;MACJW,YAAY,EAAEZ,IADV;MAEJa,cAAc,EAAET,QAAQ,KAAK,KAAb,GAAqB,OAArB,GAA+B,iBAF3C;MAGJU,OAAO,EAAEC,IAAI,CAACC,SAAL,CAAed,OAAf;IAHL,CADW,EAMlBe,OANkB,EAAvB;;IAQA,IAAIb,QAAQ,KAAK,KAAjB,EAAwB;MACpB,OAAO,IAAP;IACH;;IAED,MAAMU,OAAO,GAAGH,QAAQ,CAACG,OAAzB;IACA,OAAOC,IAAI,CAACG,KAAL,CAAWJ,OAAX,CAAP;EACH;;AAnB+B,CAApC;eAsBehB,M"}
+{"version":3,"names":["createHandlerClientPlugin","plugin","HandlerClientPlugin","invoke","params","await","useAwait","name","payload","lambdaClient","LambdaClient","region","process","env","AWS_REGION","response","FunctionName","InvocationType","Payload","JSON","stringify","promise","parse","canUse","AWS_LAMBDA_FUNCTION_NAME","match"],"sources":["handlerClient.ts"],"sourcesContent":["import LambdaClient from \"aws-sdk/clients/lambda\";\nimport { HandlerClientPlugin } from \"@webiny/handler-client\";\n\nexport const createHandlerClientPlugin = () => {\n    const plugin = new HandlerClientPlugin({\n        invoke: async params => {\n            const { await: useAwait, name, payload } = params;\n            const lambdaClient = new LambdaClient({\n                region: process.env.AWS_REGION\n            });\n            const response = await lambdaClient\n                .invoke({\n                    FunctionName: name,\n                    InvocationType: useAwait === false ? \"Event\" : \"RequestResponse\",\n                    Payload: JSON.stringify(payload)\n                })\n                .promise();\n\n            if (useAwait === false) {\n                return null;\n            }\n\n            const Payload = response.Payload as string;\n            return JSON.parse(Payload);\n        },\n        canUse: params => {\n            if (!params?.name) {\n                return true;\n            }\n            const { name } = params;\n            /**\n             * In case we are invoking currently active lambda, let's use this plugin as well.\n             * When invoking some other lambda, name starts with arn.\n             */\n            if (name === process.env.AWS_LAMBDA_FUNCTION_NAME) {\n                return true;\n            }\n            return name.match(\"arn:\") !== null;\n        }\n    });\n\n    plugin.name = \"handler-client\";\n\n    return plugin;\n};\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AAEO,MAAMA,yBAAyB,GAAG,MAAM;EAC3C,MAAMC,MAAM,GAAG,IAAIC,kCAAJ,CAAwB;IACnCC,MAAM,EAAE,MAAMC,MAAN,IAAgB;MACpB,MAAM;QAAEC,KAAK,EAAEC,QAAT;QAAmBC,IAAnB;QAAyBC;MAAzB,IAAqCJ,MAA3C;MACA,MAAMK,YAAY,GAAG,IAAIC,eAAJ,CAAiB;QAClCC,MAAM,EAAEC,OAAO,CAACC,GAAR,CAAYC;MADc,CAAjB,CAArB;MAGA,MAAMC,QAAQ,GAAG,MAAMN,YAAY,CAC9BN,MADkB,CACX;QACJa,YAAY,EAAET,IADV;QAEJU,cAAc,EAAEX,QAAQ,KAAK,KAAb,GAAqB,OAArB,GAA+B,iBAF3C;QAGJY,OAAO,EAAEC,IAAI,CAACC,SAAL,CAAeZ,OAAf;MAHL,CADW,EAMlBa,OANkB,EAAvB;;MAQA,IAAIf,QAAQ,KAAK,KAAjB,EAAwB;QACpB,OAAO,IAAP;MACH;;MAED,MAAMY,OAAO,GAAGH,QAAQ,CAACG,OAAzB;MACA,OAAOC,IAAI,CAACG,KAAL,CAAWJ,OAAX,CAAP;IACH,CApBkC;IAqBnCK,MAAM,EAAEnB,MAAM,IAAI;MACd,IAAI,EAACA,MAAD,aAACA,MAAD,eAACA,MAAM,CAAEG,IAAT,CAAJ,EAAmB;QACf,OAAO,IAAP;MACH;;MACD,MAAM;QAAEA;MAAF,IAAWH,MAAjB;MACA;AACZ;AACA;AACA;;MACY,IAAIG,IAAI,KAAKK,OAAO,CAACC,GAAR,CAAYW,wBAAzB,EAAmD;QAC/C,OAAO,IAAP;MACH;;MACD,OAAOjB,IAAI,CAACkB,KAAL,CAAW,MAAX,MAAuB,IAA9B;IACH;EAlCkC,CAAxB,CAAf;EAqCAxB,MAAM,CAACM,IAAP,GAAc,gBAAd;EAEA,OAAON,MAAP;AACH,CAzCM"}

package/plugins/index.d.ts

@@ -0,0 +1,2 @@
+import { Context } from "@webiny/handler/types";
+export declare const registerDefaultPlugins: (context: Context) => void;

package/plugins/index.js

@@ -0,0 +1,14 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.registerDefaultPlugins = void 0;
+
+var _handlerClient = require("./handlerClient");
+
+const registerDefaultPlugins = context => {
+  context.plugins.register([(0, _handlerClient.createHandlerClientPlugin)()]);
+};
+
+exports.registerDefaultPlugins = registerDefaultPlugins;

package/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["registerDefaultPlugins","context","plugins","register","createHandlerClientPlugin"],"sources":["index.ts"],"sourcesContent":["import { createHandlerClientPlugin } from \"./handlerClient\";\nimport { Context } from \"@webiny/handler/types\";\n\nexport const registerDefaultPlugins = (context: Context): void => {\n    context.plugins.register([createHandlerClientPlugin()]);\n};\n"],"mappings":";;;;;;;AAAA;;AAGO,MAAMA,sBAAsB,GAAIC,OAAD,IAA4B;EAC9DA,OAAO,CAACC,OAAR,CAAgBC,QAAhB,CAAyB,CAAC,IAAAC,wCAAA,GAAD,CAAzB;AACH,CAFM"}

package/raw/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This is the handler implementation for @webiny/handler/plugins/EventPlugin.
+ * This is mostly meant for some custom lambda calls as we are sometimes invoking lambdas directly.
+ *
+ * We should try to have some kind of standardized event type implementation at some point.
+ */
+import { CreateHandlerParams as BaseCreateHandlerParams } from "@webiny/handler";
+import { Context as LambdaContext } from "aws-lambda";
+import { APIGatewayProxyResult } from "aws-lambda/trigger/api-gateway-proxy";
+export interface HandlerCallable<Payload, Response = APIGatewayProxyResult> {
+    (payload: Payload, context: LambdaContext): Promise<Response>;
+}
+export interface CreateHandlerParams extends BaseCreateHandlerParams {
+    http?: {
+        debug?: boolean;
+    };
+}
+export declare const createHandler: <Payload = any, Response_1 = APIGatewayProxyResult>(params: CreateHandlerParams) => HandlerCallable<Payload, Response_1>;
+export * from "./plugins/RawEventHandler";

package/raw/index.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  createHandler: true
+};
+exports.createHandler = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _handler = require("@webiny/handler");
+
+var _RawEventHandler = require("./plugins/RawEventHandler");
+
+Object.keys(_RawEventHandler).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _RawEventHandler[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _RawEventHandler[key];
+    }
+  });
+});
+
+var _plugins = require("../plugins");
+
+var _execute = require("../execute");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+const Reply = require("fastify/lib/reply");
+
+const url = "/webiny-raw-event";
+
+const createHandler = params => {
+  return (payload, context) => {
+    var _params$http;
+
+    const app = (0, _handler.createHandler)({
+      plugins: params.plugins,
+      options: _objectSpread({
+        logger: ((_params$http = params.http) === null || _params$http === void 0 ? void 0 : _params$http.debug) === true
+      }, params.options || {})
+    });
+    /**
+     * We always must add our default plugins to the app.
+     */
+
+    (0, _plugins.registerDefaultPlugins)(app.webiny);
+    /**
+     * There must be an event plugin for this handler to work.
+     */
+
+    const plugins = app.webiny.plugins.byType(_RawEventHandler.RawEventHandler.type);
+    const handler = plugins.shift();
+
+    if (!handler) {
+      throw new Error(`To run @webiny/handler-aws/raw, you must have RawEventHandler set.`);
+    }
+
+    app.post(url, async (request, reply) => {
+      const params = {
+        request,
+        reply,
+        context: app.webiny,
+        payload,
+        lambdaContext: context
+      };
+      const result = await handler.cb(params);
+
+      if (result instanceof Reply) {
+        return result;
+      }
+
+      app.__webiny_raw_result = result;
+      return reply.send({});
+    });
+    return (0, _execute.execute)({
+      app,
+      url,
+      payload
+    });
+  };
+};
+
+exports.createHandler = createHandler;

package/raw/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Reply","require","url","createHandler","params","payload","context","app","createBaseHandler","plugins","options","logger","http","debug","registerDefaultPlugins","webiny","byType","RawEventHandler","type","handler","shift","Error","post","request","reply","lambdaContext","result","cb","__webiny_raw_result","send","execute"],"sources":["index.ts"],"sourcesContent":["/**\n * This is the handler implementation for @webiny/handler/plugins/EventPlugin.\n * This is mostly meant for some custom lambda calls as we are sometimes invoking lambdas directly.\n *\n * We should try to have some kind of standardized event type implementation at some point.\n */\nimport {\n    createHandler as createBaseHandler,\n    CreateHandlerParams as BaseCreateHandlerParams\n} from \"@webiny/handler\";\nconst Reply = require(\"fastify/lib/reply\");\nimport { Context as LambdaContext } from \"aws-lambda\";\nimport { APIGatewayProxyResult } from \"aws-lambda/trigger/api-gateway-proxy\";\nimport { RawEventHandler } from \"~/raw/plugins/RawEventHandler\";\nimport { registerDefaultPlugins } from \"~/plugins\";\nimport { execute } from \"~/execute\";\n\nconst url = \"/webiny-raw-event\";\n\nexport interface HandlerCallable<Payload, Response = APIGatewayProxyResult> {\n    (payload: Payload, context: LambdaContext): Promise<Response>;\n}\n\nexport interface CreateHandlerParams extends BaseCreateHandlerParams {\n    http?: {\n        debug?: boolean;\n    };\n}\n\nexport const createHandler = <Payload = any, Response = APIGatewayProxyResult>(\n    params: CreateHandlerParams\n): HandlerCallable<Payload, Response> => {\n    return (payload, context) => {\n        const app = createBaseHandler({\n            plugins: params.plugins,\n            options: {\n                logger: params.http?.debug === true,\n                ...(params.options || {})\n            }\n        });\n        /**\n         * We always must add our default plugins to the app.\n         */\n        registerDefaultPlugins(app.webiny);\n        /**\n         * There must be an event plugin for this handler to work.\n         */\n        const plugins = app.webiny.plugins.byType<RawEventHandler<Payload, any, Response>>(\n            RawEventHandler.type\n        );\n        const handler = plugins.shift();\n        if (!handler) {\n            throw new Error(`To run @webiny/handler-aws/raw, you must have RawEventHandler set.`);\n        }\n\n        app.post(url, async (request, reply) => {\n            const params = {\n                request,\n                reply,\n                context: app.webiny,\n                payload,\n                lambdaContext: context\n            };\n            const result = await handler.cb(params);\n\n            if (result instanceof Reply) {\n                return result;\n            }\n\n            (app as any).__webiny_raw_result = result;\n            return reply.send({});\n        });\n        return execute({\n            app,\n            url,\n            payload\n        });\n    };\n};\n\nexport * from \"./plugins/RawEventHandler\";\n"],"mappings":";;;;;;;;;;;;;;AAMA;;AAOA;;AAmEA;EAAA;EAAA;EAAA;EAAA;IAAA;IAAA;MAAA;IAAA;EAAA;AAAA;;AAlEA;;AACA;;;;;;AALA,MAAMA,KAAK,GAAGC,OAAO,CAAC,mBAAD,CAArB;;AAOA,MAAMC,GAAG,GAAG,mBAAZ;;AAYO,MAAMC,aAAa,GACtBC,MADyB,IAEY;EACrC,OAAO,CAACC,OAAD,EAAUC,OAAV,KAAsB;IAAA;;IACzB,MAAMC,GAAG,GAAG,IAAAC,sBAAA,EAAkB;MAC1BC,OAAO,EAAEL,MAAM,CAACK,OADU;MAE1BC,OAAO;QACHC,MAAM,EAAE,iBAAAP,MAAM,CAACQ,IAAP,8DAAaC,KAAb,MAAuB;MAD5B,GAECT,MAAM,CAACM,OAAP,IAAkB,EAFnB;IAFmB,CAAlB,CAAZ;IAOA;AACR;AACA;;IACQ,IAAAI,+BAAA,EAAuBP,GAAG,CAACQ,MAA3B;IACA;AACR;AACA;;IACQ,MAAMN,OAAO,GAAGF,GAAG,CAACQ,MAAJ,CAAWN,OAAX,CAAmBO,MAAnB,CACZC,gCAAA,CAAgBC,IADJ,CAAhB;IAGA,MAAMC,OAAO,GAAGV,OAAO,CAACW,KAAR,EAAhB;;IACA,IAAI,CAACD,OAAL,EAAc;MACV,MAAM,IAAIE,KAAJ,CAAW,oEAAX,CAAN;IACH;;IAEDd,GAAG,CAACe,IAAJ,CAASpB,GAAT,EAAc,OAAOqB,OAAP,EAAgBC,KAAhB,KAA0B;MACpC,MAAMpB,MAAM,GAAG;QACXmB,OADW;QAEXC,KAFW;QAGXlB,OAAO,EAAEC,GAAG,CAACQ,MAHF;QAIXV,OAJW;QAKXoB,aAAa,EAAEnB;MALJ,CAAf;MAOA,MAAMoB,MAAM,GAAG,MAAMP,OAAO,CAACQ,EAAR,CAAWvB,MAAX,CAArB;;MAEA,IAAIsB,MAAM,YAAY1B,KAAtB,EAA6B;QACzB,OAAO0B,MAAP;MACH;;MAEAnB,GAAD,CAAaqB,mBAAb,GAAmCF,MAAnC;MACA,OAAOF,KAAK,CAACK,IAAN,CAAW,EAAX,CAAP;IACH,CAhBD;IAiBA,OAAO,IAAAC,gBAAA,EAAQ;MACXvB,GADW;MAEXL,GAFW;MAGXG;IAHW,CAAR,CAAP;EAKH,CA7CD;AA8CH,CAjDM"}

package/raw/plugins/RawEventHandler.d.ts

@@ -0,0 +1,13 @@
+import { Reply, Context as BaseContext } from "@webiny/handler/types";
+import { Context as LambdaContext } from "aws-lambda";
+import { EventPlugin, EventPluginCallableParams } from "@webiny/handler";
+export interface RawEventHandlerCallableParams<Event, Context extends BaseContext> extends EventPluginCallableParams<Event, Context> {
+    lambdaContext: LambdaContext;
+}
+export interface RawEventHandlerCallable<Event, Context extends BaseContext, Response> {
+    (params: RawEventHandlerCallableParams<Event, Context>): Promise<Response | Reply>;
+}
+export declare class RawEventHandler<Event = any, Context extends BaseContext = BaseContext, Response = any> extends EventPlugin {
+    constructor(cb: RawEventHandlerCallable<Event, Context, Response>);
+}
+export declare const createEventHandler: <Event_1 = any, Context extends BaseContext = BaseContext, Response_1 = any>(cb: RawEventHandlerCallable<Event_1, Context, Response_1>) => RawEventHandler<Event_1, Context, Response_1>;

package/raw/plugins/RawEventHandler.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEventHandler = exports.RawEventHandler = void 0;
+
+var _handler = require("@webiny/handler");
+
+class RawEventHandler extends _handler.EventPlugin {
+  constructor(cb) {
+    super(cb);
+  }
+
+}
+
+exports.RawEventHandler = RawEventHandler;
+
+const createEventHandler = cb => {
+  return new RawEventHandler(cb);
+};
+
+exports.createEventHandler = createEventHandler;

package/raw/plugins/RawEventHandler.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["RawEventHandler","EventPlugin","constructor","cb","createEventHandler"],"sources":["RawEventHandler.ts"],"sourcesContent":["import { Reply, Context as BaseContext } from \"@webiny/handler/types\";\nimport { Context as LambdaContext } from \"aws-lambda\";\nimport { EventPlugin, EventPluginCallableParams } from \"@webiny/handler\";\n\nexport interface RawEventHandlerCallableParams<Event, Context extends BaseContext>\n    extends EventPluginCallableParams<Event, Context> {\n    lambdaContext: LambdaContext;\n}\nexport interface RawEventHandlerCallable<Event, Context extends BaseContext, Response> {\n    (params: RawEventHandlerCallableParams<Event, Context>): Promise<Response | Reply>;\n}\n\nexport class RawEventHandler<\n    Event = any,\n    Context extends BaseContext = BaseContext,\n    Response = any\n> extends EventPlugin {\n    public constructor(cb: RawEventHandlerCallable<Event, Context, Response>) {\n        super(cb as any);\n    }\n}\n\nexport const createEventHandler = <\n    Event = any,\n    Context extends BaseContext = BaseContext,\n    Response = any\n>(\n    cb: RawEventHandlerCallable<Event, Context, Response>\n) => {\n    return new RawEventHandler<Event, Context, Response>(cb);\n};\n"],"mappings":";;;;;;;AAEA;;AAUO,MAAMA,eAAN,SAIGC,oBAJH,CAIe;EACXC,WAAW,CAACC,EAAD,EAAwD;IACtE,MAAMA,EAAN;EACH;;AAHiB;;;;AAMf,MAAMC,kBAAkB,GAK3BD,EAL8B,IAM7B;EACD,OAAO,IAAIH,eAAJ,CAA8CG,EAA9C,CAAP;AACH,CARM"}