@mobilizehub/payload-plugin 0.1.0 → 0.2.0

package/dist/types/index.d.ts

@@ -1,12 +1,135 @@
-import type { CollectionConfig, Field } from 'payload';
+import type { BasePayload, CollectionConfig, Field, PayloadRequest } from 'payload';
 export type FieldsOverride = (args: {
     defaultFields: Field[];
 }) => Field[];
 export type CollectionOverride = {
     fields?: FieldsOverride;
 } & Partial<Omit<CollectionConfig, 'fields'>>;
+/**
+ * Contact type
+ */
+export type Contact = {
+    createdAt?: string;
+    email?: string;
+    emailOptIn: boolean;
+    firstName?: string;
+    id: number | string;
+    lastName?: string;
+    tags?: {
+        createdAt?: string;
+        id: number | string;
+        name?: string;
+        updatedAt?: string;
+    }[];
+    updatedAt?: string;
+};
+/**
+ * Unsubscribe token input structure
+ */
+export interface UnsubscribeTokenInput {
+    timestamp: number;
+    tokenId: string;
+}
+/**
+ * Unsubscribe token record structure
+ */
+export type UnsubscribeTokenRecord = {
+    emailId?: number | string;
+    expiresAt?: string;
+    id: string;
+};
+/**
+ * Email activity types
+ */
+export type EmailStatus = 'bounced' | 'complained' | 'delivered' | 'failed' | 'queued' | 'sent' | 'unsubscribed';
+/**
+ * Email activity types from providers
+ */
+export type EmailActivityType = 'bounced' | 'clicked' | 'complained' | 'delivered' | 'delivery_delayed' | 'failed' | 'opened' | 'received' | 'sent';
+/**
+ * Email message structure
+ */
+export type EmailMessage = {
+    from: string;
+    html: string;
+    idempotencyKey?: string;
+    markdown?: string;
+    plainText?: string;
+    previewText?: string;
+    replyTo?: string;
+    subject: string;
+    to: string;
+    token?: string;
+};
+/**
+ * Result of a webhook call
+ */
+export type WebhookResult = {
+    body?: unknown;
+    status: number;
+};
+/**
+ * Email adapter interface for sending emails
+ */
+export type EmailAdapter = ({ payload }: {
+    payload: BasePayload;
+}) => {
+    defaultFromAddress: string;
+    defaultFromName: string;
+    name: string;
+    render: (args: EmailMessage) => string;
+    sendEmail: (args: EmailMessage) => Promise<{
+        providerId: string;
+    } | void>;
+    webhookHandler?: (req: PayloadRequest) => Promise<void | WebhookResult>;
+};
 export type MobilizehubPluginConfig = {
+    broadcastConfig?: {
+        /**
+         * Batch size for processing contacts in the broadcasts task.
+         * Higher values process faster but use more memory.
+         * @default 100
+         */
+        batchSize?: number;
+        /**
+         * Optional custom queue name for the broadcasts task
+         * @default 'send-broadcasts'
+         */
+        broadcastQueueName?: string;
+        /**
+         * Optional custom queue name for the email sending task
+         * @default 'send-email'
+         */
+        emailQueueName?: string;
+        /**
+         * Cron schedule for the broadcasts task
+         * On schedule the task will run to process and send pending broadcasts
+         * @default '5 * * * *' (every 5 minutes)
+         */
+        taskSchedule?: string;
+    };
+    /**
+     * Overrides for the broadcasts collection
+     */
+    broadcastsOverrides?: CollectionOverride;
+    /**
+     * Overrides for the contacts collection
+     */
     contactsOverrides?: CollectionOverride;
+    /**
+     * Disable the plugin
+     */
     disabled?: boolean;
+    /**
+     * Email adapter for sending emails
+     */
+    email: EmailAdapter;
+    /**
+     * Overrides for the emails collection
+     */
+    emailsOverrides?: CollectionOverride;
+    /**
+     * Overrides for the tags collection
+     */
     tagsOverrides?: CollectionOverride;
 };

