@shushed/helpers 0.0.202-bug-erp-770-20251203154745 → 0.0.202-main-20251208111718

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

@@ -0,0 +1,207 @@
+"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 runtime_1 = __importDefault(require("./runtime"));
+const utils_1 = require("./utils");
+async function gcpFetch(url, accessToken, options = {}) {
+    let res;
+    try {
+        res = await fetch(url, {
+            ...options,
+            headers: {
+                ...(options.headers || {}),
+                'Authorization': `Bearer ${accessToken}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!res.ok) {
+            const err = new Error(`GCP API error: ${res.status} ${res.statusText}`);
+            const body = await res.json().catch(() => ({
+                code: res.status,
+            }));
+            console.error('error', body);
+            err.message = body.error?.message || err.message;
+            err.code = body.error?.code || res.status;
+            throw err;
+        }
+    }
+    catch (err) {
+        const nextErr = Error(`GCP API error: ${err.message}`);
+        nextErr.code = err.code;
+        throw nextErr;
+    }
+    return res.json();
+}
+class CloudTasksHelper extends runtime_1.default {
+    projectId;
+    serviceAccount;
+    accessToken;
+    envName;
+    workflowId;
+    triggerId;
+    location = 'europe-west2';
+    constructor(opts) {
+        super(opts);
+        this.projectId = opts.projectId;
+        this.serviceAccount = opts.serviceAccount;
+        this.accessToken = opts.accessToken;
+        this.envName = opts.envName;
+        this.workflowId = opts.workflowId;
+        this.triggerId = opts.triggerId;
+    }
+    getQueueName(topicName) {
+        const infraPrefix = topicName.indexOf('---') !== -1 ? topicName : `${this.envName}---${topicName}-${crypto_1.default.createHash('sha256').update(this.triggerId).digest('hex').slice(0, 8)}`;
+        return `${infraPrefix}-${(0, utils_1.shortHash)(this.triggerId)}`;
+    }
+    getQueuePath(topicName) {
+        return `projects/${this.projectId}/locations/${this.location}/queues/${this.getQueueName(topicName)}`;
+    }
+    getQueueApiUrl(topicName) {
+        return `https://cloudtasks.googleapis.com/v2/${this.getQueuePath(topicName)}`;
+    }
+    getLocationApiUrl() {
+        return `https://cloudtasks.googleapis.com/v2/projects/${this.projectId}/locations/${this.location}`;
+    }
+    async getQueue(topicName) {
+        try {
+            const result = await gcpFetch(this.getQueueApiUrl(topicName), this.accessToken, { method: 'GET' });
+            return result;
+        }
+        catch (err) {
+            console.error('error code', err.code);
+            if (err.code === 5 || err.message?.includes('notFound') || err.code === 404) {
+                return null;
+            }
+            ;
+            throw err;
+        }
+    }
+    async createOrUpdateQueue(topicName, retryConfig = {
+        maxAttempts: 1,
+        maxRetryDuration: '60s',
+        minBackoff: '1s',
+        maxBackoff: '30s',
+        maxDoublings: 3,
+    }, rateLimits = {
+        maxDispatchesPerSecond: 20,
+        maxConcurrentDispatches: 1,
+    }) {
+        const queuePath = this.getQueuePath(topicName);
+        const queueApiUrl = this.getQueueApiUrl(topicName);
+        const locationApiUrl = this.getLocationApiUrl();
+        const queueConfig = {
+            name: queuePath,
+            retryConfig: retryConfig || { maxAttempts: 1 },
+            rateLimits: rateLimits || undefined,
+        };
+        const queue = await this.getQueue(topicName);
+        if (!queue) {
+            await gcpFetch(`${locationApiUrl}/queues`, this.accessToken, {
+                method: 'POST',
+                body: JSON.stringify(queueConfig),
+            });
+        }
+        else if ((retryConfig && (queue.retryConfig?.maxAttempts !== retryConfig.maxAttempts ||
+            queue.retryConfig?.maxRetryDuration !== retryConfig.maxRetryDuration ||
+            queue.retryConfig?.minBackoff !== retryConfig.minBackoff ||
+            queue.retryConfig?.maxBackoff !== retryConfig.maxBackoff ||
+            queue.retryConfig?.maxDoublings !== retryConfig.maxDoublings)) ||
+            (rateLimits && ((queue.rateLimits?.maxDispatchesPerSecond !== rateLimits.maxDispatchesPerSecond) ||
+                queue.rateLimits?.maxConcurrentDispatches !== rateLimits.maxConcurrentDispatches))) {
+            await gcpFetch(queueApiUrl, this.accessToken, {
+                method: 'PATCH',
+                body: JSON.stringify(queueConfig),
+            });
+        }
+    }
+    async listTasks(topicName) {
+        const url = `${this.getQueueApiUrl(topicName)}/tasks`;
+        const res = await gcpFetch(url, this.accessToken, { method: 'GET' });
+        return res.tasks || [];
+    }
+    async deleteTask(taskName) {
+        const url = `https://cloudtasks.googleapis.com/v2/${taskName}`;
+        await gcpFetch(url, this.accessToken, { method: 'DELETE' }).catch(err => {
+            if (err.code === 404 || err.code === 6)
+                return;
+            throw err;
+        });
+    }
+    async create(opts) {
+        const queuePath = this.getQueuePath(opts.topicName);
+        if (opts.deleteExistingTasks) {
+            const tasks = await this.listTasks(opts.topicName);
+            await Promise.allSettled(tasks.map(async (task) => {
+                try {
+                    await this.deleteTask(task.name);
+                }
+                catch (err) {
+                    if (err.code !== 5)
+                        throw err;
+                }
+            }));
+        }
+        const repeat = opts.repeatCount || 1;
+        const scheduleSeconds = opts.scheduleSeconds || 0;
+        const createdTaskNames = [];
+        for (let i = 0; i < repeat; i++) {
+            const scheduledDate = scheduleSeconds ? new Date(Date.now() + 1000 * scheduleSeconds * (i + 1)) : new Date();
+            const taskId = opts.doNotCreateIfExists ? crypto_1.default.createHash('sha256').update(opts.doNotCreateIfExists + (Object.entries(opts.extraQuery || {}).sort().map(x => x.join('=')).join('&'))).digest('hex').slice(0, 8) : undefined;
+            const scheduleTime = scheduleSeconds ? scheduledDate.toISOString() : undefined;
+            const httpRequest = {
+                httpMethod: opts.httpTarget.httpMethod || 'POST',
+                url: opts.httpTarget.uri || this.runtimeUrl + `/executeWorkflow/${this.workflowId}/${this.triggerId}?cloud_task=${opts.topicName}&schedule_time=${scheduledDate.toISOString()}&${new URLSearchParams(opts.extraQuery).toString()}`,
+                headers: opts.httpTarget.headers || {
+                    'Content-Type': 'application/json',
+                    'User-Agent': 'CloudTasks-Google',
+                },
+                body: opts.httpTarget.body ? Buffer.from(JSON.stringify(opts.httpTarget.body)).toString('base64') : undefined,
+                oidcToken: {
+                    serviceAccountEmail: this.serviceAccount,
+                    audience: process.env.GCLOUD_PROJECT + "/" + this.triggerId,
+                },
+            };
+            try {
+                const url = `${this.getQueueApiUrl(opts.topicName)}/tasks`;
+                const body = {
+                    task: {
+                        name: taskId ? `${queuePath}/tasks/${taskId}` : undefined,
+                        scheduleTime: scheduleTime ? scheduleTime : undefined,
+                        httpRequest,
+                    },
+                };
+                const res = await gcpFetch(url, this.accessToken, {
+                    method: 'POST',
+                    body: JSON.stringify(body),
+                });
+                if (res.name) {
+                    createdTaskNames.push(res.name);
+                }
+            }
+            catch (err) {
+                if (err.code === 5)
+                    return false;
+                if ((err.code === 6 || err.code === 409) && opts.doNotCreateIfExists)
+                    return false;
+                throw err;
+            }
+        }
+        return createdTaskNames;
+    }
+    async delete(topicName) {
+        const queueApiUrl = this.getQueueApiUrl(topicName);
+        try {
+            await gcpFetch(queueApiUrl, this.accessToken, { method: 'DELETE' });
+            return true;
+        }
+        catch (err) {
+            if (err.code === 5 || err.code === 404)
+                return false;
+            throw err;
+        }
+    }
+}
+exports.default = CloudTasksHelper;