@myapihq/cli 1.2.2 → 1.2.5

package/dist/commands/webhook.js

@@ -5,6 +5,7 @@ import { requireOrg } from '../helpers.js';
 export const EXPOSES = [
     'POST /webhook/orgs/{org_id}/endpoints',
     'GET /webhook/orgs/{org_id}/endpoints',
+    'PATCH /webhook/orgs/{org_id}/endpoints/{endpoint_id}',
     'DELETE /webhook/orgs/{org_id}/endpoints/{endpoint_id}',
     'GET /webhook/orgs/{org_id}/deliveries/{delivery_id}',
 ];
@@ -13,6 +14,8 @@ export const SCHEMA = {
     name: 'string',
     description: 'string',
     'crm-email-path': 'string',
+    // 2026-05-15: backend's POST/PATCH endpoints accept forward_url.
+    'forward-url': 'string',
 };
 export async function list(flags) {
     const config = requireConfig();
@@ -29,21 +32,78 @@ export async function list(flags) {
 }
 export async function create(nameArg, flags) {
     const config = requireConfig();
-    const orgId = requireOrg(flags, config, 'myapi webhook create <name> [--description <desc>] [--org <id>]');
+    const orgId = requireOrg(flags, config, 'myapi webhook create <name> [--description <desc>] [--crm-email-path <path>] [--forward-url <url>] [--org <id>]');
     const name = nameArg || flags.name;
     if (!name)
-        error('Missing required arguments.\nUsage: myapi webhook create <name> [--description <desc>] [--crm-email-path <path>] [--org <id>]\n   or: myapi webhook create --name <name> [...]');
+        error('Missing required arguments.\nUsage: myapi webhook create <name> [--description <desc>] [--crm-email-path <path>] [--forward-url <url>] [--org <id>]\n   or: myapi webhook create --name <name> [...]');
     const opts = {};
     if (typeof flags.description === 'string')
         opts.description = flags.description;
     if (typeof flags['crm-email-path'] === 'string')
         opts.crm_email_path = flags['crm-email-path'];
+    if (typeof flags['forward-url'] === 'string') {
+        validateForwardUrl(flags['forward-url']);
+        opts.forward_url = flags['forward-url'];
+    }
     const res = await sdkWebhook.createEndpoint(config.api_key, orgId, name, opts);
     if (flags.json) {
         printJson(res);
         return;
     }
     success(`Webhook created! ID: ${res.id}\nInbound URL: ${res.url}`);
+    if (opts.forward_url)
+        info(`Forwarding to: ${opts.forward_url}`);
+}
+export async function update(id, flags) {
+    const config = requireConfig();
+    const orgId = requireOrg(flags, config, 'myapi webhook update <id> [--name <name>] [--description <desc>] [--crm-email-path <path>] [--forward-url <url>] [--org <id>]');
+    if (!id)
+        error('Missing required arguments.\nUsage: myapi webhook update <id> [--name <name>] [--description <desc>] [--crm-email-path <path>] [--forward-url <url>]');
+    const payload = {};
+    if (typeof flags.name === 'string')
+        payload.name = flags.name;
+    if (typeof flags.description === 'string')
+        payload.description = flags.description;
+    // crm-email-path & forward-url accept "" (empty string) to explicitly
+    // disable. Don't coerce to undefined — that would mean "leave as-is".
+    if (typeof flags['crm-email-path'] === 'string')
+        payload.crm_email_path = flags['crm-email-path'];
+    if (typeof flags['forward-url'] === 'string') {
+        const fu = flags['forward-url'];
+        if (fu !== '')
+            validateForwardUrl(fu);
+        payload.forward_url = fu;
+    }
+    if (Object.keys(payload).length === 0) {
+        error('Nothing to update. Provide at least one of --name, --description, --crm-email-path, --forward-url.');
+    }
+    const res = await sdkWebhook.updateEndpoint(config.api_key, orgId, id, payload);
+    if (flags.json) {
+        printJson(res);
+        return;
+    }
+    success(`Webhook ${res.id} updated`);
+}
+// Exported for unit tests. Returns null on success, error message on failure.
+// Matches the backend's documented "Use http:// or https://" constraint.
+export function _validateForwardUrl(url) {
+    if (url === '')
+        return null; // empty = unset; valid
+    try {
+        const u = new URL(url);
+        if (u.protocol !== 'http:' && u.protocol !== 'https:') {
+            return `--forward-url must use http:// or https:// (got ${u.protocol})`;
+        }
+        return null;
+    }
+    catch {
+        return `--forward-url is not a valid URL: "${url}"`;
+    }
+}
+function validateForwardUrl(url) {
+    const err = _validateForwardUrl(url);
+    if (err)
+        error(err);
 }
 export async function del(id, flags) {
     const config = requireConfig();
@@ -74,6 +134,14 @@ CRM auto-ingest (optional):
                                 Default 'email' (top-level). For Stripe:
                                 'data.object.customer_email'. For GitHub:
                                 'sender.email'. Empty string disables ingest.`,
+    'update': `myapi webhook update <id> [--name <name>] [--description <desc>] [--crm-email-path <path>] [--forward-url <url>] [--org <id>]
+
+All fields optional — only the ones you pass get changed. Pass an empty
+string to --crm-email-path or --forward-url to explicitly clear that
+field (e.g., --forward-url "" disables forwarding without deleting the
+endpoint).
+
+Slug is immutable; create a new endpoint if you need a different slug.`,
     'delete': 'myapi webhook delete <id> [--org <id>]',
     'delivery': 'myapi webhook delivery <delivery_id> [--org <id>]',
 };
@@ -84,6 +152,7 @@ export async function run(subcommand, args, flags) {
 Subcommands:
   list       List all inbound webhook endpoints
   create     Create a new endpoint to receive data (returns an inbound URL)
+  update     Patch endpoint name / description / crm-email-path / forward-url
   delete     Delete a webhook endpoint
   delivery   Inspect a specific webhook delivery (payload, received_at)
 
@@ -118,6 +187,7 @@ See the my-webhook-api skill for the full HTML + JS recipe.`);
     switch (subcommand) {
         case 'list': return list(flags);
         case 'create': return create(args[0], flags);
+        case 'update': return update(args[0], flags);
         case 'delete': return del(args[0], flags);
         case 'delivery': return delivery(args[0], flags);
         default: error(`Unknown subcommand: ${subcommand}. Run "myapi webhook --help" for a list of valid subcommands.`);

package/dist/commands/workflow-validation.test.d.ts

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

package/dist/commands/workflow-validation.test.js

@@ -0,0 +1,137 @@
+// Unit tests for workflow.ts CLI's pure step validator. The 2026-05-15
+// additive contract change adds `http_request` (alias `http`) to the
+// supported step types; this test file pins the new validation rules and
+// regression-tests the prior shapes.
+import { describe, it, expect } from 'vitest';
+import { _validateSteps } from './workflow.js';
+const VALID_EMAIL = { type: 'send_email', from: 'a@x.com', to: 'b@x.com', subject: 'hi', html: '<p>x</p>' };
+const VALID_SLACK = { type: 'slack_message', webhook_url: 'https://hooks.slack.com/services/T1/B1/abc', text: 'hi' };
+const VALID_HTTP = { type: 'http_request', url: 'https://example.com/hook' };
+describe('_validateSteps — input shape', () => {
+    it('rejects non-array', () => {
+        expect(_validateSteps('not an array')).toMatch(/must be a JSON array/);
+        expect(_validateSteps({})).toMatch(/must be a JSON array/);
+        expect(_validateSteps(null)).toMatch(/must be a JSON array/);
+    });
+    it('rejects empty array', () => {
+        expect(_validateSteps([])).toMatch(/cannot be an empty array/);
+    });
+    it('rejects steps that are not objects', () => {
+        expect(_validateSteps(['string'])).toMatch(/must be a JSON object/);
+        expect(_validateSteps([null])).toMatch(/must be a JSON object/);
+    });
+    it('rejects unknown step types', () => {
+        expect(_validateSteps([{ type: 'pigeon' }])).toMatch(/unknown type "pigeon"/);
+    });
+    it('rejects steps missing the type field', () => {
+        expect(_validateSteps([{ from: 'x' }])).toMatch(/missing required field "type"/);
+    });
+});
+describe('_validateSteps — send_email / email', () => {
+    it('accepts valid send_email with html body', () => {
+        expect(_validateSteps([VALID_EMAIL])).toBeNull();
+    });
+    it('accepts the `email` alias', () => {
+        expect(_validateSteps([{ ...VALID_EMAIL, type: 'email' }])).toBeNull();
+    });
+    it('rejects send_email missing required fields', () => {
+        expect(_validateSteps([{ type: 'send_email', from: 'a@x.com' }]))
+            .toMatch(/missing required field "to"/);
+    });
+    it('rejects send_email with no body form', () => {
+        expect(_validateSteps([{ type: 'send_email', from: 'a@x.com', to: 'b@x.com', subject: 's' }]))
+            .toMatch(/must include exactly one of "body", "html", or "template_id"/);
+    });
+    it('rejects send_email with multiple body forms', () => {
+        expect(_validateSteps([{ ...VALID_EMAIL, body: 'plain', html: '<p>x</p>' }]))
+            .toMatch(/can only use one of/);
+    });
+    it('rejects template_vars without template_id', () => {
+        expect(_validateSteps([{ ...VALID_EMAIL, template_vars: { name: 'x' } }]))
+            .toMatch(/"template_vars" only makes sense with "template_id"/);
+    });
+});
+describe('_validateSteps — slack_message / slack', () => {
+    it('accepts valid slack_message', () => {
+        expect(_validateSteps([VALID_SLACK])).toBeNull();
+    });
+    it('accepts the `slack` alias', () => {
+        expect(_validateSteps([{ ...VALID_SLACK, type: 'slack' }])).toBeNull();
+    });
+    it('rejects slack with non-Slack webhook URL', () => {
+        expect(_validateSteps([{ ...VALID_SLACK, webhook_url: 'https://example.com/hook' }]))
+            .toMatch(/must look like https:\/\/hooks\.slack\.com/);
+    });
+    it('rejects slack missing text', () => {
+        expect(_validateSteps([{ type: 'slack_message', webhook_url: VALID_SLACK.webhook_url }]))
+            .toMatch(/missing required field "text"/);
+    });
+});
+describe('_validateSteps — http_request / http (2026-05-15)', () => {
+    it('accepts the canonical type name', () => {
+        expect(_validateSteps([VALID_HTTP])).toBeNull();
+    });
+    it('accepts the `http` alias', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, type: 'http' }])).toBeNull();
+    });
+    it('accepts all supported HTTP methods', () => {
+        for (const m of ['GET', 'POST', 'PATCH', 'PUT', 'DELETE']) {
+            expect(_validateSteps([{ ...VALID_HTTP, method: m }])).toBeNull();
+        }
+    });
+    it('accepts a body string with templating', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, body: '{"email":"{{ payload.email }}"}' }])).toBeNull();
+    });
+    it('accepts a headers map of strings', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, headers: { 'X-Token': 'abc', 'X-Other': 'def' } }])).toBeNull();
+    });
+    it('rejects when url is missing', () => {
+        expect(_validateSteps([{ type: 'http_request' }]))
+            .toMatch(/missing required field "url"/);
+    });
+    it('rejects when url is not a string', () => {
+        expect(_validateSteps([{ type: 'http_request', url: 12345 }]))
+            .toMatch(/missing required field "url"/);
+    });
+    it('rejects non-http(s) URLs', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, url: 'ftp://example.com' }]))
+            .toMatch(/must start with http:\/\/ or https:\/\//);
+        expect(_validateSteps([{ ...VALID_HTTP, url: 'javascript:alert(1)' }]))
+            .toMatch(/must start with http:\/\/ or https:\/\//);
+    });
+    it('rejects unknown HTTP methods', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, method: 'TRACE' }]))
+            .toMatch(/"method" must be one of/);
+    });
+    it('rejects body as a non-string (object)', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, body: { not: 'a string' } }]))
+            .toMatch(/"body" must be a string/);
+    });
+    it('rejects headers as a non-object', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, headers: 'X-Token: abc' }]))
+            .toMatch(/"headers" must be a JSON object/);
+    });
+    it('rejects headers as an array', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, headers: ['X-Token: abc'] }]))
+            .toMatch(/"headers" must be a JSON object/);
+    });
+    it('rejects header value that is not a string', () => {
+        expect(_validateSteps([{ ...VALID_HTTP, headers: { 'X-Token': 42 } }]))
+            .toMatch(/"headers" value for "X-Token" must be a string/);
+    });
+});
+describe('_validateSteps — mixed-type pipelines', () => {
+    it('accepts an http_request after a send_email (pipeline shape)', () => {
+        expect(_validateSteps([
+            VALID_EMAIL,
+            { ...VALID_HTTP, body: '{"sent_to":"{{ payload.email }}"}' },
+        ])).toBeNull();
+    });
+    it('reports the failing step index in the error message', () => {
+        expect(_validateSteps([
+            VALID_EMAIL,
+            VALID_SLACK,
+            { type: 'http_request' }, // missing url at index 2
+        ])).toMatch(/^step 2 \(http_request\):/);
+    });
+});

