resend-cli 1.2.1 → 1.2.2

package/.claude/worktrees/emails-list/tests/commands/domains/verify.test.ts

@@ -1,117 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from 'bun:test';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  mockSdkError,
-  setNonInteractive,
-  setupOutputSpies,
-} from '../../helpers';
-
-const mockVerify = mock(async () => ({
-  data: { object: 'domain', id: 'test-domain-id' },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    domains = { verify: mockVerify };
-  },
-}));
-
-describe('domains verify 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';
-    mockVerify.mockClear();
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    spies?.restore();
-    errorSpy?.mockRestore();
-    stderrSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    spies = undefined;
-    errorSpy = undefined;
-    stderrSpy = undefined;
-    exitSpy = undefined;
-  });
-
-  test('calls SDK verify with correct id', async () => {
-    spies = setupOutputSpies();
-
-    const { verifyDomainCommand } = await import(
-      '../../../src/commands/domains/verify'
-    );
-    await verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' });
-
-    expect(mockVerify).toHaveBeenCalledWith('test-domain-id');
-  });
-
-  test('outputs JSON object in non-interactive mode (stdout not a TTY)', async () => {
-    spies = setupOutputSpies();
-
-    const { verifyDomainCommand } = await import(
-      '../../../src/commands/domains/verify'
-    );
-    await verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' });
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.id).toBe('test-domain-id');
-    expect(parsed.object).toBe('domain');
-  });
-
-  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 { verifyDomainCommand } = await import(
-      '../../../src/commands/domains/verify'
-    );
-    await expectExit1(() =>
-      verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('auth_error');
-  });
-
-  test('errors with verify_error when SDK returns an error', async () => {
-    setNonInteractive();
-    mockVerify.mockResolvedValueOnce(
-      mockSdkError('Domain not found', 'not_found'),
-    );
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    const { verifyDomainCommand } = await import(
-      '../../../src/commands/domains/verify'
-    );
-    await expectExit1(() =>
-      verifyDomainCommand.parseAsync(['test-domain-id'], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('verify_error');
-  });
-});

package/.claude/worktrees/emails-list/tests/commands/emails/batch.test.ts

