@cb4kas17/medusa-notification-postmark 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 const-code
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,348 @@
+# @const-code/medusa-notification-postmark
+
+A Postmark notification provider for Medusa v2. Supports sending emails using custom HTML (React Email, Handlebars, plain HTML) or Postmark's hosted templates.
+
+## Features
+
+- **Dual Mode** - Use custom HTML or Postmark's hosted templates
+- **Auto CID Conversion** - Automatically converts `data:image` URLs to email attachments
+- **Message Streams** - Supports transactional, broadcasts, and custom streams
+- **Full Postmark API** - Tracking, tags, metadata, and custom headers
+- **TypeScript** - Fully typed for type safety
+- **Zero Templates** - Bring your own templates or use Postmark's
+- **Framework Agnostic** - Works with any rendering engine
+
+## Installation
+
+```bash
+npm install @const-code/medusa-notification-postmark postmark
+```
+
+Or with yarn:
+
+```bash
+yarn add @const-code/medusa-notification-postmark postmark
+```
+
+## Quick Start
+
+### 1. Configure in `medusa-config.ts`
+
+```typescript
+import { defineConfig } from "@medusajs/framework/utils"
+
+export default defineConfig({
+  modules: [
+    {
+      resolve: "@const-code/medusa-notification-postmark",
+      options: {
+        serverToken: process.env.POSTMARK_SERVER_TOKEN,
+        from: "orders@yourstore.com",
+        messageStream: "outbound", // Optional
+        trackOpens: true, // Optional
+      },
+    },
+  ],
+})
+```
+
+### 2. Add Environment Variables
+
+```env
+POSTMARK_SERVER_TOKEN=your-server-token-here
+```
+
+### 3. Use in Subscribers
+
+**Option A: Custom HTML (React Email)**
+
+```typescript
+import { render } from "@react-email/components"
+import { OrderEmail } from "../emails/order"
+
+export default async function({ event, container }) {
+  const notificationService = container.resolve("notification")
+  const order = event.data
+  
+  // Render your template
+  const html = await render(<OrderEmail order={order} />)
+  
+  // Send via Postmark
+  await notificationService.createNotifications({
+    to: order.email,
+    channel: "email",
+    template: "order-placed",
+    data: {
+      subject: `Order #${order.display_id} Confirmed`,
+      html: html,
+    },
+  })
+}
+```
+
+**Option B: Postmark Templates**
+
+```typescript
+export default async function({ event, container }) {
+  const notificationService = container.resolve("notification")
+  const user = event.data
+  
+  // Use Postmark template from dashboard
+  await notificationService.createNotifications({
+    to: user.email,
+    channel: "email",
+    template: "welcome",
+    data: {
+      templateAlias: "welcome-email", // or templateId: 12345
+      templateModel: {
+        user_name: user.name,
+        login_url: "https://yourstore.com/login",
+      },
+    },
+  })
+}
+```
+
+## Configuration Options
+
+### Provider Options
+
+```typescript
+{
+  // Required
+  serverToken: string,  // Postmark API token
+  from: string,         // Default from address
+  
+  // Optional
+  messageStream?: string,        // Default: "outbound"
+  convertDataUrlsToCID?: boolean, // Auto-convert images (default: true)
+  trackOpens?: boolean,          // Track email opens
+  trackLinks?: "None" | "HtmlAndText" | "HtmlOnly" | "TextOnly"
+}
+```
+
+### Notification Data Options
+
+**For Custom HTML:**
+
+```typescript
+{
+  html: string,              // REQUIRED: Rendered HTML
+  subject: string,           // REQUIRED: Email subject
+  from?: string,             // Override default from
+  replyTo?: string,          // Reply-to address
+  cc?: string,               // CC recipients
+  bcc?: string,              // BCC recipients
+  tag?: string,              // Postmark tag
+  metadata?: object,         // Custom metadata
+  attachments?: Attachment[], // Manual attachments
+  trackOpens?: boolean,      // Override tracking
+  trackLinks?: string,       // Override tracking
+  messageStream?: string,    // Override stream
+  headers?: Array<{          // Custom headers
+    Name: string,
+    Value: string
+  }>,
+}
+```
+
+**For Postmark Templates:**
+
+```typescript
+{
+  templateId?: number,       // Template ID OR
+  templateAlias?: string,    // Template alias (pick one)
+  templateModel: object,     // Variables for template
+  
+  // Optional (same as above)
+  from?: string,
+  replyTo?: string,
+  cc?: string,
+  bcc?: string,
+  tag?: string,
+  metadata?: object,
+  attachments?: Attachment[],
+  trackOpens?: boolean,
+  trackLinks?: string,
+  messageStream?: string,
+  headers?: Array<{ Name: string, Value: string }>,
+}
+```
+
+## Examples
+
+### Example 1: QR Codes (Auto-converted to CID)
+
+```typescript
+import QRCode from "qrcode"
+
+const qrCode = await QRCode.toDataURL(ticketId)
+const html = await render(<TicketEmail qrCode={qrCode} />)
+
+// The provider automatically converts data:image to CID attachments
+await notificationService.createNotifications({
+  to: email,
+  channel: "email",
+  template: "ticket",
+  data: {
+    subject: "Your Ticket",
+    html: html,
+  },
+})
+```
+
+### Example 2: Message Streams
+
+```typescript
+// Transactional email
+await notificationService.createNotifications({
+  to: email,
+  channel: "email",
+  template: "receipt",
+  data: {
+    subject: "Your Receipt",
+    html: html,
+    messageStream: "outbound", // Default
+  },
+})
+
+// Marketing email
+await notificationService.createNotifications({
+  to: email,
+  channel: "email",
+  template: "newsletter",
+  data: {
+    subject: "Monthly Newsletter",
+    html: html,
+    messageStream: "broadcasts",
+  },
+})
+```
+
+### Example 3: Attachments
+
+```typescript
+await notificationService.createNotifications({
+  to: email,
+  channel: "email",
+  template: "invoice",
+  data: {
+    subject: "Your Invoice",
+    html: html,
+    attachments: [
+      {
+        Name: "invoice.pdf",
+        Content: "base64-content-here",
+        ContentType: "application/pdf",
+      },
+    ],
+  },
+})
+```
+
+### Example 4: Metadata & Tags
+
+```typescript
+await notificationService.createNotifications({
+  to: email,
+  channel: "email",
+  template: "order",
+  data: {
+    subject: "Order Confirmed",
+    html: html,
+    tag: "order-confirmation",
+    metadata: {
+      orderId: order.id,
+      customerId: customer.id,
+    },
+  },
+})
+```
+
+## Message Streams
+
+| Stream | Purpose | Example Use Cases |
+|--------|---------|-------------------|
+| `outbound` | Transactional emails (default) | Orders, receipts, password resets |
+| `broadcasts` | Marketing emails | Newsletters, promotions |
+| Custom | Any stream you create in Postmark | VIP customers, internal alerts |
+
+## TypeScript Support
+
+All TypeScript types are exported:
+
+```typescript
+import {
+  PostmarkOptions,
+  NotificationPayload,
+  Attachment,
+  convertDataUrlsToCID,
+} from "@const-code/medusa-notification-postmark"
+```
+
+## Utility Functions
+
+### convertDataUrlsToCID
+
+Manually convert data URLs to CID attachments:
+
+```typescript
+import { convertDataUrlsToCID } from "@const-code/medusa-notification-postmark"
+
+const html = `<img src="data:image/png;base64,..." />`
+const { html: finalHtml, attachments } = convertDataUrlsToCID(html)
+
+// Returns:
+// finalHtml: <img src="cid:image-0" />
+// attachments: [{ Name: "image-0.png", Content: "...", ContentID: "cid:image-0" }]
+```
+
+## When to Use Each Approach
+
+### Custom HTML
+
+- Full control over design
+- Version controlled with your code
+- TypeScript type safety
+- Dynamic logic in templates
+
+Best for: Order confirmations, receipts, password resets
+
+### Postmark Templates
+
+- Non-technical team can edit templates
+- A/B testing in Postmark dashboard
+- No deployment needed for updates
+- Multi-language support
+
+Best for: Marketing emails, newsletters, campaigns
+
+## FAQ
+
+**Q: Do I need to include templates in this package?**  
+A: No. This is a transport-only provider. Bring your own templates or use Postmark's hosted templates.
+
+**Q: Can I use both approaches in the same project?**  
+A: Yes. You can use custom HTML for transactional emails and Postmark templates for marketing emails.
+
+**Q: Are QR codes supported?**  
+A: Yes. Any `data:image` URL is automatically converted to CID attachments.
+
+**Q: Can I disable CID conversion?**  
+A: Yes. Set `convertDataUrlsToCID: false` in the provider options.
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions are welcome. Please open an issue or pull request on GitHub.
+
+## Links
+
+- [GitHub](https://github.com/const-code/medusa-notification-postmark)
+- [npm](https://www.npmjs.com/package/@const-code/medusa-notification-postmark)
+- [Postmark Documentation](https://postmarkapp.com/developer)
+- [Medusa Documentation](https://docs.medusajs.com)
+

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import PostmarkNotificationService from "./service";
+declare const _default: import("@medusajs/types").ModuleProviderExports;
+export default _default;
+export * from "./types";
+export * from "./utils";
+export { PostmarkNotificationService };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,2BAA2B,MAAM,WAAW,CAAA;;AAEnD,wBAEE;AAGF,cAAc,SAAS,CAAA;AACvB,cAAc,SAAS,CAAA;AACvB,OAAO,EAAE,2BAA2B,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostmarkNotificationService = void 0;
+const utils_1 = require("@medusajs/framework/utils");
+const service_1 = __importDefault(require("./service"));
+exports.PostmarkNotificationService = service_1.default;
+exports.default = (0, utils_1.ModuleProvider)(utils_1.Modules.NOTIFICATION, {
+    services: [service_1.default],
+});
+// Export types for users
+__exportStar(require("./types"), exports);
+__exportStar(require("./utils"), exports);

package/dist/service.d.ts

@@ -0,0 +1,39 @@
+import { AbstractNotificationProviderService } from "@medusajs/framework/utils";
+import { Logger } from "@medusajs/framework/types";
+import { ServerClient } from "postmark";
+import { PostmarkOptions, NotificationPayload } from "./types";
+export default class PostmarkNotificationService extends AbstractNotificationProviderService {
+    static identifier: string;
+    protected client: ServerClient;
+    protected options: PostmarkOptions;
+    protected logger: Logger;
+    constructor({ logger }: {
+        logger: Logger;
+    }, options: PostmarkOptions);
+    /**
+     * Send notification via Postmark
+     *
+     * Supports two modes:
+     * 1. Custom HTML - Pass `html` and `subject` in data
+     * 2. Postmark Template - Pass `templateId` or `templateAlias` in data
+     *
+     * @param notification - Notification payload from Medusa
+     * @returns Object with sent message ID
+     */
+    send(notification: NotificationPayload): Promise<{
+        id: string;
+    }>;
+    /**
+     * Send email with custom HTML
+     */
+    private sendWithHtml;
+    /**
+     * Send email using Postmark template
+     */
+    private sendWithTemplate;
+    /**
+     * Add optional fields to email options
+     */
+    private addOptionalFields;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mCAAmC,EAAE,MAAM,2BAA2B,CAAA;AAC/E,OAAO,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACvC,OAAO,EACL,eAAe,EACf,mBAAmB,EAIpB,MAAM,SAAS,CAAA;AAGhB,MAAM,CAAC,OAAO,OAAO,2BAA4B,SAAQ,mCAAmC;IAC1F,MAAM,CAAC,UAAU,SAAa;IAE9B,SAAS,CAAC,MAAM,EAAE,YAAY,CAAA;IAC9B,SAAS,CAAC,OAAO,EAAE,eAAe,CAAA;IAClC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAA;gBAGtB,EAAE,MAAM,EAAE,EAAE;QAAE,MAAM,EAAE,MAAM,CAAA;KAAE,EAC9B,OAAO,EAAE,eAAe;IAqB1B;;;;;;;;;OASG;IACG,IAAI,CAAC,YAAY,EAAE,mBAAmB,GAAG,OAAO,CAAC;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE,CAAC;IActE;;OAEG;YACW,YAAY;IA4D1B;;OAEG;YACW,gBAAgB;IAkD9B;;OAEG;IACH,OAAO,CAAC,iBAAiB;CAgC1B"}

package/dist/service.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@medusajs/framework/utils");
+const postmark_1 = require("postmark");
+const utils_2 = require("./utils");
+class PostmarkNotificationService extends utils_1.AbstractNotificationProviderService {
+    constructor({ logger }, options) {
+        super();
+        if (!options.serverToken) {
+            throw new Error("Postmark server token is required");
+        }
+        if (!options.from) {
+            throw new Error("From email address is required");
+        }
+        this.logger = logger;
+        this.options = {
+            messageStream: "outbound",
+            convertDataUrlsToCID: true,
+            ...options,
+        };
+        this.client = new postmark_1.ServerClient(options.serverToken);
+    }
+    /**
+     * Send notification via Postmark
+     *
+     * Supports two modes:
+     * 1. Custom HTML - Pass `html` and `subject` in data
+     * 2. Postmark Template - Pass `templateId` or `templateAlias` in data
+     *
+     * @param notification - Notification payload from Medusa
+     * @returns Object with sent message ID
+     */
+    async send(notification) {
+        const { to, data } = notification;
+        // Check if using Postmark templates or custom HTML
+        const templateId = data?.templateId;
+        const templateAlias = data?.templateAlias;
+        if (templateId || templateAlias) {
+            return this.sendWithTemplate(to, data);
+        }
+        else {
+            return this.sendWithHtml(to, data);
+        }
+    }
+    /**
+     * Send email with custom HTML
+     */
+    async sendWithHtml(to, data) {
+        const html = data?.html;
+        const subject = data?.subject;
+        const from = data?.from || this.options.from;
+        const replyTo = data?.replyTo;
+        const messageStream = data?.messageStream || this.options.messageStream;
+        if (!html) {
+            throw new Error("No HTML content provided. Pass 'html' in notification data or use 'templateId'/'templateAlias' for Postmark templates");
+        }
+        if (!subject) {
+            throw new Error("No subject provided. Pass 'subject' in notification data");
+        }
+        // Handle attachments (convert data URLs to CID if enabled)
+        let finalHtml = html;
+        let attachments = [];
+        if (this.options.convertDataUrlsToCID && html.includes('data:image')) {
+            const converted = (0, utils_2.convertDataUrlsToCID)(html, data?.attachments || []);
+            finalHtml = converted.html;
+            attachments = converted.attachments;
+        }
+        else if (data?.attachments) {
+            attachments = data.attachments;
+        }
+        // Build email options
+        const emailOptions = {
+            From: from,
+            To: to,
+            Subject: subject,
+            HtmlBody: finalHtml,
+            MessageStream: messageStream,
+        };
+        // Add optional fields
+        this.addOptionalFields(emailOptions, data, attachments);
+        try {
+            this.logger.debug(`Sending email via Postmark (custom HTML) to ${to}`);
+            const response = await this.client.sendEmail(emailOptions);
+            this.logger.info(`Email sent successfully via Postmark: ${response.MessageID}`);
+            return { id: response.MessageID };
+        }
+        catch (error) {
+            this.logger.error(`Failed to send email via Postmark: ${error?.message || "Unknown error"}`);
+            throw error;
+        }
+    }
+    /**
+     * Send email using Postmark template
+     */
+    async sendWithTemplate(to, data) {
+        const templateId = data?.templateId;
+        const templateAlias = data?.templateAlias;
+        const templateModel = data?.templateModel || {};
+        const from = data?.from || this.options.from;
+        const replyTo = data?.replyTo;
+        const messageStream = data?.messageStream || this.options.messageStream;
+        if (!templateId && !templateAlias) {
+            throw new Error("Either 'templateId' (number) or 'templateAlias' (string) must be provided for Postmark templates");
+        }
+        // Build template options
+        const templateOptions = {
+            From: from,
+            To: to,
+            TemplateModel: templateModel,
+            MessageStream: messageStream,
+        };
+        // Use TemplateId or TemplateAlias
+        if (templateAlias) {
+            templateOptions.TemplateAlias = templateAlias;
+        }
+        else {
+            templateOptions.TemplateId = templateId;
+        }
+        // Add optional fields
+        const attachments = data?.attachments || [];
+        this.addOptionalFields(templateOptions, data, attachments);
+        try {
+            this.logger.debug(`Sending email via Postmark (template ${templateId || templateAlias}) to ${to}`);
+            const response = await this.client.sendEmailWithTemplate(templateOptions);
+            this.logger.info(`Email sent successfully via Postmark template: ${response.MessageID}`);
+            return { id: response.MessageID };
+        }
+        catch (error) {
+            this.logger.error(`Failed to send email via Postmark template: ${error?.message || "Unknown error"}`);
+            throw error;
+        }
+    }
+    /**
+     * Add optional fields to email options
+     */
+    addOptionalFields(emailOptions, data, attachments) {
+        const replyTo = data?.replyTo;
+        if (replyTo)
+            emailOptions.ReplyTo = replyTo;
+        if (data?.cc)
+            emailOptions.Cc = data.cc;
+        if (data?.bcc)
+            emailOptions.Bcc = data.bcc;
+        if (data?.tag)
+            emailOptions.Tag = data.tag;
+        if (data?.metadata)
+            emailOptions.Metadata = data.metadata;
+        if (attachments.length > 0)
+            emailOptions.Attachments = attachments;
+        // Tracking options
+        if (data?.trackOpens !== undefined) {
+            emailOptions.TrackOpens = data.trackOpens;
+        }
+        else if (this.options.trackOpens !== undefined) {
+            emailOptions.TrackOpens = this.options.trackOpens;
+        }
+        if (data?.trackLinks !== undefined) {
+            emailOptions.TrackLinks = data.trackLinks;
+        }
+        else if (this.options.trackLinks !== undefined) {
+            emailOptions.TrackLinks = this.options.trackLinks;
+        }
+        // Headers
+        if (data?.headers) {
+            emailOptions.Headers = data.headers;
+        }
+    }
+}
+PostmarkNotificationService.identifier = "postmark";
+exports.default = PostmarkNotificationService;

package/dist/types.d.ts

@@ -0,0 +1,74 @@
+export interface PostmarkOptions {
+    /** Postmark server token */
+    serverToken: string;
+    /** Default from email address */
+    from: string;
+    /** Postmark message stream (default: "outbound") */
+    messageStream?: string;
+    /** Automatically convert data URLs to CID attachments (default: true) */
+    convertDataUrlsToCID?: boolean;
+    /** Track email opens (default: undefined - uses Postmark server default) */
+    trackOpens?: boolean;
+    /** Track link clicks */
+    trackLinks?: "None" | "HtmlAndText" | "HtmlOnly" | "TextOnly";
+}
+export interface NotificationPayload {
+    /** Recipient email address */
+    to: string;
+    /** Notification channel (e.g., "email") */
+    channel: string;
+    /** Template identifier (optional - for reference) */
+    template: string;
+    /** Notification data */
+    data: Record<string, unknown> | null;
+}
+export interface EmailOptions {
+    From: string;
+    To: string;
+    Subject: string;
+    HtmlBody: string;
+    MessageStream: string;
+    ReplyTo?: string;
+    Cc?: string;
+    Bcc?: string;
+    Tag?: string;
+    Metadata?: Record<string, string>;
+    Attachments?: Attachment[];
+    TrackOpens?: boolean;
+    TrackLinks?: "None" | "HtmlAndText" | "HtmlOnly" | "TextOnly";
+    Headers?: Array<{
+        Name: string;
+        Value: string;
+    }>;
+}
+export interface TemplateOptions {
+    From: string;
+    To: string;
+    TemplateId?: number;
+    TemplateAlias?: string;
+    TemplateModel: Record<string, any>;
+    MessageStream: string;
+    ReplyTo?: string;
+    Cc?: string;
+    Bcc?: string;
+    Tag?: string;
+    Metadata?: Record<string, string>;
+    Attachments?: Attachment[];
+    TrackOpens?: boolean;
+    TrackLinks?: "None" | "HtmlAndText" | "HtmlOnly" | "TextOnly";
+    Headers?: Array<{
+        Name: string;
+        Value: string;
+    }>;
+}
+export interface Attachment {
+    /** File name */
+    Name: string;
+    /** Base64-encoded content */
+    Content: string;
+    /** MIME type */
+    ContentType: string;
+    /** Content ID for inline images (e.g., "cid:logo") */
+    ContentID?: string;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,eAAe;IAC9B,4BAA4B;IAC5B,WAAW,EAAE,MAAM,CAAA;IAEnB,iCAAiC;IACjC,IAAI,EAAE,MAAM,CAAA;IAEZ,oDAAoD;IACpD,aAAa,CAAC,EAAE,MAAM,CAAA;IAEtB,yEAAyE;IACzE,oBAAoB,CAAC,EAAE,OAAO,CAAA;IAE9B,4EAA4E;IAC5E,UAAU,CAAC,EAAE,OAAO,CAAA;IAEpB,wBAAwB;IACxB,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,UAAU,GAAG,UAAU,CAAA;CAC9D;AAED,MAAM,WAAW,mBAAmB;IAClC,8BAA8B;IAC9B,EAAE,EAAE,MAAM,CAAA;IAEV,2CAA2C;IAC3C,OAAO,EAAE,MAAM,CAAA;IAEf,qDAAqD;IACrD,QAAQ,EAAE,MAAM,CAAA;IAEhB,wBAAwB;IACxB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAA;CACrC;AAED,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,QAAQ,EAAE,MAAM,CAAA;IAChB,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,WAAW,CAAC,EAAE,UAAU,EAAE,CAAA;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,UAAU,GAAG,UAAU,CAAA;IAC7D,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,EAAE,EAAE,MAAM,CAAA;IACV,UAAU,CAAC,EAAE,MAAM,CAAA;IACnB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAClC,aAAa,EAAE,MAAM,CAAA;IACrB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,EAAE,CAAC,EAAE,MAAM,CAAA;IACX,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,WAAW,CAAC,EAAE,UAAU,EAAE,CAAA;IAC1B,UAAU,CAAC,EAAE,OAAO,CAAA;IACpB,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,UAAU,GAAG,UAAU,CAAA;IAC7D,OAAO,CAAC,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CACjD;AAED,MAAM,WAAW,UAAU;IACzB,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAA;IAEZ,6BAA6B;IAC7B,OAAO,EAAE,MAAM,CAAA;IAEf,gBAAgB;IAChB,WAAW,EAAE,MAAM,CAAA;IAEnB,sDAAsD;IACtD,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB"}

package/dist/types.js

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

package/dist/utils.d.ts

@@ -0,0 +1,25 @@
+import { Attachment } from "./types";
+/**
+ * Convert data URLs in HTML to CID attachments
+ * Recursively finds all data:image URLs and converts them to CID references
+ *
+ * @param html - HTML content with potential data URLs
+ * @param existingAttachments - Any existing attachments to preserve
+ * @returns Object with modified HTML and all attachments
+ */
+export declare function convertDataUrlsToCID(html: string, existingAttachments?: any[]): {
+    html: string;
+    attachments: Attachment[];
+};
+/**
+ * Convert any object with data URLs to CID attachments
+ * Useful for templates that pass images in data object
+ *
+ * @param data - Any data object that might contain data URLs
+ * @returns Object with modified data and attachments
+ */
+export declare function convertObjectDataUrlsToCID(data: any): {
+    data: any;
+    attachments: Attachment[];
+};
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AAEpC;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,mBAAmB,GAAE,GAAG,EAAO,GAC9B;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CAAE,CA0B7C;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,GAAG,GACR;IAAE,IAAI,EAAE,GAAG,CAAC;IAAC,WAAW,EAAE,UAAU,EAAE,CAAA;CAAE,CAwC1C"}

package/dist/utils.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDataUrlsToCID = convertDataUrlsToCID;
+exports.convertObjectDataUrlsToCID = convertObjectDataUrlsToCID;
+/**
+ * Convert data URLs in HTML to CID attachments
+ * Recursively finds all data:image URLs and converts them to CID references
+ *
+ * @param html - HTML content with potential data URLs
+ * @param existingAttachments - Any existing attachments to preserve
+ * @returns Object with modified HTML and all attachments
+ */
+function convertDataUrlsToCID(html, existingAttachments = []) {
+    const attachments = [...existingAttachments];
+    let finalHtml = html;
+    let imageCount = 0;
+    // Find all data URLs in the HTML
+    const dataUrlRegex = /data:image\/(png|jpeg|jpg|gif|webp);base64,([A-Za-z0-9+/=]+)/g;
+    let match;
+    while ((match = dataUrlRegex.exec(html)) !== null) {
+        const [fullMatch, imageType, base64Content] = match;
+        const cid = `image-${imageCount++}`;
+        // Create CID attachment
+        attachments.push({
+            Name: `${cid}.${imageType}`,
+            Content: base64Content,
+            ContentType: `image/${imageType}`,
+            ContentID: `cid:${cid}`,
+        });
+        // Replace data URL with CID reference
+        finalHtml = finalHtml.replace(fullMatch, `cid:${cid}`);
+    }
+    return { html: finalHtml, attachments };
+}
+/**
+ * Convert any object with data URLs to CID attachments
+ * Useful for templates that pass images in data object
+ *
+ * @param data - Any data object that might contain data URLs
+ * @returns Object with modified data and attachments
+ */
+function convertObjectDataUrlsToCID(data) {
+    const attachments = [];
+    let imageCount = 0;
+    function processValue(value) {
+        if (typeof value === 'string' && value.startsWith('data:image')) {
+            const match = value.match(/data:image\/(png|jpeg|jpg|gif|webp);base64,([A-Za-z0-9+/=]+)/);
+            if (match) {
+                const [, imageType, base64Content] = match;
+                const cid = `image-${imageCount++}`;
+                attachments.push({
+                    Name: `${cid}.${imageType}`,
+                    Content: base64Content,
+                    ContentType: `image/${imageType}`,
+                    ContentID: `cid:${cid}`,
+                });
+                return `cid:${cid}`;
+            }
+        }
+        if (Array.isArray(value)) {
+            return value.map(processValue);
+        }
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.entries(value).map(([k, v]) => [k, processValue(v)]));
+        }
+        return value;
+    }
+    return {
+        data: processValue(data),
+        attachments,
+    };
+}

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@cb4kas17/medusa-notification-postmark",
+  "version": "1.0.0",
+  "description": "Generic Postmark notification provider for Medusa v2 - supports custom HTML and Postmark templates",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test": "jest"
+  },
+  "keywords": [
+    "medusa",
+    "medusa-plugin",
+    "medusa-v2",
+    "notification",
+    "postmark",
+    "email",
+    "notification-provider"
+  ],
+  "author": "const-code",
+  "license": "MIT",
+  "peerDependencies": {
+    "@medusajs/framework": "^2.0.0",
+    "postmark": "^4.0.0"
+  },
+  "devDependencies": {
+    "@medusajs/framework": "^2.13.1",
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.19.33",
+    "jest": "^29.0.0",
+    "postmark": "^4.0.5",
+    "typescript": "^5.9.3"
+  },
+  "directories": {
+    "example": "examples"
+  }
+}