@live-change/stripe-service 0.8.109 → 0.8.111

package/index.js

@@ -4,6 +4,7 @@ const app = App.app()
 import definition from './definition.js'
 
 import "./payment.js"
+import "./stripeEvents.js"
 import "./webhook.js"
 
 export default definition

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@live-change/stripe-service",
-  "version": "0.8.109",
+  "version": "0.8.111",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -21,14 +21,14 @@
     "url": "https://www.viamage.com/"
   },
   "dependencies": {
-    "@live-change/framework": "^0.8.109",
-    "@live-change/relations-plugin": "^0.8.109",
+    "@live-change/framework": "^0.8.111",
+    "@live-change/relations-plugin": "^0.8.111",
     "lru-cache": "^7.12.0",
     "pluralize": "^8.0.0",
     "progress-stream": "^2.0.0",
     "prosemirror-model": "^1.18.1",
     "stripe": "^17.2.1"
   },
-  "gitHead": "075bf3759fae6c40fb8e44d77d9f12c5c175e098",
+  "gitHead": "9b96afb2fc61ab3d2a5d143924e2c56d411280b4",
   "type": "module"
 }

package/payment.js

@@ -4,38 +4,38 @@ const app = App.app()
 import definition from './definition.js'
 import config from './config.js'
 
-import stripe from 'stripe'
+import stripe from "./stripeClient.js"
 
 const itemsArray = {
-    type: Array,
-    of: {
-      type: Object,
-      properties: {
-        name: {
-          type: String,
-          validation: ['nonEmpty']
-        },
-        price: {
-          type: Number,
-          validation: ['nonEmpty', 'number']
-        },
-        currency: {
-          type: String,
-          validation: ['nonEmpty']
-        },
-        quantity: {
-          type: Number,
-          validation: ['nonEmpty', 'number']
-        },
-        description: {
-          type: String
-        },
-        taxCode: {
-          type: String
-        }
+  type: Array,
+  of: {
+    type: Object,
+    properties: {
+      name: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      price: {
+        type: Number,
+        validation: ['nonEmpty', 'number']
+      },
+      currency: {
+        type: String,
+        validation: ['nonEmpty']
+      },
+      quantity: {
+        type: Number,
+        validation: ['nonEmpty', 'number']
+      },
+      description: {
+        type: String
+      },
+      taxCode: {
+        type: String
       }
     }
   }
+}
 
 const paymentParameters = {
   items: itemsArray,
@@ -54,10 +54,18 @@ const paymentParameters = {
   cancelUrl: {
     type: String,
     validation: ['nonEmpty']
+  },
+  payerType: {
+    type: String,
+    validation: ['nonEmpty']
+  },
+  payer: {
+    type: String,
+    validation: ['nonEmpty']
   }
 }
 
-definition.model({
+const Payment = definition.model({
   name: "Payment",
   entity:{
   },
@@ -65,7 +73,7 @@ definition.model({
     ...paymentParameters,
     state: {
       type: String,
-      options: ['created', 'succeeded', 'failed', 'refunded']
+      options: ['created', 'pending', 'succeeded', 'failed', 'refunded']
     },
     stripeSession: {
       type: String
@@ -75,21 +83,33 @@ definition.model({
   }
 })
 
+export { Payment}
+
 definition.trigger({
   name: 'startPayment',
   properties: {
     ...paymentParameters
   },
-  async execute({ items, causeType, cause, successUrl, cancelUrl }, { client, service }, emit) {
-    console.log("STRIPE SECRET KEY", config.secretKey)
+  waitForEvents: true,
+  async execute({ items, causeType, cause, successUrl, cancelUrl, payerType, payer }, { service }, emit) {
     const payment = app.generateUid()
-    const stripeClient = stripe(config.secretKey)
+    if(!successUrl) successUrl = config.checkoutSuccessUrl + '/' + payment.replace(/\[/g, '(').replace(/]/g, ')')
+    if(!cancelUrl) cancelUrl = config.checkoutCancelUrl + '/' + payment.replace(/\[/g, '(').replace(/]/g, ')')
     console.log("URLS", {
-      success_url: successUrl ?? (config.checkoutSuccessUrl + '/' + payment),
-      cancel_url: cancelUrl ?? (config.checkoutCancelUrl + '/' + payment)
+      success_url: successUrl,
+      cancel_url: cancelUrl,
     })
-    const session = await stripeClient.checkout.sessions.create({
+    const metadata = {
+      type: 'payment',
+      payment
+    }
+    const session = await stripe.checkout.sessions.create({
       payment_method_types: ['card'],
+      client_reference_id: 'payment:'+payment,
+      // customer: // store stripe customer id ?
+      // customer_creation: 'always'
+      /// TODO:
+      // customer_email: /// get from contacts
       line_items: items.map(item => ({
         price_data: {
           currency: item.currency,
@@ -102,15 +122,23 @@ definition.trigger({
         },
         quantity: item.quantity
       })),
+      invoice_creation: {
+        enabled: true
+      },
+      metadata,
+      payment_intent_data: {
+        metadata
+      },
       mode: 'payment',
-      success_url: successUrl ?? (config.checkoutSuccessUrl + '/' + payment),
-      cancel_url: cancelUrl ?? (config.checkoutCancelUrl + '/' + payment)
+      success_url: successUrl,
+      cancel_url: cancelUrl,
     })
     emit({
       type: 'PaymentCreated',
       payment,
       data: {
-        items, causeType, cause,
+        items, causeType, cause, payerType, payer,
+        successUrl, cancelUrl,
         stripeSession: session.id,
         state: 'created'
       }

package/stripeClient.js

@@ -0,0 +1,8 @@
+import stripe from 'stripe'
+
+import config from './config.js'
+
+console.log("STRIPE SECRET KEY", config.secretKey)
+const stripeClient = stripe(config.secretKey)
+
+export default stripeClient

package/stripeEvents.js

@@ -0,0 +1,323 @@
+import App from '@live-change/framework'
+const app = App.app()
+
+import definition from './definition.js'
+import config from './config.js'
+
+import stripe from "./stripeClient.js"
+
+import { Payment } from './payment.js'
+
+definition.trigger({
+  name: 'stripeEvent.checkout.session.completed',
+  properties: {
+    data: {
+      type: Object,
+      properties: {
+        object: {
+          type: Object,
+          properties: {
+            client_reference_id: {
+              type: String,
+              validation: ['nonEmpty']
+            }
+          }
+        }
+      }
+    }
+  },
+  async execute({ data: { object } }, { triggerService, trigger }, emit) {
+    //console.log('stripeEvent.checkout.session.completed', object)
+    const id = object.client_reference_id
+    const referenceType = id.slice(0, id.indexOf(':'))
+    const referenceId = id.slice(id.indexOf(':') + 1)
+    if(referenceType === 'payment') {
+      const payment = await Payment.get(referenceId)
+      if(!payment) throw new Error('Payment '+referenceId+' not found')
+      if(object.payment_status === 'paid') {
+        console.log("PAYMENT TO UPDATE", payment)
+        await triggerService({
+          service: definition.name,
+          type: 'stripe_updatePayment'
+        }, {
+          payment: referenceId,
+          state: 'succeeded'
+        })
+        const triggerData = {
+          paymentType: 'stripe_Payment',
+          payment: referenceId,
+          causeType: payment.causeType,
+          cause: payment.cause,
+          payerType: payment.payerType,
+          payer: payment.payer,
+          items: payment.items
+        }
+        await trigger({
+          type: 'paymentSucceeded_'+payment.causeType,
+        }, triggerData)
+        await trigger({
+          type: 'paymentSucceeded',
+        }, triggerData)
+      } else if(object.payment_status === 'unpaid') {
+        await triggerService({
+          service: definition.name,
+          type: 'stripe_updatePayment'
+        }, {
+          payment: referenceId,
+          state: 'pending'
+        })
+      }
+    } else {
+      // Ignore
+    }
+
+  }
+})
+
+
+definition.trigger({
+  name: 'stripeEvent.checkout.session.expired',
+  properties: {
+    data: {
+      type: Object,
+      properties: {
+        object: {
+          type: Object,
+          properties: {
+            client_reference_id: {
+              type: String,
+              validation: ['nonEmpty']
+            }
+          }
+        }
+      }
+    }
+  },
+  async execute({ data: { object } }, { triggerService, trigger }, emit) {
+    ///console.log('stripeEvent.checkout.session.expired', object)
+    const id = object.client_reference_id
+    const referenceType = id.slice(0, id.indexOf(':'))
+    const referenceId = id.slice(id.indexOf(':') + 1)
+    if(referenceType === 'payment') {
+      const payment = await Payment.get(referenceId)
+      if(!payment) throw new Error('Payment '+referenceId+' not found')
+      await triggerService({
+        type: 'stripe_updatePayment'
+      }, {
+        payment: referenceId,
+        state: 'failed'
+      })
+      const triggerData = {
+        paymentType: 'stripe_Payment',
+        payment: referenceId,
+        causeType: payment.causeType,
+        cause: payment.cause,
+        payerType: payment.payerType,
+        payer: payment.payer,
+        items: payment.items
+      }
+      await trigger({
+        type: 'paymentFailed_'+payment.causeType,
+      }, triggerData)
+      await trigger({
+        type: 'paymentFailed',
+      }, triggerData)
+    } else {
+      // Ignore
+    }
+
+  }
+})
+
+
+definition.trigger({
+  name: 'stripeEvent.checkout.session.async_payment_succeeded',
+  properties: {
+    data: {
+      type: Object,
+      properties: {
+        object: {
+          type: Object,
+          properties: {
+            client_reference_id: {
+              type: String,
+              validation: ['nonEmpty']
+            }
+          }
+        }
+      }
+    }
+  },
+  async execute({ data: { object } }, { triggerService, trigger }, emit) {
+    //console.log('stripeEvent.checkout.session.async_payment_succeeded', object)
+    const id = object.client_reference_id
+    const referenceType = id.slice(0, id.indexOf(':'))
+    const referenceId = id.slice(id.indexOf(':') + 1)
+    if(referenceType === 'payment') {
+      const payment = await Payment.get(referenceId)
+      if(!payment) throw new Error('Payment '+referenceId+' not found')
+      if(object.payment_status === 'paid') {
+        await triggerService({
+          type: 'stripe_updatePayment'
+        }, {
+          payment: referenceId,
+          state: 'succeeded'
+        })
+        const triggerData = {
+          paymentType: 'stripe_Payment',
+          payment: referenceId,
+          causeType: payment.causeType,
+          cause: payment.cause,
+          payerType: payment.payerType,
+          payer: payment.payer,
+          items: payment.items
+        }
+        await trigger({
+          type: 'paymentSucceeded_'+payment.causeType,
+        }, triggerData)
+        await trigger({
+          type: 'paymentSucceeded',
+        }, triggerData)
+      } else if(object.payment_status === 'unpaid') {
+        await triggerService({
+          type: 'stripe_updatePayment'
+        }, {
+          payment: referenceId,
+          state: 'pending'
+        })
+      }
+    } else {
+      // Ignore
+    }
+
+  }
+})
+
+
+definition.trigger({
+  name: 'stripeEvent.checkout.session.async_payment_failed',
+  properties: {
+    data: {
+      type: Object,
+      properties: {
+        object: {
+          type: Object,
+          properties: {
+            client_reference_id: {
+              type: String,
+              validation: ['nonEmpty']
+            }
+          }
+        }
+      }
+    }
+  },
+  async execute({ data: { object } }, { triggerService, trigger }, emit) {
+    //console.log('stripeEvent.checkout.session.async_payment_failed', object)
+    const id = object.client_reference_id
+    const referenceType = id.slice(0, id.indexOf(':'))
+    const referenceId = id.slice(id.indexOf(':') + 1)
+    if(referenceType === 'payment') {
+      const payment = await Payment.get(referenceId)
+      if(!payment) throw new Error('Payment '+referenceId+' not found')
+      await triggerService({
+        type: 'stripe_updatePayment'
+      }, {
+        payment: referenceId,
+        state: 'failed'
+      })
+      const triggerData = {
+        paymentType: 'stripe_Payment',
+        payment: referenceId,
+        causeType: payment.causeType,
+        cause: payment.cause,
+        payerType: payment.payerType,
+        payer: payment.payer,
+        items: payment.items
+      }
+      await trigger({
+        type: 'paymentFailed_'+payment.causeType,
+      }, triggerData)
+      await trigger({
+        type: 'paymentFailed',
+      }, triggerData)
+    } else {
+      // Ignore
+    }
+
+  }
+})
+
+definition.trigger({
+  name: 'stripeEvent.charge.succeeded',
+  properties: {
+    data: {
+      type: Object,
+      properties: {
+        object: {
+          type: Object
+        }
+      }
+    }
+  },
+  async execute({ data: { object } }, { triggerService, trigger }, emit) {
+    console.log('charge.succeeded', JSON.stringify(object, null, 2))
+    if(object.metadata?.type === 'payment') {
+      const payment = await Payment.get(object.metadata.payment)
+      const triggerData = {
+        paymentType: 'stripe_Payment',
+        payment: payment.id,
+        causeType: payment.causeType,
+        cause: payment.cause,
+        payerType: payment.payerType,
+        payer: payment.payer,
+        items: payment.items
+      }
+      await trigger({
+        type: 'chargeCollected_'+payment.causeType
+      }, triggerData)
+      await trigger({
+        type: 'chargeCollected'
+      }, triggerData)
+    } else {
+      // Ignore
+    }
+  }
+})
+
+definition.trigger({
+  name: 'stripeEvent.charge.refunded',
+  properties: {
+    data: {
+      type: Object,
+      properties: {
+        object: {
+          type: Object
+        }
+      }
+    }
+  },
+  async execute({ data: { object } }, { triggerService, trigger }, emit) {
+    console.log('charge.refunded', JSON.stringify(object, null, 2))
+    if(object.metadata?.type === 'payment') {
+      const payment = await Payment.get(object.metadata.payment)
+      const triggerData = {
+        paymentType: 'stripe_Payment',
+        payment: payment.id,
+        causeType: payment.causeType,
+        cause: payment.cause,
+        payerType: payment.payerType,
+        payer: payment.payer,
+        items: payment.items
+      }
+      await trigger({
+        type: 'chargeRefunded_'+payment.causeType,
+      }, triggerData)
+      await trigger({
+        type: 'chargeRefunded',
+      }, triggerData)
+    } else {
+      // Ignore
+    }
+  }
+})

package/webhook.js

@@ -1,6 +1,9 @@
 import App from '@live-change/framework'
 const app = App.app()
 import definition from './definition.js'
+import config from './config.js'
+
+import { encodeDate } from "@live-change/uid"
 
 import crypto from "crypto"
 import express from "express"
@@ -18,11 +21,17 @@ definition.endpoint({
     })
     expressApp.post('/', express.raw({type: 'application/json'}), async (request, response) => {
       try {
-        const event = stripe.webhooks.constructEvent(request.body, sig, config.webhookSecret)
-        console.log("STRIPE WEBHOOK", event)
-        await app.triggerService({
-          service: 'stripe',
-          type: `stripe.${event.type}`
+        const signature = request.headers['stripe-signature']
+        const event = stripe.webhooks.constructEvent(request.body, signature, config.webhookSecret)
+        console.log("STRIPE WEBHOOK", event.type)//, JSON.stringify(event))
+        const { id, created } = event
+        const eventIdEncoded = `[${encodeDate(new Date(created*1000))}.${id}@stripe]`
+        await app.trigger({
+          // service: 'stripe',
+          type: `stripeEvent.${event.type}`,
+          id: eventIdEncoded // needed for deduplication
+        }, {
+          ...event
         })
         response.json({ received: true })
       } catch (err) {