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

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

@@ -1,207 +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 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;

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

@@ -1,403 +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 fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const mime_types_1 = require("mime-types");
-const runtime_1 = __importDefault(require("./runtime"));
-class DatoHelper extends runtime_1.default {
-    apiToken;
-    baseUrl;
-    environment;
-    constructor(opts, datoOpts) {
-        super(opts);
-        this.apiToken = datoOpts.apiToken;
-        this.baseUrl = datoOpts.baseUrl || 'https://site-api.datocms.com';
-        this.environment = datoOpts.environment || 'main';
-    }
-    async requestUploadParameters(filename) {
-        const response = await fetch(`${this.baseUrl}/upload-requests`, {
-            method: 'POST',
-            headers: {
-                'X-Api-Version': '3',
-                'X-Environment': this.environment,
-                'Authorization': `Bearer ${this.apiToken}`,
-                'Content-Type': "application/vnd.api+json",
-                'Accept': 'application/json',
-            },
-            body: JSON.stringify({
-                data: {
-                    type: 'upload_request',
-                    attributes: {
-                        filename: filename,
-                    },
-                },
-            }),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            this.logging.error(`Failed to request upload parameters: ${response.statusText} - ${errorText}`);
-            throw new Error(`Failed to request upload parameters: ${response.statusText} - ${errorText}`);
-        }
-        return await response.json();
-    }
-    async uploadToStorageBucket(opts, uploadData, fileStream) {
-        let blob;
-        if (fileStream instanceof ReadableStream) {
-            const response = new Response(fileStream);
-            blob = await response.blob();
-        }
-        else {
-            const chunks = [];
-            for await (const chunk of fileStream) {
-                chunks.push(chunk);
-            }
-            const buffer = Buffer.concat(chunks);
-            blob = new Blob([buffer]);
-        }
-        const response = await fetch(uploadData.attributes.url, {
-            method: 'PUT',
-            headers: {
-                'Content-Type': opts.contentType,
-            },
-            body: blob,
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            this.logging.error(`Failed to upload to storage bucket: ${response.statusText} - ${errorText}`);
-            throw new Error(`Failed to upload to storage bucket: ${response.statusText} - ${errorText}`);
-        }
-        return response;
-    }
-    async createAssetFromUpload(uploadId, opts, uploadCollectionId) {
-        const body = {
-            data: {
-                type: 'upload',
-                attributes: {
-                    path: uploadId,
-                    author: opts.author,
-                    copyright: opts.copyright,
-                    notes: opts.notes || null,
-                    default_field_metadata: {
-                        en: {
-                            title: opts.title,
-                            alt: opts.alt,
-                        }
-                    },
-                    tags: opts.tags || [],
-                },
-            },
-        };
-        if (uploadCollectionId) {
-            body.data.relationships = {
-                upload_collection: {
-                    data: {
-                        type: 'upload_collection',
-                        id: uploadCollectionId,
-                    },
-                },
-            };
-        }
-        const response = await fetch(`${this.baseUrl}/uploads`, {
-            method: 'POST',
-            headers: {
-                'Authorization': `Bearer ${this.apiToken}`,
-                'Accept': 'application/json',
-                'X-Api-Version': '3',
-                'X-Environment': this.environment,
-                'Content-Type': 'application/vnd.api+json',
-            },
-            body: JSON.stringify(body),
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            this.logging.error(`Failed to create asset from upload: ${response.statusText} - ${errorText}`);
-            throw new Error(`Failed to create asset from upload: ${response.statusText} - ${errorText}`);
-        }
-        return await response.json();
-    }
-    async checkJobResult(jobId) {
-        const response = await fetch(`${this.baseUrl}/job-results/${jobId}`, {
-            method: 'GET',
-            headers: {
-                'Authorization': `Bearer ${this.apiToken}`,
-                'Accept': 'application/json',
-                'X-Api-Version': '3',
-                'X-Environment': this.environment
-            },
-        });
-        if (!response.ok) {
-            if (response.status === 404) {
-                return null;
-            }
-            const errorText = await response.text();
-            this.logging.error(`Failed to check job result: ${response.statusText} - ${errorText}`);
-            throw new Error(`Failed to check job result: ${response.statusText} - ${errorText}`);
-        }
-        return await response.json();
-    }
-    async waitForJobCompletion(jobId, maxAttempts = 30) {
-        for (let attempt = 0; attempt < maxAttempts; attempt++) {
-            const jobResult = await this.checkJobResult(jobId);
-            if (jobResult?.data.attributes.status >= 200 && jobResult?.data.attributes.status < 300) {
-                return jobResult.data.attributes.payload;
-            }
-            if (jobResult?.data.attributes.status) {
-                const errorMsg = `Job failed: ${JSON.stringify(jobResult.data)}`;
-                this.logging.error(errorMsg);
-                throw new Error(errorMsg);
-            }
-            await new Promise(resolve => setTimeout(resolve, 1000));
-        }
-        const timeoutMsg = 'Job completion timeout';
-        this.logging.error(timeoutMsg);
-        throw new Error(timeoutMsg);
-    }
-    async uploadFromUrl(options) {
-        const { url, filename, uploadCollectionId } = options;
-        this.logging.log(`Starting upload from URL: ${url}`);
-        const fileResponse = await fetch(url);
-        if (!fileResponse.ok) {
-            const errorMsg = `Failed to fetch file from URL: ${fileResponse.statusText}`;
-            this.logging.error(errorMsg);
-            throw new Error(errorMsg);
-        }
-        let finalFilename = filename || path_1.default.basename(new URL(url).pathname) || 'bs-' + this.triggerId + '-' + new Date().getTime();
-        if (!path_1.default.extname(finalFilename) && fileResponse.headers.has('content-type')) {
-            finalFilename += `.${(0, mime_types_1.extension)(fileResponse.headers.get('content-type'))}`;
-        }
-        const uploadRequest = await this.requestUploadParameters(finalFilename);
-        const uploadId = uploadRequest.data.id;
-        if (!fileResponse.body) {
-            throw new Error('Response body is null');
-        }
-        const contentType = fileResponse.headers.get('content-type') || (0, mime_types_1.lookup)(finalFilename) || 'application/octet-stream';
-        await this.uploadToStorageBucket({ contentType }, uploadRequest.data, fileResponse.body);
-        const assetJob = await this.createAssetFromUpload(uploadId, options, uploadCollectionId);
-        const jobId = assetJob.data.id;
-        const assetPayload = await this.waitForJobCompletion(jobId);
-        this.logging.log(`Upload completed successfully: ${assetPayload.data.attributes.url}`);
-        return {
-            success: true,
-            upload: assetPayload.data.attributes.url,
-            assetId: assetPayload.data.id,
-        };
-    }
-    async uploadFromFile(options) {
-        const { filePath, filename, uploadCollectionId } = options;
-        if (!fs_1.default.existsSync(filePath)) {
-            const errorMsg = `File not found: ${filePath}`;
-            this.logging.error(errorMsg);
-            throw new Error(errorMsg);
-        }
-        this.logging.log(`Starting upload from file: ${filePath}`);
-        const finalFilename = filename || path_1.default.basename(filePath);
-        const uploadRequest = await this.requestUploadParameters(finalFilename);
-        const uploadId = uploadRequest.data.id;
-        const fileStream = fs_1.default.createReadStream(filePath);
-        const contentType = (0, mime_types_1.lookup)(filePath) || 'application/octet-stream';
-        await this.uploadToStorageBucket({ contentType }, uploadRequest.data, fileStream);
-        const assetJob = await this.createAssetFromUpload(uploadId, options, uploadCollectionId);
-        const jobId = assetJob.data.id;
-        const assetPayload = await this.waitForJobCompletion(jobId);
-        this.logging.log(`Upload completed successfully: ${assetPayload.data.attributes.url}`);
-        return {
-            success: true,
-            upload: assetPayload.data.attributes.url,
-            assetId: assetPayload.data.id,
-        };
-    }
-    async getUploadCollections() {
-        const response = await fetch(`${this.baseUrl}/upload-collections`, {
-            method: 'GET',
-            headers: {
-                'X-Api-Version': '3',
-                'X-Environment': this.environment,
-                'Authorization': `Bearer ${this.apiToken}`,
-                'Accept': 'application/json',
-            },
-        });
-        if (!response.ok) {
-            const errorText = await response.text();
-            this.logging.error(`Failed to fetch upload collections: ${response.statusText} - ${errorText}`);
-            throw new Error(`Failed to fetch upload collections: ${response.statusText} - ${errorText}`);
-        }
-        return await response.json();
-    }
-    async findUploadCollectionByLabel(label) {
-        const collections = await this.getUploadCollections();
-        return collections.data?.find((collection) => collection.attributes.label === label) || null;
-    }
-    static buildUrl(asset, opts) {
-        const src = (asset ?? '').trim();
-        const hasAnyNewOption = typeof opts.width === 'number' ||
-            typeof opts.height === 'number' ||
-            typeof opts.crop === 'string' ||
-            typeof opts.quality === 'number' ||
-            typeof opts.format === 'string';
-        const qIndex = src.indexOf('?');
-        const base = qIndex === -1 ? src : src.slice(0, qIndex);
-        const existingQuery = qIndex === -1 ? '' : src.slice(qIndex + 1);
-        if (opts.overrideExisting && !hasAnyNewOption) {
-            return base;
-        }
-        const params = new URLSearchParams(opts.overrideExisting ? '' : existingQuery);
-        const setNum = (key, val) => {
-            if (typeof val === 'number' && Number.isFinite(val)) {
-                params.set(key, String(val));
-            }
-        };
-        const setStr = (key, val) => {
-            if (typeof val === 'string' && val.length > 0) {
-                params.set(key, val);
-            }
-        };
-        setNum('w', opts.width);
-        setNum('h', opts.height);
-        setStr('crop', opts.crop);
-        setNum('q', opts.quality);
-        setStr('fm', opts.format);
-        const query = params.toString();
-        return query ? `${base}?${query}` : base;
-    }
-    async findUploadByFilename(filename) {
-        try {
-            const response = await fetch(`${this.baseUrl}/uploads?filter[filename]=${encodeURIComponent(filename)}`, {
-                headers: {
-                    'Authorization': `Bearer ${this.apiToken}`,
-                    'X-Api-Version': '3',
-                    'X-Environment': this.environment,
-                    'Accept': 'application/json',
-                },
-            });
-            if (!response.ok) {
-                const errorText = await response.text();
-                this.logging.error(`Failed to search for existing upload: ${response.status} ${response.statusText} - ${errorText}`);
-                return null;
-            }
-            const data = await response.json().catch((err) => {
-                this.logging.error(`Failed to parse JSON in findUploadByFilename: ${err.message}`);
-                return null;
-            });
-            return data?.data?.[0] || null;
-        }
-        catch (err) {
-            this.logging.error(`Error in findUploadByFilename: ${err.message}`);
-            return null;
-        }
-    }
-    async getItemTypeId(apiKey) {
-        try {
-            const res = await fetch(`${this.baseUrl}/item-types`, {
-                method: "GET",
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    Accept: "application/json",
-                },
-            });
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to fetch item types: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            const data = await res.json();
-            const type = data.data.find((t) => t.attributes.api_key === apiKey);
-            if (!type)
-                throw new Error(`Item type "${apiKey}" not found in ${this.environment} - ${JSON.stringify(data)}`);
-            return type.id;
-        }
-        catch (err) {
-            this.logging.error(`getItemTypeId failed: ${err.message}`);
-            throw err;
-        }
-    }
-    async getProductBySku(sku) {
-        try {
-            const encodedSku = encodeURIComponent(sku);
-            const res = await fetch(`${this.baseUrl}/items?filter[type]=product&filter[fields][sku][eq]=${encodedSku}&version=current`, {
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    "Content-Type": "application/vnd.api+json",
-                    Accept: "application/json",
-                },
-            });
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to fetch product by SKU: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            return await res.json();
-        }
-        catch (err) {
-            this.logging.error(`getProductBySku failed: ${err.message}`);
-            throw err;
-        }
-    }
-    async createProduct(sku, productTypeId) {
-        try {
-            const res = await fetch(`${this.baseUrl}/items`, {
-                method: "POST",
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    "Content-Type": "application/vnd.api+json",
-                    Accept: "application/json",
-                },
-                body: JSON.stringify({
-                    data: {
-                        type: "item",
-                        attributes: { sku },
-                        relationships: {
-                            item_type: { data: { type: "item_type", id: productTypeId } },
-                        },
-                    },
-                }),
-            });
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to create product: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            return await res.json();
-        }
-        catch (err) {
-            this.logging.error(`createProduct failed: ${err.message}`);
-            throw err;
-        }
-    }
-    async updateProductGallery(productId, gallery) {
-        try {
-            const res = await fetch(`${this.baseUrl}/items/${productId}`, {
-                method: "PATCH",
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    "Content-Type": "application/vnd.api+json",
-                    Accept: "application/json",
-                },
-                body: JSON.stringify({
-                    data: {
-                        type: "item",
-                        id: productId,
-                        attributes: { gallery },
-                    },
-                }),
-            });
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to update product gallery: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            return await res.json();
-        }
-        catch (err) {
-            this.logging.error(`updateProductGallery failed: ${err.message}`);
-            throw err;
-        }
-    }
-}
-exports.default = DatoHelper;