package/dist/types/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["import type { CollectionConfig, Field } from 'payload'\n\nexport type FieldsOverride = (args: { defaultFields: Field[] }) => Field[]\n\nexport type CollectionOverride = { fields?: FieldsOverride } & Partial<\n  Omit<CollectionConfig, 'fields'>\n>\nexport type MobilizehubPluginConfig = {\n  contactsOverrides?: CollectionOverride\n  disabled?: boolean\n  tagsOverrides?: CollectionOverride\n}\n"],"names":[],"mappings":"AAOA,WAIC"}
+{"version":3,"sources":["../../src/types/index.ts"],"sourcesContent":["import type { BasePayload, CollectionConfig, Field, PayloadRequest } from 'payload'\n\nexport type FieldsOverride = (args: { defaultFields: Field[] }) => Field[]\n\nexport type CollectionOverride = { fields?: FieldsOverride } & Partial<\n  Omit<CollectionConfig, 'fields'>\n>\n\n/**\n * Contact type\n */\nexport type Contact = {\n  createdAt?: string\n  email?: string\n  emailOptIn: boolean\n  firstName?: string\n  id: number | string\n  lastName?: string\n  tags?: {\n    createdAt?: string\n    id: number | string\n    name?: string\n    updatedAt?: string\n  }[]\n  updatedAt?: string\n}\n\n/**\n * Unsubscribe token input structure\n */\nexport interface UnsubscribeTokenInput {\n  timestamp: number\n  tokenId: string\n}\n\n/**\n * Unsubscribe token record structure\n */\nexport type UnsubscribeTokenRecord = {\n  emailId?: number | string\n  expiresAt?: string\n  id: string\n}\n\n/**\n * Email activity types\n */\nexport type EmailStatus =\n  | 'bounced'\n  | 'complained'\n  | 'delivered'\n  | 'failed'\n  | 'queued'\n  | 'sent'\n  | 'unsubscribed'\n\n/**\n * Email activity types from providers\n */\nexport type EmailActivityType =\n  | 'bounced'\n  | 'clicked'\n  | 'complained'\n  | 'delivered'\n  | 'delivery_delayed'\n  | 'failed'\n  | 'opened'\n  | 'received'\n  | 'sent'\n\n/**\n * Email message structure\n */\nexport type EmailMessage = {\n  from: string\n  html: string\n  idempotencyKey?: string\n  markdown?: string\n  plainText?: string\n  previewText?: string\n  replyTo?: string\n  subject: string\n  to: string\n  token?: string\n}\n\n/**\n * Result of a webhook call\n */\nexport type WebhookResult = {\n  body?: unknown\n  status: number\n}\n\n/**\n * Email adapter interface for sending emails\n */\nexport type EmailAdapter = ({ payload }: { payload: BasePayload }) => {\n  defaultFromAddress: string\n  defaultFromName: string\n  name: string\n  render: (args: EmailMessage) => string\n  sendEmail: (args: EmailMessage) => Promise<{ providerId: string } | void>\n  webhookHandler?: (req: PayloadRequest) => Promise<void | WebhookResult>\n}\n\nexport type MobilizehubPluginConfig = {\n  broadcastConfig?: {\n    /**\n     * Batch size for processing contacts in the broadcasts task.\n     * Higher values process faster but use more memory.\n     * @default 100\n     */\n    batchSize?: number\n    /**\n     * Optional custom queue name for the broadcasts task\n     * @default 'send-broadcasts'\n     */\n    broadcastQueueName?: string\n    /**\n     * Optional custom queue name for the email sending task\n     * @default 'send-email'\n     */\n    emailQueueName?: string\n    /**\n     * Cron schedule for the broadcasts task\n     * On schedule the task will run to process and send pending broadcasts\n     * @default '5 * * * *' (every 5 minutes)\n     */\n    taskSchedule?: string\n  }\n  /**\n   * Overrides for the broadcasts collection\n   */\n  broadcastsOverrides?: CollectionOverride\n\n  /**\n   * Overrides for the contacts collection\n   */\n  contactsOverrides?: CollectionOverride\n  /**\n   * Disable the plugin\n   */\n  disabled?: boolean\n  /**\n   * Email adapter for sending emails\n   */\n  email: EmailAdapter\n  /**\n   * Overrides for the emails collection\n   */\n  emailsOverrides?: CollectionOverride\n  /**\n   * Overrides for the tags collection\n   */\n  tagsOverrides?: CollectionOverride\n}\n"],"names":[],"mappings":"AA0GA,WAkDC"}

package/dist/utils/api-response.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Standard API success response format
+ * @template T - Type of the data payload
+ */
+export type ApiSuccessResponse<T = unknown> = {
+    data?: T;
+    success: true;
+};
+/**
+ * Standard API error response format
+ */
+export type ApiErrorResponse = {
+    error: {
+        /** Error code constant (e.g., 'BAD_REQUEST', 'UNAUTHORIZED') */
+        code: string;
+        /** Human-readable error message */
+        message: string;
+    };
+    success: false;
+};
+/**
+ * Union type for all API responses
+ * @template T - Type of the data payload for success responses
+ */
+export type ApiResponse<T = unknown> = ApiErrorResponse | ApiSuccessResponse<T>;
+/**
+ * Create a standardized success response
+ *
+ * @template T - Type of the response data
+ * @param data - Optional data payload to include in the response
+ * @param status - HTTP status code (default: 200)
+ * @returns Response object with JSON body
+ *
+ * @example
+ * ```typescript
+ * return successResponse({ message: 'Email sent successfully' }, 200)
+ * // Returns: { success: true, data: { message: 'Email sent successfully' } }
+ * ```
+ */
+export declare function successResponse<T>(data?: T, status?: number): Response;
+/**
+ * Create a standardized error response
+ *
+ * @param code - Error code from ErrorCodes constant
+ * @param message - Human-readable error message
+ * @param status - HTTP status code (default: 400)
+ * @returns Response object with JSON error body
+ *
+ * @example
+ * ```typescript
+ * return errorResponse(ErrorCodes.UNAUTHORIZED, 'You must be logged in', 401)
+ * // Returns: { success: false, error: { code: 'UNAUTHORIZED', message: '...' } }
+ * ```
+ */
+export declare function errorResponse(code: string, message: string, status?: number): Response;
+/**
+ * Standard error codes used across the MobilizeHub plugin API
+ */
+export declare const ErrorCodes: {
+    readonly BAD_REQUEST: "BAD_REQUEST";
+    readonly BROADCAST_INVALID_STATUS: "BROADCAST_INVALID_STATUS";
+    readonly BROADCAST_NOT_FOUND: "BROADCAST_NOT_FOUND";
+    readonly CONTACT_NOT_FOUND: "CONTACT_NOT_FOUND";
+    readonly EMAIL_SEND_FAILED: "EMAIL_SEND_FAILED";
+    readonly INTERNAL_ERROR: "INTERNAL_ERROR";
+    readonly NOT_FOUND: "NOT_FOUND";
+    readonly RATE_LIMITED: "RATE_LIMITED";
+    readonly TOKEN_EXPIRED: "TOKEN_EXPIRED";
+    readonly TOKEN_INVALID: "TOKEN_INVALID";
+    readonly UNAUTHORIZED: "UNAUTHORIZED";
+    readonly VALIDATION_ERROR: "VALIDATION_ERROR";
+};

