@quatrain/messaging 1.0.2 → 1.0.4

package/package.json

@@ -1,41 +1,39 @@
 {
-  "name": "@quatrain/messaging",
-  "version": "1.0.2",
-  "license": "MIT",
-  "description": "Messaging adapters commons",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
-  "files": [
-    "lib/",
-    "README.md"
-  ],
-  "author": "Quatrain Développement SAS <developers@quatrain.com>",
-  "dependencies": {
-    "@quatrain/core": "^1.1.19",
-    "mustache": "^4.2.0"
-  },
-  "devDependencies": {
-    "@tsconfig/recommended": "^1.0.1",
-    "@types/jest": "^27.0.3",
-    "@types/mustache": "^4",
-    "@types/node": "^22.10.1",
-    "jest": "^27.4.7",
-    "jest-node-exports-resolver": "^1.1.6",
-    "jest-serial-runner": "^1.2.1",
-    "trace-unhandled": "^2.0.1",
-    "ts-jest": "^27.1.2",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.1.5"
-  },
-  "scripts": {
-    "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"
-  }
-}
+   "name": "@quatrain/messaging",
+   "version": "1.0.4",
+   "license": "AGPL-3.0-only",
+   "description": "Messaging adapters commons",
+   "main": "lib/index.js",
+   "types": "lib/index.d.ts",
+   "bun": "src/index.ts",
+   "files": [
+      "LICENSE.md",
+      "src/",
+      "lib/",
+      "README.md"
+   ],
+   "author": "Quatrain Développement SAS <developers@quatrain.com>",
+   "dependencies": {
+      "@quatrain/core": "^1.1.43",
+      "mustache": "^4.2.0"
+   },
+   "devDependencies": {
+      "@tsconfig/recommended": "^1.0.1",
+      "@types/jest": "^27.0.3",
+      "@types/mustache": "^4",
+      "@types/node": "^22.10.1",
+      "jest": "^30.2.0",
+      "jest-node-exports-resolver": "^1.1.6",
+      "jest-serial-runner": "^1.2.1",
+      "trace-unhandled": "^2.0.1",
+      "ts-jest": "^27.1.2",
+      "ts-node": "^10.9.1",
+      "typescript": "^5.1.5"
+   },
+   "scripts": {
+      "test-ci": "jest --runInBand",
+      "build": "tsc",
+      "wbuild": "tsc --watch",
+      "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 = {
+    
+}