@evershop/evershop 1.0.0-beta

package/src/modules/checkout/services/cart/Cart.js

@@ -0,0 +1,360 @@
+/* eslint-disable no-underscore-dangle */
+const isEqualWith = require('lodash/isEqualWith');
+const { select, del } = require('@evershop/mysql-query-builder');
+const { pool } = require('../../../../lib/mysql/connection');
+const { DataObject } = require('./DataObject');
+const { Item } = require('./Item');
+const { toPrice } = require('../toPrice');
+const { v4: uuidv4 } = require('uuid');
+const { getSetting } = require('../../../setting/services/setting');
+// eslint-disable-next-line no-multi-assign
+module.exports = exports = {};
+
+exports.Cart = class Cart extends DataObject {
+  static fields = [
+    {
+      key: 'cart_id',
+      async resolver() {
+        if (this.dataSource.cart_id) {
+          const cart = await select()
+            .from('cart')
+            .where('cart_id', '=', this.dataSource.cart_id)
+            .load(pool);
+          if (!cart || cart.status === 0) {
+            this.error = 'Cart does not exist';
+            this.dataSource = {};
+            return null;
+          } else {
+            return cart.cart_id;
+          }
+        } else {
+          return undefined;
+        }
+      }
+    },
+    {
+      key: 'uuid',
+      resolver() {
+        const key = uuidv4();
+        // Replace all '-' with '' from key
+        return this.dataSource.uuid ? this.dataSource.uuid : key.replace(/-/g, '');
+      },
+      dependencies: ['cart_id']
+    },
+    {
+      key: 'currency',
+      async resolver() {
+        return await getSetting('storeCurrency', 'USD');
+      }
+    },
+    {
+      key: 'user_ip',
+      async resolver() {
+        return this.dataSource.user_ip ?? this.getData('user_ip') ?? null;
+      }
+    },
+    {
+      key: 'sid',
+      async resolver() {
+        return this.dataSource.sid;
+      }
+    },
+    {
+      key: 'status',
+      async resolver() {
+        return this.dataSource.status ?? this.getData('status') ?? 1;
+      }
+    },
+    {
+      key: 'total_qty',
+      async resolver() {
+        let count = 0;
+        const items = this.getItems();
+        items.forEach((i) => {
+          count += parseInt(i.getData('qty'), 10);
+        });
+
+        return count;
+      },
+      dependencies: ['items']
+    },
+    {
+      key: 'total_weight',
+      async resolver() {
+        let weight = 0;
+        const items = this.getItems();
+        items.forEach((i) => {
+          weight += i.getData('product_weight') * i.getData('qty');
+        });
+
+        return weight;
+      },
+      dependencies: ['items']
+    },
+    {
+      key: 'tax_amount',
+      async resolver() {
+        return 0; // Will be added later
+      },
+      dependencies: []
+    },
+    {
+      key: 'sub_total',
+      async resolver() {
+        let total = 0;
+        const items = this.getItems();
+        items.forEach((i) => {
+          total += i.getData('final_price') * i.getData('qty');
+        });
+
+        return toPrice(total);
+      },
+      dependencies: ['items']
+    },
+    {
+      key: 'grand_total',
+      async resolver() {
+        return this.getData('sub_total');
+      },
+      dependencies: ['sub_total']
+    },
+    {
+      key: 'shipping_address_id',
+      async resolver() {
+        return this.dataSource.shipping_address_id;
+      },
+      dependencies: ['cart_id']
+    },
+    {
+      key: 'shippingAddress',
+      async resolver() {
+        if (!this.getData('shipping_address_id')) {
+          return undefined;
+        } else {
+          return { ...await select().from('cart_address').where('cart_address_id', '=', this.getData('shipping_address_id')).load(pool) };
+        }
+      },
+      dependencies: ['shipping_address_id']
+    },
+    {
+      key: 'shipping_method',
+      async resolver() {
+        // TODO: This field should be handled by each of shipping method
+        return this.dataSource.shipping_method;
+      },
+      dependencies: ['shipping_address_id']
+    },
+    {
+      key: 'shipping_method_name',
+      async resolver() {
+        // TODO: This field should be handled by each of shipping method
+        return this.dataSource.shipping_method_name;
+      },
+      dependencies: ['shipping_method']
+    },
+    {
+      key: 'shipping_fee_excl_tax',
+      async resolver() {
+        return 0;// TODO: This field should be handled by each of shipping method
+      },
+      dependencies: ['shipping_method']
+    },
+    {
+      key: 'shipping_fee_incl_tax',
+      async resolver() {
+        return 0;// TODO: This field should be handled by each of shipping method
+      },
+      dependencies: ['shipping_method']
+    },
+    {
+      key: 'billing_address_id',
+      async resolver() {
+        return this.dataSource.billing_address_id;
+      },
+      dependencies: ['cart_id']
+    },
+    {
+      key: 'billingAddress',
+      async resolver() {
+        if (!this.getData('billing_address_id')) {
+          return undefined;
+        } else {
+          return { ...await select().from('cart_address').where('cart_address_id', '=', this.getData('billing_address_id')).load(pool) };
+        }
+      },
+      dependencies: ['billing_address_id']
+    },
+    {
+      key: 'payment_method',
+      async resolver() {
+        // TODO: This field should be handled by each of payment method
+        const method = this.dataSource.payment_method;
+        if (!method) {
+          this.error = 'Payment method is required';
+        }
+
+        return method;
+      }
+    },
+    {
+      key: 'payment_method_name',
+      async resolver() {
+        // TODO: This field should be handled by each of payment method
+        return this.dataSource.payment_method_name;
+      },
+      dependencies: ['payment_method']
+    },
+    {
+      key: 'items',
+      async resolver() {
+        const items = [];
+        if (this.dataSource.items) {
+          await Promise.all(this.dataSource.items.map(async (item) => {
+            // If this is just new added item, add it to the list
+            if (!/^\d+$/.test(item.getData('cart_item_id')) && item.error === undefined) {
+              items.push(item);
+            } else if (/^\d+$/.test(item.getData('cart_item_id'))) {
+              // If the item is not build
+              if (item.dataSource.product === undefined)
+                await item.build();
+              items.push(item);
+            }
+          }));
+        } else {
+          const query = select();
+          const list = await query.from('cart_item')
+            .where('cart_id', '=', this.getData('cart_id'))
+            .execute(pool);
+
+          await Promise.all(list.map(async (i) => {
+            const item = new Item(i);
+            await item.build();
+            if (!item.getData('product_id')) {
+              await del('cart_item')
+                .where('cart_item_id', '=', i.cart_item_id)
+                .execute(pool);
+              return;
+            }
+            let flag = true;
+            items.forEach((_item) => {
+              if (_item.getData('product_sku') === item.getData('product_sku') && isEqualWith(_item.getData('product_custom_options'), item.getData('product_custom_options'))) {
+                _item.setData('qty', _item.getData('qty') + item.getData('qty'));
+                flag = false;
+              }
+            });
+            if (flag === false) {
+              await del('cart_item')
+                .where('cart_item_id', '=', i.cart_item_id)
+                .execute(pool);
+            } else items.push(item);
+          }));
+          this.dataSource.items = items;
+        }
+
+        return items;
+      },
+      dependencies: ['cart_id']
+    }
+  ];
+
+  constructor(data = {}, request) {
+    super();
+    this.dataSource = data;
+    this.request = request;
+    this.prepareFields();
+  }
+
+  /**
+   * @returns {Array<Item>}
+  */
+  getItems() {
+    return this.getData('items') ?? [];
+  }
+
+  async addItem(data) {
+    const item = new Item(data);
+    await item.build();
+    if (item.error) {
+      throw new Error(item.error);
+    } else {
+      let items = this.getItems();
+      //console.log(items);
+      let flag = false;
+      for (let i = 0; i < items.length; i += 1) {
+        if (items[i].getData('product_sku') === item.getData('product_sku') && isEqualWith(items[i].getData('product_custom_options'), item.getData('product_custom_options'))) {
+          // eslint-disable-next-line no-await-in-loop
+          await items[i].setData('qty', item.getData('qty') + items[i].getData('qty'));
+          if (item.error) {
+            throw new Error(item.error);
+          }
+          flag = true;
+        }
+      }
+
+      if (flag === false) {
+        items = items.concat(item);
+      }
+      await this.setData('items', items);
+      return item;
+    }
+  }
+
+  /**
+   * @param {string||int} id
+   * @returns {Item}
+   * @throws {Error}
+  */
+  async removeItem(id) {
+    const items = this.getItems();
+    const item = this.getItem(id);
+    // Check if id in integer string (This item already saved to database)
+    if (/^\d+$/.test(id)) {
+      id = parseInt(id, 10);
+    }
+
+    const newItems = items.filter((i) => i.getData('cart_item_id') !== id)
+    if (item) {
+      await this.setData('items', newItems);
+      return item;
+    } else {
+      throw new Error('Item not found');
+    }
+  }
+
+  getItem(id) {
+    const items = this.getItems();
+    return items.find((item) => item.getData('cart_item_id') == id);
+  }
+
+  hasItemError() {
+    const items = this.getItems();
+    let flag = false;
+    for (let i = 0; i < items.length; i += 1) {
+      if (items[i].error) {
+        flag = true;
+        break;
+      }
+    }
+
+    return flag;
+  }
+
+  hasError() {
+    if (this.error) return true;
+    return this.hasItemError();
+  }
+
+  export() {
+    const data = {};
+    this.constructor.fields.forEach((f) => {
+      if (f.key !== 'items') {
+        data[f.key] = this.data[f.key];
+      } else {
+        const items = this.getItems();
+        data[f.key] = items.map((item) => item.export());
+      }
+    });
+
+    return data;
+  }
+};

