@quatrain/messaging 1.0.3 → 1.0.5

package/LICENSE.md

@@ -0,0 +1,15 @@
+# LICENSE UPDATE NOTICE
+
+As of 01/01/2026, Quatrain Core is licensed under the **GNU Affero General Public License v3.0 (AGPL v3)**.
+Previous versions remain under the MIT License.
+
+## Why AGPL?
+
+We believe in open collaboration for the development ecosystem. The AGPL ensures that any modification or deployment of this BaaS stack, including over a network, benefits the entire community.
+
+## Commercial Services & Enterprise Usage
+
+We provide official deployment services, technical training, and certification for Quatrain Core.
+For organizations requiring a non-copyleft license (commercial license) or custom proprietary integrations, please contact the copyright holder: **Quatrain Technologies**.
+
+Copyright © 2024-2026 Quatrain Technologies. All Rights Reserved.

package/dist/Messaging.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/Messaging.test.js

@@ -0,0 +1,258 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Messaging_1 = require("./Messaging");
+const MockMessagingAdapter_1 = require("./MockMessagingAdapter");
+describe('Messaging', () => {
+    let mockAdapter1;
+    let mockAdapter2;
+    beforeEach(() => {
+        // Reset messagers before each test
+        ;
+        Messaging_1.Messaging._messagers = {};
+        Messaging_1.Messaging.defaultMessager = 'default';
+        // Create fresh mock adapters
+        mockAdapter1 = new MockMessagingAdapter_1.MockMessagingAdapter({ debug: false });
+        mockAdapter2 = new MockMessagingAdapter_1.MockMessagingAdapter({ debug: false });
+    });
+    afterEach(() => {
+        // Clean up
+        mockAdapter1 === null || mockAdapter1 === void 0 ? void 0 : mockAdapter1.clearMessages();
+        mockAdapter2 === null || mockAdapter2 === void 0 ? void 0 : mockAdapter2.clearMessages();
+    });
+    describe('addMessager', () => {
+        it('should add a messager with an alias', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test-messager');
+            const messager = Messaging_1.Messaging.getMessager('test-messager');
+            expect(messager).toBe(mockAdapter1);
+        });
+        it('should add multiple messagers with different aliases', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'messager1');
+            Messaging_1.Messaging.addMessager(mockAdapter2, 'messager2');
+            const messager1 = Messaging_1.Messaging.getMessager('messager1');
+            const messager2 = Messaging_1.Messaging.getMessager('messager2');
+            expect(messager1).toBe(mockAdapter1);
+            expect(messager2).toBe(mockAdapter2);
+        });
+        it('should set default messager when setDefault is true', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'custom-messager', true);
+            expect(Messaging_1.Messaging.defaultMessager).toBe('custom-messager');
+            const messager = Messaging_1.Messaging.getMessager(); // Should use default
+            expect(messager).toBe(mockAdapter1);
+        });
+        it('should not change default messager when setDefault is false', () => {
+            const originalDefault = Messaging_1.Messaging.defaultMessager;
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'custom-messager', false);
+            expect(Messaging_1.Messaging.defaultMessager).toBe(originalDefault);
+        });
+        it('should allow overriding an existing messager', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'messager');
+            Messaging_1.Messaging.addMessager(mockAdapter2, 'messager');
+            const messager = Messaging_1.Messaging.getMessager('messager');
+            expect(messager).toBe(mockAdapter2);
+        });
+    });
+    describe('getMessager', () => {
+        it('should return the correct messager by alias', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test-messager');
+            const messager = Messaging_1.Messaging.getMessager('test-messager');
+            expect(messager).toBe(mockAdapter1);
+        });
+        it('should return the default messager when no alias is specified', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'default', true);
+            const messager = Messaging_1.Messaging.getMessager();
+            expect(messager).toBe(mockAdapter1);
+        });
+        it('should throw error when messager alias does not exist', () => {
+            expect(() => {
+                Messaging_1.Messaging.getMessager('non-existent');
+            }).toThrow("Unknown messager alias: 'non-existent'");
+        });
+        it('should throw error when getting default messager that does not exist', () => {
+            expect(() => {
+                Messaging_1.Messaging.getMessager();
+            }).toThrow("Unknown messager alias: 'default'");
+        });
+    });
+    describe('defaultMessager property', () => {
+        it('should have a default value of "default"', () => {
+            expect(Messaging_1.Messaging.defaultMessager).toBe('default');
+        });
+        it('should allow changing the default messager', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'new-default', true);
+            expect(Messaging_1.Messaging.defaultMessager).toBe('new-default');
+        });
+    });
+    describe('Integration with MockMessagingAdapter - Notifications', () => {
+        const recipient = {
+            firstname: 'John',
+            lastname: 'Doe',
+            email: 'john@example.com',
+            messageToken: 'test-token-123',
+        };
+        const message = {
+            title: 'Test Notification',
+            body: 'This is a test',
+        };
+        it('should send single notification', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const result = yield messager.sendNotification(recipient, message);
+            expect(result.success).toBe(true);
+            expect(result.messageId).toMatch(/^notif-/);
+            expect(messager.getMessageCount('notification')).toBe(1);
+        }));
+        it('should send batch notifications', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const recipients = [
+                recipient,
+                Object.assign(Object.assign({}, recipient), { email: 'jane@example.com' }),
+            ];
+            const result = yield messager.sendNotifications(recipients, message);
+            expect(result.success).toBe(true);
+            expect(result.count).toBe(2);
+            expect(messager.getMessageCount('notification')).toBe(1); // One batch
+        }));
+    });
+    describe('Integration with MockMessagingAdapter - Emails', () => {
+        const recipient = {
+            firstname: 'John',
+            lastname: 'Doe',
+            email: 'john@example.com',
+            messageToken: 'test-token-123',
+        };
+        const message = {
+            title: 'Test Email',
+            body: 'This is a test email',
+        };
+        it('should send single email', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const result = yield messager.sendEmail(recipient, message);
+            expect(result.success).toBe(true);
+            expect(result.messageId).toMatch(/^email-/);
+            expect(messager.getMessageCount('email')).toBe(1);
+        }));
+        it('should send batch emails', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const recipients = [
+                recipient,
+                Object.assign(Object.assign({}, recipient), { email: 'jane@example.com' }),
+            ];
+            const result = yield messager.sendEmails(recipients, message);
+            expect(result.success).toBe(true);
+            expect(result.count).toBe(2);
+            expect(messager.getMessageCount('email')).toBe(1); // One batch
+        }));
+    });
+    describe('Integration with MockMessagingAdapter - Text Messages', () => {
+        const recipient = {
+            firstname: 'John',
+            lastname: 'Doe',
+            email: 'john@example.com',
+            messageToken: 'test-token-123',
+        };
+        const message = {
+            title: 'Test SMS',
+            body: 'This is a test SMS',
+        };
+        it('should send single text message', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const result = yield messager.sendTextMessage(recipient, message);
+            expect(result.success).toBe(true);
+            expect(result.messageId).toMatch(/^text-/);
+            expect(messager.getMessageCount('text')).toBe(1);
+        }));
+        it('should send batch text messages', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const recipients = [
+                recipient,
+                Object.assign(Object.assign({}, recipient), { email: 'jane@example.com' }),
+            ];
+            const result = yield messager.sendTextMessages(recipients, message);
+            expect(result.success).toBe(true);
+            expect(result.count).toBe(2);
+            expect(messager.getMessageCount('text')).toBe(1); // One batch
+        }));
+    });
+    describe('Integration - Multiple message types', () => {
+        it('should maintain separate state between messagers', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'messager1');
+            Messaging_1.Messaging.addMessager(mockAdapter2, 'messager2');
+            const adapter1 = Messaging_1.Messaging.getMessager('messager1');
+            const adapter2 = Messaging_1.Messaging.getMessager('messager2');
+            const recipient = {
+                firstname: 'Test',
+                lastname: 'User',
+                email: 'test@example.com',
+                messageToken: 'test-token-123',
+            };
+            const message = {
+                title: 'Test',
+                body: 'Test message',
+            };
+            yield adapter1.sendNotification(recipient, message);
+            yield adapter2.sendEmail(recipient, message);
+            expect(adapter1.getMessageCount('notification')).toBe(1);
+            expect(adapter1.getMessageCount('email')).toBe(0);
+            expect(adapter2.getMessageCount('email')).toBe(1);
+            expect(adapter2.getMessageCount('notification')).toBe(0);
+        }));
+        it('should track different message types', () => __awaiter(void 0, void 0, void 0, function* () {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'test');
+            const messager = Messaging_1.Messaging.getMessager('test');
+            const recipient = {
+                firstname: 'Test',
+                lastname: 'User',
+                email: 'test@example.com',
+                messageToken: 'test-token-123',
+            };
+            const message = {
+                title: 'Test',
+                body: 'Test message',
+            };
+            yield messager.sendNotification(recipient, message);
+            yield messager.sendEmail(recipient, message);
+            yield messager.sendTextMessage(recipient, message);
+            expect(messager.getMessageCount()).toBe(3);
+            expect(messager.getMessageCount('notification')).toBe(1);
+            expect(messager.getMessageCount('email')).toBe(1);
+            expect(messager.getMessageCount('text')).toBe(1);
+        }));
+    });
+    describe('Messaging registry behavior', () => {
+        it('should maintain messagers across multiple operations', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'persistent');
+            // Multiple get operations
+            const messager1 = Messaging_1.Messaging.getMessager('persistent');
+            const messager2 = Messaging_1.Messaging.getMessager('persistent');
+            expect(messager1).toBe(messager2);
+            expect(messager1).toBe(mockAdapter1);
+        });
+        it('should handle switching default messager multiple times', () => {
+            Messaging_1.Messaging.addMessager(mockAdapter1, 'messager1', true);
+            expect(Messaging_1.Messaging.defaultMessager).toBe('messager1');
+            Messaging_1.Messaging.addMessager(mockAdapter2, 'messager2', true);
+            expect(Messaging_1.Messaging.defaultMessager).toBe('messager2');
+            const defaultMessager = Messaging_1.Messaging.getMessager();
+            expect(defaultMessager).toBe(mockAdapter2);
+        });
+    });
+    describe('logger', () => {
+        it('should have a logger instance', () => {
+            expect(Messaging_1.Messaging.logger).toBeDefined();
+        });
+    });
+});