package/dist/commands/workflow.d.ts

@@ -3,6 +3,7 @@ import { type Flags } from '../helpers.js';
 import type { Exposes } from '../exposes.js';
 export declare const EXPOSES: Exposes;
 export declare const SCHEMA: FlagSchema;
+export declare function _validateSteps(steps: unknown): string | null;
 export declare function list(flags: Flags): Promise<void>;
 export declare function get(id: string, flags: Flags): Promise<void>;
 export declare function create(nameArg: string | undefined, flags: Flags): Promise<void>;

package/dist/commands/workflow.js

@@ -23,59 +23,100 @@ export const SCHEMA = {
 // Mirrors the backend's SupportedStepTypes list. Both alias and underscore
 // forms are accepted by the workflow runner. Keep this in sync if the
 // backend grows new step types.
-const SUPPORTED_STEP_TYPES = ['send_email', 'email', 'slack_message', 'slack'];
+//
+// 2026-05-15: backend added `http_request` (alias `http`). See
+// myapi-hq/internal/routes/workflow/execute.go.
+const SUPPORTED_STEP_TYPES = ['send_email', 'email', 'slack_message', 'slack', 'http_request', 'http'];
+const HTTP_METHODS = new Set(['GET', 'POST', 'PATCH', 'PUT', 'DELETE']);
 const SLACK_HOOK_RE = /^https:\/\/hooks\.slack\.com\/services\/[A-Za-z0-9_-]+\/[A-Za-z0-9_-]+\/[A-Za-z0-9_-]+/;
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 // Per-step-type required fields. Validated client-side so typos and
 // hallucinated shapes fail fast, before the network call. Backend
 // performs the same validation as defense in depth.
-function validateSteps(steps) {
+//
+// `_validateSteps` is the pure form — returns the first error message
+// (string) or null on success. Suitable for unit tests. The internal
+// `validateSteps` wrapper calls `error()` on a non-null result, which
+// exits the process — used by command handlers.
+export function _validateSteps(steps) {
     if (!Array.isArray(steps))
-        error('--steps must be a JSON array of step objects.');
+        return '--steps must be a JSON array of step objects.';
     if (steps.length === 0)
-        error('--steps cannot be an empty array.');
-    steps.forEach((s, i) => {
+        return '--steps cannot be an empty array.';
+    for (let i = 0; i < steps.length; i++) {
+        const s = steps[i];
         const where = `step ${i}`;
         if (!s || typeof s !== 'object')
-            error(`${where}: must be a JSON object.`);
+            return `${where}: must be a JSON object.`;
         if (!s.type)
-            error(`${where}: missing required field "type". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
+            return `${where}: missing required field "type". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`;
         if (!SUPPORTED_STEP_TYPES.includes(s.type)) {
-            error(`${where}: unknown type "${s.type}". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`);
+            return `${where}: unknown type "${s.type}". Supported: ${SUPPORTED_STEP_TYPES.join(', ')}`;
         }
         if (s.type === 'send_email' || s.type === 'email') {
             const required = ['from', 'to', 'subject'];
             for (const f of required) {
                 if (!s[f] || typeof s[f] !== 'string') {
-                    error(`${where} (${s.type}): missing required field "${f}".`);
+                    return `${where} (${s.type}): missing required field "${f}".`;
                 }
             }
             const bodyForms = ['body', 'html', 'template_id'].filter(f => s[f] !== undefined && s[f] !== '');
             if (bodyForms.length === 0) {
-                error(`${where} (${s.type}): must include exactly one of "body", "html", or "template_id".`);
+                return `${where} (${s.type}): must include exactly one of "body", "html", or "template_id".`;
             }
             if (bodyForms.length > 1) {
-                error(`${where} (${s.type}): can only use one of "body", "html", "template_id" — got: ${bodyForms.join(', ')}.`);
+                return `${where} (${s.type}): can only use one of "body", "html", "template_id" — got: ${bodyForms.join(', ')}.`;
             }
             if (s.template_vars !== undefined && !s.template_id) {
-                error(`${where} (${s.type}): "template_vars" only makes sense with "template_id".`);
+                return `${where} (${s.type}): "template_vars" only makes sense with "template_id".`;
             }
             if (s.template_vars !== undefined && (typeof s.template_vars !== 'object' || Array.isArray(s.template_vars))) {
-                error(`${where} (${s.type}): "template_vars" must be a JSON object.`);
+                return `${where} (${s.type}): "template_vars" must be a JSON object.`;
             }
         }
         if (s.type === 'slack_message' || s.type === 'slack') {
             if (!s.webhook_url || typeof s.webhook_url !== 'string') {
-                error(`${where} (${s.type}): missing required field "webhook_url".`);
+                return `${where} (${s.type}): missing required field "webhook_url".`;
             }
             if (!SLACK_HOOK_RE.test(s.webhook_url)) {
-                error(`${where} (${s.type}): "webhook_url" must look like https://hooks.slack.com/services/T.../B.../xxx — got "${s.webhook_url}".`);
+                return `${where} (${s.type}): "webhook_url" must look like https://hooks.slack.com/services/T.../B.../xxx — got "${s.webhook_url}".`;
             }
             if (!s.text || typeof s.text !== 'string') {
-                error(`${where} (${s.type}): missing required field "text".`);
+                return `${where} (${s.type}): missing required field "text".`;
             }
         }
-    });
+        if (s.type === 'http_request' || s.type === 'http') {
+            if (!s.url || typeof s.url !== 'string') {
+                return `${where} (${s.type}): missing required field "url".`;
+            }
+            if (!/^https?:\/\//.test(s.url)) {
+                return `${where} (${s.type}): "url" must start with http:// or https:// — got "${s.url}".`;
+            }
+            if (s.method !== undefined) {
+                if (typeof s.method !== 'string' || !HTTP_METHODS.has(s.method.toUpperCase())) {
+                    return `${where} (${s.type}): "method" must be one of ${[...HTTP_METHODS].join(', ')}.`;
+                }
+            }
+            if (s.body !== undefined && typeof s.body !== 'string') {
+                return `${where} (${s.type}): "body" must be a string (template substitutions supported).`;
+            }
+            if (s.headers !== undefined) {
+                if (typeof s.headers !== 'object' || Array.isArray(s.headers)) {
+                    return `${where} (${s.type}): "headers" must be a JSON object of {string: string}.`;
+                }
+                for (const [k, v] of Object.entries(s.headers)) {
+                    if (typeof v !== 'string')
+                        return `${where} (${s.type}): "headers" value for "${k}" must be a string.`;
+                }
+            }
+        }
+    }
+    return null;
+}
+function validateSteps(steps) {
+    const err = _validateSteps(steps);
+    if (err)
+        error(err);
 }
 function summarizeWorkflow(w) {
     return {

package/dist/exposes.test.js

@@ -37,6 +37,7 @@ const COMMAND_MODULES = [
     './commands/url.js',
     './commands/webhook.js',
     './commands/workflow.js',
+    './commands/fn.js',
 ];
 const ENDPOINT_PATTERN = /^(GET|POST|PATCH|PUT|DELETE) \/[A-Za-z0-9_\-./{}]*$/;
 describe('every CLI command exports a typed EXPOSES array (S-101)', () => {

package/dist/index.js

@@ -29,6 +29,7 @@ import * as audienceCmd from './commands/audience.js';
 import * as llmCmd from './commands/llm.js';
 import * as databaseCmd from './commands/database.js';
 import * as crmCmd from './commands/crm/index.js';
+import * as fnCmd from './commands/fn.js';
 import { initCompletion, installCompletion, uninstallCompletion } from './completion.js';
 // Each command file declares the value flags it understands. We union them
 // into a single schema for the upfront parse, so adding a new value flag in
@@ -55,6 +56,7 @@ const COMBINED_SCHEMA = {
     ...urlCmd.SCHEMA,
     ...webhookCmd.SCHEMA,
     ...workflowCmd.SCHEMA,
+    ...fnCmd.SCHEMA,
     // Top-level flags
     version: 'boolean',
     V: 'boolean',
@@ -88,13 +90,26 @@ const ERROR_MESSAGES = {
     INVALID_TTL: 'Invalid TTL. Use the auto sentinel (1) or a value between 60 and 86400 seconds.',
     INVALID_RECORD_CONTENT: 'Invalid record content for this type.',
     RECORD_LIMIT_EXCEEDED: 'Cloudflare per-zone record limit reached.',
-    CF_API_ERROR: 'Cloudflare API error. The backend will surface a `cf_message` field with the underlying detail.',
+    CF_API_ERROR: 'Cloudflare API error.',
     // invalid_json_response intentionally absent — the SDK's MyApiError now
     // builds a useful detailed message for that case (status + URL + body
     // snippet), and friendlyError(err.code) would override it.
 };
-function friendlyError(code) {
-    return ERROR_MESSAGES[code] || code;
+function friendlyError(err) {
+    const body = err.body ?? {};
+    // CF_API_ERROR: the cf_message already includes a "Cloudflare API error"
+    // prefix, so use it verbatim (with cf_status if present) instead of doubling.
+    if (err.code === 'CF_API_ERROR' && typeof body.cf_message === 'string') {
+        return typeof body.cf_status === 'number'
+            ? `${body.cf_message} (HTTP ${body.cf_status})`
+            : body.cf_message;
+    }
+    const base = ERROR_MESSAGES[err.code] || err.code;
+    // Generic fallback: append the backend's `message` when it adds info beyond
+    // the friendly mapping. Future per-service detail fields can be added here.
+    if (err.detail && err.detail !== base)
+        return `${base} — ${err.detail}`;
+    return base;
 }
 async function main() {
     // Shell autocomplete: if invoked by the shell with completion env vars,
@@ -184,6 +199,9 @@ async function main() {
             case 'url':
                 await urlCmd.run(subcommand, restArgs, flags);
                 break;
+            case 'fn':
+                await fnCmd.run(subcommand, restArgs, flags);
+                break;
             // Convenience aliases
             case 'setup':
                 await setupCmd.setup(flags);
@@ -250,7 +268,7 @@ async function main() {
                 }
             }
             else
-                error(friendlyError(err.code) || err.message);
+                error(friendlyError(err) || err.message);
         }
         else {
             // Don't JSON.stringify Error instances — that returns "{}" because
@@ -304,6 +322,7 @@ const HELP_TARGETS = {
     llm: f => llmCmd.run(undefined, [], f),
     database: f => databaseCmd.run(undefined, [], f),
     crm: f => crmCmd.run(undefined, [], f),
+    fn: f => fnCmd.run(undefined, [], f),
     org: f => orgCmd.run(undefined, [], f),
     billing: f => billingCmd.run(undefined, [], f),
     keys: f => keysCmd.run(undefined, [], f),
@@ -345,6 +364,7 @@ Commands:
   update          Update CLI and skills to the latest version
   domain          Manage domain configurations
   funnel          Manage websites (publish pages, custom domains, funnels)
+  fn              Create functions on the edge runtime (Story 1 — metadata + scoped key only; bundle upload pending Story 2)
   webhook         Manage inbound webhook endpoints and inspect deliveries
   email           Manage mailboxes, send/read email, templates, and campaigns
   workflow        Run actions (send email, post to Slack) when a webhook fires

package/dist/sdk-domain-assign.test.d.ts

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

package/dist/sdk-domain-assign.test.js

@@ -0,0 +1,53 @@
+// Verifies the 2026-05-15 additive contract change: POST
+// /domain/.../{domain}/assign now accepts an optional `funnel_id` in the body.
+// SDK assignDomain takes `{ funnelId?: string }` and forwards it.
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { domain } from '@myapihq/sdk';
+const API_KEY = 'myapi_test_abc';
+const ORG_ID = '11111111-1111-4111-8111-111111111111';
+const DOMAIN = 'example.com';
+const FUNNEL_ID = '33333333-3333-4333-8333-333333333333';
+let fetchMock;
+function ok(data) {
+    return new Response(JSON.stringify({ success: true, data, meta: {} }), {
+        status: 200,
+        headers: { 'content-type': 'application/json' },
+    });
+}
+beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue(ok({
+        domain: DOMAIN, org_id: ORG_ID, include_www: true, routes_bound: [DOMAIN, `www.${DOMAIN}`],
+    }));
+    globalThis.fetch = fetchMock;
+});
+afterEach(() => {
+    vi.restoreAllMocks();
+});
+describe('domain.assignDomain — funnel_id (additive 2026-05-15)', () => {
+    it('omits funnel_id from body by default (back-compat)', async () => {
+        await domain.assignDomain(API_KEY, ORG_ID, DOMAIN);
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toEqual({ org_id: ORG_ID });
+        expect(body).not.toHaveProperty('funnel_id');
+    });
+    it('includes funnel_id when passed in opts', async () => {
+        await domain.assignDomain(API_KEY, ORG_ID, DOMAIN, { funnelId: FUNNEL_ID });
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toEqual({ org_id: ORG_ID, funnel_id: FUNNEL_ID });
+    });
+    it('combines funnel_id with include_www=false', async () => {
+        await domain.assignDomain(API_KEY, ORG_ID, DOMAIN, { funnelId: FUNNEL_ID, includeWww: false });
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toEqual({ org_id: ORG_ID, include_www: false, funnel_id: FUNNEL_ID });
+    });
+    it('omits funnel_id when it is empty string (treat as not-set)', async () => {
+        await domain.assignDomain(API_KEY, ORG_ID, DOMAIN, { funnelId: '' });
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).not.toHaveProperty('funnel_id');
+    });
+    it('still works for unassignDomain (no funnel_id involved)', async () => {
+        await domain.unassignDomain(API_KEY, ORG_ID, DOMAIN);
+        const body = JSON.parse(fetchMock.mock.calls[0][1].body);
+        expect(body).toEqual({ org_id: null });
+    });
+});

package/dist/sdk-function.test.d.ts

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