resend-cli 1.2.1 → 1.3.0

package/src/lib/pagination.ts

@@ -1,36 +0,0 @@
-import type { GlobalOpts } from './client';
-import { outputError } from './output';
-
-export function parseLimitOpt(raw: string, globalOpts: GlobalOpts): number {
-  const limit = parseInt(raw, 10);
-  if (Number.isNaN(limit) || limit < 1 || limit > 100) {
-    outputError(
-      {
-        message: '--limit must be an integer between 1 and 100',
-        code: 'invalid_limit',
-      },
-      { json: globalOpts.json },
-    );
-  }
-  return limit;
-}
-
-export function buildPaginationOpts(
-  limit: number,
-  after?: string,
-  before?: string,
-) {
-  return after ? { limit, after } : before ? { limit, before } : { limit };
-}
-
-export function printPaginationHint(list: {
-  has_more: boolean;
-  data: Array<{ id: string }>;
-}): void {
-  if (list.has_more && list.data.length > 0) {
-    const last = list.data[list.data.length - 1];
-    console.log(
-      `\nMore results available. Use --after ${last.id} to fetch the next page.`,
-    );
-  }
-}

package/src/lib/prompts.ts

@@ -1,149 +0,0 @@
-import * as p from '@clack/prompts';
-import type { GlobalOpts } from './client';
-import { outputError } from './output';
-import { isInteractive } from './tty';
-
-export interface FieldSpec {
-  flag: string;
-  message: string;
-  placeholder?: string;
-  required?: boolean;
-  validate?: (value: string | undefined) => string | undefined;
-}
-
-export function cancelAndExit(message: string): never {
-  p.cancel(message);
-  process.exit(0);
-}
-
-/**
- * Guard a delete action: error in non-interactive mode (no --yes), or show a
- * confirmation prompt in interactive mode. Exits the process on cancel/rejection.
- */
-export async function confirmDelete(
-  _id: string,
-  confirmMessage: string,
-  globalOpts: GlobalOpts,
-): Promise<void> {
-  if (!isInteractive()) {
-    outputError(
-      {
-        message: 'Use --yes to confirm deletion in non-interactive mode.',
-        code: 'confirmation_required',
-      },
-      { json: globalOpts.json },
-    );
-  }
-
-  const confirmed = await p.confirm({ message: confirmMessage });
-  if (p.isCancel(confirmed) || !confirmed) {
-    cancelAndExit('Deletion cancelled.');
-  }
-}
-
-export async function requireText(
-  value: string | undefined,
-  prompt: {
-    message: string;
-    placeholder?: string;
-    validate?: (value: string | undefined) => string | Error | undefined;
-  },
-  error: { message: string; code: string },
-  globalOpts: GlobalOpts,
-): Promise<string> {
-  if (value) {
-    return value;
-  }
-
-  if (!isInteractive()) {
-    outputError(error, { json: globalOpts.json });
-  }
-
-  const result = await p.text({
-    message: prompt.message,
-    placeholder: prompt.placeholder,
-    validate:
-      prompt.validate ??
-      ((v) =>
-        !v || v.length === 0 ? `${prompt.message} is required` : undefined),
-  });
-  if (p.isCancel(result)) {
-    cancelAndExit('Cancelled.');
-  }
-  return result;
-}
-
-export async function requireSelect<V extends string>(
-  value: V | undefined,
-  prompt: {
-    message: string;
-    options: Parameters<typeof p.select<V>>[0]['options'];
-  },
-  error: { message: string; code: string },
-  globalOpts: GlobalOpts,
-): Promise<V> {
-  if (value) {
-    return value;
-  }
-
-  if (!isInteractive()) {
-    outputError(error, { json: globalOpts.json });
-  }
-
-  const result = await p.select<V>({
-    message: prompt.message,
-    options: prompt.options,
-  });
-  if (p.isCancel(result)) {
-    cancelAndExit('Cancelled.');
-  }
-  return result;
-}
-
-export async function promptForMissing<
-  T extends Record<string, string | undefined>,
->(
-  current: T,
-  fields: FieldSpec[],
-  globalOpts: GlobalOpts,
-): Promise<{ [K in keyof T]: string }> {
-  const missing = fields.filter(
-    (f) => f.required !== false && !current[f.flag],
-  );
-
-  if (missing.length === 0) {
-    return current as { [K in keyof T]: string };
-  }
-
-  if (!isInteractive()) {
-    const flags = missing.map((f) => `--${f.flag}`).join(', ');
-    outputError(
-      { message: `Missing required flags: ${flags}`, code: 'missing_flags' },
-      { json: globalOpts.json },
-    );
-  }
-
-  const result = await p.group(
-    Object.fromEntries(
-      missing.map((field) => [
-        field.flag,
-        () =>
-          p.text({
-            message: field.message,
-            placeholder: field.placeholder,
-            validate:
-              field.validate ??
-              ((v) =>
-                !v || v.length === 0
-                  ? `${field.message} is required`
-                  : undefined),
-          }),
-      ]),
-    ),
-    {
-      onCancel: () => cancelAndExit('Operation cancelled.'),
-    },
-  );
-
-  return { ...current, ...result } as { [K in keyof T]: string };
-}