package/dist/MockMessagingAdapter.d.ts

@@ -0,0 +1,32 @@
+import { AbstractMessagingAdapter } from './AbstractMessagingAdapter';
+import { NotificationCapableAdapter } from './types/NotificationCapableAdapter';
+import { EmailCapableAdapter } from './types/EmailCapableAdapter';
+import { TextCapableAdapter } from './types/TextCapableAdapter';
+import { MessagingRecipient } from './types/MessagingRecipient';
+import { NotificationMessage } from './types/NotificationMessage';
+import { MessagingParameters } from './Messaging';
+interface SentMessage {
+    type: 'notification' | 'email' | 'text';
+    recipient: MessagingRecipient | MessagingRecipient[];
+    message: NotificationMessage;
+    timestamp: number;
+}
+/**
+ * Mock Messaging Adapter for testing purposes
+ * Implements all three capability interfaces
+ */
+export declare class MockMessagingAdapter extends AbstractMessagingAdapter implements NotificationCapableAdapter, EmailCapableAdapter, TextCapableAdapter {
+    private sentMessages;
+    constructor(params?: MessagingParameters);
+    sendNotification(recipient: MessagingRecipient, message: NotificationMessage): Promise<any>;
+    sendNotifications(recipients: MessagingRecipient[], message: NotificationMessage): Promise<any>;
+    sendEmail(recipient: MessagingRecipient, message: NotificationMessage): Promise<any>;
+    sendEmails(recipients: MessagingRecipient[], message: NotificationMessage): Promise<any>;
+    sendTextMessage(recipient: MessagingRecipient, message: NotificationMessage): Promise<any>;
+    sendTextMessages(recipients: MessagingRecipient[], message: NotificationMessage): Promise<any>;
+    getSentMessages(type?: 'notification' | 'email' | 'text'): SentMessage[];
+    clearMessages(): void;
+    getMessageCount(type?: 'notification' | 'email' | 'text'): number;
+    getLastMessage(type?: 'notification' | 'email' | 'text'): SentMessage | undefined;
+}
+export {};

