@webiny/handler 0.0.0-mt-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,9 @@
+# @webiny/handler
+[![](https://img.shields.io/npm/dw/@webiny/handler.svg)](https://www.npmjs.com/package/@webiny/handler) 
+[![](https://img.shields.io/npm/v/@webiny/handler.svg)](https://www.npmjs.com/package/@webiny/handler)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A tiny, universal, and plugin-based framework for creating (serverless) handlers, used within services like AWS Lambda, Azure Serverless Functions, and others. 
+
+A handler can be anything from a simple event-handler, to a fully-fledged GraphQL server. It all depends on the additional plugins that are passed upon the creating the handler.

package/createHandler.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (...plugins: any[]) => (...args: any[]) => Promise<any>;
+export default _default;

package/createHandler.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _plugins = require("@webiny/plugins");
+
+var _middleware = _interopRequireDefault(require("./middleware"));
+
+var _default = (...plugins) => async (...args) => {
+  const context = {
+    plugins: new _plugins.PluginsContainer(plugins),
+    args,
+    // @ts-ignore
+    // this is injected using webpack.DefinePlugin at build time
+    WEBINY_VERSION: process.env.WEBINY_VERSION
+  };
+  const result = await handle(args, context);
+  const handlerPlugins = context.plugins.byType("handler-result");
+
+  for (let i = 0; i < handlerPlugins.length; i++) {
+    if (handlerPlugins[i].apply) {
+      await handlerPlugins[i].apply(result, context);
+    }
+  }
+
+  return result;
+};
+
+exports.default = _default;
+
+async function handle(_, context) {
+  try {
+    const contextPlugins = context.plugins.byType("context");
+
+    for (let i = 0; i < contextPlugins.length; i++) {
+      if (contextPlugins[i].apply) {
+        await contextPlugins[i].apply(context);
+      }
+    }
+
+    const beforeHandlerPlugins = context.plugins.byType("before-handler");
+
+    for (let i = 0; i < beforeHandlerPlugins.length; i++) {
+      if (beforeHandlerPlugins[i].apply) {
+        await beforeHandlerPlugins[i].apply(context);
+      }
+    }
+
+    const handlers = context.plugins.byType("handler");
+    const handler = (0, _middleware.default)(handlers.map(pl => pl.handle));
+    const result = await handler(context);
+
+    if (!result) {
+      throw Error(`No result was returned from registered handlers.`);
+    }
+
+    return result;
+  } catch (error) {
+    // Log error to cloud, as these can be extremely annoying to debug!
+    console.log(error);
+    const handlers = context.plugins.byType("handler-error");
+    const handler = (0, _middleware.default)(handlers.map(pl => pl.handle));
+    return handler(context, error);
+  }
+}

package/index.d.ts

@@ -0,0 +1 @@
+export { default as createHandler } from "./createHandler";

package/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "createHandler", {
+  enumerable: true,
+  get: function () {
+    return _createHandler.default;
+  }
+});
+
+var _createHandler = _interopRequireDefault(require("./createHandler"));

package/middleware.d.ts

@@ -0,0 +1,5 @@
+declare const _default: (functions?: Array<Function>) => Function;
+/**
+ * Compose a single middleware from the array of middleware functions
+ */
+export default _default;

package/middleware.js

@@ -0,0 +1,51 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+/**
+ * Compose a single middleware from the array of middleware functions
+ */
+var _default = (functions = []) => {
+  return (...args) => {
+    if (!functions.length) {
+      return Promise.resolve();
+    } // Create a clone of function chain to prevent modifying the original array with `shift()`
+
+
+    const chain = [...functions];
+    return new Promise((parentResolve, parentReject) => {
+      const next = async () => {
+        const fn = chain.shift();
+
+        if (!fn) {
+          return Promise.resolve();
+        }
+
+        return new Promise(async (resolve, reject) => {
+          try {
+            const result = await fn(...args, resolve);
+
+            if (typeof result !== "undefined") {
+              return parentResolve(result);
+            }
+          } catch (e) {
+            reject(e);
+          }
+        }).then(() => {
+          return next();
+        }).then(() => {
+          parentResolve(...args);
+        }).catch(e => {
+          parentReject(e);
+        });
+      };
+
+      return next();
+    });
+  };
+};
+
+exports.default = _default;

package/package.json

@@ -0,0 +1,38 @@
+{
+	"name": "@webiny/handler",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "A pluginable function for the cloud.",
+	"contributors": [
+		"Pavel Denisjuk <pavel@webiny.com>",
+		"Sven Al Hamad <sven@webiny.com>",
+		"Adrian Smijulj <adrian@webiny.com>"
+	],
+	"dependencies": {
+		"@babel/runtime": "7.15.4",
+		"@webiny/plugins": "0.0.0-mt-1"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@babel/preset-env": "^7.5.5",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"rimraf": "^3.0.2",
+		"typescript": "^4.1.3"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"gitHead": "37736d8456a6ecb342a6c3645060bd9a3f2d4bb0"
+}

package/plugins/BeforeHandlerPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+interface Callable<TContext> {
+    (context: TContext): void | Promise<void>;
+}
+export declare class BeforeHandlerPlugin<TContext> extends Plugin {
+    static readonly type = "before-handler";
+    private readonly _callable;
+    constructor(callable?: Callable<TContext>);
+    apply(context: TContext): void | Promise<void>;
+}
+export {};

package/plugins/BeforeHandlerPlugin.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BeforeHandlerPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class BeforeHandlerPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "_callable", void 0);
+    this._callable = callable;
+  }
+
+  apply(context) {
+    if (typeof this._callable !== "function") {
+      throw Error(`Missing callable in BeforeHandlerPlugin! Either pass a callable to plugin constructor or extend the plugin and override the "apply" method.`);
+    }
+
+    return this._callable(context);
+  }
+
+}
+
+exports.BeforeHandlerPlugin = BeforeHandlerPlugin;
+(0, _defineProperty2.default)(BeforeHandlerPlugin, "type", "before-handler");

package/plugins/ContextPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+interface Callable<TContext> {
+    (context: TContext): void | Promise<void>;
+}
+export declare class ContextPlugin<TContext> extends Plugin {
+    static readonly type = "context";
+    private readonly _callable;
+    constructor(callable?: Callable<TContext>);
+    apply(context: TContext): void | Promise<void>;
+}
+export {};

package/plugins/ContextPlugin.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ContextPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class ContextPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "_callable", void 0);
+    this._callable = callable;
+  }
+
+  apply(context) {
+    if (typeof this._callable !== "function") {
+      throw Error(`Missing callable in ContextPlugin! Either pass a callable to plugin constructor or extend the plugin and override the "apply" method.`);
+    }
+
+    return this._callable(context);
+  }
+
+}
+
+exports.ContextPlugin = ContextPlugin;
+(0, _defineProperty2.default)(ContextPlugin, "type", "context");

