airtable-ts 1.5.0 → 1.6.0

package/dist/AirtableTs.d.ts

@@ -1,9 +1,9 @@
 import Airtable from 'airtable';
-import { Item, Table } from './mapping/typeUtils';
-import { AirtableTsTable, AirtableTsOptions, ScanParams } from './types';
+import { type Item, type Table } from './mapping/typeUtils';
+import { type AirtableTsTable, type AirtableTsOptions, type ScanParams } from './types';
 export declare class AirtableTs {
     airtable: Airtable;
-    private options;
+    private readonly options;
     constructor(options: AirtableTsOptions);
     get<T extends Item>(table: Table<T>, id: string): Promise<T>;
     scan<T extends Item>(table: Table<T>, params?: ScanParams): Promise<T[]>;

package/dist/AirtableTs.js

@@ -19,7 +19,7 @@ class AirtableTs {
         this.options = {
             ...airtable_1.default.default_config(),
             ...options,
-            baseSchemaCacheDurationMs: options.baseSchemaCacheDurationMs ?? 120000,
+            baseSchemaCacheDurationMs: options.baseSchemaCacheDurationMs ?? 120_000,
         };
     }
     async get(table, id) {
@@ -59,7 +59,7 @@ class AirtableTs {
         (0, assertMatchesSchema_1.assertMatchesSchema)(table, { ...data });
         const { id, ...withoutId } = data;
         const airtableTsTable = await (0, getAirtableTsTable_1.getAirtableTsTable)(this.airtable, table, this.options);
-        const record = await airtableTsTable.update(data.id, (0, recordMapper_1.mapRecordToAirtable)(table, withoutId, airtableTsTable));
+        const record = await airtableTsTable.update(id, (0, recordMapper_1.mapRecordToAirtable)(table, withoutId, airtableTsTable));
         return (0, recordMapper_1.mapRecordFromAirtable)(table, record);
     }
     async remove(table, id) {

package/dist/AirtableTsError.js

@@ -27,9 +27,7 @@ class AirtableTsError extends Error {
 exports.AirtableTsError = AirtableTsError;
 const prependError = (error, prefix) => {
     if (error instanceof AirtableTsError) {
-        // eslint-disable-next-line no-param-reassign
         error.message = `${prefix}: ${error.message}`;
-        // eslint-disable-next-line no-param-reassign
         error.stack = `Error: ${prefix}: ${error.stack?.startsWith('Error: ') ? error.stack.slice('Error: '.length) : error.stack}`;
     }
     return error;

package/dist/assertMatchesSchema.d.ts

@@ -1,4 +1,4 @@
-import { Item, Table } from './mapping/typeUtils';
+import { type Item, type Table } from './mapping/typeUtils';
 /**
  * In theory, this should never catch stuff because our type mapping logic should
  * verify the types are compatible.

package/dist/assertMatchesSchema.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertMatchesSchema = void 0;
+exports.assertMatchesSchema = assertMatchesSchema;
 const typeUtils_1 = require("./mapping/typeUtils");
 const AirtableTsError_1 = require("./AirtableTsError");
 /**
@@ -39,4 +39,3 @@ function assertMatchesSchema(table, data, mode = 'partial') {
         }
     });
 }
-exports.assertMatchesSchema = assertMatchesSchema;

package/dist/getAirtableTsTable.d.ts

@@ -1,4 +1,4 @@
-import Airtable from 'airtable';
-import { Item, Table } from './mapping/typeUtils';
-import { AirtableTsTable, CompleteAirtableTsOptions } from './types';
+import type Airtable from 'airtable';
+import { type Item, type Table } from './mapping/typeUtils';
+import { type AirtableTsTable, type CompleteAirtableTsOptions } from './types';
 export declare const getAirtableTsTable: <T extends Item>(airtable: Airtable, table: Table<T>, options: CompleteAirtableTsOptions) => Promise<AirtableTsTable<T>>;

package/dist/getAirtableTsTable.js

@@ -15,13 +15,23 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAirtableTsTable = void 0;
 const axios_1 = __importStar(require("axios"));
@@ -73,14 +83,13 @@ const getAirtableBaseSchema = async (baseId, options) => {
         url: `/v0/meta/bases/${baseId}/tables`,
         ...(options.requestTimeout ? { timeout: options.requestTimeout } : {}),
         headers: {
-            // eslint-disable-next-line no-underscore-dangle
             Authorization: `Bearer ${options.apiKey}`,
             ...options.customHeaders,
         },
     }).catch((err) => {
         const normalizedErrorMessage = err instanceof axios_1.AxiosError
             ? `${err.message}. Status: ${err.status}. Data: ${JSON.stringify(err.response?.data)}`
-            : err;
+            : String(err);
         throw new AirtableTsError_1.AirtableTsError({
             message: `Failed to get base schema: ${normalizedErrorMessage}`,
             type: AirtableTsError_1.ErrorType.API_ERROR,

package/dist/getFields.d.ts

@@ -1,2 +1,2 @@
-import { Item, Table } from './mapping/typeUtils';
+import { type Item, type Table } from './mapping/typeUtils';
 export declare const getFields: (table: Table<Item>) => string[];

package/dist/mapping/fieldMappers.d.ts

@@ -1,4 +1,4 @@
-import { AirtableTypeString, FromAirtableTypeString, FromTsTypeString, TsTypeString } from './typeUtils';
+import { type AirtableTypeString, type FromAirtableTypeString, type FromTsTypeString, type TsTypeString } from './typeUtils';
 type Mapper = {
     [T in TsTypeString]?: {
         [A in AirtableTypeString | 'unknown']?: {

package/dist/mapping/fieldMappers.js

@@ -30,6 +30,18 @@ const coerce = (airtableType, tsType) => (value) => {
     if (!parsedType.array && Array.isArray(value) && value.length === 1 && typeof value[0] === parsedType.single) {
         return value[0];
     }
+    // { specialValue: 'NaN' }
+    if (parsedType.nullable && typeof value === 'object' && value !== null && 'specialValue' in value && value.specialValue === 'NaN') {
+        return null;
+    }
+    // { error: '#ERROR!' }
+    if (parsedType.nullable && typeof value === 'object' && value !== null && 'error' in value && value.error === '#ERROR!') {
+        return null;
+    }
+    // [{ error: '#ERROR!' }]
+    if (parsedType.nullable && Array.isArray(value) && value.length === 1 && typeof value[0] === 'object' && value[0] !== null && 'error' in value[0] && value[0].error === '#ERROR!') {
+        return null;
+    }
     if (!parsedType.array && Array.isArray(value) && value.length !== 1) {
         throw new AirtableTsError_1.AirtableTsError({
             message: `Cannot convert array with ${value.length} entries from airtable type '${airtableType} to TypeScript type '${tsType}'.`,
@@ -45,9 +57,10 @@ const coerce = (airtableType, tsType) => (value) => {
 };
 const dateTimeMapperPair = {
     // Number assumed to be unix time in seconds
-    toAirtable: (value) => {
-        if (value === null)
+    toAirtable(value) {
+        if (value === null) {
             return null;
+        }
         const date = new Date(typeof value === 'number' ? value * 1000 : value);
         if (Number.isNaN(date.getTime())) {
             throw new AirtableTsError_1.AirtableTsError({
@@ -57,9 +70,10 @@ const dateTimeMapperPair = {
         }
         return date.toJSON();
     },
-    fromAirtable: (value) => {
-        if (value === null || value === undefined)
+    fromAirtable(value) {
+        if (value === null || value === undefined) {
             return null;
+        }
         const date = new Date(value);
         if (Number.isNaN(date.getTime())) {
             throw new AirtableTsError_1.AirtableTsError({
@@ -72,45 +86,49 @@ const dateTimeMapperPair = {
 };
 const aiTextMapperPair = {
     toAirtable: readonly('aiText'),
-    fromAirtable: (obj) => {
-        if (!obj || typeof obj !== 'object' || !('value' in obj) || typeof obj.value !== 'string')
+    fromAirtable(obj) {
+        if (!obj || typeof obj !== 'object' || !('value' in obj) || typeof obj.value !== 'string') {
             return null;
+        }
         return obj.value;
     },
 };
 const barcodeMapperPair = {
     toAirtable: (value) => ({ text: value }),
-    fromAirtable: (obj) => {
-        if (!obj || typeof obj !== 'object' || !('text' in obj) || typeof obj.text !== 'string')
+    fromAirtable(obj) {
+        if (!obj || typeof obj !== 'object' || !('text' in obj) || typeof obj.text !== 'string') {
             return null;
+        }
         return obj.text;
     },
 };
 const collaboratorMapperPair = {
     toAirtable: (value) => ({ id: value }),
-    fromAirtable: (obj) => {
-        if (!obj || typeof obj !== 'object' || !('id' in obj) || typeof obj.id !== 'string')
+    fromAirtable(obj) {
+        if (!obj || typeof obj !== 'object' || !('id' in obj) || typeof obj.id !== 'string') {
             return null;
+        }
         return obj.id;
     },
 };
 const multipleCollaboratorsMapperPair = {
     toAirtable: (value) => value,
-    fromAirtable: (obj) => {
+    fromAirtable(obj) {
         return obj?.map((v) => ('id' in v && typeof v.id === 'string' ? v.id : null)).filter(Boolean) ?? null;
     },
 };
 const multipleAttachmentsMapperPair = {
     toAirtable: readonly('multipleAttachments'),
-    fromAirtable: (obj) => {
+    fromAirtable(obj) {
         return obj?.map((v) => ('url' in v && typeof v.url === 'string' ? v.url : null)).filter(Boolean) ?? null;
     },
 };
 const buttonMapperPair = {
     toAirtable: readonly('button'),
-    fromAirtable: (obj) => {
-        if (!obj || typeof obj !== 'object' || !('label' in obj) || typeof obj.label !== 'string')
+    fromAirtable(obj) {
+        if (!obj || typeof obj !== 'object' || !('label' in obj) || typeof obj.label !== 'string') {
             return null;
+        }
         return obj.label;
     },
 };
@@ -210,10 +228,11 @@ const numberOrNull = {
         },
         date: {
             toAirtable: (value) => dateTimeMapperPair.toAirtable(value)?.slice(0, 10) ?? null,
-            fromAirtable: (value) => {
+            fromAirtable(value) {
                 const nullableValue = dateTimeMapperPair.fromAirtable(value);
-                if (nullableValue === null)
+                if (nullableValue === null) {
                     return null;
+                }
                 const date = new Date(nullableValue);
                 if (Number.isNaN(date.getTime())) {
                     throw new AirtableTsError_1.AirtableTsError({
@@ -226,10 +245,11 @@ const numberOrNull = {
         },
         dateTime: {
             toAirtable: dateTimeMapperPair.toAirtable,
-            fromAirtable: (value) => {
+            fromAirtable(value) {
                 const nullableValue = dateTimeMapperPair.fromAirtable(value);
-                if (nullableValue === null)
+                if (nullableValue === null) {
                     return null;
+                }
                 const date = new Date(nullableValue);
                 if (Number.isNaN(date.getTime())) {
                     throw new AirtableTsError_1.AirtableTsError({
@@ -242,10 +262,11 @@ const numberOrNull = {
         },
         createdTime: {
             toAirtable: dateTimeMapperPair.toAirtable,
-            fromAirtable: (value) => {
+            fromAirtable(value) {
                 const nullableValue = dateTimeMapperPair.fromAirtable(value);
-                if (nullableValue === null)
+                if (nullableValue === null) {
                     return null;
+                }
                 const date = new Date(nullableValue);
                 if (Number.isNaN(date.getTime())) {
                     throw new AirtableTsError_1.AirtableTsError({
@@ -258,10 +279,11 @@ const numberOrNull = {
         },
         lastModifiedTime: {
             toAirtable: dateTimeMapperPair.toAirtable,
-            fromAirtable: (value) => {
+            fromAirtable(value) {
                 const nullableValue = dateTimeMapperPair.fromAirtable(value);
-                if (nullableValue === null)
+                if (nullableValue === null) {
                     return null;
+                }
                 const date = new Date(nullableValue);
                 if (Number.isNaN(date.getTime())) {
                     throw new AirtableTsError_1.AirtableTsError({
@@ -297,7 +319,7 @@ const stringArrayOrNull = {
         multipleCollaborators: multipleCollaboratorsMapperPair,
         multipleAttachments: multipleAttachmentsMapperPair,
         multipleLookupValues: {
-            toAirtable: () => {
+            toAirtable() {
                 throw new AirtableTsError_1.AirtableTsError({
                     message: 'Lookup fields are read-only and cannot be modified.',
                     type: AirtableTsError_1.ErrorType.SCHEMA_VALIDATION,
@@ -306,7 +328,7 @@ const stringArrayOrNull = {
             fromAirtable: coerce('multipleLookupValues', 'string[] | null'),
         },
         formula: {
-            toAirtable: () => {
+            toAirtable() {
                 throw new AirtableTsError_1.AirtableTsError({
                     message: 'Formula fields are read-only and cannot be modified.',
                     type: AirtableTsError_1.ErrorType.SCHEMA_VALIDATION,
@@ -326,7 +348,7 @@ exports.fieldMappers = {
         ...Object.fromEntries(Object.entries(stringOrNull['string | null']).map(([airtableType, nullablePair]) => {
             return [airtableType, {
                     toAirtable: nullablePair.toAirtable,
-                    fromAirtable: (value) => {
+                    fromAirtable(value) {
                         const nullableValue = nullablePair.fromAirtable(value);
                         if (nullableValue === null && ['multipleRecordLinks', 'dateTime', 'createdTime', 'lastModifiedTime'].includes(airtableType)) {
                             throw new AirtableTsError_1.AirtableTsError({
@@ -354,7 +376,7 @@ exports.fieldMappers = {
         ...Object.fromEntries(Object.entries(numberOrNull['number | null']).map(([airtableType, nullablePair]) => {
             return [airtableType, {
                     toAirtable: nullablePair.toAirtable,
-                    fromAirtable: (value) => {
+                    fromAirtable(value) {
                         const nullableValue = nullablePair.fromAirtable(value);
                         if (nullableValue === null) {
                             throw new AirtableTsError_1.AirtableTsError({

package/dist/mapping/nameMapper.d.ts

@@ -1,4 +1,4 @@
-import { Item, Table, FromTsTypeString, TsTypeString } from './typeUtils';
+import { type Item, type Table, type FromTsTypeString, type TsTypeString } from './typeUtils';
 /**
  * Maps a TS object (matching table.mappings) to another TS object (matching table.schema),
  * mapping columns based on the table definition.

package/dist/mapping/nameMapper.js

@@ -38,9 +38,10 @@ const mapRecordFieldNamesAirtableToTs = (table, tsRecord) => {
         if (Array.isArray(mappingToAirtable)) {
             return [outputFieldName, mappingToAirtable.map((airtableFieldName) => tsRecord[airtableFieldName])];
         }
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
         return [outputFieldName, tsRecord[mappingToAirtable]];
     }));
-    return Object.assign(item, { id: tsRecord['id'] });
+    return Object.assign(item, { id: tsRecord.id });
 };
 exports.mapRecordFieldNamesAirtableToTs = mapRecordFieldNamesAirtableToTs;
 /**
@@ -88,13 +89,13 @@ const mapRecordFieldNamesTsToAirtable = (table, item) => {
                 }
                 // This should be unreachable because of our types
                 throw new AirtableTsError_1.AirtableTsError({
-                    message: `Received null for non-nullable field '${outputFieldName}' (${mappingToAirtable}) with type '${tsType}' in table '${table.name}' (${table.tableId}). This should never happen in normal operation as it should be caught before this point.`,
+                    message: `Received null for non-nullable field '${outputFieldName}' (${JSON.stringify(mappingToAirtable)}) with type '${tsType}' in table '${table.name}' (${table.tableId}). This should never happen in normal operation as it should be caught before this point.`,
                     type: AirtableTsError_1.ErrorType.SCHEMA_VALIDATION,
                 });
             }
             if (!Array.isArray(value)) {
                 throw new AirtableTsError_1.AirtableTsError({
-                    message: `Expected an array for field '${outputFieldName}' (${mappingToAirtable}) in table '${table.name}' (${table.tableId}), but received ${typeof value}.`,
+                    message: `Expected an array for field '${outputFieldName}' (${JSON.stringify(mappingToAirtable)}) in table '${table.name}' (${table.tableId}), but received ${typeof value}.`,
                     type: AirtableTsError_1.ErrorType.SCHEMA_VALIDATION,
                 });
             }

package/dist/mapping/recordMapper.d.ts

@@ -1,17 +1,13 @@
-import { FieldSet } from 'airtable';
-import { AirtableRecord, AirtableTsTable } from '../types';
-import { FromTsTypeString, Item, Table, TsTypeString } from './typeUtils';
+import { type FieldSet } from 'airtable';
+import { type AirtableRecord, type AirtableTsTable } from '../types';
+import { type FromTsTypeString, type Item, type Table, type TsTypeString } from './typeUtils';
 export declare const mapRecordFromAirtable: <T extends Item>(table: Table<T>, record: AirtableRecord) => T;
 export declare const mapRecordToAirtable: <T extends Item>(table: Table<T>, item: Partial<T>, airtableTsTable: AirtableTsTable) => FieldSet;
 export declare const visibleForTesting: {
-    mapRecordTypeAirtableToTs: <T extends {
-        [fieldNameOrId: string]: TsTypeString;
-    }>(table: Table<Item>, tsTypes: T, record: AirtableRecord) => { [F in keyof T]: FromTsTypeString<T[F]>; } & {
+    mapRecordTypeAirtableToTs: <T extends Record<string, TsTypeString>>(table: Table<Item>, tsTypes: T, record: AirtableRecord) => ({ [F in keyof T]: FromTsTypeString<T[F]>; } & {
         id: string;
-    };
-    mapRecordTypeTsToAirtable: <T_1 extends {
-        [fieldNameOrId: string]: TsTypeString;
-    }, R extends { [K in keyof T_1]?: FromTsTypeString<T_1[K]>; } & {
+    });
+    mapRecordTypeTsToAirtable: <T extends Record<string, TsTypeString>, R extends { [K in keyof T]?: FromTsTypeString<T[K]>; } & {
         id?: string;
-    }>(table: Table<Item>, tsTypes: T_1, tsRecord: R, airtableTsTable: AirtableTsTable) => FieldSet;
+    }>(table: Table<Item>, tsTypes: T, tsRecord: R, airtableTsTable: AirtableTsTable) => FieldSet;
 };

package/dist/mapping/recordMapper.js

@@ -45,7 +45,6 @@ const getMapper = (tsType, airtableType) => {
 const mapRecordTypeAirtableToTs = (table, tsTypes, record) => {
     const item = {};
     Object.entries(tsTypes).forEach(([fieldNameOrId, tsType]) => {
-        // eslint-disable-next-line no-underscore-dangle
         const fieldDefinition = record._table.fields.find((f) => f.id === fieldNameOrId || f.name === fieldNameOrId);
         if (!fieldDefinition) {
             // This should not happen normally, as we should only be trying to map fields that are in the table definition
@@ -57,7 +56,6 @@ const mapRecordTypeAirtableToTs = (table, tsTypes, record) => {
         const value = record.fields[fieldDefinition.name];
         try {
             const { fromAirtable } = getMapper(tsType, fieldDefinition.type);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             item[fieldNameOrId] = fromAirtable(value);
         }
         catch (error) {
@@ -101,7 +99,6 @@ const mapRecordTypeTsToAirtable = (table, tsTypes, tsRecord, airtableTsTable) =>
                 suggestion: 'Ensure the value matches the expected type in your schema definition.',
             });
         }
-        // eslint-disable-next-line no-underscore-dangle
         const fieldDefinition = airtableTsTable.fields.find((f) => f.id === fieldNameOrId || f.name === fieldNameOrId);
         if (!fieldDefinition) {
             const tsName = table.mappings ? Object.entries(table.mappings).find((e) => e[1] === fieldNameOrId)?.[0] : undefined;
@@ -113,7 +110,6 @@ const mapRecordTypeTsToAirtable = (table, tsTypes, tsRecord, airtableTsTable) =>
         }
         try {
             const { toAirtable } = getMapper(tsType, fieldDefinition.type);
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
             item[fieldNameOrId] = toAirtable(value);
         }
         catch (error) {

package/dist/mapping/typeUtils.d.ts

@@ -4,11 +4,11 @@ export type ToTsTypeString<T> = null extends T ? `${NonNullToString<T>} | null`
 export type FromTsTypeString<T> = T extends 'string' ? string : T extends 'string | null' ? string | null : T extends 'number' ? number : T extends 'number | null' ? number | null : T extends 'boolean' ? boolean : T extends 'boolean | null' ? boolean | null : T extends 'string[]' ? string[] : T extends 'string[] | null' ? string[] | null : T extends 'number[]' ? number[] : T extends 'number[] | null' ? number[] | null : T extends 'boolean[]' ? boolean[] : T extends 'boolean[] | null' ? boolean[] | null : never;
 export type AirtableTypeString = 'aiText' | 'autoNumber' | 'barcode' | 'button' | 'checkbox' | 'count' | 'createdBy' | 'createdTime' | 'currency' | 'date' | 'dateTime' | 'duration' | 'email' | 'externalSyncSource' | 'formula' | 'lastModifiedBy' | 'lastModifiedTime' | 'lookup' | 'multipleLookupValues' | 'multilineText' | 'multipleAttachments' | 'multipleCollaborators' | 'multipleRecordLinks' | 'multipleSelects' | 'number' | 'percent' | 'phoneNumber' | 'rating' | 'richText' | 'rollup' | 'singleCollaborator' | 'singleLineText' | 'singleSelect' | 'url';
 export type FromAirtableTypeString<T extends AirtableTypeString | 'unknown'> = null | (T extends 'url' | 'email' | 'phoneNumber' | 'singleLineText' | 'multilineText' | 'richText' | 'singleSelect' | 'externalSyncSource' | 'date' | 'dateTime' | 'createdTime' | 'lastModifiedTime' ? string : T extends 'multipleRecordLinks' | 'multipleSelects' ? string[] : T extends 'number' | 'rating' | 'duration' | 'currency' | 'percent' | 'count' | 'autoNumber' ? number : T extends 'checkbox' ? boolean : T extends 'lookup' | 'multipleLookupValues' | 'rollup' | 'formula' ? FromAirtableTypeString<any>[] : T extends 'aiText' | 'barcode' | 'singleCollaborator' | 'createdBy' | 'modifiedBy' | 'button' ? object : T extends 'multipleCollaborators' | 'multipleAttachments' ? object[] : T extends 'unknown' ? unknown : never);
-interface TypeDef {
+type TypeDef = {
     single: 'string' | 'number' | 'boolean';
     array: boolean;
     nullable: boolean;
-}
+};
 export declare const parseType: (t: TsTypeString) => TypeDef;
 /**
  * Verifies whether the given value is assignable to the given type
@@ -43,11 +43,11 @@ export declare const matchesType: (value: unknown, tsType: TsTypeString) => bool
  */
 export declare const airtableFieldNameTsTypes: <T extends Item>(table: Table<T>) => Record<string, TsTypeString>;
 export type MappingValue<T> = T extends unknown[] ? string | string[] : string;
-export interface Item {
+export type Item = {
     /** Represents the Airtable record id, @example "rec1234" */
     id: string;
-}
-export interface Table<T extends Item> {
+};
+export type Table<T extends Item> = {
     /** A simple name for the entities in this table, to be used in error messages @example "person" */
     name: string;
     /** The base id for this table. You can get this from the URL when accessing the table in the web UI. @example "app1234" */
@@ -59,19 +59,19 @@ export interface Table<T extends Item> {
         [k in keyof Omit<T, 'id'>]: ToTsTypeString<T[k]>;
     };
     /**
-     * Optional name mappings. This allows you to detach the schema names from the names you want to use in your code.
-     * @example
-     * export const personTable: Table<{ id: string, firstName: string }> = {
-     *   name: 'person', baseId: 'app1234', tableId: 'tbl1234',
-     *   schema: { firstName: 'string' },
-     *   // The field is named '[core] First Name' in the base. If this ever changes, we just need to update it here.
-     *   mappings: { firstName: '[core] First Name' },
-     * };
-     * const people = await db.scan(studentTable);
-     * const firstPersonsFirstName = people[0].firstName;
-     * */
+   * Optional name mappings. This allows you to detach the schema names from the names you want to use in your code.
+   * @example
+   * export const personTable: Table<{ id: string, firstName: string }> = {
+   *   name: 'person', baseId: 'app1234', tableId: 'tbl1234',
+   *   schema: { firstName: 'string' },
+   *   // The field is named '[core] First Name' in the base. If this ever changes, we just need to update it here.
+   *   mappings: { firstName: '[core] First Name' },
+   * };
+   * const people = await db.scan(studentTable);
+   * const firstPersonsFirstName = people[0].firstName;
+   * */
     mappings?: {
         [k in keyof Omit<T, 'id'>]: MappingValue<T[k]>;
     };
-}
+};
 export {};

package/dist/mapping/typeUtils.js

@@ -112,7 +112,7 @@ const airtableFieldNameTsTypes = (table) => {
             return [[mappingToAirtable, tsType]];
         }
         catch (error) {
-            throw (0, AirtableTsError_1.prependError)(error, `Error with field ${JSON.stringify(outputFieldName)} (${mappingToAirtable})`);
+            throw (0, AirtableTsError_1.prependError)(error, `Error with field ${String(outputFieldName)} (${JSON.stringify(mappingToAirtable)})`);
         }
     }).flat(1));
 };

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import type { FieldSet, Table as AirtableSdkTable, Record as AirtableSdkRecord, AirtableOptions } from 'airtable';
-import { QueryParams } from 'airtable/lib/query_params';
-import { Item, Table } from './mapping/typeUtils';
+import { type QueryParams } from 'airtable/lib/query_params';
+import { type Item, type Table } from './mapping/typeUtils';
 export type AirtableRecord = Omit<AirtableSdkRecord<FieldSet>, '_table'> & {
     _table: AirtableTsTable;
 };
@@ -13,10 +13,10 @@ export type AirtableTsTable<T extends Item = Item> = AirtableSdkTable<FieldSet>
     tsDefinition: Table<T>;
     __brand?: T;
 };