package/dist/MockMessagingAdapter.js

@@ -0,0 +1,131 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockMessagingAdapter = void 0;
+const AbstractMessagingAdapter_1 = require("./AbstractMessagingAdapter");
+/**
+ * Mock Messaging Adapter for testing purposes
+ * Implements all three capability interfaces
+ */
+class MockMessagingAdapter extends AbstractMessagingAdapter_1.AbstractMessagingAdapter {
+    constructor(params = {}) {
+        super(params);
+        this.sentMessages = [];
+    }
+    sendNotification(recipient, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sentMessages.push({
+                type: 'notification',
+                recipient,
+                message,
+                timestamp: Date.now(),
+            });
+            return {
+                success: true,
+                messageId: `notif-${Date.now()}`,
+                recipient: recipient.email,
+            };
+        });
+    }
+    sendNotifications(recipients, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sentMessages.push({
+                type: 'notification',
+                recipient: recipients,
+                message,
+                timestamp: Date.now(),
+            });
+            return {
+                success: true,
+                count: recipients.length,
+                messageIds: recipients.map((r, i) => `notif-batch-${Date.now()}-${i}`),
+            };
+        });
+    }
+    sendEmail(recipient, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sentMessages.push({
+                type: 'email',
+                recipient,
+                message,
+                timestamp: Date.now(),
+            });
+            return {
+                success: true,
+                messageId: `email-${Date.now()}`,
+                recipient: recipient.email,
+            };
+        });
+    }
+    sendEmails(recipients, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sentMessages.push({
+                type: 'email',
+                recipient: recipients,
+                message,
+                timestamp: Date.now(),
+            });
+            return {
+                success: true,
+                count: recipients.length,
+                messageIds: recipients.map((r, i) => `email-batch-${Date.now()}-${i}`),
+            };
+        });
+    }
+    sendTextMessage(recipient, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sentMessages.push({
+                type: 'text',
+                recipient,
+                message,
+                timestamp: Date.now(),
+            });
+            return {
+                success: true,
+                messageId: `text-${Date.now()}`,
+                recipient: recipient.email,
+            };
+        });
+    }
+    sendTextMessages(recipients, message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.sentMessages.push({
+                type: 'text',
+                recipient: recipients,
+                message,
+                timestamp: Date.now(),
+            });
+            return {
+                success: true,
+                count: recipients.length,
+                messageIds: recipients.map((r, i) => `text-batch-${Date.now()}-${i}`),
+            };
+        });
+    }
+    // Helper methods for testing
+    getSentMessages(type) {
+        if (type) {
+            return this.sentMessages.filter((msg) => msg.type === type);
+        }
+        return this.sentMessages;
+    }
+    clearMessages() {
+        this.sentMessages = [];
+    }
+    getMessageCount(type) {
+        return this.getSentMessages(type).length;
+    }
+    getLastMessage(type) {
+        const messages = this.getSentMessages(type);
+        return messages[messages.length - 1];
+    }
+}
+exports.MockMessagingAdapter = MockMessagingAdapter;

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "@quatrain/messaging",
-  "version": "1.0.3",
-  "license": "MIT",
+  "version": "1.0.5",
+  "license": "AGPL-3.0-only",
   "description": "Messaging adapters commons",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bun": "src/index.ts",
   "files": [
-    "lib/",
+    "LICENSE.md",
+    "src/",
+    "dist/",
     "README.md"
   ],
   "author": "Quatrain Développement SAS <developers@quatrain.com>",
   "dependencies": {
-    "@quatrain/core": "^1.1.19",
+    "@quatrain/core": "^1.1.45",
     "mustache": "^4.2.0"
   },
   "devDependencies": {
@@ -19,7 +22,7 @@
     "@types/jest": "^27.0.3",
     "@types/mustache": "^4",
     "@types/node": "^22.10.1",
-    "jest": "^27.4.7",
+    "jest": "^30.2.0",
     "jest-node-exports-resolver": "^1.1.6",
     "jest-serial-runner": "^1.2.1",
     "trace-unhandled": "^2.0.1",
@@ -31,11 +34,6 @@
     "test-ci": "jest --runInBand",
     "build": "tsc",
     "wbuild": "tsc --watch",
-    "bump-to": "yarn version",
-    "hash": "node ../../bin/hashFolder.js",
-    "hash:persist": "yarn hash  > .hash_latest.txt",
-    "hash:compare": "yarn hash > .hash_newest.txt && cmp -s .hash_latest.txt .hash_newest.txt",
-    "publish": "yarn hash:compare || yarn publish:process",
-    "publish:process": "yarn version patch && yarn build && yarn npm publish --access public && yarn hash:persist"
+    "bump-to": "yarn version"
   }
 }