package/dist/utils/api-response.js

@@ -0,0 +1,66 @@
+/**
+ * Standard API success response format
+ * @template T - Type of the data payload
+ */ /**
+ * Create a standardized success response
+ *
+ * @template T - Type of the response data
+ * @param data - Optional data payload to include in the response
+ * @param status - HTTP status code (default: 200)
+ * @returns Response object with JSON body
+ *
+ * @example
+ * ```typescript
+ * return successResponse({ message: 'Email sent successfully' }, 200)
+ * // Returns: { success: true, data: { message: 'Email sent successfully' } }
+ * ```
+ */ export function successResponse(data, status = 200) {
+    return Response.json({
+        data,
+        success: true
+    }, {
+        status
+    });
+}
+/**
+ * Create a standardized error response
+ *
+ * @param code - Error code from ErrorCodes constant
+ * @param message - Human-readable error message
+ * @param status - HTTP status code (default: 400)
+ * @returns Response object with JSON error body
+ *
+ * @example
+ * ```typescript
+ * return errorResponse(ErrorCodes.UNAUTHORIZED, 'You must be logged in', 401)
+ * // Returns: { success: false, error: { code: 'UNAUTHORIZED', message: '...' } }
+ * ```
+ */ export function errorResponse(code, message, status = 400) {
+    return Response.json({
+        error: {
+            code,
+            message
+        },
+        success: false
+    }, {
+        status
+    });
+}
+/**
+ * Standard error codes used across the MobilizeHub plugin API
+ */ export const ErrorCodes = {
+    BAD_REQUEST: 'BAD_REQUEST',
+    BROADCAST_INVALID_STATUS: 'BROADCAST_INVALID_STATUS',
+    BROADCAST_NOT_FOUND: 'BROADCAST_NOT_FOUND',
+    CONTACT_NOT_FOUND: 'CONTACT_NOT_FOUND',
+    EMAIL_SEND_FAILED: 'EMAIL_SEND_FAILED',
+    INTERNAL_ERROR: 'INTERNAL_ERROR',
+    NOT_FOUND: 'NOT_FOUND',
+    RATE_LIMITED: 'RATE_LIMITED',
+    TOKEN_EXPIRED: 'TOKEN_EXPIRED',
+    TOKEN_INVALID: 'TOKEN_INVALID',
+    UNAUTHORIZED: 'UNAUTHORIZED',
+    VALIDATION_ERROR: 'VALIDATION_ERROR'
+};
+
+//# sourceMappingURL=api-response.js.map

package/dist/utils/api-response.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/api-response.ts"],"sourcesContent":["/**\n * Standard API success response format\n * @template T - Type of the data payload\n */\nexport type ApiSuccessResponse<T = unknown> = {\n  data?: T\n  success: true\n}\n\n/**\n * Standard API error response format\n */\nexport type ApiErrorResponse = {\n  error: {\n    /** Error code constant (e.g., 'BAD_REQUEST', 'UNAUTHORIZED') */\n    code: string\n    /** Human-readable error message */\n    message: string\n  }\n  success: false\n}\n\n/**\n * Union type for all API responses\n * @template T - Type of the data payload for success responses\n */\nexport type ApiResponse<T = unknown> = ApiErrorResponse | ApiSuccessResponse<T>\n\n/**\n * Create a standardized success response\n *\n * @template T - Type of the response data\n * @param data - Optional data payload to include in the response\n * @param status - HTTP status code (default: 200)\n * @returns Response object with JSON body\n *\n * @example\n * ```typescript\n * return successResponse({ message: 'Email sent successfully' }, 200)\n * // Returns: { success: true, data: { message: 'Email sent successfully' } }\n * ```\n */\nexport function successResponse<T>(data?: T, status = 200): Response {\n  return Response.json({ data, success: true }, { status })\n}\n\n/**\n * Create a standardized error response\n *\n * @param code - Error code from ErrorCodes constant\n * @param message - Human-readable error message\n * @param status - HTTP status code (default: 400)\n * @returns Response object with JSON error body\n *\n * @example\n * ```typescript\n * return errorResponse(ErrorCodes.UNAUTHORIZED, 'You must be logged in', 401)\n * // Returns: { success: false, error: { code: 'UNAUTHORIZED', message: '...' } }\n * ```\n */\nexport function errorResponse(code: string, message: string, status = 400): Response {\n  return Response.json({ error: { code, message }, success: false }, { status })\n}\n\n/**\n * Standard error codes used across the MobilizeHub plugin API\n */\nexport const ErrorCodes = {\n  BAD_REQUEST: 'BAD_REQUEST',\n  BROADCAST_INVALID_STATUS: 'BROADCAST_INVALID_STATUS',\n  BROADCAST_NOT_FOUND: 'BROADCAST_NOT_FOUND',\n  CONTACT_NOT_FOUND: 'CONTACT_NOT_FOUND',\n  EMAIL_SEND_FAILED: 'EMAIL_SEND_FAILED',\n  INTERNAL_ERROR: 'INTERNAL_ERROR',\n  NOT_FOUND: 'NOT_FOUND',\n  RATE_LIMITED: 'RATE_LIMITED',\n  TOKEN_EXPIRED: 'TOKEN_EXPIRED',\n  TOKEN_INVALID: 'TOKEN_INVALID',\n  UNAUTHORIZED: 'UNAUTHORIZED',\n  VALIDATION_ERROR: 'VALIDATION_ERROR',\n} as const\n"],"names":["successResponse","data","status","Response","json","success","errorResponse","code","message","error","ErrorCodes","BAD_REQUEST","BROADCAST_INVALID_STATUS","BROADCAST_NOT_FOUND","CONTACT_NOT_FOUND","EMAIL_SEND_FAILED","INTERNAL_ERROR","NOT_FOUND","RATE_LIMITED","TOKEN_EXPIRED","TOKEN_INVALID","UNAUTHORIZED","VALIDATION_ERROR"],"mappings":"AAAA;;;CAGC,GAyBD;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASA,gBAAmBC,IAAQ,EAAEC,SAAS,GAAG;IACvD,OAAOC,SAASC,IAAI,CAAC;QAAEH;QAAMI,SAAS;IAAK,GAAG;QAAEH;IAAO;AACzD;AAEA;;;;;;;;;;;;;CAaC,GACD,OAAO,SAASI,cAAcC,IAAY,EAAEC,OAAe,EAAEN,SAAS,GAAG;IACvE,OAAOC,SAASC,IAAI,CAAC;QAAEK,OAAO;YAAEF;YAAMC;QAAQ;QAAGH,SAAS;IAAM,GAAG;QAAEH;IAAO;AAC9E;AAEA;;CAEC,GACD,OAAO,MAAMQ,aAAa;IACxBC,aAAa;IACbC,0BAA0B;IAC1BC,qBAAqB;IACrBC,mBAAmB;IACnBC,mBAAmB;IACnBC,gBAAgB;IAChBC,WAAW;IACXC,cAAc;IACdC,eAAe;IACfC,eAAe;IACfC,cAAc;IACdC,kBAAkB;AACpB,EAAU"}

