resend-cli 1.0.3 → 1.1.0

package/tests/commands/topics/update.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 mockUpdate = mock(async () => ({
+  data: { id: 'top_abc123' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    topics = { update: mockUpdate };
+  },
+}));
+
+describe('topics 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('calls SDK with id and name when --name is provided', async () => {
+    spies = setupOutputSpies();
+
+    const { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await updateTopicCommand.parseAsync(
+      ['top_abc123', '--name', 'Security Alerts'],
+      { from: 'user' },
+    );
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
+    const payload = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(payload.id).toBe('top_abc123');
+    expect(payload.name).toBe('Security Alerts');
+  });
+
+  test('calls SDK with id and description when --description is provided', async () => {
+    spies = setupOutputSpies();
+
+    const { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await updateTopicCommand.parseAsync(
+      ['top_abc123', '--description', 'Updated desc'],
+      { from: 'user' },
+    );
+
+    const payload = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(payload.id).toBe('top_abc123');
+    expect(payload.description).toBe('Updated desc');
+    expect(payload.name).toBeUndefined();
+  });
+
+  test('outputs JSON with id when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await updateTopicCommand.parseAsync(
+      ['top_abc123', '--name', 'Security Alerts'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('top_abc123');
+  });
+
+  test('errors with no_changes when neither --name nor --description provided', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await expectExit1(() =>
+      updateTopicCommand.parseAsync(['top_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 { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await expectExit1(() =>
+      updateTopicCommand.parseAsync(['top_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 { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await expectExit1(() =>
+      updateTopicCommand.parseAsync(['top_abc123', '--name', 'Test'], {
+        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('Topic not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateTopicCommand } = await import(
+      '../../../src/commands/topics/update'
+    );
+    await expectExit1(() =>
+      updateTopicCommand.parseAsync(['top_nonexistent', '--name', 'Test'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_error');
+  });
+});

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

@@ -0,0 +1,224 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockCreate = mock(async () => ({
+  data: {
+    object: 'webhook' as const,
+    id: 'wh_abc123',
+    signing_secret: 'whsec_test1234',
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { create: mockCreate };
+  },
+}));
+
+describe('webhooks create 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';
+    mockCreate.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('creates webhook with --endpoint and explicit --events', async () => {
+    spies = setupOutputSpies();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await createWebhookCommand.parseAsync(
+      [
+        '--endpoint',
+        'https://app.example.com/hooks',
+        '--events',
+        'email.sent',
+        'email.bounced',
+      ],
+      { from: 'user' },
+    );
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.endpoint).toBe('https://app.example.com/hooks');
+    expect(args.events).toEqual(['email.sent', 'email.bounced']);
+  });
+
+  test('expands "all" shorthand to all 17 events', async () => {
+    spies = setupOutputSpies();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await createWebhookCommand.parseAsync(
+      ['--endpoint', 'https://app.example.com/hooks', '--events', 'all'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.events).toHaveLength(17);
+    expect(args.events).toContain('email.sent');
+    expect(args.events).toContain('contact.created');
+    expect(args.events).toContain('domain.deleted');
+  });
+
+  test('outputs JSON with id and signing_secret when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await createWebhookCommand.parseAsync(
+      ['--endpoint', 'https://app.example.com/hooks', '--events', 'email.sent'],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('wh_abc123');
+    expect(parsed.signing_secret).toBe('whsec_test1234');
+  });
+
+  test('errors with missing_endpoint in non-interactive mode when --endpoint absent', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await expectExit1(() =>
+      createWebhookCommand.parseAsync(['--events', 'email.sent'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_endpoint');
+  });
+
+  test('errors with missing_events in non-interactive mode when --events absent', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await expectExit1(() =>
+      createWebhookCommand.parseAsync(
+        ['--endpoint', 'https://app.example.com/hooks'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_events');
+  });
+
+  test('does not call SDK when missing_endpoint error is raised', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await expectExit1(() =>
+      createWebhookCommand.parseAsync(['--events', 'email.sent'], {
+        from: 'user',
+      }),
+    );
+
+    expect(mockCreate).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 { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await expectExit1(() =>
+      createWebhookCommand.parseAsync(
+        [
+          '--endpoint',
+          'https://app.example.com/hooks',
+          '--events',
+          'email.sent',
+        ],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with create_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockCreate.mockResolvedValueOnce(
+      mockSdkError('Invalid endpoint', 'validation_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { createWebhookCommand } = await import(
+      '../../../src/commands/webhooks/create'
+    );
+    await expectExit1(() =>
+      createWebhookCommand.parseAsync(
+        [
+          '--endpoint',
+          'https://app.example.com/hooks',
+          '--events',
+          'email.sent',
+        ],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('create_error');
+  });
+});

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

@@ -0,0 +1,156 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockRemove = mock(async () => ({
+  data: { object: 'webhook' as const, id: 'wh_abc123', deleted: true },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { remove: mockRemove };
+  },
+}));
+
+describe('webhooks delete 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';
+    mockRemove.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('deletes webhook with --yes flag', async () => {
+    spies = setupOutputSpies();
+
+    const { deleteWebhookCommand } = await import(
+      '../../../src/commands/webhooks/delete'
+    );
+    await deleteWebhookCommand.parseAsync(['wh_abc123', '--yes'], {
+      from: 'user',
+    });
+
+    expect(mockRemove).toHaveBeenCalledTimes(1);
+    expect(mockRemove.mock.calls[0][0]).toBe('wh_abc123');
+  });
+
+  test('outputs synthesized JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { deleteWebhookCommand } = await import(
+      '../../../src/commands/webhooks/delete'
+    );
+    await deleteWebhookCommand.parseAsync(['wh_abc123', '--yes'], {
+      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');
+    expect(parsed.deleted).toBe(true);
+  });
+
+  test('errors with confirmation_required when --yes absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { deleteWebhookCommand } = await import(
+      '../../../src/commands/webhooks/delete'
+    );
+    await expectExit1(() =>
+      deleteWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('confirmation_required');
+  });
+
+  test('does not call SDK when confirmation_required error is raised', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { deleteWebhookCommand } = await import(
+      '../../../src/commands/webhooks/delete'
+    );
+    await expectExit1(() =>
+      deleteWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' }),
+    );
+
+    expect(mockRemove).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 { deleteWebhookCommand } = await import(
+      '../../../src/commands/webhooks/delete'
+    );
+    await expectExit1(() =>
+      deleteWebhookCommand.parseAsync(['wh_abc123', '--yes'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with delete_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockRemove.mockResolvedValueOnce(
+      mockSdkError('Webhook not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { deleteWebhookCommand } = await import(
+      '../../../src/commands/webhooks/delete'
+    );
+    await expectExit1(() =>
+      deleteWebhookCommand.parseAsync(['wh_nonexistent', '--yes'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('delete_error');
+  });
+});

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

@@ -0,0 +1,125 @@
+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: 'webhook' as const,
+    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',
+    signing_secret: 'whsec_test1234',
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    webhooks = { get: mockGet };
+  },
+}));
+
+describe('webhooks 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('calls SDK get with the provided id', async () => {
+    spies = setupOutputSpies();
+
+    const { getWebhookCommand } = await import(
+      '../../../src/commands/webhooks/get'
+    );
+    await getWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' });
+
+    expect(mockGet).toHaveBeenCalledTimes(1);
+    expect(mockGet.mock.calls[0][0]).toBe('wh_abc123');
+  });
+
+  test('outputs JSON with webhook fields when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { getWebhookCommand } = await import(
+      '../../../src/commands/webhooks/get'
+    );
+    await getWebhookCommand.parseAsync(['wh_abc123'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('wh_abc123');
+    expect(parsed.endpoint).toBe('https://app.example.com/hooks/resend');
+    expect(parsed.status).toBe('enabled');
+  });
+
+  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 { getWebhookCommand } = await import(
+      '../../../src/commands/webhooks/get'
+    );
+    await expectExit1(() =>
+      getWebhookCommand.parseAsync(['wh_abc123'], { 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 { getWebhookCommand } = await import(
+      '../../../src/commands/webhooks/get'
+    );
+    await expectExit1(() =>
+      getWebhookCommand.parseAsync(['wh_nonexistent'], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('fetch_error');
+  });
+});