package/src/AbstractMessagingAdapter.ts

@@ -0,0 +1,9 @@
+import { MessagingParameters } from './Messaging'
+
+export abstract class AbstractMessagingAdapter {
+   protected _params: MessagingParameters = {}
+
+   constructor(params: MessagingParameters = {}) {
+      this._params = params
+   }
+}

package/src/MessageFormatter.ts

@@ -0,0 +1,11 @@
+import Mustache from 'mustache'
+
+export class MessageFormatter {
+   static formatTitle(title: string) {
+      return title.replace(/(<([^>]+)>)/gi, '')
+   }
+
+   static formatBody(body: string, data?: {}) {
+      return Mustache.render(body, data)
+   }
+}

package/src/Messaging.test.ts

@@ -0,0 +1,318 @@
+import { Messaging, MessagingParameters } from './Messaging'
+import { MockMessagingAdapter } from './MockMessagingAdapter'
+import { MessagingRecipient } from './types/MessagingRecipient'
+import { NotificationMessage } from './types/NotificationMessage'
+
+describe('Messaging', () => {
+   let mockAdapter1: MockMessagingAdapter
+   let mockAdapter2: MockMessagingAdapter
+
+   beforeEach(() => {
+      // Reset messagers before each test
+      ;(Messaging as any)._messagers = {}
+      Messaging.defaultMessager = 'default'
+
+      // Create fresh mock adapters
+      mockAdapter1 = new MockMessagingAdapter({ debug: false })
+      mockAdapter2 = new MockMessagingAdapter({ debug: false })
+   })
+
+   afterEach(() => {
+      // Clean up
+      mockAdapter1?.clearMessages()
+      mockAdapter2?.clearMessages()
+   })
+
+   describe('addMessager', () => {
+      it('should add a messager with an alias', () => {
+         Messaging.addMessager(mockAdapter1, 'test-messager')
+
+         const messager = Messaging.getMessager('test-messager')
+         expect(messager).toBe(mockAdapter1)
+      })
+
+      it('should add multiple messagers with different aliases', () => {
+         Messaging.addMessager(mockAdapter1, 'messager1')
+         Messaging.addMessager(mockAdapter2, 'messager2')
+
+         const messager1 = Messaging.getMessager('messager1')
+         const messager2 = Messaging.getMessager('messager2')
+
+         expect(messager1).toBe(mockAdapter1)
+         expect(messager2).toBe(mockAdapter2)
+      })
+
+      it('should set default messager when setDefault is true', () => {
+         Messaging.addMessager(mockAdapter1, 'custom-messager', true)
+
+         expect(Messaging.defaultMessager).toBe('custom-messager')
+         const messager = Messaging.getMessager() // Should use default
+         expect(messager).toBe(mockAdapter1)
+      })
+
+      it('should not change default messager when setDefault is false', () => {
+         const originalDefault = Messaging.defaultMessager
+         Messaging.addMessager(mockAdapter1, 'custom-messager', false)
+
+         expect(Messaging.defaultMessager).toBe(originalDefault)
+      })
+
+      it('should allow overriding an existing messager', () => {
+         Messaging.addMessager(mockAdapter1, 'messager')
+         Messaging.addMessager(mockAdapter2, 'messager')
+
+         const messager = Messaging.getMessager('messager')
+         expect(messager).toBe(mockAdapter2)
+      })
+   })
+
+   describe('getMessager', () => {
+      it('should return the correct messager by alias', () => {
+         Messaging.addMessager(mockAdapter1, 'test-messager')
+
+         const messager = Messaging.getMessager('test-messager')
+         expect(messager).toBe(mockAdapter1)
+      })
+
+      it('should return the default messager when no alias is specified', () => {
+         Messaging.addMessager(mockAdapter1, 'default', true)
+
+         const messager = Messaging.getMessager()
+         expect(messager).toBe(mockAdapter1)
+      })
+
+      it('should throw error when messager alias does not exist', () => {
+         expect(() => {
+            Messaging.getMessager('non-existent')
+         }).toThrow("Unknown messager alias: 'non-existent'")
+      })
+
+      it('should throw error when getting default messager that does not exist', () => {
+         expect(() => {
+            Messaging.getMessager()
+         }).toThrow("Unknown messager alias: 'default'")
+      })
+   })
+
+   describe('defaultMessager property', () => {
+      it('should have a default value of "default"', () => {
+         expect(Messaging.defaultMessager).toBe('default')
+      })
+
+      it('should allow changing the default messager', () => {
+         Messaging.addMessager(mockAdapter1, 'new-default', true)
+         expect(Messaging.defaultMessager).toBe('new-default')
+      })
+   })
+
+   describe('Integration with MockMessagingAdapter - Notifications', () => {
+      const recipient: MessagingRecipient = {
+         firstname: 'John',
+         lastname: 'Doe',
+         email: 'john@example.com',
+         messageToken: 'test-token-123',
+      }
+
+      const message: NotificationMessage = {
+         title: 'Test Notification',
+         body: 'This is a test',
+      }
+
+      it('should send single notification', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const result = await messager.sendNotification(recipient, message)
+
+         expect(result.success).toBe(true)
+         expect(result.messageId).toMatch(/^notif-/)
+         expect(messager.getMessageCount('notification')).toBe(1)
+      })
+
+      it('should send batch notifications', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const recipients = [
+            recipient,
+            { ...recipient, email: 'jane@example.com' },
+         ]
+         const result = await messager.sendNotifications(recipients, message)
+
+         expect(result.success).toBe(true)
+         expect(result.count).toBe(2)
+         expect(messager.getMessageCount('notification')).toBe(1) // One batch
+      })
+   })
+
+   describe('Integration with MockMessagingAdapter - Emails', () => {
+      const recipient: MessagingRecipient = {
+         firstname: 'John',
+         lastname: 'Doe',
+         email: 'john@example.com',
+         messageToken: 'test-token-123',
+      }
+
+      const message: NotificationMessage = {
+         title: 'Test Email',
+         body: 'This is a test email',
+      }
+
+      it('should send single email', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const result = await messager.sendEmail(recipient, message)
+
+         expect(result.success).toBe(true)
+         expect(result.messageId).toMatch(/^email-/)
+         expect(messager.getMessageCount('email')).toBe(1)
+      })
+
+      it('should send batch emails', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const recipients = [
+            recipient,
+            { ...recipient, email: 'jane@example.com' },
+         ]
+         const result = await messager.sendEmails(recipients, message)
+
+         expect(result.success).toBe(true)
+         expect(result.count).toBe(2)
+         expect(messager.getMessageCount('email')).toBe(1) // One batch
+      })
+   })
+
+   describe('Integration with MockMessagingAdapter - Text Messages', () => {
+      const recipient: MessagingRecipient = {
+         firstname: 'John',
+         lastname: 'Doe',
+         email: 'john@example.com',
+         messageToken: 'test-token-123',
+      }
+
+      const message: NotificationMessage = {
+         title: 'Test SMS',
+         body: 'This is a test SMS',
+      }
+
+      it('should send single text message', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const result = await messager.sendTextMessage(recipient, message)
+
+         expect(result.success).toBe(true)
+         expect(result.messageId).toMatch(/^text-/)
+         expect(messager.getMessageCount('text')).toBe(1)
+      })
+
+      it('should send batch text messages', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const recipients = [
+            recipient,
+            { ...recipient, email: 'jane@example.com' },
+         ]
+         const result = await messager.sendTextMessages(recipients, message)
+
+         expect(result.success).toBe(true)
+         expect(result.count).toBe(2)
+         expect(messager.getMessageCount('text')).toBe(1) // One batch
+      })
+   })
+
+   describe('Integration - Multiple message types', () => {
+      it('should maintain separate state between messagers', async () => {
+         Messaging.addMessager(mockAdapter1, 'messager1')
+         Messaging.addMessager(mockAdapter2, 'messager2')
+
+         const adapter1 = Messaging.getMessager(
+            'messager1'
+         ) as MockMessagingAdapter
+         const adapter2 = Messaging.getMessager(
+            'messager2'
+         ) as MockMessagingAdapter
+
+         const recipient: MessagingRecipient = {
+            firstname: 'Test',
+            lastname: 'User',
+            email: 'test@example.com',
+            messageToken: 'test-token-123',
+         }
+
+         const message: NotificationMessage = {
+            title: 'Test',
+            body: 'Test message',
+         }
+
+         await adapter1.sendNotification(recipient, message)
+         await adapter2.sendEmail(recipient, message)
+
+         expect(adapter1.getMessageCount('notification')).toBe(1)
+         expect(adapter1.getMessageCount('email')).toBe(0)
+
+         expect(adapter2.getMessageCount('email')).toBe(1)
+         expect(adapter2.getMessageCount('notification')).toBe(0)
+      })
+
+      it('should track different message types', async () => {
+         Messaging.addMessager(mockAdapter1, 'test')
+         const messager = Messaging.getMessager('test') as MockMessagingAdapter
+
+         const recipient: MessagingRecipient = {
+            firstname: 'Test',
+            lastname: 'User',
+            email: 'test@example.com',
+            messageToken: 'test-token-123',
+         }
+
+         const message: NotificationMessage = {
+            title: 'Test',
+            body: 'Test message',
+         }
+
+         await messager.sendNotification(recipient, message)
+         await messager.sendEmail(recipient, message)
+         await messager.sendTextMessage(recipient, message)
+
+         expect(messager.getMessageCount()).toBe(3)
+         expect(messager.getMessageCount('notification')).toBe(1)
+         expect(messager.getMessageCount('email')).toBe(1)
+         expect(messager.getMessageCount('text')).toBe(1)
+      })
+   })
+
+   describe('Messaging registry behavior', () => {
+      it('should maintain messagers across multiple operations', () => {
+         Messaging.addMessager(mockAdapter1, 'persistent')
+
+         // Multiple get operations
+         const messager1 = Messaging.getMessager('persistent')
+         const messager2 = Messaging.getMessager('persistent')
+
+         expect(messager1).toBe(messager2)
+         expect(messager1).toBe(mockAdapter1)
+      })
+
+      it('should handle switching default messager multiple times', () => {
+         Messaging.addMessager(mockAdapter1, 'messager1', true)
+         expect(Messaging.defaultMessager).toBe('messager1')
+
+         Messaging.addMessager(mockAdapter2, 'messager2', true)
+         expect(Messaging.defaultMessager).toBe('messager2')
+
+         const defaultMessager = Messaging.getMessager()
+         expect(defaultMessager).toBe(mockAdapter2)
+      })
+   })
+
+   describe('logger', () => {
+      it('should have a logger instance', () => {
+         expect(Messaging.logger).toBeDefined()
+      })
+   })
+})

