@evershop/evershop 1.0.0 → 1.1.0

package/src/modules/catalog/services/ProductCollection.js

@@ -1,16 +1,24 @@
 const { camelCase } = require('@evershop/evershop/src/lib/util/camelCase');
 const { getConfig } = require('@evershop/evershop/src/lib/util/getConfig');
-const uniqid = require('uniqid');
-const { select, value, node } = require('@evershop/postgres-query-builder');
+
+const { select, node, sql } = require('@evershop/postgres-query-builder');
 const { pool } = require('@evershop/evershop/src/lib/postgres/connection');
+const { getValue } = require('@evershop/evershop/src/lib/util/registry');
 
 class ProductCollection {
   constructor(baseQuery) {
     this.baseQuery = baseQuery;
+    this.baseQuery.orderBy('product.product_id', 'DESC');
   }
 
-  async init(args, { filters = [] }, { user }) {
-    if (!user) {
+  /**
+   *
+   * @param {{key: String, operation: String, value: String}[]} filters
+   * @param {boolean} isAdmin
+   */
+  async init(filters = [], isAdmin = false) {
+    // If the user is not admin, we need to filter out the out of stock products and the disabled products
+    if (!isAdmin) {
       this.baseQuery.andWhere('product.status', '=', 1);
       if (getConfig('catalog.showOutOfStockProduct', false) === false) {
         this.baseQuery
@@ -23,210 +31,37 @@ class ProductCollection {
       }
     }
     const currentFilters = [];
-    // Keyword filter
-    const keywordFilter = filters.find((f) => f.key === 'keyword');
-    if (keywordFilter) {
-      const where = this.baseQuery.getWhere();
-      const bindingKey = `keyword_${uniqid()}`;
-      where.addRaw(
-        'AND',
-        `to_tsvector('simple', product_description.name || ' ' || product_description.description) @@ websearch_to_tsquery('simple', :${bindingKey})`,
-        {
-          [bindingKey]: keywordFilter.value
-        }
-      );
-      currentFilters.push({
-        key: 'keyword',
-        operation: '=',
-        value: keywordFilter.value
-      });
-    }
-
-    // Price filter
-    const minPrice = filters.find((f) => f.key === 'minPrice');
-    const maxPrice = filters.find((f) => f.key === 'maxPrice');
-    if (minPrice && Number.isNaN(parseFloat(minPrice.value)) === false) {
-      this.baseQuery.andWhere('product.price', '>=', minPrice.value);
-      currentFilters.push({
-        key: 'minPrice',
-        operation: '=',
-        value: minPrice.value
-      });
-    }
-    if (maxPrice && Number.isNaN(parseFloat(maxPrice.value)) === false) {
-      this.baseQuery.andWhere('product.price', '<=', maxPrice.value);
-      currentFilters.push({
-        key: 'maxPrice',
-        operation: '=',
-        value: maxPrice.value
-      });
-    }
-
-    // Name filter
-    const nameFilter = filters.find((f) => f.key === 'name');
-    if (nameFilter) {
-      this.baseQuery.andWhere(
-        'product_description.name',
-        'ILIKE',
-        `%${nameFilter.value}%`
-      );
-      currentFilters.push({
-        key: 'name',
-        operation: '=',
-        value: nameFilter.value
-      });
-    }
-
-    // Qty filter
-    const qtyFilter = filters.find((f) => f.key === 'qty');
-    if (qtyFilter) {
-      const [min, max] = qtyFilter.value.split('-').map((v) => parseFloat(v));
-      let currentQtyFilter;
-      if (Number.isNaN(min) === false) {
-        this.baseQuery.andWhere('product_inventory.qty', '>=', min);
-        currentQtyFilter = { key: 'qty', operation: '=', value: `${min}` };
-      }
-
-      if (Number.isNaN(max) === false) {
-        this.baseQuery.andWhere('product_inventory.qty', '<=', max);
-        currentQtyFilter = {
-          key: 'qty',
-          operation: '=',
-          value: `${currentQtyFilter.value}-${max}`
-        };
-      }
-      if (currentQtyFilter) {
-        currentFilters.push(currentQtyFilter);
-      }
-    }
-
-    // Sku filter
-    const skuFilter = filters.find((f) => f.key === 'sku');
-    if (skuFilter) {
-      // Support like, equal and IN
-      if (['LIKE', 'like'].includes(skuFilter.operation)) {
-        this.baseQuery.andWhere('product.sku', 'ILIKE', `%${skuFilter.value}%`);
-        currentFilters.push({
-          key: 'sku',
-          operation: 'like',
-          value: skuFilter.value
-        });
-      } else if (['IN', 'in'].includes(skuFilter.operation)) {
-        const values = skuFilter.value
-          .split(',')
-          .map((v) => v.trim())
-          .filter((v) => v.length > 0);
-        if (values.length > 0) {
-          this.baseQuery.andWhere('product.sku', 'IN', values);
-          currentFilters.push({
-            key: 'sku',
-            operation: 'in',
-            value: values.join(',')
-          });
-        }
-      } else {
-        this.baseQuery.andWhere('product.sku', '=', skuFilter.value);
-        currentFilters.push({
-          key: 'sku',
-          operation: '=',
-          value: skuFilter.value
-        });
-      }
-    }
-
-    // Status filter
-    const statusFilter = filters.find((f) => f.key === 'status');
-    if (statusFilter) {
-      this.baseQuery.andWhere('product.status', '=', statusFilter.value);
-      currentFilters.push({
-        key: 'status',
-        operation: '=',
-        value: statusFilter.value
-      });
-    }
-
-    // Apply category filters
-    const categoryFilter = filters.find((f) => f.key === 'cat');
-    if (categoryFilter) {
-      const values = categoryFilter.value
-        .split(',')
-        .map((v) => parseInt(v, 10))
-        .filter((v) => Number.isNaN(v) === false);
-      this.baseQuery.andWhere('product.category_id', 'IN', values);
-
-      currentFilters.push({
-        key: 'cat',
-        operation: '=',
-        value: values.join(',')
-      });
-    }
-
     // Attribute filter
     const filterableAttributes = await select()
       .from('attribute')
       .where('type', '=', 'select')
       .and('is_filterable', '=', 1)
       .execute(pool);
-    // Attribute filters
-    filters.forEach((filter) => {
-      const attribute = filterableAttributes.find(
-        (a) => a.attribute_code === filter.key
-      );
-      if (!attribute) {
-        return;
+    // Apply the filters
+    const productCollectionFilters = await getValue(
+      'productCollectionFilters',
+      [],
+      {
+        isAdmin,
+        filterableAttributes
       }
+    );
 
-      const values = filter.value
-        .split(',')
-        .map((v) => parseInt(v, 10))
-        .filter((v) => Number.isNaN(v) === false);
-      if (values.length > 0) {
-        const alias = `attribute_${uniqid()}`;
-        this.baseQuery
-          .innerJoin('product_attribute_value_index', alias)
-          .on(`${alias}.product_id`, '=', 'product.product_id')
-          .and(`${alias}.attribute_id`, '=', value(attribute.attribute_id))
-          .and(`${alias}.option_id`, 'IN', value(values));
+    productCollectionFilters.forEach((filter) => {
+      const check = filters.find(
+        (f) => f.key === filter.key && filter.operation.includes(f.operation)
+      );
+      if (filter.key === '*' || check) {
+        filter.callback(
+          this.baseQuery,
+          check?.operation,
+          check?.value,
+          currentFilters
+        );
       }
-      currentFilters.push({
-        key: filter.key,
-        operation: filter.operation,
-        value: values.join(',')
-      });
     });
 
-    const sortBy = filters.find((f) => f.key === 'sortBy');
-    const sortOrder = filters.find(
-      (f) =>
-        f.key === 'sortOrder' &&
-        ['ASC', 'DESC', 'asc', 'desc'].includes(f.value)
-    ) || { value: 'DESC' };
-    if (sortBy && sortBy.value === 'price') {
-      this.baseQuery.orderBy('product.price', sortOrder.value);
-      currentFilters.push({
-        key: 'sortBy',
-        operation: '=',
-        value: sortBy.value
-      });
-    } else if (sortBy && sortBy.value === 'name') {
-      this.baseQuery.orderBy('product_description.name`', sortOrder.value);
-      currentFilters.push({
-        key: 'sortBy',
-        operation: '=',
-        value: sortBy.value
-      });
-    } else {
-      this.baseQuery.orderBy('product.product_id', sortOrder.value);
-    }
-    if (sortOrder.key) {
-      currentFilters.push({
-        key: 'sortOrder',
-        operation: '=',
-        value: sortOrder.value
-      });
-    }
-
-    if (!user) {
+    if (!isAdmin) {
       // Visibility. For variant group
       const copy = this.baseQuery.clone();
       // Get all group that have at lease 1 item visibile
@@ -261,31 +96,30 @@ class ProductCollection {
       } else {
         this.baseQuery.andWhere('product.visibility', '=', 't');
       }
+    } else {
+      const onePerVariantGroupQuery = this.baseQuery.clone();
+      onePerVariantGroupQuery.removeLimit();
+      onePerVariantGroupQuery.select(
+        sql(
+          'DISTINCT ON (COALESCE(product.variant_group_id, random())) product.product_id',
+          'product_id'
+        )
+      );
+      onePerVariantGroupQuery.removeOrderBy();
+      const onePerGroup = await onePerVariantGroupQuery.execute(pool);
+      this.baseQuery.andWhere(
+        'product.product_id',
+        'IN',
+        onePerGroup.map((v) => v.product_id)
+      );
     }
 
     // Clone the main query for getting total right before doing the paging
     const totalQuery = this.baseQuery.clone();
     totalQuery.select('COUNT(product.product_id)', 'total');
     totalQuery.removeOrderBy();
-    // Paging
-    const page = filters.find((f) => f.key === 'page') || { value: 1 };
-    const limit = filters.find((f) => f.key === 'limit' && f.value > 0) || {
-      value: 20
-    }; // TODO: Get from the config
-    currentFilters.push({
-      key: 'page',
-      operation: '=',
-      value: page.value
-    });
-    currentFilters.push({
-      key: 'limit',
-      operation: '=',
-      value: limit.value
-    });
-    this.baseQuery.limit(
-      (page.value - 1) * parseInt(limit.value, 10),
-      parseInt(limit.value, 10)
-    );
+    totalQuery.removeLimit();
+
     this.currentFilters = currentFilters;
     this.totalQuery = totalQuery;
   }

package/src/modules/catalog/services/attribute/deleteProductAttribute.js

@@ -30,6 +30,21 @@ async function deleteAttribute(uuid, context) {
     if (!attribute) {
       throw new Error('Invalid attribute id');
     }
+
+    // Make sure the attribute is not being used in any variant group
+    const variantGroup = await select()
+      .from('variant_group')
+      .where('attribute_one', '=', attribute.attribute_id)
+      .or('attribute_two', '=', attribute.attribute_id)
+      .or('attribute_three', '=', attribute.attribute_id)
+      .or('attribute_four', '=', attribute.attribute_id)
+      .or('attribute_five', '=', attribute.attribute_id)
+      .load(connection);
+    if (variantGroup) {
+      throw new Error(
+        `The attribute "${attribute.attribute_name}" is being used in a variant group`
+      );
+    }
     await hookable(deleteAttributeData, { ...context, connection, attribute })(
       uuid,
       connection

package/src/modules/catalog/services/getAttributeGroupsBaseQuery.js

@@ -0,0 +1,3 @@
+const { select } = require('@evershop/postgres-query-builder');
+
+module.exports.getAttributeGroupsBaseQuery = () => select().from('attribute_group');

package/src/modules/catalog/services/getAttributesBaseQuery.js

@@ -0,0 +1,3 @@
+const { select } = require('@evershop/postgres-query-builder');
+
+module.exports.getAttributesBaseQuery = () => select().from('attribute');

package/src/modules/catalog/services/getCollectionsBaseQuery.js

@@ -2,6 +2,5 @@ const { select } = require('@evershop/postgres-query-builder');
 
 module.exports.getCollectionsBaseQuery = () => {
   const query = select().from('collection');
-
   return query;
 };

package/src/modules/catalog/services/product/updateProduct.js

@@ -16,7 +16,7 @@ const {
 const {
   getConnection
 } = require('@evershop/evershop/src/lib/postgres/connection');
-const { debug } = require('@evershop/evershop/src/lib/log/debuger');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
 const { getAjv } = require('../../../base/services/getAjv');
 const productDataSchema = require('./productDataSchema.json');
 
@@ -51,6 +51,12 @@ async function updateProductInventory(inventoryData, productId, connection) {
   }
 }
 
+/**
+ * @param {number} productId
+ * @param {[{attribute_code: string, value}]} attributes
+ * @param {*} connection
+ * @returns
+ */
 async function saveProductAttributes(productId, attributes, connection) {
   for (let i = 0; i < attributes.length; i += 1) {
     const attribute = attributes[i];
@@ -248,7 +254,7 @@ async function updateProductImages(images, productId, connection) {
         )
       );
     } catch (e) {
-      debug('critical', e);
+      error(e);
       throw e;
     }
   }

package/src/modules/catalog/services/registerDefaultAttributeCollectionFilters.js

@@ -0,0 +1,149 @@
+const {
+  OPERATION_MAP
+} = require('@evershop/evershop/src/lib/util/filterOperationMapp');
+const { getValueSync } = require('@evershop/evershop/src/lib/util/registry');
+
+module.exports = async function registerDefaultAttributeCollectionFilters() {
+  // List of default supported filters
+  const defaultFilters = [
+    {
+      key: 'name',
+      operation: ['like', 'nlike'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'attribute.attribute_name',
+          OPERATION_MAP[operation],
+          `%${value}%`
+        );
+        currentFilters.push({
+          key: 'name',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'code',
+      operation: ['eq', 'like', 'nlike', 'in'],
+      callback: (query, operation, value, currentFilters) => {
+        if (operation === 'in') {
+          query.andWhere(
+            'attribute.attribute_code',
+            OPERATION_MAP[operation],
+            value.split(',')
+          );
+        } else if (operation === 'eq') {
+          query.andWhere(
+            'attribute.attribute_code',
+            OPERATION_MAP[operation],
+            value
+          );
+        } else {
+          query.andWhere(
+            'attribute.attribute_code',
+            OPERATION_MAP[operation],
+            `%${value}%`
+          );
+        }
+        currentFilters.push({
+          key: 'code',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'group',
+      operation: ['in', 'eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query
+          .innerJoin('attribute_group_link')
+          .on(
+            'attribute.attribute_id',
+            '=',
+            'attribute_group_link.attribute_id'
+          );
+        query.andWhere(
+          'attribute_group_link.group_id',
+          OPERATION_MAP[operation],
+          value
+        );
+        currentFilters.push({
+          key: 'group',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'type',
+      operation: ['eq', 'neq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere('attribute.type', OPERATION_MAP[operation], value);
+        currentFilters.push({
+          key: 'type',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'is_required',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'attribute.is_required',
+          OPERATION_MAP[operation],
+          value
+        );
+        currentFilters.push({
+          key: 'is_required',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'is_filterable',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'attribute.is_filterable',
+          OPERATION_MAP[operation],
+          value
+        );
+        currentFilters.push({
+          key: 'is_filterable',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'ob',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        const attributeCollectionSortBy = getValueSync(
+          'attributeCollectionSortBy',
+          {
+            name: (query) => query.orderBy('attribute.name'),
+            type: (query) => query.orderBy('attribute.type'),
+            is_required: (query) => query.orderBy('attribute.is_required'),
+            is_filterable: (query) => query.orderBy('attribute.is_filterable')
+          }
+        );
+
+        if (attributeCollectionSortBy[value]) {
+          attributeCollectionSortBy[value](query, operation);
+          currentFilters.push({
+            key: 'ob',
+            operation,
+            value
+          });
+        }
+      }
+    }
+  ];
+
+  return defaultFilters;
+};

package/src/modules/catalog/services/registerDefaultCategoryCollectionFilters.js

@@ -0,0 +1,85 @@
+const {
+  OPERATION_MAP
+} = require('@evershop/evershop/src/lib/util/filterOperationMapp');
+const { getValueSync } = require('@evershop/evershop/src/lib/util/registry');
+
+module.exports = async function registerDefaultCategoryCollectionFilters() {
+  const { isAdmin } = this;
+  // List of default supported filters
+  const defaultFilters = [
+    {
+      key: 'name',
+      operation: ['like'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'category_description.name',
+          OPERATION_MAP[operation],
+          `%${value}%`
+        );
+        currentFilters.push({
+          key: 'name',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'status',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere('category.status', OPERATION_MAP[operation], value);
+        currentFilters.push({
+          key: 'status',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'include_in_nav',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'category.include_in_nav',
+          OPERATION_MAP[operation],
+          value
+        );
+        currentFilters.push({
+          key: 'include_in_nav',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'ob',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        const categorySortBy = getValueSync(
+          'categoryCollectionSortBy',
+          {
+            name: (query) => query.orderBy('category_description.name'),
+            include_in_nav: (query) => query.orderBy('category.include_in_nav'),
+            status: (query) => query.orderBy('category.status')
+          },
+          {
+            isAdmin
+          }
+        );
+
+        if (categorySortBy[value]) {
+          categorySortBy[value](query, operation);
+          currentFilters.push({
+            key: 'ob',
+            operation,
+            value
+          });
+        } else {
+          query.orderBy('category.category_id', 'DESC');
+        }
+      }
+    }
+  ];
+
+  return defaultFilters;
+};

package/src/modules/catalog/services/registerDefaultCollectionCollectionFilters.js

@@ -0,0 +1,65 @@
+const {
+  OPERATION_MAP
+} = require('@evershop/evershop/src/lib/util/filterOperationMapp');
+const { getValueSync } = require('@evershop/evershop/src/lib/util/registry');
+
+module.exports = async function registerDefaultCollectionCollectionFilters() {
+  // List of default supported filters
+  const defaultFilters = [
+    {
+      key: 'name',
+      operation: ['like'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'collection.name',
+          OPERATION_MAP[operation],
+          `%${value}%`
+        );
+        currentFilters.push({
+          key: 'name',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'code',
+      operation: ['like', 'eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'collection.code',
+          OPERATION_MAP[operation],
+          `%${value}%`
+        );
+        currentFilters.push({
+          key: 'code',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'ob',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        const collectionSortBy = getValueSync('collectionCollectionSortBy', {
+          name: (query) => query.orderBy('collection.name'),
+          code: (query) => query.orderBy('collection.code')
+        });
+
+        if (collectionSortBy[value]) {
+          collectionSortBy[value](query, operation);
+          currentFilters.push({
+            key: 'ob',
+            operation,
+            value
+          });
+        } else {
+          query.orderBy('collection.collection_id', 'DESC');
+        }
+      }
+    }
+  ];
+
+  return defaultFilters;
+};