airtable-ts-codegen 2.0.0 → 2.1.0

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

@@ -358,5 +358,6 @@ export declare const tablesMeta: {
             name: string;
             description?: never;
         })[];
+        views: never[];
     }[];
 };

package/dist/__fixture__/tablesMeta.json.js

@@ -64,5 +64,6 @@ exports.tablesMeta = {
                 { type: 'autoNumber', id: 'fldGM8wIYk3G8WMiE', name: 'ID' },
                 { type: 'barcode', id: 'fldMPs1eLH8X5bWeS', name: 'Barcode' },
                 { type: 'button', id: 'fldAG3LTbJRwQVEvS', name: 'Button' }],
+            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/escape/escapeIdentifier.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Reset the internal state - useful for testing
+ */
+export declare function resetIdentifierState(): void;
 /**
  * Used for identifiers:
  * - If the name is already a valid JS identifier, return it unmodified.
@@ -5,6 +9,7 @@
  *   - Remove invalid characters.
  *   - Convert to PascalCase.
  *   - If the result starts with a digit, prefix with `_`.
+ *   - If duplicate, add a number suffix.
  * - Returns a default identifier if the identifier cannot be salvaged.
  */
 export declare function escapeIdentifier(name: string): string;

package/dist/escape/escapeIdentifier.js

@@ -1,9 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.resetIdentifierState = resetIdentifierState;
 exports.escapeIdentifier = escapeIdentifier;
 const diacritics_1 = require("diacritics");
 let invalidIdentifierCount = 0;
 const DEFAULT_IDENTIFIER = 'invalidIdentifier';
+// Track used identifiers to avoid duplicates
+const usedIdentifiers = new Set();
+/**
+ * Reset the internal state - useful for testing
+ */
+function resetIdentifierState() {
+    usedIdentifiers.clear();
+    invalidIdentifierCount = 0;
+}
 /**
  * Checks if 'str' is already a valid JavaScript identifier.
  * If yes, returns true. Otherwise false.
@@ -46,6 +56,7 @@ function toPascalCase(str) {
  *   - Remove invalid characters.
  *   - Convert to PascalCase.
  *   - If the result starts with a digit, prefix with `_`.
+ *   - If duplicate, add a number suffix.
  * - Returns a default identifier if the identifier cannot be salvaged.
  */
 function escapeIdentifier(name) {
@@ -92,5 +103,13 @@ function escapeIdentifier(name) {
             return `${DEFAULT_IDENTIFIER}${invalidIdentifierCount}`;
         }
     }
-    return pascal;
+    // Handle duplicates by adding numbers
+    let finalIdentifier = pascal;
+    let counter = 2;
+    while (usedIdentifiers.has(finalIdentifier)) {
+        finalIdentifier = `${pascal}${counter}`;
+        counter += 1;
+    }
+    usedIdentifiers.add(finalIdentifier);
+    return finalIdentifier;
 }

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,29 +6,33 @@ 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;
-const generateInterfaceEntry = ({ jsName, jsType, name, type }) => {
+const generateInterfaceEntry = ({ jsName, jsType, name, type, originalName }) => {
     if (jsType === null) {
-        return `\n  // Unsupported field ${name} of type ${type}`;
+        return `\n  // Unsupported field "${name}" of type ${type}`;
     }
-    return `\n  ${jsName}: ${jsType},`;
+    const comment = originalName !== jsName ? ` // Original field: "${originalName}"` : '';
+    return `\n  ${jsName}: ${jsType},${comment}`;
 };
-const generateMappingEntry = ({ jsName, id, jsType, name }) => {
+const generateMappingEntry = ({ jsName, id, jsType, name, originalName }) => {
     if (jsType === null) {
-        return `\n    // Unsupported field ${name}: ${(0, escapeString_1.escapeString)(id)}`;
+        return `\n    // Unsupported field "${name}": ${(0, escapeString_1.escapeString)(id)}`;
     }
-    return `\n    ${jsName}: '${(0, escapeString_1.escapeString)(id)}',`;
+    const comment = originalName !== jsName ? ` // Original field: "${originalName}"` : '';
+    return `\n    ${jsName}: '${(0, escapeString_1.escapeString)(id)}',${comment}`;
 };
 const generateSchemaEntry = ({ jsName, jsType }) => {
     if (jsType === null) {
@@ -37,11 +41,13 @@ const generateSchemaEntry = ({ jsName, jsType }) => {
     return `\n    ${jsName}: '${(0, escapeString_1.escapeString)(jsType)}',`;
 };
 const generateCode = (config, tableSchema) => {
+    (0, escapeIdentifier_1.resetIdentifierState)();
     const itemNameRaw = (0, escapeIdentifier_1.escapeIdentifier)((0, recase_1.recase)(null, 'pascal', tableSchema.name));
     const itemName = /.s$/.test(itemNameRaw) ? itemNameRaw.slice(0, itemNameRaw.length - 1) : itemNameRaw;
     const tableName = (0, escapeIdentifier_1.escapeIdentifier)(`${(0, recase_1.recase)(null, 'camel', tableSchema.name)}Table`);
     const fields = tableSchema.fields.map((f) => ({
         ...f,
+        originalName: f.name,
         jsName: (0, escapeIdentifier_1.escapeIdentifier)((0, recase_1.recase)(null, 'camel', (0, escapeIdentifier_1.escapeIdentifier)(f.name))),
         jsType: (0, jsTypeForAirtableType_1.jsTypeForAirtableType)(f),
     }));

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.0",
+  "version": "2.1.0",
   "description": "Autogenerate TypeScript definitions for your Airtable base",
   "license": "MIT",
   "author": "Adam Jones (domdomegg)",