@shushed/helpers 0.0.200-v2-20251128093319 → 0.0.200

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

@@ -1,680 +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"));
-const utils_1 = require("./utils");
-class DatoHelper extends runtime_1.default {
-    apiToken;
-    baseUrl;
-    environment;
-    root;
-    constructor(opts, datoOpts) {
-        super(opts);
-        this.apiToken = datoOpts.apiToken;
-        this.baseUrl = datoOpts.baseUrl || 'https://site-api.datocms.com';
-        this.environment = datoOpts.environment || 'main';
-        this.root = datoOpts.root;
-    }
-    handle429(response) {
-        if (response.status === 429 && this.root) {
-            (0, utils_1.setRetryAfterVariable)(response, { root: this.root });
-        }
-    }
-    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,
-                    },
-                },
-            }),
-        });
-        this.handle429(response);
-        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 normalizedTags = Array.isArray(opts.tags) && opts.tags.length > 0
-            ? opts.tags
-            : ["integrations"];
-        const safeTitle = opts.title && opts.title.trim().length > 0 ? opts.title : "untitled";
-        const safeAlt = opts.alt && opts.alt.trim().length > 0 ? opts.alt : safeTitle;
-        const body = {
-            data: {
-                type: 'upload',
-                attributes: {
-                    path: uploadId,
-                    author: opts.author,
-                    copyright: opts.copyright,
-                    notes: opts.notes || null,
-                    title: safeTitle,
-                    alt: safeAlt,
-                    default_field_metadata: {
-                        "en-GB": {
-                            title: safeTitle,
-                            alt: safeAlt,
-                            custom_data: {
-                                source: normalizedTags[0] || "uploaded-by-integrations",
-                                tags: normalizedTags,
-                            }
-                        },
-                        en: {
-                            title: safeTitle,
-                            alt: safeAlt,
-                            custom_data: {
-                                source: normalizedTags[0] || "uploaded-by-integrations",
-                                tags: normalizedTags,
-                            }
-                        },
-                        "en-US": {
-                            title: safeTitle,
-                            alt: safeAlt,
-                            custom_data: {
-                                source: normalizedTags[0] || "uploaded-by-integrations",
-                                tags: normalizedTags,
-                            }
-                        }
-                    },
-                    tags: normalizedTags || [],
-                },
-            },
-        };
-        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),
-        });
-        this.handle429(response);
-        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
-            },
-        });
-        this.handle429(response);
-        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);
-    }
-    updateUpload = async (options) => {
-        try {
-            this.logging.log(`Starting update upload - ${JSON.stringify(options)}`);
-            if (!options.id)
-                throw new Error("updateUpload requires 'id' in options");
-            const safeTitle = options.title && options.title.trim().length > 0
-                ? options.title.trim()
-                : options.filename?.trim().split(".")[0] || "untitled";
-            const safeAlt = options.alt && options.alt.trim().length > 0
-                ? options.alt.trim()
-                : safeTitle;
-            const normalizedTags = Array.isArray(options.tags) && options.tags.length > 0
-                ? options.tags
-                : ["integrations"];
-            const body = {
-                data: {
-                    type: "upload",
-                    id: options.id,
-                    attributes: {
-                        author: options.author,
-                        copyright: options.copyright,
-                        tags: normalizedTags,
-                        notes: options.notes || null,
-                        default_field_metadata: {
-                            "en-GB": {
-                                title: safeTitle,
-                                alt: safeAlt,
-                                custom_data: {
-                                    source: normalizedTags[0] || "uploaded-by-integrations",
-                                    tags: normalizedTags,
-                                },
-                            },
-                            en: {
-                                title: safeTitle,
-                                alt: safeAlt,
-                                custom_data: {
-                                    source: normalizedTags[0] || "uploaded-by-integrations",
-                                    tags: normalizedTags,
-                                },
-                            },
-                            "en-US": {
-                                title: safeTitle,
-                                alt: safeAlt,
-                                custom_data: {
-                                    source: normalizedTags[0] || "uploaded-by-integrations",
-                                    tags: normalizedTags,
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            if (options.uploadCollectionId) {
-                body.data.relationships = {
-                    upload_collection: {
-                        data: {
-                            type: "upload_collection",
-                            id: options.uploadCollectionId,
-                        },
-                    },
-                };
-            }
-            const response = await fetch(`${this.baseUrl}/uploads/${options.id}`, {
-                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(body),
-            });
-            this.handle429(response);
-            if (!response.ok) {
-                const errorText = await response.text();
-                this.logging.error(`Failed to update upload: ${response.statusText} - ${errorText}`);
-                throw new Error(`Failed to update upload: ${response.statusText} - ${errorText}`);
-            }
-            const updated = await response.json();
-            if (Array.isArray(updated.data) && updated.data[0]?.type === "api_error") {
-                const errorCode = updated.data[0].attributes?.code || "UNKNOWN_ERROR";
-                const errorMsg = `DatoCMS API error: ${errorCode}`;
-                this.logging.error(errorMsg);
-                throw new Error(errorMsg);
-            }
-            if (updated.data?.type === "job") {
-                this.logging.log(`Waiting for job completion: ${updated.data.id}`);
-                const jobPayload = await this.waitForJobCompletion(updated.data.id);
-                const assetId = jobPayload?.data?.id;
-                const assetUrl = jobPayload?.data?.attributes?.url;
-                if (!assetId || !assetUrl) {
-                    throw new Error(`Job completed but payload missing expected fields: ${JSON.stringify(jobPayload)}`);
-                }
-                this.logging.log(`Job completed for upload: ${assetId}`);
-                return { success: true, assetId, upload: assetUrl };
-            }
-            if (updated.data?.type === "upload") {
-                const { id, attributes } = updated.data;
-                this.logging.log(`Upload updated successfully: ${id}`);
-                return { success: true, assetId: id, upload: attributes.url };
-            }
-            const errMsg = `Unexpected update response: ${JSON.stringify(updated)}`;
-            this.logging.error(errMsg);
-            throw new Error(errMsg);
-        }
-        catch (err) {
-            const msg = err?.message ?? JSON.stringify(err);
-            this.logging.error(`[updateUpload] failed: ${msg}`);
-            throw new Error(msg);
-        }
-    };
-    async uploadFromUrl(options) {
-        const { url, filename, uploadCollectionId, skipCreationIfAlreadyExists } = 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}-${Date.now()}`;
-        if (filename && !path_1.default.extname(finalFilename)) {
-            const urlObj = new URL(url);
-            const pathname = urlObj.pathname;
-            if (pathname.includes(".")) {
-                const urlExtension = path_1.default.extname(pathname);
-                if (urlExtension) {
-                    finalFilename += urlExtension;
-                }
-            }
-            if (!path_1.default.extname(finalFilename) && fileResponse.headers.has('content-type')) {
-                const ext = (0, mime_types_1.extension)(fileResponse.headers.get('content-type'));
-                if (typeof ext === "string" && ext.length > 0) {
-                    finalFilename += `.${ext}`;
-                }
-            }
-        }
-        else if (!filename) {
-            if (!path_1.default.extname(finalFilename) && fileResponse.headers.has('content-type')) {
-                const ext = (0, mime_types_1.extension)(fileResponse.headers.get('content-type'));
-                if (typeof ext === "string" && ext.length > 0) {
-                    finalFilename += `.${ext}`;
-                }
-            }
-        }
-        if (skipCreationIfAlreadyExists) {
-            const existing = await this.findUploadByFilename(finalFilename);
-            if (existing) {
-                this.logging.log(`Skipping upload: existing asset found for "${finalFilename}"`);
-                return {
-                    success: true,
-                    assetId: existing.id,
-                    upload: existing.attributes.url,
-                    skipped: true,
-                };
-            }
-        }
-        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,
-            skipped: false,
-        };
-    }
-    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',
-            },
-        });
-        this.handle429(response);
-        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 {
-            if (!filename || typeof filename !== 'string') {
-                this.logging.log(`findUploadByFilename called with invalid filename: ${String(filename)}`);
-                return null;
-            }
-            const normalizedTarget = filename.trim().toLowerCase().replace(/\.[^.]+$/, '');
-            const query = encodeURIComponent(normalizedTarget);
-            this.logging.log(`Searching uploads with query="${normalizedTarget}" for filename="${filename}"`);
-            const response = await fetch(`${this.baseUrl}/uploads?filter[query]=${query}&page[limit]=100`, {
-                headers: {
-                    'Authorization': `Bearer ${this.apiToken}`,
-                    'X-Api-Version': '3',
-                    'X-Environment': this.environment,
-                    'Accept': 'application/json',
-                },
-            });
-            this.handle429(response);
-            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;
-            });
-            const uploads = data?.data || [];
-            if (!uploads.length) {
-                this.logging.log(`No uploads returned for query="${normalizedTarget}"`);
-                return null;
-            }
-            const targetFull = filename.trim().toLowerCase();
-            const match = uploads.find((u) => {
-                const storedFull = u?.attributes?.filename?.toLowerCase();
-                if (!storedFull)
-                    return false;
-                if (storedFull === targetFull)
-                    return true;
-                const storedNormalized = storedFull.replace(/\.[^.]+$/, '');
-                if (storedNormalized === normalizedTarget)
-                    return true;
-                return false;
-            });
-            if (match) {
-                this.logging.log(`Found existing upload for "${filename}" -> asset_id=${match.id}, storedFilename=${match.attributes?.filename}`);
-                return match;
-            }
-            this.logging.log(`No exact filename match found among ${uploads.length} uploads for "${filename}" (query="${normalizedTarget}")`);
-            return null;
-        }
-        catch (err) {
-            this.logging.error(`Error in findUploadByFilename: ${err?.message ?? String(err)}`);
-            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",
-                },
-            });
-            this.handle429(res);
-            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",
-                },
-            });
-            this.handle429(res);
-            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 } },
-                        },
-                    },
-                }),
-            });
-            this.handle429(res);
-            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 },
-                    },
-                }),
-            });
-            this.handle429(res);
-            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;
-        }
-    }
-    async updateProductSwatch(productId, uploadId) {
-        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: {
-                            swatch: { upload_id: uploadId },
-                        },
-                    },
-                }),
-            });
-            this.handle429(res);
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to update product swatch: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            return await res.json();
-        }
-        catch (err) {
-            this.logging.error(`updateProductSwatch failed: ${err.message}`);
-            throw err;
-        }
-    }
-    async publishProduct(productId) {
-        try {
-            const res = await fetch(`${this.baseUrl}/items/${productId}/publish`, {
-                method: "PUT",
-                headers: {
-                    Authorization: `Bearer ${this.apiToken}`,
-                    "X-Api-Version": "3",
-                    "X-Environment": this.environment,
-                    "Content-Type": "application/vnd.api+json",
-                    Accept: "application/json",
-                },
-            });
-            this.handle429(res);
-            if (!res.ok) {
-                const errorText = await res.text();
-                throw new Error(`Failed to publish product: ${res.status} ${res.statusText} - ${errorText}`);
-            }
-            return await res.json();
-        }
-        catch (err) {
-            this.logging.error(`publishProduct failed: ${err.message}`);
-            throw err;
-        }
-    }
-}
-exports.default = DatoHelper;