airtable-ts-codegen 2.0.1 → 2.1.1

package/README.md

@@ -12,6 +12,16 @@ AIRTABLE_API_KEY=pat1234.abcd AIRTABLE_BASE_ID=app1234 npx airtable-ts-codegen
 
 This will output a file `app1234.ts` that exports all the table definitions
 
+### Generate from a specific view
+
+You can also generate TypeScript definitions based on a specific view, which will only include the fields visible in those views:
+
+```sh
+AIRTABLE_API_KEY=pat1234.abcd AIRTABLE_BASE_ID=app1234 AIRTABLE_VIEW_IDS=viw1234,viw5678 npx airtable-ts-codegen
+```
+
+This will output a file `app1234.ts` that exports table definitions with only the fields visible in the specified views.
+
 <details>
 <summary>Example generated file</summary>
 

package/dist/__fixture__/tablesMeta.json.d.ts

@@ -35,6 +35,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -58,6 +60,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -85,6 +89,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -108,6 +114,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -134,6 +142,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -163,6 +173,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -186,6 +198,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -209,6 +223,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -232,6 +248,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -255,6 +273,8 @@ export declare const tablesMeta: {
                 isValid?: never;
                 formula?: never;
                 result?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -281,6 +301,8 @@ export declare const tablesMeta: {
                 symbol?: never;
                 durationFormat?: never;
                 max?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -300,6 +322,8 @@ export declare const tablesMeta: {
                             format: string;
                         };
                         timeZone: string;
+                        precision?: never;
+                        choices?: never;
                     };
                 };
                 choices?: never;
@@ -317,6 +341,8 @@ export declare const tablesMeta: {
                 max?: never;
                 isValid?: never;
                 formula?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
             };
             id: string;
             name: string;
@@ -338,6 +364,8 @@ export declare const tablesMeta: {
                             format: string;
                         };
                         timeZone: string;
+                        precision?: never;
+                        choices?: never;
                     };
                 };
                 choices?: never;
@@ -353,10 +381,109 @@ export declare const tablesMeta: {
                 durationFormat?: never;
                 max?: never;
                 formula?: never;
+                recordLinkFieldId?: never;
+                fieldIdInLinkedTable?: never;
+            };
+            id: string;
+            name: string;
+            description?: never;
+        } | {
+            type: string;
+            options: {
+                isValid: boolean;
+                recordLinkFieldId: string;
+                fieldIdInLinkedTable: string;
+                result: {
+                    type: string;
+                    options?: never;
+                };
+                choices?: never;
+                isReversed?: never;
+                referencedFieldIds?: never;
+                prompt?: never;
+                icon?: never;
+                color?: never;
+                dateFormat?: never;
+                timeFormat?: never;
+                timeZone?: never;
+                precision?: never;
+                symbol?: never;
+                durationFormat?: never;
+                max?: never;
+                formula?: never;
+            };
+            id: string;
+            name: string;
+            description?: never;
+        } | {
+            type: string;
+            options: {
+                isValid: boolean;
+                recordLinkFieldId: string;
+                fieldIdInLinkedTable: string;
+                result: {
+                    type: string;
+                    options: {
+                        precision: number;
+                        dateFormat?: never;
+                        timeFormat?: never;
+                        timeZone?: never;
+                        choices?: never;
+                    };
+                };
+                choices?: never;
+                isReversed?: never;
+                referencedFieldIds?: never;
+                prompt?: never;
+                icon?: never;
+                color?: never;
+                dateFormat?: never;
+                timeFormat?: never;
+                timeZone?: never;
+                precision?: never;
+                symbol?: never;
+                durationFormat?: never;
+                max?: never;
+                formula?: never;
+            };
+            id: string;
+            name: string;
+            description?: never;
+        } | {
+            type: string;
+            options: {
+                isValid: boolean;
+                recordLinkFieldId: string;
+                fieldIdInLinkedTable: string;
+                result: {
+                    type: string;
+                    options: {
+                        choices: never[];
+                        dateFormat?: never;
+                        timeFormat?: never;
+                        timeZone?: never;
+                        precision?: never;
+                    };
+                };
+                choices?: never;
+                isReversed?: never;
+                referencedFieldIds?: never;
+                prompt?: never;
+                icon?: never;
+                color?: never;
+                dateFormat?: never;
+                timeFormat?: never;
+                timeZone?: never;
+                precision?: never;
+                symbol?: never;
+                durationFormat?: never;
+                max?: never;
+                formula?: never;
             };
             id: string;
             name: string;
             description?: never;
         })[];
+        views: never[];
     }[];
 };

package/dist/__fixture__/tablesMeta.json.js

