@lowdefy/engine 3.22.0 → 4.0.0-alpha.1

package/dist/Events.js

@@ -1,166 +1,124 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _helpers = require("@lowdefy/helpers");
-
-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); }); }; }
-
-class Events {
-  constructor(_ref) {
-    var {
-      arrayIndices,
-      block,
-      context
-    } = _ref;
-    this.defaultDebounceMs = 300;
-    this.events = {};
-    this.timeouts = {};
-    this.arrayIndices = arrayIndices;
-    this.block = block;
-    this.context = context;
-    this.init = this.init.bind(this);
-    this.triggerEvent = this.triggerEvent.bind(this);
-    this.registerEvent = this.registerEvent.bind(this);
-    this.initEvent = this.initEvent.bind(this);
-    this.init();
-  }
-
-  initEvent(actions) {
-    return {
-      actions: (_helpers.type.isObject(actions) ? actions.try : actions) || [],
-      catchActions: (_helpers.type.isObject(actions) ? actions.catch : []) || [],
-      debounce: _helpers.type.isObject(actions) ? actions.debounce : null,
-      history: [],
-      loading: false
-    };
-  }
-
-  init() {
-    Object.keys(this.block.events).forEach(eventName => {
-      this.events[eventName] = this.initEvent(this.block.events[eventName]);
-    });
-  }
-
-  registerEvent(_ref2) {
-    var {
-      name,
-      actions
-    } = _ref2;
-    this.events[name] = this.initEvent(actions);
-  }
-
-  triggerEvent(_ref3) {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      var {
-        name,
-        event
-      } = _ref3;
-      var eventDescription = _this.events[name];
-      var result = {
-        blockId: _this.block.blockId,
-        event,
-        eventName: name,
-        responses: {},
-        endTimestamp: new Date(),
-        startTimestamp: new Date(),
-        success: true,
-        bounced: false
-      }; // no event
-
-      if (_helpers.type.isUndefined(eventDescription)) {
-        return result;
-      }
-
-      eventDescription.loading = true;
-      _this.block.update = true;
-
-      _this.context.update();
-
-      var actionHandle = /*#__PURE__*/function () {
-        var _ref4 = _asyncToGenerator(function* () {
-          var res = yield _this.context.Actions.callActions({
-            actions: eventDescription.actions,
-            arrayIndices: _this.arrayIndices,
-            block: _this.block,
-            catchActions: eventDescription.catchActions,
+/*
+  Copyright 2020-2021 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';
+let Events = class Events {
+    initEvent(actions) {
+        return {
+            actions: (type.isObject(actions) ? actions.try : actions) || [],
+            catchActions: (type.isObject(actions) ? actions.catch : []) || [],
+            debounce: type.isObject(actions) ? actions.debounce : null,
+            history: [],
+            loading: false
+        };
+    }
+    init() {
+        Object.keys(this.block.events).forEach((eventName)=>{
+            this.events[eventName] = this.initEvent(this.block.events[eventName]);
+        });
+    }
+    registerEvent({ name , actions: actions1  }) {
+        this.events[name] = this.initEvent(actions1);
+    }
+    async triggerEvent({ name: name1 , event  }) {
+        const eventDescription = this.events[name1];
+        let result = {
+            blockId: this.block.blockId,
             event,
-            eventName: name
-          });
-          eventDescription.history.unshift(res);
-
-          _this.context.eventLog.unshift(res);
-
-          eventDescription.loading = false;
-          _this.block.update = true;
-
-          _this.context.update();
-
-          return res;
+            eventName: name1,
+            responses: {
+            },
+            endTimestamp: new Date(),
+            startTimestamp: new Date(),
+            success: true,
+            bounced: false
+        };
+        // no event
+        if (type.isUndefined(eventDescription)) {
+            return result;
+        }
+        eventDescription.loading = true;
+        this.block.update = true;
+        this.context._internal.update();
+        const actionHandle = async ()=>{
+            const res = await this.context._internal.Actions.callActions({
+                actions: eventDescription.actions,
+                arrayIndices: this.arrayIndices,
+                block: this.block,
+                catchActions: eventDescription.catchActions,
+                event,
+                eventName: name1
+            });
+            eventDescription.history.unshift(res);
+            this.context.eventLog.unshift(res);
+            eventDescription.loading = false;
+            this.block.update = true;
+            this.context._internal.update();
+            return res;
+        };
+        // no debounce
+        if (type.isNone(eventDescription.debounce)) {
+            return actionHandle();
+        }
+        const delay = !type.isNone(eventDescription.debounce.ms) ? eventDescription.debounce.ms : this.defaultDebounceMs;
+        // leading edge: bounce
+        if (this.timeouts[name1] && eventDescription.debounce.immediate === true) {
+            result.bounced = true;
+            eventDescription.history.unshift(result);
+            this.context.eventLog.unshift(result);
+            return result;
+        }
+        // leading edge: trigger
+        if (eventDescription.debounce.immediate === true) {
+            this.timeouts[name1] = setTimeout(()=>{
+                this.timeouts[name1] = null;
+            }, delay);
+            return actionHandle();
+        }
+        // trailing edge
+        if (eventDescription.bouncer) {
+            eventDescription.bouncer();
+        }
+        return new Promise((resolve)=>{
+            const timeout = setTimeout(async ()=>{
+                eventDescription.bouncer = null;
+                const res = await actionHandle();
+                resolve(res);
+            }, delay);
+            eventDescription.bouncer = ()=>{
+                clearTimeout(timeout);
+                result.bounced = true;
+                eventDescription.history.unshift(result);
+                this.context.eventLog.unshift(result);
+                resolve(result);
+            };
         });
-
-        return function actionHandle() {
-          return _ref4.apply(this, arguments);
+    }
+    constructor({ arrayIndices , block , context  }){
+        this.defaultDebounceMs = 300;
+        this.events = {
         };
-      }(); // no debounce
-
-
-      if (_helpers.type.isNone(eventDescription.debounce)) {
-        return actionHandle();
-      }
-
-      var delay = !_helpers.type.isNone(eventDescription.debounce.ms) ? eventDescription.debounce.ms : _this.defaultDebounceMs; // leading edge: bounce
-
-      if (_this.timeouts[name] && eventDescription.debounce.immediate === true) {
-        result.bounced = true;
-        eventDescription.history.unshift(result);
-
-        _this.context.eventLog.unshift(result);
-
-        return result;
-      } // leading edge: trigger
-
-
-      if (eventDescription.debounce.immediate === true) {
-        _this.timeouts[name] = setTimeout(() => {
-          _this.timeouts[name] = null;
-        }, delay);
-        return actionHandle();
-      } // trailing edge
-
-
-      if (eventDescription.bouncer) {
-        eventDescription.bouncer();
-      }
-
-      return new Promise(resolve => {
-        var timeout = setTimeout( /*#__PURE__*/_asyncToGenerator(function* () {
-          eventDescription.bouncer = null;
-          var res = yield actionHandle();
-          resolve(res);
-        }), delay);
-
-        eventDescription.bouncer = () => {
-          clearTimeout(timeout);
-          result.bounced = true;
-          eventDescription.history.unshift(result);
-
-          _this.context.eventLog.unshift(result);
-
-          resolve(result);
+        this.timeouts = {
         };
-      });
-    })();
-  }
-
-}
-
-var _default = Events;
-exports.default = _default;
+        this.arrayIndices = arrayIndices;
+        this.block = block;
+        this.context = context;
+        this.init = this.init.bind(this);
+        this.triggerEvent = this.triggerEvent.bind(this);
+        this.registerEvent = this.registerEvent.bind(this);
+        this.initEvent = this.initEvent.bind(this);
+        this.init();
+    }
+};
+export default Events;

