pockethost 1.0.0-rc.1

package/dist/mothership-app/pb_hooks/src/signup.pb.js

@@ -0,0 +1,214 @@
+/// <reference path="../types/types.d.ts" />
+
+routerAdd(
+  'GET',
+  '/api/signup',
+  (c) => {
+    /**
+     * @param {string} slug
+     * @returns
+     */
+    const isAvailable = (slug) => {
+      try {
+        const record = $app
+          .dao()
+          .findFirstRecordByData('instances', 'subdomain', slug)
+        return false
+      } catch {
+        return true
+      }
+    }
+
+    /**
+     * @param {string} fieldName
+     * @param {string} slug
+     * @param {string} description
+     * @param {StringKvLookup} [extra]
+     * @returns
+     */
+    const error = (fieldName, slug, description, extra) =>
+      new ApiError(500, description, {
+        [fieldName]: new ValidationError(slug, description),
+        ...extra,
+      })
+
+    const instanceName = (() => {
+      const name = c.queryParam('name').trim()
+      if (name) {
+        if (name.match(/^[a-z][a-z0-9-]{2,39}$/) === null) {
+          throw error(
+            `instanceName`,
+            `invalid`,
+            `Instance name must begin with a letter, be between 3-40 characters, and can only contain a-z, 0-9, and hyphen (-).`,
+          )
+        }
+        if (isAvailable(name)) {
+          return name
+        }
+        throw error(
+          `instanceName`,
+          `exists`,
+          `Instance name ${name} is not available.`,
+        )
+      } else {
+        const random = require(`${__hooks}/random-words.js`)
+        let i = 0
+        while (true) {
+          i++
+          if (i > 100) {
+            return +new Date()
+          }
+          const slug = random.generate(2).join(`-`)
+          if (isAvailable(slug)) return slug
+        }
+      }
+    })()
+    return c.json(200, { instanceName })
+  } /* optional middlewares */,
+)
+
+/*
+  // HTTP 200
+  {
+    status: 'ok'
+  }
+  
+  // HTTP 500
+  {
+      "code": 500,
+      "message": "That user account already exists. Try a password reset.",
+      "data": {
+          "email": {
+              "code": "exists",
+              "message": "That user account already exists. Try a password reset."
+          }
+      }
+  }
+  
+  {
+      "code": 500,
+      "message": "Instance name was taken, sorry about that. Try another.",
+      "data": {
+          "instanceName": {
+              "code": "exists",
+              "message": "Instance name was taken, sorry about that. Try another."
+          }
+      }
+  }
+  */
+
+// https://pocketbase.io/docs/js-routing/#sending-request-to-custom-routes-using-the-sdks
+routerAdd(
+  'POST',
+  '/api/signup',
+  (c) => {
+    const dao = $app.dao()
+    const parsed = (() => {
+      const rawBody = readerToString(c.request().body)
+      try {
+        const parsed = JSON.parse(rawBody)
+        return parsed
+      } catch (e) {
+        throw new BadRequestError(
+          `Error parsing payload. You call this JSON? ${rawBody}`,
+          e,
+        )
+      }
+    })()
+    const email = parsed.email?.trim()
+    const password = parsed.password?.trim()
+    const desiredInstanceName = parsed.instanceName?.trim()
+
+    /**
+     * @param {string} fieldName
+     * @param {string} slug
+     * @param {string} description
+     * @param {StringKvLookup} [extra]
+     * @returns
+     */
+    const error = (fieldName, slug, description, extra) =>
+      new ApiError(500, description, {
+        [fieldName]: new ValidationError(slug, description),
+        ...extra,
+      })
+
+    if (!email) {
+      throw error(`email`, 'required', 'Email is required')
+    }
+
+    if (!password) {
+      throw error(`password`, `required`, 'Password is required')
+    }
+
+    if (!desiredInstanceName) {
+      throw error(`instanceName`, `required`, `Instance name is required`)
+    }
+
+    const userExists = (() => {
+      try {
+        const record = dao.findFirstRecordByData('users', 'email', email)
+        return true
+      } catch {
+        return false
+      }
+    })()
+
+    if (userExists) {
+      throw error(
+        `email`,
+        `exists`,
+        `That user account already exists. Try a password reset.`,
+      )
+    }
+
+    dao.runInTransaction((txDao) => {
+      const usersCollection = dao.findCollectionByNameOrId('users')
+      const instanceCollection = $app
+        .dao()
+        .findCollectionByNameOrId('instances')
+
+      const user = new Record(usersCollection)
+      try {
+        const username = $app
+          .dao()
+          .suggestUniqueAuthRecordUsername(
+            'users',
+            'user' + $security.randomStringWithAlphabet(5, '123456789'),
+          )
+        user.set('username', username)
+        user.set('email', email)
+        user.set('subscription', 'free')
+        user.set('notifyMaintenanceMode', true)
+        user.setPassword(password)
+        txDao.saveRecord(user)
+      } catch (e) {
+        throw error(`email`, `fail`, `Could not create user: ${e}`)
+      }
+
+      try {
+        const instance = new Record(instanceCollection)
+        instance.set('subdomain', desiredInstanceName)
+        instance.set('uid', user.get('id'))
+        instance.set('status', 'idle')
+        instance.set('notifyMaintenanceMode', true)
+        instance.set('syncAdmin', true)
+        const { versions } = require(`${__hooks}/versions.js`)
+        instance.set('version', versions[0])
+        txDao.saveRecord(instance)
+      } catch (e) {
+        if (`${e}`.match(/ UNIQUE /)) {
+          throw error(
+            `instanceName`,
+            `exists`,
+            `Instance name was taken, sorry about that. Try another.`,
+          )
+        }
+        throw error(`instanceName`, `fail`, `Could not create instance: ${e}`)
+      }
+
+      $mails.sendRecordVerification($app, user)
+    })
+
+    return c.json(200, { status: 'ok' })
+  } /* optional middlewares */,
+)

