@evershop/evershop 1.0.0-beta

package/src/modules/catalog/graphql/types/Attribute/Attribute.resolvers.js

@@ -0,0 +1,171 @@
+const { select } = require('@evershop/mysql-query-builder');
+const { buildUrl } = require('../../../../../lib/router/buildUrl');
+const { camelCase } = require('../../../../../lib/util/camelCase');
+
+module.exports = {
+  Query: {
+    attribute: async (_, { id }, { pool }) => {
+      const attribute = await select().from('attribute').where('attribute_id', '=', id).load(pool);
+      if (!attribute) {
+        return null;
+      } else {
+        return camelCase(attribute);
+      }
+    },
+    attributes: async (_, { filters = [] }, { pool }) => {
+      const query = select().from('attribute');
+
+      const currentFilters = [];
+
+      filters = filters.map(filter => {
+        if (filter.operation.toUpperCase() === 'LIKE') {
+          filter.valueRaw = codeFilter.value.replace(/^%/, '').replace(/%$/, '');
+        } else {
+          filter.valueRaw = filter.value;
+        }
+        if (filter.operation.toUpperCase() === 'IN') {
+          filter.value = filter.value.split(',');
+        }
+        return filter;
+      })
+
+      // Name filter
+      const nameFilter = filters.find((f) => f.key === 'name');
+      if (nameFilter) {
+        query.andWhere('attribute.`attribute_name`', nameFilter.operation, nameFilter.value);
+        currentFilters.push({ key: 'name', operation: nameFilter.operation, value: nameFilter.value });
+      }
+
+      // Code filter
+      const codeFilter = filters.find((f) => f.key === 'code');
+      if (codeFilter) {
+        query.andWhere('attribute.`attribute_code`', codeFilter.operation, codeFilter.value);
+        currentFilters.push({ key: 'code', operation: codeFilter.operation, value: codeFilter.valueRaw });
+      }
+
+      // Code filter
+      const groupFilter = filters.find((f) => f.key === 'group');
+      if (groupFilter) {
+        const attributes = await select()
+          .from('attribute_group_link')
+          .where('group_id', groupFilter.operation, groupFilter.value)
+          .execute(pool);
+
+        query.andWhere('attribute.`attribute_id`', 'IN', attributes.map(a => a.attribute_id));
+        currentFilters.push({ key: 'group', operation: groupFilter.operation, value: groupFilter.valueRaw });
+      }
+
+      // Type filter
+      const typeFilter = filters.find((f) => f.key === 'type');
+      if (typeFilter) {
+        query.andWhere('attribute.`type`', typeFilter.operation, typeFilter.value);
+        currentFilters.push({ key: 'type', operation: typeFilter.operation, value: typeFilter.valueRaw });
+      }
+
+      // isRequired filter
+      const isRequiredFilter = filters.find((f) => f.key === 'isRequired');
+      if (isRequiredFilter) {
+        query.andWhere('attribute.`is_required`', isRequiredFilter.operation, isRequiredFilter.value);
+        currentFilters.push({ key: 'isRequired', operation: isRequiredFilter.operation, value: isRequiredFilter.valueRaw });
+      }
+
+      // isFilterable filter
+      const isFilterableFilter = filters.find((f) => f.key === 'isFilterable');
+      if (isFilterableFilter) {
+        query.andWhere('attribute.`is_filterable`', isFilterableFilter.operation, isFilterableFilter.value);
+        currentFilters.push({ key: 'isFilterable', operation: isFilterableFilter.operation, value: isFilterableFilter.valueRaw });
+      }
+
+      const sortBy = filters.find((f) => f.key === 'sortBy');
+      const sortOrder = filters.find((f) => f.key === 'sortOrder' && ['ASC', 'DESC'].includes(f.value)) || { value: 'ASC' };
+      if (sortBy && sortBy.value === 'name') {
+        query.orderBy('des.`name`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else {
+        query.orderBy('attribute.`attribute_id`', "DESC");
+      };
+      if (sortOrder.key) {
+        currentFilters.push({
+          key: 'sortOrder',
+          operation: '=',
+          value: sortOrder.value
+        });
+      }
+      // Clone the main query for getting total right before doing the paging
+      const cloneQuery = query.clone();
+      cloneQuery.select('COUNT(attribute.`attribute_id`)', 'total');
+      // const total = await cloneQuery.load(pool);
+      // console.log('total', total);
+      // Paging
+      const page = filters.find((f) => f.key === 'page') || { value: 1 };
+      const limit = filters.find((f) => f.key === 'limit') || { value: 20 };// TODO: Get from config
+      currentFilters.push({
+        key: 'page',
+        operation: '=',
+        value: page.value
+      });
+      currentFilters.push({
+        key: 'limit',
+        operation: '=',
+        value: limit.value
+      });
+      query.limit((page.value - 1) * parseInt(limit.value), parseInt(limit.value));
+      return {
+        items: (await query.execute(pool)).map(row => camelCase(row)),
+        total: (await cloneQuery.load(pool))['total'],
+        currentFilters: currentFilters,
+      }
+    },
+    attributeGroups: async (_, { }, { pool }) => {
+      const query = select().from('attribute_group');
+      return await query
+        .execute(pool)
+        .then((results) => results.map((result) => camelCase(result)));
+    }
+  },
+  AttributeGroup: {
+    attributes: async (group, _, { pool }) => {
+      const rows = await select()
+        .from('attribute')
+        .where(
+          'attribute_id',
+          'IN',
+          (await select('attribute_id')
+            .from('attribute_group_link')
+            .where('group_id', '=', group.attributeGroupId)
+            .execute(pool)).map(a => a.attribute_id)
+        )
+        .execute(pool);
+      return rows.map((row) => camelCase(row));
+    }
+  },
+
+  Attribute: {
+    groups: async (attribute, _, { pool }) => {
+      const results = await select()
+        .from('attribute_group')
+        .where(
+          'attribute_group_id',
+          'IN',
+          (await select('group_id')
+            .from('attribute_group_link')
+            .where('attribute_id', '=', attribute.attributeId)
+            .execute(pool)).map(g => g.group_id)
+        )
+        .execute(pool)
+      return results.map((result) => camelCase(result));
+    },
+    options: async (attribute, _, { pool }) => {
+      const results = await select()
+        .from('attribute_option')
+        .where('attribute_id', '=', attribute.attributeId)
+        .execute(pool);
+      return results.map((result) => camelCase(result))
+    },
+    editUrl: ({ attributeId }) => buildUrl('attributeEdit', { id: attributeId })
+  }
+}

package/src/modules/catalog/graphql/types/Category/Category.graphql

@@ -0,0 +1,65 @@
+type Category {
+  categoryId: ID!
+  name: String!
+  status: Int!
+  includeInNav: Int!
+  description: String
+  urlKey: String
+  metaTitle: String
+  metaDescription: String
+  metaKeywords: String
+  image: CategoryImage
+  products(filters: [FilterInput]): ProductCollection
+  url: String
+  editUrl: String
+  availableFilters: [FilterAttribute]
+}
+
+type CategoryImage {
+  path: String!
+  url: String!
+}
+
+input FilterInput {
+  key: String!
+  operation: String!
+  value: String!
+}
+
+type Filter {
+  key: String!
+  operation: String!
+  value: String!
+}
+
+type FilterOption {
+  optionId: Int!
+  optionText: String!
+}
+
+type FilterAttribute {
+  attributeName: String!
+  attributeCode: String!
+  attributeId: Int!
+  options: [FilterOption]
+}
+
+type CategoryCollection {
+  items: [Category]
+  currentPage: Int!
+  total: Int!
+  currentFilters: [Filter]
+}
+
+type ProductCollection {
+  items: [Product]
+  currentPage: Int!
+  total: Int!
+  currentFilters: [Filter]
+}
+
+extend type Query {
+  categories(filters: [FilterInput]): CategoryCollection
+  category(id: Int): Category
+  products(filters: [FilterInput]): ProductCollection
+}

package/src/modules/catalog/graphql/types/Category/Category.resolvers.js

@@ -0,0 +1,328 @@
+const { select } = require('@evershop/mysql-query-builder');
+const { buildUrl } = require('../../../../../lib/router/buildUrl');
+const { camelCase } = require('../../../../../lib/util/camelCase');
+const uniqid = require('uniqid');
+const { getProductsQuery } = require('../../../services/getProductsQuery');
+
+module.exports = {
+  Query: {
+    category: async (_, { id }, { pool }) => {
+      const query = select().from('category');
+      query.leftJoin('category_description')
+        .on('category_description.`category_description_category_id`', '=', 'category.`category_id`')
+      query.where('category_id', '=', id)
+        .andWhere('category.`status`', '=', 1);
+      const result = await query.load(pool)
+      return result ? camelCase(result) : null;
+    },
+    categories: async (_, { filters = [] }, { pool }) => {
+      const query = select().from('category');
+      query.leftJoin('category_description', 'des')
+        .on('des.`category_description_category_id`', '=', 'category.`category_id`');
+
+      const currentFilters = [];
+      // Name filter
+      const nameFilter = filters.find((f) => f.key === 'name');
+      if (nameFilter) {
+        query.andWhere('des.`name`', 'LIKE', `%${nameFilter.value}%`);
+        currentFilters.push({ key: 'name', operation: '=', value: nameFilter.value });
+      }
+
+      // Status filter
+      const statusFilter = filters.find((f) => f.key === 'status');
+      if (statusFilter) {
+        query.andWhere('category.`status`', '=', statusFilter.value);
+        currentFilters.push({ key: 'status', operation: '=', value: statusFilter.value });
+      }
+
+      const sortBy = filters.find((f) => f.key === 'sortBy');
+      const sortOrder = filters.find((f) => f.key === 'sortOrder' && ['ASC', 'DESC'].includes(f.value)) || { value: 'ASC' };
+      if (sortBy && sortBy.value === 'name') {
+        query.orderBy('des.`name`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else {
+        query.orderBy('category.`category_id`', "DESC");
+      };
+      if (sortOrder.key) {
+        currentFilters.push({
+          key: 'sortOrder',
+          operation: '=',
+          value: sortOrder.value
+        });
+      }
+      // Clone the main query for getting total right before doing the paging
+      const cloneQuery = query.clone();
+      cloneQuery.select('COUNT(category.`category_id`)', 'total');
+      // const total = await cloneQuery.load(pool);
+      // console.log('total', total);
+      // Paging
+      const page = filters.find((f) => f.key === 'page') || { value: 1 };
+      const limit = filters.find((f) => f.key === 'limit') || { value: 20 };// TODO: Get from config
+      currentFilters.push({
+        key: 'page',
+        operation: '=',
+        value: page.value
+      });
+      currentFilters.push({
+        key: 'limit',
+        operation: '=',
+        value: limit.value
+      });
+      query.limit((page.value - 1) * parseInt(limit.value), parseInt(limit.value));
+      return {
+        items: (await query.execute(pool)).map(row => camelCase(row)),
+        total: (await cloneQuery.load(pool))['total'],
+        currentFilters: currentFilters,
+      }
+    },
+    products: async (_, { filters = [] }, { pool, tokenPlayload }) => {
+      const query = select()
+        .from('product');
+      query.leftJoin('product_description', 'des')
+        .on('product.`product_id`', '=', 'des.`product_description_product_id`');
+      const currentFilters = [];
+      // Price filter 
+      const priceFilter = filters.find((f) => f.key === 'price');
+      if (priceFilter) {
+        const [min, max] = priceFilter.value.split('-').map((v) => parseFloat(v));
+        let currentPriceFilter;
+        if (isNaN(min) === false) {
+          query.andWhere('product.`price`', '>=', min);
+          currentPriceFilter = { key: 'price', operation: '=', value: `${min}` };
+        }
+
+        if (isNaN(max) === false) {
+          query.andWhere('product.`price`', '<=', max);
+          currentPriceFilter = { key: 'price', operation: '=', value: `${currentPriceFilter.value}-${max}` };
+        }
+        if (currentPriceFilter) {
+          currentFilters.push(currentPriceFilter);
+        }
+      };
+
+      // 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 (isNaN(min) === false) {
+          query.andWhere('product.`qty`', '>=', min);
+          currentQtyFilter = { key: 'qty', operation: '=', value: `${min}` };
+        }
+
+        if (isNaN(max) === false) {
+          query.andWhere('product.`qty`', '<=', max);
+          currentQtyFilter = { key: 'qty', operation: '=', value: `${currentQtyFilter.value}-${max}` };
+        }
+        if (currentQtyFilter) {
+          currentFilters.push(currentQtyFilter);
+        }
+      };
+
+      // Name filter
+      const nameFilter = filters.find((f) => f.key === 'name');
+      if (nameFilter) {
+        query.andWhere('des.`name`', 'LIKE', `%${nameFilter.value}%`);
+        currentFilters.push({ key: 'name', operation: '=', value: nameFilter.value });
+      }
+
+      // Sku filter
+      const skuFilter = filters.find((f) => f.key === 'sku');
+      if (skuFilter) {
+        query.andWhere('product.`sku`', 'LIKE', `%${skuFilter.value}%`);
+        currentFilters.push({ key: 'sku', operation: '=', value: skuFilter.value });
+      }
+
+      // Status filter
+      const statusFilter = filters.find((f) => f.key === 'status');
+      if (statusFilter) {
+        query.andWhere('product.`status`', '=', statusFilter.value);
+        currentFilters.push({ key: 'status', operation: '=', value: statusFilter.value });
+      }
+
+      const sortBy = filters.find((f) => f.key === 'sortBy');
+      const sortOrder = filters.find((f) => f.key === 'sortOrder' && ['ASC', 'DESC'].includes(f.value)) || { value: 'ASC' };
+      if (sortBy && sortBy.value === 'price') {
+        query.orderBy('product.`price`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else if (sortBy && sortBy.value === 'name') {
+        query.orderBy('des.`name`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else {
+        query.orderBy('product.`product_id`', "DESC");
+      };
+      if (sortOrder.key) {
+        currentFilters.push({
+          key: 'sortOrder',
+          operation: '=',
+          value: sortOrder.value
+        });
+      }
+      // Clone the main query for getting total right before doing the paging
+      const cloneQuery = query.clone();
+      cloneQuery.select('COUNT(product.`product_id`)', 'total');
+      // const total = await cloneQuery.load(pool);
+      // console.log('total', total);
+      // Paging
+      const page = filters.find((f) => f.key === 'page') || { value: 1 };
+      const limit = filters.find((f) => f.key === 'limit') || { value: 20 };// TODO: Get from config
+      currentFilters.push({
+        key: 'page',
+        operation: '=',
+        value: page.value
+      });
+      currentFilters.push({
+        key: 'limit',
+        operation: '=',
+        value: limit.value
+      });
+      query.limit((page.value - 1) * parseInt(limit.value), parseInt(limit.value));
+      return {
+        itemQuery: query,
+        totalQuery: cloneQuery,
+        currentFilters: currentFilters,
+      }
+    }
+  },
+  Category: {
+    products: async (category, { filters = [] }, { filterableAttributes, priceRange }) => {
+      const query = await getProductsQuery(category.categoryId);
+      const currentFilters = [];
+      // Price filter 
+      const priceFilter = filters.find((f) => f.key === 'price');
+      if (priceFilter) {
+        const [min, max] = priceFilter.value.split('-').map((v) => parseFloat(v));
+        let currentPriceFilter;
+        if (isNaN(min) === false) {
+          query.andWhere('product.`price`', '>=', min);
+          currentPriceFilter = { key: 'price', value: `${min}` };
+        }
+
+        if (isNaN(max) === false) {
+          query.andWhere('product.`price`', '<=', max);
+          currentPriceFilter = { key: 'price', value: `${currentPriceFilter.value}-${max}` };
+        }
+        if (currentPriceFilter) {
+          currentFilters.push(currentPriceFilter);
+        }
+      }
+      // TODO: Apply category filters
+
+      // Attribute filters
+      filters.forEach((filter) => {
+        if (filter.key === 'price') {
+          return;
+        }
+        const attribute = filterableAttributes.find((a) => a.attributeCode === filter.key);
+        if (attribute) {
+          const values = filter.value.split(',')
+            .map((v) => parseInt(v))
+            .filter((v) => isNaN(v) === false);
+          if (values.length > 0) {
+            const alias = uniqid();
+            query.innerJoin('product_attribute_value_index', alias)
+              .on(`${alias}.product_id`, '=', 'product.`product_id`')
+              .and(`${alias}.attribute_id`, '=', attribute.attributeId)
+              .and(`${alias}.option_id`, 'IN', values);
+          }
+          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'].includes(f.value)) || { value: 'ASC' };
+      if (sortBy && sortBy.value === 'price') {
+        query.orderBy('product.`price`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else if (sortBy && sortBy.value === 'name') {
+        query.orderBy('product_description.`name`', sortOrder.value);
+        currentFilters.push({
+          key: 'sortBy',
+          operation: '=',
+          value: sortBy.value
+        });
+      } else {
+        query.orderBy('product.`product_id`', sortOrder.value);
+      };
+      if (sortOrder.key) {
+        currentFilters.push({
+          key: 'sortOrder',
+          operation: '=',
+          value: sortOrder.value
+        });
+      }
+      // Clone the main query for getting total right before doing the paging
+      const cloneQuery = query.clone();
+      cloneQuery.select('COUNT(product.`product_id`)', 'total');
+      // const total = await cloneQuery.load(pool);
+      // console.log('total', total);
+      // Paging
+      const page = filters.find((f) => f.key === 'page') || { value: 1 };
+      const limit = filters.find((f) => f.key === 'limit') || { value: 20 };// TODO: Get from config
+      currentFilters.push({
+        key: 'page',
+        operation: '=',
+        value: page.value
+      });
+      currentFilters.push({
+        key: 'limit',
+        operation: '=',
+        value: limit.value
+      });
+      query.limit((page.value - 1) * parseInt(limit.value), parseInt(limit.value));
+      return {
+        itemQuery: query,
+        totalQuery: cloneQuery,
+        currentFilters: currentFilters,
+      }
+    },
+    availableFilters: async (category, _, { filterableAttributes, priceRange }) => {
+      return filterableAttributes;
+    },
+    url: (category, _, { pool }) => {
+      return buildUrl('categoryView', { url_key: category.urlKey });
+    },
+    editUrl: (category, _, { pool }) => {
+      return buildUrl('categoryEdit', { id: category.categoryId });
+    },
+    image: (category, _, { pool }) => {
+      const image = category.image;
+      if (!image) {
+        return null;
+      } else {
+        return {
+          path: image,
+          url: `/assets${image}`
+        }
+      }
+    }
+  },
+  ProductCollection: {
+    items: async ({ itemQuery }, _, { pool }) => {
+      return (await itemQuery.execute(pool)).map((row) => camelCase(row));
+    },
+    total: async ({ totalQuery }, _, { pool }) => {
+      return (await totalQuery.load(pool)).total;
+    }
+  }
+}

package/src/modules/catalog/graphql/types/FeaturedCategory/FeaturedCategory.graphql

@@ -0,0 +1,3 @@
+extend type Query {
+  featuredCategory: [Category]
+}

package/src/modules/catalog/graphql/types/FeaturedCategory/FeaturedCategory.resolvers.js

@@ -0,0 +1,28 @@
+const { select } = require('@evershop/mysql-query-builder');
+const { camelCase } = require('../../../../../lib/util/camelCase');
+
+module.exports = {
+  Query: {
+    featuredProducts: async (_, { }, { pool }) => {
+      const query = select('product.`product_id`')
+        .select('product.`sku`')
+        .select('product.`price`')
+        .select('product_description.`name`')
+        .select('product_description.`url_key`')
+        .select('product.`image`')
+        .select('SUM(cart_item.`qty`)', 'soldQty')
+        .from('product');
+      query.leftJoin('product_description')
+        .on('product.`product_id`', '=', 'product_description.`product_description_product_id`');
+      query.leftJoin('cart_item')
+        .on('cart_item.`product_id`', '=', 'product.`product_id`');
+      query.where('product.`status`', '=', 1);
+      query.groupBy('product.`product_id`');
+      query.orderBy('soldQty', 'desc');
+      query.limit(0, 4);
+
+      const products = await query.execute(pool);
+      return products.map((product) => camelCase(product));
+    }
+  }
+}

package/src/modules/catalog/graphql/types/FeaturedProduct/FeaturedProduct.graphql

@@ -0,0 +1,3 @@
+extend type Query {
+  featuredProducts: [Product]
+}

package/src/modules/catalog/graphql/types/FeaturedProduct/FeaturedProduct.resolvers.js

@@ -0,0 +1,28 @@
+const { select } = require('@evershop/mysql-query-builder');
+const { camelCase } = require('../../../../../lib/util/camelCase');
+
+module.exports = {
+  Query: {
+    featuredProducts: async (_, { }, { pool }) => {
+      const query = select('product.`product_id`')
+        .select('product.`sku`')
+        .select('product.`price`')
+        .select('product_description.`name`')
+        .select('product_description.`url_key`')
+        .select('product.`image`')
+        .select('SUM(cart_item.`qty`)', 'soldQty')
+        .from('product');
+      query.leftJoin('product_description')
+        .on('product.`product_id`', '=', 'product_description.`product_description_product_id`');
+      query.leftJoin('cart_item')
+        .on('cart_item.`product_id`', '=', 'product.`product_id`');
+      query.where('product.`status`', '=', 1);
+      query.groupBy('product.`product_id`');
+      query.orderBy('soldQty', 'desc');
+      query.limit(0, 4);
+
+      const products = await query.execute(pool);
+      return products.map((product) => camelCase(product));
+    }
+  }
+}

package/src/modules/catalog/graphql/types/Product/Attribute/ProductAttribute.graphql

@@ -0,0 +1,10 @@
+type ProductAttributeIndex {
+  attributeId: ID!
+  optionId: Int
+  optionText: String
+}
+
+extend type Product {
+  attributeIndex: [ProductAttributeIndex]
+  attributes: [Attribute]
+}

package/src/modules/catalog/graphql/types/Product/Attribute/ProductAttribute.resolvers.js

@@ -0,0 +1,24 @@
+const { select } = require('@evershop/mysql-query-builder');
+const { camelCase } = require('../../../../../../lib/util/camelCase');
+
+module.exports = {
+  Product: {
+    attributeIndex: async (product, _, { pool }) => {
+      return (await select()
+        .from('product_attribute_value_index')
+        .where('product_id', '=', product.productId)
+        .execute(pool)).map((row) => camelCase(row));
+    },
+    attributes: async (product, _, { pool }) => {
+      const valueIndex = (await select()
+        .from('product_attribute_value_index')
+        .where('product_id', '=', product.productId)
+        .execute(pool)).map((row) => row.attribute_id);
+      const attributes = await select()
+        .from('attribute')
+        .where('attribute_id', 'IN', valueIndex)
+        .execute(pool);
+      return attributes.map(a => camelCase(a))
+    }
+  }
+}

package/src/modules/catalog/graphql/types/Product/CustomOption/CustomOption.graphql

@@ -0,0 +1,17 @@
+type Option {
+  optionId: ID!
+  optionName: String!
+  optionType: String!
+  isRequired: Boolean!
+  values: [OptionValue]
+}
+
+type OptionValue {
+  valueId: ID!
+  value: String!
+  extraPrice: Price!
+}
+
+extend type Product {
+  options: [Option]
+}