package/dist/Requests.js

@@ -1,147 +1,113 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-
-var _graphqlTag = _interopRequireDefault(require("graphql-tag"));
-
-var _helpers = require("@lowdefy/helpers");
-
-var _templateObject;
-
-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 _taggedTemplateLiteral(strings, raw) { if (!raw) { raw = strings.slice(0); } return Object.freeze(Object.defineProperties(strings, { raw: { value: Object.freeze(raw) } })); }
-
-var CALL_REQUEST = (0, _graphqlTag.default)(_templateObject || (_templateObject = _taggedTemplateLiteral(["\n  query callRequest($input: RequestInput!) {\n    request(input: $input) {\n      id\n      type\n      success\n      response\n    }\n  }\n"])));
-
-class Requests {
-  constructor(context) {
-    this.context = context;
-    this.requestList = this.context.rootBlock.requests || [];
-    this.callRequests = this.callRequests.bind(this);
-    this.callRequest = this.callRequest.bind(this);
-    this.fetch = this.fetch.bind(this);
-  }
-
-  callRequests() {
-    var {
-      requestIds,
-      event,
-      arrayIndices
-    } = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-    if (!requestIds) {
-      return Promise.all(this.requestList.map(request => this.callRequest({
-        requestId: request.requestId,
-        event,
-        arrayIndices
-      })));
+/*
+  Copyright 2020-2021 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 { get, serializer, type } from '@lowdefy/helpers';
+let Requests = class Requests {
+    callRequests({ actions , arrayIndices , event , params  } = {
+    }) {
+        if (params.all === true) {
+            return Promise.all(Object.keys(this.requestConfig).map((requestId)=>this.callRequest({
+                    requestId,
+                    event,
+                    arrayIndices
+                })
+            ));
+        }
+        let requestIds = [];
+        if (type.isString(params)) requestIds = [
+            params
+        ];
+        if (type.isArray(params)) requestIds = params;
+        return Promise.all(requestIds.map((requestId)=>this.callRequest({
+                actions,
+                requestId,
+                event,
+                arrayIndices
+            })
+        ));
     }
-
-    return Promise.all(requestIds.map(requestId => this.callRequest({
-      requestId,
-      event,
-      arrayIndices
-    })));
-  }
-
-  callRequest(_ref) {
-    var {
-      requestId,
-      event,
-      arrayIndices
-    } = _ref;
-
-    if (!this.context.requests[requestId]) {
-      var request = this.requestList.find(req => req.requestId === requestId);
-
-      if (!request) {
-        this.context.requests[requestId] = {
-          loading: false,
-          response: null,
-          error: [new Error("Configuration Error: Request ".concat(requestId, " not defined on context."))]
-        };
-        return Promise.reject(new Error("Configuration Error: Request ".concat(requestId, " not defined on context.")));
-      }
-
-      this.context.requests[requestId] = {
-        loading: true,
-        response: null,
-        error: []
-      };
+    callRequest({ actions: actions1 , arrayIndices: arrayIndices1 , event: event1 , requestId  }) {
+        const request = this.requestConfig[requestId];
+        if (!request) {
+            const error = new Error(`Configuration Error: Request ${requestId} not defined on page.`);
+            this.context.requests[requestId] = {
+                loading: false,
+                response: null,
+                error: [
+                    error
+                ]
+            };
+            return Promise.reject(error);
+        }
+        if (!this.context.requests[requestId]) {
+            this.context.requests[requestId] = {
+                loading: true,
+                response: null,
+                error: []
+            };
+        }
+        const { output: payload , errors: parserErrors  } = this.context._internal.parser.parse({
+            actions: actions1,
+            event: event1,
+            arrayIndices: arrayIndices1,
+            input: request.payload,
+            location: requestId
+        });
+        // TODO: We are throwing this error differently to the request does not exist error
+        if (parserErrors.length > 0) {
+            throw parserErrors[0];
+        }
+        return this.fetch({
+            requestId,
+            payload
+        });
     }
-
-    return this.fetch({
-      requestId,
-      event,
-      arrayIndices
-    });
-  }
-
-  fetch(_ref2) {
-    var _this = this;
-
-    return _asyncToGenerator(function* () {
-      var {
-        requestId,
-        event,
-        arrayIndices
-      } = _ref2;
-      _this.context.requests[requestId].loading = true;
-
-      if (_this.context.RootBlocks) {
-        _this.context.RootBlocks.setBlocksLoadingCache();
-      }
-
-      try {
-        var gqlResponse = yield _this.context.lowdefy.client.query({
-          query: CALL_REQUEST,
-          fetchPolicy: 'network-only',
-          variables: {
-            input: {
-              arrayIndices,
-              requestId,
-              blockId: _this.context.blockId,
-              event: _helpers.serializer.serialize(event) || {},
-              input: _helpers.serializer.serialize(_this.context.lowdefy.inputs[_this.context.id]),
-              lowdefyGlobal: _helpers.serializer.serialize(_this.context.lowdefy.lowdefyGlobal),
-              pageId: _this.context.pageId,
-              state: _helpers.serializer.serialize(_this.context.state),
-              urlQuery: _helpers.serializer.serialize(_this.context.lowdefy.urlQuery)
-            }
-          }
+    async fetch({ requestId: requestId1 , payload  }) {
+        this.context.requests[requestId1].loading = true;
+        if (this.context._internal.RootBlocks) {
+            this.context._internal.RootBlocks.setBlocksLoadingCache();
+        }
+        try {
+            const response = await this.context._internal.lowdefy._internal.callRequest({
+                pageId: this.context.pageId,
+                payload: serializer.serialize(payload),
+                requestId: requestId1
+            });
+            const deserializedResponse = serializer.deserialize(get(response, 'response', {
+                default: null
+            }));
+            this.context.requests[requestId1].response = deserializedResponse;
+            this.context.requests[requestId1].loading = false;
+            this.context._internal.update();
+            return deserializedResponse;
+        } catch (error) {
+            this.context.requests[requestId1].error.unshift(error);
+            this.context.requests[requestId1].loading = false;
+            this.context._internal.update();
+            throw error;
+        }
+    }
+    constructor(context){
+        this.context = context;
+        this.callRequests = this.callRequests.bind(this);
+        this.callRequest = this.callRequest.bind(this);
+        this.fetch = this.fetch.bind(this);
+        this.requestConfig = {
+        };
+        (this.context._internal.rootBlock.requests || []).forEach((request)=>{
+            this.requestConfig[request.requestId] = request;
         });
-
-        var response = _helpers.serializer.deserialize((0, _helpers.get)(gqlResponse, 'data.request.response', {
-          default: null
-        }));
-
-        _this.context.requests[requestId].response = response;
-        _this.context.requests[requestId].loading = false;
-
-        _this.context.update();
-
-        return response;
-      } catch (error) {
-        _this.context.requests[requestId].error.unshift(error);
-
-        _this.context.requests[requestId].loading = false;
-
-        _this.context.update();
-
-        throw error;
-      }
-    })();
-  }
-
-}
-
-var _default = Requests;
-exports.default = _default;
+    }
+};
+export default Requests;