@flink-app/email-plugin 2.0.0-alpha.92 → 2.0.0-alpha.93

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # @flink-app/email-plugin
 
+## 2.0.0-alpha.93
+
+### Minor Changes
+
+-   64ae56f: feat(email-plugin): add Postmark provider
+
+    Add `postmarkClient` alongside the existing SMTP, SendGrid, AWS SES, and Flowmailer clients. Construct it with `{ serverToken, defaultMessageStream? }` and pass it as the `client` option to `emailPlugin`. Supports html/text bodies, cc/bcc, reply-to, attachments, message streams, tags, and metadata.
+
+### Patch Changes
+
+-   @flink-app/flink@2.0.0-alpha.93
+
 ## 2.0.0-alpha.92
 
 ### Patch Changes

package/dist/index.d.ts

@@ -4,8 +4,10 @@ export { sendgridClient } from "./sendgridClient";
 export { smtpClient } from "./smtpClient";
 export { flowMailerClient } from "./flowmailerClient";
 export { sesClient } from "./sesClient";
+export { postmarkClient } from "./postmarkClient";
 export type { email } from "./schemas/email";
 export type { emailSes } from "./schemas/emailSes";
+export type { emailPostmark, PostmarkAttachment } from "./schemas/emailPostmark";
 export * from "./ses-types";
 export type emailPluginOptions = {
     /**

package/dist/index.js

@@ -14,7 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.emailPlugin = exports.sesClient = exports.flowMailerClient = exports.smtpClient = exports.sendgridClient = void 0;
+exports.emailPlugin = exports.postmarkClient = exports.sesClient = exports.flowMailerClient = exports.smtpClient = exports.sendgridClient = void 0;
 var sendgridClient_1 = require("./sendgridClient");
 Object.defineProperty(exports, "sendgridClient", { enumerable: true, get: function () { return sendgridClient_1.sendgridClient; } });
 var smtpClient_1 = require("./smtpClient");
@@ -23,6 +23,8 @@ var flowmailerClient_1 = require("./flowmailerClient");
 Object.defineProperty(exports, "flowMailerClient", { enumerable: true, get: function () { return flowmailerClient_1.flowMailerClient; } });
 var sesClient_1 = require("./sesClient");
 Object.defineProperty(exports, "sesClient", { enumerable: true, get: function () { return sesClient_1.sesClient; } });
+var postmarkClient_1 = require("./postmarkClient");
+Object.defineProperty(exports, "postmarkClient", { enumerable: true, get: function () { return postmarkClient_1.postmarkClient; } });
 __exportStar(require("./ses-types"), exports);
 var emailPlugin = function (options) {
     return {

package/dist/postmarkClient.d.ts

@@ -0,0 +1,19 @@
+import { ServerClient } from "postmark";
+import { emailPostmark as email } from "./schemas/emailPostmark";
+import { client } from "./schemas/client";
+export interface postmarkClientOptions {
+    /**
+     * Postmark server token
+     */
+    serverToken: string;
+    /**
+     * Default Postmark message stream, defaults to "outbound"
+     */
+    defaultMessageStream?: string;
+}
+export declare class postmarkClient implements client {
+    postmark: ServerClient;
+    defaultMessageStream: string;
+    constructor(options: postmarkClientOptions);
+    send(email: email): Promise<boolean>;
+}

package/dist/postmarkClient.js

