Files
ui/pkg/commerce/service/impls/standalone/index.ts

580 lines
17 KiB
TypeScript

import {
computed,
makeObservable,
observable,
runInAction,
action,
toJS
} from 'mobx'
import { computedFn } from 'mobx-utils'
import type {
CommerceService,
Family,
LineItem,
SelectedPaths,
CategoryNode,
CategoryNodeRole,
Promo
} from '../../../types'
import {
createOrder as createOrderHelper,
updateOrderShippingInfo as updateOrderShippingInfoHelper,
updateOrderPaymentInfo as updateOrderPaymentInfoHelper
} from './order'
import ActualLineItem, { type ActualLineItemSnapshot } from './actual-line-item'
import { getParentPath } from '../../path-utils'
import { getErrorMessage } from '../../../util'
import sep from '../../sep'
import { getInstance } from './get-instance'
type StandaloneServiceOptions = {
dbName: string
ordersTable: string
localStorageKey: string
}
interface StandaloneServiceSnapshot {
items: ActualLineItemSnapshot[]
}
class StandaloneService
implements CommerceService
{
private _familyMap = new Map<string, Family>()
private _rootNode: CategoryNode
private _selectedPaths: SelectedPaths = {}
private _promo: Promo | null = null
private _options : StandaloneServiceOptions
private _currentFamily: Family | undefined = undefined
private _currentItem: ActualLineItem | undefined = undefined
constructor(
families: Family[],
rootNode: CategoryNode,
options: StandaloneServiceOptions,
serviceSnapshot?: StandaloneServiceSnapshot,
) {
this._rootNode = rootNode
this._options = options
families.forEach((fam) => {
fam.products = fam.products.map((p) => {
if (serviceSnapshot) {
const itemSnapshot = serviceSnapshot.items.find((is) => (is.sku === p.sku))
if (itemSnapshot) {
return new ActualLineItem(p, itemSnapshot)
}
}
return new ActualLineItem(p)
})
this._familyMap.set(fam.id, fam)
})
makeObservable<
StandaloneService,
'_selectedPaths' |
'_currentItem' |
'_currentFamily' |
'_promo' |
'_cartItems'
>(this, {
_selectedPaths : observable.deep,
_currentItem: observable.shallow,
_currentFamily: observable.shallow,
_promo: observable,
_cartItems: computed
})
makeObservable(this, {
setCurrentItem: action,
setCurrentFamily: action,
setAppliedPromo: action,
/* NOT selectPaths. It implements it's action mechanism */
cartItems: computed,
recentItem: computed,
cartQuantity: computed,
cartTotal: computed,
promoAppliedCartTotal: computed,
cartEmpty: computed,
selectedItems: computed,
selectedFamilies: computed,
hasSelection: computed,
currentItem: computed,
currentFamily: computed,
item: computed,
family: computed,
selectedPaths: computed,
appliedPromo: computed,
})
}
getFamilyById(id: string): Family | undefined {
return this._familyMap.get(id)
}
getNodeAtPath(skuPath: string): CategoryNode | undefined {
const toks = skuPath.split(sep.tok)
let level = 1
let node: CategoryNode | undefined = this._rootNode
do {
node = node!.subNodes?.find((sn) => (sn.skuToken === toks[level]))
level++
}
while (node && (level < toks.length))
return level === toks.length ? node : undefined
}
peek(skuPath: string): {
role: CategoryNodeRole
family: Family | undefined
families: Family[] | undefined
node: CategoryNode | undefined
item: LineItem | undefined
} | string /* OR error string */ {
const toks = skuPath.split(sep.tok)
let level: number
let node: CategoryNode | undefined = this._rootNode
let parent: CategoryNode | undefined = undefined
for (level = 1; level < toks.length && node && node.subNodes; level++) {
// https://stackoverflow.com/questions/62367492/inference-problem-referenced-directly-or-indirectly-in-its-own-initializer
const _node: CategoryNode | undefined =
node!.subNodes.find((sn) => (sn.skuToken === toks[level]))
if (!_node) {
return `service.peekAtNode: traversing '${skuPath}'... no CategoryNode at '${toks[level]}'!`
}
parent = node
node = _node
}
const atEnd = level === toks.length
const possibleSKU = level === toks.length - 1
let role: CategoryNodeRole = 'non-outermost'
let families: Family[] | undefined = undefined
let family: Family | undefined = undefined
let item: LineItem | undefined = undefined
let error: string | undefined = undefined
try {
if (node.subNodes && atEnd && node.outermost) {
role = 'multi-family'
families = node.subNodes.map((sub) => {
const familyId = skuPath + sep.tok + sub.skuToken
const fam = this._familyMap.get(familyId)
if (!fam) {
throw new Error(`service.peekAtNode: No Family under for CategoryNode '${skuPath}' with id ${familyId}!`)
}
return fam
})
}
else if (!node.subNodes && (atEnd || possibleSKU)) {
const _skuPath = (possibleSKU) ? getParentPath(skuPath) : skuPath
if (parent?.outermost) {
role = 'family-in-multi-family'
const fam = this._familyMap.get(_skuPath)
if (!fam) {
throw new Error(`service.peekAtNode: '${_skuPath}' graphs as a Family under a multi-family node, but no such family exists!`)
}
family = fam
const parentPath = getParentPath(_skuPath)
// get all siblings (subnodes of parent)
families = parent.subNodes!.map((sn) => {
const familyId = parentPath + sep.tok + sn.skuToken
const fam = this._familyMap.get(familyId)
if (!fam) {
throw new Error(`service.peekAtNode: No sibling Family for '${_skuPath}' with id '${familyId}'!`)
}
return fam
})
node = parent
}
else {
role = 'single-family'
const fam = this._familyMap.get(_skuPath)
if (!fam) {
throw new Error(`service.peekAtNode: '${_skuPath}' graphs as a single Family, but no such family exists!`)
}
family = fam
}
if (possibleSKU) {
const skuToTry = family.id + sep.tok + toks[toks.length - 1]
const _item = family.products.find((p) => (p.sku === skuToTry))
if (_item) {
item = _item as LineItem
}
else {
throw new Error(`service.peekAtNode: '${skuPath}' graphs as LineItem in Family '${family.id}', but no such sku exists there!`)
}
}
}
}
catch (e) {
error = getErrorMessage(e)
}
return error ?? {
role,
family,
families,
node,
item
}
}
getSelectedNodesAtLevel = computedFn((level: number): CategoryNode[] | undefined => {
let lvl = 1
let nodesAtLevel: CategoryNode[] | undefined = this._rootNode.subNodes
do {
let selectedAtLevel: CategoryNode[] | undefined = undefined
// If not specified, assume all
if (lvl in this._selectedPaths) {
selectedAtLevel = nodesAtLevel!.filter((n) => (this._selectedPaths[lvl].includes(n.skuToken)))
}
else {
selectedAtLevel = nodesAtLevel
}
let allSubsOfSelected: CategoryNode[] = []
selectedAtLevel?.forEach((n: CategoryNode) => {
if (n.subNodes) {
allSubsOfSelected = [...allSubsOfSelected, ...n.subNodes]
}
})
nodesAtLevel = allSubsOfSelected
lvl++
} while (nodesAtLevel.length > 0 && lvl <= level)
return (nodesAtLevel.length > 0 && ((lvl - 1) === level)) ? nodesAtLevel : undefined
})
get options() { return this._options}
//async createOrder(email: string, paymentMethod: string): Promise<string | undefined> {
async createOrder(email: string, name?: string): Promise<string | undefined> {
const snapshot = this.takeSnapshot()
const order = await createOrderHelper(email, snapshot.items, this._options, name) // didn't want to have two levels of 'items'
return order.id
}
// TODO: add shippingInfo type
async updateOrderShippingInfo(orderId: string, shippingInfo: any): Promise<void> {
updateOrderShippingInfoHelper(orderId, shippingInfo, this._options)
}
// TODO: add paymentInfo type
async updateOrderPaymentInfo(orderId: string, paymentInfo: any): Promise<void> {
updateOrderPaymentInfoHelper(orderId, paymentInfo, this._options)
}
// Might as well use the ordered set.
takeSnapshot = (): StandaloneServiceSnapshot => ({
items : (this.cartItems as ActualLineItem[]).map((it) => (it.takeSnapshot(this)))
})
// last cartItem whose quantity was modified (undefined if cartEmpty)
get recentItem(): { item: LineItem, modified: number} | undefined {
if (this.cartEmpty) return undefined;
const mostRecent = this._cartItems.reduce(
(newest, item) => ((!newest) ? item : (
(item as ActualLineItem).timeModified > (newest as ActualLineItem).timeModified) ? item : newest
),
undefined as LineItem | undefined
)
return { item: mostRecent!, modified: (mostRecent! as ActualLineItem).timeModified }
}
private get _cartItems(): LineItem[] {
let result: LineItem[] = []
this._familyMap.forEach((fam) => {
result = [...result, ...(fam.products as LineItem[]).filter((item) => (item.isInCart))]
})
return result
}
get cartItems(): LineItem[] {
return this._cartItems.sort((it1, it2) => ((it1 as ActualLineItem).timeAdded - (it2 as ActualLineItem).timeAdded))
}
get cartEmpty(): boolean {
return this._cartItems.length === 0
}
get cartTotal(): number {
return this._cartItems.reduce(
(total, item) => (total + item.price * item.quantity),
0
)
}
_promoValue_unsafe(value: number): number {
if (this._promo!.type === 'percent') {
return value * (1 - this._promo!.value / 100)
}
return value - this._promo!.value
}
get promoAppliedCartTotal(): number {
if (!this._promo) {
return this.cartTotal
}
if (!this._promo.skus) {
return this._promoValue_unsafe(this.cartTotal)
}
let total = this._cartItems.reduce(
(total, item) => {
const itemPrice = this._promo!.skus!.includes(item.sku) ?
this._promoValue_unsafe(item.price)
:
item.price
return total + itemPrice * item.quantity
},
0
)
return total
}
itemPromoPrice(item: LineItem): number | undefined {
if (this._promo && (!this._promo.skus || this._promo.skus.includes(item.sku) )) {
return this._promoValue_unsafe(item.price)
}
return undefined
}
get cartQuantity(): number {
return this.cartItems.reduce(
(total, item) => (total + item.quantity),
0
)
}
get appliedPromo(): Promo | null {
return this._promo
}
setAppliedPromo(promo: Promo | null): void {
this._promo = promo
}
getItemBySku = (skuToFind: string | undefined): LineItem | undefined => {
if (skuToFind === undefined || skuToFind.length === 0) {
return undefined
}
// Self-calling
const found = ((): ActualLineItem | undefined => {
const familiesTried: string[] = []
if (this.selectedFamilies && this.selectedFamilies.length > 0) {
for (let family of this.selectedFamilies) {
familiesTried.push(family.id)
const foundItem = family.products.find((p) => (p.sku === skuToFind))
if (foundItem) {
return foundItem as ActualLineItem
}
}
}
for( const [familyId, family] of this._familyMap.entries()) {
if (familiesTried.includes(familyId)) continue
const foundItem = family.products.find((p) => (p.sku === skuToFind)) as ActualLineItem | undefined
if (foundItem) {
return foundItem as ActualLineItem
}
}
return undefined
})(); // Self-calling, necessary semi
return found
}
setCurrentItem = (skuToFind: string | undefined): boolean => {
if (skuToFind === undefined || skuToFind.length === 0) {
this._currentItem = undefined
return true
}
// self calling function
this._currentItem = this.getItemBySku(skuToFind) as ActualLineItem | undefined
this.setCurrentFamily(this._currentItem ? this._currentItem.familyId : undefined)
return !!this._currentItem
}
/* for ObsLineItemRef */
get item(): LineItem | undefined {
return this._currentItem
}
get currentItem(): LineItem | undefined {
return this._currentItem
}
setCurrentFamily(id: string | undefined): boolean {
if (id === undefined || id.length === 0) {
this._currentFamily = undefined
return true
}
const fam = this._familyMap.get(id)
this._currentFamily = fam // undef ok
if (
this._currentFamily &&
this._currentItem &&
this._currentItem.familyId !== this._currentFamily.id
) {
this._currentItem = undefined
}
return !!this._currentFamily
}
get currentFamily(): Family | undefined {
return this._currentFamily
}
/* for ObsFamilyRef */
get family(): Family | undefined {
return this._currentFamily
}
selectPaths(sel: SelectedPaths): Family[] {
runInAction (() => {
this._selectedPaths = this._processAndValidate(sel)
})
return this.selectedFamilies
}
selectPath(skuPath: string): Family[] {
const toks = skuPath.split(sep.tok)
const highestLevel = toks.length - 1
const fsv: SelectedPaths = {}
for (let level = 1; level <= highestLevel; level++ ) {
fsv[level] = [toks[level]]
}
return this.selectPaths(fsv)
}
get selectedPaths(): SelectedPaths {
const result: SelectedPaths = {}
for( let level in this._selectedPaths ) {
result[level] = [...this._selectedPaths[level]]
}
return result
}
get selectedFamilies(): Family[] {
if (Object.keys(toJS(this._selectedPaths)).length === 0) {
// FacetsDesc have never been set or unset, so cannot evaluate them
return []
}
return this._rootNode.subNodes!.reduce(
(acc: Family[], subFacet: CategoryNode) => (
// Pass the root token as a one member array
this._reduceNode([this._rootNode.skuToken], acc, subFacet)
),
[]
)
}
private _reduceNode(parentPath: string[], acc: Family[], node: CategoryNode): Family[] {
const path = [...parentPath, node.skuToken] // Don't mutate original please :)
const level = path.length - 1
// If there is no token array supplied for this level,
// assume all are specified. Otherwise, see if the
// current node is in the array
const specified = (
!this._selectedPaths[level]
||
this._selectedPaths[level].includes(node.skuToken)
)
if (specified) {
// Process subnodes
if (node.subNodes && node.subNodes.length > 0) {
return node.subNodes.reduce((acc, n) => (
this._reduceNode(path, acc, n)
)
, acc)
}
// Process leaf
const fam = this._familyMap.get(path.join(sep.tok))
if (!fam) {
throw new Error("selectedFamilies WTF?!" + path.join(sep.tok))
}
acc.push(fam)
}
return acc
}
private _processAndValidate(partial: SelectedPaths): SelectedPaths {
const result: SelectedPaths = {}
let level = 1
let currentSet = this._rootNode.subNodes!
while (true) {
let possibleCurrent = currentSet.map((el) => (el.skuToken))
const validTokens = !partial[level] ? undefined : partial[level].filter((tok) => possibleCurrent.includes(tok))
if (!validTokens) {
break
}
result[level] = validTokens
currentSet = validTokens.map((tok) => {
const fd = currentSet.find((node) => ( node.skuToken === tok ))
return (fd && fd.subNodes && fd.subNodes.length > 0) ? fd.subNodes : []
}).flat()
level++
}
return result
}
get selectedItems(): LineItem[] {
if (Object.keys(toJS(this._selectedPaths)).length === 0) {
// FacetsDesc have never been set or unset, so cannot evaluate them
return []
}
return this.selectedFamilies.reduce(
(allProducts, fam) => ([...allProducts, ...(fam.products as LineItem[])]), [] as LineItem[])
}
get hasSelection(): boolean {
return this.selectedFamilies.length > 0
}
getFamilySubtotal(familyId: string): number {
const c = this._familyMap.get(familyId)!
return (c.products as LineItem[]).reduce(
// avoid floating point bs around zero
(total, item) => (item.quantity > 0 ? total + item.price * item.quantity : total),
0
)
}
}
export {
type StandaloneServiceOptions,
type StandaloneServiceSnapshot,
StandaloneService,
getInstance
}