@shushed/helpers 0.0.200-v2-20251126121340 → 0.0.200-v2-20251127150547

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

@@ -7,19 +7,30 @@ 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',
@@ -33,6 +44,7 @@ class DatoHelper extends runtime_1.default {
                 },
             }),
         });
+        this.handle429(response);
         if (!response.ok) {
             const errorText = await response.text();
             this.logging.error(`Failed to request upload parameters: ${response.statusText} - ${errorText}`);
@@ -69,6 +81,11 @@ 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',
@@ -77,13 +94,35 @@ class DatoHelper extends runtime_1.default {
                     author: opts.author,
                     copyright: opts.copyright,
                     notes: opts.notes || null,
-                    defaultFieldMetadata: {
+                    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: opts.title,
-                            alt: opts.alt,
+                            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: opts.tags || [],
+                    tags: normalizedTags || [],
                 },
             },
         };
@@ -103,10 +142,12 @@ 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),
         });
+        this.handle429(response);
         if (!response.ok) {
             const errorText = await response.text();
             this.logging.error(`Failed to create asset from upload: ${response.statusText} - ${errorText}`);
@@ -121,8 +162,10 @@ class DatoHelper extends runtime_1.default {
                 '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;
@@ -150,8 +193,120 @@ 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),
+            });
+            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 } = options;
+        const { url, filename, uploadCollectionId, skipCreationIfAlreadyExists } = options;
         this.logging.log(`Starting upload from URL: ${url}`);
         const fileResponse = await fetch(url);
         if (!fileResponse.ok) {
@@ -159,9 +314,43 @@ 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 + '-' + 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'))}`;
+        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;
@@ -178,6 +367,7 @@ class DatoHelper extends runtime_1.default {
             success: true,
             upload: assetPayload.data.attributes.url,
             assetId: assetPayload.data.id,
+            skipped: false,
         };
     }
     async uploadFromFile(options) {
@@ -209,10 +399,12 @@ class DatoHelper extends runtime_1.default {
             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}`);
@@ -256,5 +448,209 @@ 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',
+                },
+            });
+            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;
+        }
+    }
 }
 exports.default = DatoHelper;

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

@@ -92,6 +92,9 @@ class Runtime {
         }
     }
     getRuntimeUrl(options) {
+        if (options.runtimeUrl && this.isDeployment) {
+            return options.runtimeUrl;
+        }
         const systemEnvName = this.getSystemEnvName(options);
         const [_, ...idParts] = (process.env.GCLOUD_PROJECT || '').split('-');
         if (process.env.RUNTIME_URL) {
@@ -130,6 +133,9 @@ class Runtime {
         }
         return systemEnvName || 'test-env';
     }
+    get isDeployment() {
+        return process.env.K_SERVICE === 'manager';
+    }
 }
 exports.default = Runtime;
 ;

package/dist/types/src-public/dato.d.ts

@@ -2,21 +2,54 @@ import Runtime, { Opts as RuntimeOpts } from './runtime';
 interface DatoHelperOptions {
     apiToken: string;
     baseUrl?: string;
+    environment?: string;
+    root?: {
+        state: Record<string, any>;
+        inputs: any;
+    };
 }
 interface UploadResult {
     success: boolean;
     upload: string;
     assetId?: string;
+    skipped?: boolean;
+}
+interface UploadReturn {
+    id: string;
+    type: string;
+    attributes: {
+        url: string;
+        filename: string;
+        [key: string]: any;
+    };
 }
 export default class DatoHelper extends Runtime {
     private apiToken;
     private baseUrl;
+    private environment;
+    private root?;
     constructor(opts: RuntimeOpts, datoOpts: DatoHelperOptions);
+    private handle429;
     private requestUploadParameters;
     private uploadToStorageBucket;
     private createAssetFromUpload;
     private checkJobResult;
     private waitForJobCompletion;
+    updateUpload: (options: {
+        id: string;
+        filename?: string;
+        tags: string[];
+        notes?: string;
+        title: string;
+        alt: string;
+        author: string;
+        copyright: string;
+        uploadCollectionId?: string;
+    }) => Promise<{
+        success: boolean;
+        assetId: string;
+        upload: string;
+    }>;
     uploadFromUrl(options: {
         url: string;
         copyright: string;
@@ -51,5 +84,11 @@ export default class DatoHelper extends Runtime {
         quality?: number;
         format?: 'jpg' | 'pjpg' | 'png' | 'webp' | 'avif' | 'gif' | 'jxl' | 'jp2' | 'jxr' | 'json' | 'blurhash' | (string & {});
     }): string;
+    findUploadByFilename(filename: string): Promise<UploadReturn | null>;
+    getItemTypeId(apiKey: string): Promise<string>;
+    getProductBySku(sku: string): Promise<any>;
+    createProduct(sku: string, productTypeId: string): Promise<any>;
+    updateProductGallery(productId: string, gallery: any[]): Promise<any>;
+    updateProductSwatch(productId: string, uploadId: string): Promise<any>;
 }
 export {};

package/dist/types/src-public/runtime.d.ts

@@ -53,4 +53,5 @@ export default class Runtime {
     constructor(opts: Opts | Runtime);
     private getRuntimeUrl;
     private getSystemEnvName;
+    private get isDeployment();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shushed/helpers",
-  "version": "0.0.200-v2-20251126121340",
+  "version": "0.0.200-v2-20251127150547",
   "author": "",
   "license": "UNLICENSED",
   "description": "",