stacks 0.56.24 → 0.58.18

package/core/src/email/email-forwarder.cjs

@@ -0,0 +1,406 @@
+/* eslint-disable */
+'use strict'
+
+const { CopyObjectCommand, GetObjectCommand, S3Client } = require('@aws-sdk/client-s3')
+const { SendEmailCommand, SESv2Client } = require('@aws-sdk/client-sesv2')
+
+// Configure the S3 bucket and key prefix for stored raw emails, and the
+// mapping of email addresses to forward from and to.
+//
+// Expected keys/values:
+//
+// - fromEmail: Forwarded emails will come from this verified address
+//
+// - subjectPrefix: Forwarded emails subject will contain this prefix
+//
+// - emailBucket: S3 bucket name where SES stores emails.
+//
+// - emailKeyPrefix: S3 key name prefix where SES stores email. Include the
+//   trailing slash.
+//
+// - allowPlusSign: Enables support for plus sign suffixes on email addresses.
+//   If set to `true`, the username/mailbox part of an email address is parsed
+//   to remove anything after a plus sign. For example, an email sent to
+//   `example+test@example.com` would be treated as if it was sent to
+//   `example@example.com`.
+//
+// - forwardMapping: Object where the key is the lowercase email address from
+//   which to forward and the value is an array of email addresses to which to
+//   send the message.
+//
+//   To match all email addresses on a domain, use a key without the name part
+//   of an email address before the "at" symbol (i.e. `@example.com`).
+//
+//   To match a mailbox name on all domains, use a key without the "at" symbol
+//   and domain part of an email address (i.e. `info`).
+//
+//   To match all email addresses matching no other mapping, use "@" as a key.
+const defaultConfig = {
+  fromEmail: 'noreply@stacksjs.com',
+  subjectPrefix: '',
+  emailBucket: 'stacksjs.com-email',
+  emailKeyPrefix: 'stacks/',
+  allowPlusSign: true,
+  forwardMapping: {
+    'hello@stacksjs.com': [
+      'chrisbreuer93@gmail.com',
+    ],
+    // 'abuse@example.com': [
+    //   'example.jim@example.com',
+    // ],
+    '@stacksjs.com': [
+      'chrisbreuer93@gmail.com',
+    ],
+    // 'info': [
+    //   'info@example.com',
+    // ],
+  },
+}
+
+/**
+ * Parses the SES event record provided for the `mail` and `recipients` data.
+ *
+ * @param {object} data - Data bundle with context, email, etc.
+ *
+ * @return {object} - Promise resolved with data.
+ */
+exports.parseEvent = function (data) {
+  // Validate characteristics of a SES event record.
+  if (!data.event
+      || !data.event.hasOwnProperty('Records')
+      || data.event.Records.length !== 1
+      || !data.event.Records[0].hasOwnProperty('eventSource')
+      || data.event.Records[0].eventSource !== 'aws:ses'
+      || data.event.Records[0].eventVersion !== '1.0') {
+    data.log({
+      message: 'parseEvent() received invalid SES message:',
+      level: 'error',
+      event: JSON.stringify(data.event),
+    })
+    return Promise.reject(new Error('Error: Received invalid SES message.'))
+  }
+
+  data.email = data.event.Records[0].ses.mail
+  data.recipients = data.event.Records[0].ses.receipt.recipients
+  return Promise.resolve(data)
+}
+
+/**
+ * Transforms the original recipients to the desired forwarded destinations.
+ *
+ * @param {object} data - Data bundle with context, email, etc.
+ *
+ * @return {object} - Promise resolved with data.
+ */
+exports.transformRecipients = function (data) {
+  let newRecipients = []
+  data.originalRecipients = data.recipients
+  data.recipients.forEach((origEmail) => {
+    let origEmailKey = origEmail.toLowerCase()
+    if (data.config.allowPlusSign)
+      origEmailKey = origEmailKey.replace(/\+.*?@/, '@')
+
+    if (data.config.forwardMapping.hasOwnProperty(origEmailKey)) {
+      newRecipients = newRecipients.concat(
+        data.config.forwardMapping[origEmailKey],
+      )
+      data.originalRecipient = origEmail
+    }
+    else {
+      let origEmailDomain
+      let origEmailUser
+      const pos = origEmailKey.lastIndexOf('@')
+      if (pos === -1) {
+        origEmailUser = origEmailKey
+      }
+      else {
+        origEmailDomain = origEmailKey.slice(pos)
+        origEmailUser = origEmailKey.slice(0, pos)
+      }
+      if (origEmailDomain
+          && data.config.forwardMapping.hasOwnProperty(origEmailDomain)) {
+        newRecipients = newRecipients.concat(
+          data.config.forwardMapping[origEmailDomain],
+        )
+        data.originalRecipient = origEmail
+      }
+      else if (origEmailUser
+        && data.config.forwardMapping.hasOwnProperty(origEmailUser)) {
+        newRecipients = newRecipients.concat(
+          data.config.forwardMapping[origEmailUser],
+        )
+        data.originalRecipient = origEmail
+      }
+      else if (data.config.forwardMapping.hasOwnProperty('@')) {
+        newRecipients = newRecipients.concat(
+          data.config.forwardMapping['@'],
+        )
+        data.originalRecipient = origEmail
+      }
+    }
+  })
+
+  if (!newRecipients.length) {
+    data.log({
+      message: 'Finishing process. No new recipients found for '
+        + `original destinations: ${data.originalRecipients.join(', ')}`,
+      level: 'info',
+    })
+    return data.callback()
+  }
+
+  data.recipients = newRecipients
+  return Promise.resolve(data)
+}
+
+/**
+ * Fetches the message data from S3.
+ *
+ * @param {object} data - Data bundle with context, email, etc.
+ *
+ * @return {object} - Promise resolved with data.
+ */
+exports.fetchMessage = function (data) {
+  // Copying email object to ensure read permission
+  data.log({
+    level: 'info',
+    message: `Fetching email at s3://${data.config.emailBucket}/${
+       data.config.emailKeyPrefix}${data.email.messageId}`,
+  })
+  return new Promise((resolve, reject) => {
+    data.s3.send(new CopyObjectCommand({
+      Bucket: data.config.emailBucket,
+      CopySource: `${data.config.emailBucket}/${data.config.emailKeyPrefix
+        }${data.email.messageId}`,
+      Key: data.config.emailKeyPrefix + data.email.messageId,
+      ACL: 'private',
+      ContentType: 'text/plain',
+      StorageClass: 'STANDARD',
+    }), (err) => {
+      if (err) {
+        data.log({
+          level: 'error',
+          message: 'copyObject() returned error:',
+          error: err,
+          stack: err.stack,
+        })
+        return reject(
+          new Error('Error: Could not make readable copy of email.'),
+        )
+      }
+
+      // Load the raw email from S3
+      data.s3.send(new GetObjectCommand({
+        Bucket: data.config.emailBucket,
+        Key: data.config.emailKeyPrefix + data.email.messageId,
+      }), (err, result) => {
+        if (err) {
+          data.log({
+            level: 'error',
+            message: 'getObject() returned error:',
+            error: err,
+            stack: err.stack,
+          })
+          return reject(
+            new Error('Error: Failed to load message body from S3.'),
+          )
+        }
+        result.Body.transformToString().then(
+          (body) => {
+            data.emailData = body
+            resolve(data)
+          },
+        )
+      })
+    })
+  })
+}
+
+/**
+ * Processes the message data, making updates to recipients and other headers
+ * before forwarding message.
+ *
+ * @param {object} data - Data bundle with context, email, etc.
+ *
+ * @return {object} - Promise resolved with data.
+ */
+exports.processMessage = function (data) {
+  let match = data.emailData.match(/^((?:.+\r?\n)*)(\r?\n(?:.*\s+)*)/m)
+  let header = match && match[1] ? match[1] : data.emailData
+  const body = match && match[2] ? match[2] : ''
+
+  // Add "Reply-To:" with the "From" address if it doesn't already exists
+  if (!/^reply-to:[\t ]?/mi.test(header)) {
+    match = header.match(/^from:[\t ]?(.*(?:\r?\n\s+.*)*\r?\n)/mi)
+    const from = match && match[1] ? match[1] : ''
+    if (from) {
+      header = `${header}Reply-To: ${from}`
+      data.log({
+        level: 'info',
+        message: `Added Reply-To address of: ${from}`,
+      })
+    }
+    else {
+      data.log({
+        level: 'info',
+        message: 'Reply-To address not added because From address was not '
+          + 'properly extracted.',
+      })
+    }
+  }
+
+  // SES does not allow sending messages from an unverified address,
+  // so replace the message's "From:" header with the original
+  // recipient (which is a verified domain)
+  header = header.replace(
+    /^from:[\t ]?(.*(?:\r?\n\s+.*)*)/mgi,
+    (match, from) => {
+      let fromText
+      if (data.config.fromEmail) {
+        fromText = `From: ${from.replace(/<(.*)>/, '').trim()
+        } <${data.config.fromEmail}>`
+      }
+      else {
+        fromText = `From: ${from.replace('<', 'at ').replace('>', '')
+        } <${data.originalRecipient}>`
+      }
+      return fromText
+    },
+  )
+
+  // Add a prefix to the Subject
+  if (data.config.subjectPrefix) {
+    header = header.replace(
+      /^subject:[\t ]?(.*)/mgi,
+      (match, subject) => {
+        return `Subject: ${data.config.subjectPrefix}${subject}`
+      },
+    )
+  }
+
+  // Replace original 'To' header with a manually defined one
+  if (data.config.toEmail)
+    header = header.replace(/^to:[\t ]?(.*)/mgi, () => `To: ${data.config.toEmail}`)
+
+  // Remove the Return-Path header.
+  header = header.replace(/^return-path:[\t ]?(.*)\r?\n/mgi, '')
+
+  // Remove Sender header.
+  header = header.replace(/^sender:[\t ]?(.*)\r?\n/mgi, '')
+
+  // Remove Message-ID header.
+  header = header.replace(/^message-id:[\t ]?(.*)\r?\n/mgi, '')
+
+  // Remove all DKIM-Signature headers to prevent triggering an
+  // "InvalidParameterValue: Duplicate header 'DKIM-Signature'" error.
+  // These signatures will likely be invalid anyways, since the From
+  // header was modified.
+  header = header.replace(/^dkim-signature:[\t ]?.*\r?\n(\s+.*\r?\n)*/mgi, '')
+
+  data.emailData = header + body
+  return Promise.resolve(data)
+}
+
+/**
+ * Send email using the SES sendRawEmail command.
+ *
+ * @param {object} data - Data bundle with context, email, etc.
+ *
+ * @return {object} - Promise resolved with data.
+ */
+exports.sendMessage = function (data) {
+  data.log({
+    level: 'info',
+    message: `sendMessage: Sending email via SES. Original recipients: ${
+       data.originalRecipients.join(', ')}. Transformed recipients: ${
+       data.recipients.join(', ')}.`,
+  })
+  return new Promise((resolve, reject) => {
+    data.ses.send(new SendEmailCommand({
+      Content: {
+        Raw: {
+          Data: Buffer.from(data.emailData),
+        },
+      },
+    }), (err, result) => {
+      if (err) {
+        data.log({
+          level: 'error',
+          message: 'sendRawEmail() returned error.',
+          error: err,
+          stack: err.stack,
+        })
+        return reject(new Error('Error: Email sending failed.'))
+      }
+      data.log({
+        level: 'info',
+        message: 'sendRawEmail() successful.',
+        result,
+      })
+      resolve(data)
+    })
+  })
+}
+
+/**
+ * Handler function to be invoked by AWS Lambda with an inbound SES email as
+ * the event.
+ *
+ * @param {object} event - Lambda event from inbound email received by AWS SES.
+ * @param {object} context - Lambda context object.
+ * @param {object} callback - Lambda callback object.
+ * @param {object} overrides - Overrides for the default data, including the
+ * configuration, SES object, and S3 object.
+ */
+exports.handler = function (event, context, callback, overrides) {
+  console.log('AWS Lambda SES Forwarder')
+
+  const steps = overrides && overrides.steps
+    ? overrides.steps
+    : [
+        exports.parseEvent,
+        exports.transformRecipients,
+        exports.fetchMessage,
+        exports.processMessage,
+        exports.sendMessage,
+      ]
+  const data = {
+    event,
+    callback,
+    context,
+    config: overrides && overrides.config ? overrides.config : defaultConfig,
+    log: overrides && overrides.log ? overrides.log : console.log,
+    ses: overrides && overrides.ses ? overrides.ses : new SESv2Client(),
+    s3: overrides && overrides.s3
+      ? overrides.s3
+      : new S3Client({ signatureVersion: 'v4' }),
+  }
+  Promise.series(steps, data)
+    .then((data) => {
+      data.log({
+        level: 'info',
+        message: 'Process finished successfully.',
+      })
+      return data.callback()
+    })
+    .catch((err) => {
+      data.log({
+        level: 'error',
+        message: `Step returned error: ${err.message}`,
+        error: err,
+        stack: err.stack,
+      })
+      return data.callback(new Error('Error: Step returned error.'))
+    })
+}
+
+Promise.series = function (promises, initValue) {
+  return promises.reduce((chain, promise) => {
+    if (typeof promise !== 'function') {
+      return chain.then(() => {
+        throw new Error(`Error: Invalid promise item: ${promise}`)
+      })
+    }
+    return chain.then(promise)
+  }, Promise.resolve(initValue))
+}