package/src/Messaging.ts

@@ -0,0 +1,44 @@
+import { Core } from '@quatrain/core'
+import { NotificationCapableAdapter } from './types/NotificationCapableAdapter'
+import { EmailCapableAdapter } from './types/EmailCapableAdapter'
+import { TextCapableAdapter } from './types/TextCapableAdapter'
+
+export type MessagingRegistry<T extends NotificationCapableAdapter
+         | EmailCapableAdapter
+         | TextCapableAdapter> = {
+   [x: string]: T
+}
+
+export interface MessagingParameters {
+   config?: any
+   debug?: boolean
+}
+
+export class Messaging extends Core {
+   static defaultMessager = 'default'
+   static logger = this.addLogger('Messaging')
+
+   protected static _messagers: MessagingRegistry<any> = {}
+
+   static addMessager(
+      messager:
+         | NotificationCapableAdapter
+         | EmailCapableAdapter
+         | TextCapableAdapter,
+      alias: string,
+      setDefault: boolean = false
+   ) {
+      this._messagers[alias] = messager
+      if (setDefault) {
+         this.defaultMessager = alias
+      }
+   }
+
+   static getMessager(alias: string = this.defaultMessager) {
+      if (this._messagers[alias]) {
+         return this._messagers[alias]
+      } else {
+         throw new Error(`Unknown messager alias: '${alias}'`)
+      }
+   }
+}