@@ -0,0 +1,91 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.postmarkClient = void 0;
+var postmark_1 = require("postmark");
+var postmarkClient = /** @class */ (function () {
+    function postmarkClient(options) {
+        var _a;
+        this.postmark = new postmark_1.ServerClient(options.serverToken);
+        this.defaultMessageStream = (_a = options.defaultMessageStream) !== null && _a !== void 0 ? _a : "outbound";
+    }
+    postmarkClient.prototype.send = function (email) {
+        return __awaiter(this, void 0, void 0, function () {
+            var ex_1;
+            var _a, _b, _c, _d;
+            return __generator(this, function (_e) {
+                switch (_e.label) {
+                    case 0:
+                        _e.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, this.postmark.sendEmail({
+                                From: email.from,
+                                To: email.to.join(","),
+                                Cc: (_a = email.cc) === null || _a === void 0 ? void 0 : _a.join(","),
+                                Bcc: (_b = email.bcc) === null || _b === void 0 ? void 0 : _b.join(","),
+                                ReplyTo: email.replyTo,
+                                Subject: email.subject,
+                                HtmlBody: "html" in email ? email.html : undefined,
+                                TextBody: "text" in email ? email.text : undefined,
+                                MessageStream: (_c = email.messageStream) !== null && _c !== void 0 ? _c : this.defaultMessageStream,
+                                Tag: email.tag,
+                                Metadata: email.metadata,
+                                Attachments: (_d = email.attachments) === null || _d === void 0 ? void 0 : _d.map(function (a) {
+                                    var _a, _b;
+                                    return ({
+                                        Name: a.filename,
+                                        Content: a.content,
+                                        ContentType: (_a = a.contentType) !== null && _a !== void 0 ? _a : "application/octet-stream",
+                                        ContentID: (_b = a.contentId) !== null && _b !== void 0 ? _b : "",
+                                    });
+                                }),
+                            })];
+                    case 1:
+                        _e.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        ex_1 = _e.sent();
+                        console.log(JSON.stringify(ex_1));
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/, true];
+                }
+            });
+        });
+    };
+    return postmarkClient;
+}());
+exports.postmarkClient = postmarkClient;

package/dist/schemas/client.d.ts

@@ -1,7 +1,8 @@
 import { email } from "./email";
 import { emailFlowmailer } from "./emailFlowmailer";
+import { emailPostmark } from "./emailPostmark";
 import { emailSendgrid } from "./emailSendgrid";
 import { emailSes } from "./emailSes";
 export interface client {
-    send(email: email | emailSendgrid | emailFlowmailer | emailSes): Promise<boolean>;
+    send(email: email | emailSendgrid | emailFlowmailer | emailSes | emailPostmark): Promise<boolean>;
 }

package/dist/schemas/emailPostmark.d.ts

@@ -0,0 +1,67 @@
+export type emailPostmark = {
+    /**
+     * From address used to send the email
+     */
+    from: string;
+    /**
+     * Email addresses to send to
+     */
+    to: string[];
+    /**
+     * Reply-to address
+     */
+    replyTo?: string;
+    /**
+     * CC addresses
+     */
+    cc?: string[];
+    /**
+     * BCC addresses
+     */
+    bcc?: string[];
+    /**
+     * Subject of email
+     */
+    subject: string;
+    /**
+     * Postmark message stream id, defaults to "outbound"
+     */
+    messageStream?: string;
+    /**
+     * Postmark tag for categorization
+     */
+    tag?: string;
+    /**
+     * Custom metadata sent along with the email
+     */
+    metadata?: Record<string, string>;
+    /**
+     * File attachments
+     */
+    attachments?: PostmarkAttachment[];
+} & ({
+    text: string;
+} | {
+    html: string;
+} | {
+    text: string;
+    html: string;
+});
+export interface PostmarkAttachment {
+    /**
+     * Base64 encoded content
+     */
+    content: string;
+    /**
+     * Filename shown to recipient
+     */
+    filename: string;
+    /**
+     * MIME content type (e.g. "application/pdf"). Defaults to "application/octet-stream"
+     */
+    contentType?: string;
+    /**
+     * Content-ID for inline attachments, e.g. "cid:image1"
+     */
+    contentId?: string;
+}