@@ -63,6 +63,22 @@ exports.tablesMeta = {
                 { type: 'createdBy', id: 'fldDcRoVGJXIhVSAi', name: 'Created By' },
                 { type: 'autoNumber', id: 'fldGM8wIYk3G8WMiE', name: 'ID' },
                 { type: 'barcode', id: 'fldMPs1eLH8X5bWeS', name: 'Barcode' },
-                { type: 'button', id: 'fldAG3LTbJRwQVEvS', name: 'Button' }],
+                { type: 'button', id: 'fldAG3LTbJRwQVEvS', name: 'Button' },
+                {
+                    type: 'multipleLookupValues', options: {
+                        isValid: true, recordLinkFieldId: 'fldLinked', fieldIdInLinkedTable: 'fldName', result: { type: 'singleLineText' },
+                    }, id: 'fldLookupText', name: 'Lookup Text',
+                },
+                {
+                    type: 'multipleLookupValues', options: {
+                        isValid: true, recordLinkFieldId: 'fldLinked', fieldIdInLinkedTable: 'fldNumber', result: { type: 'number', options: { precision: 0 } },
+                    }, id: 'fldLookupNumber', name: 'Lookup Number',
+                },
+                {
+                    type: 'multipleLookupValues', options: {
+                        isValid: true, recordLinkFieldId: 'fldLinked', fieldIdInLinkedTable: 'fldTags', result: { type: 'multipleSelects', options: { choices: [] } },
+                    }, id: 'fldLookupTags', name: 'Lookup Tags',
+                }],
+            views: [],
         }],
 };

package/dist/cli.js

@@ -12,8 +12,16 @@ const baseId = process.env.AIRTABLE_BASE_ID;
 if (!baseId) {
     throw new Error('No Airtable base id set. Make sure the AIRTABLE_BASE_ID environment variable is set.');
 }
