@evershop/evershop 1.0.0 → 1.1.0

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

@@ -0,0 +1,219 @@
+const uniqid = require('uniqid');
+const { value } = require('@evershop/postgres-query-builder');
+const {
+  OPERATION_MAP
+} = require('@evershop/evershop/src/lib/util/filterOperationMapp');
+const { getValueSync } = require('@evershop/evershop/src/lib/util/registry');
+
+module.exports = async function registerDefaultProductCollectionFilters() {
+  // List of default supported filters
+  const defaultFilters = [
+    {
+      key: 'keyword',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        const where = query.getWhere();
+        const bindingKey = `keyword_${uniqid()}`;
+        where.addRaw(
+          'AND',
+          `to_tsvector('simple', product_description.name || ' ' || product_description.description) @@ websearch_to_tsquery('simple', :${bindingKey})`,
+          {
+            [bindingKey]: value
+          }
+        );
+        currentFilters.push({
+          key: 'keyword',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'min_price',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        // Check if the value is a positive number
+        if (!Number.isNaN(parseFloat(value)) && parseFloat(value) > 0) {
+          query.andWhere('product.price', '>=', parseFloat(value));
+          currentFilters.push({
+            key: 'min_price',
+            operation,
+            value
+          });
+        }
+      }
+    },
+    {
+      key: 'max_price',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        if (!Number.isNaN(parseFloat(value)) && parseFloat(value) > 0) {
+          query.andWhere('product.price', '<=', parseFloat(value));
+          currentFilters.push({
+            key: 'max_price',
+            operation,
+            value
+          });
+        }
+      }
+    },
+    {
+      key: 'name',
+      operation: ['like'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'product_description.name',
+          OPERATION_MAP[operation],
+          `%${value}%`
+        );
+        currentFilters.push({
+          key: 'name',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'qty',
+      operation: ['eq', 'gteq', 'lteq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'product_inventory.qty',
+          OPERATION_MAP[operation],
+          parseFloat(value) || 0
+        );
+        currentFilters.push({
+          key: 'qty',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'sku',
+      operation: ['like', 'in'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'product.sku',
+          OPERATION_MAP[operation],
+          value.split(',')
+        );
+        currentFilters.push({
+          key: 'sku',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'status',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere('product.status', OPERATION_MAP[operation], value);
+        currentFilters.push({
+          key: 'status',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'type',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        if (['simple', 'configurable'].includes(value)) {
+          switch (value) {
+            case 'simple':
+              query.andWhere('product.variant_group_id', 'IS NULL', null);
+              break;
+            case 'configurable':
+              query.andWhere('product.variant_group_id', 'IS NOT NULL', null);
+              break;
+            default:
+              break;
+          }
+          currentFilters.push({
+            key: 'type',
+            operation,
+            value
+          });
+        }
+      }
+    },
+    {
+      key: 'cat',
+      operation: ['eq', 'in', 'nin'],
+      callback: (query, operation, value, currentFilters) => {
+        query.andWhere(
+          'product.category_id',
+          OPERATION_MAP[operation],
+          ['in', 'nin'].includes(operation) ? value.split(',') : value
+        );
+        currentFilters.push({
+          key: 'cat',
+          operation,
+          value
+        });
+      }
+    },
+    {
+      key: 'ob',
+      operation: ['eq'],
+      callback: (query, operation, value, currentFilters) => {
+        const productSortBy = getValueSync(
+          'productCollectionSortBy',
+          {
+            price: (query) => query.orderBy('product.price'),
+            name: (query) => query.orderBy('product_description.name'),
+            qty: (query) => query.orderBy('product_inventory.qty'),
+            status: (query) => query.orderBy('product.status')
+          },
+          {
+            isAdmin
+          }
+        );
+
+        if (productSortBy[value]) {
+          productSortBy[value](query, operation);
+          currentFilters.push({
+            key: 'ob',
+            operation,
+            value
+          });
+        } else {
+          query.orderBy('product.product_id', 'DESC');
+        }
+      }
+    }
+  ];
+
+  const { filterableAttributes } = this;
+  const { isAdmin } = this;
+  // Attribute filters
+  filterableAttributes.forEach((attribute) => {
+    defaultFilters.push({
+      key: attribute.attribute_code,
+      operation: ['in'],
+      callback: (query, operation, val, currentFilters) => {
+        const alias = `attribute_${uniqid()}`;
+        // Split the value by comma and only get the positive integer
+        const values = val
+          .split(',')
+          .map((v) => parseInt(v, 10))
+          .filter((v) => v > 0);
+        query
+          .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));
+        currentFilters.push({
+          key: attribute.attribute_code,
+          operation,
+          value: val
+        });
+      }
+    });
+  });
+
+  return defaultFilters;
+};

package/src/modules/catalog/subscribers/category_created/buildUrlRewrite.js

@@ -1,4 +1,4 @@
-const { error } = require('@evershop/evershop/src/lib/log/debuger');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
 const { pool } = require('@evershop/evershop/src/lib/postgres/connection');
 const {
   execute,

package/src/modules/catalog/subscribers/category_deleted/deleteUrlRewrite.js

@@ -1,4 +1,4 @@
-const { error } = require('@evershop/evershop/src/lib/log/debuger');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
 const { pool } = require('@evershop/evershop/src/lib/postgres/connection');
 const { execute, select } = require('@evershop/postgres-query-builder');
 

package/src/modules/catalog/subscribers/category_updated/builUrlRewrite.js

@@ -1,4 +1,4 @@
-const { error } = require('@evershop/evershop/src/lib/log/debuger');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
 const { pool } = require('@evershop/evershop/src/lib/postgres/connection');
 const {
   execute,

package/src/modules/catalog/subscribers/product_created/builUrlRewrite.js

@@ -1,4 +1,4 @@
-const { error } = require('@evershop/evershop/src/lib/log/debuger');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
 const { pool } = require('@evershop/evershop/src/lib/postgres/connection');
 const { select, insertOnUpdate } = require('@evershop/postgres-query-builder');
 

package/src/modules/catalog/subscribers/product_deleted/deleteUrlRewrite.js

@@ -7,6 +7,6 @@ module.exports = async function buildUrlReWrite(data) {
   // Delete the url rewrite for the product
   await execute(
     pool,
-    `DELETE FROM url_rewrite WHERE entity_uuid = ${productUuid} AND entity_type = 'product'`
+    `DELETE FROM url_rewrite WHERE entity_uuid = '${productUuid}' AND entity_type = 'product'`
   );
 };

package/src/modules/catalog/subscribers/product_image_added/localGenerateProductImageVariant.js

@@ -5,7 +5,7 @@ const sharp = require('sharp');
 const { update } = require('@evershop/postgres-query-builder');
 const { pool } = require('@evershop/evershop/src/lib/postgres/connection');
 const { CONSTANTS } = require('@evershop/evershop/src/lib/helpers');
-const { debug } = require('@evershop/evershop/src/lib/log/debuger');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
 
 module.exports = async function localGenerateProductImageVariant(data) {
   if (getConfig('system.file_storage') === 'local') {
@@ -55,8 +55,8 @@ module.exports = async function localGenerateProductImageVariant(data) {
         .where('product_image_product_id', '=', data.product_image_product_id)
         .and('origin_image', '=', data.origin_image)
         .execute(pool);
-    } catch (error) {
-      debug('critical', error);
+    } catch (e) {
+      error(e);
     }
   }
 };

package/src/modules/checkout/api/addCartShippingMethod/saveShippingMethod.js

@@ -4,6 +4,10 @@ const {
   INTERNAL_SERVER_ERROR,
   INVALID_PAYLOAD
 } = require('@evershop/evershop/src/lib/util/httpStatus');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
+const {
+  translate
+} = require('@evershop/evershop/src/lib/locale/translate/translate');
 const { getCartByUUID } = require('../../services/getCartByUUID');
 const { saveCart } = require('../../services/saveCart');
 
@@ -37,10 +41,11 @@ module.exports = async (request, response, delegate, next) => {
       next();
     }
   } catch (e) {
+    error(e);
     response.status(INTERNAL_SERVER_ERROR);
     response.json({
       error: {
-        message: e.message,
+        message: translate('Failed to set shipping method'),
         status: INTERNAL_SERVER_ERROR
       }
     });

package/src/modules/checkout/api/createCart/[context]bodyParser[auth].js

@@ -0,0 +1,5 @@
+const bodyParser = require('body-parser');
+
+module.exports = (request, response, delegate, next) => {
+  bodyParser.json({ inflate: false })(request, response, next);
+};

package/src/modules/checkout/api/createCart/createNewCart.js

@@ -0,0 +1,92 @@
+const {
+  INVALID_PAYLOAD,
+  INTERNAL_SERVER_ERROR,
+  OK
+} = require('@evershop/evershop/src/lib/util/httpStatus');
+const { getConfig } = require('@evershop/evershop/src/lib/util/getConfig');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
+const {
+  translate
+} = require('@evershop/evershop/src/lib/locale/translate/translate');
+const { setContextValue } = require('../../../graphql/services/contextHelper');
+const { saveCart } = require('../../services/saveCart');
+const { Cart } = require('../../services/cart/Cart');
+
+module.exports = async (request, response, delegate, next) => {
+  try {
+    const { items, customer_full_name, customer_email } = request.body;
+    const cartData = {
+      currency: getConfig('shop.currency', 'USD')
+    };
+    if (customer_full_name) {
+      cartData.customer_full_name = customer_full_name;
+    }
+    if (customer_email) {
+      cartData.customer_email = customer_email;
+    }
+    const cart = new Cart(cartData);
+    // Check if items is not an empty array
+    if (items.length === 0) {
+      response.status(INVALID_PAYLOAD);
+      response.json({
+        error: {
+          status: INVALID_PAYLOAD,
+          message: translate('Requires at least one item to create a cart')
+        }
+      });
+      return;
+    }
+    // Maximum 100 items per cart
+    if (items.length > 100) {
+      response.status(INVALID_PAYLOAD);
+      response.json({
+        error: {
+          status: INVALID_PAYLOAD,
+          message: translate('Too many items requested')
+        }
+      });
+      return;
+    }
+
+    // Loop through the items and group by sku
+    const groupedItems = items.reduce(
+      (acc, item) => {
+        if (acc.find((i) => i.sku === item.sku)) {
+          acc.find((i) => i.sku === item.sku).qty += item.qty;
+        } else {
+          acc.push(item);
+        }
+        return acc;
+      },
+      [{ sku: items[0].sku, qty: 0 }]
+    );
+    // Loop through the grouped items and add them to the cart
+    const cartItems = await Promise.all(
+      groupedItems.map(async (item) => {
+        const cartItem = await cart.addItem(item.sku, item.qty);
+        return cartItem;
+      })
+    );
+    await saveCart(cart);
+    // Set the new cart id to the context, so next middleware can use it
+    setContextValue(request, 'cartId', cart.getData('uuid'));
+    response.status(OK);
+    response.$body = {
+      data: {
+        items: cartItems.map((item) => item.export()),
+        count: cart.getItems().length,
+        cartId: cart.getData('uuid')
+      }
+    };
+    next();
+  } catch (e) {
+    error(e);
+    response.status(INTERNAL_SERVER_ERROR);
+    response.json({
+      error: {
+        status: INTERNAL_SERVER_ERROR,
+        message: e.message
+      }
+    });
+  }
+};

package/src/modules/checkout/api/createCart/payloadSchema.json

@@ -0,0 +1,44 @@
+{
+  "type": "object",
+  "properties": {
+    "customer_full_name": {
+      "type": "string"
+    },
+    "customer_email": {
+      "type": ["string"],
+      "format": "email",
+      "errorMessage": {
+        "type": "Email is invalid"
+      }
+    },
+    "items": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "properties": {
+          "sku": {
+            "type": "string"
+          },
+          "qty": {
+            "type": "integer"
+          }
+        },
+        "required": ["sku", "qty"],
+        "additionalProperties": true,
+        "errorMessage": {
+          "properties": {
+            "sku": "Sku is required",
+            "qty": "Qty is invalid"
+          }
+        }
+      }
+    }
+  },
+  "required": ["items"],
+  "errorMessage": {
+    "required": {
+      "items": "Must provide at least one item"
+    }
+  },
+  "additionalProperties": true
+}

package/src/modules/checkout/api/createCart/route.json

@@ -0,0 +1,5 @@
+{
+  "methods": ["POST"],
+  "path": "/carts",
+  "access": "public"
+}

package/src/modules/checkout/api/deleteShippingZone/deleteShippingZone.js

@@ -0,0 +1,58 @@
+/* eslint-disable camelcase */
+const {
+  rollback,
+  commit,
+  startTransaction,
+  del,
+  select
+} = require('@evershop/postgres-query-builder');
+const {
+  getConnection
+} = require('@evershop/evershop/src/lib/postgres/connection');
+const {
+  OK,
+  INTERNAL_SERVER_ERROR,
+  INVALID_PAYLOAD
+} = require('@evershop/evershop/src/lib/util/httpStatus');
+const { error } = require('@evershop/evershop/src/lib/log/logger');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, deledate, next) => {
+  const { id } = request.params;
+  const connection = await getConnection();
+  await startTransaction(connection);
+  try {
+    // Load the shipping zone
+    const shippingZone = await select()
+      .from('shipping_zone')
+      .where('uuid', '=', id)
+      .load(connection);
+
+    if (!shippingZone) {
+      response.status(INVALID_PAYLOAD);
+      response.json({
+        error: {
+          status: INVALID_PAYLOAD,
+          message: 'Invalid zone id'
+        }
+      });
+      return;
+    }
+    await del('shipping_zone').where('uuid', '=', id).execute(connection);
+    await commit(connection);
+    response.status(OK);
+    response.json({
+      data: shippingZone
+    });
+  } catch (e) {
+    error(e);
+    await rollback(connection);
+    response.status(INTERNAL_SERVER_ERROR);
+    response.json({
+      error: {
+        status: INTERNAL_SERVER_ERROR,
+        message: e.message
+      }
+    });
+  }
+};

package/src/modules/checkout/api/deleteShippingZone/route.json

@@ -0,0 +1,5 @@
+{
+  "methods": ["DELETE"],
+  "path": "/shippingZones/:id",
+  "access": "private"
+}

package/src/modules/checkout/api/deleteShippingZoneMethod/deleteShippingZoneMethod.js

@@ -0,0 +1,85 @@
+/* eslint-disable camelcase */
+const {
+  rollback,
+  commit,
+  startTransaction,
+  select,
+  del
+} = require('@evershop/postgres-query-builder');
+const {
+  getConnection
+} = require('@evershop/evershop/src/lib/postgres/connection');
+const {
+  OK,
+  INTERNAL_SERVER_ERROR,
+  INVALID_PAYLOAD
+} = require('@evershop/evershop/src/lib/util/httpStatus');
+
+// eslint-disable-next-line no-unused-vars
+module.exports = async (request, response, deledate, next) => {
+  const { method_id, zone_id } = request.params;
+  const connection = await getConnection();
+  await startTransaction(connection);
+  try {
+    // Load the shipping zone
+    const shippingZone = await select()
+      .from('shipping_zone')
+      .where('uuid', '=', zone_id)
+      .load(connection, false);
+
+    if (!shippingZone) {
+      response.status(INVALID_PAYLOAD);
+      response.json({
+        error: {
+          status: INVALID_PAYLOAD,
+          message: 'Invalid zone id'
+        }
+      });
+      return;
+    }
+
+    const zoneMethodQuery = select().from('shipping_method');
+    zoneMethodQuery
+      .innerJoin('shipping_zone_method')
+      .on(
+        'shipping_method.shipping_method_id',
+        '=',
+        'shipping_zone_method.method_id'
+      );
+    zoneMethodQuery
+      .where('shipping_zone_method.zone_id', '=', shippingZone.shipping_zone_id)
+      .and('shipping_method.uuid', '=', method_id);
+
+    const zoneMethod = await zoneMethodQuery.load(connection, false);
+    if (!zoneMethod) {
+      response.status(INVALID_PAYLOAD);
+      response.json({
+        error: {
+          status: INVALID_PAYLOAD,
+          message: 'Invalid method id'
+        }
+      });
+      return;
+    }
+
+    // Delete the shipping zone method
+    await del('shipping_zone_method')
+      .where('method_id', '=', zoneMethod.shipping_method_id)
+      .and('zone_id', '=', shippingZone.shipping_zone_id)
+      .execute(connection);
+    await commit(connection);
+    response.status(OK);
+    response.json({
+      data: zoneMethod
+    });
+  } catch (e) {
+    await rollback(connection);
+    response.status(INTERNAL_SERVER_ERROR);
+    response.json({
+      error: {
+        status: INTERNAL_SERVER_ERROR,
+        message: e.message
+      }
+    });
+  }
+};

package/src/modules/checkout/api/deleteShippingZoneMethod/route.json

@@ -0,0 +1,5 @@
+{
+  "methods": ["DELETE"],
+  "path": "/shippingZones/:zone_id/methods/:method_id",
+  "access": "private"
+}

package/src/modules/checkout/api/getShippingMethods/sendMethods.js

@@ -131,6 +131,43 @@ module.exports = async (request, response, delegate, next) => {
             ...method,
             cost: toPrice(jsonResponse.data.data.cost, true)
           };
+        } else if (method.weight_based_cost) {
+          const totalWeight = cart.total_weight;
+          const weightBasedCost = method.weight_based_cost
+            .map(({ min_weight, cost }) => ({
+              min_weight: parseFloat(min_weight),
+              cost: toPrice(cost)
+            }))
+            .sort((a, b) => a.min_weight - b.min_weight);
+
+          let cost = 0;
+          for (let i = 0; i < weightBasedCost.length; i += 1) {
+            if (totalWeight >= weightBasedCost[i].min_weight) {
+              cost = weightBasedCost[i].cost;
+            }
+          }
+          return {
+            ...method,
+            cost: toPrice(cost, true)
+          };
+        } else if (method.price_based_cost) {
+          const subTotal = toPrice(cart.sub_total);
+          const priceBasedCost = method.price_based_cost
+            .map(({ min_price, cost }) => ({
+              min_price: toPrice(min_price),
+              cost: toPrice(cost)
+            }))
+            .sort((a, b) => a.min_price - b.min_price);
+          let cost = 0;
+          for (let i = 0; i < priceBasedCost.length; i += 1) {
+            if (subTotal >= priceBasedCost[i].min_price) {
+              cost = priceBasedCost[i].cost;
+            }
+          }
+          return {
+            ...method,
+            cost: toPrice(cost, true)
+          };
         } else {
           return {
             ...method,

package/src/modules/checkout/api/updateShippingMethod/[context]borderParser[auth].js

@@ -0,0 +1,5 @@
+const bodyParser = require('body-parser');
+
+module.exports = (request, response, delegate, next) => {
+  bodyParser.json({ inflate: false })(request, response, next);
+};

package/src/modules/checkout/api/updateShippingMethod/payloadSchema.json

@@ -0,0 +1,12 @@
+{
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string"
+    }
+  },
+  "additionalProperties": true,
+  "required": [
+    "name"
+  ]
+}

package/src/modules/checkout/api/updateShippingMethod/route.json

@@ -0,0 +1,5 @@
+{
+  "methods": ["PATCH"],
+  "path": "/shippingMethods/:id",
+  "access": "private"
+}