@shushed/helpers 0.0.258 → 0.0.259

package/dist/cjs/src-public/airtable.js

@@ -39,6 +39,23 @@ class AirtableHelper extends runtime_1.default {
         });
         return nextObj;
     }
+    static translateFieldsAll(dictionary, y) {
+        const mappedFieldIds = new Set(Object.values(dictionary));
+        const nextFields = {};
+        for (const k in dictionary) {
+            const v = dictionary[k];
+            nextFields[k] = y.fields[v];
+        }
+        for (const fieldId in y.fields) {
+            if (!mappedFieldIds.has(fieldId)) {
+                nextFields[fieldId] = y.fields[fieldId];
+            }
+        }
+        const nextObj = Object.assign({}, y, {
+            fields: nextFields
+        });
+        return nextObj;
+    }
     async createIfNotExist(payload) {
         const existingRecord = await this.getExistingRecord(payload);
         if (!existingRecord) {
@@ -257,18 +274,21 @@ class AirtableHelper extends runtime_1.default {
             throw new Error(`Failed to obtain records with the id: ${id} from the ${this.tableId} table and the baseId ${this.baseId}. Status Code: ${responseRecords?.status || 'unknown'}. Error: ${err.message}`);
         }
     }
-    async getExistingRecords(formula = '') {
+    async getExistingRecords(formula, options) {
         const allRecords = [];
         let offset = undefined;
         const tableUrl = `https://api.airtable.com/v0/${this.baseId}/${this.tableId}/listRecords`;
+        const fetchAllFields = options?.fetchAllFields === true;
         do {
             let responseRecords = null;
             const params = {
-                filterByFormula: formula,
+                filterByFormula: formula || '',
                 pageSize: 100,
                 returnFieldsByFieldId: true,
-                fields: Object.values(this.dictionary).filter((x, idx, arr) => arr.indexOf(x) === idx),
             };
+            if (!fetchAllFields) {
+                params.fields = Object.values(this.dictionary).filter((x, idx, arr) => arr.indexOf(x) === idx);
+            }
             if (offset) {
                 params.offset = `${offset}`;
             }
@@ -295,9 +315,12 @@ class AirtableHelper extends runtime_1.default {
                 throw new Error(`Failed to obtain records ${formulaMsg} from the ${this.tableId} table and the baseId ${this.baseId}. Status Code: ${responseRecords?.status || 'unknown'}. Error: ${err.message}`);
             }
         } while (offset);
+        if (fetchAllFields) {
+            return allRecords.map(x => AirtableHelper.translateFieldsAll(this.dictionary, x));
+        }
         return allRecords.map(x => AirtableHelper.translateFields(this.dictionary, x));
     }
-    async getExistingRecordsByKeys(keys) {
+    async getExistingRecordsByKeys(keys, options) {
         const result = new Map();
         if (keys.length === 0) {
             return result;
@@ -311,7 +334,7 @@ class AirtableHelper extends runtime_1.default {
             const batch = dedupedKeys.slice(i, i + batchSize);
             const orConditions = batch.map(key => `${this.dictionary[this.primaryKeyFieldName]} = "${escapeFormulaValue(key)}"`).join(', ');
             const formula = `OR(${orConditions})`;
-            const records = await this.getExistingRecords(formula);
+            const records = await this.getExistingRecords(formula, options);
             for (const record of records) {
                 const key = record.fields[this.primaryKeyFieldName];
                 result.set(key, record);
@@ -685,5 +708,129 @@ class AirtableHelper extends runtime_1.default {
         const notSameImage = ([key, value]) => !(value && Array.isArray(value) && value.every(x => x && typeof x === 'object' && Object.keys(x).length === 1 && x.url && y.fields[key]?.some((y) => y.url === x.url)));
         return Object.fromEntries(Object.entries(x).filter(([key, value]) => notUndefinedAndNotClearsUndefined([key, value]) && notEqual([key, value]) && notSameImage([key, value])));
     }
+    async getTableFields(tableId) {
+        const targetTableId = tableId || this.tableId;
+        const fields = await this.getTableFieldsFull(targetTableId);
+        const result = {};
+        for (const field of fields) {
+            result[field.id] = field.name;
+        }
+        return result;
+    }
+    async getTableFieldsFull(tableId) {
+        let response = null;
+        const url = `https://api.airtable.com/v0/meta/bases/${this.baseId}/tables`;
+        try {
+            response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => `${response?.status || 'unknown'}`);
+                throw new Error(text);
+            }
+            const data = await response.json();
+            const table = data.tables.find(t => t.id === tableId);
+            if (!table) {
+                throw new Error(`Table ${tableId} not found in base ${this.baseId}`);
+            }
+            return table.fields;
+        }
+        catch (err) {
+            throw new Error(`Failed to get table fields for ${tableId} in base ${this.baseId}. Status Code: ${response?.status || 'unknown'}. Error: ${err.message}`);
+        }
+    }
+    async upsertFields(fields, options) {
+        const defaultLimitter = { run: (x) => x() };
+        const limitter = options?.limitter || defaultLimitter;
+        const targetTableId = this.tableId;
+        const existingFields = await limitter.run(() => this.getTableFieldsFull(targetTableId));
+        const existingByName = new Map();
+        for (const field of existingFields) {
+            existingByName.set(field.name, field);
+        }
+        const result = {};
+        for (const field of fields) {
+            const existing = existingByName.get(field.name);
+            if (existing) {
+                let hasChanged = false;
+                for (const key of Object.keys(field)) {
+                    if (field[key] !== undefined && !(0, lodash_isequal_1.default)(field[key], existing[key])) {
+                        hasChanged = true;
+                        break;
+                    }
+                }
+                if (hasChanged) {
+                    const updated = await limitter.run(() => this.updateField(targetTableId, existing.id, field));
+                    result[updated.name] = updated.id;
+                }
+                else {
+                    result[existing.name] = existing.id;
+                }
+            }
+            else {
+                if (!field.type) {
+                    throw new Error(`Cannot create field "${field.name}": type is required for new fields`);
+                }
+                const created = await limitter.run(() => this.createField(targetTableId, field));
+                result[created.name] = created.id;
+            }
+        }
+        return result;
+    }
+    async createField(tableId, field) {
+        let response = null;
+        const url = `https://api.airtable.com/v0/meta/bases/${this.baseId}/tables/${tableId}/fields`;
+        try {
+            response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(field),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => `${response?.status || 'unknown'}`);
+                throw new Error(text);
+            }
+            return await response.json();
+        }
+        catch (err) {
+            throw new Error(`Failed to create field "${field.name}" in table ${tableId}, base ${this.baseId}. Status Code: ${response?.status || 'unknown'}. Error: ${err.message}`);
+        }
+    }
+    async updateField(tableId, fieldId, field) {
+        let response = null;
+        const url = `https://api.airtable.com/v0/meta/bases/${this.baseId}/tables/${tableId}/fields/${fieldId}`;
+        const payload = {};
+        if (field.name !== undefined)
+            payload.name = field.name;
+        if (field.description !== undefined)
+            payload.description = field.description;
+        if (Object.keys(payload).length === 0) {
+            return { id: fieldId, name: field.name || '', type: '' };
+        }
+        try {
+            response = await fetch(url, {
+                method: 'PATCH',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+            });
+            if (!response.ok) {
+                const text = await response.text().catch(() => `${response?.status || 'unknown'}`);
+                throw new Error(text);
+            }
+            return await response.json();
+        }
+        catch (err) {
+            throw new Error(`Failed to update field "${fieldId}" in table ${tableId}, base ${this.baseId}. Status Code: ${response?.status || 'unknown'}. Error: ${err.message}`);
+        }
+    }
 }
 exports.default = AirtableHelper;

package/dist/types/src-public/airtable.d.ts

@@ -29,6 +29,13 @@ declare class AirtableHelper<T extends Record<string, string>, K extends keyof T
             [key in keyof T]: any;
         };
     };
