@airtable/blocks 1.10.1 → 1.11.0

package/dist/cjs/error_utils.js

@@ -1,11 +1,16 @@
 "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.invariant = invariant;
 exports.spawnUnknownSwitchCaseError = spawnUnknownSwitchCaseError;
 exports.spawnAbstractMethodError = spawnAbstractMethodError;
@@ -52,6 +57,26 @@ function spawnError(errorMessageFormat) {
   }
 
   return spawnErrorWithOriginOmittedFromStackTrace(errorMessageFormat, errorMessageArgs, spawnError);
+} // istanbul ignore next
+
+/**
+ * Logs an error to Rollbar
+ *
+ * @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];
+    }
+
+    rollbar.warn(spawnError(errorMessageFormat, ...errorMessageArgs));
+  }
 }
 /**
  * An alternative to facebook's invariant that's safe to use with base data
@@ -62,8 +87,8 @@ function spawnError(errorMessageFormat) {
 
 function invariant(condition, errorMessageFormat) {
   if (!condition) {
-    for (var _len2 = arguments.length, errorMessageArgs = new Array(_len2 > 2 ? _len2 - 2 : 0), _key2 = 2; _key2 < _len2; _key2++) {
-      errorMessageArgs[_key2 - 2] = arguments[_key2];
+    for (var _len3 = arguments.length, errorMessageArgs = new Array(_len3 > 2 ? _len3 - 2 : 0), _key3 = 2; _key3 < _len3; _key3++) {
+      errorMessageArgs[_key3 - 2] = arguments[_key3];
     }
 
     throw spawnErrorWithOriginOmittedFromStackTrace(errorMessageFormat, errorMessageArgs, invariant);

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/linked_records_query_result.js

@@ -520,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
 
@@ -610,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
 
 

package/dist/cjs/models/mutations.js

@@ -231,6 +231,26 @@ function () {
     }
     /** @internal */
 
