resend-cli 1.0.3 → 1.1.0

package/tests/commands/contacts/segments.test.ts

@@ -0,0 +1,167 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockListSegments = mock(async () => ({
+  data: {
+    object: 'list' as const,
+    data: [
+      {
+        id: '7b1e0a3d-4c5f-4e8a-9b2d-1a3c5e7f9b2d',
+        name: 'Newsletter',
+        created_at: '2026-01-01T00:00:00.000Z',
+      },
+    ],
+    has_more: false,
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    contacts = {
+      segments: { list: mockListSegments },
+    };
+  },
+}));
+
+describe('contacts segments 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';
+    mockListSegments.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('lists segments by contact ID', async () => {
+    spies = setupOutputSpies();
+
+    const { listContactSegmentsCommand } = await import(
+      '../../../src/commands/contacts/segments'
+    );
+    await listContactSegmentsCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      {
+        from: 'user',
+      },
+    );
+
+    expect(mockListSegments).toHaveBeenCalledTimes(1);
+    const args = mockListSegments.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.contactId).toBe('a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+    expect(args.email).toBeUndefined();
+  });
+
+  test('lists segments by contact email', async () => {
+    spies = setupOutputSpies();
+
+    const { listContactSegmentsCommand } = await import(
+      '../../../src/commands/contacts/segments'
+    );
+    await listContactSegmentsCommand.parseAsync(['jane@example.com'], {
+      from: 'user',
+    });
+
+    const args = mockListSegments.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.email).toBe('jane@example.com');
+    expect(args.contactId).toBeUndefined();
+  });
+
+  test('outputs JSON list when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listContactSegmentsCommand } = await import(
+      '../../../src/commands/contacts/segments'
+    );
+    await listContactSegmentsCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      {
+        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[0].name).toBe('Newsletter');
+  });
+
+  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 { listContactSegmentsCommand } = await import(
+      '../../../src/commands/contacts/segments'
+    );
+    await expectExit1(() =>
+      listContactSegmentsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        {
+          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();
+    mockListSegments.mockResolvedValueOnce(
+      mockSdkError('Not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listContactSegmentsCommand } = await import(
+      '../../../src/commands/contacts/segments'
+    );
+    await expectExit1(() =>
+      listContactSegmentsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        {
+          from: 'user',
+        },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/tests/commands/contacts/topics.test.ts

@@ -0,0 +1,163 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockListTopics = mock(async () => ({
+  data: {
+    object: 'list' as const,
+    data: [
+      {
+        id: 'topic_abc',
+        name: 'Product Updates',
+        description: 'Updates about the product',
+        subscription: 'opt_in' as const,
+      },
+    ],
+    has_more: false,
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    contacts = {
+      topics: { list: mockListTopics },
+    };
+  },
+}));
+
+describe('contacts topics 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';
+    mockListTopics.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('lists topics by contact ID', async () => {
+    spies = setupOutputSpies();
+
+    const { listContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/topics'
+    );
+    await listContactTopicsCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      {
+        from: 'user',
+      },
+    );
+
+    expect(mockListTopics).toHaveBeenCalledTimes(1);
+    const args = mockListTopics.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.id).toBe('a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+  });
+
+  test('lists topics by contact email', async () => {
+    spies = setupOutputSpies();
+
+    const { listContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/topics'
+    );
+    await listContactTopicsCommand.parseAsync(['jane@example.com'], {
+      from: 'user',
+    });
+
+    const args = mockListTopics.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.email).toBe('jane@example.com');
+  });
+
+  test('outputs JSON list when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { listContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/topics'
+    );
+    await listContactTopicsCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      {
+        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[0].name).toBe('Product Updates');
+    expect(parsed.data[0].subscription).toBe('opt_in');
+  });
+
+  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 { listContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/topics'
+    );
+    await expectExit1(() =>
+      listContactTopicsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        { 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();
+    mockListTopics.mockResolvedValueOnce(
+      mockSdkError('Not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { listContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/topics'
+    );
+    await expectExit1(() =>
+      listContactTopicsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('list_error');
+  });
+});

package/tests/commands/contacts/update-topics.test.ts

@@ -0,0 +1,247 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  mockSdkError,
+  setNonInteractive,
+  setupOutputSpies,
+} from '../../helpers';
+
+const mockUpdateTopics = mock(async () => ({
+  data: { id: 'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6' },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    contacts = {
+      topics: { update: mockUpdateTopics },
+    };
+  },
+}));
+
+describe('contacts update-topics 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';
+    mockUpdateTopics.mockClear();
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    errorSpy?.mockRestore();
+    stderrSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    spies = undefined;
+    errorSpy = undefined;
+    stderrSpy = undefined;
+    exitSpy = undefined;
+  });
+
+  test('updates topics by contact ID', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await updateContactTopicsCommand.parseAsync(
+      [
+        'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        '--topics',
+        '[{"id":"topic_abc","subscription":"opt_in"}]',
+      ],
+      { from: 'user' },
+    );
+
+    expect(mockUpdateTopics).toHaveBeenCalledTimes(1);
+    const args = mockUpdateTopics.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.id).toBe('a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+    expect(args.topics).toEqual([{ id: 'topic_abc', subscription: 'opt_in' }]);
+  });
+
+  test('updates topics by contact email', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await updateContactTopicsCommand.parseAsync(
+      [
+        'jane@example.com',
+        '--topics',
+        '[{"id":"topic_abc","subscription":"opt_out"}]',
+      ],
+      { from: 'user' },
+    );
+
+    const args = mockUpdateTopics.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.email).toBe('jane@example.com');
+    expect(args.topics[0].subscription).toBe('opt_out');
+  });
+
+  test('passes multiple topics in array', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await updateContactTopicsCommand.parseAsync(
+      [
+        'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        '--topics',
+        '[{"id":"t1","subscription":"opt_in"},{"id":"t2","subscription":"opt_out"}]',
+      ],
+      { from: 'user' },
+    );
+
+    const args = mockUpdateTopics.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.topics).toHaveLength(2);
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await updateContactTopicsCommand.parseAsync(
+      [
+        'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        '--topics',
+        '[{"id":"topic_abc","subscription":"opt_in"}]',
+      ],
+      { from: 'user' },
+    );
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.id).toBe('a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+  });
+
+  test('errors with missing_topics when --topics absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await expectExit1(() =>
+      updateContactTopicsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+        {
+          from: 'user',
+        },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_topics');
+  });
+
+  test('errors with invalid_topics when --topics is not valid JSON', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await expectExit1(() =>
+      updateContactTopicsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--topics', 'not-json'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_topics');
+  });
+
+  test('errors with invalid_topics when --topics is not an array', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await expectExit1(() =>
+      updateContactTopicsCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--topics', '{"id":"t1"}'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_topics');
+  });
+
+  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 { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await expectExit1(() =>
+      updateContactTopicsCommand.parseAsync(
+        [
+          'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+          '--topics',
+          '[{"id":"t1","subscription":"opt_in"}]',
+        ],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('auth_error');
+  });
+
+  test('errors with update_topics_error when SDK returns an error', async () => {
+    setNonInteractive();
+    mockUpdateTopics.mockResolvedValueOnce(
+      mockSdkError('Topic not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateContactTopicsCommand } = await import(
+      '../../../src/commands/contacts/update-topics'
+    );
+    await expectExit1(() =>
+      updateContactTopicsCommand.parseAsync(
+        [
+          'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+          '--topics',
+          '[{"id":"bad_topic","subscription":"opt_in"}]',
+        ],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_topics_error');
+  });
+});