@lodashventure/medusa-brand 1.1.0

package/dist/api/admin/brands/[id]/logo/route.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE = exports.POST = exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const upload_brand_image_1 = require("../../../../../workflows/upload-brand-image");
+const gcs_direct_upload_1 = require("../../../../../services/gcs-direct-upload");
+// GET - Get brand logo
+const GET = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    try {
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        return res.json({
+            logo: brand.logo || null,
+        });
+    }
+    catch (error) {
+        console.error("Error fetching brand logo:", error);
+        return res.status(500).json({ error: "Failed to fetch brand logo" });
+    }
+};
+exports.GET = GET;
+// POST - Upload brand logo
+const POST = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        const file = req.file;
+        if (!file) {
+            return res.status(400).json({ error: "No file uploaded" });
+        }
+        // Validate file type
+        const allowedMimeTypes = ['image/jpeg', 'image/jpg', 'image/png', 'image/gif', 'image/webp', 'image/svg+xml'];
+        if (!allowedMimeTypes.includes(file.mimetype)) {
+            return res.status(400).json({
+                error: "Invalid file type. Only JPEG, PNG, GIF, WebP, and SVG images are allowed."
+            });
+        }
+        // Validate file size (max 2MB for logos)
+        if (file.size > 2 * 1024 * 1024) {
+            return res.status(400).json({
+                error: "File size too large. Maximum allowed size is 2MB."
+            });
+        }
+        const result = await (0, upload_brand_image_1.uploadBrandImageWorkflow)(req.scope).run({
+            input: {
+                brandId: id,
+                imageType: "logo",
+                fileData: {
+                    filename: file.originalname,
+                    mimeType: file.mimetype,
+                    content: file.buffer.toString("base64"),
+                },
+            },
+        });
+        return res.json({
+            brand: {
+                id,
+                logo: result.result.imageUrl,
+            },
+        });
+    }
+    catch (error) {
+        logger.error("Error uploading brand logo:", error);
+        return res.status(500).json({ error: "Failed to upload brand logo" });
+    }
+};
+exports.POST = POST;
+// DELETE - Delete brand logo
+const DELETE = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const gcsUploadService = new gcs_direct_upload_1.GcsDirectUploadService();
+    try {
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        if (!brand.logo) {
+            return res.status(404).json({ error: "No logo found for this brand" });
+        }
+        // Delete the file from GCS
+        if (brand.logo.includes('storage.googleapis.com')) {
+            try {
+                const parts = brand.logo.split('/');
+                const bucketIndex = parts.indexOf('sangaroon');
+                if (bucketIndex !== -1 && bucketIndex < parts.length - 1) {
+                    const filename = parts.slice(bucketIndex + 1).join('/');
+                    await gcsUploadService.deleteFile(filename);
+                }
+            }
+            catch (deleteError) {
+                logger.error("Error deleting file from GCS:", deleteError);
+                // Continue even if file deletion fails
+            }
+        }
+        await brandService.updateBrands([
+            { id: brand.id, logo: null }
+        ]);
+        return res.json({
+            message: "Brand logo deleted successfully",
+        });
+    }
+    catch (error) {
+        logger.error("Error deleting brand logo:", error);
+        return res.status(500).json({ error: "Failed to delete brand logo" });
+    }
+};
+exports.DELETE = DELETE;

package/dist/api/admin/brands/[id]/products/route.d.ts

@@ -0,0 +1,2 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+export declare const GET: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;

