@pvh-afl/core 1.0.0

package/dist/theme/theme-content.service.js

@@ -0,0 +1,738 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeContentService = void 0;
+const tslib_1 = require("tslib");
+const common_1 = require("@nestjs/common");
+const cache_service_1 = require("../cache/cache.service");
+const config_service_1 = require("../config/config.service");
+const shopify_theme_1 = require("../integrations/shopify-theme");
+const logger_1 = require("../common/logger");
+const theme_content_interfaces_1 = require("./theme-content.interfaces");
+let ThemeContentService = class ThemeContentService {
+    cacheService;
+    configService;
+    shopifyThemeService;
+    collectionService;
+    productService;
+    refreshInProgress = new Set();
+    constructor(cacheService, configService, shopifyThemeService, collectionService, productService) {
+        this.cacheService = cacheService;
+        this.configService = configService;
+        this.shopifyThemeService = shopifyThemeService;
+        this.collectionService = collectionService;
+        this.productService = productService;
+    }
+    /**
+     * Build cache key for theme content.
+     */
+    buildCacheKey(brand, path) {
+        return this.shopifyThemeService.buildCacheKey(brand, path);
+    }
+    /**
+     * Get theme content with stale-while-revalidate semantics.
+     */
+    async getContent(brand, path) {
+        const cacheKey = this.buildCacheKey(brand, path);
+        const cached = await this.cacheService.get(cacheKey);
+        let themeStructure = null;
+        let isStale = false;
+        let triggeredRefresh = false;
+        if (!cached) {
+            logger_1.logger.info('Theme content cache miss, fetching fresh data', {
+                brand,
+                path,
+                cacheKey,
+            });
+            themeStructure = await this.fetchAndCacheContent(brand, path);
+        }
+        else {
+            themeStructure = cached.data;
+            isStale = cached.isStale;
+            if (cached.isStale) {
+                logger_1.logger.info('Theme content is stale, triggering background refresh', {
+                    brand,
+                    path,
+                    cacheKey,
+                });
+                this.refreshContentInBackground(brand, path, cacheKey);
+                triggeredRefresh = true;
+            }
+        }
+        if (!themeStructure) {
+            return { data: null, isStale: false, triggeredRefresh: false };
+        }
+        // Resolve collection and product references
+        let resolvedContent = await this.resolveCollectionReferences(brand, themeStructure);
+        resolvedContent = await this.resolveProductReferences(brand, resolvedContent);
+        return {
+            data: resolvedContent,
+            isStale,
+            triggeredRefresh,
+        };
+    }
+    /**
+     * Refresh content in the background (non-blocking)
+     */
+    async refreshContentInBackground(brand, path, cacheKey) {
+        if (this.refreshInProgress.has(cacheKey)) {
+            logger_1.logger.info('Refresh already in progress, skipping', { cacheKey });
+            return;
+        }
+        this.refreshInProgress.add(cacheKey);
+        try {
+            await this.fetchAndCacheContent(brand, path);
+        }
+        finally {
+            this.refreshInProgress.delete(cacheKey);
+        }
+    }
+    /**
+     * Fetch fresh content from Shopify and update cache.
+     */
+    async fetchAndCacheContent(brand, path, options) {
+        const cacheKey = this.buildCacheKey(brand, path);
+        logger_1.logger.info('Fetching fresh theme content', {
+            brand,
+            path,
+            cacheKey,
+        });
+        try {
+            const parsed = await this.shopifyThemeService.fetchThemeFile(brand, path);
+            if (!parsed) {
+                logger_1.logger.warn('No content found for theme file', { brand, path });
+                return null;
+            }
+            let curated = await this.curateThemeContent(brand, parsed);
+            curated = await this.resolveMediaReferences(brand, curated);
+            const { defaultTTL: configDefaultTTL, staleTTL: configStaleTTL } = this.configService.getLandingPageCacheTTL(brand);
+            const defaultTTL = options?.defaultTTL ?? configDefaultTTL;
+            const staleTTL = options?.staleTTL ?? configStaleTTL;
+            await this.cacheService.set(cacheKey, curated, defaultTTL, staleTTL);
+            logger_1.logger.info('Theme content cached', { brand, cacheKey });
+            return curated;
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to fetch and curate theme content', {
+                brand,
+                path,
+                error: error instanceof Error ? error.message : 'Unknown',
+            });
+            return null;
+        }
+    }
+    /**
+     * Curates parsed theme content
+     */
+    async curateThemeContent(brand, parsed) {
+        const { sections, order } = parsed;
+        if (!sections || !order) {
+            logger_1.logger.warn('Invalid theme content structure', {
+                hasSections: !!sections,
+                hasOrder: !!order,
+            });
+            return [];
+        }
+        const curatedSections = [];
+        for (const sectionKey of order) {
+            if (!sections[sectionKey])
+                continue;
+            const section = sections[sectionKey];
+            const curatedSection = {
+                type: section.type,
+            };
+            if (section.blocks && section.block_order) {
+                curatedSection.blocks = section.block_order
+                    .filter((blockKey) => section.blocks?.[blockKey])
+                    .map((blockKey) => {
+                    const block = section.blocks[blockKey];
+                    return this.curateBlock(block);
+                });
+            }
+            if (section.settings) {
+                curatedSection.settings = section.settings;
+                // Store collection reference for lazy resolution
+                const featuredCollection = section.settings.featured_collection;
+                if (featuredCollection) {
+                    const productsCount = section.settings.products_count || 8;
+                    curatedSection.collectionRef = {
+                        handle: featuredCollection,
+                        productsCount,
+                    };
+                }
+                // Handle featured-collection section type
+                const collectionHandle = section.settings.collection;
+                if (section.type === 'featured-collection' && collectionHandle) {
+                    const productsCount = section.settings.products_to_show || 8;
+                    curatedSection.collectionRef = {
+                        handle: collectionHandle,
+                        productsCount,
+                    };
+                }
+                // Store product reference for lazy resolution
+                const featuredProduct = section.settings.featured_product;
+                if (featuredProduct) {
+                    curatedSection.productRef = {
+                        handle: featuredProduct,
+                    };
+                }
+            }
+            curatedSections.push(curatedSection);
+        }
+        return curatedSections;
+    }
+    /**
+     * Curates a single block, including nested blocks recursively.
+     */
+    curateBlock(block) {
+        const curatedBlock = {
+            type: block.type,
+        };
+        if (block.settings) {
+            curatedBlock.settings = block.settings;
+        }
+        if (block.blocks && block.block_order) {
+            curatedBlock.blocks = block.block_order
+                .filter((nestedBlockKey) => block.blocks?.[nestedBlockKey])
+                .map((nestedBlockKey) => {
+                const nestedBlock = block.blocks[nestedBlockKey];
+                return this.curateBlock(nestedBlock);
+            });
+        }
+        return curatedBlock;
+    }
+    /**
+     * Resolve collection references to actual products.
+     */
+    async resolveCollectionReferences(brand, content) {
+        if (!this.collectionService || !this.productService) {
+            logger_1.logger.warn('Collection/Product services not provided, skipping resolution');
+            return content;
+        }
+        const sectionsWithRefs = content
+            .map((section, index) => ({ section, index }))
+            .filter(({ section }) => section.collectionRef);
+        if (sectionsWithRefs.length === 0) {
+            return content;
+        }
+        // Fetch all collections in parallel
+        const collectionPromises = sectionsWithRefs.map(({ section }) => this.collectionService.getCollectionByHandle(brand, section.collectionRef.handle, section.collectionRef.productsCount).catch((error) => {
+            logger_1.logger.error('Failed to fetch collection for theme section', {
+                brand,
+                handle: section.collectionRef.handle,
+                error: error instanceof Error ? error.message : 'Unknown',
+            });
+            return null;
+        }));
+        const collections = await Promise.all(collectionPromises);
+        // Collect all unique product handles
+        const allProductHandles = new Set();
+        collections.forEach((collection) => {
+            collection?.productHandles?.forEach((handle) => allProductHandles.add(handle));
+        });
+        // Fetch all products in parallel
+        const productHandleArray = Array.from(allProductHandles);
+        const productPromises = productHandleArray.map((handle) => this.productService.getProductByHandle(brand, handle).catch((error) => {
+            logger_1.logger.error('Failed to fetch product for collection', {
+                brand,
+                handle,
+                error: error instanceof Error ? error.message : 'Unknown',
+            });
+            return null;
+        }));
+        const products = await Promise.all(productPromises);
+        // Build product lookup map
+        const productByHandle = new Map();
+        productHandleArray.forEach((handle, i) => {
+            const product = products[i];
+            if (product) {
+                productByHandle.set(handle, this.mapToCuratedProduct(product));
+            }
+        });
+        // Build a map of section index to resolved products
+        const productsMap = new Map();
+        sectionsWithRefs.forEach(({ index }, i) => {
+            const collection = collections[i];
+            if (collection?.productHandles) {
+                const resolvedProducts = collection.productHandles
+                    .map((handle) => productByHandle.get(handle))
+                    .filter((p) => p !== undefined);
+                if (resolvedProducts.length > 0) {
+                    productsMap.set(index, resolvedProducts);
+                }
+            }
+        });
+        // Merge products into sections
+        return content.map((section, index) => {
+            const { collectionRef, ...sectionWithoutRef } = section;
+            const sectionProducts = productsMap.get(index);
+            if (sectionProducts && sectionProducts.length > 0) {
+                return {
+                    ...sectionWithoutRef,
+                    products: sectionProducts,
+                };
+            }
+            return sectionWithoutRef;
+        });
+    }
+    /**
+     * Resolve product references to actual product data.
+     */
+    async resolveProductReferences(brand, content) {
+        if (!this.productService) {
+            logger_1.logger.warn('Product service not provided, skipping resolution');
+            return content;
+        }
+        const sectionsWithRefs = content
+            .map((section, index) => ({ section, index }))
+            .filter(({ section }) => section.productRef);
+        if (sectionsWithRefs.length === 0) {
+            return content;
+        }
+        // Fetch all products in parallel
+        const productPromises = sectionsWithRefs.map(({ section }) => this.productService.getProductByHandle(brand, section.productRef.handle).catch((error) => {
+            logger_1.logger.error('Failed to fetch product for theme section', {
+                brand,
+                handle: section.productRef.handle,
+                error: error instanceof Error ? error.message : 'Unknown',
+            });
+            return null;
+        }));
+        const products = await Promise.all(productPromises);
+        // Build a map of section index to resolved product
+        const productMap = new Map();
+        sectionsWithRefs.forEach(({ index }, i) => {
+            const product = products[i];
+            if (product) {
+                productMap.set(index, this.mapToCuratedProduct(product));
+            }
+        });
+        // Merge product into sections
+        return content.map((section, index) => {
+            const { productRef, ...sectionWithoutRef } = section;
+            const product = productMap.get(index);
+            if (product) {
+                return {
+                    ...sectionWithoutRef,
+                    product,
+                };
+            }
+            return sectionWithoutRef;
+        });
+    }
+    /**
+     * Map ThemeProduct to CuratedProduct
+     */
+    mapToCuratedProduct(product) {
+        const firstVariantCompareAtPrice = product.variants?.[0]?.compareAtPrice;
+        const displayTag = this.computeDisplayTag(product.tags);
+        return {
+            id: product.id,
+            title: product.title,
+            handle: product.handle,
+            vendor: product.vendor,
+            productType: product.productType,
+            featuredImage: product.featuredImage
+                ? {
+                    url: product.featuredImage.url,
+                    altText: product.featuredImage.altText ?? undefined,
+                    width: product.featuredImage.width,
+                    height: product.featuredImage.height,
+                }
+                : undefined,
+            images: product.images.map((img) => ({
+                id: img.url,
+                url: img.url,
+                altText: img.altText ?? undefined,
+                width: img.width,
+                height: img.height,
+            })),
+            priceRange: product.priceRange,
+            compareAtPrice: firstVariantCompareAtPrice ?? null,
+            tags: product.tags,
+            displayTag,
+        };
+    }
+    /**
+     * Compute displayTag from product tags.
+     */
+    computeDisplayTag(tags) {
+        if (!tags || tags.length === 0) {
+            return null;
+        }
+        const priorityTags = [
+            'new',
+            'sale',
+            'bestseller',
+            'limited',
+            'exclusive',
+            'trending',
+            'hot',
+            'popular',
+            'featured',
+        ];
+        const lowerTags = tags.map((tag) => tag.toLowerCase());
+        for (const priorityTag of priorityTags) {
+            const matchIndex = lowerTags.findIndex((tag) => tag.includes(priorityTag));
+            if (matchIndex !== -1) {
+                return tags[matchIndex];
+            }
+        }
+        return tags[0];
+    }
+    async resolveMediaReferences(brand, curated) {
+        const references = this.extractShopifyReferences(curated);
+        if (references.size === 0) {
+            return curated;
+        }
+        logger_1.logger.info('Resolving media references', {
+            brand,
+            count: references.size,
+        });
+        const urlMap = await this.fetchMediaUrls(brand, Array.from(references));
+        if (urlMap.size === 0) {
+            logger_1.logger.warn('No media URLs resolved');
+        }
+        return this.replaceMediaReferences(curated, urlMap);
+    }
+    extractShopifyReferences(curated) {
+        const references = new Set();
+        const shopifyPattern = /^shopify:\/\//;
+        const extractFromObject = (obj, skipKeys = []) => {
+            for (const [key, value] of Object.entries(obj)) {
+                if (skipKeys.includes(key))
+                    continue;
+                if (typeof value === 'string' && shopifyPattern.test(value)) {
+                    references.add(value);
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    if (Array.isArray(value)) {
+                        value.forEach((item) => {
+                            if (typeof item === 'object' && item !== null) {
+                                extractFromObject(item, skipKeys);
+                            }
+                        });
+                    }
+                    else {
+                        extractFromObject(value, skipKeys);
+                    }
+                }
+            }
+        };
+        const extractFromBlocks = (blocks) => {
+            for (const block of blocks) {
+                if (block.settings) {
+                    extractFromObject(block.settings);
+                }
+                if (block.blocks) {
+                    extractFromBlocks(block.blocks);
+                }
+            }
+        };
+        for (const section of curated) {
+            if (section.settings) {
+                extractFromObject(section.settings);
+            }
+            if (section.blocks) {
+                extractFromBlocks(section.blocks);
+            }
+        }
+        return references;
+    }
+    async fetchMediaUrls(brand, references) {
+        const urlMap = new Map();
+        const adminToken = this.configService.getShopifyAdminToken(brand);
+        const storeDomain = this.configService.getShopifyStoreDomain(brand);
+        if (!adminToken || !storeDomain) {
+            logger_1.logger.warn('Missing Admin API configuration for media resolution', {
+                brand,
+            });
+            return urlMap;
+        }
+        const shopImageRefs = [];
+        const filesApiRefs = [];
+        for (const ref of references) {
+            if (ref.startsWith('shopify://shop_images/')) {
+                shopImageRefs.push(ref);
+            }
+            else if (ref.startsWith('shopify://files/')) {
+                filesApiRefs.push(ref);
+            }
+        }
+        if (shopImageRefs.length > 0) {
+            await this.resolveShopImages(shopImageRefs, urlMap, adminToken, storeDomain);
+        }
+        if (filesApiRefs.length > 0) {
+            await this.resolveFilesApiMedia(filesApiRefs, urlMap, adminToken, storeDomain);
+        }
+        return urlMap;
+    }
+    async resolveShopImages(refs, urlMap, adminToken, storeDomain) {
+        const filenameMap = new Map();
+        for (const ref of refs) {
+            const filename = ref.split('/').pop();
+            if (filename) {
+                filenameMap.set(filename, ref);
+            }
+        }
+        const query = `{
+      files(first: 250, query: "media_type:IMAGE status:READY", sortKey: CREATED_AT, reverse: true) {
+        nodes {
+          ... on MediaImage {
+            id
+            image {
+              url
+              width
+              height
+            }
+          }
+        }
+      }
+    }`;
+        try {
+            const response = await fetch(`https://${storeDomain}/admin/api/2024-01/graphql.json`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Shopify-Access-Token': adminToken,
+                },
+                body: JSON.stringify({ query }),
+            });
+            const result = (await response.json());
+            if (result.errors?.length) {
+                logger_1.logger.error('Shopify Files API errors for shop_images', {
+                    errors: result.errors.map((e) => e.message),
+                });
+                return;
+            }
+            const files = result.data?.files?.nodes || [];
+            const extractFilenameFromUrl = (url) => {
+                const urlWithoutQuery = url.split('?')[0];
+                const segments = urlWithoutQuery.split('/');
+                return segments[segments.length - 1].toLowerCase();
+            };
+            // First pass: exact filename match
+            for (const file of files) {
+                const image = file.image;
+                if (!image?.url)
+                    continue;
+                const cdnFilename = extractFilenameFromUrl(image.url);
+                for (const [filename, ref] of filenameMap.entries()) {
+                    const lookupFilename = filename.toLowerCase();
+                    if (cdnFilename === lookupFilename) {
+                        urlMap.set(ref, {
+                            url: image.url,
+                            width: image.width,
+                            height: image.height,
+                        });
+                        filenameMap.delete(filename);
+                        break;
+                    }
+                }
+                if (filenameMap.size === 0)
+                    break;
+            }
+            // Second pass: fuzzy match for remaining
+            if (filenameMap.size > 0) {
+                for (const file of files) {
+                    const image = file.image;
+                    if (!image?.url)
+                        continue;
+                    const cdnUrlLower = image.url.toLowerCase();
+                    for (const [filename, ref] of filenameMap.entries()) {
+                        const nameWithoutExt = filename.replace(/\.[^/.]+$/, '').toLowerCase();
+                        if (cdnUrlLower.includes(nameWithoutExt)) {
+                            urlMap.set(ref, {
+                                url: image.url,
+                                width: image.width,
+                                height: image.height,
+                            });
+                            filenameMap.delete(filename);
+                            break;
+                        }
+                    }
+                    if (filenameMap.size === 0)
+                        break;
+                }
+            }
+            if (filenameMap.size > 0) {
+                logger_1.logger.warn('Unresolved shop_images', {
+                    filenames: Array.from(filenameMap.keys()),
+                });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to fetch shop_images from Files API', {
+                error: error instanceof Error ? error.message : 'Unknown',
+            });
+        }
+    }
+    async resolveFilesApiMedia(refs, urlMap, adminToken, storeDomain) {
+        const videoFilenameMap = new Map();
+        for (const ref of refs) {
+            const filename = ref.split('/').pop();
+            if (filename) {
+                videoFilenameMap.set(filename, ref);
+            }
+        }
+        const query = `{
+      files(first: 100, query: "media_type:VIDEO status:READY", sortKey: CREATED_AT, reverse: true) {
+        nodes {
+          ... on Video {
+            id
+            filename
+            sources {
+              url
+              mimeType
+              width
+              height
+            }
+          }
+        }
+      }
+    }`;
+        try {
+            const response = await fetch(`https://${storeDomain}/admin/api/2024-01/graphql.json`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'X-Shopify-Access-Token': adminToken,
+                },
+                body: JSON.stringify({ query }),
+            });
+            const result = (await response.json());
+            if (result.errors?.length) {
+                logger_1.logger.error('Shopify Files API errors', {
+                    errors: result.errors.map((e) => e.message),
+                });
+                return;
+            }
+            const files = result.data?.files?.nodes || [];
+            for (const file of files) {
+                if (!file.sources || file.sources.length === 0)
+                    continue;
+                const mp4Source = file.sources.find((s) => s.mimeType.includes('mp4'));
+                const selectedSource = mp4Source || file.sources[0];
+                if (!selectedSource?.url)
+                    continue;
+                const videoIdentifier = (file.filename || selectedSource.url).toLowerCase();
+                for (const [filename, ref] of videoFilenameMap.entries()) {
+                    const nameWithoutExt = filename.replace(/\.[^/.]+$/, '').toLowerCase();
+                    if (videoIdentifier.includes(nameWithoutExt)) {
+                        urlMap.set(ref, {
+                            url: selectedSource.url,
+                            width: selectedSource.width,
+                            height: selectedSource.height,
+                        });
+                        videoFilenameMap.delete(filename);
+                        break;
+                    }
+                }
+                if (videoFilenameMap.size === 0)
+                    break;
+            }
+            if (videoFilenameMap.size > 0) {
+                logger_1.logger.warn('Unresolved videos', {
+                    filenames: Array.from(videoFilenameMap.keys()),
+                });
+            }
+        }
+        catch (error) {
+            logger_1.logger.error('Failed to fetch Files API media', {
+                error: error instanceof Error ? error.message : 'Unknown',
+            });
+        }
+    }
+    mediaFieldNames = new Set([
+        'image',
+        'image_web',
+        'image_mweb',
+        'image_mobile',
+        'video',
+        'video_web',
+        'video_mweb',
+        'video_mobile',
+    ]);
+    isMediaUrl(value) {
+        return (value.startsWith('https://') ||
+            value.startsWith('http://') ||
+            value.startsWith('//'));
+    }
+    replaceMediaReferences(curated, urlMap) {
+        const replaceInObject = (obj) => {
+            const result = { ...obj };
+            for (const [key, value] of Object.entries(result)) {
+                if (typeof value === 'string') {
+                    if (urlMap.has(value)) {
+                        const media = urlMap.get(value);
+                        result[key] = {
+                            url: media.url,
+                            width: media.width,
+                            height: media.height,
+                        };
+                    }
+                    else if (this.mediaFieldNames.has(key) && this.isMediaUrl(value)) {
+                        result[key] = {
+                            url: value,
+                            width: null,
+                            height: null,
+                        };
+                    }
+                    else if (this.mediaFieldNames.has(key) &&
+                        value.startsWith('shopify://')) {
+                        logger_1.logger.warn('Unresolved shopify:// media reference', {
+                            key,
+                            value,
+                        });
+                        result[key] = null;
+                    }
+                }
+                else if (typeof value === 'object' && value !== null) {
+                    if (Array.isArray(value)) {
+                        result[key] = value.map((item) => {
+                            if (typeof item === 'object' && item !== null) {
+                                return replaceInObject(item);
+                            }
+                            return item;
+                        });
+                    }
+                    else {
+                        result[key] = replaceInObject(value);
+                    }
+                }
+            }
+            return result;
+        };
+        const processBlock = (block) => {
+            const newBlock = { ...block };
+            if (newBlock.settings) {
+                newBlock.settings = replaceInObject(newBlock.settings);
+            }
+            if (newBlock.blocks) {
+                newBlock.blocks = newBlock.blocks.map(processBlock);
+            }
+            return newBlock;
+        };
+        return curated.map((section) => {
+            const newSection = { ...section };
+            if (newSection.settings) {
+                newSection.settings = replaceInObject(newSection.settings);
+            }
+            if (newSection.blocks) {
+                newSection.blocks = newSection.blocks.map(processBlock);
+            }
+            return newSection;
+        });
+    }
+};
+exports.ThemeContentService = ThemeContentService;
+exports.ThemeContentService = ThemeContentService = tslib_1.__decorate([
+    (0, common_1.Injectable)(),
+    tslib_1.__param(3, (0, common_1.Optional)()),
+    tslib_1.__param(3, (0, common_1.Inject)(theme_content_interfaces_1.THEME_COLLECTION_SERVICE)),
+    tslib_1.__param(4, (0, common_1.Optional)()),
+    tslib_1.__param(4, (0, common_1.Inject)(theme_content_interfaces_1.THEME_PRODUCT_SERVICE)),
+    tslib_1.__metadata("design:paramtypes", [cache_service_1.CacheService,
+        config_service_1.ConfigService,
+        shopify_theme_1.ShopifyThemeService, Object, Object])
+], ThemeContentService);
+//# sourceMappingURL=theme-content.service.js.map