+    static translateFieldsAll<T extends Record<string, string>, S extends {
+        fields: Record<string, any>;
+    }>(dictionary: T, y: S): S & {
+        fields: {
+            [key in keyof T]: any;
+        } & Record<string, any>;
+    };
     createIfNotExist(payload: Partial<{
         [key in keyof T]: any;
     }> & {
@@ -101,17 +108,21 @@ declare class AirtableHelper<T extends Record<string, string>, K extends keyof T
             [key in keyof T]: any;
         };
     }>;
-    getExistingRecords(formula?: string): Promise<Array<{
+    getExistingRecords(formula?: string, options?: {
+        fetchAllFields?: boolean;
+    }): Promise<Array<{
         id: string;
         fields: {
             [key in keyof T]: any;
-        };
+        } & (Record<string, any>);
     }>>;
-    getExistingRecordsByKeys(keys: Array<string>): Promise<Map<string, {
+    getExistingRecordsByKeys(keys: Array<string>, options?: {
+        fetchAllFields?: boolean;
+    }): Promise<Map<string, {
         id: string;
         fields: {
             [key in keyof T]: any;
-        };
+        } & (Record<string, any>);
     }>>;
     pingWebhook(webhook: {
         webhook: {
@@ -180,6 +191,20 @@ declare class AirtableHelper<T extends Record<string, string>, K extends keyof T
     }>(x: T1, y: T2 | null | undefined): {
         [k: string]: any;
     };
+    getTableFields(tableId?: string): Promise<Record<string, string>>;
+    private getTableFieldsFull;
+    upsertFields(fields: Array<{
+        name: string;
+        type?: string;
+        description?: string;
+        options?: Record<string, any>;
+    }>, options?: {
+        limitter?: {
+            run: <T>(fn: () => Promise<T>) => Promise<T>;
+        };
+    }): Promise<Record<string, string>>;
+    private createField;
+    private updateField;
 }
 export default AirtableHelper;
 type AirtableWebhook = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.258",
+  "version": "0.0.259",
   "author": "",
   "license": "UNLICENSED",
   "description": "",