package/dist/api/admin/brands/[id]/products/route.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+// GET - Get all products for a brand
+const GET = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const productModuleService = req.scope.resolve(utils_1.Modules.PRODUCT);
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        const { limit = 20, offset = 0, } = req.query;
+        // Verify brand exists
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        // Get all product-brand associations for this brand
+        const productBrands = await brandService.listProductBrands({
+            brand_id: id,
+        });
+        if (productBrands.length === 0) {
+            return res.json({
+                products: [],
+                count: 0,
+                offset: Number(offset),
+                limit: Number(limit),
+            });
+        }
+        // Get product IDs
+        const productIds = productBrands.map((pb) => pb.product_id);
+        // Fetch products from product module
+        const products = await productModuleService.listProducts({
+            id: productIds,
+        });
+        const count = await productModuleService.listProducts({
+            id: productIds,
+        }).then((result) => result.length);
+        return res.json({
+            products,
+            count,
+            offset: Number(offset),
+            limit: Number(limit),
+        });
+    }
+    catch (error) {
+        logger.error(`Error getting products for brand ${id}:`, error);
+        return res.status(500).json({ error: "Failed to get brand products" });
+    }
+};
+exports.GET = GET;

package/dist/api/admin/brands/[id]/route.d.ts

@@ -0,0 +1,5 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { UpdateBrandRequest } from "../../../../types";
+export declare const GET: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;
+export declare const PUT: (req: MedusaRequest<UpdateBrandRequest>, res: MedusaResponse) => Promise<MedusaResponse>;
+export declare const DELETE: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;

package/dist/api/admin/brands/[id]/route.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE = exports.PUT = exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const gcs_direct_upload_1 = require("../../../../services/gcs-direct-upload");
+// GET - Get a specific brand by ID
+const GET = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        return res.json({ brand });
+    }
+    catch (error) {
+        logger.error(`Error retrieving brand ${id}:`, error);
+        return res.status(500).json({ error: "Failed to retrieve brand" });
+    }
+};
+exports.GET = GET;
+// PUT - Update a brand
+const PUT = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        const { name, slug, description, website, is_active, metadata, } = req.body;
+        // Check if new slug conflicts with another brand
+        if (slug && slug !== brand.slug) {
+            const existingBrand = await brandService.listBrands({ slug }).then((result) => result[0]);
+            if (existingBrand && existingBrand.id !== id) {
+                return res.status(400).json({
+                    error: "Brand with this slug already exists"
+                });
+            }
+        }
+        const updateData = {
+            id,
+        };
+        if (name !== undefined)
+            updateData.name = name;
+        if (slug !== undefined)
+            updateData.slug = slug;
+        if (description !== undefined)
+            updateData.description = description;
+        if (website !== undefined)
+            updateData.website = website;
+        if (is_active !== undefined)
+            updateData.is_active = is_active;
+        if (metadata !== undefined)
+            updateData.metadata = metadata;
+        const updatedBrand = await brandService.updateBrands([updateData]).then((result) => result[0]);
+        return res.json({ brand: updatedBrand });
+    }
+    catch (error) {
+        logger.error(`Error updating brand ${id}:`, error);
+        return res.status(500).json({ error: "Failed to update brand" });
+    }
+};
+exports.PUT = PUT;
+// DELETE - Delete a brand
+const DELETE = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    const gcsUploadService = new gcs_direct_upload_1.GcsDirectUploadService();
+    try {
+        const brand = await brandService.retrieveBrand(id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        // Delete images from GCS if they exist
+        const imagesToDelete = [brand.image, brand.logo].filter(Boolean);
+        for (const imageUrl of imagesToDelete) {
+            if (imageUrl.includes('storage.googleapis.com')) {
+                try {
+                    const parts = imageUrl.split('/');
+                    const bucketIndex = parts.indexOf('sangaroon');
+                    if (bucketIndex !== -1 && bucketIndex < parts.length - 1) {
+                        const filename = parts.slice(bucketIndex + 1).join('/');
+                        await gcsUploadService.deleteFile(filename);
+                    }
+                }
+                catch (error) {
+                    logger.error(`Failed to delete image ${imageUrl}:`, error);
+                    // Continue even if image deletion fails
+                }
+            }
+        }
+        // Delete product-brand associations
+        const productBrands = await brandService.listProductBrands({ brand_id: id });
+        if (productBrands.length > 0) {
+            await brandService.deleteProductBrands(productBrands.map((pb) => pb.id));
+        }
+        // Delete the brand
+        await brandService.deleteBrands([id]);
+        return res.json({ message: "Brand deleted successfully" });
+    }
+    catch (error) {
+        logger.error(`Error deleting brand ${id}:`, error);
+        return res.status(500).json({ error: "Failed to delete brand" });
+    }
+};
+exports.DELETE = DELETE;

