resend-cli 1.0.2 → 1.1.0

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)
-    }
-}

package/src/routes.js

@@ -1,37 +0,0 @@
-import enquirer from "enquirer";
-import email from "./sections/email.js";
-import domain from "./sections/domain.js";
-import apikeys from "./sections/apikeys.js";
-import audiences from "./sections/audiences.js";
-import contacts from "./sections/contacts.js";
-
-export default async ({resend, apiKey, config}) => {
-    const prompt = new enquirer.Select({
-        message: "Choose a section",
-        choices: [
-            {name: "email", message: "Emails"},
-            {name: "domain", message: "Domains"},
-            {name: "apiKeys", message: "API Keys"},
-            {name: "audiences", message: "Audiences"},
-            {name: "contacts", message: "Contacts"},
-        ]
-    })
-    const answer = await prompt.run()
-    switch (answer) {
-        case "email":
-            await email({resend, apiKey, config})
-            break
-        case "domain":
-            await domain({resend, apiKey, config})
-            break
-        case "apiKeys":
-            await apikeys({resend, apiKey, config})
-            break
-        case "audiences":
-            await audiences({resend, apiKey, config})
-            break
-        case "contacts":
-            await contacts({resend, apiKey, config})
-            break
-    }
-}

package/src/sections/apikeys.js

@@ -1,99 +0,0 @@
-import ora from "ora"
-import enquirer from "enquirer";
-
-const logAPIKey = (apiKey) => {
-    console.log("- ID: " + apiKey.id)
-    if (apiKey.token) {
-        console.log("- API Key: " + apiKey.token)
-    }
-    if (apiKey.name) {
-        console.log("- Name: " + apiKey.name)
-    }
-    if (apiKey.created_at) {
-        console.log("- Created At: " + apiKey.created_at)
-    }
-}
-
-export default async function({resend}, apiKey) {
-    const prompt = new enquirer.Select({
-        message: "Choose an action",
-        choices: [
-            {name: "create", message: "Create API Key"},
-            {name: "list", message: "List API Keys"},
-            {name: "delete", message: "Delete API Key"},
-        ]
-    })
-    const answer = await prompt.run()
-    switch (answer) {
-        case "create":
-            {
-                let form = new enquirer.Form({
-                    name: "createApiKey",
-                    message: "Create an API Key.\nPossible values for permission: full, sending.",
-                    choices: [
-                        {name: "name", message: "Name", initial: "My API Key"},
-                        {name: "permission", message: "Permission", initial: "full"}
-                    ]
-                })
-                form = await form.run()
-                const name = form.name
-                const permission = form.permission === "sending" ? "sending_access" : "full_access"
-                const spinner = ora({text: "Creating API Key...", spinner: "toggle9"}).start()
-                const apiKey = await resend.apiKeys.create({name, permission})
-                spinner.stop()
-                console.log("IMPORTANT! Save this API key in a safe place. It will not be shown again.")
-                logAPIKey(apiKey.data)
-            }
-            break;
-        case "list":
-            {
-                const spinner2 = ora({text: "Fetching API Keys...", spinner: "toggle9"}).start()
-                const listApiKeysResponse = await resend.apiKeys.list()
-                spinner2.stop()
-                const choices = listApiKeysResponse.data.data.map((apiKey) => {
-                    return {message: apiKey.name, name: apiKey.id}
-                })
-                //console.log(choices)
-                let answer = new enquirer.Select({
-                    name: "listApiKeys",
-                    message: "Choose an API Key to view info on",
-                    choices
-                })
-                answer = await answer.run()
-                for (let apiKey of listApiKeysResponse.data.data) {
-                    if (apiKey.id === answer) {
-                        logAPIKey(apiKey)
-                    }
-                }
-            }
-            break
-        case "delete":
-            {
-                const spinner3 = ora({text: "Fetching API Keys...", spinner: "toggle9"}).start()
-                const listApiKeysResponse2 = await resend.apiKeys.list()
-                spinner3.stop()
-                const choices2 = listApiKeysResponse2.data.data.map((apiKey) => {return {message: apiKey.name, name: apiKey.id}})
-                let answer2 = new enquirer.Select({
-                    name: "deleteApiKey",
-                    message: "Choose an API Key to delete",
-                    choices: choices2
-                })
-                answer2 = await answer2.run()
-                console.log(answer2)
-                let confirmDelete = new enquirer.Confirm({
-                    message: "If this API Key is the one you make resend-cli with, you will not be able to use resend-cli anymore with the same key. This action is IRREVERSIBLE!!"
-                })
-                confirmDelete = await confirmDelete.run()
-                if (!confirmDelete) {
-                    console.log("Aborting...")
-                    process.exit(0)
-                }
-                const spinner4 = ora({text: "Deleting API Key...", spinner: "toggle9"}).start()
-                await resend.apiKeys.remove(answer2)
-                spinner4.stop()
-                    console.log("API Key deleted.")
-            }
-            break
-    }
-    process.exit(0)
-}