package/types.d.ts

@@ -0,0 +1,37 @@
+import { Plugin, PluginsContainer } from "@webiny/plugins/types";
+export declare type HandlerArgs = any[];
+export interface HandlerContext {
+    plugins: PluginsContainer;
+    args: HandlerArgs;
+    readonly WEBINY_VERSION: string;
+}
+export interface ContextInterface {
+    plugins: PluginsContainer;
+    args: HandlerArgs;
+    readonly WEBINY_VERSION: string;
+}
+export declare type Context<C0 = Record<string, any>, C1 = Record<string, any>, C2 = Record<string, any>, C3 = Record<string, any>, C4 = Record<string, any>, C5 = Record<string, any>, C6 = Record<string, any>, C7 = Record<string, any>, C8 = Record<string, any>, C9 = Record<string, any>> = {
+    plugins: PluginsContainer;
+    args: HandlerArgs;
+    readonly WEBINY_VERSION: string;
+} & C0 & C1 & C2 & C3 & C4 & C5 & C6 & C7 & C8 & C9;
+export interface BeforeHandlerPlugin<T extends ContextInterface = ContextInterface> extends Plugin {
+    type: "before-handler";
+    apply: (context: T) => Promise<void>;
+}
+export declare type ContextPlugin<C0 = Context, C1 = Context, C2 = Context, C3 = Context, C4 = Context, C5 = Context, C6 = Context, C7 = Context, C8 = Context, C9 = Context> = Plugin & {
+    type: "context";
+    apply(context: C0 & C1 & C2 & C3 & C4 & C5 & C6 & C7 & C8 & C9): Promise<void>;
+};
+export declare type HandlerPlugin<C0 = Context, C1 = Context, C2 = Context, C3 = Context, C4 = Context, C5 = Context, C6 = Context, C7 = Context, C8 = Context, C9 = Context> = Plugin & {
+    type: "handler";
+    handle(context: C0 & C1 & C2 & C3 & C4 & C5 & C6 & C7 & C8 & C9, next: Function): any;
+};
+export declare type HandlerResultPlugin<C0 = Context, C1 = Context, C2 = Context, C3 = Context, C4 = Context, C5 = Context, C6 = Context, C7 = Context, C8 = Context, C9 = Context> = Plugin & {
+    type: "handler-result";
+    handle(context: C0 & C1 & C2 & C3 & C4 & C5 & C6 & C7 & C8 & C9, result: any): any;
+};
+export declare type HandlerErrorPlugin<C0 = Context, C1 = Context, C2 = Context, C3 = Context, C4 = Context, C5 = Context, C6 = Context, C7 = Context, C8 = Context, C9 = Context> = Plugin & {
+    type: "handler-error";
+    handle(context: C0 & C1 & C2 & C3 & C4 & C5 & C6 & C7 & C8 & C9, error: any, next: Function): Promise<any>;
+};

package/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});