package/dist/api/admin/brands/route.d.ts

@@ -0,0 +1,4 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { CreateBrandRequest } from "../../../types";
+export declare const GET: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;
+export declare const POST: (req: MedusaRequest<CreateBrandRequest>, res: MedusaResponse) => Promise<MedusaResponse>;

package/dist/api/admin/brands/route.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POST = exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+// GET - List all brands with filters
+const GET = async (req, res) => {
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        const { is_active, q, limit = 20, offset = 0, } = req.query;
+        const filters = {};
+        if (is_active !== undefined) {
+            filters.is_active = is_active === 'true';
+        }
+        if (q) {
+            filters.$or = [
+                { name: { $ilike: `%${q}%` } },
+                { description: { $ilike: `%${q}%` } },
+            ];
+        }
+        const [brands, count] = await Promise.all([
+            brandService.listBrands(filters, {
+                limit: Number(limit),
+                offset: Number(offset),
+                order: { created_at: "DESC" },
+            }),
+            brandService.listBrands(filters).then((result) => result.length)
+        ]);
+        return res.json({
+            brands,
+            count,
+            offset: Number(offset),
+            limit: Number(limit),
+        });
+    }
+    catch (error) {
+        logger.error("Error listing brands:", error);
+        return res.status(500).json({ error: "Failed to list brands" });
+    }
+};
+exports.GET = GET;
+// POST - Create a new brand
+const POST = async (req, res) => {
+    const brandService = req.scope.resolve("brandCustom");
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        const { name, slug, description, website, is_active = true, metadata, } = req.body;
+        if (!name || !slug) {
+            return res.status(400).json({
+                error: "Name and slug are required"
+            });
+        }
+        // Check if slug already exists
+        const existingBrand = await brandService.listBrands({ slug }).then((result) => result[0]);
+        if (existingBrand) {
+            return res.status(400).json({
+                error: "Brand with this slug already exists"
+            });
+        }
+        const brand = await brandService.createBrands([{
+                name,
+                slug,
+                description,
+                website,
+                is_active,
+                metadata,
+            }]).then((result) => result[0]);
+        return res.status(201).json({ brand });
+    }
+    catch (error) {
+        logger.error("Error creating brand:", error);
+        return res.status(500).json({ error: "Failed to create brand" });
+    }
+};
+exports.POST = POST;

package/dist/api/admin/products/[id]/brand/route.d.ts

@@ -0,0 +1,5 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+import { SetBrandRequest } from "../../../../../types";
+export declare const GET: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;
+export declare const POST: (req: MedusaRequest<SetBrandRequest>, res: MedusaResponse) => Promise<MedusaResponse>;
+export declare const DELETE: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;

