@webbycrown/webbycommerce 1.2.1 → 2.0.0

package/server/src/controllers/productTag.js

@@ -0,0 +1,370 @@
+'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 = {
+  /**
+   * List tags
+   */
+  async getTags(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { search, limit = 50, start = 0 } = ctx.query;
+
+      // Strapi v5 stores drafts + published versions as separate rows (document model).
+      // For storefront APIs we only want published records, otherwise you can see duplicates.
+      const where = { publishedAt: { $notNull: true } };
+      if (search) {
+        where.name = { $containsi: search };
+      }
+
+      const tags = await strapi.db.query('plugin::webbycommerce.product-tag').findMany({
+        where,
+        limit: parseInt(limit, 10),
+        start: parseInt(start, 10),
+        orderBy: { createdAt: 'desc' },
+      });
+
+      const total = await strapi.db.query('plugin::webbycommerce.product-tag').count({ where });
+
+      ctx.send({ data: tags, meta: { total, limit: parseInt(limit, 10), start: parseInt(start, 10) } });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in getTags:`, error);
+      ctx.internalServerError('Failed to fetch tags. Please try again.');
+    }
+  },
+
+  /**
+   * Get single tag
+   */
+  async getTag(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const rawId = ctx.params?.id;
+      const idOrSlug = typeof rawId === 'string' ? decodeURIComponent(rawId).trim() : '';
+
+      if (!idOrSlug) {
+        return ctx.badRequest('Tag ID or slug is required.');
+      }
+
+      // Check if it's a numeric ID or a slug
+      const isNumericId = /^[0-9]+$/.test(idOrSlug);
+      let tag;
+
+      if (isNumericId) {
+        // Query by ID
+        tag = await strapi.db.query('plugin::webbycommerce.product-tag').findOne({
+          where: { id: idOrSlug },
+          populate: {
+            products: {
+              where: { publishedAt: { $notNull: true } },
+            },
+          },
+        });
+      } else {
+        // Query by slug
+        const results = await strapi.db.query('plugin::webbycommerce.product-tag').findMany({
+          where: { slug: idOrSlug, publishedAt: { $notNull: true } },
+          limit: 1,
+          orderBy: { publishedAt: 'desc', id: 'desc' },
+          populate: {
+            products: {
+              where: { publishedAt: { $notNull: true } },
+            },
+          },
+        });
+        
+        tag = results?.[0];
+      }
+
+      if (!tag) {
+        return ctx.notFound('Tag not found.');
+      }
+
+      // Filter and deduplicate products by documentId (Strapi v5 document model)
+      if (Array.isArray(tag?.products)) {
+        const publishedOnly = tag.products.filter((p) => p && p.publishedAt);
+        tag.products = uniqBy(publishedOnly, (p) => p.documentId || String(p.id));
+      }
+
+      ctx.send({ data: tag });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in getTag:`, error);
+      ctx.internalServerError('Failed to fetch tag. Please try again.');
+    }
+  },
+
+  /**
+   * Create tag
+   */
+  async createTag(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { name, slug } = ctx.request.body || {};
+
+      if (!name) {
+        return ctx.badRequest('Name is required.');
+      }
+
+      // Use entityService for Strapi v5 document model compatibility
+      // This ensures tags appear in the content manager
+      const tag = await strapi.entityService.create('plugin::webbycommerce.product-tag', {
+        data: {
+          name,
+          slug: slug || undefined,
+          publishedAt: new Date(), // Set publishedAt so it appears in content manager
+        },
+      });
+
+      // Re-fetch with populated relations
+      const populated = await strapi.entityService.findOne('plugin::webbycommerce.product-tag', tag.id, {
+        populate: ['products'],
+      });
+
+      ctx.send({ data: populated || tag });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in createTag:`, error);
+      ctx.internalServerError('Failed to create tag. Please try again.');
+    }
+  },
+
+  /**
+   * Update tag
+   */
+  async updateTag(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-tag').update({
+        where: { id },
+        data: updateData,
+      });
+
+      if (!updated) {
+        return ctx.notFound('Tag not found.');
+      }
+
+      ctx.send({ data: updated });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in updateTag:`, error);
+      ctx.internalServerError('Failed to update tag. Please try again.');
+    }
+  },
+
+  /**
+   * Delete tag
+   */
+  async deleteTag(ctx) {
+    try {
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { id } = ctx.params;
+
+      const existing = await strapi.db.query('plugin::webbycommerce.product-tag').findOne({ where: { id } });
+      if (!existing) {
+        return ctx.notFound('Tag not found.');
+      }
+
+      await strapi.db.query('plugin::webbycommerce.product-tag').delete({ where: { id } });
+
+      ctx.send({ data: { id } });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in deleteTag:`, error);
+      ctx.internalServerError('Failed to delete tag. 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 tags = await strapi.db.query('plugin::webbycommerce.product-tag').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'],
+      });
+
+      const total = await strapi.db.query('plugin::webbycommerce.product-tag').count({ where });
+
+      ctx.send({
+        data: tags,
+        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 tags.');
+    }
+  },
+
+  async findOne(ctx) {
+    try {
+      const rawId = ctx.params?.id;
+      const idOrSlug = typeof rawId === 'string' ? decodeURIComponent(rawId).trim() : '';
+
+      if (!idOrSlug) {
+        return ctx.badRequest('Tag ID or slug is required.');
+      }
+
+      // Check if it's a numeric ID or a slug
+      const isNumericId = /^[0-9]+$/.test(idOrSlug);
+      let tag;
+
+      if (isNumericId) {
+        // Query by ID
+        tag = await strapi.db.query('plugin::webbycommerce.product-tag').findOne({
+          where: { id: idOrSlug, publishedAt: { $notNull: true } },
+          populate: {
+            products: {
+              where: { publishedAt: { $notNull: true } },
+            },
+          },
+        });
+      } else {
+        // Query by slug
+        const results = await strapi.db.query('plugin::webbycommerce.product-tag').findMany({
+          where: { slug: idOrSlug, publishedAt: { $notNull: true } },
+          limit: 1,
+          orderBy: { publishedAt: 'desc', id: 'desc' },
+          populate: {
+            products: {
+              where: { publishedAt: { $notNull: true } },
+            },
+          },
+        });
+        
+        tag = results?.[0];
+      }
+
+      if (!tag) {
+        return ctx.notFound('Tag not found.');
+      }
+
+      // Filter and deduplicate products by documentId (Strapi v5 document model)
+      if (Array.isArray(tag?.products)) {
+        const publishedOnly = tag.products.filter((p) => p && p.publishedAt);
+        tag.products = uniqBy(publishedOnly, (p) => p.documentId || String(p.id));
+      }
+
+      ctx.send({ data: tag });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in findOne:`, error);
+      ctx.internalServerError('Failed to fetch tag.');
+    }
+  },
+
+  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 tag = await strapi.entityService.create('plugin::webbycommerce.product-tag', {
+        data,
+      });
+
+      const populated = await strapi.entityService.findOne('plugin::webbycommerce.product-tag', tag.id, {
+        populate: ['products'],
+      });
+
+      ctx.send({ data: populated || tag });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in create:`, error);
+      ctx.internalServerError('Failed to create tag.');
+    }
+  },
+
+  async update(ctx) {
+    try {
+      const { id } = ctx.params;
+      const data = ctx.request.body.data || ctx.request.body;
+
+      const tag = await strapi.db.query('plugin::webbycommerce.product-tag').update({
+        where: { id },
+        data,
+      });
+
+      if (!tag) {
+        return ctx.notFound('Tag not found.');
+      }
+
+      const populated = await strapi.db.query('plugin::webbycommerce.product-tag').findOne({
+        where: { id: tag.id },
+        populate: ['products'],
+      });
+
+      ctx.send({ data: populated || tag });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in update:`, error);
+      ctx.internalServerError('Failed to update tag.');
+    }
+  },
+
+  async delete(ctx) {
+    try {
+      const { id } = ctx.params;
+
+      const tag = await strapi.db.query('plugin::webbycommerce.product-tag').delete({
+        where: { id },
+      });
+
+      if (!tag) {
+        return ctx.notFound('Tag not found.');
+      }
+
+      ctx.send({ data: tag });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in delete:`, error);
+      ctx.internalServerError('Failed to delete tag.');
+    }
+  },
+};

package/server/src/controllers/productVariation.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const PLUGIN_ID = 'webbycommerce';
+const { ensureEcommercePermission } = require('../utils/check-ecommerce-permission');
+
+module.exports = {
+  // Standard Strapi controller methods for content manager
+  async find(ctx) {
+    try {
+      // Check ecommerce permission
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { limit = 25, start = 0, sort = 'createdAt:desc' } = ctx.query;
+
+      const variations = await strapi.db.query('plugin::webbycommerce.product-variation').findMany({
+        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: ['product', 'attributes', 'attributeValues'],
+      });
+
+      const total = await strapi.db.query('plugin::webbycommerce.product-variation').count();
+
+      ctx.send({
+        data: variations,
+        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 variations.');
+    }
+  },
+
+  async findOne(ctx) {
+    try {
+      // Check ecommerce permission
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const rawId = ctx.params?.id;
+      const idOrSlug = typeof rawId === 'string' ? decodeURIComponent(rawId).trim() : '';
+
+      if (!idOrSlug) {
+        return ctx.badRequest('Variation ID or slug is required.');
+      }
+
+      // Check if it's a numeric ID or a slug
+      const isNumericId = /^[0-9]+$/.test(idOrSlug);
+      let variation;
+
+      if (isNumericId) {
+        // Query by ID
+        variation = await strapi.db.query('plugin::webbycommerce.product-variation').findOne({
+          where: { id: idOrSlug },
+          populate: ['product', 'attributes', 'attributeValues'],
+        });
+      } else {
+        // Query by slug
+        const results = await strapi.db.query('plugin::webbycommerce.product-variation').findMany({
+          where: { slug: idOrSlug },
+          limit: 1,
+          orderBy: { id: 'desc' },
+          populate: ['product', 'attributes', 'attributeValues'],
+        });
+        
+        variation = results?.[0];
+      }
+
+      if (!variation) {
+        return ctx.notFound('Product variation not found.');
+      }
+
+      ctx.send({ data: variation });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in findOne:`, error);
+      ctx.internalServerError('Failed to fetch product variation.');
+    }
+  },
+
+  async create(ctx) {
+    try {
+      // Check ecommerce permission
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const data = ctx.request.body.data || ctx.request.body;
+
+      // Ensure slug is handled properly - if not provided, Strapi will auto-generate from name
+      if (data.slug === '') {
+        data.slug = undefined;
+      }
+
+      const variation = await strapi.db.query('plugin::webbycommerce.product-variation').create({ data });
+
+      const populated = await strapi.db.query('plugin::webbycommerce.product-variation').findOne({
+        where: { id: variation.id },
+        populate: ['product', 'attributes', 'attributeValues'],
+      });
+
+      ctx.send({ data: populated || variation });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in create:`, error);
+      ctx.internalServerError('Failed to create product variation.');
+    }
+  },
+
+  async update(ctx) {
+    try {
+      // Check ecommerce permission
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { id } = ctx.params;
+      const data = ctx.request.body.data || ctx.request.body;
+
+      // Ensure slug is handled properly - if empty string, set to undefined to allow auto-generation
+      if (data.slug === '') {
+        data.slug = undefined;
+      }
+
+      const variation = await strapi.db.query('plugin::webbycommerce.product-variation').update({
+        where: { id },
+        data,
+      });
+
+      if (!variation) {
+        return ctx.notFound('Product variation not found.');
+      }
+
+      const populated = await strapi.db.query('plugin::webbycommerce.product-variation').findOne({
+        where: { id: variation.id },
+        populate: ['product', 'attributes', 'attributeValues'],
+      });
+
+      ctx.send({ data: populated || variation });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in update:`, error);
+      ctx.internalServerError('Failed to update product variation.');
+    }
+  },
+
+  async delete(ctx) {
+    try {
+      // Check ecommerce permission
+      if (!(await ensureEcommercePermission(ctx))) {
+        return;
+      }
+
+      const { id } = ctx.params;
+
+      const variation = await strapi.db.query('plugin::webbycommerce.product-variation').delete({
+        where: { id },
+      });
+
+      if (!variation) {
+        return ctx.notFound('Product variation not found.');
+      }
+
+      ctx.send({ data: variation });
+    } catch (error) {
+      strapi.log.error(`[${PLUGIN_ID}] Error in delete:`, error);
+      ctx.internalServerError('Failed to delete product variation.');
+    }
+  },
+};