Merge remote-tracking branch 'origin/develop' into docker

packages/build/src/build/buildPages/buildBlock.js

@@ -30,6 +30,7 @@ async function buildBlock(block, blockContext) {
   block.blockId = block.id;
   block.id = `block:${blockContext.pageId}:${block.id}`;
   await setBlockMeta(block, blockContext.metaLoader, blockContext.pageId);
+
   let newBlockContext = blockContext;
   if (block.meta.category === 'context') {
     newBlockContext = {
@@ -44,6 +45,32 @@ async function buildBlock(block, blockContext) {
   if (block.meta.category === 'context') {
     block.requests = newBlockContext.requests;
   }
+
+  if (block.events) {
+    Object.keys(block.events).map((key) => {
+      if (type.isArray(block.events[key])) {
+        block.events[key] = {
+          try: block.events[key],
+          catch: [],
+        };
+      }
+      if (!type.isArray(block.events[key].try)) {
+        throw new Error(
+          `Events must be an array of actions at ${block.blockId} in events ${key} on page ${
+            newBlockContext.pageId
+          }. Received ${JSON.stringify(block.events[key].try)}`
+        );
+      }
+      if (!type.isArray(block.events[key].catch) && !type.isNone(block.events[key].catch)) {
+        throw new Error(
+          `Catch events must be an array of actions at ${block.blockId} in events ${key} on page ${
+            newBlockContext.pageId
+          }. Received ${JSON.stringify(block.events[key].catch)}`
+        );
+      }
+    });
+  }
+
   if (!type.isNone(block.blocks)) {
     if (!type.isArray(block.blocks)) {
       throw new Error(

packages/build/src/build/buildPages/buildPages.test.js

@@ -1760,3 +1760,167 @@ describe('web operators', () => {
     ]);
   });
 });
+
+test('block events actions array should map to try catch', async () => {
+  const components = {
+    pages: [
+      {
+        id: 'page_1',
+        type: 'Context',
+        auth,
+        blocks: [
+          {
+            id: 'block_1',
+            type: 'Input',
+            events: {
+              onClick: [
+                {
+                  id: 'action_1',
+                  type: 'Reset',
+                },
+              ],
+            },
+          },
+        ],
+      },
+    ],
+  };
+  const res = await buildPages({ components, context });
+  expect(get(res, 'pages.0.areas.content.blocks.0.events.onClick.try')).toEqual([
+    {
+      id: 'action_1',
+      type: 'Reset',
+    },
+  ]);
+  expect(get(res, 'pages.0.areas.content.blocks.0.events.onClick.catch')).toEqual([]);
+});
+
+test('block events actions as try catch arrays', async () => {
+  const components = {
+    pages: [
+      {
+        id: 'page_1',
+        type: 'Context',
+        auth,
+        blocks: [
+          {
+            id: 'block_1',
+            type: 'Input',
+            events: {
+              onClick: {
+                try: [
+                  {
+                    id: 'action_1',
+                    type: 'Reset',
+                  },
+                ],
+                catch: [
+                  {
+                    id: 'action_1',
+                    type: 'Retry',
+                  },
+                ],
+              },
+            },
+          },
+        ],
+      },
+    ],
+  };
+  const res = await buildPages({ components, context });
+  expect(get(res, 'pages.0.areas.content.blocks.0.events.onClick.try')).toEqual([
+    {
+      id: 'action_1',
+      type: 'Reset',
+    },
+  ]);
+  expect(get(res, 'pages.0.areas.content.blocks.0.events.onClick.catch')).toEqual([
+    {
+      id: 'action_1',
+      type: 'Retry',
+    },
+  ]);
+});
+
+test('block events actions try not an array', async () => {
+  const components = {
+    pages: [
+      {
+        id: 'page_1',
+        type: 'Context',
+        auth,
+        blocks: [
+          {
+            id: 'block_1',
+            type: 'Input',
+            events: {
+              onClick: {
+                try: {
+                  id: 'action_1',
+                  type: 'Reset',
+                },
+              },
+            },
+          },
+        ],
+      },
+    ],
+  };
+  await expect(buildPages({ components, context })).rejects.toThrow(
+    'Events must be an array of actions at block_1 in events onClick on page page_1. Received {"id":"action_1","type":"Reset"}'
+  );
+});
+
+test('block events actions not an array', async () => {
+  const components = {
+    pages: [
+      {
+        id: 'page_1',
+        type: 'Context',
+        auth,
+        blocks: [
+          {
+            id: 'block_1',
+            type: 'Input',
+            events: {
+              onClick: {},
+            },
+          },
+        ],
+      },
+    ],
+  };
+  await expect(buildPages({ components, context })).rejects.toThrow(
+    'Events must be an array of actions at block_1 in events onClick on page page_1. Received undefined'
+  );
+});
+
+test('block events actions catch not an array', async () => {
+  const components = {
+    pages: [
+      {
+        id: 'page_1',
+        type: 'Context',
+        auth,
+        blocks: [
+          {
+            id: 'block_1',
+            type: 'Input',
+            events: {
+              onClick: {
+                try: [],
+                catch: {
+                  id: 'action_1',
+                  type: 'Reset',
+                },
+              },
+            },
+          },
+        ],
+      },
+    ],
+  };
+  await expect(buildPages({ components, context })).rejects.toThrow(
+    'Catch events must be an array of actions at block_1 in events onClick on page page_1. Received {"id":"action_1","type":"Reset"}'
+  );
+});

packages/build/src/lowdefySchema.json

@@ -248,10 +248,32 @@
           "type": "object",
           "patternProperties": {
             "^.*$": {
-              "type": "array",
-              "items": {
-                "$ref": "#/definitions/action"
-              }
+              "anyOf": [
+                {
+                  "type": "array",
+                  "items": {
+                    "$ref": "#/definitions/action"
+                  }
+                },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "try": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/action"
+                      }
+                    },
+                    "catch": {
+                      "type": "array",
+                      "items": {
+                        "$ref": "#/definitions/action"
+                      }
+                    }
+                  }
+                }
+              ]
             }
           },
           "errorMessage": {
@@ -400,7 +422,7 @@
       }
     },
     "menuItem": {
-      "$anyOf": [
+      "anyOf": [
         {
           "$ref": "#/definitions/menuGroup"
         },

packages/docs/concepts/events-and-actions.yaml

@@ -28,7 +28,9 @@ _ref:
             - Events are triggered when something happens on a page, like clicking a button or loading a page.
             - A list of actions are executed sequentially by a triggered event.
             - If an action errors, the actions that follow are skipped.
+            - Action errors can be handled by providing a list of `try` and `catch` actions to the event.
             - Operators used in action `params` are evaluated right before the action is executed.
+            - The [`_actions`](/_actions)) operator is available for sequential actions to use the values returned from preceding actions in the chain.
             - Actions have a `skip` field that can be used to skip action execution.
             - The `onInit` event is triggered the first time a context is mounted and keeps the page in loading until all actions have finished.
             - The `onEnter` event is triggered the every time a context is mounted and keeps the page in loading until all actions have finished.
@@ -40,13 +42,13 @@ _ref:
 
             Blocks can define _events_ which the block can trigger when something happens on the page, like a button being clicked, an input's value being modified or a page being loaded. Some examples are `onClick` on a [`Button`](/Button) or `onEnter` on a [`PageHeaderMenu`](/PageHeaderMenu) block.
 
-            _Actions_ are tasks that can be executed, like calling a request, linking to a new page or changing a value in state. An array of actions can be defined for an event defined by a block. If that event gets triggered, those actions will execute sequentially. If any actions error while executing, the actions that follow it won't be executed.
+            _Actions_ are tasks that can be executed, like calling a request, linking to a new page or changing a value in state. An array of actions can be defined for a event on a block. If that event gets triggered, those actions will execute sequentially. If any actions error while executing, the actions that follow it won't be executed, however, `catch` actions chain can be defined on a event to trigger when a error in a chain of actions occurs.
 
             Each action has an `id`, unique to that action chain, and a `type` field which are required.
 
-            Actions can have a `params` field for specifying input parameters when executing the action. Operators used in action `params` will be evaluated right before the action is executed. Some events might have data relating to that event, like what the new value of an input is, or the row that was clicked in a table. The `event` object can be used in the action using the [`_event`](/_event) operator.
+            Actions can have a `params` field for specifying input parameters when executing the action. Operators used in action `params` will be evaluated right before the action is executed. Some events might have data relating to that event, like what the new value of an input is, or the row that was clicked in a table. The `event` object can be used in the action using the [`_event`](/_event) operator. Some actions also return values which can be passed to preceding actions in the same action chain using the [`_actions`](/_actions) operator.
 
-            Actions can also have a `skip` field. Operators in the `skip` field are also evaluated before an action is executed, and if the evaluated result is `true`, that action is skipped and the next action is executed.
+            Actions can also have a `skip` field. Operators in the `skip` field will be evaluated before an action is executed, and if the evaluated result is `true`, that action is skipped and the next action is executed.
 
             # Action Schema
 
@@ -85,12 +87,47 @@ _ref:
             ```
             # The actions object
 
-            When an event is triggered each completed action writes its response to the actions object under the action id object key. Thus all following actions in a event action list has access to the response of all preceding actions in the same event list through the [`_actions`](/_actions) operator.
+            When events are triggered, each completed action writes its response to the actions object under the action id object key. Thus all following actions in a event action list have access to the responses of all preceding actions in the same event list through the [`_actions`](/_actions) operator.
 
             # The event object
 
             When events are triggered, the can provide a data object describing the event (e.g. a description of the clicked item or uploaded file). This data object can be accessed using the [`_event`](/_event) operator in an action definition.
 
+            # Catching action errors
+
+            If one action in the chain of event actions fails by throwing an error, the actions in the list following the failed action will not be executed. To handle any errors thrown by an action, Lowdefy event actions can be provided as lists of `try` and `catch` actions.
+
+            The schema for passing actions to Lowdefy events is:
+            ```
+              (eventName: action[])
+              (eventName: {
+                try: action[],
+                catch?: action[],
+              })
+            ```
+
+            ###### Event try catch actions example for dealing with action errors:
+            ```yaml
+            - id: block_with_actions
+              type: Block
+              properties:
+                # ...
+              events:
+                onEvent1:
+                  try:
+                    - id: action1
+                      type: ActionType1
+                      params:
+                        # ...
+                    - id: action2
+                      type: ActionType2
+                  catch:
+                    - id: unsuccessful
+                      type: ActionType1
+                      params:
+                        # ...
+            ```
+
             # Context initialisation events
 
             Four events are always defined for [`context`](/context) type blocks, called in the following order:

packages/docs/menus.yaml

@@ -699,3 +699,39 @@
         - id: _yaml
           type: MenuLink
           pageId: _yaml
+    - id: versions
+      type: MenuGroup
+      properties:
+        title: Lowdefy Versions
+        icon: BranchesOutlined
+      links:
+        - id: latest
+          type: MenuLink
+          url: https://docs.lowdefy.com
+          properties:
+            title: Latest
+        - id: v3.16.5
+          type: MenuLink
+          url: https://60b4bfc8f6822500088a1c45--lowdefy-docs.netlify.app
+          properties:
+            title: v3.16.5
+        - id: v3.15.0
+          type: MenuLink
+          url: https://609a6df368df720007f2cc9c--lowdefy-docs.netlify.app
+          properties:
+            title: v3.15.0
+        - id: v3.14.1
+          type: MenuLink
+          url: https://6089404fb5958f00070b8520--lowdefy-docs.netlify.app
+          properties:
+            title: v3.14.1
+        - id: v3.13.0
+          type: MenuLink
+          url: https://607952a468b9200008ad4db0--lowdefy-docs.netlify.app
+          properties:
+            title: v3.13.0
+        - id: v3.12.6
+          type: MenuLink
+          url: https://606c6baf132ad60007ef8f38--lowdefy-docs.netlify.app
+          properties:
+            title: v3.12.6

packages/docs/templates/blocks/template.yaml.njk

@@ -103,6 +103,11 @@ properties:
   footer:
     style:
       background: '#FFFFFF'
+  breadcrumb:
+    list:
+      - _ref: version.yaml
+      - {{ category }}
+      - {{ block_type }}
 layout:
   contentGutter: 16
 areas:

packages/docs/templates/general.yaml.njk

@@ -73,9 +73,10 @@ properties:
     style:
       background: '#FFFFFF'
       padding: 16px 0px 0px 0px
-  {% if section %}
   breadcrumb:
     list:
+      - _ref: version.yaml
+  {% if section %}
       - {{ section }}
       - {{ pageTitle }}
   {% endif %}

packages/docs/version.yaml

@@ -0,0 +1 @@
+v3.16.5

packages/engine/src/Actions.js

@@ -21,36 +21,58 @@ class Actions {
   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 = actions;
   }
 
-  async callActions({ actions, arrayIndices, block, event, eventName }) {
+  async callActionLoop({ actions, arrayIndices, block, event, responses }) {
+    for (const [index, action] of actions.entries()) {
+      try {
+        const response = await this.callAction({
+          action,
+          arrayIndices,
+          block,
+          event,
+          index,
+          responses,
+        });
+        responses[action.id] = response;
+      } catch (error) {
+        throw {
+          error,
+          action,
+        };
+      }
+    }
+  }
+
+  async callActions({ actions, arrayIndices, block, catchActions, event, eventName }) {
     const startTimestamp = new Date();
     const responses = {};
     try {
-      for (const [index, action] of actions.entries()) {
-        try {
-          const response = await this.callAction({
-            action,
-            arrayIndices,
-            block,
-            event,
-            index,
-            responses,
-          });
-          responses[action.id] = response;
-        } catch (error) {
-          throw {
-            error,
-            action,
-          };
-        }
-      }
+      await this.callActionLoop({ actions, arrayIndices, block, event, responses });
     } catch (error) {
       responses[error.action.id] = error.error;
       console.error(error);
+      try {
+        await this.callActionLoop({ actions: catchActions, arrayIndices, block, event, responses });
+      } catch (errorCatch) {
+        responses[errorCatch.action.id] = errorCatch.error;
+        console.error(errorCatch);
+        return {
+          blockId: block.blockId,
+          error,
+          errorCatch,
+          event,
+          eventName,
+          responses,
+          endTimestamp: new Date(),
+          startTimestamp,
+          success: false,
+        };
+      }
       return {
         blockId: block.blockId,
         error,

packages/engine/src/Events.js

@@ -26,26 +26,28 @@ class Events {
     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: (type.isObject(actions) ? actions.try : actions) || [],
+      catchActions: (type.isObject(actions) ? actions.catch : []) || [],
+      history: [],
+      loading: false,
+    };
+  }
+
   init() {
     Object.keys(this.block.events).forEach((eventName) => {
-      this.events[eventName] = {
-        actions: this.block.events[eventName] || [],
-        history: [],
-        loading: false,
-      };
+      this.events[eventName] = this.initEvent(this.block.events[eventName]);
     });
   }
 
   registerEvent({ name, actions }) {
-    this.events[name] = {
-      actions: actions || [],
-      history: [],
-      loading: false,
-    };
+    this.events[name] = this.initEvent(actions);
   }
 
   async triggerEvent({ name, event }) {
@@ -61,6 +63,7 @@ class Events {
       actions: eventDescription.actions,
       arrayIndices: this.arrayIndices,
       block: this.block,
+      catchActions: eventDescription.catchActions,
       event,
       eventName: name,
     });

packages/engine/test/Actions/Actions.test.js

@@ -25,6 +25,9 @@ jest.mock('../../src/actions/index.js', () => ({
   ActionError: jest.fn(() => {
     throw new Error('Test error');
   }),
+  CatchActionError: jest.fn(() => {
+    throw new Error('Test catch error');
+  }),
 }));
 
 const pageId = 'one';
@@ -72,6 +75,7 @@ test('call a synchronous action', async () => {
     actions: [{ id: 'test', type: 'ActionSync', params: 'params' }],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -109,6 +113,7 @@ test('call a asynchronous action', async () => {
     actions: [{ id: 'test', type: 'ActionAsync', params: 'params' }],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -149,6 +154,7 @@ test('call 2 actions', async () => {
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -203,6 +209,7 @@ test('operators are evaluated in params, skip and messages', async () => {
         messages: { _event: 'messages' },
       },
     ],
+    catchActions: [],
     arrayIndices: [1],
     block: { blockId: 'blockId' },
     event: {
@@ -265,6 +272,7 @@ test('skip a action', async () => {
     actions: [{ id: 'test', type: 'ActionSync', skip: true }],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -302,6 +310,7 @@ test('action throws a error', async () => {
     actions: [{ id: 'test', type: 'ActionError', params: 'params' }],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -354,6 +363,7 @@ test('actions after a error are not called throws a error', async () => {
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -404,6 +414,7 @@ test('Invalid action type', async () => {
     actions: [{ id: 'test', type: 'Invalid', params: 'params' }],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -452,6 +463,7 @@ test('Parser error in action', async () => {
     actions: [{ id: 'test', type: 'ActionSync', params: { _state: [] } }],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -512,6 +524,7 @@ test('Display default loading and success messages when value == true ', async (
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -556,6 +569,7 @@ test('Display custom loading and success messages when value is a string ', asyn
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -599,6 +613,7 @@ test('Do not display loading and success messages by default', async () => {
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -627,6 +642,7 @@ test('Display error message by default', async () => {
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -665,6 +681,7 @@ test('Display custom error message', async () => {
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
@@ -703,8 +720,186 @@ test('Do not display an error message if message === false', async () => {
     ],
     arrayIndices,
     block: { blockId: 'blockId' },
+    catchActions: [],
     event: {},
     eventName,
   });
   expect(displayMessage.mock.calls).toEqual([]);
 });
+
+test('Call catchActions when actions throws error', async () => {
+  const rootBlock = {
+    blockId: 'root',
+    meta: {
+      category: 'context',
+    },
+  };
+  const context = await testContext({
+    lowdefy,
+    rootBlock,
+  });
+  const Actions = context.Actions;
+  const res = await Actions.callActions({
+    actions: [
+      {
+        id: 'try_error',
+        type: 'ActionError',
+        messages: {
+          error: false,
+        },
+      },
+    ],
+    arrayIndices,
+    block: { blockId: 'blockId' },
+    catchActions: [
+      {
+        id: 'catch_test',
+        type: 'ActionAsync',
+        params: 'params',
+      },
+    ],
+    event: {},
+    eventName,
+  });
+  expect(res).toEqual({
+    blockId: 'blockId',
+    endTimestamp: {
+      date: 0,
+    },
+    error: {
+      action: {
+        id: 'try_error',
+        messages: {
+          error: false,
+        },
+        type: 'ActionError',
+      },
+      error: {
+        error: new Error('Test error'),
+        index: 0,
+        type: 'ActionError',
+      },
+    },
+    event: {},
+    eventName: 'eventName',
+    responses: {
+      catch_test: {
+        index: 0,
+        response: 'params',
+        type: 'ActionAsync',
+      },
+      try_error: {
+        error: new Error('Test error'),
+        index: 0,
+        type: 'ActionError',
+      },
+    },
+    startTimestamp: {
+      date: 0,
+    },
+    success: false,
+  });
+  expect(actions.ActionAsync.mock.calls.length).toBe(1);
+});
+
+test('Call catchActions when actions throws error and catchActions throws error', async () => {
+  const rootBlock = {
+    blockId: 'root',
+    meta: {
+      category: 'context',
+    },
+  };
+  const context = await testContext({
+    lowdefy,
+    rootBlock,
+  });
+  const Actions = context.Actions;
+  const res = await Actions.callActions({
+    actions: [
+      {
+        id: 'try_error',
+        type: 'ActionError',
+        messages: {
+          error: false,
+        },
+      },
+    ],
+    arrayIndices,
+    block: { blockId: 'blockId' },
+
+    catchActions: [
+      {
+        id: 'catch_test',
+        type: 'ActionAsync',
+        params: 'params',
+      },
+      {
+        id: 'catch_error',
+        type: 'CatchActionError',
+        messages: {
+          error: false,
+        },
+      },
+    ],
+    event: {},
+    eventName,
+  });
+  expect(res).toEqual({
+    blockId: 'blockId',
+    endTimestamp: {
+      date: 0,
+    },
+    error: {
+      action: {
+        id: 'try_error',
+        messages: {
+          error: false,
+        },
+        type: 'ActionError',
+      },
+      error: {
+        error: new Error('Test error'),
+        index: 0,
+        type: 'ActionError',
+      },
+    },
+    errorCatch: {
+      action: {
+        id: 'catch_error',
+        messages: {
+          error: false,
+        },
+        type: 'CatchActionError',
+      },
+      error: {
+        error: new Error('Test catch error'),
+        index: 1,
+        type: 'CatchActionError',
+      },
+    },
+    event: {},
+    eventName: 'eventName',
+    responses: {
+      catch_test: {
+        index: 0,
+        response: 'params',
+        type: 'ActionAsync',
+      },
+      try_error: {
+        error: new Error('Test error'),
+        index: 0,
+        type: 'ActionError',
+      },
+      catch_error: {
+        error: new Error('Test catch error'),
+        index: 1,
+        type: 'CatchActionError',
+      },
+    },
+    startTimestamp: {
+      date: 0,
+    },
+    success: false,
+  });
+  expect(actions.ActionAsync.mock.calls.length).toBe(1);
+});

packages/engine/test/Events.test.js

@@ -106,6 +106,7 @@ test('init Events', async () => {
     onClick: {
       history: [],
       loading: false,
+      catchActions: [],
       actions: [{ id: 'a', type: 'SetState', params: { a: 'a' } }],
     },
   });
@@ -177,6 +178,7 @@ test('triggerEvent x1', async () => {
     onClick: {
       history: [],
       loading: true,
+      catchActions: [],
       actions: [{ id: 'a', type: 'SetState', params: { a: 'a' } }],
     },
   });
@@ -344,6 +346,7 @@ test('registerEvent then triggerEvent x1', async () => {
     onClick: {
       history: [],
       loading: false,
+      catchActions: [],
       actions: [{ id: 'a', type: 'SetState', params: { a: 'a' } }],
     },
   });
@@ -411,6 +414,7 @@ test('triggerEvent skip', async () => {
             "type": "SetState",
           },
         ],
+        "catchActions": Array [],
         "history": Array [
           Object {
             "blockId": "button",
@@ -509,6 +513,7 @@ test('triggerEvent skip tests === true', async () => {
             "type": "SetState",
           },
         ],
+        "catchActions": Array [],
         "history": Array [
           Object {
             "blockId": "button",
@@ -597,7 +602,86 @@ test('Actions array defaults', async () => {
     actions: null,
   });
   expect(button.Events.events).toEqual({
-    onClick: { actions: [], history: [], loading: false },
-    registered: { actions: [], history: [], loading: false },
+    onClick: { actions: [], history: [], loading: false, catchActions: [] },
+    registered: { actions: [], history: [], loading: false, catchActions: [] },
+  });
+});
+
+test('Actions try catch array defaults', async () => {
+  const rootBlock = {
+    blockId: 'root',
+    meta: {
+      category: 'context',
+    },
+    areas: {
+      content: {
+        blocks: [
+          {
+            blockId: 'button',
+            type: 'Button',
+            meta: {
+              category: 'display',
+              valueType: 'string',
+            },
+            events: {
+              onClick: {
+                try: null,
+                catch: null,
+              },
+            },
+          },
+        ],
+      },
+    },
+  };
+  const context = await testContext({
+    lowdefy,
+    rootBlock,
+  });
+  const { button } = context.RootBlocks.map;
+  expect(button.Events.events).toEqual({
+    onClick: { actions: [], history: [], loading: false, catchActions: [] },
+  });
+});
+
+test('Actions try catch arrays', async () => {
+  const rootBlock = {
+    blockId: 'root',
+    meta: {
+      category: 'context',
+    },
+    areas: {
+      content: {
+        blocks: [
+          {
+            blockId: 'button',
+            type: 'Button',
+            meta: {
+              category: 'display',
+              valueType: 'string',
+            },
+            events: {
+              onClick: {
+                try: [{ id: 'a', type: 'SetState', params: { a: 'a' } }],
+                catch: [{ id: 'b', type: 'SetState', params: { b: 'b' } }],
+              },
+            },
+          },
+        ],
+      },
+    },
+  };
+  const context = await testContext({
+    lowdefy,
+    rootBlock,
+  });
+  const { button } = context.RootBlocks.map;
+  expect(button.Events.events).toEqual({
+    onClick: {
+      actions: [{ id: 'a', type: 'SetState', params: { a: 'a' } }],
+      history: [],
+      loading: false,
+      catchActions: [{ id: 'b', type: 'SetState', params: { b: 'b' } }],
+    },
   });
 });