package/src/lib/spinner.ts

@@ -1,93 +0,0 @@
-import spinners from 'unicode-animations';
-import type { GlobalOpts } from './client';
-import { errorMessage, outputError } from './output';
-import { isInteractive, isUnicodeSupported } from './tty';
-
-// Status symbols generated via String.fromCodePoint() — never literal Unicode in
-// source — to prevent UTF-8 → Latin-1 corruption when the npm package is bundled.
-const TICK = isUnicodeSupported ? String.fromCodePoint(0x2714) : 'v'; // ✔
-const WARN = isUnicodeSupported ? String.fromCodePoint(0x26a0) : '!'; // ⚠
-const CROSS = isUnicodeSupported ? String.fromCodePoint(0x2717) : 'x'; // ✗
-
-type SdkResponse<T> = { data: T | null; error: { message: string } | null };
-
-/**
- * Wraps an SDK call with a spinner, unified error handling, and automatic stop/fail.
- * Eliminates the repeated try/catch + spinner boilerplate across all command files.
- */
-export async function withSpinner<T>(
-  messages: { loading: string; success: string; fail: string },
-  call: () => Promise<SdkResponse<T>>,
-  errorCode: string,
-  globalOpts: GlobalOpts,
-): Promise<T> {
-  const spinner = createSpinner(messages.loading, 'braille', globalOpts.quiet);
-  try {
-    const { data, error } = await call();
-    if (error) {
-      spinner.fail(messages.fail);
-      outputError(
-        { message: error.message, code: errorCode },
-        { json: globalOpts.json },
-      );
-    }
-    if (data === null) {
-      spinner.fail(messages.fail);
-      outputError(
-        { message: 'Unexpected empty response', code: errorCode },
-        { json: globalOpts.json },
-      );
-    }
-    spinner.stop(messages.success);
-    return data;
-  } catch (err) {
-    spinner.fail(messages.fail);
-    return outputError(
-      { message: errorMessage(err, 'Unknown error'), code: errorCode },
-      { json: globalOpts.json },
-    );
-  }
-}
-
-export type SpinnerName = keyof typeof spinners;
-
-export function createSpinner(
-  message: string,
-  name: SpinnerName = 'braille',
-  quiet?: boolean,
-) {
-  if (quiet || !isInteractive()) {
-    return {
-      update(_msg: string) {},
-      stop(_msg: string) {},
-      warn(_msg: string) {},
-      fail(_msg: string) {},
-    };
-  }
-
-  const { frames, interval } = spinners[name];
-  let i = 0;
-  let text = message;
-
-  const timer = setInterval(() => {
-    process.stderr.write(`\r\x1B[2K  ${frames[i++ % frames.length]} ${text}`);
-  }, interval);
-
-  return {
-    update(msg: string) {
-      text = msg;
-    },
-    stop(msg: string) {
-      clearInterval(timer);
-      process.stderr.write(`\r\x1B[2K  ${TICK} ${msg}\n`);
-    },
-    warn(msg: string) {
-      clearInterval(timer);
-      process.stderr.write(`\r\x1B[2K  ${WARN} ${msg}\n`);
-    },
-    fail(msg: string) {
-      clearInterval(timer);
-      process.stderr.write(`\r\x1B[2K  ${CROSS} ${msg}\n`);
-    },
-  };
-}

package/src/lib/table.ts

@@ -1,57 +0,0 @@
-import { isUnicodeSupported } from './tty';
-
-// All box-drawing characters generated via String.fromCodePoint() — never literal
-// Unicode in source — to prevent UTF-8 → Latin-1 corruption in npm bundles.
-const BOX = isUnicodeSupported
-  ? {
-      h: String.fromCodePoint(0x2500), // ─
-      v: String.fromCodePoint(0x2502), // │
-      tl: String.fromCodePoint(0x250c), // ┌
-      tr: String.fromCodePoint(0x2510), // ┐
-      bl: String.fromCodePoint(0x2514), // └
-      br: String.fromCodePoint(0x2518), // ┘
-      lm: String.fromCodePoint(0x251c), // ├
-      rm: String.fromCodePoint(0x2524), // ┤
-      tm: String.fromCodePoint(0x252c), // ┬
-      bm: String.fromCodePoint(0x2534), // ┴
-      mm: String.fromCodePoint(0x253c), // ┼
-    }
-  : {
-      h: '-',
-      v: '|',
-      tl: '+',
-      tr: '+',
-      bl: '+',
-      br: '+',
-      lm: '+',
-      rm: '+',
-      tm: '+',
-      bm: '+',
-      mm: '+',
-    };
-
-export function renderTable(
-  headers: string[],
-  rows: string[][],
-  emptyMessage = '(no results)',
-): string {
-  if (rows.length === 0) {
-    return emptyMessage;
-  }
-  const widths = headers.map((h, i) =>
-    Math.max(h.length, ...rows.map((r) => r[i].length)),
-  );
-  const top =
-    BOX.tl + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.tm) + BOX.tr;
-  const mid =
-    BOX.lm + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.mm) + BOX.rm;
-  const bot =
-    BOX.bl + widths.map((w) => BOX.h.repeat(w + 2)).join(BOX.bm) + BOX.br;
-  const row = (cells: string[]) =>
-    BOX.v +
-    ' ' +
-    cells.map((c, i) => c.padEnd(widths[i])).join(` ${BOX.v} `) +
-    ' ' +
-    BOX.v;
-  return [top, row(headers), mid, ...rows.map(row), bot].join('\n');
-}

