@lowdefy/engine 0.0.0-alpha.7 → 0.0.0-experimental-20231123124425

package/dist/Actions.js

@@ -1,503 +1,248 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
-var _makeContextId = _interopRequireDefault(require("./makeContextId"));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
-
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-
-class Actions {
-  constructor(context) {
-    this.context = context;
-    this.build = this.build.bind(this);
-    this.callMethod = this.callMethod.bind(this);
-    this.request = this.request.bind(this);
-    this.link = this.link.bind(this);
-    this.message = this.message.bind(this);
-    this.reset = this.reset.bind(this);
-    this.scrollTo = this.scrollTo.bind(this);
-    this.setGlobal = this.setGlobal.bind(this);
-    this.setState = this.setState.bind(this);
-    this.validate = this.validate.bind(this);
-    this.actions = {
-      CallMethod: this.callMethod,
-      Request: this.request,
-      Link: this.link,
-      Message: this.message,
-      Reset: this.reset,
-      ScrollTo: this.scrollTo,
-      SetGlobal: this.setGlobal,
-      SetState: this.setState,
-      Validate: this.validate
-    };
-  }
-
-  static invalidAction(action) {
-    return () => Promise.reject({
-      errorMessage: action.error || 'Invalid action',
-      error: new Error("Invalid action: ".concat(JSON.stringify(action)))
-    });
-  }
-
-  build(actions) {
-    return actions.map(action => _objectSpread(_objectSpread({}, action), {}, {
-      fn: (_ref) => {
-        var {
-          args,
-          arrayIndices,
-          blockId
-        } = _ref;
-        return (0, _helpers.get)(this.actions, action.type, {
-          default: Actions.invalidAction(action)
-        })(action.params, action.success, action.error, args, arrayIndices, blockId);
-      }
-    }));
-  }
-
-  reset(_, successMessage, errorMessage) {
-    try {
-      this.context.State.resetState();
-      this.context.RootBlocks.reset(_helpers.serializer.deserializeFromString(this.context.State.frozenState));
-      this.context.update(); // Consider firing onReset and onResetAsync actions
-    } catch (error) {
-      // log e
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to reset page.',
-        error
-      });
+/*
+  Copyright 2020-2023 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/ import { type } from '@lowdefy/helpers';
+import getActionMethods from './actions/getActionMethods.js';
+let Actions = class Actions {
+    async callAsyncAction({ action, arrayIndices, block, event, index, responses }) {
+        try {
+            const response = await this.callAction({
+                action,
+                arrayIndices,
+                block,
+                event,
+                index,
+                responses
+            });
+            responses[action.id] = response;
+        } catch (error) {
+            responses[action.id] = error;
+            console.error(error);
+        }
     }
-  }
-
-  callMethod(params, successMessage, errorMessage, _, arrayIndices) {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      // TODO: add callMethod on block and use instead
-      try {
-        var {
-          blockId,
-          method,
-          args
-        } = params;
-
-        var blockMethod = _this.context.RootBlocks.map[(0, _helpers.applyArrayIndices)(arrayIndices, blockId)].methods[method];
-
-        var response;
-
-        if (_helpers.type.isArray(args)) {
-          response = yield blockMethod(...args);
-        } else {
-          response = yield blockMethod(args);
+    async callActionLoop({ actions, arrayIndices, block, event, progress, responses }) {
+        for (const [index, action] of actions.entries()){
+            try {
+                if (action.async === true) {
+                    this.callAsyncAction({
+                        action,
+                        arrayIndices,
+                        block,
+                        event,
+                        index,
+                        progress,
+                        responses
+                    });
+                } else {
+                    const response = await this.callAction({
+                        action,
+                        arrayIndices,
+                        block,
+                        event,
+                        index,
+                        progress,
+                        responses
+                    });
+                    responses[action.id] = response;
+                }
+            } catch (error) {
+                responses[action.id] = error;
+                throw {
+                    error,
+                    action
+                };
+            }
+        }
+    }
+    async callActions({ actions, arrayIndices, block, catchActions, event, eventName, progress }) {
+        const startTimestamp = new Date();
+        const responses = {};
+        try {
+            await this.callActionLoop({
+                actions,
+                arrayIndices,
+                block,
+                event,
+                responses,
+                progress
+            });
+        } catch (error) {
+            console.error(error);
+            try {
+                await this.callActionLoop({
+                    actions: catchActions,
+                    arrayIndices,
+                    block,
+                    event,
+                    responses,
+                    progress
+                });
+            } catch (errorCatch) {
+                console.error(errorCatch);
+                return {
+                    blockId: block.blockId,
+                    bounced: false,
+                    endTimestamp: new Date(),
+                    error,
+                    errorCatch,
+                    event,
+                    eventName,
+                    responses,
+                    startTimestamp,
+                    success: false
+                };
+            }
+            return {
+                blockId: block.blockId,
+                bounced: false,
+                endTimestamp: new Date(),
+                error,
+                event,
+                eventName,
+                responses,
+                startTimestamp,
+                success: false
+            };
         }
-
         return {
-          successMessage,
-          response
+            blockId: block.blockId,
+            bounced: false,
+            endTimestamp: new Date(),
+            event,
+            eventName,
+            responses,
+            startTimestamp,
+            success: true
         };
-      } catch (error) {
-        // log e
-        return Promise.reject({
-          errorMessage: errorMessage || 'Failed to callMethod.',
-          error
-        });
-      }
-    })();
-  }
-
-  request(params, successMessage, errorMessage, args, arrayIndices) {
-    if (_helpers.type.isNone(params)) {
-      // Should this resolve or error
-      return Promise.resolve();
     }
-
-    if (params.all === true) {
-      return this.context.Requests.callRequests({
-        args,
-        arrayIndices
-      }).then(response => ({
-        successMessage,
-        response
-      })).catch(error => {
-        if (errorMessage) {
-          return Promise.reject({
-            errorMessage,
-            error
-          });
-        }
-
-        try {
-          var {
-            displayTitle,
-            displayMessage
-          } = error.graphQLErrors[0].extensions;
-          return Promise.reject({
-            errorMessage: "".concat(displayTitle, ": ").concat(displayMessage),
-            error
-          });
-        } catch (e) {// Not a graphQLError, displayTitle, displayMessage do not exist
+    async callAction({ action, arrayIndices, block, event, index, progress, responses }) {
+        if (!this.actions[action.type]) {
+            throw {
+                error: new Error(`Invalid action type "${action.type}" at "${block.blockId}".`),
+                type: action.type,
+                index
+            };
         }
-
-        return Promise.reject({
-          errorMessage: error.message,
-          error
+        const { output: parsedAction, errors: parserErrors } = this.context._internal.parser.parse({
+            actions: responses,
+            event,
+            arrayIndices,
+            input: action,
+            location: block.blockId
         });
-      });
-    }
-
-    if (_helpers.type.isString(params)) {
-      return this.context.Requests.callRequest({
-        requestId: params,
-        args,
-        arrayIndices
-      }).then(response => ({
-        successMessage,
-        response
-      })).catch(error => {
-        if (errorMessage) {
-          return Promise.reject({
-            errorMessage,
-            error
-          });
+        if (parserErrors.length > 0) {
+            throw {
+                error: parserErrors[0],
+                type: action.type,
+                index
+            };
         }
-
-        try {
-          var {
-            displayTitle,
-            displayMessage
-          } = error.graphQLErrors[0].extensions;
-          return Promise.reject({
-            errorMessage: "".concat(displayTitle, ": ").concat(displayMessage),
-            error
-          });
-        } catch (e) {// Not a graphQLError, displayTitle, displayMessage do not exist
+        if (parsedAction.skip === true) {
+            return {
+                type: action.type,
+                skipped: true,
+                index
+            };
         }
-
-        return Promise.reject({
-          errorMessage: error.message,
-          error
+        const messages = parsedAction.messages || {};
+        let response;
+        const closeLoading = this.displayMessage({
+            defaultMessage: 'Loading',
+            duration: 0,
+            message: messages.loading,
+            status: 'loading'
         });
-      });
-    }
-
-    if (_helpers.type.isArray(params)) {
-      return this.context.Requests.callRequests({
-        requestIds: params,
-        args,
-        arrayIndices
-      }).then(response => ({
-        successMessage,
-        response
-      })).catch(error => {
-        if (errorMessage) {
-          return Promise.reject({
-            errorMessage,
-            error
-          });
-        }
-
         try {
-          var {
-            displayTitle,
-            displayMessage
-          } = error.graphQLErrors[0].extensions;
-          return Promise.reject({
-            errorMessage: "".concat(displayTitle, ": ").concat(displayMessage),
-            error
-          });
-        } catch (e) {// Not a graphQLError, displayTitle, displayMessage do not exist
+            response = await this.actions[action.type]({
+                globals: this.context._internal.lowdefy._internal.globals,
+                methods: getActionMethods({
+                    actions: responses,
+                    arrayIndices,
+                    blockId: block.blockId,
+                    context: this.context,
+                    event
+                }),
+                params: parsedAction.params
+            });
+            if (progress) {
+                progress();
+            }
+        } catch (error) {
+            responses[action.id] = {
+                error,
+                index,
+                type: action.type
+            };
+            const { output: parsedMessages, errors: parserErrors } = this.context._internal.parser.parse({
+                actions: responses,
+                event,
+                arrayIndices,
+                input: action.messages,
+                location: block.blockId
+            });
+            if (parserErrors.length > 0) {
+                // this condition is very unlikely since parser errors usually occur in the first parse.
+                throw {
+                    error: parserErrors[0],
+                    type: action.type,
+                    index
+                };
+            }
+            closeLoading();
+            this.displayMessage({
+                defaultMessage: error.message,
+                duration: 6,
+                hideExplicitly: true,
+                message: (parsedMessages || {}).error,
+                status: 'error'
+            });
+            throw {
+                type: action.type,
+                error,
+                index
+            };
         }
-
-        return Promise.reject({
-          errorMessage: error.message,
-          error
+        closeLoading();
+        this.displayMessage({
+            defaultMessage: 'Success',
+            message: messages.success,
+            status: 'success'
         });
-      });
-    }
-
-    return Promise.reject({
-      errorMessage: errorMessage || "Failed to call request.",
-      error: new Error("Invalid _request params: ".concat(params))
-    });
-  }
-
-  message() {
-    var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-    var successMessage = arguments.length > 1 ? arguments[1] : undefined;
-    var errorMessage = arguments.length > 2 ? arguments[2] : undefined;
-    var args = arguments.length > 3 ? arguments[3] : undefined;
-    var arrayIndices = arguments.length > 4 ? arguments[4] : undefined;
-    var blockId = arguments.length > 5 ? arguments[5] : undefined;
-
-    try {
-      var {
-        output: parsed,
-        errors: parseErrors
-      } = this.context.parser.parse({
-        args,
-        arrayIndices,
-        input: params,
-        location: blockId
-      });
-
-      if (parseErrors.length > 0) {
-        return Promise.reject({
-          errorMessage: errorMessage || "Message failed.",
-          error: parseErrors
-        });
-      }
-
-      this.context.displayMessage[parsed.status || 'success']({
-        content: parsed.content || 'Success',
-        duration: _helpers.type.isNone(parsed.duration) ? 5 : parsed.duration
-      });
-      return Promise.resolve({
-        successMessage
-      });
-    } catch (error) {
-      return Promise.reject({
-        errorMessage: errorMessage || "Message failed.",
-        error
-      });
-    }
-  }
-
-  setState(value, successMessage, errorMessage, args, arrayIndices, blockId) {
-    try {
-      var {
-        output: parsed,
-        errors: stateParseErrors
-      } = this.context.parser.parse({
-        args,
-        arrayIndices,
-        input: value,
-        location: blockId
-      });
-
-      if (stateParseErrors.length > 0) {
-        return Promise.reject({
-          errorMessage: errorMessage || 'Failed to set state due to parser error.',
-          error: stateParseErrors
-        });
-      }
-
-      Object.keys(parsed).forEach(key => {
-        this.context.State.set((0, _helpers.applyArrayIndices)(arrayIndices, key), parsed[key]);
-      });
-      this.context.RootBlocks.reset();
-      this.context.update();
-    } catch (error) {
-      // log e
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to set state.',
-        error
-      });
-    }
-
-    return Promise.resolve({
-      successMessage
-    });
-  }
-
-  setGlobal(value, successMessage, errorMessage, args, arrayIndices, blockId) {
-    try {
-      var {
-        output: parsed,
-        errors: globalParseErrors
-      } = this.context.parser.parse({
-        args,
-        arrayIndices,
-        input: value,
-        location: blockId
-      });
-
-      if (globalParseErrors.length > 0) {
-        return Promise.reject({
-          errorMessage: errorMessage || 'Failed to set global due to parser error.',
-          error: globalParseErrors
-        });
-      }
-
-      Object.keys(parsed).forEach(key => {
-        (0, _helpers.set)(this.context.lowdefyGlobal, (0, _helpers.applyArrayIndices)(arrayIndices, key), parsed[key]);
-      });
-      this.context.RootBlocks.reset();
-      this.context.update();
-    } catch (error) {
-      // log e
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to set global.',
-        error
-      });
-    }
-
-    return Promise.resolve({
-      successMessage
-    });
-  }
-
-  scrollTo(params, successMessage, errorMessage, args, arrayIndices, blockId) {
-    var {
-      output: parsedParams,
-      errors: parserErrors
-    } = this.context.parser.parse({
-      args,
-      arrayIndices,
-      input: params,
-      location: blockId
-    });
-
-    if (parserErrors.length > 0) {
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to scroll due to parser error.',
-        error: parserErrors
-      });
-    }
-
-    try {
-      if (parsedParams) {
-        if (parsedParams.blockId) {
-          var element = this.context.document.getElementById(parsedParams.blockId);
-
-          if (element) {
-            element.scrollIntoView(parsedParams.options);
-          }
-        } else {
-          this.context.window.scrollTo(parsedParams);
-        }
-      }
-    } catch (error) {
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to scroll.',
-        error
-      });
-    }
-
-    return Promise.resolve({
-      successMessage
-    });
-  }
-
-  link(params, successMessage, errorMessage, args, arrayIndices, blockId) {
-    var {
-      output: parsedParams,
-      errors: parserErrors
-    } = this.context.parser.parse({
-      args,
-      arrayIndices,
-      input: params,
-      location: blockId
-    });
-
-    if (parserErrors.length > 0) {
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to follow page link due to parser error.',
-        error: parserErrors
-      });
+        return {
+            type: action.type,
+            response,
+            index
+        };
     }
-
-    try {
-      var lowdefyUrlQuery = _helpers.type.isNone(parsedParams.urlQuery) ? '' : "?".concat(_helpers.urlQuery.stringify(parsedParams.urlQuery));
-      var pageId;
-
-      if (_helpers.type.isString(parsedParams)) {
-        // eslint-disable-next-line no-const-assign
-        pageId = parsedParams;
-      }
-
-      if (parsedParams.pageId) {
-        pageId = parsedParams.pageId;
-      }
-
-      if (pageId) {
-        // set input for page before changing
-        if (!_helpers.type.isNone(parsedParams.input)) {
-          var nextContextId = (0, _makeContextId.default)({
-            pageId,
-            search: parsedParams.urlQuery,
-            blockId: pageId
-          });
-          this.context.allInputs[nextContextId] = parsedParams.input;
-        }
-
-        if (parsedParams.newWindow) {
-          this.context.window.open("".concat(this.context.window.location.origin, "/").concat(pageId).concat(lowdefyUrlQuery), '_blank').focus();
-        } else {
-          this.context.routeHistory.push("/".concat(pageId).concat(lowdefyUrlQuery));
-        }
-      } else if (parsedParams.url) {
-        if (parsedParams.newWindow) {
-          this.context.window.open("".concat(parsedParams.url).concat(lowdefyUrlQuery), '_blank').focus();
-        } else {
-          this.context.window.location.href = "".concat(parsedParams.url).concat(lowdefyUrlQuery);
+    displayMessage({ defaultMessage, duration, hideExplicitly, message, status }) {
+        let close = ()=>undefined;
+        if (hideExplicitly && message !== false || !hideExplicitly && !type.isNone(message)) {
+            close = this.context._internal.lowdefy._internal.displayMessage({
+                content: type.isString(message) ? message : defaultMessage,
+                duration,
+                status
+            });
         }
-      } else if (parsedParams.home) {
-        if (parsedParams.newWindow) {
-          this.context.window.open("".concat(this.context.window.location.origin, "/").concat(lowdefyUrlQuery), '_blank').focus();
-        } else {
-          this.context.routeHistory.push("/".concat(lowdefyUrlQuery));
-        }
-      }
-    } catch (error) {
-      return Promise.reject({
-        errorMessage: errorMessage || 'Failed to follow link.',
-        error
-      });
+        return close;
     }
-
-    return Promise.resolve({
-      successMessage
-    });
-  }
-
-  validate(params, successMessage, errorMessage) {
-    try {
-      if (!_helpers.type.isNone(params) && !_helpers.type.isString(params) && !_helpers.type.isArray(params)) {
-        throw new Error('Invalid validate params.');
-      }
-
-      this.context.showValidationErrors = true;
-      var validationErrors = this.context.RootBlocks.validate();
-
-      if (params) {
-        var blockIds = _helpers.type.isString(params) ? [params] : params;
-        validationErrors = validationErrors.filter(block => {
-          return blockIds.includes(block.blockId);
-        });
-      }
-
-      if (validationErrors.length > 0) {
-        return Promise.reject({
-          errorMessage: errorMessage || "Your input has ".concat(validationErrors.length, " validation error").concat(validationErrors.length !== 1 ? 's' : '', ".")
-        });
-      }
-    } catch (error) {
-      return Promise.reject({
-        errorMessage: 'Failed to validate page input.',
-        error
-      });
+    constructor(context){
+        this.context = context;
+        this.callAction = this.callAction.bind(this);
+        this.callActionLoop = this.callActionLoop.bind(this);
+        this.callActions = this.callActions.bind(this);
+        this.displayMessage = this.displayMessage.bind(this);
+        this.actions = context._internal.lowdefy._internal.actions;
     }
-
-    return Promise.resolve({
-      successMessage
-    });
-  }
-
-}
-
-var _default = Actions;
-exports.default = _default;
+};
+export default Actions;