resend-cli 1.0.2 → 1.1.0

package/tests/commands/webhooks/list.test.ts

@@ -0,0 +1,177 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockList = mock(async () => ({
+  data: {
+    object: 'list' as const,
+    has_more: false,
+    data: [
+      {
+        id: 'wh_abc123',
+        endpoint: 'https://app.example.com/hooks/resend',
+        events: ['email.sent', 'email.bounced'] as string[],
+        status: 'enabled' as const,
+        created_at: '2026-01-01T00:00:00.000Z',
+      },
+    ],
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { list: mockList };
+  },
+}));
+
+describe('webhooks list command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let stderrSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockList.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('calls SDK list method with default pagination', async () => {
+    spies = setupOutputSpies();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.parseAsync([], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(10);
+  });
+
+  test('passes --limit to pagination options', async () => {
+    spies = setupOutputSpies();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.parseAsync(['--limit', '5'], { from: 'user' });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.limit).toBe(5);
+  });
+
+  test('passes --after cursor to pagination options', async () => {
+    spies = setupOutputSpies();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.parseAsync(['--after', 'wh_cursor123'], {
+      from: 'user',
+    });
+
+    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.after).toBe('wh_cursor123');
+  });
+
+  test('outputs JSON list with webhook data when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await listWebhooksCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(Array.isArray(parsed.data)).toBe(true);
+    expect(parsed.data[0].id).toBe('wh_abc123');
+    expect(parsed.data[0].endpoint).toBe(
+      'https://app.example.com/hooks/resend',
+    );
+    expect(parsed.has_more).toBe(false);
+  });
+
+  test('errors with invalid_limit for out-of-range limit', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await expectExit1(() =>
+      listWebhooksCommand.parseAsync(['--limit', '200'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_limit');
+  });
+
+  test('errors with auth_error when no API key', async () => {
+    setNonInteractive();
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await expectExit1(() =>
+      listWebhooksCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with list_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockList.mockResolvedValueOnce(
+      mockSdkError('Server error', 'server_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listWebhooksCommand } = await import(
+      '../../../src/commands/webhooks/list'
+    );
+    await expectExit1(() =>
+      listWebhooksCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/tests/commands/webhooks/update.test.ts

@@ -0,0 +1,206 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockUpdate = mock(async () => ({
+  data: { object: 'webhook' as const, id: 'wh_abc123' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { update: mockUpdate };
+  },
+}));
+
+describe('webhooks update command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let stderrSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key';
+    mockUpdate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('updates endpoint with --endpoint flag', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--endpoint', 'https://new-app.example.com/hooks'],
+      { from: 'user' },
+    );
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
+    expect(mockUpdate.mock.calls[0][0]).toBe('wh_abc123');
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.endpoint).toBe('https://new-app.example.com/hooks');
+  });
+
+  test('updates events with --events flag', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--events', 'email.sent', 'email.bounced'],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.events).toEqual(['email.sent', 'email.bounced']);
+  });
+
+  test('expands "all" shorthand in --events to 17 events', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(['wh_abc123', '--events', 'all'], {
+      from: 'user',
+    });
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.events).toHaveLength(17);
+  });
+
+  test('updates status with --status flag', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--status', 'disabled'],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.status).toBe('disabled');
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await updateWebhookCommand.parseAsync(
+      ['wh_abc123', '--status', 'enabled'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('webhook');
+    expect(parsed.id).toBe('wh_abc123');
+  });
+
+  test('errors with no_changes when no flags are provided', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('no_changes');
+  });
+
+  test('does not call SDK when no_changes error is raised', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' }),
+    );
+
+    expect(mockUpdate).not.toHaveBeenCalled();
+  });
+
+  test('errors with auth_error when no API key', async () => {
+    setNonInteractive();
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(['wh_abc123', '--status', 'enabled'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with update_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockUpdate.mockResolvedValueOnce(
+      mockSdkError('Webhook not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateWebhookCommand } = await import(
+      '../../../src/commands/webhooks/update'
+    );
+    await expectExit1(() =>
+      updateWebhookCommand.parseAsync(
+        ['wh_nonexistent', '--status', 'disabled'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_error');
+  });
+});

package/tests/commands/whoami.test.ts

@@ -0,0 +1,99 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  type spyOn,
+  test,
+} from 'bun:test';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../helpers';
+
+describe('whoami command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmpDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = tmpDir;
+    delete process.env.RESEND_API_KEY;
+    delete process.env.RESEND_TEAM;
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    spies = undefined;
+    errorSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy?.mockRestore();
+    exitSpy = undefined;
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  test('exits 1 when not authenticated (non-interactive)', async () => {
+    spies = setupOutputSpies();
+    exitSpy = mockExitThrow();
+
+    const { whoamiCommand } = await import('../../src/commands/whoami');
+    await expectExit1(() => whoamiCommand.parseAsync([], { from: 'user' }));
+
+    const output = spies.logSpy.mock.calls[0]?.[0] as string | undefined;
+    if (output) {
+      const parsed = JSON.parse(output);
+      expect(parsed.authenticated).toBe(false);
+    }
+  });
+
+  test('shows authenticated JSON when key exists in config', async () => {
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    writeFileSync(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'production',
+        teams: { production: { api_key: 're_test_key_abcd' } },
+      }),
+    );
+
+    spies = setupOutputSpies();
+
+    const { whoamiCommand } = await import('../../src/commands/whoami');
+    await whoamiCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.authenticated).toBe(true);
+    expect(parsed.team).toBe('production');
+    expect(parsed.api_key).toBe('re_...abcd');
+    expect(parsed.source).toBe('config');
+  });
+
+  test('shows env source when RESEND_API_KEY is set', async () => {
+    process.env.RESEND_API_KEY = 're_env_key_5678';
+
+    spies = setupOutputSpies();
+
+    const { whoamiCommand } = await import('../../src/commands/whoami');
+    await whoamiCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.authenticated).toBe(true);
+    expect(parsed.source).toBe('env');
+  });
+});

