@splendidlabz/third-party 0.1.0

package/.eslintrc.cjs

@@ -0,0 +1,3 @@
+module.exports = {
+  extends: ['@splendidlabz/eslint-config'],
+}

package/buttondown.js

@@ -0,0 +1,101 @@
+import { omitEmpty } from '@splendidlabz/utils'
+import { createZlFetch, reject } from 'zl-fetch'
+
+const token = import.meta.env.BUTTONDOWN_KEY
+
+const BASE_URL = 'https://api.buttondown.email/v1'
+const buttonDown = createZlFetch(BASE_URL, {
+  headers: {
+    Accept: 'application/json',
+    Authorization: `Token ${token}`,
+  },
+  returnError: true,
+  debug: true,
+})
+
+export async function getSubscriber(email) {
+  const { response } = await buttonDown.get(`/subscribers/${email}`)
+  if (response) return response.body
+  else return null
+}
+
+const DEFAULT_SUBSCRIBER_OPTIONS = {
+  notes: '',
+  metadata: {},
+  tags: [],
+  referrer_url: '',
+  utm_campagin: '',
+  utm_medium: '',
+  utm_source: '',
+  referring_subscriber_id: '',
+  subscriber_type: 'regular',
+}
+
+// Creates a subscriber
+// Notes:
+//  - Button down throws an error if the email is invalid. Though this only occurs after using fake emails for many times. Shouldn't be a problem to ignore.
+export async function createSubscriber(email, props = {}) {
+  const data = omitEmpty({ ...DEFAULT_SUBSCRIBER_OPTIONS, ...props })
+  if (props.double_opt_in === true) data.subscriber_type = 'unactivated'
+  const { response, error } = await buttonDown.post('/subscribers', {
+    body: { email, ...data },
+  })
+
+  if (response) return response.body
+  if (error) {
+    if (error.code === 'email_invalid') return // Swallow this error
+    return reject(error)
+  }
+}
+
+// https://docs.buttondown.email/api-subscribers-update
+// Updates a subscriber.
+// Notes:
+//  - Buttondown throws an error if subscriber doesn't exist.
+//  - It's not possible to change a user's email with this API.
+export async function updateSubscriber(email, props = {}, options = {}) {
+  const {
+    metadata: incomingMetadata = {},
+    tags: incomingTags = [],
+    ...rest
+  } = props
+  const { mergeTags = true, mergeMetadata = true } = options
+
+  const sub = await getSubscriber(email)
+  if (!sub) return reject({ status: 400, message: 'Subscriber not found' })
+
+  // Determine whether to merge or overwrite tags and metadata
+  const { tags, metadata } = sub
+  const newTags = mergeTags
+    ? Array.from(new Set(tags, incomingTags))
+    : incomingTags
+  const newMetadata = mergeMetadata
+    ? Object.assign(metadata, incomingMetadata)
+    : incomingMetadata
+
+  const data = omitEmpty({
+    ...rest,
+    tags: newTags,
+    metadata: newMetadata,
+  })
+
+  const { response, error } = await buttonDown.patch(`/subscribers/${email}`, {
+    body: data,
+  })
+
+  if (response) return response.body
+  if (error) return reject(error)
+}
+
+export async function upsertSubscriber(email, props = {}) {
+  const sub = await getSubscriber(email)
+  if (sub) return updateSubscriber(email, props)
+  else return createSubscriber(email, props)
+}
+
+export async function removeTagsFromSubscriber(email, tags = []) {
+  const sub = await getSubscriber(email)
+  if (!sub) return reject({ status: 400, message: 'Subscriber not found' })
+  const newTags = sub.tags.filter(tag => !tags.includes(tag))
+  return updateSubscriber(email, { tags: newTags }, { mergeTags: false })
+}

package/google.js