package/dist/utils/email.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Formats an email address with an optional display name according to RFC 5322.
+ *
+ * @param fromName - The display name to show (e.g., "John Doe")
+ * @param fromAddress - The actual email address (e.g., "john@example.com")
+ * @returns Formatted email string. If fromName is provided: `"John Doe" <john@example.com>`
+ *          Otherwise just returns the email address.
+ *
+ * @example
+ * ```typescript
+ * formatFromAddress("Acme Corp", "hello@acme.com")
+ * // Returns: '"Acme Corp" <hello@acme.com>'
+ *
+ * formatFromAddress("", "hello@acme.com")
+ * // Returns: 'hello@acme.com'
+ * ```
+ */
+export declare function formatFromAddress(fromName: string, fromAddress: string): string;
+/**
+ * Validates if a string is a properly formatted email address.
+ *
+ * Uses a permissive regex that catches most invalid formats while allowing
+ * valid edge cases like plus-addressing (user+tag@domain.com).
+ *
+ * @param email - The string to validate
+ * @returns `true` if the string appears to be a valid email format
+ *
+ * @example
+ * ```typescript
+ * isValidEmail("user@example.com")     // true
+ * isValidEmail("user+tag@example.com") // true
+ * isValidEmail("invalid")              // false
+ * isValidEmail("missing@domain")       // false
+ * ```
+ */
+export declare function isValidEmail(email: string): boolean;

package/dist/utils/email.js

@@ -0,0 +1,40 @@
+/**
+ * Formats an email address with an optional display name according to RFC 5322.
+ *
+ * @param fromName - The display name to show (e.g., "John Doe")
+ * @param fromAddress - The actual email address (e.g., "john@example.com")
+ * @returns Formatted email string. If fromName is provided: `"John Doe" <john@example.com>`
+ *          Otherwise just returns the email address.
+ *
+ * @example
+ * ```typescript
+ * formatFromAddress("Acme Corp", "hello@acme.com")
+ * // Returns: '"Acme Corp" <hello@acme.com>'
+ *
+ * formatFromAddress("", "hello@acme.com")
+ * // Returns: 'hello@acme.com'
+ * ```
+ */ export function formatFromAddress(fromName, fromAddress) {
+    return fromName ? `"${fromName}" <${fromAddress}>` : fromAddress;
+}
+/**
+ * Validates if a string is a properly formatted email address.
+ *
+ * Uses a permissive regex that catches most invalid formats while allowing
+ * valid edge cases like plus-addressing (user+tag@domain.com).
+ *
+ * @param email - The string to validate
+ * @returns `true` if the string appears to be a valid email format
+ *
+ * @example
+ * ```typescript
+ * isValidEmail("user@example.com")     // true
+ * isValidEmail("user+tag@example.com") // true
+ * isValidEmail("invalid")              // false
+ * isValidEmail("missing@domain")       // false
+ * ```
+ */ export function isValidEmail(email) {
+    return /^[^\s@]+@[^\s@][^\s.@]*\.[^\s@]+$/.test(email);
+}
+
+//# sourceMappingURL=email.js.map