package/src/modules/checkout/services/cart/CartFactory.js

@@ -0,0 +1,45 @@
+// This factory creates one Cart object per request
+const { getContextValue } = require("../../../graphql/services/contextHelper");
+const { getCustomerCart } = require("../getCustomerCart");
+const { Cart } = require("./Cart");
+
+var CartFactory = {};
+
+CartFactory.init = function init(request, response) {
+  // Get the token payload from the request
+  const tokenPayload = getContextValue(request, "tokenPayload");
+  this.carts = {
+    [tokenPayload.sid]: {
+      request,
+      response,
+    }
+  };
+
+  // Subscribe to the 'finish' event of the response
+  response.on("finish", () => {
+    // When the response is finished, delete the cart from the factory
+    delete this.carts[tokenPayload.sid];
+  }
+  );
+}
+
+/** 
+ * @param {string} uuid
+ * @returns {Promise<Cart>}
+ * @throws {Error}
+*/
+CartFactory.getCart = async function getCart(sid) {
+  if (!sid) {
+    throw new Error("Session ID is required");
+  } else {
+    const cart = this.carts[sid]?.cart;
+    if (cart === undefined) {
+      this.carts[sid]['cart'] = getCustomerCart(getContextValue(this.carts[sid].request, "tokenPayload"));
+    }
+
+    return await this.carts[sid].cart;
+  }
+}
+
+exports = module.exports = {};
+exports.CartFactory = CartFactory;

