airtable - npm Package Compare versions

Comparing version 0.10.1 to 0.11.0

CHANGELOG.md

@@ -0,1 +1,6 @@
+# v0.11.0
+ * Add support for custom headers
+ * Allow requestTimeout to be configured like other AirtableOptions
+ * Fix type warnings
+
 # v0.10.1
@@ -2,0 +7,0 @@ * Fix error handler in updating an array (#223)

lib/abort-controller.js

@@ -7,12 +7,12 @@ "use strict";
 }
+else if ('signal' in new Request('')) {
+    AbortController = window.AbortController;
+}
 else {
-    if ('signal' in new Request('')) {
-        AbortController = window.AbortController;
-    }
-    else {
-        var polyfill = require('abortcontroller-polyfill/dist/cjs-ponyfill');
-        AbortController = polyfill.AbortController;
-    }
+    /* eslint-disable @typescript-eslint/no-var-requires */
+    var polyfill = require('abortcontroller-polyfill/dist/cjs-ponyfill');
+    /* eslint-enable @typescript-eslint/no-var-requires */
+    AbortController = polyfill.AbortController;
 }
 module.exports = AbortController;
 //# sourceMappingURL=abort-controller.js.map

lib/airtable.d.ts

 import Base from './base';
-import Record from './record';
-import Table from './table';
+import AirtableRecord from './record';
+import AirtableTable from './table';
 import AirtableError from './airtable_error';
+import AirtableQuery from './query';
+import { AirtableBase } from './airtable_base';
+import { ObjectMap } from './object_map';
+import { FieldSet as AirtableFieldSet } from './field_set';
+import { Collaborator as AirtableCollaborator } from './collaborator';
+import { Thumbnail as AirtableThumbnail } from './thumbnail';
+import { Attachment as AirtableAttachment } from './attachment';
+import { Records as AirtableRecords } from './records';
+import { RecordData as AirtableRecordData } from './record_data';
+import { QueryParams as AirtableSelectOptions } from './query_params';
+declare type CustomHeaders = ObjectMap<string, string | number | boolean>;
 declare class Airtable {
     readonly _apiKey: string;
-    readonly _endpointUrl: string;
     readonly _apiVersion: string;
     readonly _apiVersionMajor: string;
+    readonly _customHeaders: CustomHeaders;
+    readonly _endpointUrl: string;
     readonly _noRetryIfRateLimited: boolean;
-    requestTimeout: number;
+    readonly _requestTimeout: number;
     static Base: typeof Base;
-    static Record: typeof Record;
-    static Table: typeof Table;
+    static Record: typeof AirtableRecord;
+    static Table: typeof AirtableTable;
     static Error: typeof AirtableError;
@@ -20,55 +32,31 @@ static apiKey: string;
     static noRetryIfRateLimited: boolean;
-    constructor(opts?: {
+    static requestTimeout: number;
+    constructor(opts?: Airtable.AirtableOptions);
+    base(baseId: string): Airtable.Base;
+    static default_config(): Airtable.AirtableOptions;
+    static configure({ apiKey, endpointUrl, apiVersion, noRetryIfRateLimited, requestTimeout, }: Pick<Airtable.AirtableOptions, 'apiKey' | 'endpointUrl' | 'apiVersion' | 'noRetryIfRateLimited' | 'requestTimeout'>): void;
+    static base(baseId: string): Airtable.Base;
+}
+declare namespace Airtable {
+    interface AirtableOptions {
         apiKey?: string;
         apiVersion?: string;
+        customHeaders?: CustomHeaders;
         endpointUrl?: string;
+        noRetryIfRateLimited?: boolean;
         requestTimeout?: number;
-        noRetryIfRateLimited?: boolean;
-    });
-    base(baseId: string): {
-        (tableName: string): Table;
-        _base: Base;
-        getId(): string;
-        makeRequest(options: {
-            method?: string;
-            path?: string;
-            qs?: globalThis.Record<string, any>;
-            headers?: globalThis.Record<string, any>;
-            body?: globalThis.Record<string, any>;
-            _numAttempts?: number;
-        }): Promise<Response & {
-            statusCode: number;
-        }>;
-        table(tableName: string): Table;
-    };
-    static default_config(): {
-        endpointUrl: string;
-        apiVersion: string;
-        apiKey: string;
-        noRetryIfRateLimited: boolean;
-        requestTimeout: number;
-    };
-    static configure({ apiKey, endpointUrl, apiVersion, noRetryIfRateLimited }: {
-        apiKey: any;
-        endpointUrl: any;
-        apiVersion: any;
-        noRetryIfRateLimited: any;
-    }): void;
-    static base(baseId: string): {
-        (tableName: string): Table;
-        _base: Base;
-        getId(): string;
-        makeRequest(options: {
-            method?: string;
-            path?: string;
-            qs?: globalThis.Record<string, any>;
-            headers?: globalThis.Record<string, any>;
-            body?: globalThis.Record<string, any>;
-            _numAttempts?: number;
-        }): Promise<Response & {
-            statusCode: number;
-        }>;
-        table(tableName: string): Table;
-    };
+    }
+    type FieldSet = AirtableFieldSet;
+    type Collaborator = AirtableCollaborator;
+    type Attachment = AirtableAttachment;
+    type Thumbnail = AirtableThumbnail;
+    type Base = AirtableBase;
+    type Error = AirtableError;
+    type Table<TFields extends AirtableFieldSet> = AirtableTable<TFields>;
+    type SelectOptions<TFields> = AirtableSelectOptions<TFields>;
+    type Query<TFields extends AirtableFieldSet> = AirtableQuery<TFields>;
+    type Record<TFields extends AirtableFieldSet> = AirtableRecord<TFields>;
+    type RecordData<TFields extends AirtableFieldSet> = AirtableRecordData<TFields>;
+    type Records<TFields extends AirtableFieldSet> = AirtableRecords<TFields>;
 }
 export = Airtable;

