@airtable/blocks 1.8.0 → 1.10.0

package/dist/cjs/models/base.js

@@ -471,7 +471,8 @@ function (_AbstractModel) {
               type: field.type
             }, field.options ? {
               options: field.options
-            } : null) : undefined
+            } : null) : undefined,
+            description: field.description
           };
         })
       });
@@ -505,7 +506,8 @@ function (_AbstractModel) {
      * Creates a new table.
      *
      * Throws an error if the user does not have permission to create a table, if an invalid
-     * table name is provided, or if invalid fields are provided (invalid name, type or options).
+     * table name is provided, or if invalid fields are provided (invalid name, type, options or
+     * description).
      *
      * Refer to {@link FieldType} for supported field types, the write format for field options, and
      * other specifics for certain field types.
@@ -522,7 +524,10 @@ function (_AbstractModel) {
      * table in your app.
      *
      * @param name name for the table. must be case-insensitive unique
-     * @param fields array of fields to create in the table: see below for details.
+     * @param fields array of fields to create in the table: see below for an example. `name` and
+     * `type` must be specified for all fields, while `options` is only required for fields that
+     * have field options. `description` is optional and will be `''` if not specified or if
+     * specified as `null`.
      *
      * @example
      * ```js
@@ -530,7 +535,7 @@ function (_AbstractModel) {
      *     const name = 'My new table';
      *     const fields = [
      *         // Name will be the primary field of the table.
-     *         {name: 'Name', type: FieldType.SINGLE_LINE_TEXT},
+     *         {name: 'Name', type: FieldType.SINGLE_LINE_TEXT, description: 'This is the primary field'},
      *         {name: 'Notes', type: FieldType.RICH_TEXT},
      *         {name: 'Attachments', type: FieldType.MULTIPLE_ATTACHMENTS},
      *         {name: 'Number', type: FieldType.NUMBER, options: {
@@ -566,13 +571,19 @@ function (_AbstractModel) {
                 type: _mutations.MutationTypes.CREATE_SINGLE_TABLE,
                 name,
                 fields: fields.map(field => {
+                  var _field$description;
+
                   return {
                     name: field.name,
                     config: _objectSpread({
                       type: field.type
                     }, field.options ? {
                       options: field.options
-                    } : null)
+                    } : null),
+                    // Coerce undefined to null so that only old SDKs pass "undefined" for description
+                    // '' is permitted, as we already set empty descriptions to '' when editing descriptions
+                    // from the UI
+                    description: (_field$description = field.description) !== null && _field$description !== void 0 ? _field$description : null
                   };
                 })
               }));

package/dist/cjs/models/cursor.js

@@ -89,6 +89,7 @@ var WatchableCursorKeys = Object.freeze({
  *      return (
  *          <div>
  *              Active table: {cursor.activeTableId}
+ *              <br />
  *              Active view: {cursor.activeViewId}
  *          </div>
  *      );
@@ -109,6 +110,7 @@ var WatchableCursorKeys = Object.freeze({
  *      return (
  *          <div>
  *              Selected records: {cursor.selectedRecordIds.join(', ')}
+ *              <br />
  *              Selected fields: {cursor.selectedFieldIds.join(', ')}
  *          </div>
  *      );

package/dist/cjs/models/field.js

@@ -109,7 +109,9 @@ function (_AbstractModel) {
     (0, _classCallCheck2.default)(this, Field);
     _this = (0, _possibleConstructorReturn2.default)(this, (0, _getPrototypeOf2.default)(Field).call(this, sdk, fieldId));
     (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_parentTable", void 0);
+    (0, _defineProperty2.default)((0, _assertThisInitialized2.default)(_this), "_cachedFieldTypeConfigOrNull", void 0);
     _this._parentTable = parentTable;
+    _this._cachedFieldTypeConfigOrNull = null;
     return _this;
   }
   /**
@@ -118,6 +120,42 @@ function (_AbstractModel) {
 
 
   (0, _createClass2.default)(Field, [{
+    key: "_getCachedConfigFromFieldTypeProvider",
+    // We use a cached response from FieldTypeProvider because getting the config can
+    // be an expensive operation. In particular when fieldConfigs are extremely large
+    // (eg: Select fields with lots of select options)
+    value: function _getCachedConfigFromFieldTypeProvider() {
+      if (this._cachedFieldTypeConfigOrNull !== null) {
+        return this._cachedFieldTypeConfigOrNull;
+      }
+
+      var airtableInterface = this._sdk.__airtableInterface;
+      var appInterface = this._sdk.__appInterface;
+      this._cachedFieldTypeConfigOrNull = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById());
+      return this._cachedFieldTypeConfigOrNull;
+    }
+  }, {
+    key: "_clearCachedConfig",
+    value: function _clearCachedConfig() {
+      this._cachedFieldTypeConfigOrNull = null;
+    }
+    /**
+     * The type and options of the field to make type narrowing `FieldOptions` easier.
+     *
+     * @see {@link FieldConfig}
+     * @example
+     * const fieldConfig = field.config;
+     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
+     *     return fieldConfig.options.choices;
+     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
+     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
+     *         return fieldConfig.options.result.options.choices;
+     *     }
+     * }
+     * return DEFAULT_CHOICES;
+     */
+
+  }, {
     key: "checkPermissionsForUpdateOptions",
 
     /**
@@ -125,7 +163,7 @@ function (_AbstractModel) {
      *
      * Accepts partial input, in the same format as {@link updateOptionsAsync}.
      *
-     * Returns `{hasPermission: true}` if the current user can update the specified record,
+     * 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.
      *
@@ -241,6 +279,104 @@ function (_AbstractModel) {
         }
       }, null, this);
     }
+    /**
+     * Checks whether the current user has permission to perform the given description update.
+     *
+     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.
+     *
+     * 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 description new description for the field
+     *
+     * @example
+     * ```js
+     * const updateFieldCheckResult = field.checkPermissionsForUpdateDescription();
+     *
+     * if (!updateFieldCheckResult.hasPermission) {
+     *     alert(updateFieldCheckResult.reasonDisplayString);
+     * }
+     * ```
+     */
+
+  }, {
+    key: "checkPermissionsForUpdateDescription",
+    value: function checkPermissionsForUpdateDescription(description) {
+      return this._sdk.__mutations.checkPermissionsForMutation({
+        type: _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION,
+        tableId: this.parentTable.id,
+        id: this.id,
+        description
+      });
+    }
+    /**
+     * An alias for `checkPermissionsForUpdateDescription(options).hasPermission`.
+     *
+     * Checks whether the current user has permission to perform the description update.
+     *
+     * Accepts partial input, in the same format as {@link updateDescriptionAsync}.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * const canUpdateField = field.hasPermissionToUpdateDescription();
+     *
+     * if (!canUpdateField) {
+     *     alert('not allowed!');
+     * }
+     * ```
+     */
+
+  }, {
+    key: "hasPermissionToUpdateDescription",
+    value: function hasPermissionToUpdateDescription(description) {
+      return this.checkPermissionsForUpdateDescription(description).hasPermission;
+    }
+    /**
+     * Updates the description for this field.
+     *
+     * To remove an existing description, pass `''` as the new description.
+     * `null` is also accepted and will be coerced to `''` for consistency with field creation.
+     *
+     * Throws an error if the user does not have permission to update the field, or if an invalid
+     * description is provided.
+     *
+     * This action is asynchronous. Unlike updates to cell values, updates to field descriptions are
+     * **not** applied optimistically locally. You must `await` the returned promise before
+     * relying on the change in your app.
+     *
+     * @param description new description for the field
+     *
+     * @example
+     * ```js
+     * await myTextField.updateDescriptionAsync('This is a text field');
+     * ```
+     */
+
+  }, {
+    key: "updateDescriptionAsync",
+    value: function updateDescriptionAsync(description) {
+      return _regenerator.default.async(function updateDescriptionAsync$(_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_DESCRIPTION,
+                tableId: this.parentTable.id,
+                id: this.id,
+                description
+              }));
+
+            case 2:
+            case "end":
+              return _context2.stop();
+          }
+        }
+      }, null, this);
+    }
     /**
      * `true` if this field is computed, `false` otherwise. A field is
      * "computed" if it's value is not set by user input (e.g. autoNumber, formula,
@@ -329,6 +465,9 @@ function (_AbstractModel) {
   }, {
     key: "__triggerOnChangeForDirtyPaths",
     value: function __triggerOnChangeForDirtyPaths(dirtyPaths) {
+      // Always clear the cached config when anything on the field data model changes
+      this._clearCachedConfig();
+
       if (dirtyPaths.name) {
         this._onChange(WatchableFieldKeys.name);
       }
@@ -402,11 +541,8 @@ function (_AbstractModel) {
   }, {
     key: "type",
     get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-
-      var _airtableInterface$fi = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById()),
-          type = _airtableInterface$fi.type; // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
+      var _this$_getCachedConfi = this._getCachedConfigFromFieldTypeProvider(),
+          type = _this$_getCachedConfi.type; // We intend to switch from "lookup" to "multipleLookupValues", but need to support both
       // until the transition is complete. See <https://airtable.quip.com/VxaMAmAfUscs> for more.
       // @ts-ignore
 
@@ -437,31 +573,14 @@ function (_AbstractModel) {
   }, {
     key: "options",
     get: function get() {
-      var airtableInterface = this._sdk.__airtableInterface;
-      var appInterface = this._sdk.__appInterface;
-
-      var _airtableInterface$fi2 = airtableInterface.fieldTypeProvider.getConfig(appInterface, this._data, this.parentTable.__getFieldNamesById()),
-          options = _airtableInterface$fi2.options; // TODO(emma): can we remove this cloneDeep?
+      var _this$_getCachedConfi2 = this._getCachedConfigFromFieldTypeProvider(),
+          options = _this$_getCachedConfi2.options; // TODO: In the next breaking release freeze (inside of the cache) and replace
+      // FieldOptions with readonly<FieldOptions>.
+      // Today this is required because we re-use the fieldTypeProvider.getConfig response.
 
 
       return options ? (0, _private_utils.cloneDeep)(options) : null;
     }
-    /**
-     * The type and options of the field to make type narrowing `FieldOptions` easier.
-     *
-     * @see {@link FieldConfig}
-     * @example
-     * const fieldConfig = field.config;
-     * if (fieldConfig.type === FieldType.SINGLE_SELECT) {
-     *     return fieldConfig.options.choices;
-     * } else if (fieldConfig.type === FieldType.MULTIPLE_LOOKUP_VALUES && fieldConfig.options.isValid) {
-     *     if (fieldConfig.options.result.type === FieldType.SINGLE_SELECT) {
-     *         return fieldConfig.options.result.options.choices;
-     *     }
-     * }
-     * return DEFAULT_CHOICES;
-     */
-
   }, {
     key: "config",
     get: function get() {

package/dist/cjs/models/linked_records_query_result.js

@@ -376,7 +376,7 @@ function (_RecordQueryResult) {
 
         this._unwatchLinkedQueryResult();
 
-        this._sdk.base.__getRecordStore(this._record.parentTable.id).unloadCellValuesInFieldIds([this._field.id]);
+        this._originRecordStore.unloadCellValuesInFieldIds([this._field.id]);
 
         this._linkedQueryResult.unloadData();
 

package/dist/cjs/models/mutation_constants.js

@@ -3,10 +3,12 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.MAX_NUM_FIELDS_PER_TABLE = exports.MAX_TABLE_NAME_LENGTH = exports.MAX_FIELD_NAME_LENGTH = void 0;
+exports.MAX_NUM_FIELDS_PER_TABLE = exports.MAX_TABLE_NAME_LENGTH = exports.MAX_FIELD_DESCRIPTION_LENGTH = exports.MAX_FIELD_NAME_LENGTH = void 0;
 // Mirrored from clientServerSharedConfigSettings
 var MAX_FIELD_NAME_LENGTH = 255;
 exports.MAX_FIELD_NAME_LENGTH = MAX_FIELD_NAME_LENGTH;
+var MAX_FIELD_DESCRIPTION_LENGTH = 20000;
+exports.MAX_FIELD_DESCRIPTION_LENGTH = MAX_FIELD_DESCRIPTION_LENGTH;
 var MAX_TABLE_NAME_LENGTH = 255;
 exports.MAX_TABLE_NAME_LENGTH = MAX_TABLE_NAME_LENGTH;
 var MAX_NUM_FIELDS_PER_TABLE = 500;

package/dist/cjs/models/mutations.js

@@ -442,7 +442,8 @@ function () {
           {
             var _tableId3 = mutation.tableId,
                 name = mutation.name,
-                config = mutation.config;
+                config = mutation.config,
+                description = mutation.description;
 
             var _table3 = this._base.getTableByIdIfExists(_tableId3);
 
@@ -475,6 +476,10 @@ function () {
               throw (0, _error_utils.spawnError)("Can't create field: invalid field config.\n%s", _validationResult2.reason);
             }
 
+            if (description && description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+              throw (0, _error_utils.spawnError)("Can't create field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+            }
+
             return;
           }
 
@@ -511,6 +516,31 @@ function () {
             return;
           }
 
+        case _mutations.MutationTypes.UPDATE_SINGLE_FIELD_DESCRIPTION:
+          {
+            var _tableId5 = mutation.tableId,
+                _id = mutation.id,
+                _description = mutation.description;
+
+            var _table5 = this._base.getTableByIdIfExists(_tableId5);
+
+            if (!_table5) {
+              throw (0, _error_utils.spawnError)("Can't update field: No table with id %s exists", _tableId5);
+            }
+
+            var _field3 = _table5.getFieldByIdIfExists(_id);
+
+            if (!_field3) {
+              throw (0, _error_utils.spawnError)("Can't update field: No field with id %s exists", _id);
+            }
+
+            if (_description && _description.length > _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH) {
+              throw (0, _error_utils.spawnError)("Can't update field: description exceeds maximum length of %s characters", _mutation_constants.MAX_FIELD_DESCRIPTION_LENGTH);
+            }
+
+            return;
+          }
+
         case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
           {
             var _name = mutation.name,
@@ -545,28 +575,32 @@ function () {
 
             try {
               for (var _iterator4 = fields[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-                var _field3 = _step4.value;
+                var _field4 = _step4.value;
 
-                if (!_field3.name) {
+                if (!_field4.name) {
                   throw (0, _error_utils.spawnError)("Can't create table: must provide non-empty name for every field");
                 }
 
-                if (_field3.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", _field3.name, _mutation_constants.MAX_FIELD_NAME_LENGTH);
+                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);
                 }
 
-                var lowercaseFieldName = _field3.name.toLowerCase();
+                var lowercaseFieldName = _field4.name.toLowerCase();
 
                 if (lowercaseFieldNames.has(lowercaseFieldName)) {
-                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field3.name);
+                  throw (0, _error_utils.spawnError)("Can't create table: duplicate field name '%s'", _field4.name);
                 }
 
                 lowercaseFieldNames.add(lowercaseFieldName); // Current config / field data is null since the field doesn't exist.
 
-                var _validationResult4 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field3.config, null, null, billingPlanGrouping);
+                var _validationResult4 = this._airtableInterface.fieldTypeProvider.validateConfigForUpdate(appInterface, _field4.config, null, null, billingPlanGrouping);
 
                 if (!_validationResult4.isValid) {
-                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field3.name, _validationResult4.reason);
+                  throw (0, _error_utils.spawnError)("Can't create table: invalid field config for field '%s'.\n%s", _field4.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);
                 }
               }
             } catch (err) {
@@ -595,7 +629,7 @@ function () {
 
         case _mutations.MutationTypes.UPDATE_VIEW_METADATA:
           {
-            var _tableId5 = mutation.tableId,
+            var _tableId6 = mutation.tableId,
                 viewId = mutation.viewId;
             var runContext = this._airtableInterface.sdkInitData.runContext;
 
@@ -603,17 +637,17 @@ function () {
               throw (0, _error_utils.spawnError)('Setting view metadata is only valid for views');
             }
 
-            if (runContext.viewId !== viewId || runContext.tableId !== _tableId5) {
+            if (runContext.viewId !== viewId || runContext.tableId !== _tableId6) {
               throw (0, _error_utils.spawnError)('Custom views can only set view metadata on themselves');
             }
 
-            var _table5 = this._base.getTableByIdIfExists(_tableId5);
+            var _table6 = this._base.getTableByIdIfExists(_tableId6);
 
-            if (!_table5) {
-              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId5);
+            if (!_table6) {
+              throw (0, _error_utils.spawnError)("Can't update metadata: No table with id %s exists", _tableId6);
             }
 
-            var view = _table5.getViewByIdIfExists(viewId);
+            var view = _table6.getViewByIdIfExists(viewId);
 
             if (!view) {
               throw (0, _error_utils.spawnError)("Can't update metadata: No view with id %s exists", viewId);
@@ -671,19 +705,19 @@ function () {
 
         case _mutations.MutationTypes.DELETE_MULTIPLE_RECORDS:
           {
-            var _tableId6 = mutation.tableId,
+            var _tableId7 = mutation.tableId,
                 recordIds = mutation.recordIds;
 
-            var _recordStore2 = this._base.__getRecordStore(_tableId6);
+            var _recordStore2 = this._base.__getRecordStore(_tableId7);
 
             if (!_recordStore2.isRecordMetadataLoaded) {
               return [];
             }
 
             return [...recordIds.map(recordId => ({
-              path: ['tablesById', _tableId6, 'recordsById', recordId],
+              path: ['tablesById', _tableId7, 'recordsById', recordId],
               value: undefined
-            })), ...this._base.getTableById(_tableId6).views.flatMap(view => {
+            })), ...this._base.getTableById(_tableId7).views.flatMap(view => {
               var viewDataStore = _recordStore2.getViewDataStore(view.id);
 
               if (!viewDataStore.isDataLoaded) {
@@ -696,10 +730,10 @@ function () {
 
         case _mutations.MutationTypes.CREATE_MULTIPLE_RECORDS:
           {
-            var _tableId7 = mutation.tableId,
+            var _tableId8 = mutation.tableId,
                 _records2 = mutation.records;
 
-            var _recordStore3 = this._base.__getRecordStore(_tableId7);
+            var _recordStore3 = this._base.__getRecordStore(_tableId8);
 
             if (!_recordStore3.isRecordMetadataLoaded) {
               return [];
@@ -738,7 +772,7 @@ function () {
               }
 
               return {
-                path: ['tablesById', _tableId7, 'recordsById', record.id],
+                path: ['tablesById', _tableId8, 'recordsById', record.id],
                 value: {
                   id: record.id,
                   cellValuesByFieldId: filteredCellValuesByFieldId,
@@ -746,7 +780,7 @@ function () {
                   createdTime: new Date().toJSON()
                 }
               };
-            }), ...this._base.getTableById(_tableId7).views.flatMap(view => {
+            }), ...this._base.getTableById(_tableId8).views.flatMap(view => {
               var viewDataStore = _recordStore3.getViewDataStore(view.id);
 
               if (!viewDataStore.isDataLoaded) {
@@ -767,6 +801,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_VIEW_METADATA:
         case _mutations.MutationTypes.CREATE_SINGLE_TABLE:
           {

package/dist/cjs/models/table.js

@@ -1735,6 +1735,7 @@ function (_AbstractModel) {
      * @param name name for the field. must be case-insensitive unique for the table
      * @param type type for the field
      * @param options options for the field. omit for fields without writable options
+     * @param description description for the field. omit to leave blank
      *
      * @example
      * ```js
@@ -1748,7 +1749,7 @@ function (_AbstractModel) {
 
   }, {
     key: "checkPermissionsForCreateField",
-    value: function checkPermissionsForCreateField(name, type, options) {
+    value: function checkPermissionsForCreateField(name, type, options, description) {
       return this._sdk.__mutations.checkPermissionsForMutation({
         type: _mutations.MutationTypes.CREATE_SINGLE_FIELD,
         tableId: this.id,
@@ -1759,11 +1760,12 @@ function (_AbstractModel) {
           type: type
         }, options ? {
           options
-        } : null) : undefined
+        } : null) : undefined,
+        description
       });
     }
     /**
-     * An alias for `checkPermissionsForCreateField(name, type, options).hasPermission`.
+     * An alias for `checkPermissionsForCreateField(name, type, options, description).hasPermission`.
      *
      * Checks whether the current user has permission to create a field in this table.
      *
@@ -1772,6 +1774,7 @@ function (_AbstractModel) {
      * @param name name for the field. must be case-insensitive unique for the table
      * @param type type for the field
      * @param options options for the field. omit for fields without writable options
+     * @param description description for the field. omit to leave blank
      *
      * @example
      * ```js
@@ -1785,8 +1788,8 @@ function (_AbstractModel) {
 
   }, {
     key: "hasPermissionToCreateField",
-    value: function hasPermissionToCreateField(name, type, options) {
-      return this.checkPermissionsForCreateField(name, type, options).hasPermission;
+    value: function hasPermissionToCreateField(name, type, options, description) {
+      return this.checkPermissionsForCreateField(name, type, options, description).hasPermission;
     }
     /**
      * Creates a new field.
@@ -1807,6 +1810,8 @@ function (_AbstractModel) {
      * @param name name for the field. must be case-insensitive unique
      * @param type type for the field
      * @param options options for the field. omit for fields without writable options
+     * @param description description for the field. is optional and will be `''` if not specified
+     * or if specified as `null`.
      *
      * @example
      * ```js
@@ -1841,7 +1846,7 @@ function (_AbstractModel) {
 
   }, {
     key: "createFieldAsync",
-    value: function createFieldAsync(name, type, options) {
+    value: function createFieldAsync(name, type, options, description) {
       var fieldId;
       return _regenerator.default.async(function createFieldAsync$(_context9) {
         while (1) {
@@ -1858,7 +1863,11 @@ function (_AbstractModel) {
                   type: type
                 }, options ? {
                   options
-                } : null)
+                } : null),
+                // Coerce undefined to null so that only old SDKs pass "undefined" for description
+                // '' is permitted, as we already set empty descriptions to '' when editing descriptions
+                // from the UI
+                description: description !== null && description !== void 0 ? description : null
               }));
 
             case 3:

package/dist/cjs/private_utils.js

@@ -50,6 +50,7 @@ exports.compact = compact;
 exports.clamp = clamp;
 exports.flattenDeep = flattenDeep;
 exports.keyBy = keyBy;
+exports.getId = getId;
 exports.uniqBy = uniqBy;
 exports.getLocallyUniqueId = getLocallyUniqueId;
 exports.getValueAtOwnPath = getValueAtOwnPath;
@@ -411,6 +412,15 @@ function keyBy(array, getKey) {
  */
 
 
+function getId(_ref) {
+  var id = _ref.id;
+  return id;
+}
+/**
+ * @hidden
+ */
+
+
 function uniqBy(array, getKey) {
   var usedKeys = new Set();
   var result = [];

package/dist/cjs/sdk.js

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