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

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.21.0-beta.0",
+	"version": "5.22.0-beta.2",
 	"main": "index.js",
 	"license": "MIT",
 	"repository": {
@@ -14,16 +14,17 @@
 		"Adrian Smijulj <adrian@webiny.com>"
 	],
 	"dependencies": {
-		"@babel/runtime": "7.16.3",
-		"@webiny/plugins": "5.21.0-beta.0"
+		"@babel/runtime": "7.16.7",
+		"@webiny/plugins": "5.22.0-beta.2"
 	},
 	"devDependencies": {
-		"@babel/cli": "^7.5.5",
-		"@babel/core": "^7.5.5",
-		"@babel/preset-env": "^7.5.5",
-		"@webiny/cli": "^5.21.0-beta.0",
-		"@webiny/project-utils": "^5.21.0-beta.0",
+		"@babel/cli": "^7.16.0",
+		"@babel/core": "^7.16.0",
+		"@babel/preset-env": "^7.16.4",
+		"@webiny/cli": "^5.22.0-beta.2",
+		"@webiny/project-utils": "^5.22.0-beta.2",
 		"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": "cad155812edbdd577a1cc858b41038fdd7a6d2d9"
+	"gitHead": "c472d20682885fb538354c206a148deaae14bfe8"
 }

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,19 @@
+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;
+    readonly plugins: PluginsContainer;
+    readonly args: HandlerArgs;
+    readonly WEBINY_VERSION: string;
+    private readonly waiters;
+    constructor(params: Params);
+    getResult(): any;
+    hasResult(): boolean;
+    setResult(value: any): void;
+    waitFor<T extends ContextInterface = ContextInterface>(obj: string | string[], cb: (context: T) => void): void;
+}

package/plugins/Context.js

@@ -0,0 +1,138 @@
+"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 {
+  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, "WEBINY_VERSION", void 0);
+    (0, _defineProperty2.default)(this, "waiters", []);
+    const {
+      plugins,
+      args,
+      WEBINY_VERSION
+    } = params;
+    this.plugins = new _plugins.PluginsContainer(plugins || []);
+    this.args = args || [];
+    this.WEBINY_VERSION = WEBINY_VERSION;
+  }
+
+  getResult() {
+    return this._result;
+  }
+
+  hasResult() {
+    return !!this._result;
+  }
+
+  setResult(value) {
+    this._result = value;
+  }
+
+  waitFor(obj, cb) {
+    const initialTargets = Array.isArray(obj) ? obj : [obj];
+    const targets = [];
+    /**
+     * We go only through the first level properties
+     */
+
+    for (const target of initialTargets) {
+      /**
+       * If property already exists, there is no need to wait for it, so we just continue the loop.
+       */
+      if (this[target]) {
+        continue;
+      }
+      /**
+       * Since there is no property, we must define it with its setter and getter.
+       * We could not know when it got defined otherwise.
+       */
+
+
+      Object.defineProperty(this, target, {
+        /**
+         * Setter sets the given value to this object.
+         * We cannot set it on exact property name it is defined because it would go into loop of setting itself.
+         * And that is why we add __ around the property name.
+         */
+        set: value => {
+          this[`__${target}__`] = value;
+          /**
+           * WWhen the property is set, we will go through all the waiters and, if any of them include currently set property, act on it.
+           */
+
+          for (const waiter of this.waiters) {
+            if (waiter.targets.includes(target) === false) {
+              continue;
+            }
+            /**
+             * Remove currently set property so we know if there are any more to be waited for.
+             */
+
+
+            waiter.targets = waiter.targets.filter(t => t !== target);
+            /**
+             * If there are more to be waited, eg. user added [cms, pageBuilder] as waited properties, we just continue the loop.
+             */
+
+            if (waiter.targets.length > 0) {
+              continue;
+            }
+            /**
+             * And if there is nothing more to be waited for, we execute the callable.
+             * Note that this callable is not async.
+             */
+
+
+            waiter.cb(this);
+          }
+        },
+
+        /**
+         * As we have set property with __ around it, we must get it as well.
+         */
+        get: () => {
+          return this[`__${target}__`];
+        },
+        configurable: false
+      });
+      /**
+       * We add the target to be awaited.
+       */
+
+      targets.push(target);
+    }
+    /**
+     * If there are no targets to be awaited, just fire the callable.
+     */
+
+
+    if (targets.length === 0) {
+      cb(this);
+      return;
+    }
+    /**
+     * Otherwise add the waiter for the target properties.
+     */
+
+
+    this.waiters.push({
+      targets,
+      cb
+    });
+  }
+
+}
+
+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,82 @@
 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;
+    /**
+     * Wait for property to be defined on the object and then execute the callable.
+     * In case of multiple objects defined, wait for all of them.
+     */
+    waitFor: <T extends Context = Context>(obj: string[] | string, cb: (context: T) => void) => 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>;