@sendmailos/sdk 1.2.0 → 1.2.1

package/dist/index.js

@@ -58,9 +58,10 @@ var EmailsResource = class {
   }
   /**
    * Send a transactional email
-   * 
+   *
    * @example
    * ```ts
+   * // Business account (single-tenant)
    * const result = await client.emails.send({
    *   to: 'user@example.com',
    *   fromName: 'Your Company',
@@ -68,6 +69,16 @@ var EmailsResource = class {
    *   subject: 'Welcome!',
    *   html: '<h1>Hello!</h1>'
    * });
+   *
+   * // Agency account (multi-tenant) - identify client by domain
+   * const result = await agencyClient.emails.send({
+   *   to: 'customer@example.com',
+   *   fromName: 'Pizza Palace',
+   *   fromEmail: 'hello@pizzapalace.com',
+   *   subject: 'Your order is ready!',
+   *   html: '<h1>Order Ready!</h1>',
+   *   domain: 'pizzapalace.com'  // Required for agency accounts
+   * });
    * ```
    */
   async send(params) {
@@ -81,13 +92,15 @@ var EmailsResource = class {
         from_name: params.fromName,
         from_email: params.fromEmail,
         variables: params.variables,
-        type: params.type || "transactional"
+        type: params.type || "transactional",
+        workspace_id: params.workspaceId,
+        domain: params.domain
       })
     });
   }
   /**
    * Send email using a template
-   * 
+   *
    * @example
    * ```ts
    * const result = await client.emails.sendTemplate({
@@ -105,7 +118,9 @@ var EmailsResource = class {
       fromName: params.fromName,
       fromEmail: params.fromEmail,
       variables: params.variables,
-      type: "transactional"
+      type: "transactional",
+      workspaceId: params.workspaceId,
+      domain: params.domain
     });
   }
 };
@@ -117,14 +132,23 @@ var SubscribersResource = class {
   }
   /**
    * Create or update a subscriber (upsert)
-   * 
+   *
    * @example
    * ```ts
+   * // Business account
    * const { subscriber } = await client.subscribers.create({
    *   email: 'user@example.com',
    *   firstName: 'John',
    *   tags: ['newsletter', 'premium']
    * });
+   *
+   * // Agency account - subscriber tracked to client domain
+   * const { subscriber } = await agencyClient.subscribers.create({
+   *   email: 'customer@example.com',
+   *   firstName: 'Jane',
+   *   domain: 'pizzapalace.com',  // Required for agency accounts
+   *   tags: ['loyalty-member']
+   * });
    * ```
    */
   async create(params) {
@@ -135,7 +159,10 @@ var SubscribersResource = class {
         first_name: params.firstName,
         last_name: params.lastName,
         tags: params.tags,
-        domain_id: params.domainId
+        domain_id: params.domainId,
+        workspace_id: params.workspaceId,
+        domain: params.domain
+        // Alternative to workspace_id
       })
     });
   }
@@ -154,6 +181,8 @@ var SubscribersResource = class {
     const searchParams = new URLSearchParams();
     if (params.limit) searchParams.set("limit", String(params.limit));
     if (params.offset) searchParams.set("offset", String(params.offset));
+    if (params.workspaceId) searchParams.set("workspace_id", params.workspaceId);
+    if (params.domain) searchParams.set("domain", params.domain);
     const query = searchParams.toString();
     const endpoint = query ? `/subscribers?${query}` : "/subscribers";
     return this.request(endpoint, {
@@ -225,9 +254,10 @@ var CampaignsResource = class {
   }
   /**
    * Send a campaign to subscribers
-   * 
+   *
    * @example
    * ```ts
+   * // Business account
    * const result = await client.campaigns.send({
    *   name: 'January Newsletter',
    *   subject: 'What\'s new this month',
@@ -236,6 +266,17 @@ var CampaignsResource = class {
    *   html: '<h1>Hello {{first_name}}!</h1>',
    *   tags: ['newsletter', 'active']
    * });
+   *
+   * // Agency account - send to specific client's subscribers
+   * const result = await agencyClient.campaigns.send({
+   *   name: 'Pizza Promo',
+   *   subject: 'New menu items!',
+   *   fromName: 'Pizza Palace',
+   *   fromEmail: 'promo@pizzapalace.com',
+   *   html: '<h1>Check out our new menu!</h1>',
+   *   domain: 'pizzapalace.com',           // Filter to this client's subscribers
+   *   sourceDomains: ['pizzapalace.com']   // Only subscribers who signed up on this domain
+   * });
    * ```
    */
   async send(params) {
@@ -249,7 +290,10 @@ var CampaignsResource = class {
         html: params.html,
         templateId: params.templateId,
         tags: params.tags,
-        variables: params.variables
+        variables: params.variables,
+        workspace_id: params.workspaceId,
+        domain: params.domain,
+        sourceDomains: params.sourceDomains
       })
     });
   }
