@project-ajax/sdk 0.0.49 → 0.0.51

package/src/cli/commands/bundle.impl.test.ts

@@ -0,0 +1,137 @@
+import {
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	type Mock,
+	vi,
+} from "vitest";
+import { ApiClient } from "../api/client.js";
+import { Result } from "../api/result.js";
+import { Config } from "../config.js";
+import { downloadBundle } from "./bundle.impl.js";
+import {
+	baseFlags,
+	cleanupTmpDirectories,
+	createBaseContext,
+	createTestConfig,
+} from "./utils/testing.js";
+
+afterEach(cleanupTmpDirectories);
+
+describe("downloadBundle", () => {
+	let stderrSpy: Mock<typeof process.stderr.write>;
+	let stdoutSpy: Mock<typeof process.stdout.write>;
+
+	beforeEach(() => {
+		stderrSpy = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+		stdoutSpy = vi
+			.spyOn(process.stdout, "write")
+			.mockImplementation(() => true);
+	});
+
+	it("downloads and pipes bundle to stdout when workerId is set", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: "worker-123",
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+
+		// Create a mock web stream
+		const mockWebStream = new ReadableStream({
+			start(controller) {
+				controller.enqueue(new TextEncoder().encode("bundle content"));
+				controller.close();
+			},
+		});
+
+		// This allows us to wait for the pipe to happen.
+		let resolveWrite: () => void;
+		const writePromise = new Promise<void>((resolve) => {
+			resolveWrite = resolve;
+		});
+		stdoutSpy = vi.spyOn(process.stdout, "write").mockImplementation(() => {
+			resolveWrite();
+			return true;
+		});
+
+		const mockDownloadWorkerBundle = vi
+			.spyOn(ApiClient.prototype, "downloadWorkerBundle")
+			.mockResolvedValue(Result.success(mockWebStream));
+
+		const context = createBaseContext();
+
+		await downloadBundle.call(context, baseFlags);
+
+		expect(mockDownloadWorkerBundle).toHaveBeenCalledWith("worker-123");
+		await writePromise;
+		expect(stdoutSpy).toHaveBeenCalledWith(Buffer.from("bundle content"));
+	});
+
+	it("throws error when workerId is not set", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: null,
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+
+		const mockDownloadWorkerBundle = vi.spyOn(
+			ApiClient.prototype,
+			"downloadWorkerBundle",
+		);
+
+		const context = createBaseContext();
+
+		await expect(downloadBundle.call(context, baseFlags)).rejects.toThrow(
+			"No worker configured. Run 'workers deploy' first to create a worker.",
+		);
+
+		expect(mockDownloadWorkerBundle).not.toHaveBeenCalled();
+	});
+
+	it("handles download failure gracefully", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: "worker-123",
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+
+		const mockDownloadWorkerBundle = vi
+			.spyOn(ApiClient.prototype, "downloadWorkerBundle")
+			.mockResolvedValue(
+				Result.fail({
+					status: 404,
+					statusText: "Not Found",
+					message: "Worker bundle not found",
+				}),
+			);
+
+		const context = createBaseContext();
+
+		await downloadBundle.call(context, baseFlags);
+
+		expect(mockDownloadWorkerBundle).toHaveBeenCalledWith("worker-123");
+
+		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
+		expect(allCalls).toContain("✗ Failed to download bundle");
+		expect(allCalls).toContain("✗ Worker bundle not found");
+
+		// Should not write anything to stdout on error
+		expect(stdoutSpy).not.toHaveBeenCalled();
+	});
+});

package/src/cli/commands/deploy.impl.test.ts

