resend-cli 1.0.2 → 1.1.0

package/tests/commands/broadcasts/get.test.ts

@@ -0,0 +1,146 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockGet = mock(async () => ({
+  data: {
+    object: 'broadcast' as const,
+    id: 'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+    name: 'Weekly Newsletter',
+    segment_id: '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
+    audience_id: null,
+    from: 'hello@domain.com',
+    subject: 'This week in Resend',
+    reply_to: null,
+    preview_text: 'Read what is new',
+    html: '<p>Hi</p>',
+    text: null,
+    status: 'sent' as const,
+    created_at: '2026-02-18T12:00:00.000Z',
+    scheduled_at: null,
+    sent_at: '2026-02-18T12:05:00.000Z',
+    topic_id: null,
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    broadcasts = { get: mockGet };
+  },
+}));
+
+describe('broadcasts get 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';
+    mockGet.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('fetches broadcast by id', async () => {
+    spies = setupOutputSpies();
+
+    const { getBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/get'
+    );
+    await getBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      { from: 'user' },
+    );
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    expect(mockGet.mock.calls[0][0]).toBe(
+      'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+    );
+  });
+
+  test('outputs full JSON when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { getBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/get'
+    );
+    await getBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+    expect(parsed.status).toBe('sent');
+    expect(parsed.subject).toBe('This week in Resend');
+  });
+
+  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 { getBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/get'
+    );
+    await expectExit1(() =>
+      getBroadcastCommand.parseAsync(['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with fetch_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockGet.mockResolvedValueOnce(mockSdkError('Not found', 'not_found'));
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { getBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/get'
+    );
+    await expectExit1(() =>
+      getBroadcastCommand.parseAsync(['00000000-0000-0000-0000-00000000bad0'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});

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

@@ -0,0 +1,196 @@
+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: 'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        name: 'Weekly Newsletter',
+        segment_id: '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
+        audience_id: null,
+        status: 'sent' as const,
+        created_at: '2026-02-18T12:00:00.000Z',
+        scheduled_at: null,
+        sent_at: null,
+      },
+    ],
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    broadcasts = { list: mockList };
+  },
+}));
+
+describe('broadcasts 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('lists broadcasts', async () => {
+    spies = setupOutputSpies();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await listBroadcastsCommand.parseAsync([], { from: 'user' });
+
+    expect(mockList).toHaveBeenCalledTimes(1);
+  });
+
+  test('outputs JSON list when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await listBroadcastsCommand.parseAsync([], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.object).toBe('list');
+    expect(parsed.data).toHaveLength(1);
+    expect(parsed.data[0].id).toBe('d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+  });
+
+  test('passes --limit to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await listBroadcastsCommand.parseAsync(['--limit', '5'], { from: 'user' });
+
+    const opts = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(opts.limit).toBe(5);
+  });
+
+  test('passes --after cursor to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await listBroadcastsCommand.parseAsync(
+      ['--after', 'c0c0c0c0-d1d1-e2e2-f3f3-a4a4a4a4a4a4'],
+      {
+        from: 'user',
+      },
+    );
+
+    const opts = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(opts.after).toBe('c0c0c0c0-d1d1-e2e2-f3f3-a4a4a4a4a4a4');
+  });
+
+  test('passes --before cursor to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await listBroadcastsCommand.parseAsync(
+      ['--before', 'c0c0c0c0-d1d1-e2e2-f3f3-a4a4a4a4a4a4'],
+      {
+        from: 'user',
+      },
+    );
+
+    const opts = mockList.mock.calls[0][0] as Record<string, unknown>;
+    expect(opts.before).toBe('c0c0c0c0-d1d1-e2e2-f3f3-a4a4a4a4a4a4');
+  });
+
+  test('errors with invalid_limit when --limit is out of range', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await expectExit1(() =>
+      listBroadcastsCommand.parseAsync(['--limit', '999'], { 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 { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await expectExit1(() =>
+      listBroadcastsCommand.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('Internal server error', 'server_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listBroadcastsCommand } = await import(
+      '../../../src/commands/broadcasts/list'
+    );
+    await expectExit1(() =>
+      listBroadcastsCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/tests/commands/broadcasts/send.test.ts

@@ -0,0 +1,161 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockSend = mock(async () => ({
+  data: { id: 'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    broadcasts = { send: mockSend };
+  },
+}));
+
+describe('broadcasts send 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';
+    mockSend.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('sends broadcast by id', async () => {
+    spies = setupOutputSpies();
+
+    const { sendBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/send'
+    );
+    await sendBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      { from: 'user' },
+    );
+
+    expect(mockSend).toHaveBeenCalledTimes(1);
+    expect(mockSend.mock.calls[0][0]).toBe(
+      'd1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+    );
+  });
+
+  test('outputs JSON id when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { sendBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/send'
+    );
+    await sendBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+  });
+
+  test('passes --scheduled-at to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { sendBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/send'
+    );
+    await sendBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--scheduled-at', 'in 1 hour'],
+      { from: 'user' },
+    );
+
+    const payload = mockSend.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.scheduledAt).toBe('in 1 hour');
+  });
+
+  test('does not pass scheduledAt when flag absent', async () => {
+    spies = setupOutputSpies();
+
+    const { sendBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/send'
+    );
+    await sendBroadcastCommand.parseAsync(
+      ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      { from: 'user' },
+    );
+
+    const payload = mockSend.mock.calls[0][1] as Record<string, unknown>;
+    expect(payload.scheduledAt).toBeUndefined();
+  });
+
+  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 { sendBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/send'
+    );
+    await expectExit1(() =>
+      sendBroadcastCommand.parseAsync(
+        ['d1c2b3a4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with send_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockSend.mockResolvedValueOnce(
+      mockSdkError('Broadcast not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { sendBroadcastCommand } = await import(
+      '../../../src/commands/broadcasts/send'
+    );
+    await expectExit1(() =>
+      sendBroadcastCommand.parseAsync(
+        ['00000000-0000-0000-0000-00000000bad0'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('send_error');
+  });
+});