@airtable/blocks 0.0.0-experimental-f52bc4e5e-20250709 → 0.0.0-experimental-3649c7162-20250904

package/dist/esm/base/assert_run_context.js

@@ -0,0 +1,12 @@
+"use strict";
+
+var _airtable_interface = _interopRequireDefault(require("../injected/airtable_interface"));
+var _error_utils = require("../shared/error_utils");
+var _airtable_interface2 = require("./types/airtable_interface");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+if (window.__getAirtableInterfaceAtVersion) {
+  const runContextType = (0, _airtable_interface.default)().sdkInitData.runContext.type;
+  if (runContextType !== _airtable_interface2.BlockRunContextType.DASHBOARD_APP && runContextType !== _airtable_interface2.BlockRunContextType.VIEW) {
+    throw (0, _error_utils.spawnError)('Unexpected import when running block in base');
+  }
+}

package/dist/{cjs → esm}/base/index.js

@@ -1,39 +1,35 @@
 "use strict";
 
-require("core-js/modules/es.array.iterator.js");
-require("core-js/modules/es.object.to-string.js");
-require("core-js/modules/es.weak-map.js");
-require("core-js/modules/web.dom-collections.iterator.js");
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.__reset = __reset;
 exports.viewport = exports.unstable_fetchAsync = exports.undoRedo = exports.settingsButton = exports.session = exports.runInfo = exports.reload = exports.installationId = exports.globalConfig = exports.cursor = exports.base = exports.__sdk = void 0;
+require("./assert_run_context");
 var _warning = _interopRequireWildcard(require("../shared/warning"));
 var _airtable_interface = _interopRequireDefault(require("../injected/airtable_interface"));
 var _perform_record_action = require("./perform_record_action");
-var _sdk2 = _interopRequireDefault(require("./sdk"));
-var _create_aggregators = require("./models/create_aggregators");
+var _sdk = _interopRequireDefault(require("./sdk"));
 var _initialize_block = require("./ui/initialize_block");
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
 function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /** @internal */
-var __sdk;
-var base;
-var globalConfig;
-var installationId;
-var reload;
-var runInfo;
-var settingsButton;
-var undoRedo;
-var viewport;
-var unstable_fetchAsync;
+let __sdk = exports.__sdk = void 0;
+let base = exports.base = void 0;
+let globalConfig = exports.globalConfig = void 0;
+let installationId = exports.installationId = void 0;
+let reload = exports.reload = void 0;
+let runInfo = exports.runInfo = void 0;
+let settingsButton = exports.settingsButton = void 0;
+let undoRedo = exports.undoRedo = void 0;
+let viewport = exports.viewport = void 0;
+let unstable_fetchAsync = exports.unstable_fetchAsync = void 0;
 
 // The `cursor` binding is declared on the following line solely as a signal to
 // the TypeScript compiler. The exported value is actually controlled by the
 // subsequent CommonJS module property descriptor.
