airtable-ts-codegen 1.1.0 → 1.3.0

package/dist/cli.js

@@ -4,13 +4,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const fs_1 = require("fs");
 const _1 = require(".");
 const escapeIdentifier_1 = require("./escape/escapeIdentifier");
-/* eslint-disable no-console */
 const apiKey = process.env.AIRTABLE_API_KEY;
-if (!apiKey)
+if (!apiKey) {
     throw new Error('No Airtable API key set. Make sure the AIRTABLE_API_KEY environment variable is set.');
+}
 const baseId = process.env.AIRTABLE_BASE_ID;
-if (!baseId)
+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);
+}).catch((err) => {
+    console.error(err);
+    process.exit(1);
 });

package/dist/escape/escapeIdentifier.d.ts

@@ -1,2 +1,10 @@
-/** Used for identifiers. If the name has symbols or is illegal Typescript, strip out symbols and make it PascalCase. */
-export declare const escapeIdentifier: (name: string) => string;
+/**
+ * Used for identifiers:
+ * - If the name is already a valid JS identifier, return it unmodified.
+ * - Otherwise:
+ *   - Remove invalid characters.
+ *   - Convert to PascalCase.
+ *   - If the result starts with a digit, prefix with `_`.
+ * - Returns a default identifier if the identifier cannot be salvaged.
+ */
+export declare function escapeIdentifier(name: string): string;

package/dist/escape/escapeIdentifier.js

@@ -1,41 +1,96 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.escapeIdentifier = void 0;
-const recase_1 = require("@kristiandupont/recase");
+exports.escapeIdentifier = escapeIdentifier;
 const diacritics_1 = require("diacritics");
