resend-cli 1.1.0 → 1.2.1

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

@@ -0,0 +1,205 @@
+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: 'contact' as const,
+    id: 'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    contacts = { update: mockUpdate };
+  },
+}));
+
+describe('contacts 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 contact by ID with --unsubscribed', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await updateContactCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--unsubscribed'],
+      { from: 'user' },
+    );
+
+    expect(mockUpdate).toHaveBeenCalledTimes(1);
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.id).toBe('a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6');
+    expect(args.unsubscribed).toBe(true);
+  });
+
+  test('updates contact by email with --no-unsubscribed', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await updateContactCommand.parseAsync(
+      ['jane@example.com', '--no-unsubscribed'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.email).toBe('jane@example.com');
+    expect(args.unsubscribed).toBe(false);
+  });
+
+  test('parses --properties JSON and passes to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await updateContactCommand.parseAsync(
+      [
+        'a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6',
+        '--properties',
+        '{"plan":"pro"}',
+      ],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.properties).toEqual({ plan: 'pro' });
+  });
+
+  test('does not include unsubscribed when neither flag is passed', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await updateContactCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6'],
+      { from: 'user' },
+    );
+
+    const args = mockUpdate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.unsubscribed).toBeUndefined();
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await updateContactCommand.parseAsync(
+      ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--unsubscribed'],
+      { 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');
+    expect(parsed.object).toBe('contact');
+  });
+
+  test('errors with invalid_properties when --properties is not valid JSON', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await expectExit1(() =>
+      updateContactCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--properties', 'bad-json'],
+        { from: 'user' },
+      ),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('invalid_properties');
+  });
+
+  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 { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await expectExit1(() =>
+      updateContactCommand.parseAsync(
+        ['a1b2c3d4-5e6f-7a8b-9c0d-e1f2a3b4c5d6', '--unsubscribed'],
+        {
+          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('Contact not found', 'not_found'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { updateContactCommand } = await import(
+      '../../../src/commands/contacts/update'
+    );
+    await expectExit1(() =>
+      updateContactCommand.parseAsync(['nonexistent_id', '--unsubscribed'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('update_error');
+  });
+});

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

@@ -0,0 +1,165 @@
+import {
+  afterEach,
+  beforeEach,
+  describe,
+  expect,
+  mock,
+  spyOn,
+  test,
+} from 'bun:test';
+import { Command } from '@commander-js/extra-typings';
+import {
+  captureTestEnv,
+  expectExit1,
+  mockExitThrow,
+  setupOutputSpies,
+} from '../helpers';
+
+// Mock resend SDK for doctor
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = {
+      list: mock(async () => ({
+        data: { data: [{ name: 'example.com', status: 'verified' }] },
+        error: null,
+      })),
+    };
+  },
+}));
+
+/**
+ * Wraps doctorCommand in a parent program with global --json option,
+ * matching the real CLI structure in src/cli.ts.
+ */
+async function createDoctorProgram() {
+  const { doctorCommand } = await import('../../src/commands/doctor');
+  const program = new Command()
+    .name('resend')
+    .option('--json', 'Force JSON output')
+    .addCommand(doctorCommand);
+  return program;
+}
+
+describe('doctor command', () => {
+  const restoreEnv = captureTestEnv();
+  let spies: ReturnType<typeof setupOutputSpies> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  beforeEach(() => {
+    process.env.RESEND_API_KEY = 're_test_key_for_doctor';
+  });
+
+  afterEach(() => {
+    restoreEnv();
+    spies?.restore();
+    spies = undefined;
+    exitSpy?.mockRestore();
+    exitSpy = undefined;
+  });
+
+  test('outputs JSON with --json flag', async () => {
+    spies = setupOutputSpies();
+
+    const program = await createDoctorProgram();
+    await program.parseAsync(['doctor', '--json'], { from: 'user' });
+
+    expect(spies.logSpy).toHaveBeenCalled();
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+
+    expect(parsed).toHaveProperty('ok');
+    expect(parsed).toHaveProperty('checks');
+    expect(Array.isArray(parsed.checks)).toBe(true);
+  });
+
+  test('JSON output has correct check structure', async () => {
+    spies = setupOutputSpies();
+
+    const program = await createDoctorProgram();
+    await program.parseAsync(['doctor', '--json'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+
+    for (const check of parsed.checks) {
+      expect(check).toHaveProperty('name');
+      expect(check).toHaveProperty('status');
+      expect(check).toHaveProperty('message');
+      expect(['pass', 'warn', 'fail']).toContain(check.status);
+    }
+  });
+
+  test('API key check passes when key is set', async () => {
+    spies = setupOutputSpies();
+
+    const program = await createDoctorProgram();
+    await program.parseAsync(['doctor', '--json'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    const keyCheck = parsed.checks.find(
+      (c: Record<string, unknown>) => c.name === 'API Key',
+    );
+
+    expect(keyCheck).toBeDefined();
+    expect(keyCheck.status).toBe('pass');
+    expect(keyCheck.message).toContain('re_');
+    expect(keyCheck.message).toContain('env');
+  });
+
+  test('API key check fails when no key is set', async () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+
+    spies = setupOutputSpies();
+    exitSpy = spyOn(process, 'exit').mockImplementation(
+      () => undefined as never,
+    );
+
+    const program = await createDoctorProgram();
+    await program.parseAsync(['doctor', '--json'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+
+    expect(parsed.ok).toBe(false);
+    const keyCheck = parsed.checks.find(
+      (c: Record<string, unknown>) => c.name === 'API Key',
+    );
+    expect(keyCheck.status).toBe('fail');
+  });
+
+  test('masks API key in output', async () => {
+    process.env.RESEND_API_KEY = 're_abcdefghijklmnop';
+    spies = setupOutputSpies();
+
+    const program = await createDoctorProgram();
+    await program.parseAsync(['doctor', '--json'], { from: 'user' });
+
+    const output = spies.logSpy.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    const keyCheck = parsed.checks.find(
+      (c: Record<string, unknown>) => c.name === 'API Key',
+    );
+
+    // Should not contain full key
+    expect(keyCheck.message).not.toContain('re_abcdefghijklmnop');
+    // Should contain masked version (re_...mnop)
+    expect(keyCheck.message).toContain('re_');
+    expect(keyCheck.message).toContain('...');
+  });
+
+  test('exits with code 1 when checks fail', async () => {
+    delete process.env.RESEND_API_KEY;
+    process.env.XDG_CONFIG_HOME = '/tmp/nonexistent-resend';
+
+    spies = setupOutputSpies();
+    exitSpy = mockExitThrow();
+
+    const program = await createDoctorProgram();
+    await expectExit1(() =>
+      program.parseAsync(['doctor', '--json'], { from: 'user' }),
+    );
+  });
+});

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

@@ -0,0 +1,192 @@
+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: {
+    id: 'test-domain-id',
+    name: 'example.com',
+    status: 'not_started',
+    created_at: '2026-01-01T00:00:00.000Z',
+    region: 'us-east-1',
+    records: [
+      {
+        record: 'SPF',
+        type: 'MX',
+        name: 'send',
+        ttl: 'Auto',
+        status: 'not_started',
+        value: 'feedback-smtp.us-east-1.amazonses.com',
+        priority: 10,
+      },
+    ],
+    capabilities: { sending: 'enabled', receiving: 'disabled' },
+  },
+  error: null,
+}));
+
+mock.module('resend', () => ({
+  Resend: class MockResend {
+    constructor(public key: string) {}
+    domains = { create: mockCreate };
+  },
+}));
+
+describe('domains 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 domain with --name flag', async () => {
+    spies = setupOutputSpies();
+
+    const { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await createDomainCommand.parseAsync(['--name', 'example.com'], {
+      from: 'user',
+    });
+
+    expect(mockCreate).toHaveBeenCalledTimes(1);
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.name).toBe('example.com');
+  });
+
+  test('passes region and tls flags to SDK', async () => {
+    spies = setupOutputSpies();
+
+    const { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await createDomainCommand.parseAsync(
+      ['--name', 'example.com', '--region', 'eu-west-1', '--tls', 'enforced'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.region).toBe('eu-west-1');
+    expect(args.tls).toBe('enforced');
+  });
+
+  test('passes receiving capability when --receiving flag is set', async () => {
+    spies = setupOutputSpies();
+
+    const { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await createDomainCommand.parseAsync(
+      ['--name', 'example.com', '--receiving'],
+      { from: 'user' },
+    );
+
+    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
+    expect(args.capabilities?.receiving).toBe('enabled');
+  });
+
+  test('outputs JSON result when non-interactive', async () => {
+    spies = setupOutputSpies();
+
+    const { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await createDomainCommand.parseAsync(['--name', 'example.com'], {
+      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.name).toBe('example.com');
+  });
+
+  test('errors with missing_name when --name absent in non-interactive mode', async () => {
+    setNonInteractive();
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await expectExit1(() =>
+      createDomainCommand.parseAsync([], { from: 'user' }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('missing_name');
+  });
+
+  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 { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await expectExit1(() =>
+      createDomainCommand.parseAsync(['--name', 'example.com'], {
+        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('Domain already exists', 'validation_error'),
+    );
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+    exitSpy = mockExitThrow();
+
+    const { createDomainCommand } = await import(
+      '../../../src/commands/domains/create'
+    );
+    await expectExit1(() =>
+      createDomainCommand.parseAsync(['--name', 'example.com'], {
+        from: 'user',
+      }),
+    );
+
+    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('create_error');
+  });
+});