@shushed/helpers 0.0.200-runtime-url-fix-20251125155626 → 0.0.200-runtime-url-fix2-20251125155916

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

@@ -10,19 +10,16 @@ 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',
@@ -72,11 +69,6 @@ class DatoHelper extends runtime_1.default {
         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',
@@ -85,35 +77,13 @@ class DatoHelper extends runtime_1.default {
                     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,
-                            }
-                        },
+                    defaultFieldMetadata: {
                         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,
-                            }
+                            title: opts.title,
+                            alt: opts.alt,
                         }
                     },
-                    tags: normalizedTags || [],
+                    tags: opts.tags || [],
                 },
             },
         };
@@ -133,7 +103,6 @@ class DatoHelper extends runtime_1.default {
                 '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),
@@ -152,7 +121,6 @@ class DatoHelper extends runtime_1.default {
                 'Authorization': `Bearer ${this.apiToken}`,
                 'Accept': 'application/json',
                 'X-Api-Version': '3',
-                'X-Environment': this.environment
             },
         });
         if (!response.ok) {
@@ -182,119 +150,8 @@ class DatoHelper extends runtime_1.default {
         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),
-            });
-            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;
+        const { url, filename, uploadCollectionId } = options;
         this.logging.log(`Starting upload from URL: ${url}`);
         const fileResponse = await fetch(url);
         if (!fileResponse.ok) {
@@ -302,43 +159,9 @@ class DatoHelper extends runtime_1.default {
             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,
-                };
-            }
+        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;
@@ -355,7 +178,6 @@ class DatoHelper extends runtime_1.default {
             success: true,
             upload: assetPayload.data.attributes.url,
             assetId: assetPayload.data.id,
-            skipped: false,
         };
     }
     async uploadFromFile(options) {
@@ -387,7 +209,6 @@ class DatoHelper extends runtime_1.default {
             method: 'GET',
             headers: {
                 'X-Api-Version': '3',
-                'X-Environment': this.environment,
                 'Authorization': `Bearer ${this.apiToken}`,
                 'Accept': 'application/json',
             },
@@ -435,203 +256,5 @@ class DatoHelper extends runtime_1.default {
         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',
-                },
-            });
-            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",
-                },
-            });
-            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;
-        }
-    }
-    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 },
-                        },
-                    },
-                }),
-            });
-            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;
-        }
-    }
 }
 exports.default = DatoHelper;

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

@@ -92,8 +92,8 @@ class Runtime {
         }
     }
     getRuntimeUrl(options) {
-        if (this.runtimeUrl && this.isDeployment) {
-            return this.runtimeUrl;
+        if (options.runtimeUrl && this.isDeployment) {
+            return options.runtimeUrl;
         }
         const systemEnvName = this.getSystemEnvName(options);
         const [_, ...idParts] = (process.env.GCLOUD_PROJECT || '').split('-');

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

@@ -16,6 +16,7 @@ exports.setRetryAfterVariable = setRetryAfterVariable;
 exports.createFunction = createFunction;
 exports.createOnResponse = createOnResponse;
 exports.onResponse = onResponse;
+exports.parsePrices = parsePrices;
 const crypto_1 = __importDefault(require("crypto"));
 const firestore_1 = require("@google-cloud/firestore");
 const jwks_1 = __importDefault(require("./jwks"));
@@ -311,7 +312,7 @@ function onResponse(config, options, requiredFlag) {
                         return Object.assign({}, x, { body: redactedResponse });
                     }
                     if (x.body instanceof Error) {
-                        return Object.assign({}, x, { message: x.body.message, error: true });
+                        return Object.assign({}, x, { body: { message: x.body.message, error: true } });
                     }
                     return x;
                 }
@@ -334,3 +335,120 @@ function onResponse(config, options, requiredFlag) {
         cacheMaxAge: 0,
     };
 }
