@webiny/handler 5.20.0-beta.2 → 5.22.0-beta.0

package/createHandler.js

@@ -7,25 +7,39 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = void 0;
 
-var _plugins = require("@webiny/plugins");
+var _HandlerPlugin = require("./plugins/HandlerPlugin");
+
+var _ContextPlugin = require("./plugins/ContextPlugin");
 
 var _middleware = _interopRequireDefault(require("./middleware"));
 
+var _BeforeHandlerPlugin = require("./plugins/BeforeHandlerPlugin");
+
+var _Context = require("./plugins/Context");
+
+var _HandlerErrorPlugin = require("./plugins/HandlerErrorPlugin");
+
+var _HandlerResultPlugin = require("./plugins/HandlerResultPlugin");
+
 var _default = (...plugins) => async (...args) => {
-  const context = {
-    plugins: new _plugins.PluginsContainer(plugins),
+  const context = new _Context.Context({
+    plugins,
     args,
-    // @ts-ignore
-    // this is injected using webpack.DefinePlugin at build time
+
+    /**
+     * Inserted via webpack on build time.
+     */
     WEBINY_VERSION: process.env.WEBINY_VERSION
-  };
-  const result = await handle(args, context);
-  const handlerPlugins = context.plugins.byType("handler-result");
+  });
+  const result = await handle(context);
+  const handlerPlugins = context.plugins.byType(_HandlerResultPlugin.HandlerResultPlugin.type);
 
   for (let i = 0; i < handlerPlugins.length; i++) {
-    if (handlerPlugins[i].apply) {
-      await handlerPlugins[i].apply(result, context);
+    if (!handlerPlugins[i].handle) {
+      continue;
     }
+
+    await handlerPlugins[i].handle(context, result);
   }
 
   return result;
@@ -33,38 +47,58 @@ var _default = (...plugins) => async (...args) => {
 
 exports.default = _default;
 
-async function handle(_, context) {
+async function handle(context) {
   try {
-    const contextPlugins = context.plugins.byType("context");
+    const contextPlugins = context.plugins.byType(_ContextPlugin.ContextPlugin.type);
 
     for (let i = 0; i < contextPlugins.length; i++) {
-      if (contextPlugins[i].apply) {
-        await contextPlugins[i].apply(context);
+      if (!contextPlugins[i].apply) {
+        continue;
+      }
+
+      await contextPlugins[i].apply(context);
+
+      if (context.hasResult()) {
+        return context.getResult();
       }
     }
 
-    const beforeHandlerPlugins = context.plugins.byType("before-handler");
+    const beforeHandlerPlugins = context.plugins.byType(_BeforeHandlerPlugin.BeforeHandlerPlugin.type);
 
     for (let i = 0; i < beforeHandlerPlugins.length; i++) {
-      if (beforeHandlerPlugins[i].apply) {
-        await beforeHandlerPlugins[i].apply(context);
+      if (!beforeHandlerPlugins[i].apply) {
+        continue;
+      }
+
+      await beforeHandlerPlugins[i].apply(context);
+
+      if (context.hasResult()) {
+        return context.getResult();
       }
     }
 
-    const handlers = context.plugins.byType("handler");
-    const handler = (0, _middleware.default)(handlers.map(pl => pl.handle));
+    const handlers = context.plugins.byType(_HandlerPlugin.HandlerPlugin.type);
+    const handler = (0, _middleware.default)(handlers.map(pl => {
+      return (context, next) => {
+        return pl.handle(context, next);
+      };
+    }));
     const result = await handler(context);
 
     if (!result) {
-      throw Error(`No result was returned from registered handlers.`);
+      throw new 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));
+    const handlers = context.plugins.byType(_HandlerErrorPlugin.HandlerErrorPlugin.type);
+    const handler = (0, _middleware.default)(handlers.map(pl => {
+      return (context, error, next) => {
+        return pl.handle(context, error, next);
+      };
+    }));
     return handler(context, error);
   }
 }

package/index.d.ts

@@ -1 +1,7 @@
 export { default as createHandler } from "./createHandler";
+export * from "./plugins/ContextPlugin";
+export * from "./plugins/Context";
+export * from "./plugins/HandlerPlugin";
+export * from "./plugins/HandlerErrorPlugin";
+export * from "./plugins/HandlerResultPlugin";
+export * from "./plugins/BeforeHandlerPlugin";

package/index.js

@@ -5,6 +5,9 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
+var _exportNames = {
+  createHandler: true
+};
 Object.defineProperty(exports, "createHandler", {
   enumerable: true,
   get: function () {
@@ -12,4 +15,88 @@ Object.defineProperty(exports, "createHandler", {
   }
 });
 
-var _createHandler = _interopRequireDefault(require("./createHandler"));
+var _createHandler = _interopRequireDefault(require("./createHandler"));
+
+var _ContextPlugin = require("./plugins/ContextPlugin");
+
+Object.keys(_ContextPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _ContextPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _ContextPlugin[key];
+    }
+  });
+});
+
+var _Context = require("./plugins/Context");
+
+Object.keys(_Context).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _Context[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _Context[key];
+    }
+  });
+});
+
+var _HandlerPlugin = require("./plugins/HandlerPlugin");
+
+Object.keys(_HandlerPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _HandlerPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _HandlerPlugin[key];
+    }
+  });
+});
+
+var _HandlerErrorPlugin = require("./plugins/HandlerErrorPlugin");
+
+Object.keys(_HandlerErrorPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _HandlerErrorPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _HandlerErrorPlugin[key];
+    }
+  });
+});
+
+var _HandlerResultPlugin = require("./plugins/HandlerResultPlugin");
+
+Object.keys(_HandlerResultPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _HandlerResultPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _HandlerResultPlugin[key];
+    }
+  });
+});
+
+var _BeforeHandlerPlugin = require("./plugins/BeforeHandlerPlugin");
+
+Object.keys(_BeforeHandlerPlugin).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _BeforeHandlerPlugin[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _BeforeHandlerPlugin[key];
+    }
+  });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/handler",
-	"version": "5.20.0-beta.2",
+	"version": "5.22.0-beta.0",
 	"main": "index.js",
 	"license": "MIT",
 	"repository": {
@@ -14,16 +14,17 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@babel/runtime": "7.16.3",
-		"@webiny/plugins": "5.20.0-beta.2"
+		"@babel/runtime": "7.16.7",
+		"@webiny/plugins": "5.22.0-beta.0"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.5.5",
-		"@babel/core": "^7.5.5",
-		"@babel/preset-env": "^7.5.5",
-		"@webiny/cli": "^5.20.0-beta.2",
-		"@webiny/project-utils": "^5.20.0-beta.2",
+		"@babel/cli": "^7.16.0",
+		"@babel/core": "^7.16.0",
+		"@babel/preset-env": "^7.16.4",
+		"@webiny/cli": "^5.22.0-beta.0",
+		"@webiny/project-utils": "^5.22.0-beta.0",
 		"rimraf": "^3.0.2",
+		"ttypescript": "^1.5.13",
 		"typescript": "^4.1.3"
 	},
 	"publishConfig": {
@@ -34,5 +35,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "86c73ea3b5bf71372f255aa24ee8c6ed98466b7f"
+	"gitHead": "487330472a07000c4845340f3b3dfa6b3ae98944"
 }

