@airtable/blocks 1.10.1 → 1.10.2-experimental-640bd10-20220211

package/dist/cjs/testing/mock_base_data_stores.js

@@ -0,0 +1,876 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("core-js/modules/es.symbol");
+
+require("core-js/modules/es.symbol.description");
+
+require("core-js/modules/es.array.concat");
+
+require("core-js/modules/es.array.filter");
+
+require("core-js/modules/es.array.find");
+
+require("core-js/modules/es.array.find-index");
+
+require("core-js/modules/es.array.includes");
+
+require("core-js/modules/es.array.index-of");
+
+require("core-js/modules/es.array.iterator");
+
+require("core-js/modules/es.array.map");
+
+require("core-js/modules/es.array.slice");
+
+require("core-js/modules/es.array.splice");
+
+require("core-js/modules/es.object.get-own-property-descriptors");
+
+require("core-js/modules/es.object.to-string");
+
+require("core-js/modules/es.object.values");
+
+require("core-js/modules/es.promise");
+
+require("core-js/modules/es.string.includes");
+
+require("core-js/modules/web.dom-collections.for-each");
+
+require("core-js/modules/web.dom-collections.iterator");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MockBaseDataStore = void 0;
+
+var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+
+require("regenerator-runtime/runtime");
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _airtable_interface = require("../types/airtable_interface");
+
+var _block_query_spec = require("../types/block_query_spec");
+
+var _view = require("../types/view");
+
+var _private_utils = require("../private_utils");
+
+var _error_utils = require("../error_utils");
+
+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) { (0, _defineProperty2.default)(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; }
+
+var blockQueryIdCounter = 0;
+/** @internal */
+
+var unmodifiableTableData = {
+  lock: null,
+  externalSyncById: null
+};
+/** @internal */
+
+var unmodifiableFieldData = {
+  lock: null
+};
+/** @hidden */
+
+var MockBaseDataStore =
+/*#__PURE__*/
+function () {
+  function MockBaseDataStore(mockAirtableInterface, fixtureData) {
+    (0, _classCallCheck2.default)(this, MockBaseDataStore);
+    (0, _defineProperty2.default)(this, "_mockAirtableInterface", void 0);
+    (0, _defineProperty2.default)(this, "_fixtureData", void 0);
+    (0, _defineProperty2.default)(this, "_tablesById", {});
+    (0, _defineProperty2.default)(this, "_subscribedQuerySpecs", {});
+    (0, _defineProperty2.default)(this, "_deletedRecordIds", []);
+    (0, _defineProperty2.default)(this, "_onUnsubscribeFromQueryCallback", null);
+    (0, _defineProperty2.default)(this, "_upperQueryIdsFromPreviousTests", 0);
+    (0, _defineProperty2.default)(this, "_shouldQueriesFail", false);
+    this._mockAirtableInterface = mockAirtableInterface;
+    this._fixtureData = fixtureData;
+    this._upperQueryIdsFromPreviousTests = blockQueryIdCounter;
+    fixtureData.base.tables.forEach(table => {
+      this._tablesById[table.id] = table;
+    });
+  }
+
+  (0, _createClass2.default)(MockBaseDataStore, [{
+    key: "setSubscribeToQueryFailureMode",
+    value: function setSubscribeToQueryFailureMode(shouldQueriesFail) {
+      this._shouldQueriesFail = shouldQueriesFail;
+    } // Subscribing / unsubscribing from queries
+
+  }, {
+    key: "subscribeToQueryAndPopulateStoresAsync",
+    value: function subscribeToQueryAndPopulateStoresAsync(querySpec, options) {
+      var blockQueryId;
+      return _regenerator.default.async(function subscribeToQueryAndPopulateStoresAsync$(_context) {
+        while (1) {
+          switch (_context.prev = _context.next) {
+            case 0:
+              if (!this._shouldQueriesFail) {
+                _context.next = 2;
+                break;
+              }
+
+              return _context.abrupt("return", {
+                success: false
+              });
+
+            case 2:
+              blockQueryId = "bqy".concat(blockQueryIdCounter++);
+              this._subscribedQuerySpecs[blockQueryId] = {
+                querySpec,
+                onChangeCallback: options.onChangeCallback,
+                callbackPriority: options.callbackPriority
+              };
+              return _context.abrupt("return", {
+                success: true,
+                blockQueryId
+              });
+
+            case 5:
+            case "end":
+              return _context.stop();
+          }
+        }
+      }, null, this);
+    }
+  }, {
+    key: "unsubscribeFromQueryIdsAsync",
+    value: function unsubscribeFromQueryIdsAsync(querySpecIds) {
+      var _iteratorNormalCompletion, _didIteratorError, _iteratorError, _iterator, _step, querySpecId, querySpecIdCount;
+
+      return _regenerator.default.async(function unsubscribeFromQueryIdsAsync$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _iteratorNormalCompletion = true;
+              _didIteratorError = false;
+              _iteratorError = undefined;
+              _context2.prev = 3;
+              _iterator = querySpecIds[Symbol.iterator]();
+
+            case 5:
+              if (_iteratorNormalCompletion = (_step = _iterator.next()).done) {
+                _context2.next = 18;
+                break;
+              }
+
+              querySpecId = _step.value;
+
+              if (this._subscribedQuerySpecs[querySpecId]) {
+                _context2.next = 14;
+                break;
+              }
+
+              querySpecIdCount = parseInt(querySpecId.slice(3), 10);
+
+              if (!(querySpecIdCount <= this._upperQueryIdsFromPreviousTests)) {
+                _context2.next = 13;
+                break;
+              }
+
+              // TODO: Remove this console.log / special case by forcing all tests to clean up
+              // eslint-disable-next-line no-console
+              console.log("unsubscribed querySpecId from previous test ".concat(querySpecId));
+              _context2.next = 14;
+              break;
+
+            case 13:
+              throw (0, _error_utils.spawnError)('Unexpected querySpecId %s', querySpecId);
+
+            case 14:
+              delete this._subscribedQuerySpecs[querySpecId];
+
+            case 15:
+              _iteratorNormalCompletion = true;
+              _context2.next = 5;
+              break;
+
+            case 18:
+              _context2.next = 24;
+              break;
+
+            case 20:
+              _context2.prev = 20;
+              _context2.t0 = _context2["catch"](3);
+              _didIteratorError = true;
+              _iteratorError = _context2.t0;
+
+            case 24:
+              _context2.prev = 24;
+              _context2.prev = 25;
+
+              if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+              }
+
+            case 27:
+              _context2.prev = 27;
+
+              if (!_didIteratorError) {
+                _context2.next = 30;
+                break;
+              }
+
+              throw _iteratorError;
+
+            case 30:
+              return _context2.finish(27);
+
+            case 31:
+              return _context2.finish(24);
+
+            case 32:
+              if (this._onUnsubscribeFromQueryCallback) {
+                this._onUnsubscribeFromQueryCallback();
+              }
+
+              return _context2.abrupt("return", {
+                status: true
+              });
+
+            case 34:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this, [[3, 20, 24, 32], [25,, 27, 31]]);
+    }
+  }, {
+    key: "setTableRecordsAsync",
+    value: function setTableRecordsAsync(tableId, fixtureRecords) {
+      var table;
+      return _regenerator.default.async(function setTableRecordsAsync$(_context3) {
+        while (1) {
+          switch (_context3.prev = _context3.next) {
+            case 0:
+              table = this._tablesById[tableId];
+              (0, _error_utils.invariant)(table, 'setTableRecordsAsync called with missing table %s', tableId);
+              table.records = fixtureRecords;
+
+            case 3:
+            case "end":
+              return _context3.stop();
+          }
+        }
+      }, null, this);
+    }
+  }, {
+    key: "deleteRecordAsync",
+    value: function deleteRecordAsync(tableId, recordId) {
+      var table, record, _i, _Object$values, _Object$values$_i, querySpec, onChangeCallback;
+
+      return _regenerator.default.async(function deleteRecordAsync$(_context4) {
+        while (1) {
+          switch (_context4.prev = _context4.next) {
+            case 0:
+              // Need to simulate two hyperbase updates:
+              // 1. delete the record in the RecordStoreForTable
+              // 2. simulate the ModelChange update
+              table = this._tablesById[tableId];
+              (0, _error_utils.invariant)(table, 'deleteRecordAsync called with missing table %s', tableId);
+              record = table.records.find(r => r.id === recordId);
+              (0, _error_utils.invariant)(record, 'deleteRecordAsync called with missing record %s', recordId); // We don't update table.records or record here to ensure that the
+              // mock implementation of isRecordPartiallyLoaded still returns `true`
+              // for this given recordId
+
+              this._deletedRecordIds.push(recordId);
+
+              _i = 0, _Object$values = Object.values(this._subscribedQuerySpecs);
+
+            case 6:
+              if (!(_i < _Object$values.length)) {
+                _context4.next = 16;
+                break;
+              }
+
+              _Object$values$_i = _Object$values[_i], querySpec = _Object$values$_i.querySpec, onChangeCallback = _Object$values$_i.onChangeCallback;
+
+              if (onChangeCallback) {
+                _context4.next = 10;
+                break;
+              }
+
+              return _context4.abrupt("continue", 13);
+
+            case 10:
+              if (!(querySpec.sourceTableId !== tableId)) {
+                _context4.next = 12;
+                break;
+              }
+
+              return _context4.abrupt("continue", 13);
+
+            case 12:
+              onChangeCallback([{
+                type: _block_query_spec.BlockQuerySubscriptionChangeType.REMOVED_RECORD_IDS,
+                tableId,
+                recordIds: [recordId]
+              }]);
+
+            case 13:
+              _i++;
+              _context4.next = 6;
+              break;
+
+            case 16:
+            case "end":
+              return _context4.stop();
+          }
+        }
+      }, null, this);
+    }
+  }, {
+    key: "createRecordAsync",
+    value: function createRecordAsync(tableId, initialFixtureRecord) {
+      var table, _i2, _Object$values2, _Object$values2$_i, querySpec, onChangeCallback;
+
+      return _regenerator.default.async(function createRecordAsync$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              table = this._tablesById[tableId];
+              (0, _error_utils.invariant)(table, 'updateRecord called with missing table %s', tableId);
+              table.records.push(initialFixtureRecord);
+              _i2 = 0, _Object$values2 = Object.values(this._subscribedQuerySpecs);
+
+            case 4:
+              if (!(_i2 < _Object$values2.length)) {
+                _context5.next = 14;
+                break;
+              }
+
+              _Object$values2$_i = _Object$values2[_i2], querySpec = _Object$values2$_i.querySpec, onChangeCallback = _Object$values2$_i.onChangeCallback;
+
+              if (onChangeCallback) {
+                _context5.next = 8;
+                break;
+              }
+
+              return _context5.abrupt("continue", 11);
+
+            case 8:
+              if (!(querySpec.sourceTableId !== tableId)) {
+                _context5.next = 10;
+                break;
+              }
+
+              return _context5.abrupt("continue", 11);
+
+            case 10:
+              onChangeCallback([{
+                type: _block_query_spec.BlockQuerySubscriptionChangeType.ADDED_RECORD_IDS,
+                tableId,
+                recordIds: [initialFixtureRecord.id]
+              }]);
+
+            case 11:
+              _i2++;
+              _context5.next = 4;
+              break;
+
+            case 14:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, null, this);
+    }
+  }, {
+    key: "updateRecord",
+    value: function updateRecord(tableId, recordId, fieldId, newValue, opts) {
+      var _ref = opts !== null && opts !== void 0 ? opts : {},
+          allowUnexpected = _ref.allowUnexpected,
+          shouldForceOnChangeCallbackWhenNoQueriesMatchRecord = _ref.shouldForceOnChangeCallbackWhenNoQueriesMatchRecord,
+          shouldCallSubscriptionChangesWithEmptyArray = _ref.shouldCallSubscriptionChangesWithEmptyArray;
+
+      var table = this._tablesById[tableId];
+      (0, _error_utils.invariant)(table, 'updateRecord called with missing table %s', tableId);
+      var record = table.records.find(r => r.id === recordId);
+
+      if (!allowUnexpected) {
+        (0, _error_utils.invariant)(record, 'updateRecord called with missing record %s', recordId);
+      }
+
+      var field = table.fields.find(f => f.id === fieldId);
+      (0, _error_utils.invariant)(field, 'updateRecord called with missing field %s', fieldId);
+
+      if (record) {
+        record.cellValuesByFieldId[fieldId] = newValue;
+      }
+
+      for (var _i3 = 0, _Object$values3 = Object.values(this._subscribedQuerySpecs); _i3 < _Object$values3.length; _i3++) {
+        var _querySpec$recordSele, _querySpec$recordSele2, _querySpec$recordSele3, _querySpec$recordSele4, _querySpec$recordSele5;
+
+        var _Object$values3$_i = _Object$values3[_i3],
+            querySpec = _Object$values3$_i.querySpec,
+            onChangeCallback = _Object$values3$_i.onChangeCallback;
+
+        if (!onChangeCallback) {
+          continue;
+        }
+
+        if (querySpec.sourceTableId !== tableId) {
+          continue;
+        }
+
+        var isMatchingFieldQuery = ((_querySpec$recordSele = querySpec.recordSelection) === null || _querySpec$recordSele === void 0 ? void 0 : (_querySpec$recordSele2 = _querySpec$recordSele.fieldSelection) === null || _querySpec$recordSele2 === void 0 ? void 0 : _querySpec$recordSele2.type) === _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE || ((_querySpec$recordSele3 = querySpec.recordSelection) === null || _querySpec$recordSele3 === void 0 ? void 0 : (_querySpec$recordSele4 = _querySpec$recordSele3.fieldSelection) === null || _querySpec$recordSele4 === void 0 ? void 0 : _querySpec$recordSele4.type) === _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS && querySpec.recordSelection.fieldSelection.fieldIds.includes(fieldId);
+
+        if (!isMatchingFieldQuery) {
+          continue;
+        }
+
+        if (((_querySpec$recordSele5 = querySpec.recordSelection) === null || _querySpec$recordSele5 === void 0 ? void 0 : _querySpec$recordSele5.recordIds) && !shouldForceOnChangeCallbackWhenNoQueriesMatchRecord && !querySpec.recordSelection.recordIds.includes(recordId)) {
+          return;
+        } // TODO(#proj-blocks-record-limits) filter rows based on querySpec
+
+
+        if (shouldCallSubscriptionChangesWithEmptyArray) {
+          onChangeCallback([]);
+        } else {
+          onChangeCallback([{
+            type: _block_query_spec.BlockQuerySubscriptionChangeType.MODIFIED_CELL_VALUES_FOR_TABLE,
+            tableId,
+            fieldIdsByRecordId: {
+              [recordId]: [fieldId]
+            },
+            fieldIds: [fieldId]
+          }]);
+        }
+      }
+    }
+  }, {
+    key: "updateCommentCount",
+    value: function updateCommentCount(tableId, recordId, newCommentCount) {
+      var table = this._tablesById[tableId];
+      (0, _error_utils.invariant)(table, 'updateCommentCount called with missing table %s', tableId);
+      var record = table.records.find(r => r.id === recordId);
+      (0, _error_utils.invariant)(record, 'updateCommentCount called with missing record %s', recordId);
+      record.commentCount = newCommentCount;
+
+      for (var _i4 = 0, _Object$values4 = Object.values(this._subscribedQuerySpecs); _i4 < _Object$values4.length; _i4++) {
+        var _querySpec$recordSele6, _querySpec$recordSele7;
+
+        var _Object$values4$_i = _Object$values4[_i4],
+            querySpec = _Object$values4$_i.querySpec,
+            onChangeCallback = _Object$values4$_i.onChangeCallback;
+
+        if (!onChangeCallback) {
+          continue;
+        }
+
+        if (querySpec.sourceTableId !== tableId) {
+          continue;
+        }
+
+        var isMatchingFieldQuery = ((_querySpec$recordSele6 = querySpec.recordSelection) === null || _querySpec$recordSele6 === void 0 ? void 0 : _querySpec$recordSele6.fieldSelection.type) === _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE || ((_querySpec$recordSele7 = querySpec.recordSelection) === null || _querySpec$recordSele7 === void 0 ? void 0 : _querySpec$recordSele7.fieldSelection.type) === _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS && querySpec.recordSelection.fieldSelection.shouldIncludeCommentCount;
+
+        if (!isMatchingFieldQuery) {
+          continue;
+        }
+
+        onChangeCallback([]);
+      }
+    }
+  }, {
+    key: "updateColorInView",
+    value: function updateColorInView(tableId, viewId, recordId, newColor) {
+      var table = this._tablesById[tableId];
+      (0, _error_utils.invariant)(table, 'updateColorInView called with missing table %s', tableId);
+      var view = table.views.find(v => v.id === viewId);
+      (0, _error_utils.invariant)(view, 'updateColorInView called with missing view %s', viewId);
+      var record = view.records.find(r => r.id === recordId);
+      (0, _error_utils.invariant)(record, 'updateColorInView called with missing record %s', recordId);
+      record.color = newColor;
+
+      for (var _i5 = 0, _Object$values5 = Object.values(this._subscribedQuerySpecs); _i5 < _Object$values5.length; _i5++) {
+        var _querySpec$viewMetada;
+
+        var _Object$values5$_i = _Object$values5[_i5],
+            onChangeCallback = _Object$values5$_i.onChangeCallback,
+            querySpec = _Object$values5$_i.querySpec;
+
+        if (!onChangeCallback) {
+          continue;
+        }
+
+        if (querySpec.sourceType !== _block_query_spec.BlockQuerySourceType.VIEW) {
+          continue;
+        }
+
+        if (querySpec.sourceTableId !== tableId || querySpec.sourceViewId !== viewId) {
+          continue;
+        }
+
+        if ((_querySpec$viewMetada = querySpec.viewMetadataSelection) === null || _querySpec$viewMetada === void 0 ? void 0 : _querySpec$viewMetada.shouldIncludeColorsForRecordId) {
+          onChangeCallback([{
+            type: _block_query_spec.BlockQuerySubscriptionChangeType.CHANGED_COLORS_BY_RECORD_ID_FOR_VIEW,
+            tableId,
+            viewId,
+            recordIds: [recordId]
+          }]);
+        }
+      }
+    } // Allows access to record cell values that have been subscribed using queries
+
+  }, {
+    key: "getTableRecordStoreIfExists",
+    value: function getTableRecordStoreIfExists(tableId) {
+      var fixtureTable = this._tablesById[tableId];
+
+      if (!fixtureTable) {
+        return null;
+      }
+
+      return {
+        getTableId: () => fixtureTable.id,
+        getPartiallyLoadedRecordIds: () => this._getPartiallyLoadedRecordIds(fixtureTable),
+        isRecordPartiallyLoaded: recordId => this._getPartiallyLoadedRecordIds(fixtureTable).includes(recordId),
+        isRecordDeleted: recordId => this._deletedRecordIds.includes(recordId),
+        isRecordCellValueLoadedForFieldId: (recordId, fieldId) => this._isRecordCellValueLoadedForFieldId(fixtureTable, recordId, fieldId),
+        getRecordCellValueByFieldId: (recordId, fieldId) => this._getRecordCellValueByFieldId(fixtureTable, recordId, fieldId),
+        getRecordCommentCount: recordId => this._getRecordCommentCount(fixtureTable, recordId),
+        getRecordCreatedTime: recordId => this._getRecordCreatedTime(fixtureTable, recordId)
+      };
+    }
+  }, {
+    key: "_getPartiallyLoadedRecordIds",
+    value: function _getPartiallyLoadedRecordIds(fixtureTable) {
+      var _this = this;
+
+      for (var _i6 = 0, _Object$values6 = Object.values(this._subscribedQuerySpecs); _i6 < _Object$values6.length; _i6++) {
+        var querySpec = _Object$values6[_i6].querySpec;
+
+        if (querySpec.sourceType === _block_query_spec.BlockQuerySourceType.TABLE && querySpec.sourceTableId === fixtureTable.id) {
+          return fixtureTable.records.map(r => r.id);
+        }
+
+        if (querySpec.sourceType === _block_query_spec.BlockQuerySourceType.VIEW && querySpec.sourceTableId === fixtureTable.id) {
+          var _ret = function () {
+            var viewId = querySpec.sourceViewId;
+            return {
+              v: fixtureTable.records.filter(r => {
+                var _this$getViewMetadata, _this$getViewMetadata2;
+
+                return (_this$getViewMetadata = _this.getViewMetadataStoreIfExists(fixtureTable.id, viewId)) === null || _this$getViewMetadata === void 0 ? void 0 : (_this$getViewMetadata2 = _this$getViewMetadata.getVisibleRecordIds()) === null || _this$getViewMetadata2 === void 0 ? void 0 : _this$getViewMetadata2.includes(r.id);
+              }).map(r => r.id)
+            };
+          }();
+
+          if (typeof _ret === "object") return _ret.v;
+        }
+      }
+
+      return [];
+    }
+  }, {
+    key: "createTable",
+    value: function createTable(tableId, name, fields) {
+      var fieldData = fields.map(field => {
+        return _objectSpread({
+          id: this._mockAirtableInterface.idGenerator.generateFieldId(),
+          name: field.name,
+          description: '',
+          type: field.type,
+          typeOptions: field.options
+        }, unmodifiableFieldData);
+      });
+      var viewData = {
+        id: this._mockAirtableInterface.idGenerator.generateViewId(),
+        name: 'Dynamically-generated Grid view',
+        type: _view.ViewType.GRID
+      };
+      var viewMetadata = {
+        fieldOrder: {
+          fieldIds: fieldData.map((_ref2) => {
+            var id = _ref2.id;
+            return id;
+          }),
+          visibleFieldCount: fieldData.length
+        }
+      };
+      this._tablesById[tableId] = {
+        id: tableId,
+        name,
+        description: '',
+        fields,
+        views: [_objectSpread({}, viewData, {}, viewMetadata, {
+          records: []
+        })],
+        records: []
+      };
+
+      this._mockAirtableInterface.triggerModelUpdates([{
+        path: ['tablesById', tableId],
+        value: _objectSpread({
+          id: tableId,
+          name: name,
+          primaryFieldId: fieldData[0].id,
+          viewOrder: [viewData.id],
+          viewsById: {
+            [viewData.id]: viewData
+          },
+          fieldsById: (0, _private_utils.keyBy)(fieldData, _private_utils.getId)
+        }, unmodifiableTableData)
+      }, {
+        path: ['tableOrder'],
+        value: this._mockAirtableInterface.sdkInitData.baseData.tableOrder.concat(tableId)
+      }]);
+    }
+  }, {
+    key: "addFieldToFixtureTable",
+    value: function addFieldToFixtureTable(tableId, fieldFixtureData) {
+      var fixtureTable = this._tablesById[tableId];
+
+      if (!fixtureTable) {
+        throw (0, _error_utils.spawnError)('Table (%s) is not loaded when loading adding Field to it', tableId);
+      }
+
+      fixtureTable.fields = [...fixtureTable.fields, fieldFixtureData];
+
+      this._mockAirtableInterface.triggerModelUpdates([{
+        path: ['tablesById', tableId, 'fieldsById', fieldFixtureData.id],
+        value: {
+          id: fieldFixtureData.id,
+          name: fieldFixtureData.name,
+          type: fieldFixtureData.type,
+          typeOptions: fieldFixtureData.options,
+          description: fieldFixtureData.description,
+          lock: null
+        }
+      }]);
+    }
+  }, {
+    key: "removeFieldFromFixtureTable",
+    value: function removeFieldFromFixtureTable(tableId, fieldId) {
+      var fixtureTable = this._tablesById[tableId];
+
+      if (!fixtureTable) {
+        throw (0, _error_utils.spawnError)('Table (%s) is not loaded when removing Field from it', tableId);
+      }
+
+      var fields = fixtureTable.fields,
+          views = fixtureTable.views;
+      var indexToRemove = fields.findIndex(f => f.id === fieldId);
+
+      if (indexToRemove === -1) {
+        throw (0, _error_utils.spawnError)('Table (%s) does not have Field %d for removal', tableId, fieldId);
+      }
+
+      fields.splice(indexToRemove, 1);
+      var modelUpdates = [{
+        path: ['tablesById', tableId, 'fieldsById', fieldId],
+        value: undefined
+      }];
+      var _iteratorNormalCompletion2 = true;
+      var _didIteratorError2 = false;
+      var _iteratorError2 = undefined;
+
+      try {
+        for (var _iterator2 = views[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
+          var view = _step2.value;
+          var fieldOrder = view.fieldOrder;
+          var index = fieldOrder.fieldIds.indexOf(fieldId);
+          var fieldIds = fieldOrder.fieldIds;
+          fieldIds.splice(index, 1);
+          var visibleFieldCount = index < fieldOrder.visibleFieldCount ? fieldOrder.visibleFieldCount - 1 : fieldOrder.visibleFieldCount;
+          fieldOrder.visibleFieldCount = visibleFieldCount;
+          modelUpdates.push({
+            path: ['tablesById', tableId, 'viewsById', view.id, 'fieldOrder'],
+            value: {
+              fieldIds,
+              visibleFieldCount
+            }
+          });
+        }
+      } catch (err) {
+        _didIteratorError2 = true;
+        _iteratorError2 = err;
+      } finally {
+        try {
+          if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
+            _iterator2.return();
+          }
+        } finally {
+          if (_didIteratorError2) {
+            throw _iteratorError2;
+          }
+        }
+      }
+
+      this._mockAirtableInterface.triggerModelUpdates(modelUpdates);
+    }
+  }, {
+    key: "_isRecordCellValueLoadedForFieldId",
+    value: function _isRecordCellValueLoadedForFieldId(fixtureTable, recordId, fieldId) {
+      var _querySpec$recordSele8;
+
+      if (!fixtureTable.fields.find(f => f.id === fieldId)) {
+        return false;
+      }
+
+      for (var _i7 = 0, _Object$values7 = Object.values(this._subscribedQuerySpecs); _i7 < _Object$values7.length; _i7++) {
+        var querySpec = _Object$values7[_i7].querySpec;
+
+        if (querySpec.sourceTableId === fixtureTable.id && fixtureTable.records.find(r => r.id === recordId)) {
+          switch ((_querySpec$recordSele8 = querySpec.recordSelection) === null || _querySpec$recordSele8 === void 0 ? void 0 : _querySpec$recordSele8.fieldSelection.type) {
+            case _block_query_spec.BlockFieldSelectionSpecType.ALL_FIELDS_FROM_TABLE:
+              return true;
+
+            case _block_query_spec.BlockFieldSelectionSpecType.SPECIFIED_FIELDS:
+              return querySpec.recordSelection.fieldSelection.fieldIds.includes(fieldId);
+
+            default:
+              break;
+          }
+        }
+      }
+
+      return false;
+    }
+  }, {
+    key: "_getRecordCellValueByFieldId",
+    value: function _getRecordCellValueByFieldId(fixtureTable, recordId, fieldId) {
+      if (!this._isRecordCellValueLoadedForFieldId(fixtureTable, recordId, fieldId)) {
+        return undefined;
+      }
+
+      var cellValue = fixtureTable.records.find(r => r.id === recordId).cellValuesByFieldId[fieldId]; // Hyperbase is responsible for always returning null if the cell is undefined
+
+      if (cellValue === undefined) {
+        return null;
+      }
+
+      return cellValue;
+    }
+  }, {
+    key: "_getRecordCommentCount",
+    value: function _getRecordCommentCount(fixtureTable, recordId) {
+      var specifiedRecord = fixtureTable.records.find(r => r.id === recordId);
+
+      if (!specifiedRecord) {
+        throw (0, _error_utils.spawnError)('Record is not loaded %s when loading commentCount', recordId);
+      }
+
+      return specifiedRecord.commentCount;
+    }
+  }, {
+    key: "_getRecordCreatedTime",
+    value: function _getRecordCreatedTime(fixtureTable, recordId) {
+      var specifiedRecord = fixtureTable.records.find(r => r.id === recordId);
+
+      if (!specifiedRecord) {
+        throw (0, _error_utils.spawnError)('Record is not loaded %s when loading createdTime', recordId);
+      }
+
+      return new Date(specifiedRecord.createdTime);
+    }
+  }, {
+    key: "setViewData",
+    value: function setViewData(tableId, viewId, viewFixtureData) {
+      var table = this._tablesById[tableId];
+      (0, _error_utils.invariant)(table, 'setViewData called with missing table %s', tableId);
+      var view = table.views.find(v => v.id === viewId);
+      (0, _error_utils.invariant)(view, 'setViewData called with missing view %s, got %s', viewId, JSON.stringify(table.views.map(v => v.id)));
+      Object.assign(view, viewFixtureData);
+      var sdkPriorityCallbacks = [];
+      var blockCodePriorityCallbacks = [];
+
+      for (var _i8 = 0, _Object$values8 = Object.values(this._subscribedQuerySpecs); _i8 < _Object$values8.length; _i8++) {
+        var _querySpec$viewMetada2, _querySpec$viewMetada3, _querySpec$viewMetada4, _querySpec$viewMetada5, _querySpec$viewMetada6;
+
+        var _Object$values8$_i = _Object$values8[_i8],
+            querySpec = _Object$values8$_i.querySpec,
+            onChangeCallback = _Object$values8$_i.onChangeCallback,
+            callbackPriority = _Object$values8$_i.callbackPriority;
+
+        if (!onChangeCallback) {
+          continue;
+        }
+
+        if (querySpec.sourceType !== _block_query_spec.BlockQuerySourceType.VIEW) {
+          continue;
+        }
+
+        if (querySpec.sourceTableId !== tableId || querySpec.sourceViewId !== viewId) {
+          continue;
+        }
+
+        if (viewFixtureData.groups && ((_querySpec$viewMetada2 = querySpec.viewMetadataSelection) === null || _querySpec$viewMetada2 === void 0 ? void 0 : _querySpec$viewMetada2.shouldIncludeGroups) || viewFixtureData.groupLevels && ((_querySpec$viewMetada3 = querySpec.viewMetadataSelection) === null || _querySpec$viewMetada3 === void 0 ? void 0 : _querySpec$viewMetada3.shouldIncludeGroupingLevels) || viewFixtureData.fieldOrder && ((_querySpec$viewMetada4 = querySpec.viewMetadataSelection) === null || _querySpec$viewMetada4 === void 0 ? void 0 : _querySpec$viewMetada4.shouldIncludeFieldOrder) || viewFixtureData.records && ((_querySpec$viewMetada5 = querySpec.viewMetadataSelection) === null || _querySpec$viewMetada5 === void 0 ? void 0 : _querySpec$viewMetada5.shouldIncludeVisibleRecordIds) || viewFixtureData.records && ((_querySpec$viewMetada6 = querySpec.viewMetadataSelection) === null || _querySpec$viewMetada6 === void 0 ? void 0 : _querySpec$viewMetada6.shouldIncludeColorsForRecordId)) {
+          if (callbackPriority === _airtable_interface.BlockQueryCallbackPriority.SDK) {
+            sdkPriorityCallbacks.push(onChangeCallback);
+          } else {
+            blockCodePriorityCallbacks.push(onChangeCallback);
+          }
+        }
+      }
+
+      for (var _i9 = 0, _arr = [...sdkPriorityCallbacks, ...blockCodePriorityCallbacks]; _i9 < _arr.length; _i9++) {
+        var callback = _arr[_i9];
+        callback([]);
+      }
+    } // Allows access to view data that has been subscribed using queries
+
+  }, {
+    key: "getViewMetadataStoreIfExists",
+    value: function getViewMetadataStoreIfExists(tableId, viewId) {
+      var fixtureTable = this._tablesById[tableId];
+
+      if (!fixtureTable) {
+        return null;
+      }
+
+      var fixtureView = fixtureTable.views.find(v => v.id === viewId);
+
+      if (!fixtureView) {
+        return null;
+      }
+
+      return {
+        getViewId: () => fixtureView.id,
+        getVisibleRecordIds: () => fixtureView.records.map(r => r.id),
+        getFieldOrder: () => fixtureView.fieldOrder,
+        getGroups: () => {
+          var _fixtureView$groups;
+
+          return (_fixtureView$groups = fixtureView.groups) !== null && _fixtureView$groups !== void 0 ? _fixtureView$groups : null;
+        },
+        getGroupLevels: () => {
+          var _fixtureView$groupLev;
+
+          return (_fixtureView$groupLev = fixtureView.groupLevels) !== null && _fixtureView$groupLev !== void 0 ? _fixtureView$groupLev : null;
+        },
+        getColorForRecordId: recordId => {
+          var _ref3, _fixtureView$records$;
+
+          return (_ref3 = (_fixtureView$records$ = fixtureView.records.find(r => r.id === recordId)) === null || _fixtureView$records$ === void 0 ? void 0 : _fixtureView$records$.color) !== null && _ref3 !== void 0 ? _ref3 : null;
+        }
+      };
+    }
+  }, {
+    key: "getCountOfQueriesSubscribed",
+    value: function getCountOfQueriesSubscribed() {
+      return Object.keys(this._subscribedQuerySpecs).length;
+    }
+  }, {
+    key: "onUnsubscribeFromQuery",
+    value: function onUnsubscribeFromQuery(onUnsubscribeFromQueryCallback) {
+      this._onUnsubscribeFromQueryCallback = onUnsubscribeFromQueryCallback;
+    }
+  }]);
+  return MockBaseDataStore;
+}();
+
+exports.MockBaseDataStore = MockBaseDataStore;