resend-cli 1.0.3 → 1.2.0

package/tests/lib/output.test.ts

@@ -0,0 +1,127 @@
+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');
+  });
+});

package/tests/lib/prompts.test.ts

@@ -0,0 +1,178 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
+import { expectExit1, mockExitThrow } from '../helpers';
+
+describe('promptForMissing', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy = undefined;
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  });
+
+  test('returns options unchanged when nothing is missing', async () => {
+    const { promptForMissing } = require('../../src/lib/prompts');
+    const opts = { from: 'a@b.com', to: 'c@d.com', subject: 'Hi' };
+    const result = await promptForMissing(
+      opts,
+      [
+        { flag: 'from', message: 'From' },
+        { flag: 'to', message: 'To' },
+        { flag: 'subject', message: 'Subject' },
+      ],
+      {},
+    );
+    expect(result).toEqual(opts);
+  });
+
+  test('exits with missing_flags error in non-interactive mode', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { promptForMissing } = require('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      promptForMissing(
+        { from: undefined, to: 'c@d.com', subject: undefined },
+        [
+          { flag: 'from', message: 'From' },
+          { flag: 'to', message: 'To' },
+          { flag: 'subject', message: 'Subject' },
+        ],
+        {},
+      ),
+    );
+
+    const allErrors = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(allErrors).toContain('--from');
+    expect(allErrors).toContain('--subject');
+    // --to should NOT be listed since it has a value
+    expect(allErrors).not.toContain('--to,');
+  });
+
+  test('errors output includes missing_flags code', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { promptForMissing } = require('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      promptForMissing(
+        { from: undefined },
+        [{ flag: 'from', message: 'From' }],
+        {},
+      ),
+    );
+
+    const allErrors = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(allErrors).toContain('missing_flags');
+  });
+
+  test('skips fields marked as required=false', async () => {
+    const { promptForMissing } = require('../../src/lib/prompts');
+    const opts = { from: 'a@b.com', to: undefined };
+    const result = await promptForMissing(
+      opts,
+      [
+        { flag: 'from', message: 'From' },
+        { flag: 'to', message: 'To', required: false },
+      ],
+      {},
+    );
+    expect(result).toEqual(opts);
+  });
+});
+
+describe('confirmDelete', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let errorSpy: ReturnType<typeof spyOn> | undefined;
+  let exitSpy: ReturnType<typeof spyOn> | undefined;
+
+  afterEach(() => {
+    errorSpy?.mockRestore();
+    exitSpy?.mockRestore();
+    errorSpy = undefined;
+    exitSpy = undefined;
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+  });
+
+  test('exits with confirmation_required when non-interactive', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { confirmDelete } = require('../../src/lib/prompts');
+
+    await expectExit1(() =>
+      confirmDelete('res_123', 'Delete resource res_123?', { json: false }),
+    );
+
+    const output = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    expect(output).toContain('confirmation_required');
+  });
+
+  test('outputs JSON confirmation_required error when json option is true', async () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    errorSpy = spyOn(console, 'error').mockImplementation(() => {});
+    exitSpy = mockExitThrow();
+
+    const { confirmDelete } = require('../../src/lib/prompts');
+    await expectExit1(() =>
+      confirmDelete('res_123', 'Delete?', { json: true }),
+    );
+
+    const raw = errorSpy?.mock.calls.map((c) => c[0]).join(' ');
+    const parsed = JSON.parse(raw);
+    expect(parsed.error.code).toBe('confirmation_required');
+  });
+});

package/tests/lib/spinner.test.ts

