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

package/CHANGELOG.md

@@ -9,10 +9,21 @@ Not every commit needs to result in a change to this file (e.g. docs and chore c
 commit that affects the code in a way that consumers might care about should include edits to the
 'Unreleased' section though. Breaking changes should be prefixed with `**BREAKING:**`.
 
-## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.10.2...HEAD)
+## [Unreleased](https://github.com/airtable/blocks/compare/@airtable/blocks@1.11.1...HEAD)
 
 No changes.
 
+## [1.11.1](https://github.com/airtable/blocks/compare/@airtable/blocks@1.11.0...@airtable/blocks@1.11.1) - 2022-04-13
+
+-   Update internal utilities for error reporting
+
+## [1.11.0](https://github.com/airtable/blocks/compare/@airtable/blocks@1.10.2...@airtable/blocks@1.11.0) - 2022-03-10
+
+-   Add workspace id to base object.
+-   Add `Field.updateNameAsync`
+-   Fixes a crash when a linked record is deleted
+-   Fixes a crash when a record containing a linked record is deleted and restored
+
 ## [1.10.2](https://github.com/airtable/blocks/compare/@airtable/blocks@1.10.1...@airtable/blocks@1.10.2) - 2022-01-25
 
 -   Rare invariant failure addressed

package/dist/cjs/error_utils.js

@@ -1,19 +1,14 @@
 "use strict";
 
-require("core-js/modules/es.array.iterator");
-
 require("core-js/modules/es.string.replace");
 
-require("core-js/modules/web.dom-collections.iterator");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.spawnError = spawnError;
-exports.logErrorToRollbar = logErrorToRollbar;
+exports.logErrorToSentry = logErrorToSentry;
 exports.invariant = invariant;
 exports.spawnUnknownSwitchCaseError = spawnUnknownSwitchCaseError;
-exports.spawnExhaustiveSwitchError = spawnExhaustiveSwitchError;
 exports.spawnAbstractMethodError = spawnAbstractMethodError;
 
 // If errorOriginFn is specified, all frames above and including the call to errorOriginFn
@@ -61,22 +56,18 @@ function spawnError(errorMessageFormat) {
 } // istanbul ignore next
 
 /**
- * Logs an error to Rollbar
+ * Logs an error to Sentry
  *
  * @hidden
  */
 
 
-function logErrorToRollbar(errorMessageFormat) {
-  // See this comment for how to log via Rollbar: https://github.com/Hyperbase/hyperbase/blob/009dcd1dc4c5204277c2939e7f61dfce74535f30/client/run_block_frame.tsx#L548
-  var rollbar = window.Rollbar;
-
-  if (rollbar === null || rollbar === void 0 ? void 0 : rollbar.warn) {
-    for (var _len2 = arguments.length, errorMessageArgs = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
-      errorMessageArgs[_key2 - 1] = arguments[_key2];
-    }
+function logErrorToSentry(errorMessage, metadata) {
+  // See this comment for how to log via Sentry: https://github.com/Hyperbase/hyperbase/blob/2c5438ecaddcb9fa196e027e40df5e0c68c90989/client/run_block_frame.tsx#L333
+  var blocksErrorReporter = window.blocksErrorReporter;
 
-    rollbar.warn(spawnError(errorMessageFormat, ...errorMessageArgs));
+  if (blocksErrorReporter === null || blocksErrorReporter === void 0 ? void 0 : blocksErrorReporter.reportWarning) {
+    blocksErrorReporter.reportWarning(errorMessage, metadata);
   }
 }
 /**
@@ -88,8 +79,8 @@ function logErrorToRollbar(errorMessageFormat) {
 
 function invariant(condition, errorMessageFormat) {
   if (!condition) {
-    for (var _len3 = arguments.length, errorMessageArgs = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
-      errorMessageArgs[_key3 - 2] = arguments[_key3];
+    for (var _len2 = arguments.length, errorMessageArgs = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
+      errorMessageArgs[_key2 - 2] = arguments[_key2];
     }
 
     throw spawnErrorWithOriginOmittedFromStackTrace(errorMessageFormat, errorMessageArgs, invariant);
@@ -105,22 +96,6 @@ function spawnUnknownSwitchCaseError(valueDescription, providedValue, key) {
   var providedValueKeyString = providedValueKey !== null && providedValueKey !== undefined ? providedValueKey : 'null';
   return spawnErrorWithOriginOmittedFromStackTrace('Unknown value %s for %s', [providedValueKeyString, valueDescription], spawnUnknownSwitchCaseError);
 }
-/**
- * Forces TypeScript to prove that calling this function is impossible at a
- * type level by accepting `never`. In the unlikely case this function is
- * called we infer a useful error message.
- *
- * @internal
- */
-
-
-function spawnExhaustiveSwitchError(impossibleValue) {
-  if (impossibleValue === null) {
-    return spawnErrorWithOriginOmittedFromStackTrace('Unexpected null in exhaustive switch', undefined, spawnExhaustiveSwitchError);
-  } else {
-    return spawnErrorWithOriginOmittedFromStackTrace("Unexpected %s in exhaustive switch", [typeof impossibleValue], spawnExhaustiveSwitchError);
-  }
-}
 /**
  * @internal
  */

package/dist/cjs/models/base.js

@@ -864,6 +864,21 @@ function (_AbstractModel) {
     get: function get() {
       return this._data.name;
     }
+    /**
+     * The workspace id of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The workspace id of your base is', base.workspaceId);
+     * ```
+     */
+
+  }, {
+    key: "workspaceId",
+    get: function get() {
+      return this._data.workspaceId;
+    }
     /**
      * The color of the base.
      *

package/dist/cjs/models/field.js

@@ -279,6 +279,101 @@ function (_AbstractModel) {
         }
       }, null, this);
     }
+    /**
+     * Checks whether the current user has permission to perform the given name update.
+     *
+     * Accepts partial input, in the same format as {@link updateNameAsync}.
+     *
+     * Returns `{hasPermission: true}` if the current user can update the specified field,
+     * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+     * used to display an error message to the user.
+     *
+     * @param name new name for the field
+     *
+     * @example
+     * ```js
+     * const updateFieldCheckResult = field.checkPermissionsForUpdateName();
+     *
+     * if (!updateFieldCheckResult.hasPermission) {
+     *     alert(updateFieldCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+
+  }, {
+    key: "checkPermissionsForUpdateName",
+    value: function checkPermissionsForUpdateName(name) {
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME,
+        tableId: this.parentTable.id,
+        id: this.id,
+        name
+      });
+    }
+    /**
+     * An alias for `checkPermissionsForUpdateName(options).hasPermission`.
+     *
+     * Checks whether the current user has permission to perform the name update.
+     *
+     * Accepts partial input, in the same format as {@link updateNameAsync}.
+     *
+     * @param name new name for the field
+     *
+     * @example
+     * ```js
+     * const canUpdateField = field.hasPermissionToUpdateName();
+     *
+     * if (!canUpdateField) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+
+  }, {
+    key: "hasPermissionToUpdateName",
+    value: function hasPermissionToUpdateName(name) {
+      return this.checkPermissionsForUpdateName(name).hasPermission;
+    }
+    /**
+     * Updates the name for this field.
+     *
+     * Throws an error if the user does not have permission to update the field, or if an invalid
+     * name is provided.
+     *
+     * This action is asynchronous. Unlike updates to cell values, updates to field name are
+     * **not** applied optimistically locally. You must `await` the returned promise before
+     * relying on the change in your app.
+     *
+     * @param name new name for the field
+     *
+     * @example
+     * ```js
+     * await myTextField.updateNameAsync('My New Name');
+     * ```
+     */
+
+  }, {
+    key: "updateNameAsync",
+    value: function updateNameAsync(name) {
+      return _regenerator.default.async(function updateNameAsync$(_context2) {
+        while (1) {
+          switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return _regenerator.default.awrap(this._sdk.__mutations.applyMutationAsync({
+                type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME,
+                tableId: this.parentTable.id,
+                id: this.id,
+                name
+              }));
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    }
     /**
      * Checks whether the current user has permission to perform the given description update.
      *
@@ -358,11 +453,11 @@ function (_AbstractModel) {
   }, {
     key: "updateDescriptionAsync",
     value: function updateDescriptionAsync(description) {
-      return _regenerator.default.async(function updateDescriptionAsync$(_context2) {
+      return _regenerator.default.async(function updateDescriptionAsync$(_context3) {
         while (1) {
-          switch (_context2.prev = _context2.next) {
+          switch (_context3.prev = _context3.next) {
             case 0:
-              _context2.next = 2;
+              _context3.next = 2;
               return _regenerator.default.awrap(this._sdk.__mutations.applyMutationAsync({
                 type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
                 tableId: this.parentTable.id,
@@ -372,7 +467,7 @@ function (_AbstractModel) {
 
             case 2:
             case "end":
-              return _context2.stop();
+              return _context3.stop();
           }
         }
       }, null, this);

package/dist/cjs/models/grouped_record_query_result.js

@@ -245,13 +245,19 @@ function (_RecordQueryResult) {
         while (1) {
           switch (_context2.prev = _context2.next) {
             case 0:
-              // TODO: This entire class assumes it is torn down and re-created by the parent whenever
-              // a change to the group is made.
-              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this);
+              this._parentQueryResult.__groupedRecordQueryResultPool.registerObjectForReuseStrong(this); // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
+              // TODO: (SeanKeenan) At the moment this should never be relevant, because groups are recreated
+              // anytime the groups change - but this is how it should work once groups persist AND
+              // watching recordIds only changes if records in this group change.
+              // In the meantime this does ensure that a deleted GroupedRecordQuery with stale recordIds
+              // doesn't return the cached array.
 
+
+              this.watch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
+              this.watch(['recordIds'], this._invalidateRecordIdsSet, this);
               return _context2.abrupt("return", this._getChangedKeysOnLoad());
 
-            case 2:
+            case 4:
             case "end":
               return _context2.stop();
           }
@@ -263,7 +269,10 @@ function (_RecordQueryResult) {
   }, {
     key: "_unloadData",
     value: function _unloadData() {
-      // Invalidate both of the caches, as this object can no longer be accessed
+      // Ensure we invalidate our memoized computed recordIds whenever a relevant hook changes
+      this.unwatch(['recordIds', 'groups', 'groupLevels'], this._invalidateComputedRecordIds, this);
+      this.unwatch(['recordIds'], this._invalidateRecordIdsSet, this); // Invalidate both of the caches, as this object can no longer be accessed
+
       this._invalidateComputedRecordIds();
 
       this._invalidateRecordIdsSet();

package/dist/cjs/models/linked_records_query_result.js

@@ -29,8 +29,6 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.default = exports.getLinkedTableId = void 0;
 
-var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
-
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 
 require("regenerator-runtime/runtime");
@@ -55,14 +53,8 @@ var _field = require("../types/field");
 
 var _error_utils = require("../error_utils");
 
-var _block_query_spec = require("../types/block_query_spec");
-
-var _airtable_interface = require("../types/airtable_interface");
-
 var _record_query_result = _interopRequireDefault(require("./record_query_result"));
 
-var _record_store = require("./record_store");
-
 /** @module @airtable/blocks/models: RecordQueryResult */
 
 /** */
@@ -126,8 +118,6 @@ function (_RecordQueryResult) {
 
   /** @internal */
 
-  /** @internal */
-
   /** @internal */
   function LinkedRecordsQueryResult(record, field, normalizedOpts, sdk) {
     var _this;
@@ -144,7 +134,6 @@ function (_RecordQueryResult) {
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_computedRecordIdsSet", null);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_computedFilteredSortedRecordIds", null);
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cellValueChangeHandlerByFieldId", {});
-    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_recordStoreQueryId", null);
     (0, _error_utils.invariant)(record.parentTable === field.parentTable, 'record and field must belong to the same table');
     _this._record = record;
     _this._field = field;
@@ -290,7 +279,7 @@ function (_RecordQueryResult) {
   }, {
     key: "_loadDataAsync",
     value: function _loadDataAsync() {
-      var initiallyLoaded, _ref, _ref2, recordStoreQueryId, changedKeys, fieldIds, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, fieldId;
+      var initiallyLoaded, changedKeys, fieldIds, _iteratorNormalCompletion3, _didIteratorError3, _iteratorError3, _iterator3, _step3, fieldId;
 
       return _regenerator.default.async(function _loadDataAsync$(_context2) {
         while (1) {
@@ -302,21 +291,11 @@ function (_RecordQueryResult) {
 
               this._watchLinkedQueryResult();
 
-              initiallyLoaded = this._linkedQueryResult.isDataLoaded; // https://airtable.com/appahuJQw7qfQTBBU/tblSbpimM8Spp9txp/viweAFIus3MhU9Gxa/recNjFYJpeV23LPhH?blocks=hide
-              // TODO: (#proj-blocks-sdk-record-limits) Currently queries all cell values in a table
-              // when loading linked record data. Must add a LinkedRecord query type in the future.
-              // Since _loadDataAsync can only be called once, this recordStoreQueryId is only set once,
-              // although it is guaranteed to be stable if needed (so long as this._field.id is stable)
-
+              initiallyLoaded = this._linkedQueryResult.isDataLoaded;
               _context2.next = 6;
-              return _regenerator.default.awrap(Promise.all([this._sdk.base.__getRecordStore(this._record.parentTable.id).loadAllCellValuesInFieldIdsAsync([this._field.id]), this._linkedQueryResult.loadDataAsync(), this._loadRecordColorsAsync()]));
+              return _regenerator.default.awrap(Promise.all([this._sdk.base.__getRecordStore(this._record.parentTable.id).loadCellValuesInFieldIdsAsync([this._field.id]), this._linkedQueryResult.loadDataAsync(), this._loadRecordColorsAsync()]));
 
             case 6:
-              _ref = _context2.sent;
-              _ref2 = (0, _slicedToArray2.default)(_ref, 1);
-              recordStoreQueryId = _ref2[0];
-              this._recordStoreQueryId = recordStoreQueryId;
-
               this._invalidateComputedData();
 
               changedKeys = ['records', 'recordIds', 'recordColors']; // If the linked query result was not initially loaded, then the
@@ -332,55 +311,55 @@ function (_RecordQueryResult) {
               _iteratorNormalCompletion3 = true;
               _didIteratorError3 = false;
               _iteratorError3 = undefined;
-              _context2.prev = 17;
+              _context2.prev = 13;
 
               for (_iterator3 = fieldIds[Symbol.iterator](); !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                 fieldId = _step3.value;
                 changedKeys.push(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
               }
 
-              _context2.next = 25;
+              _context2.next = 21;
               break;
 
-            case 21:
-              _context2.prev = 21;
-              _context2.t0 = _context2["catch"](17);
+            case 17:
+              _context2.prev = 17;
+              _context2.t0 = _context2["catch"](13);
               _didIteratorError3 = true;
               _iteratorError3 = _context2.t0;
 
-            case 25:
-              _context2.prev = 25;
-              _context2.prev = 26;
+            case 21:
+              _context2.prev = 21;
+              _context2.prev = 22;
 
               if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
                 _iterator3.return();
               }
 
-            case 28:
-              _context2.prev = 28;
+            case 24:
+              _context2.prev = 24;
 
               if (!_didIteratorError3) {
-                _context2.next = 31;
+                _context2.next = 27;
                 break;
               }
 
               throw _iteratorError3;
 
-            case 31:
-              return _context2.finish(28);
+            case 27:
+              return _context2.finish(24);
 
-            case 32:
-              return _context2.finish(25);
+            case 28:
+              return _context2.finish(21);
 
-            case 33:
+            case 29:
               return _context2.abrupt("return", changedKeys);
 
-            case 34:
+            case 30:
             case "end":
               return _context2.stop();
           }
         }
-      }, null, this, [[17, 21, 25, 33], [26,, 28, 32]]);
+      }, null, this, [[13, 17, 21, 29], [22,, 24, 28]]);
     }
     /** @internal */
 
@@ -397,9 +376,7 @@ function (_RecordQueryResult) {
 
         this._unwatchLinkedQueryResult();
 
-        (0, _error_utils.invariant)(this._recordStoreQueryId, 'Unsubscribing from linked record record store without queryId');
-
-        this._originRecordStore.unloadCellValuesForQueryIdsThatAreSubscribedToAllCells([this._recordStoreQueryId]);
+        this._originRecordStore.unloadCellValuesInFieldIds([this._field.id]);
 
         this._linkedQueryResult.unloadData();
 
@@ -471,13 +448,7 @@ function (_RecordQueryResult) {
       // result
 
 
-      this._originRecordStore.watchWithRecordQueryResult({
-        priority: _airtable_interface.BlockQueryCallbackPriority.SDK,
-        recordQueryResult: this,
-        keys: _record_store.WatchableRecordStoreKeys.recordIds,
-        callbackForRegistration: this._onOriginRecordsChange,
-        context: this
-      }); // if the linked field in the origin table is deleted, we need to
+      this._originRecordStore.watch('recordIds', this._onOriginRecordsChange, this); // if the linked field in the origin table is deleted, we need to
       // invalidate this result
 
 
@@ -549,12 +520,17 @@ function (_RecordQueryResult) {
   }, {
     key: "_onLinkedRecordIdsChange",
     value: function _onLinkedRecordIdsChange() {
-      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
-
-      if (!this.isDataLoaded) {
+      if (!this.isDataLoaded || this._record.isDeleted) {
+        //TODO(jamesmoody-at): Adding this._dataOrNullIfDeleted as an exit condition here is a temporary fix to address an issue where
+        // we are not reseting isValid to true while restoring deleted records that contain linked record fields. It seems the only way
+        // to do this is by creating a new LinkRecordsQueryResult instance but it seems like we might be reusing the original instance
+        // that we've already set isValid to false with. We'll need to do more investigating to figure out the right way to restore these
+        // records while keeping the behavior of isValid consistent
         return;
       }
 
+      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
+
       this._invalidateComputedData(); // we don't actually know at this stage whether anything changed or
       // not. it may have done though, so notify watchers
 
@@ -621,12 +597,11 @@ function (_RecordQueryResult) {
           if (Array.isArray(recordIds)) {
             var recordIdsSet = this._getOrGenerateRecordIdsSet();
 
-            var filteredRecordIds = recordIds.filter(id => typeof id === 'string' && recordIdsSet[id] === true); // There should always be a filteredRecordIds found for this query
-            // type - not finding any is a fundamental mistake in our query engine
+            var filteredRecordIds = recordIds.filter(id => typeof id === 'string' && recordIdsSet[id] === true);
 
-            (0, _error_utils.invariant)(filteredRecordIds.length, 'Filtered record change on incorrect record, query engine issue');
-
-            this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, filteredRecordIds);
+            if (filteredRecordIds.length) {
+              this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId, filteredRecordIds);
+            }
           } else {
             this._onChange(_record_query_result.default.WatchableCellValuesInFieldKeyPrefix + fieldId);
           }
@@ -640,15 +615,19 @@ function (_RecordQueryResult) {
   }, {
     key: "_onOriginCellValueChange",
     value: function _onOriginCellValueChange() {
-      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid');
-
-      if (!this.isDataLoaded) {
+      if (!this.isDataLoaded || this._field.isDeleted) {
+        //TODO(jamesmoody-at): Adding this._dataOrNullIfDeleted as an exit condition here is a temporary fix to address an issue where
+        // we are not resetting isValid to true while restoring deleted records that contain linked record fields. It seems the only way
+        // to do this is by creating a new LinkRecordsQueryResult instance but it seems like we might be reusing the original instance
+        // that we've already set isValid to false with. We'll need to do more investigating to figure out the right way to restore these
+        // records while keeping the behavior of isValid consistent
         return;
-      } // when the origin cell value (listing all the linked records) changes,
+      }
+
+      (0, _error_utils.invariant)(this.isValid, 'watch key change event whilst invalid'); // when the origin cell value (listing all the linked records) changes,
       // invalidate all the data we have stored - we need to completely
       // regenerate it
 
-
       this._invalidateComputedData(); // notify watchers that our set of linked records has changed
 
 
@@ -806,27 +785,6 @@ function (_RecordQueryResult) {
       (0, _error_utils.invariant)(recordIdsSet, 'recordIdsSet must exist');
       return recordIdsSet;
     }
-    /**
-     * This allows a record query result to specify the source of the query
-     * eg: View, Table, Linked record when watching fields.
-     * This scopes the watch to those fields + rows in the query.
-     *
-     * @internal
-     */
-
-  }, {
-    key: "__constructQuerySpecForBlockFieldSelectionSpec",
-    value: function __constructQuerySpecForBlockFieldSelectionSpec(fieldSelection) {
-      // The origin tableId is always the one referred to here as we must watch the origin record for deletion
-      var originTableId = this._record.parentTable.id;
-      return {
-        sourceType: _block_query_spec.BlockQuerySourceType.TABLE,
-        sourceTableId: originTableId,
-        recordSelection: {
-          fieldSelection
-        }
-      };
-    }
   }, {
     key: "isValid",
     get: function get() {