Discount conditions

[olivermrbl]

Goal

Allow store managers to create discounts, that are only applicable for a specific product collection (e.g. to use in flash sales), customer group (e.g. offering a discount only to VIP Customers), product type, products, or product tags.

What we have right now

• Discount
  Represents a promotion that can be applied to a cart.
• DiscountRule
  Rule that governs how a Discount is calculated when applied to a cart. The DiscountRule currently has valid_for which holds all products to which the discount is applicable.

What we want
We want to introduce the notion of a DiscountRuleCondition and kill valid_for on DiscountRule. The DiscountRuleCondition should hold the applicable products, product collections, product types, product tags, or customer groups mentioned in the Goal section. So it's essentially an extension of valid_for, we are looking to add.

Current approach
Our current entity DiscountRule would be updated to have a relation like so:

class DiscountRule
id
...
conditions: DiscountRuleCondition[]

This relation, conditions, determines for which products, product types, product tags, customer groups, and product collections the discount is applicable, as we've already mentioned a couple of times.

The schema for DiscountRuleCondition is currently scoped to be:

class DiscountRuleCondition
  id: string
  type: "products" | "product_types" | "product_tags" |   "product_collections" | "customer_groups"
  products: Product[]
  product_types: ProductType[]
  product_tags: ProductTag[]
  product_collections: ProductCollection[]
  customer_groups: CustomerGroup[]

Though this is sub-optimal, since it would require us to add entities for each of the different types of conditions to have referential integrity like so:

class ProductDiscountRuleCondition
  id: string
  product_id: string;
  product: Product
  discount_rule_condition: DiscountRuleCondition

class ProductTagDiscountRuleCondition
  id: string
  product_tag_id: string;
  product_tag: ProductTag
  discount_rule_condition: DiscountRuleCondition
  
class ProductTypeDiscountRuleCondition
  id: string
  product_type_id: string;
  product_type: ProductType
  discount_rule_condition: DiscountRuleCondition
  
class ProductCollectionDiscountRuleCondition
  id: string
  product_collection_id: string;
  product_collection: ProductCollection
  discount_rule_condition: DiscountRuleCondition
  
class CustomerGroupDiscountRuleCondition
  id: string
  customer_group_id: string;
  customer_group: CustomerGroup
  discount_rule_condition: DiscountRuleCondition

This quickly becomes ugly, and if we continue with this pattern going forward, we would end up with a huge amount of entities in the db over time.

Optimal implementation

It would be optimal to have a somewhat dynamic condition type i.e modeling the DicountRuleCondition more generally like so:

class DiscountRuleCondition
  id: string
  rule_id: string
  rule: DiscountRule
  type: "products" | "product_types" | "product_tags" |   "product_collections" | "customer_groups"
  values: DiscountRuleConditionType[] // a list of products, or a list of product types, etc.

class DiscountRuleConditionType
  resource_id: string // id of resource e.g. "prod_12345"
  resource_name: string // e.g. name of resource e.g. "product"
  discount_rule_condition_id: string

And again, add it as a relation to our existing DiscountRule like so:

class DiscountRule
  id: string
  conditions: DiscountRuleCondition[]

We might encounter some issues with foreign keys on the latter approach, since entries of DiscountRuleConditionType could point to missing resources. Hope that some of you might have some input to how and if we can go about it like this 💜

[adrien2p]

What I would suggest is something alongs the line (from the discussion I had with @olivermrbl)

import { Column, Entity, Index, JoinColumn, ManyToOne, OneToMany } from "typeorm";

@Entity()
@Index("resource_name_resource_id_idx", ["resource_name", "resource_id", …], { unique: true })
export class DiscountRuleConditionType<TModel = any> {
    @Column({ type: "string" })
    resource_id: string;

    @Column({ type: "string" })
    resource_name: string;

    @Column({ type: "string" })
    discount_rule_condition_id: string;

    @ManyToOne(() => DiscountRuleCondition, discountRuleCondition => discountRuleCondition.values)
    discount_rule_condition: DiscountRuleCondition<TModel>;

    @ManyToOne(() => DiscountEntity, discountEntity => discountEntity.discountRuleConditionTypes)
    entity: DiscountEntity<TModel>;
}

@Entity()
export class DiscountRuleCondition<TModel = any> {
    @Column({ type: "string" })
    id: string;

    @Column({ type: "string" })
    type: "products" | "product_types" | "product_tags" | "product_collections" | "customer_groups";

    @OneToMany(() => DiscountRuleConditionType, discountRuleConditionType => discountRuleConditionType.discount_rule_condition)
    values: DiscountRuleConditionType<TModel>[];

    @Column({ type: "string" })
    discount_rule_id: string;

    @ManyToOne(() => DiscountRule, discountRule => discountRule.conditions)
    discount_rule: DiscountRule<TModel>;
}

@Entity()
export class DiscountRule<TModel = any> {
    @Column({ type: "string" })
    id: string;

    @OneToMany(() => DiscountRuleCondition, discountRuleCondition => discountRuleCondition.discount_rule_id)
    conditions: DiscountRuleCondition<TModel>[];
}

And then for the base discount class from which the entity extends would hold a method alongs the line (which is the solution I would prefer since it is more flexible)

import { getManager } from "typeorm";
const entityManager = getManager();

/* Base Entity to extend */
export class DiscountEntity<TModel> {
    async getDiscountRuleConditionTypes(): Promise<DiscountRuleConditionType<TModel>[]> {
        return entityManager.find(DiscountRuleConditionType, {
            resource_name: this.constructor.name,
            resource_id: this.id
        });
    }
}

Or to try something like this

/* Base Entity to extend */
export class DiscountEntity<TModel> {
    get resource_name() {
        return this.constructor.name;
    }

    @OneToMany(() => DiscountRuleConditionType, discountRuleConditionType => discountRuleConditionType.entity)
    @JoinColumn([
        { name: "resource_name", referencedColumnName: "resource_name" },
        { name: "resource_id", referencedColumnName: "id" }
    ])
    discountRuleConditionTypes: DiscountRuleConditionType<TModel>[];
}

I did not get the time to tests the second one, but Ive already used the first one for another project (using sequelize) where I had a table
changes that was holding the changes made on any entity with the previous_value and value as well as the user who made the changes and we used a base method to get the changes resource for the entity which was concerned.

[adrien2p]

Not sure the type on DiscountRuleCondition would be necessary anymore since the resource name would be enough to segregate?

[olivermrbl]

I like the overall idea of this approach a lot since it's very easy to work with.

Though as we've discussed in Discord, it works well for cases where referential integrity is not an absolute must (e.g. for registering changes as you mention in your comment). But in our case, we want to ensure that the resource_ids of DiscountRuleConditionType always points to existing entities and we achieve that by having foreign key constraints.

So for now, we'll proceed with the "Join table per relation" approach.