package/dist/utils/email.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/email.ts"],"sourcesContent":["/**\n * Formats an email address with an optional display name according to RFC 5322.\n *\n * @param fromName - The display name to show (e.g., \"John Doe\")\n * @param fromAddress - The actual email address (e.g., \"john@example.com\")\n * @returns Formatted email string. If fromName is provided: `\"John Doe\" <john@example.com>`\n *          Otherwise just returns the email address.\n *\n * @example\n * ```typescript\n * formatFromAddress(\"Acme Corp\", \"hello@acme.com\")\n * // Returns: '\"Acme Corp\" <hello@acme.com>'\n *\n * formatFromAddress(\"\", \"hello@acme.com\")\n * // Returns: 'hello@acme.com'\n * ```\n */\nexport function formatFromAddress(fromName: string, fromAddress: string): string {\n  return fromName ? `\"${fromName}\" <${fromAddress}>` : fromAddress\n}\n\n/**\n * Validates if a string is a properly formatted email address.\n *\n * Uses a permissive regex that catches most invalid formats while allowing\n * valid edge cases like plus-addressing (user+tag@domain.com).\n *\n * @param email - The string to validate\n * @returns `true` if the string appears to be a valid email format\n *\n * @example\n * ```typescript\n * isValidEmail(\"user@example.com\")     // true\n * isValidEmail(\"user+tag@example.com\") // true\n * isValidEmail(\"invalid\")              // false\n * isValidEmail(\"missing@domain\")       // false\n * ```\n */\nexport function isValidEmail(email: string): boolean {\n  return /^[^\\s@]+@[^\\s@][^\\s.@]*\\.[^\\s@]+$/.test(email)\n}\n"],"names":["formatFromAddress","fromName","fromAddress","isValidEmail","email","test"],"mappings":"AAAA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASA,kBAAkBC,QAAgB,EAAEC,WAAmB;IACrE,OAAOD,WAAW,CAAC,CAAC,EAAEA,SAAS,GAAG,EAAEC,YAAY,CAAC,CAAC,GAAGA;AACvD;AAEA;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASC,aAAaC,KAAa;IACxC,OAAO,oCAAoCC,IAAI,CAACD;AAClD"}

package/dist/utils/lexical.d.ts

@@ -0,0 +1,13 @@
+import type { SerializedEditorState } from '@payloadcms/richtext-lexical/lexical';
+import type { Payload } from 'payload';
+/**
+ * Parses Lexical editor content into multiple formats (HTML, Markdown, Plain Text)
+ * @param content - The serialized Lexical editor state
+ * @param payloadConfig - The Payload CMS configuration
+ * @returns Parsed content in HTML, Markdown, and Plain Text formats
+ */
+export declare function parseLexicalContent(content: SerializedEditorState, payloadConfig: Payload['config']): Promise<{
+    html: string;
+    markdown: string;
+    plainText: string;
+}>;

package/dist/utils/lexical.js

@@ -0,0 +1,27 @@
+import { convertLexicalToMarkdown, editorConfigFactory } from '@payloadcms/richtext-lexical';
+import { convertLexicalToHTML } from '@payloadcms/richtext-lexical/html';
+import { convertLexicalToPlaintext } from '@payloadcms/richtext-lexical/plaintext';
+/**
+ * Parses Lexical editor content into multiple formats (HTML, Markdown, Plain Text)
+ * @param content - The serialized Lexical editor state
+ * @param payloadConfig - The Payload CMS configuration
+ * @returns Parsed content in HTML, Markdown, and Plain Text formats
+ */ export async function parseLexicalContent(content, payloadConfig) {
+    const editorConfig = await editorConfigFactory.default({
+        config: payloadConfig
+    });
+    return {
+        html: convertLexicalToHTML({
+            data: content
+        }),
+        markdown: convertLexicalToMarkdown({
+            data: content,
+            editorConfig
+        }),
+        plainText: convertLexicalToPlaintext({
+            data: content
+        })
+    };
+}
+
+//# sourceMappingURL=lexical.js.map

package/dist/utils/lexical.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/lexical.ts"],"sourcesContent":["import type { SerializedEditorState } from '@payloadcms/richtext-lexical/lexical'\nimport type { Payload } from 'payload'\n\nimport { convertLexicalToMarkdown, editorConfigFactory } from '@payloadcms/richtext-lexical'\nimport { convertLexicalToHTML } from '@payloadcms/richtext-lexical/html'\nimport { convertLexicalToPlaintext } from '@payloadcms/richtext-lexical/plaintext'\n\n/**\n * Parses Lexical editor content into multiple formats (HTML, Markdown, Plain Text)\n * @param content - The serialized Lexical editor state\n * @param payloadConfig - The Payload CMS configuration\n * @returns Parsed content in HTML, Markdown, and Plain Text formats\n */\nexport async function parseLexicalContent(\n  content: SerializedEditorState,\n  payloadConfig: Payload['config'],\n): Promise<{\n  html: string\n  markdown: string\n  plainText: string\n}> {\n  const editorConfig = await editorConfigFactory.default({ config: payloadConfig })\n\n  return {\n    html: convertLexicalToHTML({ data: content }),\n    markdown: convertLexicalToMarkdown({ data: content, editorConfig }),\n    plainText: convertLexicalToPlaintext({ data: content }),\n  }\n}\n"],"names":["convertLexicalToMarkdown","editorConfigFactory","convertLexicalToHTML","convertLexicalToPlaintext","parseLexicalContent","content","payloadConfig","editorConfig","default","config","html","data","markdown","plainText"],"mappings":"AAGA,SAASA,wBAAwB,EAAEC,mBAAmB,QAAQ,+BAA8B;AAC5F,SAASC,oBAAoB,QAAQ,oCAAmC;AACxE,SAASC,yBAAyB,QAAQ,yCAAwC;AAElF;;;;;CAKC,GACD,OAAO,eAAeC,oBACpBC,OAA8B,EAC9BC,aAAgC;IAMhC,MAAMC,eAAe,MAAMN,oBAAoBO,OAAO,CAAC;QAAEC,QAAQH;IAAc;IAE/E,OAAO;QACLI,MAAMR,qBAAqB;YAAES,MAAMN;QAAQ;QAC3CO,UAAUZ,yBAAyB;YAAEW,MAAMN;YAASE;QAAa;QACjEM,WAAWV,0BAA0B;YAAEQ,MAAMN;QAAQ;IACvD;AACF"}

