@ewyn/client 0.1.0 → 0.2.0

package/README.md

@@ -22,9 +22,9 @@ yarn add @ewyn/client
 ### Basic Usage
 
 ```typescript
-import { Mailer } from '@ewyn/client';
+import { Ewyn } from '@ewyn/client';
 
-const client = new Mailer({
+const client = new Ewyn({
   workspaceId: 'your-workspace-id',
   apiKey: 'your-api-key',
   baseUrl: 'https://www.ewyn.ai/api/v1', // optional; omit to use production default
@@ -46,7 +46,7 @@ await client.send({
 Get full TypeScript autocomplete and validation by copying your template config from the dashboard:
 
 ```typescript
-import { Mailer } from '@ewyn/client';
+import { Ewyn } from '@ewyn/client';
 
 // 1. Copy template config from dashboard (API Keys page)
 const config = {
@@ -71,7 +71,7 @@ const config = {
 } as const; // ← Important: use 'as const'
 
 // 2. Initialize with config
-const client = new Mailer({
+const client = new Ewyn({
   workspaceId: 'your-workspace-id',
   apiKey: 'your-api-key',
   templates: config,
@@ -103,7 +103,7 @@ const config = {
   // ... paste here
 } as const;
 
-const client = new Mailer({
+const client = new Ewyn({
   workspaceId: 'your-workspace-id',
   apiKey: 'your-api-key',
   templates: config, // Now fully type-safe!
@@ -123,12 +123,12 @@ curl -X GET https://www.ewyn.ai/api/v1/workspaces/YOUR_WORKSPACE_ID/templates/co
 
 ## API Reference
 
-### `Mailer` Class
+### `Ewyn` Class
 
 #### Constructor
 
 ```typescript
-new Mailer(options: MailerOptions)
+new Ewyn(options: EwynOptions)
 ```
 
 **Options:**
@@ -168,20 +168,20 @@ Send an email using a template.
 
 **Throws:**
 
-- `MailerApiError`: If the API request fails
+- `EwynApiError`: If the API request fails
 - `Error`: If validation fails (missing template, missing variables, etc.)
 
 ### Error Handling
 
-The SDK throws `MailerApiError` for API errors:
+The SDK throws `EwynApiError` for API errors:
 
 ```typescript
-import { Mailer, MailerApiError } from '@ewyn/client';
+import { Ewyn, EwynApiError } from '@ewyn/client';
 
 try {
   await client.send({ /* ... */ });
 } catch (error) {
-  if (error instanceof MailerApiError) {
+  if (error instanceof EwynApiError) {
     console.error('API Error:', error.status, error.message);
     console.error('Details:', error.details);
     

package/dist/__tests__/config-types.test-d.js

@@ -7,7 +7,7 @@
  * variables at compile time.
  */
 import { expectTypeOf, test } from 'vitest';
-import { Mailer } from '../index.js';
+import { Ewyn } from '../index.js';
 // Dashboard-shaped config: same structure as getConfig response (id, name, version, vars)
 const dashboardConfig = {
     welcome: {
@@ -29,7 +29,7 @@ const dashboardConfig = {
     },
 };
 test('client with dashboard config has typed send', () => {
-    const client = new Mailer({
+    const client = new Ewyn({
         workspaceId: 'ws',
         apiKey: 'key',
         templates: dashboardConfig,
@@ -38,7 +38,7 @@ test('client with dashboard config has typed send', () => {
     expectTypeOf(client.send).toBeFunction();
 });
 test('valid send: required var present, optional omitted', () => {
-    const client = new Mailer({
+    const client = new Ewyn({
         workspaceId: 'ws',
         apiKey: 'key',
         templates: dashboardConfig,
@@ -50,7 +50,7 @@ test('valid send: required var present, optional omitted', () => {
     }).toMatchTypeOf();
 });
 test('valid send: required and optional vars', () => {
-    const client = new Mailer({
+    const client = new Ewyn({
         workspaceId: 'ws',
         apiKey: 'key',
         templates: dashboardConfig,
@@ -62,7 +62,7 @@ test('valid send: required and optional vars', () => {
     }).toMatchTypeOf();
 });
 test('valid send: hyphenated template name', () => {
-    const client = new Mailer({
+    const client = new Ewyn({
         workspaceId: 'ws',
         apiKey: 'key',
         templates: dashboardConfig,
@@ -74,7 +74,7 @@ test('valid send: hyphenated template name', () => {
     }).toMatchTypeOf();
 });
 test('send return type is Promise<SendEmailResponse>', () => {
-    const client = new Mailer({
+    const client = new Ewyn({
         workspaceId: 'ws',
         apiKey: 'key',
         templates: dashboardConfig,
@@ -86,7 +86,7 @@ test('template name is constrained to config keys at type level', () => {
     expectTypeOf().toMatchTypeOf();
 });
 test('missing required variable is rejected by types', () => {
-    const client = new Mailer({
+    const client = new Ewyn({
         workspaceId: 'ws',
         apiKey: 'key',
         templates: dashboardConfig,

package/dist/__tests__/dashboard-config.test.js

@@ -7,7 +7,7 @@
  * the dashboard" work with the SDK and that runtime validation behaves correctly.
  */
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { Mailer } from '../index.js';
+import { Ewyn } from '../index.js';
 global.fetch = vi.fn();
 describe('Dashboard config (runtime)', () => {
     beforeEach(() => {
@@ -45,7 +45,7 @@ describe('Dashboard config (runtime)', () => {
         },
     };
     it('sends with dashboard-shaped config (only required vars)', async () => {
-        const client = new Mailer({
+        const client = new Ewyn({
             workspaceId: 'ws-1',
             apiKey: 'key-1',
             baseUrl: 'https://api.test.com/api/v1',
@@ -81,7 +81,7 @@ describe('Dashboard config (runtime)', () => {
         expect(body.variables).toEqual({ firstName: 'Jane', lastName: 'Doe' });
     });
     it('sends with dashboard-shaped config (mixed required/optional, hyphenated key)', async () => {
-        const client = new Mailer({
+        const client = new Ewyn({
             workspaceId: 'ws-2',
             apiKey: 'key-2',
             baseUrl: 'https://api.test.com/api/v1',
@@ -117,7 +117,7 @@ describe('Dashboard config (runtime)', () => {
         });
     });
     it('sends with template that has empty vars (dashboard shape)', async () => {
-        const client = new Mailer({
+        const client = new Ewyn({
             workspaceId: 'ws-3',
             apiKey: 'key-3',
             baseUrl: 'https://api.test.com/api/v1',
@@ -147,7 +147,7 @@ describe('Dashboard config (runtime)', () => {
         expect(body.variables).toEqual({});
     });
     it('throws when required variable is missing (dashboard config)', async () => {
-        const client = new Mailer({
+        const client = new Ewyn({
             workspaceId: 'ws-1',
             apiKey: 'key-1',
             baseUrl: 'https://api.test.com/api/v1',
@@ -165,7 +165,7 @@ describe('Dashboard config (runtime)', () => {
         })).rejects.toThrow('Missing required variables for template "welcome": lastName');
     });
     it('throws when template name is not in config (dashboard config)', async () => {
-        const client = new Mailer({
+        const client = new Ewyn({
             workspaceId: 'ws-1',
             apiKey: 'key-1',
             baseUrl: 'https://api.test.com/api/v1',

package/dist/__tests__/errors.test.js

@@ -1,24 +1,24 @@
 import { describe, it, expect } from 'vitest';
-import { MailerApiError } from '../errors.js';
-describe('MailerApiError', () => {
+import { EwynApiError } from '../errors.js';
+describe('EwynApiError', () => {
     describe('constructor', () => {
         it('should create error with status code', () => {
-            const error = new MailerApiError(400);
+            const error = new EwynApiError(400);
             expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(MailerApiError);
+            expect(error).toBeInstanceOf(EwynApiError);
             expect(error.status).toBe(400);
             expect(error.message).toBe('API request failed with status 400');
-            expect(error.name).toBe('MailerApiError');
+            expect(error.name).toBe('EwynApiError');
         });
         it('should create error with custom message', () => {
-            const error = new MailerApiError(400, 'INVALID_REQUEST', undefined, 'Invalid email address');
+            const error = new EwynApiError(400, 'INVALID_REQUEST', undefined, 'Invalid email address');
             expect(error.status).toBe(400);
             expect(error.code).toBe('INVALID_REQUEST');
             expect(error.message).toBe('Invalid email address');
         });
         it('should create error with details', () => {
             const details = { field: 'to', reason: 'Invalid email format' };
-            const error = new MailerApiError(400, 'VALIDATION_ERROR', details);
+            const error = new EwynApiError(400, 'VALIDATION_ERROR', details);
             expect(error.status).toBe(400);
             expect(error.code).toBe('VALIDATION_ERROR');
             expect(error.details).toEqual(details);
@@ -26,62 +26,62 @@ describe('MailerApiError', () => {
     });
     describe('isClientError', () => {
         it('should return true for 4xx errors', () => {
-            expect(new MailerApiError(400).isClientError()).toBe(true);
-            expect(new MailerApiError(401).isClientError()).toBe(true);
-            expect(new MailerApiError(404).isClientError()).toBe(true);
-            expect(new MailerApiError(429).isClientError()).toBe(true);
-            expect(new MailerApiError(499).isClientError()).toBe(true);
+            expect(new EwynApiError(400).isClientError()).toBe(true);
+            expect(new EwynApiError(401).isClientError()).toBe(true);
+            expect(new EwynApiError(404).isClientError()).toBe(true);
+            expect(new EwynApiError(429).isClientError()).toBe(true);
+            expect(new EwynApiError(499).isClientError()).toBe(true);
         });
         it('should return false for non-4xx errors', () => {
-            expect(new MailerApiError(200).isClientError()).toBe(false);
-            expect(new MailerApiError(399).isClientError()).toBe(false);
-            expect(new MailerApiError(500).isClientError()).toBe(false);
+            expect(new EwynApiError(200).isClientError()).toBe(false);
+            expect(new EwynApiError(399).isClientError()).toBe(false);
+            expect(new EwynApiError(500).isClientError()).toBe(false);
         });
     });
     describe('isServerError', () => {
         it('should return true for 5xx errors', () => {
-            expect(new MailerApiError(500).isServerError()).toBe(true);
-            expect(new MailerApiError(502).isServerError()).toBe(true);
-            expect(new MailerApiError(503).isServerError()).toBe(true);
-            expect(new MailerApiError(599).isServerError()).toBe(true);
+            expect(new EwynApiError(500).isServerError()).toBe(true);
+            expect(new EwynApiError(502).isServerError()).toBe(true);
+            expect(new EwynApiError(503).isServerError()).toBe(true);
+            expect(new EwynApiError(599).isServerError()).toBe(true);
         });
         it('should return false for non-5xx errors', () => {
-            expect(new MailerApiError(200).isServerError()).toBe(false);
-            expect(new MailerApiError(400).isServerError()).toBe(false);
-            expect(new MailerApiError(499).isServerError()).toBe(false);
+            expect(new EwynApiError(200).isServerError()).toBe(false);
+            expect(new EwynApiError(400).isServerError()).toBe(false);
+            expect(new EwynApiError(499).isServerError()).toBe(false);
         });
     });
     describe('isRetryable', () => {
         it('should return true for 429 rate limit', () => {
-            expect(new MailerApiError(429).isRetryable()).toBe(true);
+            expect(new EwynApiError(429).isRetryable()).toBe(true);
         });
         it('should return true for 5xx errors', () => {
-            expect(new MailerApiError(500).isRetryable()).toBe(true);
-            expect(new MailerApiError(502).isRetryable()).toBe(true);
-            expect(new MailerApiError(503).isRetryable()).toBe(true);
+            expect(new EwynApiError(500).isRetryable()).toBe(true);
+            expect(new EwynApiError(502).isRetryable()).toBe(true);
+            expect(new EwynApiError(503).isRetryable()).toBe(true);
         });
         it('should return false for other errors', () => {
-            expect(new MailerApiError(200).isRetryable()).toBe(false);
-            expect(new MailerApiError(400).isRetryable()).toBe(false);
-            expect(new MailerApiError(401).isRetryable()).toBe(false);
-            expect(new MailerApiError(404).isRetryable()).toBe(false);
+            expect(new EwynApiError(200).isRetryable()).toBe(false);
+            expect(new EwynApiError(400).isRetryable()).toBe(false);
+            expect(new EwynApiError(401).isRetryable()).toBe(false);
+            expect(new EwynApiError(404).isRetryable()).toBe(false);
         });
     });
     describe('error prototype chain', () => {
         it('should maintain correct prototype chain', () => {
-            const error = new MailerApiError(400);
+            const error = new EwynApiError(400);
             expect(error instanceof Error).toBe(true);
-            expect(error instanceof MailerApiError).toBe(true);
-            expect(Object.getPrototypeOf(error)).toBe(MailerApiError.prototype);
+            expect(error instanceof EwynApiError).toBe(true);
+            expect(Object.getPrototypeOf(error)).toBe(EwynApiError.prototype);
         });
         it('should work with try-catch instanceof checks', () => {
             try {
-                throw new MailerApiError(400, 'TEST_ERROR');
+                throw new EwynApiError(400, 'TEST_ERROR');
             }
             catch (error) {
-                expect(error instanceof MailerApiError).toBe(true);
+                expect(error instanceof EwynApiError).toBe(true);
                 expect(error instanceof Error).toBe(true);
-                if (error instanceof MailerApiError) {
+                if (error instanceof EwynApiError) {
                     expect(error.code).toBe('TEST_ERROR');
                 }
             }

package/dist/__tests__/ewyn.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ewyn.test.d.ts.map

package/dist/__tests__/ewyn.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ewyn.test.d.ts","sourceRoot":"","sources":["../../src/__tests__/ewyn.test.ts"],"names":[],"mappings":""}

package/dist/__tests__/ewyn.test.js

@@ -0,0 +1,429 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { Ewyn, EwynApiError } from '../index.js';
+// Mock fetch globally
+global.fetch = vi.fn();
+describe('Ewyn SDK', () => {
+    let client;
+    beforeEach(() => {
+        vi.clearAllMocks();
+        global.fetch.mockReset();
+        client = new Ewyn({
+            workspaceId: 'test-workspace-id',
+            apiKey: 'test-api-key',
+            baseUrl: 'https://api.test.com/api/v1',
+            maxRetries: 2, // Allow 1 retry (attempt < maxRetries)
+            timeout: 5000,
+        });
+    });
+    describe('constructor', () => {
+        it('should create client with required options', () => {
+            expect(client).toBeInstanceOf(Ewyn);
+        });
+        it('should use default base URL if not provided', () => {
+            const defaultClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+            });
+            expect(defaultClient).toBeInstanceOf(Ewyn);
+        });
+        it('should accept template config', () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            expect(configClient).toBeInstanceOf(Ewyn);
+        });
+    });
+    describe('send', () => {
+        it('should send email with template ID', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            const result = await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                variables: {
+                    firstName: 'John',
+                },
+            });
+            expect(result).toEqual(mockResponse);
+            expect(global.fetch).toHaveBeenCalledWith('https://api.test.com/api/v1/workspaces/test-workspace-id/send', expect.objectContaining({
+                method: 'POST',
+                headers: expect.objectContaining({
+                    'Content-Type': 'application/json',
+                    'Authorization': 'Bearer test-api-key',
+                }),
+                body: JSON.stringify({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                    variables: {
+                        firstName: 'John',
+                    },
+                }),
+            }));
+        });
+        it('should send email with template name when config provided', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            const result = await configClient.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {
+                    firstName: 'John',
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+        it('should include version parameter if specified', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                version: 2,
+                variables: {
+                    firstName: 'John',
+                },
+            });
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining('"version":2'),
+            }));
+        });
+        it('should include metadata if provided', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                metadata: {
+                    userId: 'user-123',
+                },
+            });
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining('"metadata"'),
+            }));
+        });
+        it('should include idempotency key if provided', async () => {
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+                idempotencyKey: 'idempotency-key-123',
+            });
+            expect(global.fetch).toHaveBeenCalledWith(expect.any(String), expect.objectContaining({
+                body: expect.stringContaining('"idempotencyKey":"idempotency-key-123"'),
+            }));
+        });
+        it('should throw error if neither templateId nor template provided', async () => {
+            await expect(client.send({
+                to: 'test@example.com',
+                variables: {},
+            })).rejects.toThrow('Either templateId or template must be provided');
+        });
+        it('should throw error if template name provided without config', async () => {
+            await expect(client.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {},
+            })).rejects.toThrow('Template name provided but no template config was provided');
+        });
+        it('should throw error if template not found in config', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {},
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            await expect(configClient.send({
+                to: 'test@example.com',
+                template: 'nonexistent',
+                variables: {},
+            })).rejects.toThrow('Template "nonexistent" not found in template config');
+        });
+    });
+    describe('variable validation', () => {
+        it('should validate required variables', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                        lastName: { required: true },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            await expect(configClient.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {
+                    firstName: 'John',
+                    // lastName missing
+                },
+            })).rejects.toThrow('Missing required variables for template "welcome": lastName');
+        });
+        it('should allow optional variables to be omitted', async () => {
+            const config = {
+                welcome: {
+                    id: 'version-uuid',
+                    name: 'Welcome',
+                    version: 1,
+                    vars: {
+                        firstName: { required: true },
+                        lastName: { required: false },
+                    },
+                },
+            };
+            const configClient = new Ewyn({
+                workspaceId: 'test-workspace-id',
+                apiKey: 'test-api-key',
+                templates: config,
+            });
+            const mockResponse = {
+                messageId: 'msg-123',
+                status: 'queued',
+                queuedAt: '2024-01-01T00:00:00Z',
+            };
+            global.fetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => mockResponse,
+            });
+            const result = await configClient.send({
+                to: 'test@example.com',
+                template: 'welcome',
+                variables: {
+                    firstName: 'John',
+                    // lastName omitted (optional)
+                },
+            });
+            expect(result).toEqual(mockResponse);
+        });
+    });
+    describe('error handling', () => {
+        it('should throw EwynApiError on 400 error', async () => {
+            const mock400Response = {
+                ok: false,
+                status: 400,
+                json: async () => ({
+                    error: 'Bad request',
+                    code: 'INVALID_REQUEST',
+                    details: { field: 'to' },
+                }),
+            };
+            global.fetch
+                .mockResolvedValueOnce(mock400Response)
+                .mockResolvedValueOnce(mock400Response);
+            await expect(client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            })).rejects.toThrow(EwynApiError);
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(400);
+                expect(error.code).toBe('INVALID_REQUEST');
+                expect(error.isClientError()).toBe(true);
+                expect(error.isServerError()).toBe(false);
+                expect(error.isRetryable()).toBe(false);
+            }
+        });
+        it('should throw EwynApiError on 429 rate limit', async () => {
+            global.fetch.mockResolvedValue({
+                ok: false,
+                status: 429,
+                json: async () => ({
+                    error: 'Too many requests',
+                    code: 'RATE_LIMITED',
+                }),
+            });
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(429);
+                expect(error.isRetryable()).toBe(true);
+            }
+            // Should have retried once (maxRetries: 1)
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it('should throw EwynApiError on 500 server error', async () => {
+            global.fetch.mockResolvedValue({
+                ok: false,
+                status: 500,
+                json: async () => ({
+                    error: 'Internal server error',
+                }),
+            });
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(500);
+                expect(error.isServerError()).toBe(true);
+                expect(error.isRetryable()).toBe(true);
+            }
+            // Should have retried once
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it('should handle network errors', async () => {
+            global.fetch.mockRejectedValue(new Error('Network error'));
+            await expect(client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            })).rejects.toThrow('Network error');
+            // Should have retried once
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it('should handle timeout errors', async () => {
+            const abortError = new Error('The operation was aborted');
+            abortError.name = 'AbortError';
+            global.fetch.mockRejectedValueOnce(abortError);
+            try {
+                await client.send({
+                    to: 'test@example.com',
+                    templateId: 'template-uuid',
+                });
+            }
+            catch (error) {
+                expect(error).toBeInstanceOf(EwynApiError);
+                expect(error.status).toBe(408);
+                expect(error.code).toBe('TIMEOUT');
+            }
+        });
+    });
+    describe('retry logic', () => {
+        it('should retry on 5xx errors with exponential backoff', async () => {
+            const startTime = Date.now();
+            global.fetch
+                .mockResolvedValueOnce({
+                ok: false,
+                status: 500,
+                json: async () => ({ error: 'Server error' }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                json: async () => ({
+                    messageId: 'msg-123',
+                    status: 'queued',
+                    queuedAt: '2024-01-01T00:00:00Z',
+                }),
+            });
+            const result = await client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            });
+            const duration = Date.now() - startTime;
+            expect(result.messageId).toBe('msg-123');
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+            // Should have waited ~1 second between attempts
+            expect(duration).toBeGreaterThanOrEqual(950);
+        });
+        it('should not retry on 4xx client errors', async () => {
+            global.fetch.mockResolvedValueOnce({
+                ok: false,
+                status: 404,
+                json: async () => ({ error: 'Not found' }),
+            });
+            await expect(client.send({
+                to: 'test@example.com',
+                templateId: 'template-uuid',
+            })).rejects.toThrow(EwynApiError);
+            // Should not retry
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/errors.d.ts

@@ -1,7 +1,7 @@
 /**
- * API Error class for handling HTTP errors from the Mailer API
+ * API Error class for handling HTTP errors from the Ewyn API
  */
-export declare class MailerApiError extends Error {
+export declare class EwynApiError extends Error {
     status: number;
     code?: string | undefined;
     details?: unknown | undefined;

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,cAAe,SAAQ,KAAK;IAE9B,MAAM,EAAE,MAAM;IACd,IAAI,CAAC,EAAE,MAAM;IACb,OAAO,CAAC,EAAE,OAAO;gBAFjB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,OAAO,CAAC,EAAE,OAAO,YAAA,EACxB,OAAO,CAAC,EAAE,MAAM;IAOlB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,WAAW,IAAI,OAAO;CAGvB"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAE5B,MAAM,EAAE,MAAM;IACd,IAAI,CAAC,EAAE,MAAM;IACb,OAAO,CAAC,EAAE,OAAO;gBAFjB,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,YAAA,EACb,OAAO,CAAC,EAAE,OAAO,YAAA,EACxB,OAAO,CAAC,EAAE,MAAM;IAOlB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,WAAW,IAAI,OAAO;CAGvB"}

package/dist/errors.js

@@ -1,7 +1,7 @@
 /**
- * API Error class for handling HTTP errors from the Mailer API
+ * API Error class for handling HTTP errors from the Ewyn API
  */
-export class MailerApiError extends Error {
+export class EwynApiError extends Error {
     status;
     code;
     details;
@@ -10,8 +10,8 @@ export class MailerApiError extends Error {
         this.status = status;
         this.code = code;
         this.details = details;
-        this.name = 'MailerApiError';
-        Object.setPrototypeOf(this, MailerApiError.prototype);
+        this.name = 'EwynApiError';
+        Object.setPrototypeOf(this, EwynApiError.prototype);
     }
     /**
      * Check if the error is a client error (4xx)

package/dist/index.d.ts

@@ -1,10 +1,10 @@
-import type { MailerOptions, MailerOptionsTyped, SendEmailOptions, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig } from './types.js';
+import type { EwynOptions, EwynOptionsTyped, SendEmailOptions, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig } from './types.js';
 /**
- * Mailer SDK Client
+ * Ewyn SDK Client
  *
  * @example Basic usage without template config
  * ```ts
- * const client = new Mailer({
+ * const client = new Ewyn({
  *   workspaceId: 'your-workspace-id',
  *   apiKey: 'your-api-key',
  * });
@@ -30,7 +30,7 @@ import type { MailerOptions, MailerOptionsTyped, SendEmailOptions, SendEmailOpti
  *   }
  * } as const;
  *
- * const client = new Mailer({
+ * const client = new Ewyn({
  *   workspaceId: 'your-workspace-id',
  *   apiKey: 'your-api-key',
  *   templates: config
@@ -46,20 +46,20 @@ import type { MailerOptions, MailerOptionsTyped, SendEmailOptions, SendEmailOpti
  * });
  * ```
  */
-export declare class Mailer<TConfig extends TemplateConfig = TemplateConfig> {
+export declare class Ewyn<TConfig extends TemplateConfig = TemplateConfig> {
     private readonly workspaceId;
     private readonly apiKey;
     private readonly baseUrl;
     private readonly templates?;
     private readonly maxRetries;
     private readonly timeout;
-    constructor(options: MailerOptions | MailerOptionsTyped<TConfig>);
+    constructor(options: EwynOptions | EwynOptionsTyped<TConfig>);
     /**
      * Send an email using a template
      *
      * @param options - Email sending options
      * @returns Promise resolving to the send response
-     * @throws {MailerApiError} If the API request fails
+     * @throws {EwynApiError} If the API request fails
      *
      * @example With template ID
      * ```ts
@@ -94,6 +94,6 @@ export declare class Mailer<TConfig extends TemplateConfig = TemplateConfig> {
      */
     private requestWithRetry;
 }
-export { MailerApiError } from './errors.js';
-export type { MailerOptions, MailerOptionsTyped, SendEmailOptions, SendEmailOptionsBase, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig, TemplateConfigEntry, TemplateVariable } from './types.js';
+export { EwynApiError } from './errors.js';
+export type { EwynOptions, EwynOptionsTyped, SendEmailOptions, SendEmailOptionsBase, SendEmailOptionsTyped, SendEmailResponse, TemplateConfig, TemplateConfigEntry, TemplateVariable, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,MAAM,CAAC,OAAO,SAAS,cAAc,GAAG,cAAc;IACjE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,EAAE,aAAa,GAAG,kBAAkB,CAAC,OAAO,CAAC;IAShE;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,IAAI,CACR,OAAO,EAAE,OAAO,SAAS,cAAc,GACnC,qBAAqB,CAAC,OAAO,CAAC,GAAG,gBAAgB,GACjD,gBAAgB,GACnB,OAAO,CAAC,iBAAiB,CAAC;IA8C7B;;OAEG;YACW,iBAAiB;IAyB/B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;OAEG;YACW,gBAAgB;CAuE/B;AAED,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAC7C,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACf,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8CG;AACH,qBAAa,IAAI,CAAC,OAAO,SAAS,cAAc,GAAG,cAAc;IAC/D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAU;IACrC,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IACpC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,EAAE,WAAW,GAAG,gBAAgB,CAAC,OAAO,CAAC;IAS5D;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,IAAI,CACR,OAAO,EAAE,OAAO,SAAS,cAAc,GACnC,qBAAqB,CAAC,OAAO,CAAC,GAAG,gBAAgB,GACjD,gBAAgB,GACnB,OAAO,CAAC,iBAAiB,CAAC;IA8C7B;;OAEG;YACW,iBAAiB;IAyB/B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IA2BzB;;OAEG;YACW,gBAAgB;CAuE/B;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAC3C,YAAY,EACV,WAAW,EACX,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,cAAc,EACd,mBAAmB,EACnB,gBAAgB,GACjB,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -1,10 +1,10 @@
-import { MailerApiError } from './errors.js';
+import { EwynApiError } from './errors.js';
 /**
- * Mailer SDK Client
+ * Ewyn SDK Client
  *
  * @example Basic usage without template config
  * ```ts
- * const client = new Mailer({
+ * const client = new Ewyn({
  *   workspaceId: 'your-workspace-id',
  *   apiKey: 'your-api-key',
  * });
@@ -30,7 +30,7 @@ import { MailerApiError } from './errors.js';
  *   }
  * } as const;
  *
- * const client = new Mailer({
+ * const client = new Ewyn({
  *   workspaceId: 'your-workspace-id',
  *   apiKey: 'your-api-key',
  *   templates: config
@@ -46,7 +46,7 @@ import { MailerApiError } from './errors.js';
  * });
  * ```
  */
-export class Mailer {
+export class Ewyn {
     workspaceId;
     apiKey;
     baseUrl;
@@ -66,7 +66,7 @@ export class Mailer {
      *
      * @param options - Email sending options
      * @returns Promise resolving to the send response
-     * @throws {MailerApiError} If the API request fails
+     * @throws {EwynApiError} If the API request fails
      *
      * @example With template ID
      * ```ts
@@ -177,7 +177,7 @@ export class Mailer {
             clearTimeout(timeoutId);
             const data = await response.json().catch(() => ({}));
             if (!response.ok) {
-                const error = new MailerApiError(response.status, data.code, data.details || data, data.error || data.message);
+                const error = new EwynApiError(response.status, data.code, data.details || data, data.error || data.message);
                 // Retry on retryable errors
                 if (error.isRetryable() && attempt < this.maxRetries) {
                     // Exponential backoff: 1s, 2s, 4s
@@ -191,12 +191,12 @@ export class Mailer {
         }
         catch (error) {
             clearTimeout(timeoutId);
-            if (error instanceof MailerApiError) {
+            if (error instanceof EwynApiError) {
                 throw error;
             }
             // Handle network errors or timeouts
             if (error instanceof Error && error.name === 'AbortError') {
-                throw new MailerApiError(408, 'TIMEOUT', undefined, `Request timed out after ${this.timeout}ms`);
+                throw new EwynApiError(408, 'TIMEOUT', undefined, `Request timed out after ${this.timeout}ms`);
             }
             // Retry on network errors if we have attempts left
             if (attempt < this.maxRetries) {
@@ -204,8 +204,8 @@ export class Mailer {
                 await new Promise((resolve) => setTimeout(resolve, delay));
                 return this.requestWithRetry(path, init, attempt + 1);
             }
-            throw new MailerApiError(500, 'NETWORK_ERROR', undefined, error instanceof Error ? error.message : 'Unknown network error');
+            throw new EwynApiError(500, 'NETWORK_ERROR', undefined, error instanceof Error ? error.message : 'Unknown network error');
         }
     }
 }
-export { MailerApiError } from './errors.js';
+export { EwynApiError } from './errors.js';

package/dist/types.d.ts

@@ -97,9 +97,9 @@ export interface SendEmailResponse {
     queuedAt: string;
 }
 /**
- * Configuration options for the Mailer client (base)
+ * Configuration options for the Ewyn client (base)
  */
-export interface MailerOptionsBase {
+export interface EwynOptionsBase {
     /** Workspace ID (UUID) */
     workspaceId: string;
     /** API key secret */
@@ -114,14 +114,14 @@ export interface MailerOptionsBase {
 /**
  * Configuration options with typed template config
  */
-export type MailerOptionsTyped<TConfig extends TemplateConfig> = MailerOptionsBase & {
+export type EwynOptionsTyped<TConfig extends TemplateConfig> = EwynOptionsBase & {
     /** Template configuration for type-safe sending */
     templates: TConfig;
 };
 /**
- * Configuration options for the Mailer client (generic version)
+ * Configuration options for the Ewyn client (generic version)
  */
-export type MailerOptions = MailerOptionsBase & {
+export type EwynOptions = EwynOptionsBase & {
     /** Template configuration for name-based sending and validation */
     templates?: TemplateConfig;
 };

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ewyn/client",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Official TypeScript SDK for Ewyn email service with full type safety",
   "type": "module",
   "main": "./dist/index.js",