@@ -1,313 +0,0 @@
-import {
-  afterEach,
-  beforeEach,
-  describe,
-  expect,
-  mock,
-  spyOn,
-  test,
-} from 'bun:test';
-import { join } from 'node:path';
-import {
-  captureTestEnv,
-  expectExit1,
-  mockExitThrow,
-  setNonInteractive,
-  setupOutputSpies,
-} from '../../helpers';
-
-const mockBatchSend = mock(async () => ({
-  data: { data: [{ id: 'abc123' }, { id: 'def456' }] },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    batch = { send: mockBatchSend };
-  },
-}));
-
-const VALID_EMAILS = [
-  {
-    from: 'you@domain.com',
-    to: ['user1@example.com'],
-    subject: 'Hello 1',
-    html: '<p>Hello 1</p>',
-  },
-  {
-    from: 'you@domain.com',
-    to: ['user2@example.com'],
-    subject: 'Hello 2',
-    text: 'Hello 2',
-  },
-];
-
-describe('batch 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;
-  let tmpFile: string;
-
-  beforeEach(() => {
-    process.env.RESEND_API_KEY = 're_test_key';
-    mockBatchSend.mockClear();
-  });
-
-  afterEach(async () => {
-    restoreEnv();
-    spies?.restore();
-    errorSpy?.mockRestore();
-    stderrSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    spies = undefined;
-    errorSpy = undefined;
-    stderrSpy = undefined;
-    exitSpy = undefined;
-    if (tmpFile) {
-      const { unlinkSync } = require('node:fs');
-      try {
-        unlinkSync(tmpFile);
-      } catch {}
-      tmpFile = '';
-    }
-  });
-
-  async function writeTmpJson(content: unknown): Promise<string> {
-    const path = join(import.meta.dir, '__test_batch.json');
-    await Bun.write(path, JSON.stringify(content));
-    tmpFile = path;
-    return path;
-  }
-
-  test('sends emails from a JSON file', async () => {
-    spies = setupOutputSpies();
-
-    const file = await writeTmpJson(VALID_EMAILS);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await batchCommand.parseAsync(['--file', file], { from: 'user' });
-
-    expect(mockBatchSend).toHaveBeenCalledTimes(1);
-    const emails = mockBatchSend.mock.calls[0][0] as unknown[];
-    expect(emails).toHaveLength(2);
-  });
-
-  test('outputs array of IDs on success in JSON mode', async () => {
-    // Non-interactive mode (no TTY) automatically triggers JSON output via outputResult
-    spies = setupOutputSpies();
-
-    const file = await writeTmpJson(VALID_EMAILS);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await batchCommand.parseAsync(['--file', file], { from: 'user' });
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed).toEqual([{ id: 'abc123' }, { id: 'def456' }]);
-  });
-
-  test('errors with missing_file when no --file in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() => batchCommand.parseAsync([], { from: 'user' }));
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_file');
-  });
-
-  test('errors with file_read_error when file does not exist', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(
-        ['--file', '/tmp/nonexistent-resend-batch.json'],
-        { from: 'user' },
-      ),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('file_read_error');
-  });
-
-  test('errors with invalid_json when file is not valid JSON', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const path = join(import.meta.dir, '__test_batch_bad.json');
-    await Bun.write(path, 'not valid json{{{');
-    tmpFile = path;
-
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(['--file', path], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('invalid_json');
-  });
-
-  test('errors with invalid_format when file content is not an array', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const file = await writeTmpJson({
-      from: 'you@domain.com',
-      to: ['user@example.com'],
-    });
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(['--file', file], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('invalid_format');
-    // Regression: invalid_format check was inside the try block; ExitError thrown by
-    // outputError (when process.exit is mocked) would be caught, firing invalid_json too.
-    expect(output).not.toContain('invalid_json');
-  });
-
-  test('rejects entries with attachments', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const emails = [
-      {
-        ...VALID_EMAILS[0],
-        attachments: [{ filename: 'test.txt', content: 'hello' }],
-      },
-    ];
-    const file = await writeTmpJson(emails);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(['--file', file], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('attachments');
-  });
-
-  test('rejects entries with scheduled_at', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const emails = [
-      { ...VALID_EMAILS[0], scheduled_at: '2026-01-01T00:00:00Z' },
-    ];
-    const file = await writeTmpJson(emails);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(['--file', file], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('scheduled_at');
-  });
-
-  test('warns but continues when array length exceeds 100', async () => {
-    spies = setupOutputSpies();
-    const warnSpy = spyOn(console, 'warn').mockImplementation(() => {});
-
-    const emails = Array.from({ length: 101 }, (_, i) => ({
-      from: 'you@domain.com',
-      to: [`user${i}@example.com`],
-      subject: `Hello ${i}`,
-      text: `Hello ${i}`,
-    }));
-    const file = await writeTmpJson(emails);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await batchCommand.parseAsync(['--file', file], { from: 'user' });
-
-    expect(mockBatchSend).toHaveBeenCalledTimes(1);
-
-    warnSpy.mockRestore();
-  });
-
-  test('passes idempotency key to batch.send', async () => {
-    spies = setupOutputSpies();
-
-    const file = await writeTmpJson(VALID_EMAILS);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await batchCommand.parseAsync(
-      ['--file', file, '--idempotency-key', 'my-key-123'],
-      { from: 'user' },
-    );
-
-    expect(mockBatchSend).toHaveBeenCalledTimes(1);
-    const opts = mockBatchSend.mock.calls[0][1] as Record<string, unknown>;
-    expect(opts?.idempotencyKey).toBe('my-key-123');
-  });
-
-  test('errors with auth_error when no API key in non-interactive mode', async () => {
-    setNonInteractive();
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const file = await writeTmpJson(VALID_EMAILS);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(['--file', file], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('auth_error');
-  });
-
-  test('outputs human-readable summary in terminal mode', async () => {
-    // Make it look like a TTY so outputResult uses human-readable format
-    Object.defineProperty(process.stdin, 'isTTY', {
-      value: true,
-      writable: true,
-    });
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: true,
-      writable: true,
-    });
-    const logSpy = spyOn(console, 'log').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-
-    const file = await writeTmpJson(VALID_EMAILS);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await batchCommand.parseAsync(['--file', file], { from: 'user' });
-
-    const allOutput = logSpy.mock.calls.map((c) => c[0]).join('\n');
-    expect(allOutput).toContain('2');
-    expect(allOutput).toContain('abc123');
-    expect(allOutput).toContain('def456');
-
-    logSpy.mockRestore();
-  });
-
-  test('errors with batch_error when SDK returns an error', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    mockBatchSend.mockImplementationOnce(async () => ({
-      data: null,
-      error: { message: 'Rate limit exceeded', name: 'rate_limit_exceeded' },
-    }));
-
-    const file = await writeTmpJson(VALID_EMAILS);
-    const { batchCommand } = await import('../../../src/commands/emails/batch');
-    await expectExit1(() =>
-      batchCommand.parseAsync(['--file', file], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('batch_error');
-  });
-});

package/.claude/worktrees/emails-list/tests/commands/emails/list.test.ts

@@ -1,196 +0,0 @@
-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: 'email_abc123',
-        to: ['user@example.com'],
-        from: 'you@domain.com',
-        subject: 'Hello',
-        created_at: '2026-02-18T12:00:00.000Z',
-        last_event: 'delivered',
-        bcc: null,
-        cc: null,
-        reply_to: null,
-        scheduled_at: null,
-      },
-    ],
-  },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    emails = { list: mockList };
-  },
-}));
-
-describe('emails 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 with default pagination', async () => {
-    spies = setupOutputSpies();
-
-    const { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await listCommand.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 { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await listCommand.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 { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await listCommand.parseAsync(['--after', 'email_cursor123'], {
-      from: 'user',
-    });
-
-    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.after).toBe('email_cursor123');
-  });
-
-  test('passes --before cursor to pagination options', async () => {
-    spies = setupOutputSpies();
-
-    const { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await listCommand.parseAsync(['--before', 'email_cursor456'], {
-      from: 'user',
-    });
-
-    const args = mockList.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.before).toBe('email_cursor456');
-  });
-
-  test('outputs JSON list with email data when non-interactive', async () => {
-    spies = setupOutputSpies();
-
-    const { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await listCommand.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('email_abc123');
-    expect(parsed.data[0].from).toBe('you@domain.com');
-    expect(parsed.data[0].subject).toBe('Hello');
-    expect(parsed.data[0].last_event).toBe('delivered');
-    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 { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await expectExit1(() =>
-      listCommand.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 { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await expectExit1(() =>
-      listCommand.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 { listCommand } = await import(
-      '../../../src/commands/emails/list'
-    );
-    await expectExit1(() =>
-      listCommand.parseAsync([], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('list_error');
-  });
-});