-(0, _1.main)({ apiKey, baseId }).then((result) => {
-    (0, fs_1.writeFileSync)(`${(0, escapeIdentifier_1.escapeIdentifier)(baseId)}.ts`, result);
+const viewIds = process.env.AIRTABLE_VIEW_IDS;
+const config = { apiKey, baseId, ...(viewIds && { viewIds: viewIds.split(',') }) };
+const generateCode = async () => {
+    console.log(`Generating TypeScript definitions for base ${baseId}${viewIds ? ` with views ${viewIds}` : ''}...`);
+    return (0, _1.main)(config);
+};
+generateCode().then((result) => {
+    const filename = `${(0, escapeIdentifier_1.escapeIdentifier)(baseId)}.ts`;
+    (0, fs_1.writeFileSync)(filename, result);
+    console.log(`Generated ${filename}`);
 }).catch((err) => {
     console.error(err);
     process.exit(1);

package/dist/getBaseSchema.d.ts

@@ -6,12 +6,19 @@ export type FieldSchema = {
     description?: string;
     options?: object;
 };
+export type ViewSchema = {
+    id: string;
+    name: string;
+    type: 'grid' | 'form' | 'calendar' | 'gallery' | 'kanban' | 'timeline' | 'block';
+    visibleFieldIds?: string[];
+};
 export type BaseSchema = {
     id: string;
     name: string;
     primaryFieldId?: string;
     description?: string;
     fields: FieldSchema[];
+    views: ViewSchema[];
 }[];
 /**
  * Get the schemas from the cache or Airtable API for the tables in the given base.

package/dist/getBaseSchema.js

@@ -14,6 +14,9 @@ const getBaseSchema = async (baseId, options) => {
     const res = await (0, axios_1.default)({
         baseURL: options.endpointUrl ?? 'https://api.airtable.com',
         url: `/v0/meta/bases/${baseId}/tables`,
+        params: {
+            include: ['visibleFieldIds'],
+        },
         ...(options.requestTimeout ? { timeout: options.requestTimeout } : {}),
         headers: {
             Authorization: `Bearer ${options.apiKey}`,

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export type Config = {
     apiKey: string;
     baseId: string;
+    viewIds?: string[];
     endpointUrl?: string;
     requestTimeout?: number;
     customHeaders?: Record<string, string | number | boolean>;

package/dist/index.js

@@ -6,15 +6,17 @@ const getBaseSchema_1 = require("./getBaseSchema");
 const escapeString_1 = require("./escape/escapeString");
 const escapeIdentifier_1 = require("./escape/escapeIdentifier");
 const jsTypeForAirtableType_1 = require("./jsTypeForAirtableType");
+const view_1 = require("./view");
 // This generates a single typescript file containing all table definitions for a given base.
 const main = async (config) => {
     const baseSchema = await (0, getBaseSchema_1.getBaseSchema)(config.baseId, config);
+    const filteredBaseSchema = await (0, view_1.filterBaseSchemaByView)(baseSchema, config);
     return [
         '/* DO NOT EDIT: this file was automatically generated by airtable-ts-codegen */',
         '/* eslint-disable */',
         'import type { Item, Table } from \'airtable-ts\';',
         '',
-        baseSchema.map((tableSchema) => generateCode(config, tableSchema)).join('\n\n'),
+        filteredBaseSchema.map((tableSchema) => generateCode(config, tableSchema)).join('\n\n'),
     ].join('\n');
 };
 exports.main = main;

package/dist/jsTypeForAirtableType.js

@@ -46,8 +46,26 @@ const jsTypeForAirtableType = (field) => {
             return 'number'; // Unix timestamp in seconds
         case 'checkbox':
             return 'boolean';
-        case 'lookup':
         case 'multipleLookupValues':
+            if (field.options
+                && 'result' in field.options
+                && typeof field.options.result === 'object'
+                && field.options.result !== null) {
+                const innerType = (0, exports.jsTypeForAirtableType)(field.options.result);
+                if (innerType === null) {
+                    return null;
+                }
+                // multipleLookupValues always returns an array
+                // Strip nullability from inner type since the array itself represents empty state
+                const baseType = innerType.replace(/ \| null$/, '').replace(/^null \| /, '');
+                // If inner type is already an array, Airtable flattens lookup results
+                if (baseType.endsWith('[]')) {
+                    return baseType;
+                }
+                return `${baseType}[]`;
+            }
+            throw new Error(`Invalid ${field.type} field (no options.result): ${field.id}`);
+        case 'lookup':
         case 'rollup':
         case 'formula':
             if (field.options

package/dist/view.d.ts

@@ -0,0 +1,10 @@
+import type { Config } from './index';
+import { type BaseSchema } from './getBaseSchema';
+/**
+ * Filter base schema based on view IDs.
+ * If viewIds are specified:
+ * - Only include tables that have at least one matching view
+ * - For grid views with visibleFieldIds, filter fields to only visible ones
+ * - Throw error if any view ID doesn't match any table
+ */
+export declare const filterBaseSchemaByView: (baseSchema: BaseSchema, config: Config) => Promise<BaseSchema>;

package/dist/view.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.filterBaseSchemaByView = void 0;
+/**
+ * Find a view by ID in the base schema
+ */
+const findViewInBaseSchema = (baseSchema, viewId) => {
+    for (const table of baseSchema) {
+        const view = table.views.find((v) => v.id === viewId);
+        if (view) {
+            return { table, view };
+        }
+    }
+    return null;
+};
+/**
+ * Filter base schema based on view IDs.
+ * If viewIds are specified:
+ * - Only include tables that have at least one matching view
+ * - For grid views with visibleFieldIds, filter fields to only visible ones
+ * - Throw error if any view ID doesn't match any table
+ */
+const filterBaseSchemaByView = async (baseSchema, config) => {
+    // If no viewIds are provided, return the original schema
+    if (!config.viewIds) {
+        return baseSchema;
+    }
+    const matchedTableIds = new Set();
+    const viewToTableMap = new Map();
+    // First pass: find all views and their tables, validate all views exist
+    for (const viewId of config.viewIds) {
+        const result = findViewInBaseSchema(baseSchema, viewId);
+        if (!result) {
+            throw new Error(`View "${viewId}" not found in any table. Please check the view ID is correct.`);
+        }
+        viewToTableMap.set(viewId, result);
+        matchedTableIds.add(result.table.id);
+    }
+    // Second pass: filter tables and fields
+    const filteredTables = [];
+    for (const table of baseSchema) {
+        // Only include tables that have at least one matching view
+        if (!matchedTableIds.has(table.id)) {
+            continue;
+        }
+        // Find all matching views for this table
+        const matchingViews = config.viewIds
+            .map((viewId) => viewToTableMap.get(viewId))
+            .filter((result) => result?.table.id === table.id)
+            .map((result) => result.view);
+        // Check if any of the matching views are grid views with visibleFieldIds
+        const gridViewsWithVisibleFields = matchingViews.filter((view) => view.type === 'grid' && view.visibleFieldIds && view.visibleFieldIds.length > 0);
+        let filteredTable = table;
+        // If we have grid views with visible field restrictions, apply field filtering
+        if (gridViewsWithVisibleFields.length > 0) {
+            // Collect all visible field IDs from all matching grid views
+            const allVisibleFieldIds = new Set();
+            for (const view of gridViewsWithVisibleFields) {
+                if (view.visibleFieldIds) {
+                    view.visibleFieldIds.forEach((fieldId) => allVisibleFieldIds.add(fieldId));
+                }
+            }
+            // Filter fields to only include those visible in at least one grid view
+            filteredTable = {
+                ...table,
+                fields: table.fields.filter((field) => allVisibleFieldIds.has(field.id)),
+            };
+        }
+        filteredTables.push(filteredTable);
+    }
+    return filteredTables;
+};
+exports.filterBaseSchemaByView = filterBaseSchemaByView;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airtable-ts-codegen",
-  "version": "2.0.1",
+  "version": "2.1.1",
   "description": "Autogenerate TypeScript definitions for your Airtable base",
   "license": "MIT",
   "author": "Adam Jones (domdomegg)",