@webiny/handler 5.22.0-beta.1 → 5.22.0-beta.2

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/handler",
-	"version": "5.22.0-beta.1",
+	"version": "5.22.0-beta.2",
 	"main": "index.js",
 	"license": "MIT",
 	"repository": {
@@ -15,14 +15,14 @@
 	],
 	"dependencies": {
 		"@babel/runtime": "7.16.7",
-		"@webiny/plugins": "5.22.0-beta.1"
+		"@webiny/plugins": "5.22.0-beta.2"
 	},
 	"devDependencies": {
 		"@babel/cli": "^7.16.0",
 		"@babel/core": "^7.16.0",
 		"@babel/preset-env": "^7.16.4",
-		"@webiny/cli": "^5.22.0-beta.1",
-		"@webiny/project-utils": "^5.22.0-beta.1",
+		"@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"
@@ -35,5 +35,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "b651010b23f28b3ce1c27130713322ce65b32dcd"
+	"gitHead": "c472d20682885fb538354c206a148deaae14bfe8"
 }

package/plugins/Context.d.ts

@@ -1,20 +1,19 @@
 import { Context as ContextInterface, HandlerArgs } from "../types";
 import { PluginsContainer } from "@webiny/plugins";
 export interface Params {
-    args: HandlerArgs;
+    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;
+    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

@@ -12,31 +12,20 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 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);
+    (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._version = WEBINY_VERSION;
+    this.plugins = new _plugins.PluginsContainer(plugins || []);
+    this.args = args || [];
+    this.WEBINY_VERSION = WEBINY_VERSION;
   }
 
   getResult() {
@@ -51,6 +40,99 @@ class Context {
     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/types.d.ts

@@ -35,6 +35,11 @@ export interface Context {
      * @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;
 }
 /**
  * Left for backwards-compatibility.