-const toPascalCase = (0, recase_1.recase)(null, 'pascal');
-/** Used for identifiers. If the name has symbols or is illegal Typescript, strip out symbols and make it PascalCase. */
-// NB: A wider set of things than are accepted by this function are valid identifiers in TypeScript (see https://stackoverflow.com/a/9337047). However, this works well for our purposes.
-const escapeIdentifier = (name) => {
-    const preprocessed = (0, diacritics_1.remove)(name).trim();
-    let isLegalIdentifier = true;
-    if (!/^[$A-Z_a-z][\w$]*$/.test(preprocessed)) {
-        isLegalIdentifier = false;
+let invalidIdentifierCount = 0;
+const DEFAULT_IDENTIFIER = 'invalidIdentifier';
+/**
+ * Checks if 'str' is already a valid JavaScript identifier.
+ * If yes, returns true. Otherwise false.
+ *
+ * - Must conform to JavaScript identifier rules (e.g., no spaces, cannot start with a digit).
+ * - Also dynamically tests against reserved words and invalid usages by attempting declaration.
+ */
+function isValidJsIdentifier(str) {
+    if (!/^[$A-Z_a-z][\w$]*$/.test(str)) {
+        return false;
     }
     try {
-        // eslint-disable-next-line @typescript-eslint/no-implied-eval, no-new
-        new Function(`const ${preprocessed} = 1;`);
+        // Test against reserved words and invalid declarations
+        // eslint-disable-next-line no-new, no-new-func
+        new Function(`const ${str} = 1;`);
+        return true;
     }
     catch {
-        isLegalIdentifier = false;
+        return false;
     }
-    if (isLegalIdentifier) {
-        return preprocessed;
+}
+/**
+ * Converts a string to PascalCase:
+ * - Trims and splits by whitespace.
+ * - Capitalizes the first letter of each token.
+ * Example:
+ *   "hello world" -> "HelloWorld"
+ *   "123 abc" -> "123Abc"
+ */
+function toPascalCase(str) {
+    return str
+        .split(/\s+/)
+        .map((token) => (token ? token[0].toUpperCase() + token.slice(1).toLowerCase() : ''))
+        .join('');
+}
+/**
+ * Used for identifiers:
+ * - If the name is already a valid JS identifier, return it unmodified.
+ * - Otherwise:
+ *   - Remove invalid characters.
+ *   - Convert to PascalCase.
+ *   - If the result starts with a digit, prefix with `_`.
+ * - Returns a default identifier if the identifier cannot be salvaged.
+ */
+function escapeIdentifier(name) {
+    // Normalize string by removing diacritics and trimming whitespace
+    const trimmed = (0, diacritics_1.remove)(name).trim();
+    // If already a valid identifier, return unchanged
+    if (isValidJsIdentifier(trimmed)) {
+        return trimmed;
     }
-    // Remove all characters up to the first valid identifier start character (A-Z, a-z, $), then
-    // replace all invalid characters with underscores, and finally collapse multiple underscores into one.
-    const validIdentifierStartIndex = preprocessed.search(/[$A-Za-z]/);
-    if (validIdentifierStartIndex === -1) {
-        throw new Error(`Invalid and unsalvageable identifier: ${name}`);
+    // Sanitize: Remove invalid characters, preserving letters, numbers, underscores, and spaces for token splitting
+    const sanitized = trimmed
+        .replace(/[^\p{L}\p{N}_\s]+/gu, ' ') // Replace special characters with spaces
+        .replace(/\s+/g, ' ') // Collapse multiple spaces
+        .trim();
+    // Return a default identifier if identifier is purely numeric after sanitization
+    if (/^\d+$/.test(sanitized)) {
+        invalidIdentifierCount += 1;
+        console.warn(`Invalid identifier "${name}" became purely numeric after sanitization ("${sanitized}"). Using default identifier "${DEFAULT_IDENTIFIER}${invalidIdentifierCount}".`);
+        return `${DEFAULT_IDENTIFIER}${invalidIdentifierCount}`;
     }
-    const snaked = preprocessed
-        .slice(validIdentifierStartIndex)
-        .replace(/[^$A-Z_a-z\d]/g, '_')
-        .replace(/_+/g, '_');
-    const result = toPascalCase(snaked);
-    if (result.length === 0) {
-        throw new Error(`Invalid and unsalvageable identifier: ${name}`);
+    // Convert sanitized string to PascalCase
+    let pascal = toPascalCase(sanitized);
+    // If it starts with a digit after conversion, prefix with an underscore
+    if (/^\d/.test(pascal)) {
+        pascal = `_${pascal}`;
     }
-    return result;
-};
-exports.escapeIdentifier = escapeIdentifier;
+    // Final validation to ensure it conforms to JS identifier rules
+    if (!isValidJsIdentifier(pascal)) {
+        // Fallback: Strip all invalid characters, replace with underscores, and re-collapse
+        const validStartIndex = pascal.search(/[$A-Za-z]/);
+        if (validStartIndex === -1) {
+            invalidIdentifierCount += 1;
+            console.warn(`Invalid identifier "${name}" contains no valid starting character after sanitization. Using default identifier "${DEFAULT_IDENTIFIER}${invalidIdentifierCount}".`);
+            return `${DEFAULT_IDENTIFIER}${invalidIdentifierCount}`;
+        }
+        pascal = pascal
+            .slice(validStartIndex)
+            .replace(/[^A-Za-z0-9_$]/g, '_')
+            .replace(/_+/g, '_');
+        pascal = toPascalCase(pascal);
+        if (!isValidJsIdentifier(pascal) || pascal.length === 0) {
+            invalidIdentifierCount += 1;
+            console.warn(`Invalid identifier "${name}" could not be salvaged. Using default identifier "${DEFAULT_IDENTIFIER}${invalidIdentifierCount}".`);
+            return `${DEFAULT_IDENTIFIER}${invalidIdentifierCount}`;
+        }
+    }
+    return pascal;
+}

package/dist/escape/escapeString.js

@@ -2,5 +2,5 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.escapeString = void 0;
 /** Used for single-quoted strings. */
-const escapeString = (str) => str.replace(/'/g, "\\'").replace(/\n/g, '\\n');
+const escapeString = (str) => str.replace(/'/g, '\\\'').replace(/\n/g, '\\n');
 exports.escapeString = escapeString;

package/dist/getBaseSchema.d.ts

@@ -1,4 +1,4 @@
-import { Config } from '.';
+import { type Config } from '.';
 export type FieldSchema = {
     id: string;
     type: string;

package/dist/getBaseSchema.js

@@ -16,7 +16,6 @@ const getBaseSchema = 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,
         },

package/dist/index.d.ts

@@ -1,8 +1,8 @@
-export interface Config {
+export type Config = {
     apiKey: string;
     baseId: string;
     endpointUrl?: string;
     requestTimeout?: number;
     customHeaders?: Record<string, string | number | boolean>;
-}
+};
 export declare const main: (config: Config) => Promise<string>;

package/dist/index.js

@@ -12,26 +12,26 @@ const main = async (config) => {
     return [
         '/* DO NOT EDIT: this file was automatically generated by airtable-ts-codegen */',
         '/* eslint-disable */',
-        "import type { Item, Table } from 'airtable-ts';",
+        'import type { Item, Table } from \'airtable-ts\';',
         '',
         baseSchema.map((tableSchema) => generateCode(config, tableSchema)).join('\n\n'),
     ].join('\n');
 };
 exports.main = main;
 const generateInterfaceEntry = ({ jsName, jsType, name, type }) => {
-    if (jsType == null) {
+    if (jsType === null) {
         return `\n  // Unsupported field ${name} of type ${type}`;
     }
     return `\n  ${jsName}: ${jsType},`;
 };
 const generateMappingEntry = ({ jsName, id, jsType, name }) => {
-    if (jsType == null) {
+    if (jsType === null) {
         return `\n    // Unsupported field ${name}: ${(0, escapeString_1.escapeString)(id)}`;
     }
     return `\n    ${jsName}: '${(0, escapeString_1.escapeString)(id)}',`;
 };
 const generateSchemaEntry = ({ jsName, jsType }) => {
-    if (jsType == null) {
+    if (jsType === null) {
         return null;
     }
     return `\n    ${jsName}: '${(0, escapeString_1.escapeString)(jsType)}',`;

package/dist/jsTypeForAirtableType.d.ts

@@ -1,4 +1,4 @@
-import { FieldSchema } from './getBaseSchema';
+import { type FieldSchema } from './getBaseSchema';
 /**
  * Returns the corresponding Typescript type for the given Airtable field type.
  *

package/dist/jsTypeForAirtableType.js

@@ -16,7 +16,15 @@ const jsTypeForAirtableType = (field) => {
         case 'richText':
         case 'singleSelect':
         case 'externalSyncSource':
+        case 'aiText':
+        case 'singleCollaborator':
+        case 'createdBy':
+        case 'lastModifiedBy':
+        case 'barcode':
+        case 'button':
             return 'string';
+        case 'multipleAttachments':
+        case 'multipleCollaborators':
         case 'multipleRecordLinks':
         case 'multipleSelects':
             return 'string[]';
@@ -42,39 +50,17 @@ const jsTypeForAirtableType = (field) => {
             if (field.options
                 && 'result' in field.options
                 && typeof field.options.result === 'object'
-                && field.options.result != null) {
+                && field.options.result !== null) {
                 const innerType = (0, exports.jsTypeForAirtableType)(field.options.result);
-                if (innerType == null)
+                if (innerType === null) {
                     return null;
+                }
                 return `${innerType} | null`;
             }
             throw new Error(`Invalid ${field.type} field (no options.result): ${field.id}`);
-        // Special cases we don't yet support; for now, skip these fields
-        // case 'aiText':
-        //   return 'AiTextObject';
-        // case 'singleCollaborator':
-        // case 'createdBy':
-        // case 'lastModifiedBy':
-        //   return 'CollaboratorObject';
-        // case 'multipleCollaborators':
-        //   return 'CollaboratorObject[]';
-        // case 'multipleAttachments':
-        //   return 'AttachmentObject[]';
-        // case 'barcode':
-        //   return 'BarcodeObject';
-        // case 'button':
-        //   return 'ButtonObject';
-        case 'aiText':
-        case 'singleCollaborator':
-        case 'createdBy':
-        case 'lastModifiedBy':
-        case 'multipleCollaborators':
-        case 'multipleAttachments':
-        case 'barcode':
-        case 'button':
-            return null;
         default:
-            throw new Error(`Could not convert Airtable type '${field.type}' to a TypeScript type for field ${field.id}`);
+            console.warn(`Could not convert Airtable type '${field.type}' to a TypeScript type for field ${field.id}`);
+            return null;
     }
 };
 exports.jsTypeForAirtableType = jsTypeForAirtableType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "airtable-ts-codegen",
-  "version": "1.1.0",
+  "version": "1.3.0",
   "description": "Autogenerate TypeScript definitions for your Airtable base",
   "license": "MIT",
   "author": "Adam Jones (domdomegg)",
@@ -20,7 +20,7 @@
     "start": "npm run build && node dist/cli.js",
     "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"
@@ -34,25 +34,11 @@
     "@tsconfig/node-lts": "^20.1.3",
     "@types/diacritics": "^1.3.3",
     "@types/node": "^20.12.8",
-    "airtable-ts": "^1.1.0",
-    "eslint": "^8.57.0",
-    "eslint-config-domdomegg": "^1.2.3",
+    "airtable-ts": "^1.4.0",
+    "eslint": "^9.19.0",
+    "eslint-config-domdomegg": "^2.0.8",
     "tsconfig-domdomegg": "^1.0.0",
-    "typescript": "^5.4.4",
-    "vitest": "^1.4.0"
-  },
-  "eslintConfig": {
-    "extends": [
-      "eslint-config-domdomegg"
-    ],
-    "rules": {
-      "object-curly-newline": [
-        "error",
-        {
-          "multiline": true,
-          "consistent": true
-        }
-      ]
-    }
+    "typescript": "^5.7.3",
+    "vitest": "^3.0.7"
   }
 }