package/dist/api/admin/products/[id]/brand/route.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DELETE = exports.POST = exports.GET = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+// GET - Get brand for a product
+const GET = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const productModuleService = req.scope.resolve(utils_1.Modules.PRODUCT);
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        // Verify product exists
+        const product = await productModuleService.retrieveProduct(id);
+        if (!product) {
+            return res.status(404).json({ error: "Product not found" });
+        }
+        // Get product-brand association
+        const productBrand = await brandService.listProductBrands({
+            product_id: id,
+        }).then((result) => result[0]);
+        if (!productBrand) {
+            return res.json({ brand: null });
+        }
+        // Get brand details
+        const brand = await brandService.retrieveBrand(productBrand.brand_id);
+        return res.json({ brand });
+    }
+    catch (error) {
+        logger.error(`Error getting brand for product ${id}:`, error);
+        return res.status(500).json({ error: "Failed to get product brand" });
+    }
+};
+exports.GET = GET;
+// POST - Assign a brand to a product
+const POST = async (req, res) => {
+    const { id } = req.params;
+    const { brand_id } = req.body;
+    const brandService = req.scope.resolve("brandCustom");
+    const productModuleService = req.scope.resolve(utils_1.Modules.PRODUCT);
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        if (!brand_id) {
+            return res.status(400).json({ error: "brand_id is required" });
+        }
+        // Verify product exists
+        const product = await productModuleService.retrieveProduct(id);
+        if (!product) {
+            return res.status(404).json({ error: "Product not found" });
+        }
+        // Verify brand exists
+        const brand = await brandService.retrieveBrand(brand_id);
+        if (!brand) {
+            return res.status(404).json({ error: "Brand not found" });
+        }
+        // Check if product already has a brand
+        const existingProductBrand = await brandService.listProductBrands({
+            product_id: id,
+        }).then((result) => result[0]);
+        if (existingProductBrand) {
+            // Update existing association
+            await brandService.updateProductBrands([{
+                    id: existingProductBrand.id,
+                    brand_id: brand_id,
+                }]);
+        }
+        else {
+            // Create new association
+            await brandService.createProductBrands([{
+                    product_id: id,
+                    brand_id: brand_id,
+                }]);
+        }
+        return res.json({
+            message: "Brand assigned successfully",
+            product_id: id,
+            brand_id: brand_id,
+        });
+    }
+    catch (error) {
+        logger.error(`Error assigning brand to product ${id}:`, error);
+        return res.status(500).json({ error: "Failed to assign brand to product" });
+    }
+};
+exports.POST = POST;
+// DELETE - Remove brand from a product
+const DELETE = async (req, res) => {
+    const { id } = req.params;
+    const brandService = req.scope.resolve("brandCustom");
+    const productModuleService = req.scope.resolve(utils_1.Modules.PRODUCT);
+    const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+    try {
+        // Verify product exists
+        const product = await productModuleService.retrieveProduct(id);
+        if (!product) {
+            return res.status(404).json({ error: "Product not found" });
+        }
+        // Get product-brand association
+        const productBrand = await brandService.listProductBrands({
+            product_id: id,
+        }).then((result) => result[0]);
+        if (!productBrand) {
+            return res.status(404).json({ error: "Product has no brand assigned" });
+        }
+        // Delete the association
+        await brandService.deleteProductBrands([productBrand.id]);
+        return res.json({
+            message: "Brand removed from product successfully",
+            product_id: id,
+        });
+    }
+    catch (error) {
+        logger.error(`Error removing brand from product ${id}:`, error);
+        return res.status(500).json({ error: "Failed to remove brand from product" });
+    }
+};
+exports.DELETE = DELETE;

package/dist/api/middlewares/attach-brand-to-products.d.ts

@@ -0,0 +1,2 @@
+import { MedusaRequest, MedusaResponse, MedusaNextFunction } from "@medusajs/framework/http";
+export declare function attachBrandToProducts(req: MedusaRequest, res: MedusaResponse, next: MedusaNextFunction): Promise<void>;