@@ -0,0 +1,97 @@
+import { google } from 'googleapis'
+import { reject } from 'zl-fetch'
+
+// 1. Create New Google Project (in the cloud console https://console.cloud.google.com/apis/library?project=splendid-labz)
+// 2. Enable API Library (https://console.cloud.google.com/apis/library?project=splendid-labz)
+// 3. Create credentials
+//  Create a service account. Choose application data.
+// 4. Account Owner (cos simpler)
+// Go to Credentials, under Service Account, open it up. Create a key. This key will be saved in on your computer.
+// 5. Open up the key. Add the service account to the google sheet(s), or better, to the entire drive folder. This ensures you don't have to manually add credentials.
+//
+// https://sheets.googleapis.com
+// POST /v4/spreadsheets/{spreadsheetId}/values/{range}:append
+import { promisify } from 'util'
+
+export function GoogleSheets(credentials, options) {
+  const auth = new google.auth.GoogleAuth({
+    keyFile: credentials,
+    scopes: [
+      'https://www.googleapis.com/auth/spreadsheets',
+      'https://www.googleapis.com/auth/drive',
+    ],
+  })
+
+  const service = google.sheets({ version: 'v4' })
+  const sheets = service.spreadsheets.values
+
+  return {
+    async read(spreadsheetId, { range = 'Sheet1!A1' } = {}) {
+      const get = promisify(sheets.get).bind(sheets)
+
+      try {
+        const res = await get({
+          auth,
+          spreadsheetId,
+          range: 'Sheet1',
+        })
+        const rows = res.data.values
+        return rows
+      } catch (err) {
+        const { status, errors } = err
+        return reject({ status, message: errors[0].message })
+      }
+    },
+
+    // Check google-api samples for the actual format.
+    // It's different from the REST values mentioned in Google dcos.
+    async append(
+      spreadsheetId,
+      { majorDimension, range = 'Sheet1', values = [] } = {},
+    ) {
+      const append = promisify(sheets.append).bind(sheets)
+
+      try {
+        const res = await append({
+          auth,
+          spreadsheetId,
+          range,
+          majorDimension: majorDimension.toUpperCase(),
+          valueInputOption: 'USER_ENTERED',
+          requestBody: {
+            major_dimension: 'ROWS',
+            values,
+          },
+        })
+        return res.data.updates
+      } catch (err) {
+        const { status, errors } = err
+        return reject({ status, message: errors[0].message })
+      }
+    },
+
+    async appendOne(
+      spreadsheetId,
+      { majorDimension = 'ROWS', range = 'Sheet1', value = [] } = {},
+    ) {
+      const append = promisify(sheets.append).bind(sheets)
+
+      try {
+        const res = await append({
+          auth,
+          spreadsheetId,
+          range,
+          valueInputOption: 'USER_ENTERED',
+          requestBody: {
+            major_dimension: 'ROWS',
+            values: [value],
+          },
+        })
+        return res.data.updates
+      } catch (err) {
+        const { status, errors } = err
+        return reject({ status, message: errors[0].message })
+      }
+    },
+  }
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@splendidlabz/third-party",
+  "prettier": "@splendidlabz/prettier-config",
+  "version": "0.1.0",
+  "description": "",
+  "type": "module",
+  "main": "index.js",
+  "sideEffects": false,
+  "scripts": {
+    "lint": "eslint . --fix"
+  },
+  "author": "Zell Liew <zellwk@gmail.com>",
+  "dependencies": {
+    "googleapis": "^140.0.1",
+    "http-errors": "^2.0.0",
+    "postmark": "^4.0.4",
+    "zl-fetch": "^6.0.6"
+  },
+  "devDependencies": {
+    "@splendidlabz/eslint-config": "*",
+    "@splendidlabz/prettier-config": "*"
+  }
+}

package/postmark.js