@@ -0,0 +1,239 @@
+import {
+	afterEach,
+	beforeEach,
+	describe,
+	expect,
+	it,
+	type Mock,
+	vi,
+} from "vitest";
+import { Result } from "../api/result.js";
+import { Config } from "../config.js";
+import {
+	baseFlags,
+	cleanupTmpDirectories,
+	createBaseContext,
+	createTestConfig,
+} from "./utils/testing.js";
+
+// Mock external dependencies
+vi.mock("../deploy.js", () => ({
+	deployWorker: vi.fn(),
+}));
+
+vi.mock("prompts", () => ({
+	default: vi.fn(),
+}));
+
+import prompts from "prompts";
+import { deployWorker } from "../deploy.js";
+import { deploy } from "./deploy.impl.js";
+
+afterEach(cleanupTmpDirectories);
+
+describe("deploy", () => {
+	let stderrSpy: Mock<typeof process.stderr.write>;
+
+	beforeEach(() => {
+		stderrSpy = vi
+			.spyOn(process.stderr, "write")
+			.mockImplementation(() => true);
+	});
+
+	it("deploys existing worker when workerId is set", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: "worker-123",
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+		vi.mocked(deployWorker).mockResolvedValue(
+			Result.success({ workerId: "worker-123" }),
+		);
+
+		const setWorkerIdSpy = vi.spyOn(mockConfig, "setWorkerId");
+		const context = createBaseContext();
+
+		await deploy.call(context, baseFlags);
+
+		expect(deployWorker).toHaveBeenCalledWith(expect.anything(), {
+			workerPath: process.cwd(),
+			workerId: "worker-123",
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			environment: "local",
+		});
+
+		expect(setWorkerIdSpy).toHaveBeenCalledWith("worker-123");
+
+		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
+		expect(allCalls).toContain("Deploying worker...");
+		expect(allCalls).toContain("✓ Successfully deployed worker");
+	});
+
+	it("deploys new worker with name flag", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: null,
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+		vi.mocked(deployWorker).mockResolvedValue(
+			Result.success({ workerId: "worker-456" }),
+		);
+
+		const setWorkerIdSpy = vi.spyOn(mockConfig, "setWorkerId");
+		const context = createBaseContext();
+
+		await deploy.call(context, { ...baseFlags, name: "my-worker" });
+
+		expect(deployWorker).toHaveBeenCalledWith(expect.anything(), {
+			name: "my-worker",
+			workerPath: process.cwd(),
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			environment: "local",
+		});
+
+		expect(setWorkerIdSpy).toHaveBeenCalledWith("worker-456");
+		expect(prompts).not.toHaveBeenCalled();
+
+		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
+		expect(allCalls).toContain("✓ Successfully deployed worker");
+	});
+
+	it("prompts for name when deploying new worker without name flag", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: null,
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+		vi.mocked(prompts).mockResolvedValue({ name: "prompted-worker" });
+		vi.mocked(deployWorker).mockResolvedValue(
+			Result.success({ workerId: "worker-789" }),
+		);
+
+		const setWorkerIdSpy = vi.spyOn(mockConfig, "setWorkerId");
+		const context = createBaseContext();
+
+		await deploy.call(context, baseFlags);
+
+		expect(prompts).toHaveBeenCalledWith({
+			type: "text",
+			name: "name",
+			message: "Enter a name for the worker",
+			validate: expect.any(Function),
+		});
+
+		expect(deployWorker).toHaveBeenCalledWith(expect.anything(), {
+			name: "prompted-worker",
+			workerPath: process.cwd(),
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			environment: "local",
+		});
+
+		expect(setWorkerIdSpy).toHaveBeenCalledWith("worker-789");
+	});
+
+	it("throws error when prompt is cancelled", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: null,
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+		vi.mocked(prompts).mockResolvedValue({ name: undefined });
+
+		const context = createBaseContext();
+
+		await expect(deploy.call(context, baseFlags)).rejects.toThrow(
+			"Name is required",
+		);
+	});
+
+	it("throws error when both workerId and name are provided", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: "worker-123",
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+
+		const context = createBaseContext();
+
+		await expect(
+			deploy.call(context, { ...baseFlags, name: "my-worker" }),
+		).rejects.toThrow("Cannot specify a name when updating an existing worker");
+	});
+
+	it("handles deployment failure", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: "worker-123",
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+		vi.mocked(deployWorker).mockResolvedValue(
+			Result.fail({
+				status: 500,
+				statusText: "Internal Server Error",
+				message: "Deployment failed",
+			}),
+		);
+
+		const context = createBaseContext();
+
+		await deploy.call(context, baseFlags);
+
+		const allCalls = stderrSpy.mock.calls.map((call) => call[0]).join("");
+		expect(allCalls).toContain("✗ Failed to deploy worker");
+		expect(allCalls).toContain("Deployment failed");
+	});
+
+	it("trims whitespace from prompted name", async () => {
+		const mockConfig = await createTestConfig({
+			token:
+				"1.2.eyJzcGFjZUlkIjoic3BhY2UxIiwidXNlcklkIjoidXNlcjEiLCJjZWxsSWQiOiJjZWxsMSJ9.sig",
+			workerId: null,
+			environment: "local",
+			baseUrl: "http://localhost:3000",
+		});
+
+		vi.spyOn(Config, "load").mockResolvedValue(mockConfig);
+		vi.mocked(prompts).mockResolvedValue({ name: "  worker-name  " });
+		vi.mocked(deployWorker).mockResolvedValue(
+			Result.success({ workerId: "worker-999" }),
+		);
+
+		const context = createBaseContext();
+
+		await deploy.call(context, baseFlags);
+
+		expect(deployWorker).toHaveBeenCalledWith(
+			expect.anything(),
+			expect.objectContaining({
+				name: "worker-name",
+			}),
+		);
+	});
+});

package/src/cli/commands/exec.impl.ts

