(core) Adds a UI panel for managing webhooks

Summary:
This adds a UI panel for managing webhooks. Work started by Cyprien Pindat. You can find the UI on a document's settings page. Main changes relative to Cyprien's demo:

  * Changed behavior of virtual table to be more consistent with the rest of Grist, by factoring out part of the implementation of on-demand tables.
  * Cell values that would create an error can now be denied and reverted (as for the rest of Grist).
  * Changes made by other users are integrated in a sane way.
  * Basic undo/redo support is added using the regular undo/redo stack.
  * The table list in the drop-down is now updated if schema changes.
  * Added a notification from back-end when webhook status is updated so constant polling isn't needed to support multi-user operation.
  *  Factored out webhook specific logic from general virtual table support.
  * Made a bunch of fixes to various broken behavior.
  * Added tests.

The code remains somewhat unpolished, and behavior in the presence of errors is imperfect in general but may be adequate for this case.

I assume that we'll soon be lifting the restriction on the set of domains that are supported for webhooks - otherwise we'd want to provide some friendly way to discover that list of supported domains rather than just throwing an error.

I don't actually know a lot about how the front-end works - it looks like tables/columns/fields/sections can be safely added if they have string ids that won't collide with bone fide numeric ids from the back end. Sneaky.

Contains a migration, so needs an extra reviewer for that.

Test Plan: added tests

Reviewers: jarek, dsagal

Reviewed By: jarek, dsagal

Differential Revision: https://phab.getgrist.com/D3856

app/common/DocDataCache.ts

@@ -0,0 +1,51 @@
+import { AlternateActions, AlternateStorage, ProcessedAction} from 'app/common/AlternateActions';
+import { DocAction, UserAction } from 'app/common/DocActions';
+import { DocData } from 'app/common/DocData';
+import max from 'lodash/max';
+
+/**
+ * An implementation of an in-memory storage that can handle UserActions,
+ * generating DocActions and retValues that work as for regular storage.
+ * It shares an implementation with on-demand tables.
+ */
+export class DocDataCache implements AlternateStorage {
+  public docData: DocData;
+  private _altActions: AlternateActions;
+  constructor(actions?: DocAction[]) {
+    this.docData = new DocData(
+      async (tableId) => {
+        throw new Error(`no ${tableId}`);
+      },
+      null,
+    );
+    this._altActions = new AlternateActions(this);
+    for (const action of actions || []) {
+      this.docData.receiveAction(action);
+    }
+  }
+
+  public async sendTableActions(actions: UserAction[]): Promise<ProcessedAction[]> {
+    const results: ProcessedAction[] = [];
+    for (const userAction of actions) {
+      const processedAction = await this._altActions.processUserAction(userAction);
+      results.push(processedAction);
+      for (const storedAction of processedAction.stored) {
+        this.docData.receiveAction(storedAction);
+      }
+    }
+    return results;
+  }
+
+  public async fetchActionData(tableId: string, rowIds: number[], colIds?: string[]) {
+    const table = await this.docData.requireTable(tableId);
+    return table.getTableDataAction(
+      rowIds,
+      colIds,
+    );
+  }
+
+  public async getNextRowId(tableId: string): Promise<number> {
+    const table = await this.docData.requireTable(tableId);
+    return (max(table.getRowIds()) || 0) + 1;
+  }
+}