package/core/src/email/package.json

@@ -0,0 +1,94 @@
+{
+  "name": "@stacksjs/email",
+  "type": "module",
+  "version": "0.58.18",
+  "description": "The Stacks Email integration. Painlessly create & manage your inboxes, templates, and send emails.",
+  "author": "Chris Breuer",
+  "license": "MIT",
+  "funding": "https://github.com/sponsors/chrisbbreuer",
+  "homepage": "https://github.com/stacksjs/stacks/tree/main/storage/framework/core/src/email#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/stacksjs/stacks.git",
+    "directory": "./storage/framework/core/src/email"
+  },
+  "bugs": {
+    "url": "https://github.com/stacksjs/stacks/issues"
+  },
+  "keywords": [
+    "email",
+    "ses",
+    "aws",
+    "maizzle",
+    "stacks",
+    "emailjs",
+    "mailgun",
+    "mailjet",
+    "mandrill",
+    "netcore",
+    "nodemailer",
+    "postmark",
+    "sendgrid"
+  ],
+  "exports": {
+    ".": {
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
+    },
+    "./*": {
+      "bun": "./src/*",
+      "import": "./dist/*"
+    }
+  },
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "contributors": [
+    "Chris Breuer <chris@stacksjs.org>"
+  ],
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "scripts": {
+    "build": "bun --bun build.ts",
+    "build:inbound": "bun --bun build-inbound.ts",
+    "typecheck": "bun --bun tsc --noEmit",
+    "prepublishOnly": "bun --bun run build"
+  },
+  "peerDependencies": {
+    "@maizzle/framework": "^4.6.5",
+    "@stacksjs/cli": "workspace:*",
+    "@stacksjs/config": "workspace:*",
+    "@stacksjs/error-handling": "workspace:*",
+    "@stacksjs/types": "workspace:*"
+  },
+  "dependencies": {
+    "@maizzle/framework": "^4.6.5",
+    "@novu/stateless": "^0.22.0",
+    "@stacksjs/cli": "workspace:*",
+    "@stacksjs/config": "workspace:*",
+    "@stacksjs/error-handling": "workspace:*",
+    "@stacksjs/types": "workspace:*",
+    "@types/mailparser": "^3.4.4",
+    "mailparser": "^3.6.6",
+    "mime": "^4.0.1",
+    "moment": "^2.30.1",
+    "nodemailer": "^6.9.8",
+    "uuid": "^9.0.1"
+  },
+  "optionalDependencies": {
+    "@novu/emailjs": "^0.22.0",
+    "@novu/mailgun": "^0.22.0",
+    "@novu/mailjet": "^0.22.0",
+    "@novu/mandrill": "^0.22.0",
+    "@novu/netcore": "^0.22.0",
+    "@novu/node": "^0.22.0",
+    "@novu/nodemailer": "^0.22.0",
+    "@novu/postmark": "^0.22.0",
+    "@novu/sendgrid": "^0.22.0",
+    "@novu/ses": "^0.22.0"
+  },
+  "devDependencies": {
+    "@stacksjs/development": "workspace:*"
+  }
+}