@@ -0,0 +1,47 @@
+import postmark from 'postmark'
+
+const POSTMARK_KEY = import.meta.env.POSTMARK_KEY
+const DEFAULT_OPTIONS = {
+  MessageStream: 'outbound', // outbound | broadcast
+}
+
+const client = new postmark.ServerClient(POSTMARK_KEY)
+
+// Allow for default options
+export default function Postmark(options) {
+  const baseOpts = Object.assign({}, DEFAULT_OPTIONS, options)
+
+  return {
+    // Sends email with Postmark
+    sendEmail(newOptions) {
+      const opts = Object.assign({}, baseOpts, newOptions)
+      const { from, to, replyTo, subject, html, text, ...rest } = opts
+
+      return client.sendEmail({
+        From: from,
+        To: to,
+        ReplyTo: replyTo,
+        Subject: subject,
+        HTMLBody: html,
+        TextBody: text,
+        ...rest,
+      })
+    },
+  }
+}
+
+// Allow for direct usage
+export async function sendEmail(newOptions) {
+  const opts = Object.assign({}, DEFAULT_OPTIONS, newOptions)
+  const { from, to, replyTo, subject, html, text, ...rest } = opts
+
+  return client.sendEmail({
+    From: from,
+    To: to,
+    ReplyTo: replyTo,
+    Subject: subject,
+    HTMLBody: html,
+    TextBody: text,
+    ...rest,
+  })
+}

package/stripe.js

@@ -0,0 +1,88 @@
+import { omitEmpty, reject } from '@splendidlabz/utils'
+
+/**
+ * Verifies a Stripe webhook event.
+ * @param {Object} options
+ * @param {Request} options.request - The incoming request object.
+ * @param {Object} options.stripe - The Stripe instance.
+ * @param {string} options.webhookSecret - The webhook secret
+ * @param {boolean} [options.checkOnDev=false] - Whether to perform verification in development mode.
+ * @returns {Promise<Object|Response>} The event object
+ * @throws {Error} If there is a verification error.
+ */
+export async function verifyStripeWebhookEvent({
+  request,
+  stripe,
+  webhookSecret,
+  verify = true,
+}) {
+  // Allow skipping verification
+  if (verify === false) return request.json()
+
+  // Production.
+  // Must ensure Stripe is OK
+  const sig = request.headers.get('Stripe-Signature')
+  const payload = await request.text()
+  try {
+    return stripe.webhooks.constructEvent(payload, sig, webhookSecret)
+  } catch (err) {
+    return reject({ status: 500, message: `Webhook Error: ${err.message}` })
+  }
+}
+
+/**
+ * @typedef {('subscription_update'|'subscription_cancel'|'payment_method_update')} FlowType
+ * The type of flow for the session.
+ * @property {string} subscription_update - Update a subscription.
+ * @property {string} subscription_cancel - Cancel a subscription.
+ * @property {string} payment_method_update - Update a payment method.
+ */
+
+/**
+ * Creates a billing portal session using the Stripe API.
+ * Supports 3 types of flows:
+ *  1. Payment method update
+ *  2. Subscription update
+ *  3. Subscription cancel
+ * @param {Object} stripe - The Stripe instance
+ * @param {Object} props - Properties required to create the billing portal session.
+ * @param {string} props.customer - Customer ID
+ * @param {string} props.return_url - Return URL to be directed to
+ * @param {FlowType} [props.flow_type] - Flow type. Defaults to null.
+ * @param {string} [props.subscriptionId] - Subscription ID to be updated or cancelled.
+ * @returns {Promise<Object>} The created billing portal session.
+ * @example
+ * const session = await createBillingPortalSession(stripe, {
+ *   customer: 'cus_123456789',
+ *   return_url: 'https://example.com/return',
+ *   flow_type: 'subscription_update',
+ *   subscriptionId: 'sub_123456789'
+ * });
+ */
+export async function createBillingPortalSession(stripe, props = {}) {
+  const {
+    customer,
+    return_url,
+    flow_type = null,
+    subscriptionId = null,
+  } = props
+
+  const bpData = {
+    customer,
+    return_url,
+    flow_data: {},
+  }
+
+  if (flow_type) bpData.flow_data.type = flow_type
+
+  // For subscription update and cancel
+  if (
+    flow_type === 'subscription_update' ||
+    flow_type === 'subscription_cancel'
+  ) {
+    if (!subscriptionId) throw new Error('Subscription ID is required')
+    bpData.flow_data[flow_type] = { subscription: subscriptionId }
+  }
+
+  return stripe.billingPortal.sessions.create(omitEmpty(bpData))
+}