package/src/MockMessagingAdapter.ts

@@ -0,0 +1,163 @@
+import { AbstractMessagingAdapter } from './AbstractMessagingAdapter'
+import { NotificationCapableAdapter } from './types/NotificationCapableAdapter'
+import { EmailCapableAdapter } from './types/EmailCapableAdapter'
+import { TextCapableAdapter } from './types/TextCapableAdapter'
+import { MessagingRecipient } from './types/MessagingRecipient'
+import { NotificationMessage } from './types/NotificationMessage'
+import { MessagingParameters } from './Messaging'
+
+interface SentMessage {
+   type: 'notification' | 'email' | 'text'
+   recipient: MessagingRecipient | MessagingRecipient[]
+   message: NotificationMessage
+   timestamp: number
+}
+
+/**
+ * Mock Messaging Adapter for testing purposes
+ * Implements all three capability interfaces
+ */
+export class MockMessagingAdapter
+   extends AbstractMessagingAdapter
+   implements
+      NotificationCapableAdapter,
+      EmailCapableAdapter,
+      TextCapableAdapter
+{
+   private sentMessages: SentMessage[] = []
+
+   constructor(params: MessagingParameters = {}) {
+      super(params)
+   }
+
+   async sendNotification(
+      recipient: MessagingRecipient,
+      message: NotificationMessage
+   ): Promise<any> {
+      this.sentMessages.push({
+         type: 'notification',
+         recipient,
+         message,
+         timestamp: Date.now(),
+      })
+
+      return {
+         success: true,
+         messageId: `notif-${Date.now()}`,
+         recipient: recipient.email,
+      }
+   }
+
+   async sendNotifications(
+      recipients: MessagingRecipient[],
+      message: NotificationMessage
+   ): Promise<any> {
+      this.sentMessages.push({
+         type: 'notification',
+         recipient: recipients,
+         message,
+         timestamp: Date.now(),
+      })
+
+      return {
+         success: true,
+         count: recipients.length,
+         messageIds: recipients.map((r, i) => `notif-batch-${Date.now()}-${i}`),
+      }
+   }
+
+   async sendEmail(
+      recipient: MessagingRecipient,
+      message: NotificationMessage
+   ): Promise<any> {
+      this.sentMessages.push({
+         type: 'email',
+         recipient,
+         message,
+         timestamp: Date.now(),
+      })
+
+      return {
+         success: true,
+         messageId: `email-${Date.now()}`,
+         recipient: recipient.email,
+      }
+   }
+
+   async sendEmails(
+      recipients: MessagingRecipient[],
+      message: NotificationMessage
+   ): Promise<any> {
+      this.sentMessages.push({
+         type: 'email',
+         recipient: recipients,
+         message,
+         timestamp: Date.now(),
+      })
+
+      return {
+         success: true,
+         count: recipients.length,
+         messageIds: recipients.map((r, i) => `email-batch-${Date.now()}-${i}`),
+      }
+   }
+
+   async sendTextMessage(
+      recipient: MessagingRecipient,
+      message: NotificationMessage
+   ): Promise<any> {
+      this.sentMessages.push({
+         type: 'text',
+         recipient,
+         message,
+         timestamp: Date.now(),
+      })
+
+      return {
+         success: true,
+         messageId: `text-${Date.now()}`,
+         recipient: recipient.email,
+      }
+   }
+
+   async sendTextMessages(
+      recipients: MessagingRecipient[],
+      message: NotificationMessage
+   ): Promise<any> {
+      this.sentMessages.push({
+         type: 'text',
+         recipient: recipients,
+         message,
+         timestamp: Date.now(),
+      })
+
+      return {
+         success: true,
+         count: recipients.length,
+         messageIds: recipients.map((r, i) => `text-batch-${Date.now()}-${i}`),
+      }
+   }
+
+   // Helper methods for testing
+   getSentMessages(type?: 'notification' | 'email' | 'text'): SentMessage[] {
+      if (type) {
+         return this.sentMessages.filter((msg) => msg.type === type)
+      }
+      return this.sentMessages
+   }
+
+   clearMessages(): void {
+      this.sentMessages = []
+   }
+
+   getMessageCount(type?: 'notification' | 'email' | 'text'): number {
+      return this.getSentMessages(type).length
+   }
+
+   getLastMessage(
+      type?: 'notification' | 'email' | 'text'
+   ): SentMessage | undefined {
+      const messages = this.getSentMessages(type)
+      return messages[messages.length - 1]
+   }
+}