@@ -0,0 +1,146 @@
+import { afterEach, describe, expect, spyOn, test } from 'bun:test';
+
+describe('createSpinner', () => {
+  const originalStdinIsTTY = process.stdin.isTTY;
+  const originalStdoutIsTTY = process.stdout.isTTY;
+  let stderrSpy: ReturnType<typeof spyOn>;
+
+  afterEach(() => {
+    stderrSpy?.mockRestore();
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: originalStdinIsTTY,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: originalStdoutIsTTY,
+      writable: true,
+    });
+    delete process.env.CI;
+  });
+
+  test('returns no-op spinner in non-interactive mode', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: undefined,
+      writable: true,
+    });
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('test message');
+
+    // Should not throw when calling any method
+    expect(() => spinner.stop('done')).not.toThrow();
+    expect(() => spinner.fail('error')).not.toThrow();
+    expect(() => spinner.warn('warning')).not.toThrow();
+    expect(() => spinner.update('updating')).not.toThrow();
+  });
+
+  test('returns functional spinner in interactive mode', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+
+    expect(spinner).toHaveProperty('stop');
+    expect(spinner).toHaveProperty('fail');
+    expect(spinner).toHaveProperty('warn');
+    expect(spinner).toHaveProperty('update');
+
+    // Stop to clean up the interval
+    spinner.stop('done');
+    expect(stderrSpy).toHaveBeenCalled();
+  });
+
+  test('stop writes checkmark to stderr', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.stop('completed');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('✔');
+    expect(lastCall).toContain('completed');
+  });
+
+  test('fail writes cross mark to stderr', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.fail('error occurred');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('✗');
+    expect(lastCall).toContain('error occurred');
+  });
+
+  test('warn writes warning icon to stderr', () => {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: true,
+      writable: true,
+    });
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    stderrSpy = spyOn(process.stderr, 'write').mockImplementation(() => true);
+
+    const { createSpinner } = require('../../src/lib/spinner');
+    const spinner = createSpinner('loading...');
+    spinner.warn('watch out');
+
+    const lastCall = stderrSpy.mock.calls[
+      stderrSpy.mock.calls.length - 1
+    ][0] as string;
+    expect(lastCall).toContain('⚠');
+    expect(lastCall).toContain('watch out');
+  });
+});

package/tests/lib/table.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, test } from 'bun:test';
+import { renderTable } from '../../src/lib/table';
+
+describe('renderTable', () => {
+  test('renders a table with correct border characters', () => {
+    const output = renderTable(['Name', 'ID'], [['Alice', 'abc-123']]);
+    expect(output).toContain('┌');
+    expect(output).toContain('┐');
+    expect(output).toContain('└');
+    expect(output).toContain('┘');
+    expect(output).toContain('│');
+  });
+
+  test('includes headers in output', () => {
+    const output = renderTable(
+      ['Name', 'Status'],
+      [['my-domain.com', 'verified']],
+    );
+    expect(output).toContain('Name');
+    expect(output).toContain('Status');
+  });
+
+  test('includes row data in output', () => {
+    const output = renderTable(
+      ['Name', 'Status'],
+      [['my-domain.com', 'verified']],
+    );
+    expect(output).toContain('my-domain.com');
+    expect(output).toContain('verified');
+  });
+
+  test('pads columns to the widest cell in each column', () => {
+    const output = renderTable(
+      ['Key', 'Value'],
+      [
+        ['short', 'a very long value here'],
+        ['much longer key', 'v'],
+      ],
+    );
+    // All rows should have the same line length
+    const lines = output.split('\n');
+    const lengths = lines.map((l) => l.length);
+    expect(new Set(lengths).size).toBe(1);
+  });
+
+  test('renders multiple rows', () => {
+    const output = renderTable(
+      ['A', 'B'],
+      [
+        ['row1a', 'row1b'],
+        ['row2a', 'row2b'],
+      ],
+    );
+    expect(output).toContain('row1a');
+    expect(output).toContain('row2a');
+  });
+
+  test('contains a separator row between header and data', () => {
+    const output = renderTable(['Col'], [['val']]);
+    expect(output).toContain('├');
+    expect(output).toContain('┤');
+  });
+});

package/tests/lib/tty.test.ts