package/src/modules/checkout/services/cart/DataObject.js

@@ -0,0 +1,142 @@
+/* eslint-disable no-underscore-dangle */
+const isEqualWith = require('lodash/isEqualWith');
+const Topo = require('@hapi/topo');
+
+module.exports.DataObject = class DataObject {
+  // This is an array of objects: {key, resolver, dependencies}
+  static fields;
+
+  constructor() {
+    // This is the data opject: {key, value}
+    this.data = {}; // TODO: Private field?
+
+    // This object hold the data pool, which is used to build the data object
+    this.dataSource = [];
+    this.isBuilding = false;
+    this.isCommited = false;
+    this.error = undefined;
+  }
+
+  // Sort the fields by dependencies
+  prepareFields() {
+    // eslint-disable-next-line no-shadow
+    const fields = this.constructor.fields.filter((f, index, fields) => {
+      if (!f.dependencies) return true;
+      const { dependencies } = f;
+      let flag = true;
+      // Field will be removed if it's dependency missing
+      dependencies.forEach((d) => {
+        if (flag === false || this.constructor.fields.findIndex((m) => m.key === d) === -1) {
+          flag = false;
+        }
+      });
+
+      return flag;
+    });
+
+    const sorter = new Topo.Sorter();
+    fields.forEach((f) => {
+      sorter.add(f.key, { before: [], after: f.dependencies, group: f.key });
+    });
+
+    this.constructor.fields = sorter.nodes.map((key) => {
+      const index = fields.findIndex((f) => f.key === key);
+      const f = fields[index];
+
+      return { ...f };
+    });
+  }
+
+  /**
+   * Add a field
+   * @param {*} key 
+   * @param {*} resolver 
+   * @param {*} dependencies 
+   */
+  static addField(key, resolver, dependencies) {
+    if (!this.fields) this.fields = [];
+    this.fields.push({ key, resolver, dependencies });
+  }
+
+  // Build the field value. This function will be called when the field value is changed
+  // If error is thrown, all changes will be rollback
+  async build() {
+    let _this = this;
+
+    // Keep current values for rollback
+    const values = { ...this.data };
+
+    try {
+      this.isBuilding = true;
+      this.error = undefined;
+
+      for (let i = 0; i < this.constructor.fields.length; i += 1) {
+        const field = this.constructor.fields[i];
+        this.data[field.key] = await field.resolver.call(_this);
+      }
+      this.isBuilding = false;
+      this.isCommited = false;
+    } catch (e) {
+      this.error = e;
+      this.isBuilding = false;
+      // Rollback the changes
+      this.data = { ...values };
+    }
+  }
+
+  getData(key) {
+    const field = this.constructor.fields.find((f) => f.key === key);
+    if (field === undefined) {
+      throw new Error(`Field ${key} not existed`);
+    }
+
+    return this.data[field.key];
+  }
+
+  async setData(key, value) {
+    if (this.isBuilding === true) {
+      throw new Error('Can not set value when object is building');
+    }
+    const field = this.constructor.fields.find((f) => f.key === key);
+    if (field === undefined) {
+      throw new Error(`Field ${key} not existed`);
+    }
+
+    if (isEqualWith(this.data[key], value)) {
+      return value;
+    }
+
+    // Temporary add value to the data source
+    this.dataSource[key] = value;
+
+    // Run the full build
+    await this.build();
+    const result = this.data[key];
+    if (!isEqualWith(result, value)) {
+      throw new Error(`Field resolver returned different value - ${key}`);
+    } else {
+      return value;
+    }
+  }
+
+  hasError() {
+    return this.error !== undefined;
+  }
+
+  getError() {
+    return this.error;
+  }
+
+  export() {
+    const data = {};
+    this.constructor.fields.forEach((f) => {
+      data[f.key] = this.data[f.key];
+    });
+
+    return data;
+  }
+
+  commit() {
+    this.isCommited = true;
+  }
+}