package/src/index.ts

@@ -0,0 +1,20 @@
+import { Messaging, MessagingParameters } from './Messaging'
+import { AbstractMessagingAdapter } from './AbstractMessagingAdapter'
+import { MessagingRecipient } from './types/MessagingRecipient'
+import { NotificationMessage } from './types/NotificationMessage'
+import { MessageType } from './types/MessageType'
+import { EmailCapableAdapter } from './types/EmailCapableAdapter'
+import { NotificationCapableAdapter } from './types/NotificationCapableAdapter'
+import { MessageFormatter } from './MessageFormatter'
+
+export {
+   Messaging,
+   MessagingParameters,
+   AbstractMessagingAdapter,
+   MessagingRecipient,
+   NotificationMessage,
+   MessageType,
+   EmailCapableAdapter,
+   NotificationCapableAdapter,
+   MessageFormatter,
+}

package/src/types/EmailCapableAdapter.ts

@@ -0,0 +1,14 @@
+import { MessagingRecipient } from './MessagingRecipient'
+import { NotificationMessage } from './NotificationMessage'
+
+export interface EmailCapableAdapter {
+   sendEmail(
+      recipient: MessagingRecipient,
+      message: NotificationMessage
+   ): Promise<any>
+
+   sendEmails(
+      recipients: MessagingRecipient[],
+      message: NotificationMessage
+   ): Promise<any>
+}