-interface AirtableTsSpecificOptions {
+type AirtableTsSpecificOptions = {
     /** The Airtable base schema is used to determine the appropriate type mapper for the field type (for example converting a number to a string representing a date is different to converting a number to a singleLineText). For performance reasons, airtable-ts caches base schemas so we don't refetch it for every request. Note that we always still do validation against the expected type at runtime so the library is always type-safe. @default 120_000 */
     baseSchemaCacheDurationMs?: number;
-}
+};
 export type AirtableTsOptions = AirtableOptions & AirtableTsSpecificOptions;
 export type CompleteAirtableTsOptions = AirtableTsOptions & Required<AirtableTsSpecificOptions>;
 export type ScanParams = Omit<QueryParams<unknown>, 'fields' | 'cellFormat' | 'method' | 'returnFieldsByFieldId' | 'pageSize' | 'offset'>;

package/dist/wrapToCatchAirtableErrors.js

@@ -36,7 +36,6 @@ function wrapAirtableError(error) {
 }
 const wrapToCatchAirtableErrors = (c) => {
     // Cast to any to bypass TypeScript's type checking, as unfortunately this is too funky for TypeScript
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     const prototype = c.prototype;
     const methods = Object.getOwnPropertyNames(prototype).filter((prop) => {
         return prop !== 'constructor' && typeof prototype[prop] === 'function';
@@ -44,7 +43,6 @@ const wrapToCatchAirtableErrors = (c) => {
     methods.forEach((method) => {
         const original = prototype[method];
         if (typeof original === 'function') {
-            // eslint-disable-next-line func-names
             prototype[method] = function (...args) {
                 try {
                     const result = original.apply(this, args);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airtable-ts",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "A type-safe Airtable SDK",
   "license": "MIT",
   "author": "Adam Jones (domdomegg)",
@@ -16,26 +16,23 @@
   "scripts": {
     "test": "vitest run",
     "test:watch": "vitest --watch",
-    "lint": "eslint --ext .js,.jsx,.ts,.tsx .",
+    "lint": "eslint",
     "clean": "rm -rf dist",
     "build": "tsc --project tsconfig.build.json",
     "prepublishOnly": "npm run clean && npm run build"
   },
-  "devDependencies": {
-    "@tsconfig/node-lts": "^20.1.0",
-    "@tsconfig/strictest": "^2.0.2",
-    "eslint": "^8.56.0",
-    "eslint-config-domdomegg": "^1.2.3",
-    "typescript": "^5.3.3",
-    "vitest": "^1.0.4"
-  },
-  "eslintConfig": {
-    "extends": [
-      "eslint-config-domdomegg"
-    ]
-  },
   "dependencies": {
     "airtable": "^0.12.2",
     "axios": "^1.6.8"
+  },
+  "devDependencies": {
+    "@tsconfig/node-lts": "^22.0.1",
+    "@tsconfig/strictest": "^2.0.2",
+    "@types/node": "^22.15.3",
+    "eslint": "^9.25.1",
+    "eslint-config-domdomegg": "^2.0.8",
+    "tsconfig-domdomegg": "^1.0.0",
+    "typescript": "^5.8.3",
+    "vitest": "^3.1.2"
   }
 }