package/plugins/BeforeHandlerPlugin.d.ts

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

package/plugins/Context.d.ts

@@ -0,0 +1,20 @@
+import { Context as ContextInterface, HandlerArgs } from "../types";
+import { PluginsContainer } from "@webiny/plugins";
+export interface Params {
+    args: HandlerArgs;
+    plugins?: Plugin | Plugin[] | Plugin[][] | PluginsContainer;
+    WEBINY_VERSION: string;
+}
+export declare class Context implements ContextInterface {
+    _result: any;
+    private readonly _plugins;
+    private readonly _args;
+    private readonly _version;
+    get plugins(): PluginsContainer;
+    get args(): HandlerArgs;
+    get WEBINY_VERSION(): string;
+    constructor(params: Params);
+    getResult(): any;
+    hasResult(): boolean;
+    setResult(value: any): void;
+}

package/plugins/Context.js

@@ -0,0 +1,56 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Context = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class Context {
+  get plugins() {
+    return this._plugins;
+  }
+
+  get args() {
+    return this._args;
+  }
+
+  get WEBINY_VERSION() {
+    return this._version;
+  }
+
+  constructor(params) {
+    (0, _defineProperty2.default)(this, "_result", void 0);
+    (0, _defineProperty2.default)(this, "_plugins", void 0);
+    (0, _defineProperty2.default)(this, "_args", void 0);
+    (0, _defineProperty2.default)(this, "_version", void 0);
+    const {
+      plugins,
+      args,
+      WEBINY_VERSION
+    } = params;
+    this._plugins = new _plugins.PluginsContainer(plugins || []);
+    this._args = args;
+    this._version = WEBINY_VERSION;
+  }
+
+  getResult() {
+    return this._result;
+  }
+
+  hasResult() {
+    return !!this._result;
+  }
+
+  setResult(value) {
+    this._result = value;
+  }
+
+}
+
+exports.Context = Context;