package/src/types/MessageType.ts

@@ -0,0 +1,6 @@
+export interface MessageType {
+   token?: string
+   title: string
+   body: string
+   data?: any
+}

package/src/types/MessagingRecipient.ts

@@ -0,0 +1,6 @@
+import { UserType } from '@quatrain/core'
+
+export type MessagingRecipient = Pick<
+   UserType,
+   'firstname' | 'lastname' | 'email' | 'messageToken'
+> & { data?: { [x: string]: any } }

package/src/types/MessagingTemplate.ts

@@ -0,0 +1,3 @@
+export type MessagingTemplate = {
+    
+}

package/src/types/NotificationCapableAdapter.ts

@@ -0,0 +1,14 @@
+import { MessagingRecipient } from './MessagingRecipient'
+import { NotificationMessage } from './NotificationMessage'
+
+export interface NotificationCapableAdapter {
+   sendNotification(
+      recipient: MessagingRecipient,
+      message: NotificationMessage
+   ): Promise<any>
+
+   sendNotifications(
+      recipients: MessagingRecipient[],
+      message: NotificationMessage
+   ): Promise<any>
+}

package/src/types/NotificationMessage.ts

@@ -0,0 +1,3 @@
+import { MessageType } from './MessageType'
+
+export interface NotificationMessage extends MessageType {}

package/src/types/TextCapableAdapter.ts

@@ -0,0 +1,14 @@
+import { MessagingRecipient } from './MessagingRecipient'
+import { NotificationMessage } from './NotificationMessage'
+
+export interface TextCapableAdapter {
+   sendTextMessage(
+      recipient: MessagingRecipient,
+      message: NotificationMessage
+   ): Promise<any>
+
+   sendTextMessages(
+      recipients: MessagingRecipient[],
+      message: NotificationMessage
+   ): Promise<any>
+}

package/lib/types/AbstractMessage.d.ts

@@ -1,6 +0,0 @@
-export interface AbstractMessage {
-    token?: string;
-    title: string;
-    body: string;
-    data?: any;
-}

package/lib/types/AbstractMessage.js

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

package/lib/types/EmailCapableAdapter copy.d.ts

@@ -1,6 +0,0 @@
-import { MessagingRecipient } from './MessagingRecipient';
-import { NotificationMessage } from './NotificationMessage';
-export interface EmailCapableAdapter {
-    sendEmail(recipient: MessagingRecipient, message: NotificationMessage): Promise<any>;
-    sendEmails(recipients: MessagingRecipient[], message: NotificationMessage): Promise<any>;
-}

package/lib/types/EmailCapableAdapter copy.js

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

package/lib/types/MessagingInterface.d.ts

@@ -1,6 +0,0 @@
-import { AbstractMessage } from './AbstractMessage';
-import { MessagingRecipient } from './MessagingRecipient';
-export interface MessagingInterface {
-    sendNotification(recipient: MessagingRecipient, message: AbstractMessage): Promise<any>;
-    sendNotifications(recipients: MessagingRecipient[], message: AbstractMessage): Promise<any>;
-}

package/lib/types/MessagingInterface.js

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