package/dist/mothership-app/pb_hooks/src/sns.pb.js

@@ -0,0 +1,133 @@
+/// <reference path="../types/types.d.ts" />
+
+routerAdd('POST', '/api/sns', (c) => {
+  const dao = $app.dao()
+  const { mkLog, audit } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+  const log = mkLog(`sns`)
+
+  const processBounce = (emailAddress) => {
+    log(`Processing ${emailAddress}`)
+    const extra = /** @type {{ email: string; user: string }} */ ({
+      email: emailAddress,
+    })
+    try {
+      const user = dao.findFirstRecordByData('users', 'email', emailAddress)
+      log(`user is`, user)
+      extra.user = user.getId()
+      user.setVerified(false)
+      dao.saveRecord(user)
+      audit('PBOUNCE', `User ${emailAddress} has been disabled`, {
+        dao,
+        extra,
+        log,
+      })
+    } catch (e) {
+      audit('PBOUNCE_ERR', `${e}`, { dao, log, extra })
+      log(`After audit`)
+    }
+  }
+
+  ;[].forEach(processBounce)
+
+  const raw = readerToString(c.request().body)
+  const data = JSON.parse(raw)
+  log(JSON.stringify(data, null, 2))
+
+  const { Type } = data
+
+  switch (Type) {
+    case `SubscriptionConfirmation`:
+      const url = data.SubscribeURL
+      log(url)
+      $http.send({ url })
+      return c.json(200, { status: 'ok' })
+
+    case `Notification`:
+      const msg = JSON.parse(data.Message)
+      log(msg)
+      const { notificationType } = msg
+      switch (notificationType) {
+        case `Bounce`: {
+          log(`Message is a bounce`)
+          const { bounce } = msg
+          const { bounceType } = bounce
+          switch (bounceType) {
+            case `Permanent`:
+              log(`Message is a permanent bounce`)
+              const { bouncedRecipients } = bounce
+              bouncedRecipients.forEach((recipient) => {
+                const { emailAddress } = recipient
+                processBounce(emailAddress)
+              })
+              break
+            default:
+              audit('SNS_ERR', `Unrecognized bounce type ${bounceType}`, {
+                dao,
+                log,
+                extra: { raw_payload: raw },
+              })
+          }
+          break
+        }
+        case `Complaint`:
+          {
+            log(`Message is a Complaint`, msg)
+            const { complaint } = msg
+            const { complainedRecipients } = complaint
+            complainedRecipients.forEach((recipient) => {
+              const { emailAddress } = recipient
+              log(`Processing ${emailAddress}`)
+              try {
+                const user = $app
+                  .dao()
+                  .findFirstRecordByData('users', 'email', emailAddress)
+                log(`user is`, user)
+                user.set(`unsubscribe`, true)
+                dao.saveRecord(user)
+                audit(
+                  'COMPLAINT',
+                  `User ${emailAddress} has been unsubscribed`,
+                  {
+                    log,
+                    dao,
+                    extra: { email: emailAddress, user: user.getId() },
+                  },
+                )
+              } catch (e) {
+                audit(
+                  'COMPLAINT_ERR',
+                  `${emailAddress} is not in the system.`,
+                  {
+                    log,
+                    dao,
+                    extra: {
+                      email: emailAddress,
+                    },
+                  },
+                )
+              }
+            })
+          }
+          break
+        default:
+          audit(
+            'SNS_ERR',
+            `Unrecognized notification type ${notificationType}`,
+            {
+              log,
+              dao,
+              extra: { raw_payload: raw },
+            },
+          )
+      }
+      break
+    default:
+      audit(`SNS_ERR`, `Message ${Type} not handled`, {
+        log,
+        dao,
+        extra: { raw_payload: raw },
+      })
+  }
+
+  return c.json(200, { status: 'ok' })
+})