package/core/src/email/src/drivers/emailjs.ts

@@ -0,0 +1,23 @@
+import { EmailJsProvider } from '@novu/emailjs'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.emailjs
+
+const provider = new EmailJsProvider({
+  from: env?.from.address || '',
+  host: service?.host || '',
+  user: service?.user,
+  password: service?.password,
+  port: service?.port || 587,
+  secure: service?.secure,
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, provider, 'EmailJS', css)
+}
+
+export { send as Send, send }

package/core/src/email/src/drivers/index.ts

@@ -0,0 +1,9 @@
+export * as sendgrid from './sendgrid'
+export * as mailgun from './mailgun'
+export * as mailjet from './mailjet'
+export * as mandrill from './mandrill'
+export * as netcore from './netcore'
+export * as nodemailer from './nodemailer'
+export * as postmark from './postmark'
+export * as ses from './ses'
+export * as emailjs from './emailjs'

package/core/src/email/src/drivers/mailgun.ts

@@ -0,0 +1,21 @@
+import { MailgunEmailProvider } from '@novu/mailgun'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.mailgun
+
+const provider = new MailgunEmailProvider({
+  apiKey: service?.key || '',
+  domain: service?.domain || '',
+  username: service?.username || '',
+  from: env?.from.address || '',
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, provider, 'Mailgun', css)
+}
+
+export { send as Send, send }

