@webbycrown/webbycommerce 1.2.0 → 2.0.0

package/server/src/controllers/category.js

@@ -0,0 +1,388 @@
+'use strict';
+
+const PLUGIN_ID = 'webbycommerce';
+const { ensureEcommercePermission } = require('../utils/check-ecommerce-permission');
+
+const uniqBy = (items, keyFn) => {
+  const seen = new Set();
+  return (Array.isArray(items) ? items : []).filter((item) => {
+    const key = keyFn(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+};
+
+module.exports = {
+  async getProductCategories(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { search, limit = 50, start = 0, publicationState, status, preview } = ctx.query;
+
+      // Strapi v5 stores drafts + published versions as separate rows (document model).
+      // For storefront/public APIs we should default to published records to avoid duplicates.
+      const includeDrafts =
+        preview === 'true' || publicationState === 'preview' || status === 'preview' || status === 'draft';
+
+      const where = {};
+      if (search) {
+        where.name = { $containsi: search };
+      }
+
+      if (!includeDrafts) {
+        where.publishedAt = { $notNull: true };
+      }
+
+      const productCategories = await strapi.db.query('plugin::webbycommerce.product-category').findMany({
+        where,
+        limit: parseInt(limit, 10),
+        start: parseInt(start, 10),
+        orderBy: { createdAt: 'desc' },
+        populate: includeDrafts
+          ? ['products', 'image']
+          : {
+              products: {
+                where: { publishedAt: { $notNull: true } },
+              },
+              image: true,
+            },
+      });
+
+      if (!includeDrafts && Array.isArray(productCategories)) {
+        for (const category of productCategories) {
+          if (Array.isArray(category?.products)) {
+            // Safety net in case relation-level filtering is not applied by the ORM in some scenarios.
+            const publishedOnly = category.products.filter((p) => p && p.publishedAt);
+            category.products = uniqBy(publishedOnly, (p) => p.documentId || String(p.id));
+          }
+        }
+      }
+
+      const total = await strapi.db.query('plugin::webbycommerce.product-category').count({ where });
+
+      ctx.send({ data: productCategories, meta: { total, limit: parseInt(limit, 10), start: parseInt(start, 10) } });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in getProductCategories:`, error);
+      ctx.internalServerError('Failed to fetch product categories. Please try again.');
+    }
+  },
+
+  async getProductCategory(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const rawId = ctx.params?.id;
+      const idOrSlug = typeof rawId === 'string' ? decodeURIComponent(rawId).trim() : '';
+      const { publicationState, status, preview } = ctx.query;
+      const includeDrafts =
+        preview === 'true' || publicationState === 'preview' || status === 'preview' || status === 'draft';
+
+      if (!idOrSlug) {
+        return ctx.badRequest('Category ID or slug is required.');
+      }
+
+      // Check if it's a numeric ID or a slug
+      const isNumericId = /^[0-9]+$/.test(idOrSlug);
+      let productCategory;
+
+      if (isNumericId) {
+        // Query by ID
+        productCategory = await strapi.db.query('plugin::webbycommerce.product-category').findOne({
+          where: includeDrafts ? { id: idOrSlug } : { id: idOrSlug, publishedAt: { $notNull: true } },
+          populate: includeDrafts
+            ? ['products', 'image', 'parent']
+            : {
+                products: {
+                  where: { publishedAt: { $notNull: true } },
+                },
+                image: true,
+                parent: true,
+              },
+        });
+      } else {
+        // Query by slug
+        const where = includeDrafts ? { slug: idOrSlug } : { slug: idOrSlug, publishedAt: { $notNull: true } };
+        
+        // For slug queries, we might get multiple results (drafts + published), so get the latest published one
+        const results = await strapi.db.query('plugin::webbycommerce.product-category').findMany({
+          where,
+          limit: 1,
+          orderBy: { publishedAt: 'desc', id: 'desc' },
+          populate: includeDrafts
+            ? ['products', 'image', 'parent']
+            : {
+                products: {
+                  where: { publishedAt: { $notNull: true } },
+                },
+                image: true,
+                parent: true,
+              },
+        });
+        
+        productCategory = results?.[0];
+      }
+
+      if (!productCategory) {
+        return ctx.notFound('Product category not found.');
+      }
+
+      if (!includeDrafts && Array.isArray(productCategory?.products)) {
+        const publishedOnly = productCategory.products.filter((p) => p && p.publishedAt);
+        productCategory.products = uniqBy(publishedOnly, (p) => p.documentId || String(p.id));
+      }
+
+      ctx.send({ data: productCategory });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in getProductCategory:`, error);
+      ctx.internalServerError('Failed to fetch product category. Please try again.');
+    }
+  },
+
+  async createProductCategory(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { name, slug, description, image, parent } = ctx.request.body || {};
+
+      if (!name) {
+        return ctx.badRequest('Name is required.');
+      }
+
+      const data = {
+        name,
+        slug: slug || undefined,
+        description: description || undefined,
+        image: image || undefined,
+        publishedAt: new Date(), // Set publishedAt so it appears in content manager
+      };
+
+      // Handle parent relation if provided
+      if (parent) {
+        data.parent = typeof parent === 'object' && parent.id ? parent.id : parent;
+      }
+
+      // Use entityService for Strapi v5 document model compatibility
+      // This ensures categories appear in the content manager
+      const productCategory = await strapi.entityService.create('plugin::webbycommerce.product-category', {
+        data,
+      });
+
+      // Re-fetch with populated relations
+      const populated = await strapi.entityService.findOne('plugin::webbycommerce.product-category', productCategory.id, {
+        populate: ['products', 'image', 'parent'],
+      });
+
+      ctx.send({ data: populated || productCategory });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in createProductCategory:`, error);
+      ctx.internalServerError('Failed to create product category. Please try again.');
+    }
+  },
+
+  async updateProductCategory(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { id } = ctx.params;
+      const updateData = ctx.request.body || {};
+
+      const updated = await strapi.db.query('plugin::webbycommerce.product-category').update({
+        where: { id },
+        data: updateData,
+      });
+
+      if (!updated) {
+        return ctx.notFound('Product category not found.');
+      }
+
+      ctx.send({ data: updated });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in updateProductCategory:`, error);
+      ctx.internalServerError('Failed to update product category. Please try again.');
+    }
+  },
+
+  async deleteProductCategory(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { id } = ctx.params;
+
+      const existing = await strapi.db.query('plugin::webbycommerce.product-category').findOne({ where: { id } });
+      if (!existing) {
+        return ctx.notFound('Product category not found.');
+      }
+
+      await strapi.db.query('plugin::webbycommerce.product-category').delete({ where: { id } });
+
+      ctx.send({ data: { id } });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in deleteProductCategory:`, error);
+      ctx.internalServerError('Failed to delete product category. Please try again.');
+    }
+  },
+
+  // Standard Strapi controller methods for content manager
+  async find(ctx) {
+    try {
+      const { search, limit = 25, start = 0, sort = 'createdAt:desc' } = ctx.query;
+
+      const where = { publishedAt: { $notNull: true } };
+
+      if (search) {
+        where.name = { $containsi: search };
+      }
+
+      const categories = await strapi.db.query('plugin::webbycommerce.product-category').findMany({
+        where,
+        limit: parseInt(limit, 10),
+        start: parseInt(start, 10),
+        orderBy: sort.split(':').reduce((acc, val, i) => {
+          if (i === 0) acc[val] = 'asc';
+          else acc[val] = 'desc';
+          return acc;
+        }, {}),
+        populate: ['products', 'image'],
+      });
+
+      const total = await strapi.db.query('plugin::webbycommerce.product-category').count({ where });
+
+      ctx.send({
+        data: categories,
+        meta: {
+          pagination: {
+            page: Math.floor(parseInt(start, 10) / parseInt(limit, 10)) + 1,
+            pageSize: parseInt(limit, 10),
+            pageCount: Math.ceil(total / parseInt(limit, 10)),
+            total,
+          },
+        },
+      });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in find:`, error);
+      ctx.internalServerError('Failed to fetch product categories.');
+    }
+  },
+
+  async findOne(ctx) {
+    try {
+      const rawId = ctx.params?.id;
+      const idOrSlug = typeof rawId === 'string' ? decodeURIComponent(rawId).trim() : '';
+
+      if (!idOrSlug) {
+        return ctx.badRequest('Category ID or slug is required.');
+      }
+
+      // Check if it's a numeric ID or a slug
+      const isNumericId = /^[0-9]+$/.test(idOrSlug);
+      let category;
+
+      if (isNumericId) {
+        // Query by ID
+        category = await strapi.db.query('plugin::webbycommerce.product-category').findOne({
+          where: { id: idOrSlug, publishedAt: { $notNull: true } },
+          populate: ['products', 'image', 'parent'],
+        });
+      } else {
+        // Query by slug
+        const results = await strapi.db.query('plugin::webbycommerce.product-category').findMany({
+          where: { slug: idOrSlug, publishedAt: { $notNull: true } },
+          limit: 1,
+          orderBy: { publishedAt: 'desc', id: 'desc' },
+          populate: ['products', 'image', 'parent'],
+        });
+        
+        category = results?.[0];
+      }
+
+      if (!category) {
+        return ctx.notFound('Product category not found.');
+      }
+
+      ctx.send({ data: category });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in findOne:`, error);
+      ctx.internalServerError('Failed to fetch product category.');
+    }
+  },
+
+  async create(ctx) {
+    try {
+      const data = ctx.request.body.data || ctx.request.body;
+
+      if (!data.publishedAt) {
+        data.publishedAt = new Date();
+      }
+
+      // Use entityService for Strapi v5 document model compatibility
+      const category = await strapi.entityService.create('plugin::webbycommerce.product-category', {
+        data,
+      });
+
+      const populated = await strapi.entityService.findOne('plugin::webbycommerce.product-category', category.id, {
+        populate: ['products', 'image', 'parent'],
+      });
+
+      ctx.send({ data: populated || category });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in create:`, error);
+      ctx.internalServerError('Failed to create product category.');
+    }
+  },
+
+  async update(ctx) {
+    try {
+      const { id } = ctx.params;
+      const data = ctx.request.body.data || ctx.request.body;
+
+      const category = await strapi.db.query('plugin::webbycommerce.product-category').update({
+        where: { id },
+        data,
+      });
+
+      if (!category) {
+        return ctx.notFound('Product category not found.');
+      }
+
+      const populated = await strapi.db.query('plugin::webbycommerce.product-category').findOne({
+        where: { id: category.id },
+        populate: ['products', 'image'],
+      });
+
+      ctx.send({ data: populated || category });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in update:`, error);
+      ctx.internalServerError('Failed to update product category.');
+    }
+  },
+
+  async delete(ctx) {
+    try {
+      const { id } = ctx.params;
+
+      const category = await strapi.db.query('plugin::webbycommerce.product-category').delete({
+        where: { id },
+      });
+
+      if (!category) {
+        return ctx.notFound('Product category not found.');
+      }
+
+      ctx.send({ data: category });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in delete:`, error);
+      ctx.internalServerError('Failed to delete product category.');
+    }
+  },
+};

