@shushed/helpers 0.0.202 → 0.0.203-bug-erp-770-20251208112219

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

@@ -1,625 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const crypto_1 = __importDefault(require("crypto"));
-const lodash_isequal_1 = __importDefault(require("lodash.isequal"));
-const runtime_1 = __importDefault(require("./runtime"));
-class AirtableHelper extends runtime_1.default {
-    baseId;
-    tableId;
-    apiKey;
-    dictionary;
-    primaryKeyFieldName;
-    primaryKeyWritable = true;
-    constructor(opts, airtableOpts) {
-        super(opts);
-        this.baseId = airtableOpts.baseId;
-        this.tableId = airtableOpts.tableId;
-        this.apiKey = airtableOpts.apiKey;
-        this.primaryKeyFieldName = airtableOpts.primaryKeyFieldName;
-        this.dictionary = airtableOpts.dictionary;
-        if (typeof airtableOpts.primaryKeyWritable !== 'undefined') {
-            this.primaryKeyWritable = airtableOpts.primaryKeyWritable;
-        }
-    }
-    static translateFields(dictionary, y) {
-        const nextFields = {};
-        for (const k in dictionary) {
-            const v = dictionary[k];
-            nextFields[k] = y.fields[v];
-        }
-        const nextObj = Object.assign({}, y, {
-            fields: nextFields
-        });
-        return nextObj;
-    }
-    async createIfNotExist(payload) {
-        const existingRecord = await this.getExistingRecord(payload);
-        if (!existingRecord) {
-            return this.createRecord(this.primaryKeyWritable === false ? AirtableHelper.removePrimaryKey(payload, this.primaryKeyFieldName) : payload);
-        }
-        return existingRecord;
-    }
-    async updateMultiple(payload, options = {}, callIdx = 0, collectedResult = {
-        updatedRecords: [],
-        createdRecords: [],
-        records: []
-    }) {
-        let response = null;
-        const tableUrl = `https://api.airtable.com/v0/${this.baseId}/${this.tableId}`;
-        const currentBatch = payload.slice(callIdx * 10, (callIdx + 1) * 10);
-        try {
-            response = await fetch(`${tableUrl}`, {
-                method: "PATCH",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    performUpsert: {
-                        fieldsToMergeOn: (options.fieldsToMergeOn ?? [this.primaryKeyFieldName]).map(x => this.dictionary[x] || x),
-                    },
-                    returnFieldsByFieldId: true,
-                    records: currentBatch.map(x => {
-                        const recordId = x.$recordId;
-                        const fieldsWithoutRecordId = { ...x };
-                        delete fieldsWithoutRecordId.$recordId;
-                        const record = {
-                            fields: AirtableHelper.convertToDictionary(this.dictionary, this.primaryKeyWritable === false
-                                ? AirtableHelper.removePrimaryKey(fieldsWithoutRecordId, this.primaryKeyFieldName)
-                                : fieldsWithoutRecordId),
-                        };
-                        if (recordId) {
-                            record.id = recordId;
-                        }
-                        return record;
-                    })
-                }),
-            });
-            if (!response.ok && response) {
-                const text = await response.text().catch(() => `${response?.status || 'unknown'}`);
-                throw new Error(text);
-            }
-            const resp = (await response.json());
-            const nextCollectedResult = {
-                updatedRecords: collectedResult.updatedRecords.concat(resp.updatedRecords),
-                createdRecords: collectedResult.createdRecords.concat(resp.createdRecords),
-                records: collectedResult.records.concat(resp.records.map(x => AirtableHelper.translateFields(this.dictionary, x)))
-            };
-            if (payload.length > (callIdx + 1) * 10) {
-                return this.updateMultiple(payload, options, callIdx + 1, nextCollectedResult);
-            }
-            return nextCollectedResult;
-        }
-        catch (err) {
-            const errorMessage = `Failed to update records in ${this.tableId} table (baseId: ${this.baseId}). Status: ${response?.status || 'unknown'}. Error: ${err.message}`;
-            const batchErrors = currentBatch.map(() => new Error(errorMessage));
-            const nextCollectedResult = {
-                updatedRecords: collectedResult.updatedRecords,
-                createdRecords: collectedResult.createdRecords,
-                records: collectedResult.records.concat(batchErrors)
-            };
-            if (payload.length > (callIdx + 1) * 10) {
-                return this.updateMultiple(payload, options, callIdx + 1, nextCollectedResult);
-            }
-            return nextCollectedResult;
-        }
-    }
-    async upsert(payload) {
-        const existingRecord = await this.getExistingRecord(payload);
-        if (existingRecord) {
-            return this.updateRecord(existingRecord.id, payload);
-        }
-        else {
-            return this.createRecord(this.primaryKeyWritable === false ? AirtableHelper.removePrimaryKey(payload, this.primaryKeyFieldName) : payload);
-        }
-    }
-    static removePrimaryKey(x, primaryKeyFieldId) {
-        delete x[primaryKeyFieldId];
-        return x;
-    }
-    static convertToDictionary(dictionary, x) {
-        const nextObj = {};
-        for (const k in x) {
-            if (typeof x[k] !== 'undefined' && dictionary[k]) {
-                nextObj[dictionary[k]] = x[k];
-            }
-        }
-        return nextObj;
-    }
-    async createRecord(payload) {
-        let response = null;
-        const tableUrl = `https://api.airtable.com/v0/${this.baseId}/${this.tableId}`;
-        try {
-            response = await fetch(`${tableUrl}`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    typecast: true,
-                    returnFieldsByFieldId: true,
-                    fields: AirtableHelper.convertToDictionary(this.dictionary, this.primaryKeyWritable === false ? AirtableHelper.removePrimaryKey(payload, this.primaryKeyFieldName) : payload),
-                }),
-            });
-            if (!response.ok && response) {
-                const text = await response.text().catch(() => `${response?.status || 'unknown'}`);
-                throw new Error(text);
-            }
-            const resp = await response.json();
-            return AirtableHelper.translateFields(this.dictionary, resp);
-        }
-        catch (err) {
-            throw new Error(`Failed to create record in the ${this.tableId} table and the baseId ${this.baseId}. Status Code: ${response?.status}. Error: ${err.message}`);
-        }
-    }
-    async updateRecord(recordId, payload) {
-        let response = null;
-        const tableUrl = `https://api.airtable.com/v0/${this.baseId}/${this.tableId}`;
-        try {
-            response = await fetch(`${tableUrl}/${recordId}`, {
-                method: "PATCH",
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-                body: JSON.stringify({
-                    typecast: true,
-                    returnFieldsByFieldId: true,
-                    fields: AirtableHelper.removePrimaryKey(AirtableHelper.convertToDictionary(this.dictionary, payload), this.dictionary[this.primaryKeyFieldName]),
-                }),
-            });
-            if (!response.ok && response) {
-                const text = await response.text().catch(() => `${response?.status || 'unknown'}`);
-                throw new Error(text);
-            }
-            const resp = await response.json();
-            return AirtableHelper.translateFields(this.dictionary, resp);
-        }
-        catch (err) {
-            throw new Error(`Failed to update record: ${recordId} in the ${this.tableId} table and the baseId ${this.baseId} with payload ${JSON.stringify(payload)}. Status Code: ${response?.status || 'unknown'}. Error: ${err.message}`);
-        }
-    }
-    async getExistingRecord(payload) {
-        const formula = `${this.dictionary[this.primaryKeyFieldName]} = "${payload[this.primaryKeyFieldName]}"`;
-        return (await this.getExistingRecords(formula))?.[0] || null;
-    }
-    async getExistingRecordById(id) {
-        let responseRecords = null;
-        const tableUrl = `https://api.airtable.com/v0/${this.baseId}/${this.tableId}`;
-        try {
-            responseRecords = await fetch(`${tableUrl}/${id}`, {
-                method: 'GET',
-                headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
-                    "Content-Type": "application/json",
-                },
-            });
-            if (!responseRecords.ok && responseRecords) {
-                const text = await responseRecords.text().catch(() => `${responseRecords?.status || 'unknown'}`);
-                throw new Error(text);
-            }
-            const data = await responseRecords.json();
-            return AirtableHelper.translateFields(this.dictionary, data);
-        }
-        catch (err) {
-            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 = '') {
-        const allRecords = [];
-        let offset = undefined;
-        const tableUrl = `https://api.airtable.com/v0/${this.baseId}/${this.tableId}/listRecords`;
-        do {
-            let responseRecords = null;
-            const params = {
-                filterByFormula: formula,
-                pageSize: 100,
-                returnFieldsByFieldId: true,
-                fields: Object.values(this.dictionary).filter((x, idx, arr) => arr.indexOf(x) === idx),
-            };
-            if (offset) {
-                params.offset = `${offset}`;
-            }
-            try {
-                responseRecords = await fetch(tableUrl, {
-                    method: 'POST',
-                    body: JSON.stringify(params),
-                    headers: {
-                        Authorization: `Bearer ${this.apiKey}`,
-                        "Content-Type": "application/json",
-                    },
-                });
-                if (!responseRecords.ok && responseRecords) {
-                    const text = await responseRecords.text().catch(() => `${responseRecords?.status || 'unknown'}`);
-                    throw new Error(text);
-                }
-                const data = await responseRecords.json();
-                const records = data?.records || [];
-                allRecords.push(...records);
-                offset = data?.offset;
-            }
-            catch (err) {
-                const formulaMsg = formula ? `with the formula ${formula}` : 'from all records';
-                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);
-        return allRecords.map(x => AirtableHelper.translateFields(this.dictionary, x));
-    }
-    async getExistingRecordsByKeys(keys) {
-        const result = new Map();
-        if (keys.length === 0) {
-            return result;
-        }
-        const escapeFormulaValue = (value) => {
-            return value.replace(/"/g, '\\"');
-        };
-        const batchSize = 50;
-        for (let i = 0; i < keys.length; i += batchSize) {
-            const batch = keys.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);
-            for (const record of records) {
-                const key = record.fields[this.primaryKeyFieldName];
-                result.set(key, record);
-            }
-        }
-        return result;
-    }
-    async pingWebhook(webhook) {
-        let resp;
-        try {
-            resp = await fetch(`https://api.airtable.com/v0/bases/${this.baseId}/webhooks/${webhook.webhook.id}/payloads`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': 'Bearer ' + this.apiKey,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                },
-            });
-            if (!resp.ok) {
-                const text = await resp.text().catch(_e => `${resp.statusText || resp.status}`);
-                this.logging.error(`Requesting notification from the webhookId: ${webhook.webhook.id} failed`, text);
-                throw new Error(text);
-            }
-        }
-        catch (err) {
-            this.logging.error('Failed to ping airtable webhook with message: ', err.message);
-        }
-        return;
-    }
-    async getPayloads(opts) {
-        let resp;
-        let unprocessedResult = null;
-        let nextToProcess = null;
-        let collectedRecords = [];
-        const urlParsed = new URL(opts.url);
-        urlParsed.searchParams.set('returnFieldsByFieldId', '1');
-        this.logging.log(`Fetching records from ${urlParsed.toString()}`);
-        try {
-            resp = await fetch(`${urlParsed.toString()}`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': 'Bearer ' + this.apiKey,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                },
-            });
-            if (!resp.ok) {
-                const text = await resp.text().catch(_e => `${resp.statusText || resp.status}`);
-                throw new Error(text);
-            }
-            const res = await resp.json();
-            if (!res.fields && res.offset) {
-                const nextUrl = new URL(opts.url);
-                nextUrl.searchParams.set('offset', res.offset);
-                nextToProcess = {
-                    url: nextUrl.toString()
-                };
-            }
-            if (!res.fields && res.records) {
-                collectedRecords = res.records.map((x) => AirtableHelper.translateFields(this.dictionary, x));
-            }
-            else if (res.fields) {
-                collectedRecords.push(AirtableHelper.translateFields(this.dictionary, res));
-            }
-            this.logging.log(`Collected ${collectedRecords.length} records`);
-        }
-        catch (err) {
-            this.logging.error(`Requesting notification from the table: ${this.tableId} failed`, err.message);
-            unprocessedResult = {
-                url: opts.url,
-                $$error: err.message
-            };
-        }
-        return {
-            result: collectedRecords,
-            unprocessed: unprocessedResult,
-            nextToProcess: nextToProcess
-        };
-    }
-    async listPayloads(input, startingCursor) {
-        this.logging.log(`Requesting notification from the webhookId: ${JSON.stringify(input)} of type ${typeof input} with cursor: ${startingCursor}`);
-        let unprocessedResult = null;
-        let nextToProcess = null;
-        let collectedRecords = [];
-        let resp = null;
-        try {
-            resp = await fetch(`https://api.airtable.com/v0/bases/${this.baseId}/webhooks/${input.webhook.id}/payloads`, {
-                method: 'GET',
-                headers: {
-                    'Authorization': 'Bearer ' + this.apiKey,
-                    'Content-Type': 'application/json',
-                    'Accept': 'application/json',
-                },
-            });
-            if (!resp.ok) {
-                const text = await resp.text().catch(_e => `${resp.statusText || resp.status}`);
-                this.logging.error(`Requesting notification from the webhookId: ${input.webhook.id} failed`, text);
-                throw new Error(text);
-            }
-        }
-        catch (e) {
-            unprocessedResult = {
-                webhook: {
-                    id: input.webhook.id
-                }
-            };
-        }
-        let nextCursor = null;
-        if (!unprocessedResult) {
-            const res = (await resp.json());
-            nextCursor = res.cursor;
-            this.logging.log(`Received ${res.payloads.length} records from the table: ${this.tableId}.`);
-            for (const payload of res.payloads) {
-                const changes = payload.changedTablesById[this.tableId];
-                const airtableCreated = Object.entries(changes?.createdRecordsById || {}).map(([k, v]) => ({
-                    id: k,
-                    fields: AirtableHelper.translateFields(this.dictionary, { fields: (v.cellValuesByFieldId || {}) }).fields,
-                    created_at: v.createdTime || payload.timestamp,
-                    last_modified_at: v.createdTime || payload.timestamp,
-                    previous_fields: null
-                }));
-                const airtableChanged = Object.entries(changes?.changedRecordsById || {}).map(([k, v]) => ({
-                    id: k,
-                    fields: AirtableHelper.translateFields(this.dictionary, {
-                        fields: Object.assign({}, v.unchanged?.cellValuesByFieldId, v.current?.cellValuesByFieldId)
-                    }).fields,
-                    last_modified_at: payload.timestamp
-                }));
-                const airtableDestroyed = (changes?.destroyedRecordIds || []).map((x) => {
-                    return {
-                        id: x,
-                        fields: {},
-                        last_modified_at: payload.timestamp,
-                        deleted_at: payload.timestamp
-                    };
-                });
-                collectedRecords = collectedRecords.concat(airtableCreated, airtableChanged, airtableDestroyed);
-            }
-            if (res['mightHaveMore']) {
-                this.logging.log(`The response might have next page. Last cursor: ${res['cursor']}`);
-                nextToProcess = {
-                    webhook: {
-                        id: input.webhook.id
-                    },
-                };
-            }
-        }
-        return {
-            cursor: nextCursor || startingCursor,
-            result: collectedRecords,
-            unprocessed: unprocessedResult,
-            nextToProcess: nextToProcess
-        };
-    }
-    async getWebhooks() {
-        const url = `https://api.airtable.com/v0/bases/${this.baseId}/webhooks`;
-        const options = {
-            method: 'GET',
-            headers: { authorization: 'Bearer ' + this.apiKey }
-        };
-        try {
-            const response = await fetch(url, options);
-            if (!response.ok) {
-                throw new Error(`Invalid response: ${await response.text().catch(() => response.status)}`);
-            }
-            const data = await response.json();
-            return data.webhooks;
-        }
-        catch (error) {
-            this.logging.error(`Failed to fetch existing subscriptions. with the error: ${error.message}`, url, options);
-            throw new Error(`Failed to fetch existing subscriptions. with the error: ${error.message}`);
-        }
-    }
-    async enableOrPauseWebhook({ webhookId, pause }) {
-        const url = `https://api.airtable.com/v0/bases/${this.baseId}/webhooks/${webhookId}/enableNotifications`;
-        const options = {
-            method: 'POST',
-            headers: { authorization: 'Bearer ' + this.apiKey, 'Content-Type': 'application/json; charset=UTF-8' },
-            body: JSON.stringify({
-                enable: !pause
-            })
-        };
-        try {
-            const response = await fetch(url, options);
-            if (!response.ok) {
-                throw new Error(`Invalid response: ${await response.text().catch(() => response.status)}`);
-            }
-            const data = await response.json();
-            return data;
-        }
-        catch (error) {
-            this.logging.error(`Failed to create subscriptions. with the error: ${error.message}`, url, options);
-            throw new Error(`Failed to create subscriptions. with the error: ${error.message}`);
-        }
-    }
-    async pause() {
-        const wh = await this.getWebhook();
-        if (wh) {
-            return this.enableOrPauseWebhook({
-                webhookId: wh.id,
-                pause: true
-            }).then((wh) => ({
-                webhookId: wh.id,
-            }));
-        }
-        return {
-            webhookId: null
-        };
-    }
-    async resume() {
-        const wh = await this.getWebhook();
-        if (wh) {
-            return this.enableOrPauseWebhook({
-                webhookId: wh.id,
-                pause: false
-            }).then((wh) => ({
-                webhookId: wh.id,
-            }));
-        }
-        return {
-            webhookId: null
-        };
-    }
-    async getWebhook() {
-        const webhooks = await this.getWebhooks();
-        for (const x of webhooks) {
-            if (x.notificationUrl === this.createNotificationUrl()) {
-                return x;
-            }
-        }
-        return null;
-    }
-    createNotificationUrl() {
-        return `${this.runtimeUrl}/executeWorkflow/${this.workflowId}/${this.triggerId}?request-from-airtable=1&baseId=${this.baseId}&tableId=${this.tableId}`;
-    }
-    async isValidSignature(secret, payload, signature) {
-        const macSecretDecoded = Buffer.from(secret, 'base64');
-        const body = Buffer.from(payload, 'utf8');
-        const hmac = crypto_1.default.createHmac('sha256', macSecretDecoded);
-        hmac.update(body.toString(), 'ascii');
-        const expectedContentHmac = 'hmac-sha256=' + hmac.digest('hex');
-        return expectedContentHmac === signature;
-    }
-    async deleteWebhook(x) {
-        if (!x) {
-            const webhooks = await this.getWebhooks();
-            for (const x of webhooks) {
-                if (x.notificationUrl === this.createNotificationUrl()) {
-                    await this.deleteWebhook(x.id);
-                }
-            }
-            return true;
-        }
-        const url = `https://api.airtable.com/v0/bases/${this.baseId}/webhooks/${x}`;
-        try {
-            const response = await fetch(url, {
-                method: 'DELETE',
-                headers: { authorization: `Bearer ${this.apiKey}` },
-            });
-            if (!response.ok) {
-                throw new Error(`${await response.text().catch(() => response.status)}`);
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to delete subscriptions with the error: ${error.message}`);
-        }
-        return true;
-    }
-    async webhookHasChanged() {
-        const existingWebhook = await this.getWebhook();
-        const fieldIds = Object.values(this.dictionary).filter((x, idx, arr) => arr.indexOf(x) === idx);
-        if (existingWebhook?.specification.options.filters.recordChangeScope === this.tableId
-            && (0, lodash_isequal_1.default)(existingWebhook?.specification.options.filters.watchDataInFieldIds, fieldIds)
-            && (0, lodash_isequal_1.default)(existingWebhook?.specification.options.includes?.includeCellValuesInFieldIds, fieldIds)
-            && existingWebhook.specification.options.includes?.includePreviousCellValues) {
-            return false;
-        }
-        return true;
-    }
-    async updateOrCreateWebhook() {
-        const existingWebhook = await this.getWebhook();
-        const fieldIds = Object.values(this.dictionary).filter((x, idx, arr) => arr.indexOf(x) === idx);
-        if (existingWebhook?.specification.options.filters.recordChangeScope === this.tableId
-            && (0, lodash_isequal_1.default)(existingWebhook?.specification.options.filters.watchDataInFieldIds, fieldIds)
-            && (0, lodash_isequal_1.default)(existingWebhook?.specification.options.includes?.includeCellValuesInFieldIds, fieldIds)
-            && existingWebhook.specification.options.includes?.includePreviousCellValues) {
-            return existingWebhook;
-        }
-        await this.deleteWebhook(existingWebhook?.id);
-        const url = `https://api.airtable.com/v0/bases/${this.baseId}/webhooks`;
-        const options = {
-            method: 'POST',
-            headers: { authorization: 'Bearer ' + this.apiKey, 'Content-Type': 'application/json; charset=UTF-8' },
-            body: JSON.stringify({
-                notificationUrl: this.createNotificationUrl(),
-                specification: {
-                    options: {
-                        filters: {
-                            dataTypes: ["tableData"],
-                            recordChangeScope: this.tableId,
-                            watchDataInFieldIds: fieldIds,
-                        },
-                        includes: {
-                            includePreviousCellValues: true,
-                            includeCellValuesInFieldIds: fieldIds
-                        }
-                    },
-                }
-            })
-        };
-        try {
-            const response = await fetch(url, options);
-            if (!response.ok) {
-                throw new Error(`Invalid response: ${await response.text().catch(() => response.status)}`);
-            }
-            const data = await response.json();
-            return data;
-        }
-        catch (error) {
-            this.logging.error(`Failed to create subscriptions. with the error: ${error.message}`, url, options);
-            throw new Error(`Failed to create subscriptions. with the error: ${error.message}`);
-        }
-    }
-    replaceAirtableFields(formula) {
-        const fieldNamesInFormula = [];
-        const fieldNameRegex = /\{([^}]+)\}/g;
-        let match;
-        while ((match = fieldNameRegex.exec(formula)) !== null) {
-            const fieldName = match[1].trim();
-            if (!fieldNamesInFormula.includes(fieldName)) {
-                fieldNamesInFormula.push(fieldName);
-            }
-        }
-        const missingFields = [];
-        const replacedFields = [];
-        const replacedFormula = formula.replace(fieldNameRegex, (fullMatch, inner) => {
-            const fieldName = String(inner).trim();
-            const fieldId = this.dictionary[fieldName];
-            if (fieldId) {
-                if (!replacedFields.includes(fieldName)) {
-                    replacedFields.push(fieldName);
-                }
-                return `{${fieldId}}`;
-            }
-            else {
-                if (!missingFields.includes(fieldName)) {
-                    missingFields.push(fieldName);
-                }
-                return fullMatch;
-            }
-        });
-        return {
-            replacedFormula,
-            usedFields: fieldNamesInFormula,
-            replacedFields,
-            missingFields,
-        };
-    }
-}
-exports.default = AirtableHelper;