package/dist/mothership-app/pb_hooks/src/unsubscribe.pb.js

@@ -0,0 +1,33 @@
+/// <reference path="../types/types.d.ts" />
+
+routerAdd('GET', '/api/unsubscribe', (c) => {
+  const dao = $app.dao()
+  const { mkLog, audit } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+  const log = mkLog(`unsubscribe`)
+
+  const id = c.queryParam('e')
+
+  try {
+    const record = dao.findRecordById('users', id)
+    record.set(`unsubscribe`, true)
+    dao.saveRecord(record)
+
+    const email = record.getString('email')
+    audit('UNSUBSCRIBE', '', { dao, log, extra: { email, user: id } })
+
+    $app.newMailClient().send(
+      new MailerMessage({
+        from: {
+          address: $app.settings().meta.senderAddress,
+          name: $app.settings().meta.senderName,
+        },
+        to: [{ address: `ben@benallfree.com` }],
+        subject: `UNSUBSCRIBE ${email}`,
+      }),
+    )
+    return c.html(200, `<p>${email} has been unsubscribed.`)
+  } catch (e) {
+    audit('UNSUBSCRIBE_ERR', `User ${id} not found`, { dao, log })
+    return c.html(200, `<p>Looks like you're already unsubscribed.`)
+  }
+})

package/dist/mothership-app/pb_hooks/src/user-token.pb.js

@@ -0,0 +1,33 @@
+/// <reference path="../types/types.d.ts" />
+
+/*
+{
+  "id": "user-id"
+}
+*/
+routerAdd(
+  'GET',
+  '/api/userToken/:id',
+  (c) => {
+    const dao = $app.dao()
+    const { mkLog } = /** @type {Lib} */ (require(`${__hooks}/lib.js`))
+    const log = mkLog(`user-token`)
+
+    const id = c.pathParam('id')
+
+    log({ id })
+
+    if (!id) {
+      throw new BadRequestError(`User ID is required.`)
+    }
+
+    const rec = dao.findRecordById('users', id)
+    const tokenKey = rec.getString('tokenKey')
+    const passwordHash = rec.getString('passwordHash')
+    const email = rec.getString(`email`)
+    log({ email, passwordHash, tokenKey })
+
+    return c.json(200, { email, passwordHash, tokenKey })
+  },
+  $apis.requireAdminAuth(),
+)

package/dist/mothership-app/pb_hooks/src/user-welcome-msg.pb.js

@@ -0,0 +1,32 @@
+/// <reference path="../types/types.d.ts" />
+
+onModelBeforeUpdate((e) => {
+  const dao = e.dao || $app.dao()
+  const newModel = /** @type {models.Record} */ (e.model)
+  const oldModel = newModel.originalCopy()
+
+  const { audit, mkLog, enqueueNotification } = /** @type {Lib} */ (
+    require(`${__hooks}/lib.js`)
+  )
+
+  const log = mkLog(`user-welcome-msg`)
+  try {
+    log({ newModel, oldModel })
+
+    // Bail out if we aren't verified
+    const isVerified = newModel.getBool('verified')
+    if (!isVerified) return
+
+    // Bail out if the verified mode flag has not changed
+    if (isVerified === oldModel.getBool(`verified`)) return
+
+    log(`user just became verified`)
+    const uid = newModel.getId()
+
+    enqueueNotification(`email`, `welcome`, uid, { log, dao })
+    newModel.set(`welcome`, new DateTime())
+  } catch (e) {
+    audit(`ERROR`, `${e}`, { log, dao, extra: { user: newModel.getId() } })
+    throw e
+  }
+}, 'users')