@@ -264,7 +308,10 @@ var CampaignsResource = class {
       fromEmail: params.fromEmail,
       templateId: params.templateId,
       tags: params.tags,
-      variables: params.variables
+      variables: params.variables,
+      workspaceId: params.workspaceId,
+      domain: params.domain,
+      sourceDomains: params.sourceDomains
     });
   }
 };
@@ -556,6 +603,400 @@ var WorkspacesResource = class {
       client_can_view_reports: true
     });
   }
+  /**
+   * Smart workspace provisioning - finds existing or creates new
+   *
+   * This is the recommended method for agency client onboarding.
+   * It will:
+   * 1. Search for existing workspace by website URL or client_email
+   * 2. Return existing workspace if found
+   * 3. Create new workspace with industry templates if not found
+   * 4. Optionally generate a workspace-scoped API key
+   *
+   * @note Only available for agency accounts
+   *
+   * @example
+   * ```ts
+   * // Auto-provision workspace for a new client
+   * const result = await client.workspaces.provision({
+   *   name: 'Pizza Palace',
+   *   website: 'https://pizzapalace.com',
+   *   client_email: 'owner@pizzapalace.com',
+   *   industry: 'restaurants',
+   *   generate_api_key: true
+   * });
+   *
+   * if (result.is_new) {
+   *   console.log('Created new workspace:', result.workspace.id);
+   *   console.log('API Key:', result.api_key);
+   * } else {
+   *   console.log('Found existing workspace:', result.workspace.id);
+   * }
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Idempotent client setup - safe to call multiple times
+   * const { workspace, is_new } = await client.workspaces.provision({
+   *   name: 'Client Name',
+   *   website: 'https://client.com',
+   *   industry: 'ecommerce'
+   * });
+   * // Always returns the same workspace for the same website
+   * ```
+   */
+  async provision(request) {
+    const response = await this.request("/workspaces/provision", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    return {
+      workspace: response.workspace,
+      is_new: response.is_new,
+      api_key: response.api_key,
+      message: response.message
+    };
+  }
+  /**
+   * Alias for provision() - find or create workspace
+   * @see provision
+   */
+  async findOrCreate(request) {
+    return this.provision(request);
+  }
+  /**
+   * Complete client onboarding in ONE call (Agency only)
+   *
+   * This is the simplest way to onboard a new client:
+   * 1. Creates or finds workspace by domain
+   * 2. Registers domain for email verification
+   * 3. Generates workspace token
+   * 4. Returns DNS records + token
+   *
+   * After this, use the returned `token` for all API calls.
+   *
+   * @example
+   * ```ts
+   * // Your SaaS onboards a new restaurant
+   * const result = await agency.workspaces.onboard({
+   *   domain: 'pizzapalace.com',
+   *   industry: 'restaurants'
+   * });
+   *
+   * // Save this token - it's all you need
+   * saveToDatabase(restaurantId, result.token);
+   *
+   * // Show DNS records to restaurant owner
+   * console.log('Add these DNS records:', result.dns_records);
+   *
+   * // Later, use the token directly
+   * const restaurant = new SendMailOS(result.token);
+   * await restaurant.emails.send({ ... });
+   * ```
+   */
+  async onboard(request) {
+    const response = await this.request("/workspaces/onboard", {
+      method: "POST",
+      body: JSON.stringify(request)
+    });
+    return {
+      token: response.token,
+      workspace_id: response.workspace_id,
+      workspace_name: response.workspace_name,
+      domain: response.domain,
+      domain_status: response.domain_status,
+      dns_records: response.dns_records,
+      is_new: response.is_new,
+      message: response.message
+    };
+  }
+};
+
+// src/resources/workflows.ts
+var WorkflowsResource = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new workflow
+   *
+   * @example
+   * ```ts
+   * // Create workflow for a specific client (multi-brand)
+   * const result = await platform.workflows.create({
+   *   name: 'Welcome Sequence',
+   *   domain: 'pizzapalace.com',
+   *   trigger: { type: 'subscriber_created' }
+   * });
+   *
+   * // Create workflow (single brand)
+   * const result = await client.workflows.create({
+   *   name: 'Onboarding Flow',
+   *   trigger: { type: 'api' }
+   * });
+   * ```
+   */
+  async create(params) {
+    return this.request("/workflows", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * List all workflows
+   *
+   * @example
+   * ```ts
+   * // List all workflows
+   * const { workflows } = await client.workflows.list();
+   *
+   * // List workflows for a specific client (multi-brand)
+   * const { workflows } = await platform.workflows.list({ domain: 'pizzapalace.com' });
+   * ```
+   */
+  async list(params = {}) {
+    const searchParams = new URLSearchParams();
+    if (params.domain) searchParams.set("domain", params.domain);
+    if (params.workspace_id) searchParams.set("workspace_id", params.workspace_id);
+    const query = searchParams.toString();
+    const endpoint = query ? `/workflows?${query}` : "/workflows";
+    return this.request(endpoint, {
+      method: "GET"
+    });
+  }
+  /**
+   * Get a workflow by ID (includes nodes and edges)
+   *
+   * @example
+   * ```ts
+   * const { workflow } = await client.workflows.get('workflow-uuid');
+   * console.log(workflow.nodes); // The workflow steps
+   * console.log(workflow.edges); // Connections between steps
+   * ```
+   */
+  async get(workflowId) {
+    return this.request(`/workflows/${workflowId}`, {
+      method: "GET"
+    });
+  }
+  /**
+   * Update a workflow (name, nodes, edges, trigger)
+   *
+   * @example
+   * ```ts
+   * // Update workflow name
+   * await client.workflows.update('workflow-uuid', { name: 'New Name' });
+   *
+   * // Update workflow steps
+   * await client.workflows.update('workflow-uuid', {
+   *   nodes: [
+   *     { id: '1', type: 'trigger', data: { triggerType: 'api' } },
+   *     { id: '2', type: 'email', data: { templateId: 'tmpl_xxx', subject: 'Welcome!' } },
+   *     { id: '3', type: 'delay', data: { duration: 3, unit: 'days' } }
+   *   ],
+   *   edges: [
+   *     { id: 'e1', source: '1', target: '2' },
+   *     { id: 'e2', source: '2', target: '3' }
+   *   ]
+   * });
+   * ```
+   */
+  async update(workflowId, params) {
+    return this.request(`/workflows/${workflowId}`, {
+      method: "PUT",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete a workflow
+   */
+  async delete(workflowId) {
+    return this.request(`/workflows/${workflowId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Activate a workflow (start accepting triggers)
+   *
+   * @example
+   * ```ts
+   * await client.workflows.activate('workflow-uuid');
+   * // Workflow is now active and will process triggers
+   * ```
+   */
+  async activate(workflowId) {
+    return this.request(`/workflows/${workflowId}/activate`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Pause a workflow (stop accepting new triggers)
+   *
+   * @example
+   * ```ts
+   * await client.workflows.pause('workflow-uuid');
+   * // Workflow is paused - existing executions continue, but no new ones start
+   * ```
+   */
+  async pause(workflowId) {
+    return this.request(`/workflows/${workflowId}/pause`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Trigger a workflow for a subscriber
+   *
+   * @example
+   * ```ts
+   * // Trigger when a customer signs up
+   * const result = await platform.workflows.trigger('workflow-uuid', {
+   *   email: 'customer@example.com',
+   *   data: {
+   *     firstName: 'John',
+   *     restaurantName: 'Pizza Palace',
+   *     signupSource: 'website'
+   *   }
+   * });
+   *
+   * console.log(result.execution_id); // Track this execution
+   * ```
+   */
+  async trigger(workflowId, params) {
+    return this.request(`/webhooks/${workflowId}`, {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Send a custom event to resume waiting workflows
+   *
+   * Use this when you have workflows waiting for specific events (e.g., "purchase_completed").
+   * All workflows waiting for this event for the given subscriber will resume.
+   *
+   * @example
+   * ```ts
+   * // When a customer completes a purchase
+   * await platform.workflows.sendEvent({
+   *   event: 'purchase_completed',
+   *   email: 'customer@example.com',
+   *   data: { orderTotal: 45.99, orderId: 'ORD-123' }
+   * });
+   *
+   * // Any workflow with a "wait_for_event: purchase_completed" node will resume
+   * ```
+   */
+  async sendEvent(params) {
+    return this.request("/events", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+};
+
+// src/resources/webhooks.ts
+var WebhooksResource = class {
+  constructor(request) {
+    this.request = request;
+  }
+  /**
+   * Create a new webhook endpoint
+   *
+   * @example
+   * ```ts
+   * const webhook = await client.webhooks.create({
+   *   url: 'https://yourserver.com/webhooks',
+   *   events: ['email.sent', 'email.delivered', 'email.opened'],
+   *   secret: 'your-secret-key' // Optional, auto-generated if not provided
+   * });
+   *
+   * console.log('Webhook secret:', webhook.secret);
+   * ```
+   */
+  async create(params) {
+    return this.request("/webhooks", {
+      method: "POST",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * List all webhooks
+   */
+  async list() {
+    return this.request("/webhooks", {
+      method: "GET"
+    });
+  }
+  /**
+   * Get a webhook by ID with recent delivery history
+   */
+  async get(webhookId) {
+    return this.request(`/webhooks/${webhookId}`, {
+      method: "GET"
+    });
+  }
+  /**
+   * Update a webhook
+   *
+   * @example
+   * ```ts
+   * // Update webhook URL
+   * await client.webhooks.update('webhook-id', {
+   *   url: 'https://newserver.com/webhooks'
+   * });
+   *
+   * // Add new events
+   * await client.webhooks.update('webhook-id', {
+   *   events: ['email.sent', 'email.delivered', 'email.bounced']
+   * });
+   *
+   * // Disable webhook
+   * await client.webhooks.update('webhook-id', { active: false });
+   * ```
+   */
+  async update(webhookId, params) {
+    return this.request(`/webhooks/${webhookId}`, {
+      method: "PATCH",
+      body: JSON.stringify(params)
+    });
+  }
+  /**
+   * Delete a webhook
+   */
+  async delete(webhookId) {
+    return this.request(`/webhooks/${webhookId}`, {
+      method: "DELETE"
+    });
+  }
+  /**
+   * Test a webhook by sending a test event
+   *
+   * @example
+   * ```ts
+   * const result = await client.webhooks.test('webhook-id');
+   * if (result.test.sent) {
+   *   console.log(`Test delivered in ${result.test.responseTimeMs}ms`);
+   * } else {
+   *   console.log('Test failed:', result.test.error);
+   * }
+   * ```
+   */
+  async test(webhookId) {
+    return this.request(`/webhooks/${webhookId}/test`, {
+      method: "POST"
+    });
+  }
+  /**
+   * Enable a webhook
+   */
+  async enable(webhookId) {
+    return this.update(webhookId, { active: true });
+  }
+  /**
+   * Disable a webhook
+   */
+  async disable(webhookId) {
+    return this.update(webhookId, { active: false });
+  }
 };
 
 // src/client.ts
@@ -588,6 +1029,8 @@ var SendMailOS = class {
     this.domains = new DomainsResource(boundRequest);
     this.organization = new OrganizationResource(boundRequest);
     this.workspaces = new WorkspacesResource(boundRequest);
+    this.workflows = new WorkflowsResource(boundRequest);
+    this.webhooks = new WebhooksResource(boundRequest);
   }
   /**
    * Make an authenticated request to the API