airtable-ts 1.0.0 → 1.2.0

package/README.md

@@ -32,6 +32,9 @@ export const studentTable: Table<{ id: string, name: string, classes: string[] }
   baseId: 'app1234',
   tableId: 'tbl1234',
   schema: { name: 'string', classes: 'string[]' },
+  // optional: use mappings with field ids to prevent renamings breaking your app,
+  //           or with field names to make handling renamings easy
+  mappings: { name: 'fld1234', classes: 'Classes student is enrolled in' },
 };
 
 export const classTable: Table<{ id: string, name: string }> = {

package/dist/assertMatchesSchema.js

@@ -2,9 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.assertMatchesSchema = void 0;
 const typeUtils_1 = require("./mapping/typeUtils");
-// In theory, this should never catch stuff because our type mapping logic should
-// verify the types are compatible. However, "In theory there is no difference
-// between theory and practice - in practice there is"
 /**
  * In theory, this should never catch stuff because our type mapping logic should
  * verify the types are compatible.

package/dist/mapping/fieldMappers.js

@@ -17,12 +17,31 @@ const requiredMapperPair = {
 };
 exports.fieldMappers = {
     string: {
-        singleLineText: fallbackMapperPair('', ''),
-        email: fallbackMapperPair('', ''),
         url: fallbackMapperPair('', ''),
+        email: fallbackMapperPair('', ''),
+        phoneNumber: fallbackMapperPair('', ''),
+        singleLineText: fallbackMapperPair('', ''),
         multilineText: fallbackMapperPair('', ''),
         richText: fallbackMapperPair('', ''),
-        phoneNumber: fallbackMapperPair('', ''),
+        singleSelect: fallbackMapperPair('', ''),
+        externalSyncSource: {
+            toAirtable: () => { throw new Error('[airtable-ts] externalSyncSource type field is readonly'); },
+            fromAirtable: (value) => value ?? '',
+        },
+        multipleSelects: {
+            toAirtable: (value) => {
+                return [value];
+            },
+            fromAirtable: (value) => {
+                if (!value) {
+                    throw new Error('[airtable-ts] Failed to coerce multipleSelects type field to a single string, as it was blank');
+                }
+                if (value.length !== 1) {
+                    throw new Error(`[airtable-ts] Can't coerce multipleSelects to a single string, as there were ${value?.length} entries`);
+                }
+                return value[0];
+            },
+        },
         multipleRecordLinks: {
             toAirtable: (value) => {
                 return [value];
@@ -37,6 +56,22 @@ exports.fieldMappers = {
                 return value[0];
             },
         },
+        date: {
+            toAirtable: (value) => {
+                const date = new Date(value);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date string');
+                }
+                return date.toJSON().slice(0, 10);
+            },
+            fromAirtable: (value) => {
+                const date = new Date(value ?? '');
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date string');
+                }
+                return date.toJSON();
+            },
+        },
         dateTime: {
             toAirtable: (value) => {
                 const date = new Date(value);
@@ -54,28 +89,67 @@ exports.fieldMappers = {
             },
         },
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value) {
-                    throw new Error('[airtable-ts] Failed to coerce multipleLookupValues type field to a single string, as it was blank');
+                    throw new Error('[airtable-ts] Failed to coerce lookup type field to a single string, as it was blank');
                 }
                 if (value.length !== 1) {
-                    throw new Error(`[airtable-ts] Can't coerce multipleLookupValues to a single string, as there were ${value?.length} entries`);
+                    throw new Error(`[airtable-ts] Can't coerce lookup to a single string, as there were ${value?.length} entries`);
                 }
                 if (typeof value[0] !== 'string') {
-                    throw new Error(`[airtable-ts] Can't coerce singular multipleLookupValues to a single string, as it was of type ${typeof value[0]}`);
+                    throw new Error(`[airtable-ts] Can't coerce singular lookup to a single string, as it was of type ${typeof value[0]}`);
                 }
                 return value[0];
             },
         },
+        rollup: {
+            toAirtable: () => { throw new Error('[airtable-ts] rollup type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'string')
+                    return value;
+                if (value === undefined || value === null)
+                    return '';
+                throw new Error(`[airtable-ts] Can't coerce rollup to a string, as it was of type ${typeof value}`);
+            },
+        },
+        formula: {
+            toAirtable: () => { throw new Error('[airtable-ts] formula type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'string')
+                    return value;
+                if (value === undefined || value === null)
+                    return '';
+                throw new Error(`[airtable-ts] Can't coerce formula to a string, as it was of type ${typeof value}`);
+            },
+        },
     },
     'string | null': {
-        singleLineText: fallbackMapperPair(null, null),
-        email: fallbackMapperPair(null, null),
         url: fallbackMapperPair(null, null),
+        email: fallbackMapperPair(null, null),
+        phoneNumber: fallbackMapperPair(null, null),
+        singleLineText: fallbackMapperPair(null, null),
         multilineText: fallbackMapperPair(null, null),
         richText: fallbackMapperPair(null, null),
-        phoneNumber: fallbackMapperPair(null, null),
+        singleSelect: fallbackMapperPair(null, null),
+        externalSyncSource: {
+            toAirtable: () => { throw new Error('[airtable-ts] externalSyncSource type field is readonly'); },
+            fromAirtable: (value) => value ?? null,
+        },
+        multipleSelects: {
+            toAirtable: (value) => {
+                return value ? [value] : [];
+            },
+            fromAirtable: (value) => {
+                if (!value || value.length === 0) {
+                    return null;
+                }
+                if (value.length !== 1) {
+                    throw new Error(`[airtable-ts] Can't coerce multipleSelects to a single string, as there were ${value?.length} entries`);
+                }
+                return value[0];
+            },
+        },
         multipleRecordLinks: {
             toAirtable: (value) => {
                 return value ? [value] : [];
@@ -90,6 +164,26 @@ exports.fieldMappers = {
                 return value[0];
             },
         },
+        date: {
+            toAirtable: (value) => {
+                if (value === null)
+                    return null;
+                const date = new Date(value);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date');
+                }
+                return date.toJSON().slice(0, 10);
+            },
+            fromAirtable: (value) => {
+                if (value === null || value === undefined)
+                    return null;
+                const date = new Date(value);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date');
+                }
+                return date.toJSON();
+            },
+        },
         dateTime: {
             toAirtable: (value) => {
                 if (value === null)
@@ -111,34 +205,54 @@ exports.fieldMappers = {
             },
         },
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value || value.length === 0) {
                     return null;
                 }
                 if (value.length !== 1) {
-                    throw new Error(`[airtable-ts] Can't coerce multipleLookupValues to a single string, as there were ${value?.length} entries`);
+                    throw new Error(`[airtable-ts] Can't coerce lookup to a single string, as there were ${value?.length} entries`);
                 }
                 if (typeof value[0] !== 'string') {
-                    throw new Error(`[airtable-ts] Can't coerce singular multipleLookupValues to a single string, as it was of type ${typeof value[0]}`);
+                    throw new Error(`[airtable-ts] Can't coerce singular lookup to a single string, as it was of type ${typeof value[0]}`);
                 }
                 return value[0];
             },
         },
+        rollup: {
+            toAirtable: () => { throw new Error('[airtable-ts] rollup type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'string')
+                    return value;
+                if (value === undefined || value === null)
+                    return null;
+                throw new Error(`[airtable-ts] Can't coerce rollup to a string, as it was of type ${typeof value}`);
+            },
+        },
+        formula: {
+            toAirtable: () => { throw new Error('[airtable-ts] formula type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'string')
+                    return value;
+                if (value === undefined || value === null)
+                    return null;
+                throw new Error(`[airtable-ts] Can't coerce formula to a string, as it was of type ${typeof value}`);
+            },
+        },
     },
     boolean: {
         checkbox: fallbackMapperPair(false, false),
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value) {
-                    throw new Error('[airtable-ts] Failed to coerce multipleLookupValues type field to a single boolean, as it was blank');
+                    throw new Error('[airtable-ts] Failed to coerce lookup type field to a single boolean, as it was blank');
                 }
                 if (value.length !== 1) {
-                    throw new Error(`[airtable-ts] Can't coerce multipleLookupValues to a single boolean, as there were ${value?.length} entries`);
+                    throw new Error(`[airtable-ts] Can't coerce lookup to a single boolean, as there were ${value?.length} entries`);
                 }
                 if (typeof value[0] !== 'boolean') {
-                    throw new Error(`[airtable-ts] Can't coerce singular multipleLookupValues to a single boolean, as it was of type ${typeof value[0]}`);
+                    throw new Error(`[airtable-ts] Can't coerce singular lookup to a single boolean, as it was of type ${typeof value[0]}`);
                 }
                 return value[0];
             },
@@ -147,16 +261,16 @@ exports.fieldMappers = {
     'boolean | null': {
         checkbox: fallbackMapperPair(null, null),
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value || value.length === 0) {
                     return null;
                 }
                 if (value.length !== 1) {
-                    throw new Error(`[airtable-ts] Can't coerce multipleLookupValues to a single boolean, as there were ${value?.length} entries`);
+                    throw new Error(`[airtable-ts] Can't coerce lookup to a single boolean, as there were ${value?.length} entries`);
                 }
                 if (typeof value[0] !== 'boolean') {
-                    throw new Error(`[airtable-ts] Can't coerce singular multipleLookupValues to a single boolean, as it was of type ${typeof value[0]}`);
+                    throw new Error(`[airtable-ts] Can't coerce singular lookup to a single boolean, as it was of type ${typeof value[0]}`);
                 }
                 return value[0];
             },
@@ -164,10 +278,10 @@ exports.fieldMappers = {
     },
     number: {
         number: requiredMapperPair,
-        percent: requiredMapperPair,
-        currency: requiredMapperPair,
         rating: requiredMapperPair,
         duration: requiredMapperPair,
+        currency: requiredMapperPair,
+        percent: requiredMapperPair,
         count: {
             toAirtable: () => { throw new Error('[airtable-ts] count type field is readonly'); },
             fromAirtable: (value) => required(value),
@@ -177,6 +291,23 @@ exports.fieldMappers = {
             fromAirtable: (value) => required(value),
         },
         // Number assumed to be unix time in seconds
+        date: {
+            toAirtable: (value) => {
+                const date = new Date(value * 1000);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date');
+                }
+                return date.toJSON().slice(0, 10);
+            },
+            fromAirtable: (value) => {
+                const date = new Date(value ?? '');
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date');
+                }
+                return Math.floor(date.getTime() / 1000);
+            },
+        },
+        // Number assumed to be unix time in seconds
         dateTime: {
             toAirtable: (value) => {
                 const date = new Date(value * 1000);
@@ -194,27 +325,43 @@ exports.fieldMappers = {
             },
         },
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value) {
-                    throw new Error('[airtable-ts] Failed to coerce multipleLookupValues type field to a single number, as it was blank');
+                    throw new Error('[airtable-ts] Failed to coerce lookup type field to a single number, as it was blank');
                 }
                 if (value.length !== 1) {
-                    throw new Error(`[airtable-ts] Can't coerce multipleLookupValues to a single number, as there were ${value?.length} entries`);
+                    throw new Error(`[airtable-ts] Can't coerce lookup to a single number, as there were ${value?.length} entries`);
                 }
                 if (typeof value[0] !== 'number') {
-                    throw new Error(`[airtable-ts] Can't coerce singular multipleLookupValues to a single number, as it was of type ${typeof value[0]}`);
+                    throw new Error(`[airtable-ts] Can't coerce singular lookup to a single number, as it was of type ${typeof value[0]}`);
                 }
                 return value[0];
             },
         },
+        rollup: {
+            toAirtable: () => { throw new Error('[airtable-ts] rollup type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'number')
+                    return value;
+                throw new Error(`[airtable-ts] Can't coerce rollup to a number, as it was of type ${typeof value}`);
+            },
+        },
+        formula: {
+            toAirtable: () => { throw new Error('[airtable-ts] formula type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'number')
+                    return value;
+                throw new Error(`[airtable-ts] Can't coerce formula to a number, as it was of type ${typeof value}`);
+            },
+        },
     },
     'number | null': {
         number: fallbackMapperPair(null, null),
-        percent: fallbackMapperPair(null, null),
-        currency: fallbackMapperPair(null, null),
         rating: fallbackMapperPair(null, null),
         duration: fallbackMapperPair(null, null),
+        currency: fallbackMapperPair(null, null),
+        percent: fallbackMapperPair(null, null),
         count: {
             fromAirtable: (value) => value ?? null,
             toAirtable: () => { throw new Error('[airtable-ts] count type field is readonly'); },
@@ -224,6 +371,27 @@ exports.fieldMappers = {
             toAirtable: () => { throw new Error('[airtable-ts] autoNumber field is readonly'); },
         },
         // Number assumed to be unix time in seconds
+        date: {
+            toAirtable: (value) => {
+                if (value === null)
+                    return null;
+                const date = new Date(value * 1000);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date');
+                }
+                return date.toJSON().slice(0, 10);
+            },
+            fromAirtable: (value) => {
+                if (value === null || value === undefined)
+                    return null;
+                const date = new Date(value);
+                if (Number.isNaN(date.getTime())) {
+                    throw new Error('[airtable-ts] Invalid date');
+                }
+                return Math.floor(date.getTime() / 1000);
+            },
+        },
+        // Number assumed to be unix time in seconds
         dateTime: {
             toAirtable: (value) => {
                 if (value === null)
@@ -245,49 +413,98 @@ exports.fieldMappers = {
             },
         },
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value || value.length === 0) {
                     return null;
                 }
                 if (value.length !== 1) {
-                    throw new Error(`[airtable-ts] Can't coerce multipleLookupValues to a single number, as there were ${value?.length} entries`);
+                    throw new Error(`[airtable-ts] Can't coerce lookup to a single number, as there were ${value?.length} entries`);
                 }
                 if (typeof value[0] !== 'number') {
-                    throw new Error(`[airtable-ts] Can't coerce singular multipleLookupValues to a single number, as it was of type ${typeof value[0]}`);
+                    throw new Error(`[airtable-ts] Can't coerce singular lookup to a single number, as it was of type ${typeof value[0]}`);
                 }
                 return value[0];
             },
         },
+        rollup: {
+            toAirtable: () => { throw new Error('[airtable-ts] rollup type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'number')
+                    return value;
+                if (value === null || value === undefined)
+                    return null;
+                throw new Error(`[airtable-ts] Can't coerce rollup to a number, as it was of type ${typeof value}`);
+            },
+        },
+        formula: {
+            toAirtable: () => { throw new Error('[airtable-ts] formula type field is readonly'); },
+            fromAirtable: (value) => {
+                if (typeof value === 'number')
+                    return value;
+                if (value === null || value === undefined)
+                    return null;
+                throw new Error(`[airtable-ts] Can't coerce formula to a number, as it was of type ${typeof value}`);
+            },
+        },
     },
     'string[]': {
+        multipleSelects: fallbackMapperPair([], []),
         multipleRecordLinks: fallbackMapperPair([], []),
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
             fromAirtable: (value) => {
                 if (!Array.isArray(value)) {
-                    throw new Error('[airtable-ts] Failed to coerce multipleLookupValues type field to a string array, as it was not an array');
+                    throw new Error('[airtable-ts] Failed to coerce lookup type field to a string array, as it was not an array');
                 }
                 if (value.some((v) => typeof v !== 'string')) {
-                    throw new Error('[airtable-ts] Can\'t coerce multipleLookupValues to a string array, as it had non string type');
+                    throw new Error('[airtable-ts] Can\'t coerce lookup to a string array, as it had non string type');
+                }
+                return value;
+            },
+        },
+        formula: {
+            toAirtable: () => { throw new Error('[airtable-ts] formula type field is readonly'); },
+            fromAirtable: (value) => {
+                if (!Array.isArray(value)) {
+                    throw new Error('[airtable-ts] Failed to coerce formula type field to a string array, as it was not an array');
+                }
+                if (value.some((v) => typeof v !== 'string')) {
+                    throw new Error('[airtable-ts] Can\'t coerce formula to a string array, as it had non string type');
                 }
                 return value;
             },
         },
     },
     'string[] | null': {
+        multipleSelects: fallbackMapperPair(null, null),
         multipleRecordLinks: fallbackMapperPair(null, null),
         multipleLookupValues: {
-            toAirtable: () => { throw new Error('[airtable-ts] multipleLookupValues type field is readonly'); },
+            toAirtable: () => { throw new Error('[airtable-ts] lookup type field is readonly'); },
+            fromAirtable: (value) => {
+                if (!value && !Array.isArray(value)) {
+                    return null;
+                }
+                if (!Array.isArray(value)) {
+                    throw new Error('[airtable-ts] Failed to coerce lookup type field to a string array, as it was not an array');
+                }
+                if (value.some((v) => typeof v !== 'string')) {
+                    throw new Error('[airtable-ts] Can\'t coerce lookup to a string array, as it had non string type');
+                }
+                return value;
+            },
+        },
+        formula: {
+            toAirtable: () => { throw new Error('[airtable-ts] formula type field is readonly'); },
             fromAirtable: (value) => {
                 if (!value && !Array.isArray(value)) {
                     return null;
                 }
                 if (!Array.isArray(value)) {
-                    throw new Error('[airtable-ts] Failed to coerce multipleLookupValues type field to a string array, as it was not an array');
+                    throw new Error('[airtable-ts] Failed to coerce formula type field to a string array, as it was not an array');
                 }
                 if (value.some((v) => typeof v !== 'string')) {
-                    throw new Error('[airtable-ts] Can\'t coerce multipleLookupValues to a string array, as it had non string type');
+                    throw new Error('[airtable-ts] Can\'t coerce formula to a string array, as it had non string type');
                 }
                 return value;
             },

package/dist/mapping/recordMapper.d.ts

@@ -5,12 +5,12 @@ export declare const mapRecordFromAirtable: <T extends Item>(table: Table<T>, re
 export declare const mapRecordToAirtable: <T extends Item>(table: Table<T>, item: Partial<T>, airtableTable: AirtableTable) => FieldSet;
 export declare const visibleForTesting: {
     mapRecordTypeAirtableToTs: <T extends {
-        [fieldName: string]: TsTypeString;
+        [fieldNameOrId: string]: TsTypeString;
     }>(tsTypes: T, record: AirtableRecord) => { [F in keyof T]: FromTsTypeString<T[F]>; } & {
         id: string;
     };
     mapRecordTypeTsToAirtable: <T_1 extends {
-        [fieldName: string]: TsTypeString;
+        [fieldNameOrId: string]: TsTypeString;
     }, R extends { [K in keyof T_1]?: FromTsTypeString<T_1[K]>; } & {
         id?: string;
     }>(tsTypes: T_1, tsRecord: R, airtableTable: AirtableTable) => FieldSet;

package/dist/mapping/recordMapper.js

@@ -21,32 +21,32 @@ const typeUtils_1 = require("./typeUtils");
  */
 const mapRecordTypeAirtableToTs = (tsTypes, record) => {
     const item = {};
-    Object.entries(tsTypes).forEach(([fieldName, tsType]) => {
-        const value = record.fields[fieldName];
+    Object.entries(tsTypes).forEach(([fieldNameOrId, tsType]) => {
         // eslint-disable-next-line no-underscore-dangle
-        const airtableType = record._table.fields.find((f) => f.name === fieldName)?.type;
-        if (!airtableType) {
-            throw new Error(`[airtable-ts] Failed to get airtable type for field ${fieldName}`);
+        const fieldDefinition = record._table.fields.find((f) => f.id === fieldNameOrId || f.name === fieldNameOrId);
+        if (!fieldDefinition) {
+            throw new Error(`[airtable-ts] Failed to get Airtable field ${fieldNameOrId}`);
         }
+        const value = record.fields[fieldDefinition.name];
         const tsMapper = fieldMappers_1.fieldMappers[tsType];
         if (!tsMapper) {
             throw new Error(`[airtable-ts] No mappers for ts type ${tsType}`);
         }
-        const specificMapper = tsMapper[airtableType]?.fromAirtable;
+        const specificMapper = tsMapper[fieldDefinition.type]?.fromAirtable;
         if (!specificMapper) {
             // eslint-disable-next-line no-underscore-dangle
-            throw new Error(`[airtable-ts] Expected field ${record._table.name}.${fieldName} to be able to map to ts type ${tsType}, but got airtable type ${airtableType} which can't.`);
+            throw new Error(`[airtable-ts] Expected field ${record._table.name}.${fieldNameOrId} to be able to map to ts type ${tsType}, but got airtable type ${fieldDefinition.type} which can't.`);
         }
         try {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            item[fieldName] = specificMapper(value);
+            item[fieldNameOrId] = specificMapper(value);
         }
         catch (error) {
             if (error instanceof Error) {
                 // eslint-disable-next-line no-underscore-dangle
-                error.message = `Failed to map field ${record._table.name}.${fieldName}: ${error.message}`;
+                error.message = `Failed to map field ${record._table.name}.${fieldNameOrId}: ${error.message}`;
                 // eslint-disable-next-line no-underscore-dangle
-                error.stack = `Error: Failed to map field ${record._table.name}.${fieldName}: ${error.stack?.startsWith('Error: ') ? error.stack.slice('Error: '.length) : error.stack}`;
+                error.stack = `Error: Failed to map field ${record._table.name}.${fieldNameOrId}: ${error.stack?.startsWith('Error: ') ? error.stack.slice('Error: '.length) : error.stack}`;
             }
             throw error;
         }
@@ -73,30 +73,31 @@ const mapRecordTypeAirtableToTs = (tsTypes, record) => {
  */
 const mapRecordTypeTsToAirtable = (tsTypes, tsRecord, airtableTable) => {
     const item = {};
-    Object.entries(tsTypes).forEach(([fieldName, tsType]) => {
-        const value = tsRecord[fieldName];
-        if (!(fieldName in tsRecord)) {
+    Object.entries(tsTypes).forEach(([fieldNameOrId, tsType]) => {
+        const value = tsRecord[fieldNameOrId];
+        if (!(fieldNameOrId in tsRecord)) {
             // If we don't have the field, just skip: this allows us to support partial updates
             return;
         }
         if (!(0, typeUtils_1.matchesType)(value, tsType)) {
             // This should be unreachable because of our types
-            throw new Error(`[airtable-ts] Expected field ${airtableTable.name}.${fieldName} to match type \`${tsType}\` but got value \`${JSON.stringify(value)}\`. This should never happen in normal operation as it should be caught before this point.`);
+            throw new Error(`[airtable-ts] Expected field ${airtableTable.name}.${fieldNameOrId} to match type \`${tsType}\` but got value \`${JSON.stringify(value)}\`. This should never happen in normal operation as it should be caught before this point.`);
         }
-        const airtableType = airtableTable.fields.find((f) => f.name === fieldName)?.type;
-        if (!airtableType) {
-            throw new Error(`[airtable-ts] Failed to get airtable type for field ${fieldName}`);
+        // eslint-disable-next-line no-underscore-dangle
+        const fieldDefinition = airtableTable.fields.find((f) => f.id === fieldNameOrId || f.name === fieldNameOrId);
+        if (!fieldDefinition) {
+            throw new Error(`[airtable-ts] Failed to get Airtable field ${fieldNameOrId}`);
         }
         const tsMapper = fieldMappers_1.fieldMappers[tsType];
         if (!tsMapper) {
             throw new Error(`[airtable-ts] No mappers for ts type ${tsType}`);
         }
-        const specificMapper = tsMapper[airtableType]?.toAirtable;
+        const specificMapper = tsMapper[fieldDefinition.type]?.toAirtable;
         if (!specificMapper) {
-            throw new Error(`[airtable-ts] Expected field ${airtableTable.name}.${fieldName} to be able to map to airtable type \`${airtableType}\`, but got ts type \`${tsType}\` which can't.`);
+            throw new Error(`[airtable-ts] Expected field ${airtableTable.name}.${fieldNameOrId} to be able to map to airtable type \`${fieldDefinition.type}\`, but got ts type \`${tsType}\` which can't.`);
         }
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        item[fieldName] = specificMapper(value);
+        item[fieldNameOrId] = specificMapper(value);
     });
     return Object.assign(item, { id: tsRecord.id });
 };

package/dist/mapping/typeUtils.d.ts

@@ -2,8 +2,8 @@ export type TsTypeString = NonNullToString<any> | ToTsTypeString<any>;
 type NonNullToString<T> = T extends string ? 'string' : T extends number ? 'number' : T extends boolean ? 'boolean' : T extends number[] ? 'number[]' : T extends string[] ? 'string[]' : T extends boolean[] ? 'boolean[]' : never;
 export type ToTsTypeString<T> = null extends T ? `${NonNullToString<T>} | null` : NonNullToString<T>;
 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 = 'singleLineText' | 'email' | 'url' | 'multilineText' | 'phoneNumber' | 'checkbox' | 'number' | 'percent' | 'currency' | 'count' | 'autoNumber' | 'rating' | 'richText' | 'duration' | 'multipleRecordLinks' | 'dateTime' | 'multipleLookupValues';
-export type FromAirtableTypeString<T> = null | (T extends 'singleLineText' ? string : T extends 'email' ? string : T extends 'url' ? string : T extends 'multilineText' ? string : T extends 'richText' ? string : T extends 'phoneNumber' ? string : T extends 'checkbox' ? boolean : T extends 'number' ? number : T extends 'percent' ? number : T extends 'currency' ? number : T extends 'rating' ? number : T extends 'duration' ? number : T extends 'count' ? number : T extends 'autoNumber' ? number : T extends 'multipleRecordLinks' ? string[] : T extends 'multipleLookupValues' ? FromAirtableTypeString<any>[] : T extends 'dateTime' ? string : 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> = 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>[] : never);
 /**
  * Verifies whether the given value is assignable to the given type
  *

package/dist/types.d.ts

@@ -4,6 +4,7 @@ export type AirtableRecord = Omit<AirtableSdkRecord<FieldSet>, '_table'> & {
 };
 export type AirtableTable = AirtableSdkTable<FieldSet> & {
     fields: {
+        id: string;
         name: string;
         type: string;
     }[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airtable-ts",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "A type-safe Airtable SDK",
   "license": "MIT",
   "author": "Adam Jones (domdomegg)",