package/server/src/controllers/compare.js

@@ -0,0 +1,246 @@
+'use strict';
+
+/**
+ * compare controller
+ */
+
+const { createCoreController } = require('@strapi/strapi').factories;
+
+module.exports = createCoreController('plugin::webbycommerce.compare', ({ strapi }) => ({
+  async getCompare(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const compare = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .findUserCompare(user.id);
+
+      if (!compare) {
+        // Return empty compare structure
+        return ctx.send({
+          data: {
+            id: null,
+            userId: user.id,
+            userEmail: user.email,
+            products: [],
+            category: null,
+            isPublic: false,
+            name: null,
+            notes: null,
+          },
+          meta: {
+            totalProducts: 0,
+            comparisonData: {},
+          },
+        });
+      }
+
+      const compareData = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .getCompareData(user.id);
+
+      ctx.send({
+        data: compare,
+        meta: {
+          totalProducts: compare?.products?.length || 0,
+          comparisonData: compareData.comparisonData,
+        },
+      });
+    } catch (error) {
+      strapi.log.error('Error fetching compare:', error);
+      ctx.badRequest('Failed to fetch compare list', { error: error.message });
+    }
+  },
+
+  async addToCompare(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const { productId } = ctx.request.body;
+      if (!productId) {
+        return ctx.badRequest('Product ID is required');
+      }
+
+      const compare = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .addProductToCompare(user.id, user.email, productId);
+
+      const compareData = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .getCompareData(user.id);
+
+      ctx.send({
+        data: compare,
+        meta: {
+          totalProducts: compare?.products?.length || 0,
+          comparisonData: compareData.comparisonData,
+        },
+        message: 'Product added to compare list successfully',
+      });
+    } catch (error) {
+      strapi.log.error('Error adding to compare:', error);
+      ctx.badRequest('Failed to add product to compare list', { error: error.message });
+    }
+  },
+
+  async removeFromCompare(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const { productId } = ctx.params;
+      if (!productId) {
+        return ctx.badRequest('Product ID is required');
+      }
+
+      const compare = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .removeProductFromCompare(user.id, productId);
+
+      const compareData = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .getCompareData(user.id);
+
+      ctx.send({
+        data: compare,
+        meta: {
+          totalProducts: compare?.products?.length || 0,
+          comparisonData: compareData.comparisonData,
+        },
+        message: 'Product removed from compare list successfully',
+      });
+    } catch (error) {
+      strapi.log.error('Error removing from compare:', error);
+      ctx.badRequest('Failed to remove product from compare list', { error: error.message });
+    }
+  },
+
+  async clearCompare(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const compare = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .clearCompare(user.id);
+
+      ctx.send({
+        data: compare,
+        meta: {
+          totalProducts: 0,
+          comparisonData: {},
+        },
+        message: 'Compare list cleared successfully',
+      });
+    } catch (error) {
+      strapi.log.error('Error clearing compare:', error);
+      ctx.badRequest('Failed to clear compare list', { error: error.message });
+    }
+  },
+
+  async updateCompare(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const { name, notes, isPublic } = ctx.request.body;
+
+      const compare = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .updateCompare(user.id, { name, notes, isPublic });
+
+      ctx.send({
+        data: compare,
+        message: 'Compare list updated successfully',
+      });
+    } catch (error) {
+      strapi.log.error('Error updating compare:', error);
+      ctx.badRequest('Failed to update compare list', { error: error.message });
+    }
+  },
+
+  async getComparisonData(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const compareData = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .getCompareData(user.id);
+
+      ctx.send({
+        data: compareData,
+      });
+    } catch (error) {
+      strapi.log.error('Error getting comparison data:', error);
+      ctx.badRequest('Failed to get comparison data', { error: error.message });
+    }
+  },
+
+  async checkCompareStatus(ctx) {
+    try {
+      const user = ctx.state.user;
+      if (!user) {
+        return ctx.unauthorized('Authentication required');
+      }
+
+      const { productIds } = ctx.query;
+      if (!productIds) {
+        return ctx.badRequest('Product IDs are required');
+      }
+
+      const compare = await strapi
+        .plugin('webbycommerce')
+        .service('compare')
+        .findUserCompare(user.id);
+
+      const productIdArray = Array.isArray(productIds)
+        ? productIds.map(id => parseInt(id))
+        : [parseInt(productIds)];
+
+      const inCompare = {};
+      if (compare && compare.products && Array.isArray(compare.products)) {
+        productIdArray.forEach(productId => {
+          inCompare[productId] = compare.products.some(product => {
+            const productIdValue = typeof product === 'object' && product !== null ? product.id : product;
+            return productIdValue === productId;
+          });
+        });
+      } else {
+        productIdArray.forEach(productId => {
+          inCompare[productId] = false;
+        });
+      }
+
+      ctx.send({
+        data: inCompare,
+      });
+    } catch (error) {
+      strapi.log.error('Error checking compare status:', error);
+      ctx.badRequest('Failed to check compare status', { error: error.message });
+    }
+  },
+}));