@mobilizehub/payload-plugin 0.1.0 → 0.3.0

package/dist/tasks/sendEmailTask.js

@@ -0,0 +1,167 @@
+import { formatFromAddress } from '../utils/email.js';
+import { parseLexicalContent } from '../utils/lexical.js';
+import { generateUnsubscribeToken } from '../utils/unsubscribe-token.js';
+/**
+ * Resolves collection slugs from plugin config, falling back to defaults.
+ */ function getCollectionSlugs(config) {
+    return {
+        broadcasts: config.broadcastsOverrides?.slug || 'broadcasts',
+        contacts: config.contactsOverrides?.slug || 'contacts',
+        emails: config.emailsOverrides?.slug || 'emails'
+    };
+}
+/**
+ * Checks if an email record already exists for a broadcast-contact pair.
+ */ async function checkEmailExists(payload, collection, broadcastId, contactId) {
+    const { docs } = await payload.find({
+        collection,
+        limit: 1,
+        where: {
+            and: [
+                {
+                    broadcast: {
+                        equals: broadcastId
+                    }
+                },
+                {
+                    contact: {
+                        equals: contactId
+                    }
+                }
+            ]
+        }
+    });
+    return docs[0] ?? null;
+}
+/**
+ * Creates the send-email task configuration.
+ *
+ * Handles delivery of a single email for one contact within a broadcast.
+ * Queued by the send-broadcasts task, one job per contact.
+ */ export const createSendEmailTask = (pluginConfig)=>{
+    const collections = getCollectionSlugs(pluginConfig);
+    return {
+        slug: 'send-email',
+        handler: async ({ input, req })=>{
+            const { payload } = req;
+            const logger = payload.logger;
+            const { broadcastId, contactId } = input;
+            // Skip if already processed (handles job retries)
+            const existingEmail = await checkEmailExists(payload, collections.emails, broadcastId, contactId);
+            if (existingEmail) {
+                logger.info(`Email already exists for broadcast ${broadcastId}, contact ${contactId} ` + `(email ID: ${existingEmail.id}, status: ${existingEmail.status})`);
+                return {
+                    output: {
+                        success: true
+                    }
+                };
+            }
+            const [contact, broadcast] = await Promise.all([
+                payload.findByID({
+                    id: contactId,
+                    collection: collections.contacts
+                }),
+                payload.findByID({
+                    id: broadcastId,
+                    collection: collections.broadcasts
+                })
+            ]);
+            if (!contact) {
+                throw new Error(`Contact ${contactId} not found`);
+            }
+            if (!broadcast) {
+                throw new Error(`Broadcast ${broadcastId} not found`);
+            }
+            const sender = pluginConfig.email({
+                payload
+            });
+            const fromAddress = formatFromAddress(broadcast.fromName, broadcast.fromAddress);
+            const tokenId = crypto.randomUUID();
+            const unsubscribeToken = generateUnsubscribeToken({
+                tokenId
+            });
+            const parsedContent = await parseLexicalContent(broadcast.content, payload.config);
+            const html = sender.render({
+                from: fromAddress,
+                html: parsedContent.html,
+                markdown: parsedContent.markdown,
+                plainText: parsedContent.plainText,
+                subject: broadcast.subject,
+                to: contact.email,
+                token: unsubscribeToken
+            });
+            const email = await payload.create({
+                collection: collections.emails,
+                data: {
+                    broadcast: broadcast.id,
+                    contact: contact.id,
+                    from: fromAddress,
+                    html,
+                    status: 'queued',
+                    subject: broadcast.subject,
+                    to: contact.email
+                }
+            });
+            await payload.create({
+                collection: 'emailUnsubscribeTokens',
+                data: {
+                    id: tokenId,
+                    emailId: email.id
+                }
+            });
+            const result = await sender.sendEmail({
+                from: fromAddress,
+                html,
+                idempotencyKey: `broadcast-${broadcastId}-contact-${contactId}`,
+                markdown: parsedContent.markdown,
+                plainText: parsedContent.plainText,
+                previewText: broadcast.previewText,
+                replyTo: broadcast.replyTo,
+                subject: broadcast.subject,
+                to: contact.email,
+                token: unsubscribeToken
+            });
+            await payload.update({
+                id: email.id,
+                collection: collections.emails,
+                data: {
+                    activity: [
+                        {
+                            type: 'sent',
+                            timestamp: new Date().toISOString()
+                        }
+                    ],
+                    providerId: result?.providerId,
+                    status: 'sent'
+                }
+            });
+            logger.info(`Sent email ${email.id} for broadcast ${broadcastId} to ${contact.email}`);
+            return {
+                output: {
+                    success: true
+                }
+            };
+        },
+        inputSchema: [
+            {
+                name: 'contactId',
+                type: 'number',
+                required: true
+            },
+            {
+                name: 'broadcastId',
+                type: 'number',
+                required: true
+            }
+        ],
+        outputSchema: [
+            {
+                name: 'success',
+                type: 'checkbox'
+            }
+        ],
+        retries: 3
+    };
+};
+
+//# sourceMappingURL=sendEmailTask.js.map