+function parsePrices(priceData, timeZone = 'UTC') {
+    const result = [];
+    const defaultStartDate = convertDateToDatetimeTZ(new Date(0).toISOString(), timeZone);
+    const defaultEndDate = convertDateToDatetimeTZ(new Date('2099-01-01T00:00:00Z').toISOString(), timeZone);
+    for (let i = 0; i < priceData.length; i += 1) {
+        const priceChanges = (priceData[i].price_changes || []).map(x => ({
+            effective_from: x.effective_from ? (!isNaN(new Date(x.effective_from).getTime()) ? convertDateToDatetimeTZ(x.effective_from, timeZone) : null) : defaultStartDate,
+            effective_until: x.effective_until ? (!isNaN(new Date(x.effective_until).getTime()) ? convertDateToDatetimeTZ(x.effective_until, timeZone) : null) : defaultEndDate,
+            price: x.price * 100,
+            price_type: x.price_type,
+        }));
+        const rrpPriceTypes = parsePriceType(priceChanges.filter((x) => x.price_type === 'rrp'));
+        const permPriceTypes = parsePriceType(priceChanges.filter((x) => x.price_type === 'perm'));
+        const posPriceTypes = parsePriceType(priceChanges.filter((x) => x.price_type === 'pos'));
+        let currentPrice;
+        let currentPriceType;
+        if (rrpPriceTypes.current) {
+            currentPrice = rrpPriceTypes.current;
+            currentPriceType = 'rrp';
+        }
+        if (permPriceTypes.current) {
+            currentPrice = permPriceTypes.current;
+            currentPriceType = 'perm';
+        }
+        if (posPriceTypes.current) {
+            currentPrice = posPriceTypes.current;
+            currentPriceType = 'pos';
+        }
+        result.push({
+            ...priceData[i],
+            current_price: currentPrice,
+            current_price_type: currentPriceType,
+            rrp: rrpPriceTypes,
+            perm: permPriceTypes,
+            pos: posPriceTypes
+        });
+    }
+    return result;
+}
+function parsePriceType(priceTypeData, now = new Date()) {
+    if (!priceTypeData) {
+        return {
+            current: undefined,
+            historical: [],
+            future: []
+        };
+    }
+    const historicalEntries = [];
+    const futureEntries = [];
+    const currentEntries = [];
+    for (let i = 0; i < priceTypeData.length; i += 1) {
+        const price = priceTypeData[i];
+        if (price.effective_from !== null && price.effective_until !== null) {
+            const priceWithoutNulls = price;
+            if (priceWithoutNulls.effective_from.getTime() > priceWithoutNulls.effective_until.getTime()) {
+                continue;
+            }
+            else if (priceWithoutNulls.effective_from.getTime() > now.getTime()) {
+                futureEntries.push(priceWithoutNulls);
+            }
+            else if (priceWithoutNulls.effective_until.getTime() < now.getTime()) {
+                historicalEntries.push(priceWithoutNulls);
+            }
+            else {
+                currentEntries.push(priceWithoutNulls);
+            }
+        }
+    }
+    const [currentEntry, ...otherFutureEntries] = currentEntries.sort(createSortPriceTypes(false));
+    const sortedHistoricalEntries = historicalEntries.concat(otherFutureEntries).sort(createSortPriceTypes(true));
+    const sortedFutureEntries = futureEntries.sort(createSortPriceTypes(true));
+    return {
+        current: currentEntry,
+        historical: sortedHistoricalEntries,
+        future: sortedFutureEntries
+    };
+}
+function createSortPriceTypes(descending) {
+    return function (a, b) {
+        let effectiveFromSort;
+        if (descending) {
+            effectiveFromSort = b.effective_from.getTime() - a.effective_from.getTime();
+        }
+        else {
+            effectiveFromSort = a.effective_from.getTime() - b.effective_from.getTime();
+        }
+        if (effectiveFromSort === 0) {
+            if (!descending) {
+                return b.effective_until.getTime() - a.effective_until.getTime();
+            }
+            return a.effective_until.getTime() - b.effective_until.getTime();
+        }
+        return effectiveFromSort;
+    };
+}
+function convertDateToDatetimeTZ(dateString, timeZone) {
+    let normDateString = '';
+    if (dateString.includes('T')) {
+        normDateString = dateString.slice(0, 19);
+    }
+    else {
+        normDateString = dateString + 'T00:00:00';
+    }
+    console.error(dateString, normDateString + getOffsetString(timeZone));
+    return new Date(normDateString + getOffsetString(timeZone));
+}
+function getOffsetString(timeZone) {
+    const today = new Date(`${new Date().toISOString().slice(0, 10)}T00:00:00Z`);
+    const locale = today.toLocaleString("sv-SE", { timeZone });
+    const tzDate = new Date(locale);
+    const offsetMinutes = Math.ceil(tzDate.getTime() - today.getTime()) / 60000;
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const abs = Math.abs(offsetMinutes);
+    const hours = String(Math.floor(abs / 60)).padStart(2, "0");
+    const minutes = String(abs % 60).padStart(2, "0");
+    return `${sign}${hours}:${minutes}`;
+}