package/dist/utils/unsubscribe-token.d.ts

@@ -0,0 +1,67 @@
+type UnsubscribeToken = {
+    timestamp: number;
+    tokenId: string;
+};
+/**
+ * Creates a secure unsubscribe token for the given token ID.
+ *
+ * ## Token Format
+ * The token consists of two parts separated by a dot:
+ * - Base64URL-encoded JSON payload containing tokenId and timestamp
+ * - HMAC-SHA256 signature of the payload
+ *
+ * ## Expiration
+ * Tokens expire after 30 days from creation
+ *
+ * ## Security Considerations
+ * - Tokens are signed with HMAC-SHA256 using PAYLOAD_SECRET
+ * - Verification uses timing-safe comparison to prevent timing attacks
+ * - Tokens cannot be forged without knowing PAYLOAD_SECRET
+ *
+ * @param args - Object containing tokenId
+ * @param args.tokenId - Unique identifier for the unsubscribe token
+ * @returns Base64URL-encoded token string in format: `{payload}.{signature}`
+ * @throws Error if PAYLOAD_SECRET environment variable is not defined
+ *
+ * @example
+ * ```typescript
+ * const token = generateUnsubscribeToken({ tokenId: 'uuid-1234' })
+ * // Returns: 'eyJ0b2tlbklkIjoidXVpZC0xMjM0IiwidGltZXN0YW1wIjoxNzAwMDAwMDAwfQ.abc123...'
+ * ```
+ */
+export declare function generateUnsubscribeToken(args: {
+    tokenId: string;
+}): string;
+/**
+ * Verifies an unsubscribe token and returns the decoded payload if valid.
+ *
+ * ## Verification Process
+ * 1. Splits token into payload and signature
+ * 2. Verifies HMAC signature using timing-safe comparison
+ * 3. Decodes and parses the JSON payload
+ * 4. Checks if token has expired (30 day limit)
+ *
+ * ## Security
+ * - Uses `crypto.timingSafeEqual()` to prevent timing attacks
+ * - Returns null for any invalid or expired token
+ * - Catches and handles all errors gracefully
+ *
+ * @param args - Object containing the token to verify
+ * @param args.token - The unsubscribe token to verify
+ * @returns Decoded token input with tokenId and timestamp if valid, null otherwise
+ * @throws Error if PAYLOAD_SECRET environment variable is not defined
+ *
+ * @example
+ * ```typescript
+ * const result = verifyUnsubscribeToken({ token: 'eyJ0b2...' })
+ * if (result) {
+ *   console.log(`Token ID: ${result.tokenId}, Created: ${new Date(result.timestamp)}`)
+ * } else {
+ *   console.log('Invalid or expired token')
+ * }
+ * ```
+ */
+export declare function verifyUnsubscribeToken(args: {
+    token: string;
+}): null | UnsubscribeToken;
+export {};

package/dist/utils/unsubscribe-token.js