package/dist/tasks/sendEmailTask.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/tasks/sendEmailTask.ts"],"sourcesContent":["import type { SerializedEditorState } from '@payloadcms/richtext-lexical/lexical'\nimport type { BasePayload, TaskConfig } from 'payload'\n\nimport type { MobilizehubPluginConfig } from '../types/index.js'\n\nimport { formatFromAddress } from '../utils/email.js'\nimport { parseLexicalContent } from '../utils/lexical.js'\nimport { generateUnsubscribeToken } from '../utils/unsubscribe-token.js'\n\n/**\n * Resolves collection slugs from plugin config, falling back to defaults.\n */\nfunction getCollectionSlugs(config: MobilizehubPluginConfig) {\n  return {\n    broadcasts: config.broadcastsOverrides?.slug || 'broadcasts',\n    contacts: config.contactsOverrides?.slug || 'contacts',\n    emails: config.emailsOverrides?.slug || 'emails',\n  }\n}\n\n/**\n * Checks if an email record already exists for a broadcast-contact pair.\n */\nasync function checkEmailExists(\n  payload: BasePayload,\n  collection: string,\n  broadcastId: number | string,\n  contactId: number | string,\n) {\n  const { docs } = await payload.find({\n    collection,\n    limit: 1,\n    where: {\n      and: [{ broadcast: { equals: broadcastId } }, { contact: { equals: contactId } }],\n    },\n  })\n\n  return docs[0] ?? null\n}\n\n/**\n * Creates the send-email task configuration.\n *\n * Handles delivery of a single email for one contact within a broadcast.\n * Queued by the send-broadcasts task, one job per contact.\n */\nexport const createSendEmailTask = (pluginConfig: MobilizehubPluginConfig): TaskConfig => {\n  const collections = getCollectionSlugs(pluginConfig)\n\n  return {\n    slug: 'send-email',\n    handler: async ({ input, req }) => {\n      const { payload } = req\n      const logger = payload.logger\n\n      const { broadcastId, contactId } = input as { broadcastId: number; contactId: number }\n\n      // Skip if already processed (handles job retries)\n      const existingEmail = await checkEmailExists(\n        payload,\n        collections.emails,\n        broadcastId,\n        contactId,\n      )\n\n      if (existingEmail) {\n        logger.info(\n          `Email already exists for broadcast ${broadcastId}, contact ${contactId} ` +\n            `(email ID: ${existingEmail.id}, status: ${existingEmail.status})`,\n        )\n        return { output: { success: true } }\n      }\n\n      const [contact, broadcast] = await Promise.all([\n        payload.findByID({ id: contactId, collection: collections.contacts }),\n        payload.findByID({ id: broadcastId, collection: collections.broadcasts }),\n      ])\n\n      if (!contact) {\n        throw new Error(`Contact ${contactId} not found`)\n      }\n      if (!broadcast) {\n        throw new Error(`Broadcast ${broadcastId} not found`)\n      }\n\n      const sender = pluginConfig.email({ payload })\n      const fromAddress = formatFromAddress(broadcast.fromName, broadcast.fromAddress)\n\n      const tokenId = crypto.randomUUID()\n      const unsubscribeToken = generateUnsubscribeToken({ tokenId })\n\n      const parsedContent = await parseLexicalContent(\n        broadcast.content as SerializedEditorState,\n        payload.config,\n      )\n\n      const html = sender.render({\n        from: fromAddress,\n        html: parsedContent.html,\n        markdown: parsedContent.markdown,\n        plainText: parsedContent.plainText,\n        subject: broadcast.subject,\n        to: contact.email,\n        token: unsubscribeToken,\n      })\n\n      const email = await payload.create({\n        collection: collections.emails,\n        data: {\n          broadcast: broadcast.id,\n          contact: contact.id,\n          from: fromAddress,\n          html,\n          status: 'queued',\n          subject: broadcast.subject,\n          to: contact.email,\n        },\n      })\n\n      await payload.create({\n        collection: 'emailUnsubscribeTokens',\n        data: { id: tokenId, emailId: email.id },\n      })\n\n      const result = await sender.sendEmail({\n        from: fromAddress,\n        html,\n        idempotencyKey: `broadcast-${broadcastId}-contact-${contactId}`,\n        markdown: parsedContent.markdown,\n        plainText: parsedContent.plainText,\n        previewText: broadcast.previewText,\n        replyTo: broadcast.replyTo,\n        subject: broadcast.subject,\n        to: contact.email,\n        token: unsubscribeToken,\n      })\n\n      await payload.update({\n        id: email.id,\n        collection: collections.emails,\n        data: {\n          activity: [{ type: 'sent', timestamp: new Date().toISOString() }],\n          providerId: result?.providerId,\n          status: 'sent',\n        },\n      })\n\n      logger.info(`Sent email ${email.id} for broadcast ${broadcastId} to ${contact.email}`)\n\n      return { output: { success: true } }\n    },\n    inputSchema: [\n      { name: 'contactId', type: 'number', required: true },\n      { name: 'broadcastId', type: 'number', required: true },\n    ],\n    outputSchema: [{ name: 'success', type: 'checkbox' }],\n    retries: 3,\n  }\n}\n"],"names":["formatFromAddress","parseLexicalContent","generateUnsubscribeToken","getCollectionSlugs","config","broadcasts","broadcastsOverrides","slug","contacts","contactsOverrides","emails","emailsOverrides","checkEmailExists","payload","collection","broadcastId","contactId","docs","find","limit","where","and","broadcast","equals","contact","createSendEmailTask","pluginConfig","collections","handler","input","req","logger","existingEmail","info","id","status","output","success","Promise","all","findByID","Error","sender","email","fromAddress","fromName","tokenId","crypto","randomUUID","unsubscribeToken","parsedContent","content","html","render","from","markdown","plainText","subject","to","token","create","data","emailId","result","sendEmail","idempotencyKey","previewText","replyTo","update","activity","type","timestamp","Date","toISOString","providerId","inputSchema","name","required","outputSchema","retries"],"mappings":"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"}

package/dist/types/index.d.ts

@@ -1,12 +1,144 @@
-import type { CollectionConfig, Field } from 'payload';
+import type { BasePayload, Block, CollectionConfig, Field, PayloadRequest } from 'payload';
 export type FieldsOverride = (args: {
     defaultFields: Field[];
 }) => Field[];
 export type CollectionOverride = {
     fields?: FieldsOverride;
 } & Partial<Omit<CollectionConfig, 'fields'>>;
+export type BlocksOverride = (args: {
+    defaultBlocks: Block[];
+}) => Block[];
+/**
+ * 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 pages collection
+     */
+    pagesOverrides?: {
+        blocks?: BlocksOverride;
+    } & 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, Block, 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\nexport type BlocksOverride = (args: { defaultBlocks: Block[] }) => Block[]\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 pages collection\n   */\n  pagesOverrides?: { blocks?: BlocksOverride } & CollectionOverride\n  /**\n   * Overrides for the tags collection\n   */\n  tagsOverrides?: CollectionOverride\n  /**\n   *\n   */\n}\n"],"names":[],"mappings":"AA4GA,WAyDC"}

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"}