package/src/lib/tty.ts

@@ -1,28 +0,0 @@
-export function isInteractive(): boolean {
-  if (!process.stdin.isTTY || !process.stdout.isTTY) {
-    return false;
-  }
-  if (process.env.CI === 'true' || process.env.CI === '1') {
-    return false;
-  }
-  if (process.env.GITHUB_ACTIONS) {
-    return false;
-  }
-  if (process.env.TERM === 'dumb') {
-    return false;
-  }
-  return true;
-}
-
-/**
- * True on macOS/Linux and on Windows terminals that support Unicode
- * (Windows Terminal, VS Code integrated terminal).
- * False on legacy Windows cmd.exe — callers should fall back to ASCII symbols.
- *
- * Generated via String.fromCodePoint() (never literal Unicode in source)
- * to prevent UTF-8 → Latin-1 corruption when the npm package is bundled.
- */
-export const isUnicodeSupported: boolean =
-  process.platform !== 'win32' ||
-  Boolean(process.env.WT_SESSION) ||
-  process.env.TERM_PROGRAM === 'vscode';

package/src/lib/version.ts

@@ -1,4 +0,0 @@
-import pkg from '../../package.json';
-
-export const VERSION: string = pkg.version;
-export const PACKAGE_NAME: string = pkg.name;

package/tests/commands/api-keys/create.test.ts

@@ -1,195 +0,0 @@
-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-key-id', token: 're_testtoken1234567890' },
-  error: null,
-}));
-
-mock.module('resend', () => ({
-  Resend: class MockResend {
-    constructor(public key: string) {}
-    apiKeys = { create: mockCreate };
-  },
-}));
-
-describe('api-keys 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 API key with --name flag', async () => {
-    spies = setupOutputSpies();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await createApiKeyCommand.parseAsync(['--name', 'Production'], {
-      from: 'user',
-    });
-
-    expect(mockCreate).toHaveBeenCalledTimes(1);
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.name).toBe('Production');
-  });
-
-  test('passes permission flag to SDK', async () => {
-    spies = setupOutputSpies();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await createApiKeyCommand.parseAsync(
-      ['--name', 'CI Token', '--permission', 'sending_access'],
-      { from: 'user' },
-    );
-
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.permission).toBe('sending_access');
-  });
-
-  test('passes domain_id (snake_case) to SDK when --domain-id is provided', async () => {
-    spies = setupOutputSpies();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await createApiKeyCommand.parseAsync(
-      [
-        '--name',
-        'Domain Token',
-        '--permission',
-        'sending_access',
-        '--domain-id',
-        'domain-123',
-      ],
-      { from: 'user' },
-    );
-
-    const args = mockCreate.mock.calls[0][0] as Record<string, unknown>;
-    expect(args.domain_id).toBe('domain-123');
-  });
-
-  test('outputs JSON result when non-interactive', async () => {
-    spies = setupOutputSpies();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await createApiKeyCommand.parseAsync(['--name', 'Production'], {
-      from: 'user',
-    });
-
-    const output = spies.logSpy.mock.calls[0][0] as string;
-    const parsed = JSON.parse(output);
-    expect(parsed.id).toBe('test-key-id');
-    expect(parsed.token).toBe('re_testtoken1234567890');
-  });
-
-  test('errors with missing_name when --name absent in non-interactive mode', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await expectExit1(() =>
-      createApiKeyCommand.parseAsync([], { from: 'user' }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('missing_name');
-  });
-
-  test('does not call SDK when missing_name error is raised', async () => {
-    setNonInteractive();
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    exitSpy = mockExitThrow();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await expectExit1(() =>
-      createApiKeyCommand.parseAsync([], { 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 { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await expectExit1(() =>
-      createApiKeyCommand.parseAsync(['--name', 'Production'], {
-        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('Name already taken', 'validation_error'),
-    );
-    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
-    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
-    exitSpy = mockExitThrow();
-
-    const { createApiKeyCommand } = await import(
-      '../../../src/commands/api-keys/create'
-    );
-    await expectExit1(() =>
-      createApiKeyCommand.parseAsync(['--name', 'Production'], {
-        from: 'user',
-      }),
-    );
-
-    const output = errorSpy.mock.calls.map((c) => c[0]).join(' ');
-    expect(output).toContain('create_error');
-  });
-});