package/plugins/ContextPlugin.d.ts

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

package/plugins/HandlerErrorPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+import { Context } from "../types";
+export interface HandlerErrorCallable<T extends Context = Context> {
+    (context: T, error: Error, next: Function): Promise<any>;
+}
+export declare class HandlerErrorPlugin<T extends Context = Context> extends Plugin {
+    static readonly type: string;
+    private readonly _callable;
+    constructor(callable: HandlerErrorCallable<T>);
+    handle(context: T, error: Error, next: Function): Promise<any>;
+}

package/plugins/HandlerErrorPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HandlerErrorPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class HandlerErrorPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "_callable", void 0);
+    this._callable = callable;
+  }
+
+  async handle(context, error, next) {
+    return this._callable(context, error, next);
+  }
+
+}
+
+exports.HandlerErrorPlugin = HandlerErrorPlugin;
+(0, _defineProperty2.default)(HandlerErrorPlugin, "type", "handler-error");

package/plugins/HandlerPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+import { Context } from "../types";
+export interface HandlerCallable<T extends Context = Context> {
+    (context: T, next: Function): Promise<any>;
+}
+export declare class HandlerPlugin<T extends Context = Context> extends Plugin {
+    static readonly type: string;
+    private readonly _callable;
+    constructor(callable: HandlerCallable<T>);
+    handle(context: T, next: Function): Promise<any>;
+}

package/plugins/HandlerPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HandlerPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class HandlerPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "_callable", void 0);
+    this._callable = callable;
+  }
+
+  async handle(context, next) {
+    return this._callable(context, next);
+  }
+
+}
+
+exports.HandlerPlugin = HandlerPlugin;
+(0, _defineProperty2.default)(HandlerPlugin, "type", "handler");

package/plugins/HandlerResultPlugin.d.ts

@@ -0,0 +1,11 @@
+import { Plugin } from "@webiny/plugins";
+import { Context } from "../types";
+export interface HandlerResultCallable<T extends Context = Context> {
+    (context: T, result: any): Promise<any>;
+}
+export declare class HandlerResultPlugin<T extends Context = Context> extends Plugin {
+    static readonly type: string;
+    private readonly _callable;
+    constructor(callable: HandlerResultCallable<T>);
+    handle(context: T, result: any): Promise<any>;
+}

package/plugins/HandlerResultPlugin.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.HandlerResultPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class HandlerResultPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "_callable", void 0);
+    this._callable = callable;
+  }
+
+  async handle(context, result) {
+    return this._callable(context, result);
+  }
+
+}
+
+exports.HandlerResultPlugin = HandlerResultPlugin;
+(0, _defineProperty2.default)(HandlerResultPlugin, "type", "handler-result");

package/types.d.ts

@@ -1,36 +1,77 @@
 import { Plugin, PluginsContainer } from "@webiny/plugins/types";
 export declare type HandlerArgs = any[];
-export interface HandlerContext {
+/**
+ * Left for backwards compatibility.
+ * @deprecated
+ */
+export declare type HandlerContext = Context;
+/**
+ * The main context which is constructed on every request.
+ * All other contexts should extend this one.
+ */
+export interface Context {
     plugins: PluginsContainer;
     args: HandlerArgs;
     readonly WEBINY_VERSION: string;
+    /**
+     * Not to be used outside of Webiny internal code.
+     * @internal
+     */
+    hasResult: () => boolean;
+    /**
+     * Not to be used outside of Webiny internal code.
+     * @internal
+     *
+     * @private
+     */
+    _result?: any;
+    /**
+     * Not to be used outside of Webiny internal code.
+     * @internal
+     */
+    setResult: (value: any) => void;
+    /**
+     * Not to be used outside of Webiny internal code.
+     * @internal
+     */
+    getResult: () => void;
 }
-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>;
-}
+/**
+ * Left for backwards-compatibility.
+ *
+ * @internal
+ * @deprecated
+ */
 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>;
 };
+/**
+ * Left for backwards-compatibility.
+ *
+ * @internal
+ * @deprecated
+ */
 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;
 };
+/**
+ * Left for backwards-compatibility.
+ *
+ * @internal
+ * @deprecated
+ */
 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;
 };
+/**
+ * Left for backwards-compatibility.
+ *
+ * @internal
+ * @deprecated
+ */
 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>;