@@ -0,0 +1,103 @@
+import crypto from 'crypto';
+const UNSUBSCRIBE_TOKEN_EXPIRATION = 30 * 24 * 60 * 60 * 1000 // 30 days in milliseconds
+;
+const HMAC_ALGORITHM = 'sha256';
+const TOKEN_ENCODING = 'base64url';
+/**
+ * Creates a secure unsubscribe token for the given token ID.
+ *
+ * ## Token Format
+ * The token consists of two parts separated by a dot:
+ * - Base64URL-encoded JSON payload containing tokenId and timestamp
+ * - HMAC-SHA256 signature of the payload
+ *
+ * ## Expiration
+ * Tokens expire after 30 days from creation
+ *
+ * ## Security Considerations
+ * - Tokens are signed with HMAC-SHA256 using PAYLOAD_SECRET
+ * - Verification uses timing-safe comparison to prevent timing attacks
+ * - Tokens cannot be forged without knowing PAYLOAD_SECRET
+ *
+ * @param args - Object containing tokenId
+ * @param args.tokenId - Unique identifier for the unsubscribe token
+ * @returns Base64URL-encoded token string in format: `{payload}.{signature}`
+ * @throws Error if PAYLOAD_SECRET environment variable is not defined
+ *
+ * @example
+ * ```typescript
+ * const token = generateUnsubscribeToken({ tokenId: 'uuid-1234' })
+ * // Returns: 'eyJ0b2tlbklkIjoidXVpZC0xMjM0IiwidGltZXN0YW1wIjoxNzAwMDAwMDAwfQ.abc123...'
+ * ```
+ */ export function generateUnsubscribeToken(args) {
+    const secret = process.env.PAYLOAD_SECRET;
+    if (!secret) {
+        throw new Error('PAYLOAD_SECRET environment variable is not defined');
+    }
+    const input = {
+        timestamp: Date.now(),
+        tokenId: args.tokenId
+    };
+    const inputBase64 = Buffer.from(JSON.stringify(input)).toString(TOKEN_ENCODING);
+    const hmac = crypto.createHmac(HMAC_ALGORITHM, secret);
+    hmac.update(inputBase64);
+    const signature = hmac.digest(TOKEN_ENCODING);
+    return `${inputBase64}.${signature}`;
+}
+/**
+ * Verifies an unsubscribe token and returns the decoded payload if valid.
+ *
+ * ## Verification Process
+ * 1. Splits token into payload and signature
+ * 2. Verifies HMAC signature using timing-safe comparison
+ * 3. Decodes and parses the JSON payload
+ * 4. Checks if token has expired (30 day limit)
+ *
+ * ## Security
+ * - Uses `crypto.timingSafeEqual()` to prevent timing attacks
+ * - Returns null for any invalid or expired token
+ * - Catches and handles all errors gracefully
+ *
+ * @param args - Object containing the token to verify
+ * @param args.token - The unsubscribe token to verify
+ * @returns Decoded token input with tokenId and timestamp if valid, null otherwise
+ * @throws Error if PAYLOAD_SECRET environment variable is not defined
+ *
+ * @example
+ * ```typescript
+ * const result = verifyUnsubscribeToken({ token: 'eyJ0b2...' })
+ * if (result) {
+ *   console.log(`Token ID: ${result.tokenId}, Created: ${new Date(result.timestamp)}`)
+ * } else {
+ *   console.log('Invalid or expired token')
+ * }
+ * ```
+ */ export function verifyUnsubscribeToken(args) {
+    try {
+        const secret = process.env.PAYLOAD_SECRET;
+        if (!secret) {
+            throw new Error('PAYLOAD_SECRET environment variable is not defined');
+        }
+        const parts = args.token.split('.');
+        if (parts.length !== 2) {
+            return null;
+        }
+        const [inputBase64, signature] = parts;
+        const hmac = crypto.createHmac(HMAC_ALGORITHM, secret);
+        hmac.update(inputBase64);
+        const expectedSignature = hmac.digest(TOKEN_ENCODING);
+        if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {
+            return null;
+        }
+        const inputJson = Buffer.from(inputBase64, TOKEN_ENCODING).toString('utf-8');
+        const input = JSON.parse(inputJson);
+        if (Date.now() - input.timestamp > UNSUBSCRIBE_TOKEN_EXPIRATION) {
+            return null;
+        }
+        return input;
+    } catch  {
+        return null;
+    }
+}
+
+//# sourceMappingURL=unsubscribe-token.js.map

