Events

Storecraft boasts an event system called pub-sub. You can subscribe to events and dispatch events.

Each Storecraft App call, dispatches events, that you can listen to.

Quick Example

import { App } from '@storecraft/core'
import type { CollectionType, AuthUserType } from '@storecraft/core/api'

const app = new App(config)
.withPlatform(new NodePlatform())
.withDatabase(new MongoDB())
.withStorage(new GoogleStorage())
.on(
  'collections/upsert',
  async (event) => {
    const previous: CollectionType = event.payload.previous;
    const current: CollectionType = event.payload.current;
  }
)
.on(
  'auth/signup',
  async (event) => {
    const user: Partial<AuthUserType> = event.payload;

    // Here you can send an onboarding email for example

    console.log(user.email);
  }
)
.on(
  'orders/checkout/complete',
  async (event) => {
    const order_data: OrderData = event.payload.current;

    // Here send an email with order details to customer
  }
)
.on(
  'orders/fulfillment/shipped',
  async (event) => {
    const order_data: OrderData = event.payload.current;

    // Here send an email with order shipping
  }
)
.init();

Events Rundown

auth

event	dispatches
auth/signup	Partial<AuthUserType>
auth/signin	Partial<AuthUserType>
auth/refresh	Partial<ApiAuthResult>
auth/remove	Partial<AuthUserType>
auth/upsert	Partial<AuthUserType>
auth/apikey-created	Partial<AuthUserType>
auth/change-password	Partial<AuthUserType>
auth/confirm-email-token-generated	{ auth_user: Partial<AuthUserType>, token: string }
auth/confirm-email-token-confirmed	Partial<AuthUserType>
auth/forgot-password-token-generated	{ auth_user: Partial<AuthUserType>, token: string }
auth/forgot-password-token-confirmed	Partial<AuthUserType>

event	dispatches
email/before-send	Partial<MailObject>
email/after-send	{ mail_object: Partial<MailObject>, mail_response: Partial<MailResponse> }

orders

event	dispatches
orders/upsert	{ previous: OrderData, current: OrderData }
orders/remove	{ previous: OrderData, success: boolean }
orders/get	{ current: OrderData, }
orders/list	{ current: OrderData[], }
orders/checkout/created	{ previous: OrderData, current: OrderData }
orders/checkout/complete	{ previous: OrderData, current: OrderData }
orders/checkout/requires_action	{ previous: OrderData, current: OrderData }
orders/checkout/failed	{ previous: OrderData, current: OrderData }
orders/checkout/unknown	{ previous: OrderData, current: OrderData }
orders/checkout/update	{ previous: OrderData, current: OrderData }
orders/fulfillment/draft	{ previous: OrderData, current: OrderData }
orders/fulfillment/processing	{ previous: OrderData, current: OrderData }
orders/fulfillment/shipped	{ previous: OrderData, current: OrderData }
orders/fulfillment/fulfilled	{ previous: OrderData, current: OrderData }
orders/fulfillment/cancelled	{ previous: OrderData, current: OrderData }
orders/fulfillment/update	{ previous: OrderData, current: OrderData }
orders/payments/unpaid	{ previous: OrderData, current: OrderData }
orders/payments/authorized	{ previous: OrderData, current: OrderData }
orders/payments/captured	{ previous: OrderData, current: OrderData }
orders/payments/requires_auth	{ previous: OrderData, current: OrderData }
orders/payments/voided	{ previous: OrderData, current: OrderData }
orders/payments/failed	{ previous: OrderData, current: OrderData }
orders/payments/partially_paid	{ previous: OrderData, current: OrderData }
orders/payments/partially_refunded	{ previous: OrderData, current: OrderData }
orders/payments/cancelled	{ previous: OrderData, current: OrderData }
orders/payments/update	{ previous: OrderData, current: OrderData }

storefronts

event	dispatches
storefronts/upsert	{ previous: StorefrontType, current: StorefrontType }
storefronts/remove	{ previous: StorefrontType, success: boolean }
storefronts/get	{ current: StorefrontType, }
storefronts/list	{ current: StorefrontType[], }

customers

event	dispatches
customers/upsert	{ previous: CustomerType, current: CustomerType }
customers/remove	{ previous: CustomerType, success: boolean }
customers/get	{ current: CustomerType, }
customers/list	{ current: CustomerType[], }

products

event	dispatches
products/upsert	{ previous: ProductType, current: ProductType }
products/remove	{ previous: ProductType, success: boolean }
products/get	{ current: ProductType, }
products/list	{ current: ProductType[], }

collections

event	dispatches
collections/upsert	{ previous: CollectionType, current: CollectionType }
collections/remove	{ previous: CollectionType, success: boolean }
collections/get	{ current: CollectionType, }
collections/list	{ current: CollectionType[], }

discounts

event	dispatches
discounts/upsert	{ previous: DiscountType, current: DiscountType }
discounts/remove	{ previous: DiscountType, success: boolean }
discounts/get	{ current: DiscountType, }
discounts/list	{ current: DiscountType[], }

event	dispatches
tags/upsert	{ previous: TagType, current: TagType }
tags/remove	{ previous: TagType, success: boolean }
tags/get	{ current: TagType, }
tags/list	{ current: TagType[], }

event	dispatches
shipping/upsert	{ previous: ShippingMethodType, current: ShippingMethodType }
shipping/remove	{ previous: ShippingMethodType, success: boolean }
shipping/get	{ current: ShippingMethodType, }
shipping/list	{ current: ShippingMethodType[], }

event	dispatches
posts/upsert	{ previous: PostType, current: PostType }
posts/remove	{ previous: PostType, success: boolean }
posts/get	{ current: PostType, }
posts/list	{ current: PostType[], }

event	dispatches
images/upsert	{ previous: ImageType, current: ImageType }
images/remove	{ previous: ImageType, success: boolean }
images/get	{ current: ImageType, }
images/list	{ current: ImageType[], }

event	dispatches
templates/upsert	{ previous: TemplateType, current: TemplateType }
templates/remove	{ previous: TemplateType, success: boolean }
templates/get	{ current: TemplateType, }
templates/list	{ current: TemplateType[], }