package/tests/helpers.ts

@@ -0,0 +1,93 @@
+import { expect, spyOn } from 'bun:test';
+
+export class ExitError extends Error {
+  constructor(public code: number) {
+    super(`process.exit(${code})`);
+  }
+}
+
+export function setNonInteractive(): void {
+  Object.defineProperty(process.stdin, 'isTTY', {
+    value: undefined,
+    writable: true,
+  });
+  Object.defineProperty(process.stdout, 'isTTY', {
+    value: undefined,
+    writable: true,
+  });
+}
+
+export function mockExitThrow(): ReturnType<typeof spyOn> {
+  return spyOn(process, 'exit').mockImplementation((code?: number) => {
+    throw new ExitError(code ?? 0);
+  });
+}
+
+/**
+ * Captures current env and TTY state and returns a function that restores it.
+ * Call once at the top of a describe block (not inside beforeEach) so state
+ * is captured before any test runs.
+ */
+export function captureTestEnv(): () => void {
+  const originalEnv = { ...process.env };
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  return () => {
+    process.env = { ...originalEnv };
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  };
+}
+
+/**
+ * Sets non-interactive mode and mocks console.log + process.stderr.write.
+ * Returns the spies and a restore() function. Use in happy-path tests.
+ */
+export function setupOutputSpies() {
+  setNonInteractive();
+  const logSpy = spyOn(console, 'log').mockImplementation(() => {});
+  const stderrSpy = spyOn(process.stderr, 'write').mockImplementation(
+    () => true,
+  );
+  return {
+    logSpy,
+    stderrSpy,
+    restore() {
+      logSpy.mockRestore();
+      stderrSpy.mockRestore();
+    },
+  };
+}
+
+/**
+ * Asserts that fn throws ExitError with code 1.
+ * Eliminates the expect(true).toBe(false) anti-pattern in error-path tests.
+ */
+/**
+ * Returns a properly-typed SDK error response without needing `as any`.
+ */
+export function mockSdkError(message: string, name = 'error') {
+  return { data: null, error: { message, name }, headers: null };
+}
+
+export async function expectExit1(fn: () => Promise<unknown>): Promise<void> {
+  let threw = false;
+  try {
+    await fn();
+  } catch (err) {
+    threw = true;
+    expect(err).toBeInstanceOf(ExitError);
+    expect((err as ExitError).code).toBe(1);
+  }
+  if (!threw) {
+    throw new Error(
+      'Expected command to exit with code 1 but it completed successfully',
+    );
+  }
+}

package/tests/lib/client.test.ts

@@ -0,0 +1,71 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { Resend } from 'resend';
+import { captureTestEnv } from '../helpers';
+
+describe('createClient', () => {
+  const restoreEnv = captureTestEnv();
+
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  test('returns Resend instance when flag value provided', () => {
+    const { createClient } = require('../../src/lib/client');
+    const client = createClient('re_test_key');
+    expect(client).toBeInstanceOf(Resend);
+  });
+
+  test('returns Resend instance when env var set', () => {
+    process.env.RESEND_API_KEY = 're_env_key';
+    const { createClient } = require('../../src/lib/client');
+    const client = createClient();
+    expect(client).toBeInstanceOf(Resend);
+  });
+
+  test('throws when no API key available', () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend-test';
+    const { createClient } = require('../../src/lib/client');
+    expect(() => createClient()).toThrow('No API key found');
+  });
+
+  test('flag value takes priority over env var', () => {
+    process.env.RESEND_API_KEY = 're_env_key';
+    const { createClient } = require('../../src/lib/client');
+    const client = createClient('re_flag_key');
+    expect(client).toBeInstanceOf(Resend);
+  });
+
+  test('team name is threaded through to resolveApiKey', () => {
+    delete process.env.RESEND_API_KEY;
+    const tmpDir = join(
+      tmpdir(),
+      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
+    );
+    mkdirSync(tmpDir, { recursive: true });
+    process.env.XDG_CONFIG_HOME = tmpDir;
+
+    const configDir = join(tmpDir, 'resend');
+    mkdirSync(configDir, { recursive: true });
+    Bun.write(
+      join(configDir, 'credentials.json'),
+      JSON.stringify({
+        active_team: 'default',
+        teams: {
+          default: { api_key: 're_default_key' },
+          staging: { api_key: 're_staging_key' },
+        },
+      }),
+    );
+
+    const { createClient } = require('../../src/lib/client');
+    // Should not throw — resolves staging team's key
+    const client = createClient(undefined, 'staging');
+    expect(client).toBeInstanceOf(Resend);
+
+    rmSync(tmpDir, { recursive: true, force: true });
+  });
+});