package/core/src/email/src/drivers/mailjet.ts

@@ -0,0 +1,21 @@
+import { MailjetEmailProvider } from '@novu/mailjet'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.mailjet
+
+const provider = new MailjetEmailProvider({
+  apiKey: service?.key || '',
+  apiSecret: service?.secret || '',
+  from: env?.from.address || '',
+  senderName: env?.from.name || '', // look into what exactly this stands for
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, provider, 'Mailjet', css)
+}
+
+export { send as Send, send }

package/core/src/email/src/drivers/mandrill.ts

@@ -0,0 +1,19 @@
+// import { MandrillProvider } from '@novu/mandrill'
+// import type { EmailOptions } from '@stacksjs/types'
+// import { notification } from '@stacksjs/config'
+// import type { ResultAsync } from '@stacksjs/error-handling'
+// import { send as sendEmail } from '../actions/send'
+
+// const env = notification.email
+// const service = notification.email?.drivers.mandrill
+
+// const provider = new MandrillProvider({
+//   apiKey: service?.key || '',
+//   from: env?.from.address || '',
+// })
+
+// async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+//   return sendEmail(options, provider, 'Mandrill', css)
+// }
+
+// export { send as Send, send }

package/core/src/email/src/drivers/netcore.ts

@@ -0,0 +1,19 @@
+import { NetCoreProvider } from '@novu/netcore'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.netcore
+
+const provider = new NetCoreProvider({
+  apiKey: service?.key || '',
+  from: env?.from.address || '',
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, provider, 'Netcore', css)
+}
+
+export { send as Send, send }

