resend-cli 1.2.1 → 1.3.0

package/tests/lib/config.test.ts

@@ -1,414 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from 'bun:test';
-import { mkdirSync, readFileSync, rmSync, statSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import {
-  getConfigDir,
-  listTeams,
-  removeTeam,
-  resolveApiKey,
-  resolveTeamName,
-  setActiveTeam,
-  storeApiKey,
-} from '../../src/lib/config';
-import { captureTestEnv } from '../helpers';
-
-describe('getConfigDir', () => {
-  const restoreEnv = captureTestEnv();
-
-  afterEach(() => {
-    restoreEnv();
-  });
-
-  test('respects XDG_CONFIG_HOME', () => {
-    process.env.XDG_CONFIG_HOME = '/custom/config';
-    expect(getConfigDir()).toBe('/custom/config/resend');
-  });
-
-  test('falls back to ~/.config/resend on non-Windows', () => {
-    delete process.env.XDG_CONFIG_HOME;
-    const dir = getConfigDir();
-    expect(dir).toMatch(/\.config\/resend$/);
-  });
-});
-
-describe('resolveApiKey', () => {
-  const restoreEnv = captureTestEnv();
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(tmpDir, { recursive: true });
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test('flag value takes highest priority', () => {
-    process.env.RESEND_API_KEY = 're_env_key';
-    const result = resolveApiKey('re_flag_key');
-    expect(result).toEqual({ key: 're_flag_key', source: 'flag' });
-  });
-
-  test('env var is second priority', () => {
-    process.env.RESEND_API_KEY = 're_env_key';
-    const result = resolveApiKey();
-    expect(result).toEqual({ key: 're_env_key', source: 'env' });
-  });
-
-  test('config file is third priority', () => {
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = tmpDir;
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    Bun.write(
-      join(configDir, 'credentials.json'),
-      JSON.stringify({
-        active_team: 'default',
-        teams: { default: { api_key: 're_config_key' } },
-      }),
-    );
-
-    const result = resolveApiKey();
-    expect(result).toEqual({
-      key: 're_config_key',
-      source: 'config',
-      team: 'default',
-    });
-  });
-
-  test('reads legacy format (api_key at root)', () => {
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = tmpDir;
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    Bun.write(
-      join(configDir, 'credentials.json'),
-      JSON.stringify({ api_key: 're_legacy_key' }),
-    );
-
-    const result = resolveApiKey();
-    expect(result).toEqual({
-      key: 're_legacy_key',
-      source: 'config',
-      team: 'default',
-    });
-  });
-
-  test('resolves specific team from config', () => {
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = tmpDir;
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    Bun.write(
-      join(configDir, 'credentials.json'),
-      JSON.stringify({
-        active_team: 'default',
-        teams: {
-          default: { api_key: 're_default' },
-          staging: { api_key: 're_staging' },
-        },
-      }),
-    );
-
-    const result = resolveApiKey(undefined, 'staging');
-    expect(result).toEqual({
-      key: 're_staging',
-      source: 'config',
-      team: 'staging',
-    });
-  });
-
-  test('returns null when no key found', () => {
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = tmpDir;
-    const result = resolveApiKey();
-    expect(result).toBeNull();
-  });
-
-  test('returns null on malformed config JSON', () => {
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = tmpDir;
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    Bun.write(join(configDir, 'credentials.json'), 'not json');
-
-    const result = resolveApiKey();
-    expect(result).toBeNull();
-  });
-
-  test('returns null when team does not exist in config', () => {
-    delete process.env.RESEND_API_KEY;
-    process.env.XDG_CONFIG_HOME = tmpDir;
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    Bun.write(
-      join(configDir, 'credentials.json'),
-      JSON.stringify({
-        active_team: 'default',
-        teams: { default: { api_key: 're_default' } },
-      }),
-    );
-
-    const result = resolveApiKey(undefined, 'nonexistent');
-    expect(result).toBeNull();
-  });
-});
-
-describe('resolveTeamName', () => {
-  const restoreEnv = captureTestEnv();
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    mkdirSync(tmpDir, { recursive: true });
-    process.env.XDG_CONFIG_HOME = tmpDir;
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test('flag value takes highest priority', () => {
-    process.env.RESEND_TEAM = 'env_team';
-    expect(resolveTeamName('flag_team')).toBe('flag_team');
-  });
-
-  test('env var is second priority', () => {
-    process.env.RESEND_TEAM = 'env_team';
-    expect(resolveTeamName()).toBe('env_team');
-  });
-
-  test('active_team from config is third priority', () => {
-    delete process.env.RESEND_TEAM;
-    const configDir = join(tmpDir, 'resend');
-    mkdirSync(configDir, { recursive: true });
-    Bun.write(
-      join(configDir, 'credentials.json'),
-      JSON.stringify({
-        active_team: 'production',
-        teams: { production: { api_key: 're_xxx' } },
-      }),
-    );
-
-    expect(resolveTeamName()).toBe('production');
-  });
-
-  test('defaults to "default" when nothing configured', () => {
-    delete process.env.RESEND_TEAM;
-    expect(resolveTeamName()).toBe('default');
-  });
-});
-
-describe('storeApiKey', () => {
-  const restoreEnv = captureTestEnv();
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    process.env.XDG_CONFIG_HOME = tmpDir;
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test('writes credentials.json with team structure', () => {
-    const configPath = storeApiKey('re_test_key_123');
-    expect(configPath).toContain('credentials.json');
-
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.active_team).toBe('default');
-    expect(data.teams.default.api_key).toBe('re_test_key_123');
-  });
-
-  test('stores key under specific team name', () => {
-    const configPath = storeApiKey('re_staging_key', 'staging');
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.teams.staging.api_key).toBe('re_staging_key');
-  });
-
-  test('preserves existing teams when adding new one', () => {
-    storeApiKey('re_default_key');
-    storeApiKey('re_staging_key', 'staging');
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.teams.default.api_key).toBe('re_default_key');
-    expect(data.teams.staging.api_key).toBe('re_staging_key');
-  });
-
-  test('creates config directory if it does not exist', () => {
-    storeApiKey('re_test_key');
-    const configDir = join(tmpDir, 'resend');
-    const stat = statSync(configDir);
-    expect(stat.isDirectory()).toBe(true);
-  });
-
-  test('sets file permissions to 0600', () => {
-    const configPath = storeApiKey('re_test_key');
-    const stat = statSync(configPath);
-    const mode = stat.mode & 0o777;
-    expect(mode).toBe(0o600);
-  });
-
-  test('overwrites existing team key', () => {
-    storeApiKey('re_first_key');
-    storeApiKey('re_second_key');
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.teams.default.api_key).toBe('re_second_key');
-  });
-
-  test('sets first team as active', () => {
-    storeApiKey('re_first_key', 'myteam');
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.active_team).toBe('myteam');
-  });
-});
-
-describe('listTeams', () => {
-  const restoreEnv = captureTestEnv();
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    process.env.XDG_CONFIG_HOME = tmpDir;
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test('returns empty array when no config', () => {
-    expect(listTeams()).toEqual([]);
-  });
-
-  test('returns teams with active flag', () => {
-    storeApiKey('re_default', 'default');
-    storeApiKey('re_staging', 'staging');
-
-    const teams = listTeams();
-    expect(teams).toEqual([
-      { name: 'default', active: true },
-      { name: 'staging', active: false },
-    ]);
-  });
-});
-
-describe('setActiveTeam', () => {
-  const restoreEnv = captureTestEnv();
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    process.env.XDG_CONFIG_HOME = tmpDir;
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test('switches active team', () => {
-    storeApiKey('re_default', 'default');
-    storeApiKey('re_staging', 'staging');
-
-    setActiveTeam('staging');
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.active_team).toBe('staging');
-  });
-
-  test('throws when team does not exist', () => {
-    storeApiKey('re_default');
-    expect(() => setActiveTeam('nonexistent')).toThrow('not found');
-  });
-
-  test('throws when no credentials file', () => {
-    expect(() => setActiveTeam('any')).toThrow('No credentials file');
-  });
-});
-
-describe('removeTeam', () => {
-  const restoreEnv = captureTestEnv();
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = join(
-      tmpdir(),
-      `resend-test-${Date.now()}-${Math.random().toString(36).slice(2)}`,
-    );
-    process.env.XDG_CONFIG_HOME = tmpDir;
-  });
-
-  afterEach(() => {
-    restoreEnv();
-    rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  test('removes a team entry', () => {
-    storeApiKey('re_default', 'default');
-    storeApiKey('re_staging', 'staging');
-
-    removeTeam('staging');
-
-    const teams = listTeams();
-    expect(teams).toEqual([{ name: 'default', active: true }]);
-  });
-
-  test('adjusts active_team when active is removed', () => {
-    storeApiKey('re_default', 'default');
-    storeApiKey('re_staging', 'staging');
-    setActiveTeam('staging');
-
-    removeTeam('staging');
-
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    const data = JSON.parse(readFileSync(configPath, 'utf-8'));
-    expect(data.active_team).toBe('default');
-  });
-
-  test('deletes file when last team removed', () => {
-    storeApiKey('re_only', 'only');
-
-    removeTeam('only');
-
-    const { existsSync } = require('node:fs');
-    const configPath = join(tmpDir, 'resend', 'credentials.json');
-    expect(existsSync(configPath)).toBe(false);
-  });
-
-  test('throws when team does not exist', () => {
-    storeApiKey('re_default');
-    expect(() => removeTeam('nonexistent')).toThrow('not found');
-  });
-
-  test('throws when no credentials file', () => {
-    expect(() => removeTeam('any')).toThrow('No credentials file');
-  });
-});