package/dist/schemas/emailPostmark.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@flink-app/email-plugin",
-  "version": "2.0.0-alpha.92",
-  "description": "Flink plugin that provides multi-provider email sending capabilities with support for SendGrid, SMTP, Flowmailer, and AWS SES",
+  "version": "2.0.0-alpha.93",
+  "description": "Flink plugin that provides multi-provider email sending capabilities with support for SendGrid, SMTP, Flowmailer, AWS SES, and Postmark",
   "author": "johan@frost.se",
   "publishConfig": {
     "access": "public"
@@ -15,16 +15,17 @@
     "@types/nodemailer": "^6.4.4",
     "axios": "^0.27.2",
     "nodemailer": "^6.6.2",
+    "postmark": "^4.0.7",
     "querystring": "^0.2.1"
   },
   "devDependencies": {
     "@types/jasmine": "^3.7.1",
     "@types/node": "22.13.10",
-    "@flink-app/flink": "2.0.0-alpha.92"
+    "@flink-app/flink": "2.0.0-alpha.93"
   },
   "gitHead": "4243e3b3cd6d4e1ca001a61baa8436bf2bbe4113",
   "peerDependencies": {
-    "@flink-app/flink": ">=2.0.0-alpha.92"
+    "@flink-app/flink": ">=2.0.0-alpha.93"
   },
   "scripts": {
     "test": "jasmine-ts --config=./spec/support/jasmine.json",

package/readme.md

@@ -1,6 +1,6 @@
 # Email Plugin
 
-A Flink plugin that provides multi-provider email sending capabilities with support for SendGrid, SMTP, Flowmailer, and AWS SES.
+A Flink plugin that provides multi-provider email sending capabilities with support for SendGrid, SMTP, Flowmailer, AWS SES, and Postmark.
 
 ## Installation
 
@@ -12,7 +12,7 @@ npm install @flink-app/email-plugin
 
 ## Configuration
 
-The email plugin supports four different email providers through a unified client interface:
+The email plugin supports five different email providers through a unified client interface:
 
 ### Option 1: SendGrid
 
@@ -162,6 +162,61 @@ Credentials are resolved in this order:
 3. IAM instance profile / ECS task role
 4. AWS SSO / credential file
 
+### Option 5: Postmark
+
+Configure the plugin with [Postmark](https://postmarkapp.com/):
+
+```typescript
+import { emailPlugin, postmarkClient } from "@flink-app/email-plugin";
+
+function start() {
+  new FlinkApp<AppContext>({
+    name: "My app",
+    plugins: [
+      emailPlugin({
+        client: new postmarkClient({
+          serverToken: process.env.POSTMARK_SERVER_TOKEN!,
+          defaultMessageStream: "outbound", // optional
+        })
+      })
+    ],
+  }).start();
+}
+```
+
+**Postmark Client Options:**
+
+```typescript
+interface postmarkClientOptions {
+  serverToken: string;             // Postmark server token
+  defaultMessageStream?: string;   // Defaults to "outbound"
+}
+```
+
+**Postmark Email Type:**
+
+```typescript
+type emailPostmark = {
+  from: string;
+  to: string[];
+  replyTo?: string;
+  cc?: string[];
+  bcc?: string[];
+  subject: string;
+  messageStream?: string;            // Overrides defaultMessageStream
+  tag?: string;                      // Postmark tag for categorization
+  metadata?: Record<string, string>; // Custom metadata
+  attachments?: PostmarkAttachment[];
+} & ({ text: string } | { html: string } | { text: string; html: string });
+
+interface PostmarkAttachment {
+  content: string;       // Base64 encoded
+  filename: string;
+  contentType?: string;  // Defaults to "application/octet-stream"
+  contentId?: string;    // For inline images, e.g. "cid:image1"
+}
+```
+
 ## TypeScript Setup
 
 Add the plugin context to your app's context type (usually in `Ctx.ts`):
@@ -350,7 +405,7 @@ All email clients implement this unified interface:
 
 ```typescript
 interface client {
-  send(email: email | emailSendgrid | emailFlowmailer | emailSes): Promise<boolean>;
+  send(email: email | emailSendgrid | emailFlowmailer | emailSes | emailPostmark): Promise<boolean>;
 }
 ```
 
@@ -602,4 +657,5 @@ aws sesv2 create-configuration-set --configuration-set-name my-tracking-set --re
 - Flowmailer automatically handles OAuth token refresh
 - SendGrid attachments must be base64 encoded
 - SMTP client uses nodemailer internally
+- Postmark attachments must be base64 encoded; supports `messageStream`, `tag`, and `metadata` Postmark-specific fields
 - Multiple recipients are supported by all clients

package/src/index.ts

@@ -4,8 +4,10 @@ export { sendgridClient } from "./sendgridClient";
 export { smtpClient } from "./smtpClient";
 export { flowMailerClient } from "./flowmailerClient";
 export { sesClient } from "./sesClient";
+export { postmarkClient } from "./postmarkClient";
 export type { email } from "./schemas/email";
 export type { emailSes } from "./schemas/emailSes";
+export type { emailPostmark, PostmarkAttachment } from "./schemas/emailPostmark";
 export * from "./ses-types";
 
 export type emailPluginOptions = {

package/src/postmarkClient.ts

@@ -0,0 +1,53 @@
+import { ServerClient } from "postmark";
+import { emailPostmark as email } from "./schemas/emailPostmark";
+import { client } from "./schemas/client";
+
+export interface postmarkClientOptions {
+  /**
+   * Postmark server token
+   */
+  serverToken: string;
+
+  /**
+   * Default Postmark message stream, defaults to "outbound"
+   */
+  defaultMessageStream?: string;
+}
+
+export class postmarkClient implements client {
+  postmark: ServerClient;
+  defaultMessageStream: string;
+
+  constructor(options: postmarkClientOptions) {
+    this.postmark = new ServerClient(options.serverToken);
+    this.defaultMessageStream = options.defaultMessageStream ?? "outbound";
+  }
+
+  async send(email: email) {
+    try {
+      await this.postmark.sendEmail({
+        From: email.from,
+        To: email.to.join(","),
+        Cc: email.cc?.join(","),
+        Bcc: email.bcc?.join(","),
+        ReplyTo: email.replyTo,
+        Subject: email.subject,
+        HtmlBody: "html" in email ? email.html : undefined,
+        TextBody: "text" in email ? email.text : undefined,
+        MessageStream: email.messageStream ?? this.defaultMessageStream,
+        Tag: email.tag,
+        Metadata: email.metadata,
+        Attachments: email.attachments?.map(a => ({
+          Name: a.filename,
+          Content: a.content,
+          ContentType: a.contentType ?? "application/octet-stream",
+          ContentID: a.contentId ?? "",
+        })),
+      });
+    } catch (ex) {
+      console.log(JSON.stringify(ex));
+      return false;
+    }
+    return true;
+  }
+}

package/src/schemas/client.ts

@@ -1,8 +1,9 @@
 import { email } from "./email";
 import { emailFlowmailer } from "./emailFlowmailer";
+import { emailPostmark } from "./emailPostmark";
 import { emailSendgrid } from "./emailSendgrid";
 import { emailSes } from "./emailSes";
 
 export interface client {
-  send(email: email | emailSendgrid | emailFlowmailer | emailSes): Promise<boolean>;
+  send(email: email | emailSendgrid | emailFlowmailer | emailSes | emailPostmark): Promise<boolean>;
 }

package/src/schemas/emailPostmark.ts

@@ -0,0 +1,73 @@
+export type emailPostmark = {
+  /**
+   * From address used to send the email
+   */
+  from: string;
+
+  /**
+   * Email addresses to send to
+   */
+  to: string[];
+
+  /**
+   * Reply-to address
+   */
+  replyTo?: string;
+
+  /**
+   * CC addresses
+   */
+  cc?: string[];
+
+  /**
+   * BCC addresses
+   */
+  bcc?: string[];
+
+  /**
+   * Subject of email
+   */
+  subject: string;
+
+  /**
+   * Postmark message stream id, defaults to "outbound"
+   */
+  messageStream?: string;
+
+  /**
+   * Postmark tag for categorization
+   */
+  tag?: string;
+
+  /**
+   * Custom metadata sent along with the email
+   */
+  metadata?: Record<string, string>;
+
+  /**
+   * File attachments
+   */
+  attachments?: PostmarkAttachment[];
+} & ({ text: string } | { html: string } | { text: string; html: string });
+
+export interface PostmarkAttachment {
+  /**
+   * Base64 encoded content
+   */
+  content: string;
+
+  /**
+   * Filename shown to recipient
+   */
+  filename: string;
+
+  /**
+   * MIME content type (e.g. "application/pdf"). Defaults to "application/octet-stream"
+   */
+  contentType?: string;
+
+  /**
+   * Content-ID for inline attachments, e.g. "cid:image1"
+   */
+  contentId?: string;
+}