package/core/src/email/src/drivers/nodemailer.ts

@@ -0,0 +1,23 @@
+import { NodemailerProvider } from '@novu/nodemailer'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.nodemailer
+
+const provider = new NodemailerProvider({
+  from: env?.from.address || '',
+  host: service?.host || '',
+  user: service?.user,
+  password: service?.password,
+  port: service?.port || 587,
+  secure: service?.secure,
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, provider, 'Nodemailer', css)
+}
+
+export { send as Send, send }

package/core/src/email/src/drivers/postmark.ts

@@ -0,0 +1,19 @@
+import { PostmarkEmailProvider } from '@novu/postmark'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.postmark
+
+const provider = new PostmarkEmailProvider({
+  apiKey: service?.key || '',
+  from: env?.from.address || '',
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, provider, 'Postmark', css)
+}
+
+export { send as Send, send }

package/core/src/email/src/drivers/sendgrid.ts

@@ -0,0 +1,20 @@
+import { SendgridEmailProvider } from '@novu/sendgrid'
+import type { EmailOptions } from '@stacksjs/types'
+import type { ResultAsync } from '@stacksjs/error-handling'
+import { notification } from '@stacksjs/config'
+import { send as sendEmail } from '../send'
+
+const env = notification.email
+const service = notification.email?.drivers.sendgrid
+
+const driver = new SendgridEmailProvider({
+  apiKey: service?.key || '',
+  from: env?.from.address || '',
+  senderName: service?.senderName || '',
+})
+
+async function send(options: EmailOptions, css?: string): Promise<ResultAsync<any, Error>> {
+  return sendEmail(options, driver, 'Sendgrid', css)
+}
+
+export { send as Send, send }