@@ -82,6 +82,10 @@ export const exec = buildAuthedHandler(async function (
 
 					switch (parsedLine._tag) {
 						case "log":
+							if (!flags.debug) {
+								break;
+							}
+
 							if (parsedLine.event.stream === "stdout") {
 								allOutput.push(parsedLine.event.data);
 							}

package/src/cli/commands/utils/testing.ts

@@ -0,0 +1,60 @@
+import * as fs from "node:fs";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import * as os from "node:os";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { Config, type Environment } from "../../config.js";
+import type { GlobalFlags } from "../../flags.js";
+import { Writer } from "../../writer.js";
+
+export type ConfigFileContents = {
+	token: string | null;
+	workerId: string | null;
+	environment: Environment;
+	baseUrl: string;
+};
+
+export const tmpDirectories: string[] = [];
+
+export const baseFlags: GlobalFlags = {
+	debug: false,
+};
+
+export async function createConfigFile(contents: ConfigFileContents) {
+	const dir = await mkdtemp(path.join(tmpdir(), "cmd-test-"));
+	tmpDirectories.push(dir);
+	const configFilePath = path.join(dir, "config.json");
+
+	await writeFile(configFilePath, JSON.stringify(contents, null, 2), "utf-8");
+	return configFilePath;
+}
+
+export async function createTestConfig(
+	configFileContents: ConfigFileContents,
+): Promise<Config> {
+	const configFilePath = await createConfigFile(configFileContents);
+	return Config.load({
+		configFilePath,
+		processEnv: {} as NodeJS.ProcessEnv,
+		flags: { debug: false },
+	});
+}
+
+export function createBaseContext() {
+	return {
+		writer: new Writer({ debugEnabled: false }),
+		process,
+		fs,
+		os,
+		path,
+	};
+}
+
+export async function cleanupTmpDirectories() {
+	while (tmpDirectories.length > 0) {
+		const dir = tmpDirectories.pop();
+		if (dir) {
+			await rm(dir, { recursive: true, force: true });
+		}
+	}
+}

package/src/cli/config.test.ts

@@ -0,0 +1,114 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import * as path from "node:path";
+import { afterEach, describe, expect, it } from "vitest";
+import { Config, type Environment } from "./config.js";
+import type { GlobalFlags } from "./flags.js";
+
+type ConfigFileContents = {
+	token: string | null;
+	workerId: string | null;
+	environment: Environment;
+	baseUrl: string;
+};
+
+const tmpDirectories: string[] = [];
+
+async function createConfigFile(contents: ConfigFileContents) {
+	const dir = await mkdtemp(path.join(tmpdir(), "config-test-"));
+	tmpDirectories.push(dir);
+	const configFilePath = path.join(dir, "config.json");
+
+	await writeFile(configFilePath, JSON.stringify(contents, null, 2), "utf-8");
+	return configFilePath;
+}
+
+afterEach(async () => {
+	while (tmpDirectories.length > 0) {
+		const dir = tmpDirectories.pop();
+		if (dir) {
+			await rm(dir, { recursive: true, force: true });
+		}
+	}
+});
+
+async function loadTestConfig({
+	configFile,
+	env,
+	flags,
+}: {
+	configFile: ConfigFileContents;
+	env?: Partial<NodeJS.ProcessEnv>;
+	flags?: Partial<GlobalFlags>;
+}) {
+	const configFilePath = await createConfigFile(configFile);
+	return Config.load({
+		configFilePath,
+		processEnv: { ...(env ?? {}) } as NodeJS.ProcessEnv,
+		flags: {
+			debug: false,
+			...(flags ?? {}),
+		},
+	});
+}
+
+const baseConfigFile: ConfigFileContents = {
+	token: "file-token",
+	workerId: "file-worker",
+	environment: "local",
+	baseUrl: "https://config.example.com",
+};
+
+describe("Config.load precedence", () => {
+	it("uses values from the config file when no overrides are present", async () => {
+		const config = await loadTestConfig({
+			configFile: baseConfigFile,
+		});
+
+		expect(config.token).toBe(baseConfigFile.token);
+		expect(config.workerId).toBe(baseConfigFile.workerId);
+		expect(config.environment).toBe(baseConfigFile.environment);
+		expect(config.baseUrl).toBe(baseConfigFile.baseUrl);
+	});
+
+	it("prefers environment variables over the config file", async () => {
+		const envVars = {
+			WORKERS_TOKEN: "env-token",
+			WORKERS_WORKER_ID: "env-worker",
+			WORKERS_ENVIRONMENT: "staging",
+		};
+		const config = await loadTestConfig({
+			configFile: baseConfigFile,
+			env: envVars,
+		});
+
+		expect(config.token).toBe(envVars.WORKERS_TOKEN);
+		expect(config.workerId).toBe(envVars.WORKERS_WORKER_ID);
+		expect(config.environment).toBe(envVars.WORKERS_ENVIRONMENT);
+		expect(config.baseUrl).toBe(baseConfigFile.baseUrl);
+	});
+
+	it("prefers flags over environment variables and config file values", async () => {
+		const envVars = {
+			WORKERS_WORKER_ID: "env-worker",
+			WORKERS_ENVIRONMENT: "staging",
+			WORKERS_BASE_URL: "https://env.example.com",
+		};
+
+		const flags = {
+			env: "dev" as const,
+			"base-url": "https://flag.example.com",
+		};
+
+		const config = await loadTestConfig({
+			configFile: baseConfigFile,
+			env: envVars,
+			flags,
+		});
+
+		expect(config.token).toBe(baseConfigFile.token);
+		expect(config.workerId).toBe(envVars.WORKERS_WORKER_ID);
+		expect(config.environment).toBe(flags.env);
+		expect(config.baseUrl).toBe(flags["base-url"]);
+	});
+});