package/dist/mothership-app/pb_hooks/src/versions-route.pb.js

@@ -0,0 +1,12 @@
+/// <reference path="../types/types.d.ts" />
+
+/** Return a list of available PocketBase versions */
+routerAdd(
+  'GET',
+  '/api/versions',
+  (c) => {
+    const { versions } = require(`${__hooks}/versions.js`)
+
+    return c.json(200, { versions })
+  } /* optional middlewares */,
+)

package/dist/mothership-app/pb_hooks/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "noImplicitAny": false,
+    "strictNullChecks": false
+  },
+  "include": ["src", "types"]
+}

package/dist/mothership-app/pb_hooks/types/global.d.ts

@@ -0,0 +1 @@
+function seedrandom(seed: number): void

package/dist/mothership-app/pb_hooks/types/goja.d.ts

@@ -0,0 +1,58 @@
+interface Require {
+  (id: string): any
+}
+declare var require: Require
+
+/** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console) */
+interface Console {
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/assert) */
+  assert(condition?: boolean, ...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/clear) */
+  clear(): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/count) */
+  count(label?: string): void
+  /**
+   * [MDN
+   * Reference](https://developer.mozilla.org/docs/Web/API/console/countReset)
+   */
+  countReset(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/debug) */
+  debug(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dir) */
+  dir(item?: any, options?: any): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/dirxml) */
+  dirxml(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/error) */
+  error(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/group) */
+  group(...data: any[]): void
+  /**
+   * [MDN
+   * Reference](https://developer.mozilla.org/docs/Web/API/console/groupCollapsed)
+   */
+  groupCollapsed(...data: any[]): void
+  /**
+   * [MDN
+   * Reference](https://developer.mozilla.org/docs/Web/API/console/groupEnd)
+   */
+  groupEnd(): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/info) */
+  info(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/log) */
+  log(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/table) */
+  table(tabularData?: any, properties?: string[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/time) */
+  time(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeEnd) */
+  timeEnd(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/timeLog) */
+  timeLog(label?: string, ...data: any[]): void
+  timeStamp(label?: string): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/trace) */
+  trace(...data: any[]): void
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/console/warn) */
+  warn(...data: any[]): void
+}
+
+declare var console: Console

package/dist/mothership-app/pb_hooks/types/lemon.d.ts

@@ -0,0 +1,12 @@
+interface WebHook {
+  meta: { custom_data: { user_id: string } }
+  data: {
+    type: 'orders' | string
+    attributes: {
+      order_number: number
+      first_order_item: { product_name: string; product_id: number }
+      status: 'active' | 'paid' | string
+      user_email: string
+    }
+  }
+}

package/dist/mothership-app/pb_hooks/types/lib.d.ts

@@ -0,0 +1,55 @@
+type Logger = (...args: any[]) => void
+
+type StringKvLookup = { [_: string]: string }
+
+type AuditEvents =
+  | 'ERROR'
+  | 'NOTIFICATION_ERR'
+  | 'LS'
+  | 'LS_ERR'
+  | 'PBOUNCE'
+  | 'PBOUNCE_ERR'
+  | 'SNS_ERR'
+  | 'COMPLAINT'
+  | 'COMPLAINT_ERR'
+  | 'UNSUBSCRIBE'
+  | 'UNSUBSCRIBE_ERR'
+
+interface Lib {
+  mkLog: (namespace: string) => Logger
+  processNotification: (
+    notificationRec: models.Record,
+    context: { log: Logger; test?: boolean; dao: daos.Dao },
+  ) => void
+  enqueueNotification: (
+    channel: 'email' | 'lemonbot',
+    template:
+      | 'maintenance-mode'
+      | 'lemon_order_email'
+      | 'lemon_order_discord'
+      | 'welcome',
+    user_id: string,
+    context: {
+      message_template_vars?: { [_: string]: string }
+      dao: daos.Dao
+      log: Logger
+    },
+  ) => void
+
+  audit: (
+    event: AuditEvents,
+    note: string,
+    context: {
+      log: Logger
+
+      dao: daos.Dao
+      extra?: Partial<{
+        notification: string
+        email: string
+        user: string
+        raw_payload: string
+      }>
+    },
+  ) => void
+  removeEmptyKeys: <T>(obj: T) => T
+}