+  }, {
+    key: "_assertFieldNameIsValidForMutation",
+    value: function _assertFieldNameIsValidForMutation(name, table) {
+      if (!name) {
+        throw (0, _error_utils.spawnError)("Can't create or update field: must provide non-empty name");
+      }
+
+      if (name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
+        throw (0, _error_utils.spawnError)("Can't create or update field: name '%s' exceeds maximum length of %s characters", name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+      } // Verify the new name doesn't collide with any existing field name.
+
+
+      var existingLowercaseFieldNames = table.fields.map(field => field.name.toLowerCase());
+
+      if (existingLowercaseFieldNames.includes(name.toLowerCase())) {
+        throw (0, _error_utils.spawnError)("Can't create or update field: field with name '%s' already exists", name);
+      }
+    }
+    /** @internal */
+
   }, {
     key: "_assertMutationIsValid",
     value: function _assertMutationIsValid(mutation) {
@@ -455,19 +475,7 @@ function () {
               throw (0, _error_utils.spawnError)("Can't create field: table already has the maximum of %s fields", _mutation_constants.MAX_NUM_FIELDS_PER_TABLE);
             }
 
-            if (!name) {
-              throw (0, _error_utils.spawnError)("Can't create field: must provide non-empty name");
-            }
-
-            if (name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
-              throw (0, _error_utils.spawnError)("Can't create field: name '%s' exceeds maximum length of %s characters", name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
-            }
-
-            var existingLowercaseFieldNames = _table3.fields.map(field => field.name.toLowerCase());
-
-            if (existingLowercaseFieldNames.includes(name.toLowerCase())) {
-              throw (0, _error_utils.spawnError)("Can't create field: field with name '%s' already exists", name);
-            } // Current config / field data is null since the field doesn't exist.
+            this._assertFieldNameIsValidForMutation(name, _table3); // Current config / field data is null since the field doesn't exist.
 
 
             var _validationResult2 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, config, null, null, billingPlanGrouping);
@@ -541,23 +549,51 @@ function () {
             return;
           }
 
+        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
+          {
+            var _tableId6 = mutation.tableId,
+                _id2 = mutation.id,
+                _name = mutation.name;
+
+            var _table6 = this._base.getTableByIdIfExists(_tableId6);
+
+            if (!_table6) {
+              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId6);
+            }
+
+            var _field4 = _table6.getFieldByIdIfExists(_id2);
+
+            if (!_field4) {
+              throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", _id2);
+            } // We skip name validation if it's the same name:
+            // If it's exactly same name, this will result in no-op;
+            // If it's only case change, we allow update and we know this name is already validated before;
+
+
+            if (_field4.name.toLowerCase() !== _name.toLowerCase()) {
+              this._assertFieldNameIsValidForMutation(_name, _table6);
+            }
+
+            return;
+          }
+
         case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
           {
-            var _name = mutation.name,
+            var _name2 = mutation.name,
                 fields = mutation.fields;
 
-            if (!_name) {
+            if (!_name2) {
               throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name");
             }
 
-            if (_name.length > _mutation_constants.MAX_TABLE_NAME_LENGTH) {
-              throw (0, _error_utils.spawnError)("Can't create table: name '%s' exceeds maximum length of %s characters", _name, _mutation_constants.MAX_TABLE_NAME_LENGTH);
+            if (_name2.length > _mutation_constants.MAX_TABLE_NAME_LENGTH) {
+              throw (0, _error_utils.spawnError)("Can't create table: name '%s' exceeds maximum length of %s characters", _name2, _mutation_constants.MAX_TABLE_NAME_LENGTH);
             }
 
             var existingLowercaseTableNames = this._base.tables.map(table => table.name.toLowerCase());
 
-            if (existingLowercaseTableNames.includes(_name.toLowerCase())) {
-              throw (0, _error_utils.spawnError)("Can't create table: table with name '%s' already exists", _name);
+            if (existingLowercaseTableNames.includes(_name2.toLowerCase())) {
+              throw (0, _error_utils.spawnError)("Can't create table: table with name '%s' already exists", _name2);
             }
 
             if (fields.length === 0) {
@@ -575,32 +611,32 @@ function () {
 
             try {
               for (var _iterator4 = fields[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-                var _field4 = _step4.value;
+                var _field5 = _step4.value;
 
-                if (!_field4.name) {
+                if (!_field5.name) {
                   throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name for every field");
                 }
 
-                if (_field4.name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
-                  throw (0, _error_utils.spawnError)("Can't create table: field name '%s' exceeds maximum length of %s characters", _field4.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+                if (_field5.name.length > _mutation_constants.MAX_FIELD_NAME_LENGTH) {
+                  throw (0, _error_utils.spawnError)("Can't create table: field name '%s' exceeds maximum length of %s characters", _field5.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
                 }
 
-                var lowercaseFieldName = _field4.name.toLowerCase();
+                var lowercaseFieldName = _field5.name.toLowerCase();
 
                 if (lowercaseFieldNames.has(lowercaseFieldName)) {
-                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field4.name);
+                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field5.name);
                 }
 
                 lowercaseFieldNames.add(lowercaseFieldName); // Current config / field data is null since the field doesn't exist.
 
-                var _validationResult4 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field4.config, null, null, billingPlanGrouping);
+                var _validationResult4 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field5.config, null, null, billingPlanGrouping);
 
                 if (!_validationResult4.isValid) {
-                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field4.name, _validationResult4.reason);
+                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field5.name, _validationResult4.reason);
                 }
 
-                if (_field4.description && _field4.description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
-                  throw (0, _error_utils.spawnError)("Can't create table: description for field '%s' exceeds maximum length of %s characters", _field4.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+                if (_field5.description && _field5.description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+                  throw (0, _error_utils.spawnError)("Can't create table: description for field '%s' exceeds maximum length of %s characters", _field5.name, _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
                 }
               }
             } catch (err) {
@@ -629,7 +665,7 @@ function () {
 
         case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
           {
-            var _tableId6 = mutation.tableId,
+            var _tableId7 = mutation.tableId,
                 viewId = mutation.viewId;
             var runContext = this._airtableInterface.sdkInitData.runContext;
 
@@ -637,17 +673,17 @@ function () {
               throw (0, _error_utils.spawnError)('Setting view metadata is only valid for views');
             }
 
-            if (runContext.viewId !== viewId || runContext.tableId !== _tableId6) {
+            if (runContext.viewId !== viewId || runContext.tableId !== _tableId7) {
               throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
             }
 
-            var _table6 = this._base.getTableByIdIfExists(_tableId6);
+            var _table7 = this._base.getTableByIdIfExists(_tableId7);
 
-            if (!_table6) {
-              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId6);
+            if (!_table7) {
+              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId7);
             }
 
-            var view = _table6.getViewByIdIfExists(viewId);
+            var view = _table7.getViewByIdIfExists(viewId);
 
             if (!view) {
               throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);
@@ -705,19 +741,19 @@ function () {
 
         case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
           {
-            var _tableId7 = mutation.tableId,
+            var _tableId8 = mutation.tableId,
                 recordIds = mutation.recordIds;
 
-            var _recordStore2 = this._base.__getRecordStore(_tableId7);
+            var _recordStore2 = this._base.__getRecordStore(_tableId8);
 
             if (!_recordStore2.isRecordMetadataLoaded) {
               return [];
             }
 
             return [...recordIds.map(recordId => ({
-              path: ['tablesById', _tableId7, 'recordsById', recordId],
+              path: ['tablesById', _tableId8, 'recordsById', recordId],
               value: undefined
-            })), ...this._base.getTableById(_tableId7).views.flatMap(view => {
+            })), ...this._base.getTableById(_tableId8).views.flatMap(view => {
               var viewDataStore = _recordStore2.getViewDataStore(view.id);
 
               if (!viewDataStore.isDataLoaded) {
@@ -730,10 +766,10 @@ function () {
 
         case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
           {
-            var _tableId8 = mutation.tableId,
+            var _tableId9 = mutation.tableId,
                 _records2 = mutation.records;
 
-            var _recordStore3 = this._base.__getRecordStore(_tableId8);
+            var _recordStore3 = this._base.__getRecordStore(_tableId9);
 
             if (!_recordStore3.isRecordMetadataLoaded) {
               return [];
@@ -772,7 +808,7 @@ function () {
               }
 
               return {
-                path: ['tablesById', _tableId8, 'recordsById', record.id],
+                path: ['tablesById', _tableId9, 'recordsById', record.id],
                 value: {
                   id: record.id,
                   cellValuesByFieldId: filteredCellValuesByFieldId,
@@ -780,7 +816,7 @@ function () {
                   createdTime: new Date().toJSON()
                 }
               };
-            }), ...this._base.getTableById(_tableId8).views.flatMap(view => {
+            }), ...this._base.getTableById(_tableId9).views.flatMap(view => {
               var viewDataStore = _recordStore3.getViewDataStore(view.id);
 
               if (!viewDataStore.isDataLoaded) {
@@ -802,6 +838,7 @@ function () {
         case _mutations.MutationTypes.CREATE_SINGLE_FIELD:
         case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_CONFIG:
         case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_NAME:
         case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
         case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
           {

package/dist/cjs/models/record_store.js

@@ -515,7 +515,7 @@ function (_AbstractModelWithAsy) {
   }, {
     key: "_loadCellValuesInFieldIdsAsync",
     value: function _loadCellValuesInFieldIdsAsync(fieldIds) {
-      var _ref, newRecordsById, existingRecordsById, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, _step7$value, recordId, newRecordObj, existingRecordObj, existingCellValuesByFieldId, i, fieldId, changedKeys;
+      var _ref, newRecordsById, existingRecordsById, _iteratorNormalCompletion7, _didIteratorError7, _iteratorError7, _iterator7, _step7, _step7$value, recordId, newRecordObj, existingRecordObj, isCommentCountTypesSame, isCreatedTimeTypesSame, existingCellValuesByFieldId, i, fieldId, changedKeys;
 
       return _regenerator.default.async(function _loadCellValuesInFieldIdsAsync$(_context3) {
         while (1) {
@@ -545,12 +545,22 @@ function (_AbstractModelWithAsy) {
                 if (!(0, _private_utils.has)(existingRecordsById, recordId)) {
                   existingRecordsById[recordId] = newRecordObj;
                 } else {
-                  existingRecordObj = existingRecordsById[recordId]; // Metadata (createdTime, commentCount) should already be up to date,
-                  // but just verify for sanity. If this doesn't catch anything, can
-                  // remove it for perf.
+                  existingRecordObj = existingRecordsById[recordId]; // Metadata (createdTime, commentCount) should generally be up to date,
+                  // but can be out of date in the rare scenario where realtime
+                  // data has not yet been delivered to the SDK, but is populated in hyperbase
+                  // at the time this new fetch is executed.
+                  // istanbul ignore next
 
-                  (0, _error_utils.invariant)(existingRecordObj.commentCount === newRecordObj.commentCount, 'comment count out of sync');
-                  (0, _error_utils.invariant)(existingRecordObj.createdTime === newRecordObj.createdTime, 'created time out of sync');
+                  if (existingRecordObj.commentCount !== newRecordObj.commentCount) {
+                    isCommentCountTypesSame = typeof existingRecordObj.commentCount !== typeof newRecordObj.commentCount;
+                    (0, _error_utils.logErrorToRollbar)('comment count out of sync - types are same: %s', isCommentCountTypesSame);
+                  } // istanbul ignore next
+
+
+                  if (existingRecordObj.createdTime !== newRecordObj.createdTime) {
+                    isCreatedTimeTypesSame = typeof existingRecordObj.createdTime !== typeof newRecordObj.createdTime;
+                    (0, _error_utils.logErrorToRollbar)('created time out of sync - types are same: %s', isCreatedTimeTypesSame);
+                  }
 
                   if (!existingRecordObj.cellValuesByFieldId) {
                     existingRecordObj.cellValuesByFieldId = {};

package/dist/cjs/sdk.js

@@ -330,4 +330,4 @@ function () {
 }();
 
 exports.default = BlockSdk;
-(0, _defineProperty2.default)(BlockSdk, "VERSION", "1.10.1");
+(0, _defineProperty2.default)(BlockSdk, "VERSION", "1.11.0");

package/dist/cjs/types/mutations.js

@@ -18,6 +18,7 @@ var MutationTypes = Object.freeze({
   CREATE_SINGLE_FIELD: 'createSingleField',
   UPDATE_SINGLE_FIELD_CONFIG: 'updateSingleFieldConfig',
   UPDATE_SINGLE_FIELD_DESCRIPTION: 'updateSingleFieldDescription',
+  UPDATE_SINGLE_FIELD_NAME: 'updateSingleFieldName',
   CREATE_SINGLE_TABLE: 'createSingleTable',
   UPDATE_VIEW_METADATA: 'updateViewMetadata'
 });

package/dist/types/src/error_utils.d.ts

@@ -2,6 +2,12 @@
  * @hidden
  */
 export declare function spawnError(errorMessageFormat: string, ...errorMessageArgs: ReadonlyArray<unknown>): Error;
+/**
+ * Logs an error to Rollbar
+ *
+ * @hidden
+ */
+export declare function logErrorToRollbar(errorMessageFormat: string, ...errorMessageArgs: ReadonlyArray<unknown>): void;
 /**
  * An alternative to facebook's invariant that's safe to use with base data
  *

package/dist/types/src/error_utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"error_utils.d.ts","sourceRoot":"","sources":["../../../src/error_utils.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,wBAAgB,UAAU,CACtB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,aAAa,CAAC,OAAO,CAAC,SAO9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACrB,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,KAAK,CAAC,OAAO,CAAC,GACpC,OAAO,CAAC,SAAS,CAQnB"}
+{"version":3,"file":"error_utils.d.ts","sourceRoot":"","sources":["../../../src/error_utils.ts"],"names":[],"mappings":"AAsCA;;GAEG;AACH,wBAAgB,UAAU,CACtB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,aAAa,CAAC,OAAO,CAAC,SAO9C;AAGD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAC7B,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,aAAa,CAAC,OAAO,CAAC,QAO9C;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACrB,SAAS,EAAE,OAAO,EAClB,kBAAkB,EAAE,MAAM,EAC1B,GAAG,gBAAgB,EAAE,KAAK,CAAC,OAAO,CAAC,GACpC,OAAO,CAAC,SAAS,CAQnB"}

package/dist/types/src/models/base.d.ts

@@ -48,6 +48,16 @@ declare class Base extends AbstractModel<BaseData, WatchableBaseKey> {
      * ```
      */
     get name(): string;
+    /**
+     * The workspace id of the base.
+     *
+     * @example
+     * ```js
+     * import {base} from '@airtable/blocks';
+     * console.log('The workspace id of your base is', base.workspaceId);
+     * ```
+     */
+    get workspaceId(): string;
     /**
      * The color of the base.
      *

package/dist/types/src/models/base.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/models/base.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../../src/models/base.ts"],"names":[],"mappings":"AAAA,4CAA4C,CAAC,MAAM;AACnD,OAAO,EAAC,QAAQ,EAAc,MAAM,eAAe,CAAC;AACpD,OAAO,EAAC,gBAAgB,EAAE,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAC/D,OAAO,EAAC,SAAS,EAAC,MAAM,gBAAgB,CAAC;AACzC,OAAO,EAAgB,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AACxE,OAAO,EAAC,OAAO,EAAC,MAAM,gBAAgB,CAAC;AACvC,OAAO,EAAoC,YAAY,EAAiB,MAAM,kBAAkB,CAAC;AAGjG,OAAO,KAAK,MAAM,SAAS,CAAC;AAE5B,OAAO,aAAa,MAAM,kBAAkB,CAAC;AAgB7C,QAAA,MAAM,iBAAiB;;;;;;EAMrB,CAAC;AAEH;;;;;;GAMG;AACH,aAAK,gBAAgB,GAAG,YAAY,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAS/D;;;;;;;;;;;;;;GAcG;AACH,cAAM,IAAK,SAAQ,aAAa,CAAC,QAAQ,EAAE,gBAAgB,CAAC;IAwCxD;;;;;;;;OAQG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;OAQG;IACH,IAAI,WAAW,IAAI,MAAM,CAExB;IAED;;;;;;;;;OASG;IACH,IAAI,KAAK,IAAI,MAAM,CAElB;IAED;;;;;;;;OAQG;IACH,IAAI,MAAM,IAAI,KAAK,CAAC,KAAK,CAAC,CAczB;IACD;;;;;;;;OAQG;IACH,IAAI,mBAAmB,IAAI,KAAK,CAAC,gBAAgB,CAAC,CAIjD;IACD;;;;;OAKG;IACH,2BAA2B,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI;IAI5E;;;;;;;OAOG;IACH,mBAAmB,CAAC,cAAc,EAAE,MAAM,GAAG,gBAAgB;IAW7D;;;;;;;;OAQG;IACH,uBAAuB,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,IAAI;IA2BlF;;;;;;;;;OASG;IACH,eAAe,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,GAAG,gBAAgB,GAAG,IAAI;IA6B1E;;;;OAIG;IACH,oBAAoB,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IAenD;;;;;;OAMG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,KAAK;IAOpC;;;;OAIG;IACH,sBAAsB,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK,GAAG,IAAI;IAQvD;;;;;;OAMG;IACH,cAAc,CAAC,SAAS,EAAE,MAAM,GAAG,KAAK;IAOxC;;;;;;;;;OASG;IACH,gBAAgB,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK,GAAG,IAAI;IAK/D;;;;;;;;;;OAUG;IACH,QAAQ,CAAC,aAAa,EAAE,OAAO,GAAG,MAAM,GAAG,KAAK;IAYhD;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,8BAA8B,CAC1B,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,KAAK,CAAC;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB,OAAO,CAAC,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAC,GAAG,IAAI,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,GACH,qBAAqB;IAuBxB;;;;;;;;;;;;;;;;;;OAkBG;IACH,0BAA0B,CACtB,IAAI,CAAC,EAAE,MAAM,EACb,MAAM,CAAC,EAAE,KAAK,CAAC;QACX,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,SAAS,CAAC;QACjB,OAAO,CAAC,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAC,GAAG,IAAI,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,GACH,OAAO;IAIV;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAoDG;IACG,gBAAgB,CAClB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,KAAK,CAAC;QACV,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,SAAS,CAAC;QAChB,OAAO,CAAC,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAA;SAAC,GAAG,IAAI,CAAC;QAC1C,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KAC/B,CAAC,GACH,OAAO,CAAC,KAAK,CAAC;IA4BjB;;OAEG;IACH,qBAAqB,IAAI,MAAM;CAsHlC;AAED,eAAe,IAAI,CAAC"}

package/dist/types/src/models/field.d.ts

@@ -168,6 +168,64 @@ declare class Field extends AbstractModel<FieldData, WatchableFieldKey> {
      * ```
      */
     updateOptionsAsync(options: FieldOptions, opts?: UpdateFieldOptionsOpts): Promise<void>;
+    /**
+     * 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);
+     * }
+     * ```
+     */
+    checkPermissionsForUpdateName(name?: string): PermissionCheckResult;
+    /**
+     * 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!');
+     * }
+     * ```
+     */
+    hasPermissionToUpdateName(name?: string): boolean;
+    /**
+     * 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');
+     * ```
+     */
+    updateNameAsync(name: string): Promise<void>;
     /**
      * Checks whether the current user has permission to perform the given description update.
      *