@@ -0,0 +1,85 @@
+import { afterEach, describe, expect, test } from 'bun:test';
+import { captureTestEnv } from '../helpers';
+
+// We need to import the module fresh per test to pick up env changes,
+// so we use dynamic imports.
+
+describe('isInteractive', () => {
+  const restoreEnv = captureTestEnv();
+
+  afterEach(() => {
+    restoreEnv();
+  });
+
+  function setTTY(stdin: boolean, stdout: boolean) {
+    Object.defineProperty(process.stdin, 'isTTY', {
+      value: stdin ? true : undefined,
+      writable: true,
+    });
+    Object.defineProperty(process.stdout, 'isTTY', {
+      value: stdout ? true : undefined,
+      writable: true,
+    });
+  }
+
+  test('returns true when stdin and stdout are TTY and no CI env', () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    delete process.env.TERM;
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(true);
+  });
+
+  test('returns false when stdin is not TTY', () => {
+    setTTY(false, true);
+    delete process.env.CI;
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when stdout is not TTY', () => {
+    setTTY(true, false);
+    delete process.env.CI;
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when CI=true', () => {
+    setTTY(true, true);
+    process.env.CI = 'true';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when CI=1', () => {
+    setTTY(true, true);
+    process.env.CI = '1';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when GITHUB_ACTIONS is set', () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    process.env.GITHUB_ACTIONS = 'true';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+
+  test('returns false when TERM=dumb', () => {
+    setTTY(true, true);
+    delete process.env.CI;
+    delete process.env.GITHUB_ACTIONS;
+    process.env.TERM = 'dumb';
+
+    const { isInteractive } = require('../../src/lib/tty');
+    expect(isInteractive()).toBe(false);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["bun"]
+  },
+  "include": ["src/**/*.ts"]
+}

package/src/index.js

@@ -1,72 +0,0 @@
-#!/usr/bin/env node
-
-import enquirer from "enquirer"
-import * as fs from "fs/promises"
-import {homedir} from "os"
-import figlet from "figlet"
-import {promisify} from "util"
-const fig = promisify(figlet)
-import ora from "ora"
-import { Resend } from "resend"
-import routes from "./routes.js"
-import readline from "readline"
-
-if (process.platform === "win32") {
-    var rl = readline.createInterface({
-      input: process.stdin,
-      output: process.stdout
-    });
-  
-    rl.on("SIGINT", function () {
-      process.emit("SIGINT");
-    });
-  }
-  
-  process.on("SIGINT", function () {
-    //graceful shutdown
-    console.log("\nExiting...");
-    process.exit();
-  });
-
-const text = await fig("resend-cli")
-console.log(text)
-const configPath = `${homedir()}/.resend_config.json`
-const fileExists = await fs.access(configPath).then(() => true).catch(() => false);
-if (fileExists) {
-    let config, instance
-    try {
-        let fileContents = await fs.readFile(configPath)
-        fileContents = fileContents + ''
-        config = JSON.parse(fileContents)
-        //console.log(config.apiKey)
-        instance = new Resend(config.apiKey)
-    } catch (e) {
-        console.error("Error reading config file")
-        console.error(e)
-        process.exit(1)
-    }
-
-    try {
-        await routes({resend: instance, apiKey: config.apiKey, config})
-    } catch {} // this is needed so that Ctrl+C doesn't throw an exception
-} else {
-    const apiKeyResponse = await enquirer.password({
-        message: "Enter an API key with full access: "
-    })
-    const spinner = ora({text: "Authenticating...", spinner: "toggle9"}).start()
-    const resend = new Resend(apiKeyResponse)
-    const apiKeys = await resend.apiKeys.list()
-    spinner.stop()
-    if (apiKeys?.error?.statusCode === 400) {
-        console.error("Invalid API key")
-        process.exit(1)
-    } else {
-        const config = {
-            apiKey: apiKeyResponse
-        }
-        await fs.writeFile(configPath, JSON.stringify(config))
-        console.log("API key saved in plain text to ~/.resend_config.json.")
-        console.log("Run `resend-cli` again to use the CLI.")
-        process.exit(0)
-    }
-}