lib/airtable.js

@@ -18,5 +18,2 @@ "use strict";
             },
-            _endpointUrl: {
-                value: opts.endpointUrl || Airtable.endpointUrl || defaultConfig.endpointUrl,
-            },
             _apiVersion: {
@@ -28,2 +25,8 @@ value: apiVersion,
             },
+            _customHeaders: {
+                value: opts.customHeaders || {},
+            },
+            _endpointUrl: {
+                value: opts.endpointUrl || Airtable.endpointUrl || defaultConfig.endpointUrl,
+            },
             _noRetryIfRateLimited: {
@@ -34,4 +37,6 @@ value: opts.noRetryIfRateLimited ||
             },
+            _requestTimeout: {
+                value: opts.requestTimeout || Airtable.requestTimeout || defaultConfig.requestTimeout,
+            },
         });
-        this.requestTimeout = opts.requestTimeout || defaultConfig.requestTimeout;
         if (!this._apiKey) {
@@ -54,3 +59,3 @@ throw new Error('An API key is required to connect to Airtable');
     Airtable.configure = function (_a) {
-        var apiKey = _a.apiKey, endpointUrl = _a.endpointUrl, apiVersion = _a.apiVersion, noRetryIfRateLimited = _a.noRetryIfRateLimited;
+        var apiKey = _a.apiKey, endpointUrl = _a.endpointUrl, apiVersion = _a.apiVersion, noRetryIfRateLimited = _a.noRetryIfRateLimited, requestTimeout = _a.requestTimeout;
         Airtable.apiKey = apiKey;
@@ -60,2 +65,3 @@ Airtable.endpointUrl = endpointUrl;
         Airtable.noRetryIfRateLimited = noRetryIfRateLimited;
+        Airtable.requestTimeout = requestTimeout;
     };
@@ -62,0 +68,0 @@ Airtable.base = function (baseId) {

lib/base.d.ts

 import AirtableError from './airtable_error';
 import Table from './table';
-import type Airtable from './airtable';
-declare type BaseRequestOptions = {
+import runAction from './run_action';
+import Airtable from './airtable';
+import { AirtableBase } from './airtable_base';
+import { FieldSet } from './field_set';
+declare type BaseBody = any;
+interface BaseRequestOptions {
     method?: string;
     path?: string;
-    qs?: Record<string, any>;
-    headers?: Record<string, any>;
-    body?: Record<string, any>;
+    qs?: Record<string, BaseBody>;
+    headers?: Record<string, string>;
+    body?: BaseBody;
     _numAttempts?: number;
-};
-declare type BaseResponse = Response & {
+}
+interface BaseResponse {
     statusCode: Response['status'];
-};
-declare type AirtableBase = {
-    (tableName: string): Table;
-    _base: Base;
-    getId(): string;
-    makeRequest(options: BaseRequestOptions): Promise<BaseResponse>;
-    table(tableName: string): Table;
-};
+    headers: Response['headers'];
+    body: BaseBody;
+}
 declare class Base {
@@ -26,11 +25,15 @@ readonly _airtable: Airtable;
     constructor(airtable: Airtable, baseId: string);
-    table(tableName: string): Table;
-    makeRequest(options?: BaseRequestOptions): Promise<unknown>;
+    table<TFields extends FieldSet>(tableName: string): Table<TFields>;
+    makeRequest(options?: BaseRequestOptions): Promise<BaseResponse>;
     /**
      * @deprecated This method is deprecated.
      */
-    runAction(method: any, path: any, queryParams: any, bodyData: any, callback: any): void;
-    _getRequestHeaders(headers: any): {};
-    _checkStatusForError(statusCode: any, body: any): AirtableError;
-    doCall(tableName: any): Table;
+    runAction(method: string, path: string, queryParams: runAction.Params, bodyData: runAction.Body, callback: runAction.Callback): void;
+    _getRequestHeaders(headers: {
+        [key: string]: string;
+    }): {
+        [key: string]: string;
+    };
+    _checkStatusForError(statusCode: number, body?: BaseBody): null | AirtableError;
+    doCall<TFields extends FieldSet>(tableName: string): Table<TFields>;
     getId(): string;
@@ -37,0 +40,0 @@ static createFunctor(airtable: Airtable, baseId: string): AirtableBase;

lib/base.js

 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var forEach_1 = __importDefault(require("lodash/forEach"));
 var get_1 = __importDefault(require("lodash/get"));
-var assign_1 = __importDefault(require("lodash/assign"));
 var isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
+var keys_1 = __importDefault(require("lodash/keys"));
 var fetch_1 = __importDefault(require("./fetch"));
@@ -29,2 +39,3 @@ var abort_controller_1 = __importDefault(require("./abort-controller"));
         var _this = this;
+        var _a;
         if (options === void 0) { options = {}; }
@@ -34,5 +45,6 @@ var method = get_1.default(options, 'method', 'GET').toUpperCase();
         var controller = new abort_controller_1.default();
+        var headers = this._getRequestHeaders(Object.assign({}, this._airtable._customHeaders, (_a = options.headers) !== null && _a !== void 0 ? _a : {}));
         var requestOptions = {
             method: method,
-            headers: this._getRequestHeaders(get_1.default(options, 'headers', {})),
+            headers: headers,
             signal: controller.signal,
@@ -45,3 +57,3 @@ };
             controller.abort();
-        }, this._airtable.requestTimeout);
+        }, this._airtable._requestTimeout);
         return new Promise(function (resolve, reject) {
@@ -51,3 +63,2 @@ fetch_1.default(url, requestOptions)
                 clearTimeout(timeout);
-                resp.statusCode = resp.status;
                 if (resp.status === 429 && !_this._airtable._noRetryIfRateLimited) {
@@ -57,5 +68,3 @@ var numAttempts_1 = get_1.default(options, '_numAttempts', 0);
                     setTimeout(function () {
-                        var newOptions = assign_1.default({}, options, {
-                            _numAttempts: numAttempts_1 + 1,
-                        });
+                        var newOptions = __assign(__assign({}, options), { _numAttempts: numAttempts_1 + 1 });
                         _this.makeRequest(newOptions)
@@ -106,5 +115,6 @@ .then(resolve)
         result.set('Content-Type', 'application/json');
-        forEach_1.default(headers, function (headerValue, headerKey) {
-            result.set(headerKey, headerValue);
-        });
+        for (var _i = 0, _a = keys_1.default(headers); _i < _a.length; _i++) {
+            var headerKey = _a[_i];
+            result.set(headerKey, headers[headerKey]);
+        }
         return result.toJSON();
@@ -157,6 +167,7 @@ };
         };
-        forEach_1.default(['table', 'makeRequest', 'runAction', 'getId'], function (baseMethod) {
-            baseFn[baseMethod] = base[baseMethod].bind(base);
-        });
         baseFn._base = base;
+        baseFn.table = base.table.bind(base);
+        baseFn.makeRequest = base.makeRequest.bind(base);
+        baseFn.runAction = base.runAction.bind(base);
+        baseFn.getId = base.getId.bind(base);
         return baseFn;
@@ -163,0 +174,0 @@ };

lib/callback_to_promise.d.ts

@@ -7,3 +7,3 @@ /**
  */
-declare function callbackToPromise(fn: any, context: any, callbackArgIndex?: any): any;
+declare function callbackToPromise(fn: any, context: any, callbackArgIndex?: number): any;
 export = callbackToPromise;

lib/callback_to_promise.js

@@ -8,9 +8,15 @@ "use strict";
  */
+/* eslint-disable @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types */
 function callbackToPromise(fn, context, callbackArgIndex) {
     if (callbackArgIndex === void 0) { callbackArgIndex = void 0; }
+    /* eslint-enable @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types */
     return function () {
+        var callArgs = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            callArgs[_i] = arguments[_i];
+        }
         var thisCallbackArgIndex;
         if (callbackArgIndex === void 0) {
             // istanbul ignore next
-            thisCallbackArgIndex = arguments.length > 0 ? arguments.length - 1 : 0;
+            thisCallbackArgIndex = callArgs.length > 0 ? callArgs.length - 1 : 0;
         }
@@ -20,5 +26,5 @@ else {
         }
-        var callbackArg = arguments[thisCallbackArgIndex];
+        var callbackArg = callArgs[thisCallbackArgIndex];
         if (typeof callbackArg === 'function') {
-            fn.apply(context, arguments);
+            fn.apply(context, callArgs);
             return void 0;
@@ -31,5 +37,5 @@ }
             // our constructed callback ends up at the right index.
-            var argLen = Math.max(arguments.length, thisCallbackArgIndex);
+            var argLen = Math.max(callArgs.length, thisCallbackArgIndex);
             for (var i = 0; i < argLen; i++) {
-                args_1.push(arguments[i]);
+                args_1.push(callArgs[i]);
             }
@@ -36,0 +42,0 @@ return new Promise(function (resolve, reject) {

lib/deprecate.d.ts

@@ -12,3 +12,3 @@ /**
  */
-declare function deprecate(fn: any, key: any, message: any): (...args: any[]) => void;
+declare function deprecate<Args extends unknown[]>(fn: (...args: Args) => void, key: string, message: string): (...args: Args) => void;
 export = deprecate;

lib/fetch.js

@@ -5,6 +5,5 @@ "use strict";
 };
+// istanbul ignore file
 var node_fetch_1 = __importDefault(require("node-fetch"));
-module.exports = (
-// istanbul ignore next
-typeof window === 'undefined' ? node_fetch_1.default : window.fetch.bind(window));
+module.exports = typeof window === 'undefined' ? node_fetch_1.default : window.fetch.bind(window);
 //# sourceMappingURL=fetch.js.map

lib/has.d.ts

@@ -0,4 +1,5 @@
+declare type HasValue = any;
 declare function has<O, P extends string>(object: O, property: P): object is O & {
-    [key in P]: any;
+    [key in P]: HasValue;
 };
 export = has;

lib/has.js

 "use strict";
+/* eslint-enable @typescript-eslint/no-explicit-any */
 function has(object, property) {
@@ -3,0 +4,0 @@ return Object.prototype.hasOwnProperty.call(object, property);

lib/http_headers.d.ts

 declare class HttpHeaders {
     _headersByLowercasedKey: any;
     constructor();
-    set(headerKey: any, headerValue: any): void;
-    toJSON(): {};
+    set(headerKey: string, headerValue: string): void;
+    toJSON(): {
+        [key: string]: string;
+    };
 }
 export = HttpHeaders;

lib/http_headers.js

@@ -5,3 +5,3 @@ "use strict";
 };
-var forEach_1 = __importDefault(require("lodash/forEach"));
+var keys_1 = __importDefault(require("lodash/keys"));
 var isBrowser = typeof window !== 'undefined';
@@ -25,4 +25,6 @@ var HttpHeaders = /** @class */ (function () {
         var result = {};
-        forEach_1.default(this._headersByLowercasedKey, function (headerDefinition, lowercasedKey) {
-            var headerKey;
+        for (var _i = 0, _a = keys_1.default(this._headersByLowercasedKey); _i < _a.length; _i++) {
+            var lowercasedKey = _a[_i];
+            var headerDefinition = this._headersByLowercasedKey[lowercasedKey];
+            var headerKey = void 0;
             /* istanbul ignore next */
@@ -38,3 +40,3 @@ if (isBrowser && lowercasedKey === 'user-agent') {
             result[headerKey] = headerDefinition.headerValue;
-        });
+        }
         return result;
@@ -41,0 +43,0 @@ };

lib/object_to_query_param_string.d.ts

@@ -1,2 +0,3 @@
-declare function objectToQueryParamString(obj: any): string;
+declare type ToParamBody = any;
+declare function objectToQueryParamString(obj: ToParamBody): string;
 export = objectToQueryParamString;

lib/object_to_query_param_string.js

@@ -6,4 +6,5 @@ "use strict";
 var isArray_1 = __importDefault(require("lodash/isArray"));
-var forEach_1 = __importDefault(require("lodash/forEach"));
 var isNil_1 = __importDefault(require("lodash/isNil"));
+var keys_1 = __importDefault(require("lodash/keys"));
+/* eslint-enable @typescript-eslint/no-explicit-any */
 // Adapted from jQuery.param:
@@ -14,3 +15,4 @@ // https://github.com/jquery/jquery/blob/2.2-stable/src/serialize.js
         // Serialize array item.
-        forEach_1.default(obj, function (value, index) {
+        for (var index = 0; index < obj.length; index++) {
+            var value = obj[index];
             if (/\[\]$/.test(prefix)) {
@@ -24,9 +26,11 @@ // Treat each array item as a scalar.
             }
-        });
+        }
     }
     else if (typeof obj === 'object') {
         // Serialize object item.
-        forEach_1.default(obj, function (value, key) {
+        for (var _i = 0, _a = keys_1.default(obj); _i < _a.length; _i++) {
+            var key = _a[_i];
+            var value = obj[key];
             buildParams(prefix + "[" + key + "]", value, addFn);
-        });
+        }
     }
@@ -44,5 +48,7 @@ else {
     };
-    forEach_1.default(obj, function (value, key) {
+    for (var _i = 0, _a = keys_1.default(obj); _i < _a.length; _i++) {
+        var key = _a[_i];
+        var value = obj[key];
         buildParams(key, value, addFn);
-    });
+    }
     return parts.join('&').replace(/%20/g, '+');
@@ -49,0 +55,0 @@ }

lib/package_version.js

 "use strict";
 module.exports = require('../package.json').version;
+/* eslint-enable @typescript-eslint/no-var-requires */
 //# sourceMappingURL=package_version.js.map

lib/query_params.d.ts

@@ -66,4 +66,17 @@ export declare const paramValidators: {
 };
-export declare type QueryParams = {
-    [key in keyof typeof paramValidators]?: Parameters<typeof paramValidators[key]>[0];
-};
+export interface SortParameter<TFields> {
+    field: keyof TFields;
+    direction?: 'asc' | 'desc';
+}
+export interface QueryParams<TFields> {
+    fields?: (keyof TFields)[];
+    filterByFormula?: string;
+    maxRecords?: number;
+    pageSize?: number;
+    offset?: number;
+    sort?: SortParameter<TFields>[];
+    view?: string;
+    cellFormat?: 'json' | 'string';
+    timeZone?: string;
+    userLocale?: string;
+}

lib/query_params.js

@@ -11,3 +11,2 @@ "use strict";
 var isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
-var includes_1 = __importDefault(require("lodash/includes"));
 exports.paramValidators = {
@@ -22,3 +21,3 @@ fields: typecheck_1.default(typecheck_1.default.isArrayOf(isString_1.default), 'the value for `fields` should be an array of strings'),
             isString_1.default(obj.field) &&
-            (obj.direction === void 0 || includes_1.default(['asc', 'desc'], obj.direction)));
+            (obj.direction === void 0 || ['asc', 'desc'].includes(obj.direction)));
     }), 'the value for `sort` should be an array of sort objects. ' +
@@ -29,3 +28,3 @@ 'Each sort object must have a string `field` value, and an optional ' +
     cellFormat: typecheck_1.default(function (cellFormat) {
-        return isString_1.default(cellFormat) && includes_1.default(['json', 'string'], cellFormat);
+        return isString_1.default(cellFormat) && ['json', 'string'].includes(cellFormat);
     }, 'the value for `cellFormat` should be "json" or "string"'),
@@ -32,0 +31,0 @@ timeZone: typecheck_1.default(isString_1.default, 'the value for `timeZone` should be a string'),

lib/query.d.ts

@@ -1,14 +0,16 @@
-import Record from './record';
 import Table from './table';
 import { QueryParams } from './query_params';
-declare type PageCallback = (records: Record[], processNextPage: () => void) => void;
-declare type RecordCollectionCallback = (error: any, records?: Record[]) => void;
-declare type DoneCallback = (error: any) => void;
-interface RecordCollectionRequestMethod {
-    (): Promise<Record[]>;
-    (done: RecordCollectionCallback): void;
+import { FieldSet } from './field_set';
+import { Records } from './records';
+declare type CallbackError = any;
+declare type PageCallback<TFields extends FieldSet> = (records: Records<TFields>, processNextPage: () => void) => void;
+declare type RecordCollectionCallback<TFields extends FieldSet> = (error: CallbackError, records?: Records<TFields>) => void;
+declare type DoneCallback = (error: CallbackError) => void;
+interface RecordCollectionRequestMethod<TFields extends FieldSet> {
+    (): Promise<Records<TFields>>;
+    (done: RecordCollectionCallback<TFields>): void;
 }
-interface RecordPageIteratationMethod {
-    (pageCallback: PageCallback): Promise<void>;
-    (pageCallback: PageCallback, done: DoneCallback): void;
+interface RecordPageIteratationMethod<TFields extends FieldSet> {
+    (pageCallback: PageCallback<TFields>): Promise<void>;
+    (pageCallback: PageCallback<TFields>, done: DoneCallback): void;
 }
@@ -22,8 +24,8 @@ /**
  */
-declare class Query {
-    readonly _table: Table;
-    readonly _params: QueryParams;
-    readonly firstPage: RecordCollectionRequestMethod;
-    readonly eachPage: RecordPageIteratationMethod;
-    readonly all: RecordCollectionRequestMethod;
+declare class Query<TFields extends FieldSet> {
+    readonly _table: Table<TFields>;
+    readonly _params: QueryParams<TFields>;
+    readonly firstPage: RecordCollectionRequestMethod<TFields>;
+    readonly eachPage: RecordPageIteratationMethod<TFields>;
+    readonly all: RecordCollectionRequestMethod<TFields>;
     static paramValidators: {
@@ -94,3 +96,3 @@ fields: (value: string[]) => {
     };
-    constructor(table: Table, params: QueryParams);
+    constructor(table: Table<TFields>, params: QueryParams<TFields>);
     /**
@@ -106,8 +108,8 @@ * Validates the parameters for passing to the Query constructor.
      */
-    static validateParams(params: any): {
-        validParams: QueryParams;
-        ignoredKeys: any[];
-        errors: any[];
+    static validateParams<TFields extends FieldSet, Params extends QueryParams<TFields> = QueryParams<TFields>>(params: Params): {
+        validParams: QueryParams<TFields>;
+        ignoredKeys: string[];
+        errors: string[];
     };
 }
 export = Query;

lib/query.js

 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
@@ -6,5 +17,2 @@ return (mod && mod.__esModule) ? mod : { "default": mod };
 var isFunction_1 = __importDefault(require("lodash/isFunction"));
-var clone_1 = __importDefault(require("lodash/clone"));
-var forEach_1 = __importDefault(require("lodash/forEach"));
-var map_1 = __importDefault(require("lodash/map"));
 var keys_1 = __importDefault(require("lodash/keys"));
@@ -44,3 +52,4 @@ var record_1 = __importDefault(require("./record"));
         var errors = [];
-        forEach_1.default(keys_1.default(params), function (key) {
+        for (var _i = 0, _a = keys_1.default(params); _i < _a.length; _i++) {
+            var key = _a[_i];
             var value = params[key];
@@ -60,3 +69,3 @@ if (has_1.default(Query.paramValidators, key)) {
             }
-        });
+        }
         return {
@@ -104,3 +113,3 @@ validParams: validParams,
     var path = "/" + this._table._urlEncodedNameOrId();
-    var params = clone_1.default(this._params);
+    var params = __assign({}, this._params);
     var inner = function () {
@@ -122,3 +131,3 @@ _this._table._base.runAction('get', path, params, null, function (err, response, result) {
                 }
-                var records = map_1.default(result.records, function (recordJson) {
+                var records = result.records.map(function (recordJson) {
                     return new record_1.default(_this._table, null, recordJson);
@@ -125,0 +134,0 @@ });

lib/record.d.ts

@@ -0,33 +1,39 @@
+import { FieldSet } from './field_set';
 import Table from './table';
-interface RecordCallback {
-    (error: null, record: Record): void;
-    (error: any): void;
+declare type RecordError = any;
+declare type RecordJson = any;
+declare type OptionalParameters = {
+    typecast: boolean;
+};
+interface RecordCallback<TFields extends FieldSet> {
+    (error: null, record: Record<TFields>): void;
+    (error: RecordError): void;
 }
-interface RecordActionMethod {
-    (): Promise<Record>;
-    (done: RecordCallback): void;
+interface RecordActionMethod<TFields extends FieldSet> {
+    (): Promise<Record<TFields>>;
+    (done: RecordCallback<TFields>): void;
 }
-interface RecordChangeMethod {
-    (cellValuesByName: any, done: RecordCallback): void;
-    (cellValuesByName: any, opts: any, done: RecordCallback): void;
-    (cellValuesByName: any, opts?: any): Promise<Record>;
+interface RecordChangeMethod<TFields extends FieldSet> {
+    (cellValuesByName: TFields, done: RecordCallback<TFields>): void;
+    (cellValuesByName: TFields, opts: OptionalParameters, done: RecordCallback<TFields>): void;
+    (cellValuesByName: TFields, opts?: OptionalParameters): Promise<Record<TFields>>;
 }
-declare class Record {
-    readonly _table: Table;
-    _rawJson: any;
+declare class Record<TFields extends FieldSet> {
+    readonly _table: Table<TFields>;
+    _rawJson: RecordJson;
     readonly id: string;
-    fields: any;
-    readonly save: RecordActionMethod;
-    readonly patchUpdate: RecordChangeMethod;
-    readonly putUpdate: RecordChangeMethod;
-    readonly destroy: RecordActionMethod;
-    readonly fetch: RecordActionMethod;
-    readonly updateFields: RecordChangeMethod;
-    readonly replaceFields: RecordChangeMethod;
-    constructor(table: Table, recordId: string, recordJson?: any);
+    fields: TFields;
+    readonly save: RecordActionMethod<TFields>;
+    readonly patchUpdate: RecordChangeMethod<TFields>;
+    readonly putUpdate: RecordChangeMethod<TFields>;
+    readonly destroy: RecordActionMethod<TFields>;
+    readonly fetch: RecordActionMethod<TFields>;
+    readonly updateFields: RecordChangeMethod<TFields>;
+    readonly replaceFields: RecordChangeMethod<TFields>;
+    constructor(table: Table<TFields>, recordId: string, recordJson?: RecordJson);
     getId(): string;
-    get(columnName: string): any;
-    set(columnName: string, columnValue: any): void;
-    setRawJson(rawJson: any): void;
+    get<Field extends keyof TFields>(columnName: Field): TFields[Field];
+    set<Field extends keyof TFields>(columnName: Field, columnValue: TFields[Field]): void;
+    setRawJson(rawJson: RecordJson): void;
 }
 export = Record;

lib/record.js

 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var assign_1 = __importDefault(require("lodash/assign"));
 var callback_to_promise_1 = __importDefault(require("./callback_to_promise"));
@@ -44,5 +54,3 @@ var Record = /** @class */ (function () {
     }
-    var updateBody = assign_1.default({
-        fields: cellValuesByName,
-    }, opts);
+    var updateBody = __assign({ fields: cellValuesByName }, opts);
     this._table._base.runAction('patch', "/" + this._table._urlEncodedNameOrId() + "/" + this.id, {}, updateBody, function (err, response, results) {
@@ -63,5 +71,3 @@ if (err) {
     }
-    var updateBody = assign_1.default({
-        fields: cellValuesByName,
-    }, opts);
+    var updateBody = __assign({ fields: cellValuesByName }, opts);
     this._table._base.runAction('put', "/" + this._table._urlEncodedNameOrId() + "/" + this.id, {}, updateBody, function (err, response, results) {
@@ -68,0 +74,0 @@ if (err) {

lib/run_action.d.ts

@@ -1,2 +0,19 @@
-declare function runAction(base: any, method: any, path: any, queryParams: any, bodyData: any, callback: any, numAttempts: any): void;
+import Base from './base';
+declare type ActionBody = any;
+declare type ActionError = any;
+declare type ActionParams = {
+    [key: string]: ActionBody;
+};
+declare type ActionResponse = {
+    -readonly [key in keyof Response]: Response[key];
+} & {
+    statusCode: number;
+};
+declare type ActionCallback = (error: ActionError, response?: ActionResponse, body?: ActionBody) => void;
+declare function runAction(base: Base, method: string, path: string, queryParams: ActionParams, bodyData: ActionBody, callback: ActionCallback, numAttempts: number): void;
+declare namespace runAction {
+    type Body = ActionBody;
+    type Params = ActionParams;
+    type Callback = ActionCallback;
+}
 export = runAction;

lib/run_action.js

@@ -45,3 +45,3 @@ "use strict";
         controller.abort();
-    }, base._airtable.requestTimeout);
+    }, base._airtable._requestTimeout);
     fetch_1.default(url, options)
@@ -48,0 +48,0 @@ .then(function (resp) {

lib/table.d.ts

@@ -5,42 +5,55 @@ import Query from './query';
 import Base from './base';
+import { Records } from './records';
+import { FieldSet } from './field_set';
+import { RecordData } from './record_data';
+declare type TableError = any;
+declare type CreateRecord<TFields> = Pick<RecordData<Partial<TFields>>, 'fields'>;
+declare type CreateRecords<TFields> = string[] | Partial<TFields>[] | CreateRecord<TFields>[];
 declare type OptionalParameters = {
-    [key: string]: any;
+    typecast?: boolean;
 };
-declare type RecordCallback = (error: any, record?: Record) => void;
-declare type RecordCollectionCallback = (error: any, records?: Record[]) => void;
-interface TableFindRecord {
-    (recordId: string): Promise<Record>;
-    (recordId: string, done: RecordCallback): void;
+declare type RecordCollectionCallback<TFields extends FieldSet> = (error: TableError, records?: Records<TFields>) => void;
+declare type RecordCallback<TFields extends FieldSet> = (error: TableError, record?: Record<TFields>) => void;
+declare type RecordListCallback<TFields extends FieldSet> = (error: TableError, records?: Records<TFields>, offset?: number) => void;
+declare type RecordForEachCallback<TFields extends FieldSet> = (record: Record<TFields>) => void;
+declare type RecordForEachDoneCallback = (error?: TableError) => void;
+interface TableFindRecord<TFields extends FieldSet> {
+    (recordId: string): Promise<Record<TFields>>;
+    (recordId: string, done: RecordCallback<TFields>): void;
 }
-interface TableCreateRecords {
-    (recordsData: any[], optionalParameters?: OptionalParameters): Promise<Record[]>;
-    (recordsData: any[], optionalParameters: OptionalParameters, done: RecordCollectionCallback): void;
-    (recordsData: any[], done: RecordCollectionCallback): void;
-    (recordData: any, optionalParameters?: OptionalParameters): Promise<Record>;
-    (recordData: any, optionalParameters: OptionalParameters, done: RecordCallback): void;
-    (recordData: any, done: RecordCallback): void;
+interface TableSelectRecord<TFields extends FieldSet> {
+    (params?: QueryParams<TFields>): Query<TFields>;
 }
-interface TableChangeRecords {
-    (recordId: string, recordData: any, opts?: OptionalParameters): Promise<Record>;
-    (recordId: string, recordData: any, opts: OptionalParameters, done: RecordCallback): void;
-    (recordId: string, recordData: any, done: RecordCallback): void;
-    (recordsData: any[], opts?: OptionalParameters): Promise<Record[]>;
-    (recordsData: any[], opts: OptionalParameters, done: RecordCollectionCallback): void;
-    (recordsData: any[], done: RecordCollectionCallback): void;
+interface TableCreateRecords<TFields extends FieldSet> {
+    (recordsData: CreateRecords<TFields>, optionalParameters?: OptionalParameters): Promise<Records<TFields>>;
+    (recordsData: CreateRecords<TFields>, optionalParameters: OptionalParameters, done: RecordCollectionCallback<TFields>): void;
+    (recordsData: CreateRecords<TFields>, done: RecordCollectionCallback<TFields>): void;
+    (recordData: string | Partial<TFields>, optionalParameters?: OptionalParameters): Promise<Record<TFields>>;
+    (recordData: string | Partial<TFields>, optionalParameters: OptionalParameters, done: RecordCallback<TFields>): void;
+    (recordData: string | Partial<TFields>, done: RecordCallback<TFields>): void;
 }
-interface TableDestroyRecords {
-    (recordId: string): Promise<Record>;
-    (recordIds: string[]): Promise<Record[]>;
-    (recordIds: string[], done: RecordCollectionCallback): void;
+interface TableChangeRecords<TFields extends FieldSet> {
+    (recordId: string, recordData: Partial<TFields>, opts?: OptionalParameters): Promise<Record<TFields>>;
+    (recordId: string, recordData: Partial<TFields>, opts: OptionalParameters, done: RecordCallback<TFields>): void;
+    (recordId: string, recordData: Partial<TFields>, done: RecordCallback<TFields>): void;
+    (recordsData: RecordData<Partial<TFields>>[], opts?: OptionalParameters): Promise<Records<TFields>>;
+    (recordsData: RecordData<Partial<TFields>>[], opts: OptionalParameters, done: RecordCollectionCallback<TFields>): void;
+    (recordsData: RecordData<Partial<TFields>>[], done: RecordCollectionCallback<TFields>): void;
 }
-declare class Table {
+interface TableDestroyRecords<TFields extends FieldSet> {
+    (recordId: string): Promise<Record<TFields>>;
+    (recordId: string, done: RecordCallback<TFields>): void;
+    (recordIds: string[]): Promise<Records<TFields>>;
+    (recordIds: string[], done: RecordCollectionCallback<TFields>): void;
+}
+declare class Table<TFields extends FieldSet> {
     readonly _base: Base;
     readonly id: string;
     readonly name: string;
-    readonly find: TableFindRecord;
-    readonly select: (params?: QueryParams) => Query;
-    readonly create: TableCreateRecords;
-    readonly update: TableChangeRecords;
-    readonly replace: TableChangeRecords;
-    readonly destroy: TableDestroyRecords;
+    readonly find: TableFindRecord<TFields>;
+    readonly select: TableSelectRecord<TFields>;
+    readonly create: TableCreateRecords<TFields>;
+    readonly update: TableChangeRecords<TFields>;
+    readonly replace: TableChangeRecords<TFields>;
+    readonly destroy: TableDestroyRecords<TFields>;
     /** @deprecated */
@@ -52,18 +65,18 @@ readonly list: any;
     constructor(base: Base, tableId: string, tableName: string);
-    _findRecordById(recordId: string, done: RecordCallback): void;
-    _selectRecords(params?: QueryParams): Query;
+    _findRecordById(recordId: string, done: RecordCallback<TFields>): void;
+    _selectRecords(params?: QueryParams<TFields>): Query<TFields>;
     _urlEncodedNameOrId(): string;
-    _createRecords(recordData: any, done: RecordCallback): void;
-    _createRecords(recordData: any, optionalParameters: OptionalParameters, done: RecordCallback): void;
-    _createRecords(recordsData: any[], done: RecordCollectionCallback): void;
-    _createRecords(recordsData: any[], optionalParameters: OptionalParameters, done: RecordCollectionCallback): void;
-    _updateRecords(isDestructiveUpdate: boolean, recordId: string, recordData: any, done: RecordCallback): void;
-    _updateRecords(isDestructiveUpdate: boolean, recordId: string, recordData: any, opts: OptionalParameters, done: RecordCallback): void;
-    _updateRecords(isDestructiveUpdate: boolean, recordsData: any[], done: RecordCollectionCallback): void;
-    _updateRecords(isDestructiveUpdate: boolean, recordsData: any[], opts: OptionalParameters, done: RecordCollectionCallback): void;
-    _destroyRecord(recordId: string, done: RecordCallback): void;
-    _destroyRecord(recordIds: string[], done: RecordCollectionCallback): void;
-    _listRecords(limit: any, offset: any, opts: any, done: any): void;
-    _forEachRecord(opts: any, callback: any, done: any): void;
+    _createRecords(recordData: TFields, done: RecordCallback<TFields>): void;
+    _createRecords(recordData: TFields, optionalParameters: OptionalParameters, done: RecordCallback<TFields>): void;
+    _createRecords(recordsData: TFields[], done: RecordCollectionCallback<TFields>): void;
+    _createRecords(recordsData: TFields[], optionalParameters: OptionalParameters, done: RecordCollectionCallback<TFields>): void;
+    _updateRecords(isDestructiveUpdate: boolean, recordId: string, recordData: TFields, done: RecordCallback<TFields>): void;
+    _updateRecords(isDestructiveUpdate: boolean, recordId: string, recordData: TFields, opts: OptionalParameters, done: RecordCallback<TFields>): void;
+    _updateRecords(isDestructiveUpdate: boolean, recordsData: TFields[], done: RecordCollectionCallback<TFields>): void;
+    _updateRecords(isDestructiveUpdate: boolean, recordsData: TFields[], opts: OptionalParameters, done: RecordCollectionCallback<TFields>): void;
+    _destroyRecord(recordId: string, done: RecordCallback<TFields>): void;
+    _destroyRecord(recordIds: string[], done: RecordCollectionCallback<TFields>): void;
+    _listRecords(limit: number, offset: number, opts: OptionalParameters | RecordListCallback<TFields>, done?: RecordListCallback<TFields>): void;
+    _forEachRecord(opts: OptionalParameters, callback: RecordForEachCallback<TFields>, done: RecordForEachDoneCallback): void;
 }
 export = Table;

lib/table.js

 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
-var isArray_1 = __importDefault(require("lodash/isArray"));
 var isPlainObject_1 = __importDefault(require("lodash/isPlainObject"));
-var assign_1 = __importDefault(require("lodash/assign"));
-var forEach_1 = __importDefault(require("lodash/forEach"));
-var map_1 = __importDefault(require("lodash/map"));
 var deprecate_1 = __importDefault(require("./deprecate"));
@@ -47,3 +54,3 @@ var query_1 = __importDefault(require("./query"));
             if (validationResults.errors.length) {
-                var formattedErrors = map_1.default(validationResults.errors, function (error) {
+                var formattedErrors = validationResults.errors.map(function (error) {
                     return "  * " + error;
@@ -67,3 +74,3 @@ });
         var _this = this;
-        var isCreatingMultipleRecords = isArray_1.default(recordsData);
+        var isCreatingMultipleRecords = Array.isArray(recordsData);
         if (!done) {
@@ -75,8 +82,7 @@ done = optionalParameters;
         if (isCreatingMultipleRecords) {
-            requestData = { records: recordsData };
+            requestData = __assign({ records: recordsData }, optionalParameters);
         }
         else {
-            requestData = { fields: recordsData };
+            requestData = __assign({ fields: recordsData }, optionalParameters);
         }
-        assign_1.default(requestData, optionalParameters);
         this._base.runAction('post', "/" + this._urlEncodedNameOrId() + "/", {}, requestData, function (err, resp, body) {
@@ -102,8 +108,8 @@ if (err) {
         var opts;
-        if (isArray_1.default(recordsDataOrRecordId)) {
+        if (Array.isArray(recordsDataOrRecordId)) {
             var recordsData = recordsDataOrRecordId;
             opts = isPlainObject_1.default(recordDataOrOptsOrDone) ? recordDataOrOptsOrDone : {};
-            done = optsOrDone || recordDataOrOptsOrDone;
+            done = (optsOrDone || recordDataOrOptsOrDone);
             var method = isDestructiveUpdate ? 'put' : 'patch';
-            var requestData = assign_1.default({ records: recordsData }, opts);
+            var requestData = __assign({ records: recordsData }, opts);
             this._base.runAction(method, "/" + this._urlEncodedNameOrId() + "/", {}, requestData, function (err, resp, body) {
@@ -124,3 +130,3 @@ if (err) {
             opts = isPlainObject_1.default(optsOrDone) ? optsOrDone : {};
-            done = done || optsOrDone;
+            done = (done || optsOrDone);
             var record = new record_1.default(this, recordId);
@@ -137,3 +143,3 @@ if (isDestructiveUpdate) {
         var _this = this;
-        if (isArray_1.default(recordIdsOrId)) {
+        if (Array.isArray(recordIdsOrId)) {
             var queryParams = { records: recordIdsOrId };
@@ -145,3 +151,3 @@ this._base.runAction('delete', "/" + this._urlEncodedNameOrId(), queryParams, null, function (err, response, results) {
                 }
-                var records = map_1.default(results.records, function (_a) {
+                var records = results.records.map(function (_a) {
                     var id = _a.id;
@@ -164,6 +170,4 @@ return new record_1.default(_this, id, null);
         }
-        var listRecordsParameters = assign_1.default({
-            limit: limit,
-            offset: offset,
-        }, opts);
+        var listRecordsParameters = __assign({ limit: limit,
+            offset: offset }, opts);
         this._base.runAction('get', "/" + this._urlEncodedNameOrId() + "/", listRecordsParameters, null, function (err, response, results) {
@@ -174,3 +178,3 @@ if (err) {
             }
-            var records = map_1.default(results.records, function (recordJson) {
+            var records = results.records.map(function (recordJson) {
                 return new record_1.default(_this, null, recordJson);
@@ -196,3 +200,5 @@ });
                 }
-                forEach_1.default(page, callback);
+                for (var index = 0; index < page.length; index++) {
+                    callback(page[index]);
+                }
                 if (newOffset) {
@@ -199,0 +205,0 @@ offset = newOffset;

lib/typecheck.d.ts

@@ -1,2 +0,3 @@
-declare function check<Value, Error>(fn: (value: any) => value is Value, error: Error): (value: Value) => {
+declare type CheckValue = any;
+declare function check<Value, Error>(fn: (value: CheckValue) => value is Value, error: Error): (value: Value) => {
     pass: true;
@@ -3,0 +4,0 @@ } | {

lib/typecheck.js

 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var includes_1 = __importDefault(require("lodash/includes"));
-var isArray_1 = __importDefault(require("lodash/isArray"));
+/* eslint-enable @typescript-eslint/no-explicit-any */
 function check(fn, error) {
@@ -18,7 +14,7 @@ return function (value) {
 check.isOneOf = function isOneOf(options) {
-    return includes_1.default.bind(this, options);
+    return options.includes.bind(options);
 };
 check.isArrayOf = function (itemValidator) {
     return function (value) {
-        return isArray_1.default(value) && value.every(itemValidator);
+        return Array.isArray(value) && value.every(itemValidator);
     };
@@ -25,0 +21,0 @@ };

package.json

 {
   "name": "airtable",
-  "version": "0.10.1",
+  "version": "0.11.0",
   "license": "MIT",
@@ -75,2 +75,2 @@ "homepage": "https://github.com/airtable/airtable.js",
   }
-}
+}

Fixed alerts

New author

Supply chain risk

A new npm collaborator published a version of the package for the first time. New collaborators are usually benign additions to a project, but do indicate a change to the security surface area of a package.

Found 1 instance in 1 package

Improved metrics

Number of package files

87

increased by38.1%

Number of medium supply chain risk alerts

7

decreased by-12.5%

Worsened metrics

Total package byte prevSize

226431

decreased by-26.45%

Lines of code

4920

decreased by-34.45%

No dependency changes