package/tests/lib/files.test.ts

@@ -1,65 +0,0 @@
-import { afterEach, describe, expect, spyOn, test } from 'bun:test';
-import { unlinkSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { expectExit1, mockExitThrow } from '../helpers';
-
-const globalOpts = { json: false, apiKey: undefined };
-const jsonOpts = { json: true, apiKey: undefined };
-
-describe('readFile', () => {
-  const tmpFile = join(import.meta.dir, 'tmp-test.txt');
-  let errorSpy: ReturnType<typeof spyOn> | undefined;
-  let exitSpy: ReturnType<typeof spyOn> | undefined;
-
-  afterEach(() => {
-    errorSpy?.mockRestore();
-    errorSpy = undefined;
-    exitSpy?.mockRestore();
-    exitSpy = undefined;
-    try {
-      unlinkSync(tmpFile);
-    } catch {
-      /* already removed */
-    }
-  });
-
-  test('reads file content and returns it as a string', () => {
-    writeFileSync(tmpFile, '<h1>Hello</h1>', 'utf-8');
-    const { readFile } = require('../../src/lib/files');
-    const content = readFile(tmpFile, globalOpts);
-    expect(content).toBe('<h1>Hello</h1>');
-  });
-
-  test('reads JSON file content and returns it as a string', () => {
-    writeFileSync(tmpFile, '[{"id":1}]', 'utf-8');
-    const { readFile } = require('../../src/lib/files');
-    const content = readFile(tmpFile, globalOpts);
-    expect(content).toBe('[{"id":1}]');
-  });
-
-  test('exits with file_read_error when file does not exist', async () => {
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { readFile } = require('../../src/lib/files');
-    await expectExit1(async () =>
-      readFile('/nonexistent/path/data.txt', globalOpts),
-    );
-
-    const output = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('Failed to read file:');
-  });
-
-  test('outputs JSON error with file_read_error code when json option is true', async () => {
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { readFile } = require('../../src/lib/files');
-    await expectExit1(async () => readFile('/nonexistent/file.txt', jsonOpts));
-
-    const raw = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
-    const parsed = JSON.parse(raw);
-    expect(parsed.error.code).toBe('file_read_error');
-    expect(parsed.error.message).toContain('Failed to read file:');
-  });
-});

package/tests/lib/help-text.test.ts

@@ -1,97 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import { buildHelpText } from '../../src/lib/help-text';
-
-describe('buildHelpText', () => {
-  it('full leaf command — all options, setup: false', () => {
-    const result = buildHelpText({
-      context: 'Some context line\n\nNon-interactive: --required-flag <value>',
-      output: '  {"id":"em_123"}',
-      errorCodes: ['auth_error', 'send_error'],
-      examples: [
-        'resend emails send --to user@example.com --subject Hi --text Hello',
-      ],
-      setup: false,
-    });
-
-    expect(result).toBe(
-      '\n' +
-        'Some context line\n\nNon-interactive: --required-flag <value>' +
-        '\n\n' +
-        'Global options:\n' +
-        '  --api-key <key>   API key (or set RESEND_API_KEY env var)\n' +
-        '  --team <name>     Team profile to use (overrides RESEND_TEAM)\n' +
-        '  --json            Force JSON output (also auto-enabled when stdout is piped)\n' +
-        '  -q, --quiet       Suppress spinners and status output (implies --json)' +
-        '\n\n' +
-        'Output (--json or piped):\n' +
-        '  {"id":"em_123"}' +
-        '\n\n' +
-        'Errors (exit code 1):\n' +
-        '  {"error":{"message":"<message>","code":"<code>"}}\n' +
-        '  Codes: auth_error | send_error' +
-        '\n\n' +
-        'Examples:\n' +
-        '  $ resend emails send --to user@example.com --subject Hi --text Hello',
-    );
-  });
-
-  it('setup variant — no --api-key line, short --json form', () => {
-    const result = buildHelpText({
-      context: 'Setup context',
-      output: '  {"configured":true}',
-      errorCodes: ['write_error'],
-      examples: ['resend setup cursor'],
-      setup: true,
-    });
-
-    expect(result).not.toContain('--api-key');
-    expect(result).toContain('--json         Force JSON output');
-    expect(result).not.toContain('--json            Force JSON output');
-    expect(result).toContain('Global options:');
-  });
-
-  it('index command — no output, no errorCodes', () => {
-    const result = buildHelpText({
-      context: 'Manage emails.',
-      examples: ['resend emails send', 'resend emails receiving list'],
-    });
-
-    expect(result).not.toContain('Output (--json or piped):');
-    expect(result).not.toContain('Errors (exit code 1):');
-    expect(result).toContain('Global options:');
-    expect(result).toContain('Examples:');
-    expect(result).toContain('  $ resend emails send');
-    expect(result).toContain('  $ resend emails receiving list');
-  });
-
-  it('no context — string starts with newline then Global options header directly', () => {
-    const result = buildHelpText({
-      output: '  {"id":"dm_abc"}',
-      errorCodes: ['auth_error'],
-      examples: ['resend domains list'],
-    });
-
-    expect(result.startsWith('\nGlobal options:')).toBe(true);
-  });
-
-  it('multi-line output — verbatim after the Output header', () => {
-    const multiLineOutput =
-      '  {"id":"em_123"}\n  // or with all fields:\n  {"id":"em_456","to":["a@b.com"]}';
-    const result = buildHelpText({
-      output: multiLineOutput,
-      errorCodes: ['auth_error'],
-      examples: ['resend emails send --to a@b.com --subject Hi --text Hi'],
-    });
-
-    expect(result).toContain(`Output (--json or piped):\n${multiLineOutput}`);
-  });
-
-  it('error codes join — uses " | " separator', () => {
-    const result = buildHelpText({
-      errorCodes: ['auth_error', 'list_error', 'fetch_error'],
-      examples: ['resend domains list'],
-    });
-
-    expect(result).toContain('Codes: auth_error | list_error | fetch_error');
-  });
-});

package/tests/lib/output.test.ts

@@ -1,127 +0,0 @@
-import { afterEach, describe, expect, spyOn, test } from 'bun:test';
-import { outputError, outputResult } from '../../src/lib/output';
-
-describe('outputResult', () => {
-  let logSpy: ReturnType<typeof spyOn>;
-  const originalIsTTY = process.stdout.isTTY;
-
-  afterEach(() => {
-    logSpy?.mockRestore();
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: originalIsTTY,
-      writable: true,
-    });
-  });
-
-  test('outputs JSON when json option is true', () => {
-    logSpy = spyOn(console, 'log').mockImplementation(() => {});
-    outputResult({ id: '123' }, { json: true });
-    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
-  });
-
-  test('outputs JSON when stdout is not TTY', () => {
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: undefined,
-      writable: true,
-    });
-    logSpy = spyOn(console, 'log').mockImplementation(() => {});
-    outputResult({ id: '123' });
-    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
-  });
-
-  test('outputs string directly for human-readable mode', () => {
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: true,
-      writable: true,
-    });
-    logSpy = spyOn(console, 'log').mockImplementation(() => {});
-    outputResult('Email sent successfully');
-    expect(logSpy).toHaveBeenCalledWith('Email sent successfully');
-  });
-
-  test('outputs JSON for objects in human mode (fallback)', () => {
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: true,
-      writable: true,
-    });
-    logSpy = spyOn(console, 'log').mockImplementation(() => {});
-    outputResult({ id: '123' });
-    expect(logSpy).toHaveBeenCalledWith(JSON.stringify({ id: '123' }, null, 2));
-  });
-});
-
-describe('outputError', () => {
-  let errorSpy: ReturnType<typeof spyOn>;
-  let exitSpy: ReturnType<typeof spyOn>;
-  const originalIsTTY = process.stdout.isTTY;
-
-  afterEach(() => {
-    errorSpy?.mockRestore();
-    exitSpy?.mockRestore();
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: originalIsTTY,
-      writable: true,
-    });
-  });
-
-  test('outputs JSON error when json is true', () => {
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = spyOn(process, 'exit').mockImplementation(
-      () => undefined as never,
-    );
-
-    outputError({ message: 'not found', code: 'not_found' }, { json: true });
-
-    const expected = JSON.stringify(
-      { error: { message: 'not found', code: 'not_found' } },
-      null,
-      2,
-    );
-    expect(errorSpy).toHaveBeenCalledWith(expected);
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-
-  test('outputs text error when TTY and no json flag', () => {
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: true,
-      writable: true,
-    });
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = spyOn(process, 'exit').mockImplementation(
-      () => undefined as never,
-    );
-
-    outputError({ message: 'something broke' });
-
-    expect(errorSpy).toHaveBeenCalledWith('Error: something broke');
-    expect(exitSpy).toHaveBeenCalledWith(1);
-  });
-
-  test('uses custom exit code', () => {
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = spyOn(process, 'exit').mockImplementation(
-      () => undefined as never,
-    );
-
-    outputError({ message: 'error' }, { exitCode: 2, json: true });
-
-    expect(exitSpy).toHaveBeenCalledWith(2);
-  });
-
-  test('defaults error code to "unknown" when not provided', () => {
-    Object.defineProperty(process.stdout, 'isTTY', {
-      value: undefined,
-      writable: true,
-    });
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = spyOn(process, 'exit').mockImplementation(
-      () => undefined as never,
-    );
-
-    outputError({ message: 'oops' });
-
-    const output = errorSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.error.code).toBe('unknown');
-  });
-});