package/dist/api/middlewares/attach-brand-to-products.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachBrandToProducts = attachBrandToProducts;
+const utils_1 = require("@medusajs/framework/utils");
+// Middleware to attach brand information to product responses
+async function attachBrandToProducts(req, res, next) {
+    // Store original json method
+    const originalJson = res.json.bind(res);
+    // Override json method to inject brand data
+    res.json = function (data) {
+        const brandService = req.scope.resolve("brandCustom");
+        const logger = req.scope.resolve(utils_1.ContainerRegistrationKeys.LOGGER);
+        // Process asynchronously and then call original json
+        (async () => {
+            try {
+                // Handle single product response (admin and store)
+                if (data?.product?.id) {
+                    try {
+                        // Get product-brand association
+                        const productBrand = await brandService.listProductBrands({
+                            product_id: data.product.id,
+                        }).then((result) => result[0]);
+                        if (productBrand) {
+                            // Get brand details
+                            const brand = await brandService.retrieveBrand(productBrand.brand_id);
+                            data.product.brand = brand;
+                        }
+                        else {
+                            data.product.brand = null;
+                        }
+                    }
+                    catch (error) {
+                        logger.error(`Error attaching brand to product ${data.product.id}:`, error);
+                        data.product.brand = null;
+                    }
+                }
+                // Handle multiple products response
+                if (data?.products && Array.isArray(data.products)) {
+                    const productIds = data.products.map((p) => p.id);
+                    try {
+                        // Get all product-brand associations for these products
+                        const productBrands = await brandService.listProductBrands({
+                            product_id: { $in: productIds },
+                        });
+                        // Create a map for quick lookup
+                        const brandMap = new Map();
+                        const productBrandMap = new Map();
+                        // Map product brands for quick lookup
+                        productBrands.forEach((pb) => {
+                            productBrandMap.set(pb.product_id, pb.brand_id);
+                        });
+                        // Fetch all unique brand IDs
+                        const brandIds = [...new Set(productBrands.map((pb) => pb.brand_id))];
+                        if (brandIds.length > 0) {
+                            // Fetch all brands at once
+                            const brands = await Promise.all(brandIds.map((id) => brandService.retrieveBrand(id).catch(() => null)));
+                            // Map brands by ID
+                            brands.forEach((brand) => {
+                                if (brand) {
+                                    brandMap.set(brand.id, brand);
+                                }
+                            });
+                            // Attach brands to products
+                            data.products = data.products.map((product) => {
+                                const brandId = productBrandMap.get(product.id);
+                                if (brandId && brandMap.has(brandId)) {
+                                    product.brand = brandMap.get(brandId);
+                                }
+                                else {
+                                    product.brand = null;
+                                }
+                                return product;
+                            });
+                        }
+                        else {
+                            // No brands found, set all to null
+                            data.products = data.products.map((product) => {
+                                product.brand = null;
+                                return product;
+                            });
+                        }
+                    }
+                    catch (error) {
+                        logger.error("Error attaching brands to products:", error);
+                        // On error, set all brands to null
+                        data.products = data.products.map((product) => {
+                            product.brand = null;
+                            return product;
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                // Silently fail and continue without brand data
+                console.error("Brand middleware error:", error);
+            }
+            // Call original json method with potentially modified data
+            originalJson(data);
+        })();
+        // Return the response object synchronously
+        return res;
+    };
+    next();
+}

package/dist/api/middlewares.d.ts

@@ -0,0 +1,6 @@
+import { attachBrandToProducts } from "./middlewares/attach-brand-to-products";
+export declare const config: {
+    method: string[];
+    matcher: string;
+    middlewares: (typeof attachBrandToProducts)[];
+}[];

package/dist/api/middlewares.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.config = void 0;
+const attach_brand_to_products_1 = require("./middlewares/attach-brand-to-products");
+exports.config = [
+    {
+        method: ["GET"],
+        matcher: "/admin/products",
+        middlewares: [attach_brand_to_products_1.attachBrandToProducts],
+    },
+    {
+        method: ["GET"],
+        matcher: "/admin/products/:id",
+        middlewares: [attach_brand_to_products_1.attachBrandToProducts],
+    },
+    {
+        method: ["GET"],
+        matcher: "/store/products",
+        middlewares: [attach_brand_to_products_1.attachBrandToProducts],
+    },
+    {
+        method: ["GET"],
+        matcher: "/store/products/:id",
+        middlewares: [attach_brand_to_products_1.attachBrandToProducts],
+    },
+];

package/dist/api/store/brands/route.d.ts

@@ -0,0 +1,2 @@
+import { MedusaRequest, MedusaResponse } from "@medusajs/framework/http";
+export declare const GET: (req: MedusaRequest, res: MedusaResponse) => Promise<MedusaResponse>;