-var cursor;
+let cursor = exports.cursor = void 0;
 Object.defineProperty(module.exports, 'cursor', {
   enumerable: true,
   get() {
@@ -45,7 +41,7 @@ Object.defineProperty(module.exports, 'cursor', {
 // The `session` binding is declared on the following line solely as a signal
 // to the TypeScript compiler. The exported value is actually controlled by the
 // subsequent CommonJS module property descriptor.
-var session;
+let session = exports.session = void 0;
 Object.defineProperty(module.exports, 'session', {
   enumerable: true,
   get() {
@@ -74,21 +70,23 @@ Object.defineProperty(module.exports, 'UI', {
 
 /** @internal */
 function __reset() {
-  exports.__sdk = __sdk = new _sdk2.default((0, _airtable_interface.default)());
+  exports.__sdk = __sdk = new _sdk.default((0, _airtable_interface.default)());
+  ({
+    base,
+    globalConfig,
+    installationId,
+    reload,
+    runInfo,
+    settingsButton,
+    undoRedo,
+    viewport,
+    unstable_fetchAsync
+  } = __sdk);
+
   // The following injections are necessary to allow the referenced modules
   // to be imported directly by consumer code while also avoiding cycles in
   // the module dependency graph.
-  var _sdk = __sdk;
-  exports.base = base = _sdk.base;
-  exports.globalConfig = globalConfig = _sdk.globalConfig;
-  exports.installationId = installationId = _sdk.installationId;
-  exports.reload = reload = _sdk.reload;
-  exports.runInfo = runInfo = _sdk.runInfo;
-  exports.settingsButton = settingsButton = _sdk.settingsButton;
-  exports.undoRedo = undoRedo = _sdk.undoRedo;
-  exports.viewport = viewport = _sdk.viewport;
-  exports.unstable_fetchAsync = unstable_fetchAsync = _sdk.unstable_fetchAsync;
-  (0, _create_aggregators.__injectSdkIntoCreateAggregators)(__sdk);
+  exports.base = base, exports.globalConfig = globalConfig, exports.installationId = installationId, exports.reload = reload, exports.runInfo = runInfo, exports.settingsButton = settingsButton, exports.undoRedo = undoRedo, exports.viewport = viewport, exports.unstable_fetchAsync = unstable_fetchAsync;
   (0, _perform_record_action.__injectSdkIntoPerformRecordAction)(__sdk);
   (0, _initialize_block.__injectSdkIntoInitializeBlock)(__sdk);
   (0, _warning.__injectSdkIntoWarning)(__sdk);

package/dist/esm/base/models/abstract_model_with_async_data.js

@@ -0,0 +1,190 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _private_utils = require("../../shared/private_utils");
+var _error_utils = require("../../shared/error_utils");
+var _abstract_model = _interopRequireDefault(require("../../shared/models/abstract_model"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module @airtable/blocks/models: Abstract models */ /** */
+
+/**
+ * Abstract superclass for all Blocks SDK models that need to fetch async data.
+ *
+ * @docsPath models/advanced/AbstractModelWithAsyncData
+ */
+class AbstractModelWithAsyncData extends _abstract_model.default {
+  /** @internal */
+  static __DATA_UNLOAD_DELAY_MS = 1000;
+  /** @internal */
+  static _shouldLoadDataForKey(key) {
+    // Override to return whether watching the key should trigger the
+    // data to be loaded for this model.
+    return false;
+  }
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  /**
+   * This flag is used to keep track of models that have been
+   * forced to unload (regardless of the retain count). The force
+   * unload happens via _forceUnload method and the only proper use
+   * of that function is when the underlying data gets deleted while
+   * the model is still active. e.g. when a table is deleted in the
+   * main extension while an instance of record_store is still alive.
+   * NOTE: Once set to true, it never goes back to false.
+   *
+   * @internal
+   */
+  _isForceUnloaded = false;
+  /** @hidden */
+  constructor(sdk, modelId) {
+    super(sdk, modelId);
+    this._isDataLoaded = false;
+    this._pendingDataLoadPromise = null;
+    this._dataRetainCount = 0;
+    this._unloadDataTimeoutId = null;
+  }
+  /**
+   * Watching a key that needs to load data asynchronously will automatically
+   * cause the data to be fetched. Once the data is available, the callback
+   * will be called.
+   *
+   * @inheritdoc
+   */
+  watch(keys, callback, context) {
+    this._assertNotForceUnloaded();
+    const validKeys = super.watch(keys, callback, context);
+    for (const key of validKeys) {
+      if (this.constructor._shouldLoadDataForKey(key)) {
+        // Note: for simplicity, we will call loadData for every key that needs
+        // needs data, relying on the retain count to unload once all keys have
+        // been unwatched.
+        (0, _private_utils.fireAndForgetPromise)(this.loadDataAsync.bind(this));
+      }
+    }
+    return validKeys;
+  }
+  /**
+   * Unwatching a key that needs to load data asynchronously will automatically
+   * cause the data to be released. Once the data is available, the callback
+   * will be called.
+   *
+   * @inheritdoc
+   */
+  unwatch(keys, callback, context) {
+    const validKeys = super.unwatch(keys, callback, context);
+    for (const key of validKeys) {
+      if (this.constructor._shouldLoadDataForKey(key)) {
+        // We called loadDataAsync for every key that needs data so call
+        // unloadData for every key to balance the retain count.
+        this.unloadData();
+      }
+    }
+    return validKeys;
+  }
+  /** @inheritdoc */
+  get isDeleted() {
+    if (this._isForceUnloaded) {
+      return true;
+    }
+    return super.isDeleted;
+  }
+  /** */
+  get isDataLoaded() {
+    if (this.isDeleted) {
+      return false;
+    }
+    return this._isDataLoaded;
+  }
+  /** @internal */
+
+  /** @internal */
+
+  /** @internal */
+
+  // Override this method if your model is dependent on other models.
+  // Do NOT load other models' data from _loadDataAsync, since it can lead to
+  // unexpected behavior.
+  // IMPORTANT: always call super.loadDataAsync() from your override.
+  /**
+   * Will cause all the async data to be fetched and retained. Every call to
+   * `loadDataAsync` should have a matching call to `unloadData`.
+   *
+   * Returns a Promise that will resolve once the data is loaded.
+   */
+  async loadDataAsync() {
+    this._assertNotForceUnloaded();
+    if (this._unloadDataTimeoutId !== null) {
+      // If we set a timeout to unload data, clear it since we are incrementing
+      // the retain count and loading data.
+      clearTimeout(this._unloadDataTimeoutId);
+      this._unloadDataTimeoutId = null;
+    }
+
+    // We keep a count of how many things have loaded the data so we don't
+    // actually unload the data until the retain count comes back down to zero.
+    this._dataRetainCount++;
+    if (this._isDataLoaded) {
+      return;
+    }
+    if (!this._pendingDataLoadPromise) {
+      this._pendingDataLoadPromise = this._loadDataAsync().then(changedKeys => {
+        this._isDataLoaded = true;
+        this._pendingDataLoadPromise = null;
+        for (const key of changedKeys) {
+          this._onChange(key);
+        }
+        this._onChangeIsDataLoaded();
+        return changedKeys;
+      });
+    }
+    await this._pendingDataLoadPromise;
+  }
+  // Override this method if your model is dependent on other models.
+  // Do NOT unload other models' data from _unloadData, since it can lead to
+  // unexpected behavior.
+  // IMPORTANT: always call super.unloadData() from your override.
+  /** */
+  unloadData() {
+    if (this._isForceUnloaded) {
+      return;
+    }
+    this._dataRetainCount--;
+    if (this._dataRetainCount < 0) {
+      console.warn(`Block ${this.constructor._className} data over-released`); // eslint-disable-line no-console
+      this._dataRetainCount = 0;
+    }
+    if (this._dataRetainCount === 0) {
+      // Don't unload immediately. Wait a while in case something else
+      // requests the data, so we can avoid going back to liveapp or
+      // the network.
+      this._unloadDataTimeoutId = setTimeout(() => {
+        (0, _error_utils.invariant)(this._dataRetainCount === 0, 'Unload data timeout fired with non-zero retain count');
+
+        // Set _isDataLoaded to false before calling _unloadData in case
+        // _unloadData reads from isDataLoaded.
+        this._isDataLoaded = false;
+        this._unloadData();
+        this._onChangeIsDataLoaded();
+      }, AbstractModelWithAsyncData.__DATA_UNLOAD_DELAY_MS);
+    }
+  }
+  _forceUnload() {
+    while (this._dataRetainCount > 0) {
+      this.unloadData();
+    }
+    this._isForceUnloaded = true;
+  }
+  _assertNotForceUnloaded() {
+    (0, _error_utils.invariant)(!this._isForceUnloaded, 'model (%s) permanently deleted', this.id);
+  }
+}
+var _default = exports.default = AbstractModelWithAsyncData;

package/dist/esm/base/models/base.js

@@ -0,0 +1,252 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+var _base_core = require("../../shared/models/base_core");
+var _mutations = require("../types/mutations");
+var _private_utils = require("../../shared/private_utils");
+var _record_store = _interopRequireDefault(require("./record_store"));
+var _table = _interopRequireDefault(require("./table"));
+var _create_aggregators = _interopRequireDefault(require("./create_aggregators"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+/** @module @airtable/blocks/models: Base */ /** */
+
+/**
+ * Model class representing a base.
+ *
+ * If you want the base model to automatically recalculate whenever the base schema changes, try the
+ * {@link useBase} hook. Alternatively, you can manually subscribe to changes with
+ * {@link useWatchable} (recommended) or [Base#watch](/api/models/Base#watch).
+ *
+ * @example
+ * ```js
+ * import {base} from '@airtable/blocks/base';
+ *
+ * console.log('The name of your base is', base.name);
+ * ```
+ * @docsPath models/Base
+ */
+class Base extends _base_core.BaseCore {
+  /** @internal */
+  static _className = 'Base';
+  _aggregators = null;
+
+  /** @internal */
+  _constructTable(tableId) {
+    const recordStore = this.__getRecordStore(tableId);
+    return new _table.default(this, recordStore, tableId, this._sdk);
+  }
+
+  /** @internal */
+  _constructRecordStore(sdk, tableId) {
+    return new _record_store.default(sdk, tableId);
+  }
+
+  /** @internal */
+  _iterateTableIds() {
+    return this._data.tableOrder;
+  }
+
+  /**
+   * Aggregators can be used to compute aggregates for cell values.
+   *
+   * @example
+   * ```js
+   * import {base} from '@airtable/blocks/base';
+   *
+   * // To get a list of aggregators supported for a specific field:
+   * const fieldAggregators = myField.availableAggregators;
+   *
+   * // To compute the total attachment size of an attachment field:
+   * const aggregator = base.aggregators.totalAttachmentSize;
+   * const value = aggregator.aggregate(myRecords, myAttachmentField);
+   * const valueAsString = aggregate.aggregateToString(myRecords, myAttachmentField);
+   * ```
+   */
+  get aggregators() {
+    if (!this._aggregators) {
+      this._aggregators = (0, _create_aggregators.default)(this._sdk);
+    }
+    return this._aggregators;
+  }
+
+  /**
+   * Checks whether the current user has permission to create a table.
+   *
+   * Accepts partial input, in the same format as {@link createTableAsync}.
+   *
+   * Returns `{hasPermission: true}` if the current user can update the specified record,
+   * `{hasPermission: false, reasonDisplayString: string}` otherwise. `reasonDisplayString` may be
+   * used to display an error message to the user.
+   *
+   * @param name name for the table. must be case-insensitive unique
+   * @param fields array of fields to create in the table
+   *
+   * @example
+   * ```js
+   * const createTableCheckResult = base.checkPermissionsForCreateTable();
+   *
+   * if (!createTableCheckResult.hasPermission) {
+   *     alert(createTableCheckResult.reasonDisplayString);
+   * }
+   * ```
+   */
+  checkPermissionsForCreateTable(name, fields) {
+    return this._sdk.__mutations.checkPermissionsForMutation({
+      type: _mutations.MutationTypes.CREATE_SINGLE_TABLE,
+      id: undefined,
+      // Generated in createTableAsync.
+      name: name,
+      fields: fields?.map(field => {
+        return {
+          name: field.name,
+          config: field.type ? {
+            type: field.type,
+            // In field.options we translate options to null when it's undefined (no options),
+            // but the mutation expects config to match the PublicApiConfig, where it's
+            // not present at all (options: undefined will fail validation).
+            ...(field.options ? {
+              options: field.options
+            } : null)
+          } : undefined,
+          description: field.description
+        };
+      })
+    });
+  }
+
+  /**
+   * An alias for `checkPermissionsForCreateTable(name, fields).hasPermission`.
+   *
+   * Checks whether the current user has permission to create a table.
+   *
+   * Accepts partial input, in the same format as {@link createTableAsync}.
+   *
+   * @param name name for the table. must be case-insensitive unique
+   * @param fields array of fields to create in the table
+   *
+   * @example
+   * ```js
+   * const canCreateTable = table.hasPermissionToCreateTable();
+   *
+   * if (!canCreateTable) {
+   *     alert('not allowed!');
+   * }
+   * ```
+   */
+  hasPermissionToCreateTable(name, fields) {
+    return this.checkPermissionsForCreateTable(name, fields).hasPermission;
+  }
+
+  /**
+   * 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, options or
+   * description).
+   *
+   * Refer to {@link FieldType} for supported field types, the write format for field options, and
+   * other specifics for certain field types.
+   *
+   * At least one field must be specified. The first field in the `fields` array will be used as
+   * the table's [primary field](https://support.airtable.com/hc/en-us/articles/202624179-The-Name-Field)
+   * and must be a supported primary field type. Fields must have case-insensitive unique names
+   * within the table.
+   *
+   * A default grid view will be created with all fields visible.
+   *
+   * This action is asynchronous. Unlike new records, new tables are **not** created
+   * optimistically locally. You must `await` the returned promise before using the new
+   * table in your extension.
+   *
+   * @param name name for the table. must be case-insensitive unique
+   * @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
+   * async function createNewTable() {
+   *     const name = 'My new table';
+   *     const fields = [
+   *         // Name will be the primary field of the table.
+   *         {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: {
+   *             precision: 8,
+   *         }},
+   *         {name: 'Select', type: FieldType.SINGLE_SELECT, options: {
+   *             choices: [
+   *                 {name: 'A'},
+   *                 {name: 'B'},
+   *             ],
+   *         }},
+   *     ];
+   *
+   *     if (base.hasPermissionToCreateTable(name, fields)) {
+   *         await base.createTableAsync(name, fields);
+   *     }
+   * }
+   * ```
+   */
+  async createTableAsync(name, fields) {
+    const tableId = this._sdk.__airtableInterface.idGenerator.generateTableId();
+    await this._sdk.__mutations.applyMutationAsync({
+      id: tableId,
+      type: _mutations.MutationTypes.CREATE_SINGLE_TABLE,
+      name,
+      fields: fields.map(field => {
+        return {
+          name: field.name,
+          config: {
+            type: field.type,
+            // In field.options we translate options to null when it's undefined (no options),
+            // but the mutation expects config to match the PublicApiConfig, where it's
+            // not present at all (options: undefined will fail validation).
+            ...(field.options ? {
+              options: field.options
+            } : 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 ?? null
+        };
+      })
+    });
+    return this.getTableById(tableId);
+  }
+
+  /**
+   * @internal
+   */
+  __triggerOnChangeForChangedPaths(changedPaths) {
+    super.__triggerOnChangeForChangedPaths(changedPaths);
+    let didSchemaChange = false;
+    if (changedPaths.tableOrder) {
+      this._onChange(_base_core.WatchableBaseKeys.tables);
+      didSchemaChange = true;
+
+      // Clean up deleted tables
+      for (const [tableId, tableModel] of (0, _private_utils.entries)(this._tableModelsById)) {
+        if (tableModel.isDeleted) {
+          delete this._tableModelsById[tableId];
+        }
+      }
+      for (const [tableId, recordStore] of (0, _private_utils.entries)(this._tableRecordStoresByTableId)) {
+        if (recordStore && recordStore.isDeleted) {
+          recordStore.__onDataDeletion();
+          delete this._tableRecordStoresByTableId[tableId];
+        }
+      }
+    }
+    if (didSchemaChange) {
+      this._onChange(_base_core.WatchableBaseKeys.schema);
+    }
+  }
+}
+var _default = exports.default = Base;

package/dist/esm/base/models/create_aggregators.js

@@ -0,0 +1,90 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = createAggregators;
+var _error_utils = require("../../shared/error_utils");
+// istanbul ignore file
+/** @module @airtable/blocks/models: Aggregators */ /** */
+
+/**
+ * Aggregators can be used to compute aggregates for cell values.
+ *
+ * @example
+ * ```js
+ * import {base} from '@airtable/blocks/base';
+ *
+ * // To get a list of aggregators supported for a specific field:
+ * const fieldAggregators = myField.availableAggregators;
+ *
+ * // To compute the total attachment size of an attachment field:
+ * const aggregator = base.aggregators.totalAttachmentSize;
+ * const value = aggregator.aggregate(myRecords, myAttachmentField);
+ * const valueAsString = aggregate.aggregateToString(myRecords, myAttachmentField);
+ * ```
+ * @docsPath models/Aggregator
+ */
+
+/**
+ * Note: this is hidden instead of internal as it is the type of the public models.aggregators.
+ *
+ * If its internal, typescript won't know about it since the types will be stripped, and typescript
+ * blocks will error due to incomplete type definitions.
+ *
+ * @hidden
+ */
+
+const aggregate = (sdk, aggregatorKey, records, field) => {
+  if (!field.isAggregatorAvailable(aggregatorKey)) {
+    throw (0, _error_utils.spawnError)('The %s aggregator is not available for %s fields', aggregatorKey, field.type);
+  }
+  const {
+    __appInterface: appInterface,
+    __airtableInterface: airtableInterface
+  } = sdk;
+  const cellValues = records.map(record => record._getRawCellValue(field));
+  return airtableInterface.aggregators.aggregate(appInterface, aggregatorKey, cellValues, field._data);
+};
+const aggregateToString = (sdk, aggregatorKey, records, field) => {
+  if (!field.isAggregatorAvailable(aggregatorKey)) {
+    throw (0, _error_utils.spawnError)('The %s aggregator is not available for %s fields', aggregatorKey, field.type);
+  }
+  const {
+    __appInterface: appInterface,
+    __airtableInterface: airtableInterface
+  } = sdk;
+  const cellValues = records.map(record => record._getRawCellValue(field));
+  return airtableInterface.aggregators.aggregateToString(appInterface, aggregatorKey, cellValues, field._data);
+};
+
+/**
+ * Note: this is hidden instead of internal as it is used to determine the type of the public
+ * models.aggregators.
+ *
+ * If its internal, typescript won't know about it since the types will be stripped, and typescript
+ * blocks will error due to incomplete type definitions.
+ *
+ * TODO: this should be made less brittle.
+ *
+ * @hidden
+ */
+function createAggregators(sdk) {
+  const {
+    __airtableInterface: airtableInterface
+  } = sdk;
+  const aggregators = {};
+  const aggregatorKeys = airtableInterface.aggregators.getAllAvailableAggregatorKeys();
+  for (const key of aggregatorKeys) {
+    const config = airtableInterface.aggregators.getAggregatorConfig(key);
+    aggregators[key] = Object.freeze({
+      key,
+      displayName: config.displayName,
+      shortDisplayName: config.shortDisplayName,
+      aggregate: aggregate.bind(null, sdk, key),
+      aggregateToString: aggregateToString.bind(null, sdk, key)
+    });
+  }
+  Object.freeze(aggregators);
+  return aggregators;
+}