package/dist/utils/unsubscribe-token.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/utils/unsubscribe-token.ts"],"sourcesContent":["import crypto from 'crypto'\n\nconst UNSUBSCRIBE_TOKEN_EXPIRATION = 30 * 24 * 60 * 60 * 1000 // 30 days in milliseconds\n\nconst HMAC_ALGORITHM = 'sha256'\n\nconst TOKEN_ENCODING = 'base64url'\n\ntype UnsubscribeToken = {\n  timestamp: number\n  tokenId: string\n}\n\n/**\n * Creates a secure unsubscribe token for the given token ID.\n *\n * ## Token Format\n * The token consists of two parts separated by a dot:\n * - Base64URL-encoded JSON payload containing tokenId and timestamp\n * - HMAC-SHA256 signature of the payload\n *\n * ## Expiration\n * Tokens expire after 30 days from creation\n *\n * ## Security Considerations\n * - Tokens are signed with HMAC-SHA256 using PAYLOAD_SECRET\n * - Verification uses timing-safe comparison to prevent timing attacks\n * - Tokens cannot be forged without knowing PAYLOAD_SECRET\n *\n * @param args - Object containing tokenId\n * @param args.tokenId - Unique identifier for the unsubscribe token\n * @returns Base64URL-encoded token string in format: `{payload}.{signature}`\n * @throws Error if PAYLOAD_SECRET environment variable is not defined\n *\n * @example\n * ```typescript\n * const token = generateUnsubscribeToken({ tokenId: 'uuid-1234' })\n * // Returns: 'eyJ0b2tlbklkIjoidXVpZC0xMjM0IiwidGltZXN0YW1wIjoxNzAwMDAwMDAwfQ.abc123...'\n * ```\n */\nexport function generateUnsubscribeToken(args: { tokenId: string }): string {\n  const secret = process.env.PAYLOAD_SECRET\n  if (!secret) {\n    throw new Error('PAYLOAD_SECRET environment variable is not defined')\n  }\n\n  const input: UnsubscribeToken = {\n    timestamp: Date.now(),\n    tokenId: args.tokenId,\n  }\n\n  const inputBase64 = Buffer.from(JSON.stringify(input)).toString(TOKEN_ENCODING)\n\n  const hmac = crypto.createHmac(HMAC_ALGORITHM, secret)\n  hmac.update(inputBase64)\n  const signature = hmac.digest(TOKEN_ENCODING)\n\n  return `${inputBase64}.${signature}`\n}\n\n/**\n * Verifies an unsubscribe token and returns the decoded payload if valid.\n *\n * ## Verification Process\n * 1. Splits token into payload and signature\n * 2. Verifies HMAC signature using timing-safe comparison\n * 3. Decodes and parses the JSON payload\n * 4. Checks if token has expired (30 day limit)\n *\n * ## Security\n * - Uses `crypto.timingSafeEqual()` to prevent timing attacks\n * - Returns null for any invalid or expired token\n * - Catches and handles all errors gracefully\n *\n * @param args - Object containing the token to verify\n * @param args.token - The unsubscribe token to verify\n * @returns Decoded token input with tokenId and timestamp if valid, null otherwise\n * @throws Error if PAYLOAD_SECRET environment variable is not defined\n *\n * @example\n * ```typescript\n * const result = verifyUnsubscribeToken({ token: 'eyJ0b2...' })\n * if (result) {\n *   console.log(`Token ID: ${result.tokenId}, Created: ${new Date(result.timestamp)}`)\n * } else {\n *   console.log('Invalid or expired token')\n * }\n * ```\n */\nexport function verifyUnsubscribeToken(args: { token: string }): null | UnsubscribeToken {\n  try {\n    const secret = process.env.PAYLOAD_SECRET\n    if (!secret) {\n      throw new Error('PAYLOAD_SECRET environment variable is not defined')\n    }\n\n    const parts = args.token.split('.')\n    if (parts.length !== 2) {\n      return null\n    }\n\n    const [inputBase64, signature] = parts\n\n    const hmac = crypto.createHmac(HMAC_ALGORITHM, secret)\n    hmac.update(inputBase64)\n    const expectedSignature = hmac.digest(TOKEN_ENCODING)\n\n    if (!crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expectedSignature))) {\n      return null\n    }\n\n    const inputJson = Buffer.from(inputBase64, TOKEN_ENCODING).toString('utf-8')\n    const input: UnsubscribeToken = JSON.parse(inputJson)\n\n    if (Date.now() - input.timestamp > UNSUBSCRIBE_TOKEN_EXPIRATION) {\n      return null\n    }\n\n    return input\n  } catch {\n    return null\n  }\n}\n"],"names":["crypto","UNSUBSCRIBE_TOKEN_EXPIRATION","HMAC_ALGORITHM","TOKEN_ENCODING","generateUnsubscribeToken","args","secret","process","env","PAYLOAD_SECRET","Error","input","timestamp","Date","now","tokenId","inputBase64","Buffer","from","JSON","stringify","toString","hmac","createHmac","update","signature","digest","verifyUnsubscribeToken","parts","token","split","length","expectedSignature","timingSafeEqual","inputJson","parse"],"mappings":"AAAA,OAAOA,YAAY,SAAQ;AAE3B,MAAMC,+BAA+B,KAAK,KAAK,KAAK,KAAK,KAAK,0BAA0B;;AAExF,MAAMC,iBAAiB;AAEvB,MAAMC,iBAAiB;AAOvB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BC,GACD,OAAO,SAASC,yBAAyBC,IAAyB;IAChE,MAAMC,SAASC,QAAQC,GAAG,CAACC,cAAc;IACzC,IAAI,CAACH,QAAQ;QACX,MAAM,IAAII,MAAM;IAClB;IAEA,MAAMC,QAA0B;QAC9BC,WAAWC,KAAKC,GAAG;QACnBC,SAASV,KAAKU,OAAO;IACvB;IAEA,MAAMC,cAAcC,OAAOC,IAAI,CAACC,KAAKC,SAAS,CAACT,QAAQU,QAAQ,CAAClB;IAEhE,MAAMmB,OAAOtB,OAAOuB,UAAU,CAACrB,gBAAgBI;IAC/CgB,KAAKE,MAAM,CAACR;IACZ,MAAMS,YAAYH,KAAKI,MAAM,CAACvB;IAE9B,OAAO,GAAGa,YAAY,CAAC,EAAES,WAAW;AACtC;AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA4BC,GACD,OAAO,SAASE,uBAAuBtB,IAAuB;IAC5D,IAAI;QACF,MAAMC,SAASC,QAAQC,GAAG,CAACC,cAAc;QACzC,IAAI,CAACH,QAAQ;YACX,MAAM,IAAII,MAAM;QAClB;QAEA,MAAMkB,QAAQvB,KAAKwB,KAAK,CAACC,KAAK,CAAC;QAC/B,IAAIF,MAAMG,MAAM,KAAK,GAAG;YACtB,OAAO;QACT;QAEA,MAAM,CAACf,aAAaS,UAAU,GAAGG;QAEjC,MAAMN,OAAOtB,OAAOuB,UAAU,CAACrB,gBAAgBI;QAC/CgB,KAAKE,MAAM,CAACR;QACZ,MAAMgB,oBAAoBV,KAAKI,MAAM,CAACvB;QAEtC,IAAI,CAACH,OAAOiC,eAAe,CAAChB,OAAOC,IAAI,CAACO,YAAYR,OAAOC,IAAI,CAACc,qBAAqB;YACnF,OAAO;QACT;QAEA,MAAME,YAAYjB,OAAOC,IAAI,CAACF,aAAab,gBAAgBkB,QAAQ,CAAC;QACpE,MAAMV,QAA0BQ,KAAKgB,KAAK,CAACD;QAE3C,IAAIrB,KAAKC,GAAG,KAAKH,MAAMC,SAAS,GAAGX,8BAA8B;YAC/D,OAAO;QACT;QAEA,OAAOU;IACT,EAAE,OAAM;QACN,OAAO;IACT;AACF"}