@project-ajax/sdk 0.0.54 → 0.0.56

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

@@ -19,9 +19,9 @@ export const listRuns = buildAuthedHandler(async function (flags: FormatFlags) {
 
 		const data = Result.unwrap(result);
 		if (data.runs.length === 0) {
-			this.writer.writeErr("No runs found for this worker.");
+			this.io.writeErr("No runs found for this worker.");
 		} else {
-			this.writer.writeTableOut({
+			this.io.writeTableOut({
 				headers: ["Run ID", "Name", "Started At", "Ended At", "Exit Code"],
 				rows: data.runs.map((run) => [
 					run.runId,
@@ -38,10 +38,10 @@ export const listRuns = buildAuthedHandler(async function (flags: FormatFlags) {
 
 		// If it's a validation error, show the clean debug message
 		if (result.error.validationError) {
-			this.writer.writeErr(`✗ ${result.error.validationError.debugMessage}`);
+			this.io.writeErr(`✗ ${result.error.validationError.debugMessage}`);
 			throw new Error(result.error.validationError.debugMessage);
 		} else {
-			this.writer.writeErr(`✗ ${result.error.message}`);
+			this.io.writeErr(`✗ ${result.error.message}`);
 			throw new Error(result.error.message);
 		}
 	}
@@ -71,16 +71,16 @@ export const getRunLogs = buildAuthedHandler(async function (
 
 		const data = Result.unwrap(result);
 		// Output logs directly to stdout (primary output)
-		this.writer.writeOut(data.logs);
+		this.io.writeOut(data.logs);
 	} else {
 		this.process.stderr.write("ERROR\n\n");
 
 		// If it's a validation error, show the clean debug message
 		if (result.error.validationError) {
-			this.writer.writeErr(`✗ ${result.error.validationError.debugMessage}`);
+			this.io.writeErr(`✗ ${result.error.validationError.debugMessage}`);
 			throw new Error(result.error.validationError.debugMessage);
 		} else {
-			this.writer.writeErr(`✗ ${result.error.message}`);
+			this.io.writeErr(`✗ ${result.error.message}`);
 			throw new Error(result.error.message);
 		}
 	}

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

@@ -17,17 +17,17 @@ export const setSecrets = buildAuthedHandler(async function (
 		);
 	}
 
-	this.writer.writeErr(`Setting ${pluralize(secrets.length, "secret")}...`);
+	this.io.writeErr(`Setting ${pluralize(secrets.length, "secret")}...`);
 
 	const result = await this.apiClient.upsertSecrets(workerId, secrets);
 
 	if (Result.isSuccess(result)) {
 		for (const secret of Result.unwrap(result).secrets) {
-			this.writer.writeErr(`Set secret "${secret.key}"`);
+			this.io.writeErr(`Set secret "${secret.key}"`);
 		}
 	} else {
-		this.writer.writeErr(`✗ Failed to set secrets`);
-		this.writer.writeErr(`✗ ${result.error.message}`);
+		this.io.writeErr(`✗ Failed to set secrets`);
+		this.io.writeErr(`✗ ${result.error.message}`);
 		throw new Error(result.error.message);
 	}
 });
@@ -51,25 +51,25 @@ export const listSecrets = buildAuthedHandler(async function (
 
 		const data = Result.unwrap(result);
 		if (data.secrets.length === 0) {
-			this.writer.writeErr("No secrets for this worker.");
-			this.writer.writeErr(
+			this.io.writeErr("No secrets for this worker.");
+			this.io.writeErr(
 				"To list OAuth connect secrets, use `npx workers connect list`",
 			);
 		} else {
-			this.writer.writeTableOut({
+			this.io.writeTableOut({
 				headers: ["Key", "Created At"],
 				rows: data.secrets.map((secret) => [secret.key, secret.createdAt]),
 				plain: flags.plain,
 			});
-			this.writer.writeErr(
+			this.io.writeErr(
 				"To list OAuth connect secrets, use `npx workers connect list`",
 			);
 		}
 	} else {
 		this.process.stderr.write("ERROR\n\n");
 
-		this.writer.writeErr(`✗ Failed to list secrets`);
-		this.writer.writeErr(`✗ ${result.error.message}`);
+		this.io.writeErr(`✗ Failed to list secrets`);
+		this.io.writeErr(`✗ ${result.error.message}`);
 		throw new Error(result.error.message);
 	}
 });
@@ -94,8 +94,8 @@ export const removeSecret = buildAuthedHandler(async function (
 	} else {
 		this.process.stderr.write("ERROR\n\n");
 
-		this.writer.writeErr(`✗ Failed to remove secret "${key}"`);
-		this.writer.writeErr(`✗ ${result.error.message}`);
+		this.io.writeErr(`✗ Failed to remove secret "${key}"`);
+		this.io.writeErr(`✗ ${result.error.message}`);
 		throw new Error(result.error.message);
 	}
 });

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

@@ -3,16 +3,10 @@ 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 { Config, type ConfigMap } from "../../config.js";
+import type { LocalContext } from "../../context.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;
-};
+import { IO } from "../../io.js";
 
 export const tmpDirectories: string[] = [];
 
@@ -20,33 +14,36 @@ 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 createAndLoadConfig({
+	configFile,
+	env,
+	flags,
+}: {
+	configFile: Partial<ConfigMap>;
+	env?: Partial<NodeJS.ProcessEnv>;
+	flags?: Partial<GlobalFlags>;
+}): Promise<[config: Config, path: string]> {
+	const configFilePath = await createConfigFile(configFile);
 
-export async function createTestConfig(
-	configFileContents: ConfigFileContents,
-): Promise<Config> {
-	const configFilePath = await createConfigFile(configFileContents);
-	return Config.load({
+	const map = await Config.load({
 		configFilePath,
-		processEnv: {} as NodeJS.ProcessEnv,
-		flags: { debug: false },
+		processEnv: env ?? {},
+		flags: {
+			...baseFlags,
+			...(flags ?? {}),
+		},
 	});
+
+	return [map, configFilePath];
 }
 
-export function createBaseContext() {
+export function createBaseContext(): LocalContext {
 	return {
-		writer: new Writer({ debugEnabled: false }),
-		process,
 		fs,
+		io: new IO({ debugEnabled: false }),
 		os,
 		path,
+		process,
 	};
 }
 
@@ -58,3 +55,12 @@ export async function cleanupTmpDirectories() {
 		}
 	}
 }
+
+async function createConfigFile(contents: Partial<ConfigMap>) {
+	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;
+}

package/src/cli/config.test.ts

@@ -1,74 +1,30 @@
-import { mkdtemp, rm, writeFile } from "node:fs/promises";
-import { tmpdir } from "node:os";
-import * as path from "node:path";
+import { readFile } from "node:fs/promises";
 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");
+import {
+	cleanupTmpDirectories,
+	createAndLoadConfig,
+} from "./commands/utils/testing.js";
+import { Config, type ConfigMap } from "./config.js";
 
-	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 = {
+const baseConfigMap: ConfigMap = {
 	token: "file-token",
 	workerId: "file-worker",
 	environment: "local",
 	baseUrl: "https://config.example.com",
 };
 
+afterEach(cleanupTmpDirectories);
+
 describe("Config.load precedence", () => {
 	it("uses values from the config file when no overrides are present", async () => {
-		const config = await loadTestConfig({
-			configFile: baseConfigFile,
+		const [config] = await createAndLoadConfig({
+			configFile: baseConfigMap,
 		});
 
-		expect(config.token).toBe(baseConfigFile.token);
-		expect(config.workerId).toBe(baseConfigFile.workerId);
-		expect(config.environment).toBe(baseConfigFile.environment);
-		expect(config.baseUrl).toBe(baseConfigFile.baseUrl);
+		expect(config.token).toBe(baseConfigMap.token);
+		expect(config.workerId).toBe(baseConfigMap.workerId);
+		expect(config.environment).toBe(baseConfigMap.environment);
+		expect(config.baseUrl).toBe(baseConfigMap.baseUrl);
 	});
 
 	it("prefers environment variables over the config file", async () => {
@@ -77,15 +33,15 @@ describe("Config.load precedence", () => {
 			WORKERS_WORKER_ID: "env-worker",
 			WORKERS_ENVIRONMENT: "staging",
 		};
-		const config = await loadTestConfig({
-			configFile: baseConfigFile,
+		const [config] = await createAndLoadConfig({
+			configFile: baseConfigMap,
 			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);
+		expect(config.baseUrl).toBe(baseConfigMap.baseUrl);
 	});
 
 	it("prefers flags over environment variables and config file values", async () => {
@@ -100,59 +56,53 @@ describe("Config.load precedence", () => {
 			"base-url": "https://flag.example.com",
 		};
 
-		const config = await loadTestConfig({
-			configFile: baseConfigFile,
+		const [config] = await createAndLoadConfig({
+			configFile: baseConfigMap,
 			env: envVars,
 			flags,
 		});
 
-		expect(config.token).toBe(baseConfigFile.token);
+		expect(config.token).toBe(baseConfigMap.token);
 		expect(config.workerId).toBe(envVars.WORKERS_WORKER_ID);
 		expect(config.environment).toBe(flags.env);
 		expect(config.baseUrl).toBe(flags["base-url"]);
 	});
 });
 
-describe("Config.setEnvironment", () => {
-	it("updates the baseUrl when environment is changed", async () => {
-		const config = await loadTestConfig({
+describe("Config.update", () => {
+	it("persists only provided keys to disk", async () => {
+		const [, configFilePath] = await createAndLoadConfig({
 			configFile: {
-				token: "test-token",
-				workerId: null,
+				token: "file-token",
+				workerId: "file-worker",
 				environment: "prod",
-				baseUrl: "https://www.notion.so",
+				baseUrl: "https://config.example.com",
 			},
 		});
 
-		expect(config.environment).toBe("prod");
-		expect(config.baseUrl).toBe("https://www.notion.so");
-
-		await config.setEnvironment("local");
+		const config = await Config.load({
+			configFilePath,
+			processEnv: {
+				WORKERS_BASE_URL: "https://env.example.com",
+			} as NodeJS.ProcessEnv,
+			flags: { debug: false },
+		});
 
-		expect(config.environment).toBe("local");
-		expect(config.baseUrl).toBe("http://localhost:3000");
-	});
+		expect(config.baseUrl).toBe("https://env.example.com");
 
-	it("updates baseUrl for all environments", async () => {
-		const config = await loadTestConfig({
-			configFile: {
-				token: "test-token",
-				workerId: null,
-				environment: "prod",
-				baseUrl: "https://www.notion.so",
-			},
+		await config.update({
+			token: "updated-token",
 		});
 
-		await config.setEnvironment("staging");
-		expect(config.baseUrl).toBe("https://staging.notion.so");
+		expect(config.token).toBe("updated-token");
 
-		await config.setEnvironment("dev");
-		expect(config.baseUrl).toBe("https://dev.notion.so");
+		const persisted = JSON.parse(await readFile(configFilePath, "utf-8"));
 
-		await config.setEnvironment("prod");
-		expect(config.baseUrl).toBe("https://www.notion.so");
-
-		await config.setEnvironment("local");
-		expect(config.baseUrl).toBe("http://localhost:3000");
+		expect(persisted).toEqual({
+			token: "updated-token",
+			workerId: "file-worker",
+			environment: "prod",
+			baseUrl: "https://config.example.com",
+		});
 	});
 });

package/src/cli/config.ts

@@ -5,7 +5,7 @@ import type { GlobalFlags } from "./flags.js";
 export const Environments = ["local", "staging", "dev", "prod"] as const;
 export type Environment = (typeof Environments)[number];
 
-interface ConfigMap {
+export interface ConfigMap {
 	environment: Environment;
 	baseUrl: string;
 	token: string | null;
@@ -46,11 +46,11 @@ export class Config {
 	readonly #configFilePath: string;
 
 	constructor(opts: {
+		configMap: ConfigMap;
 		configFilePath: string;
-		configFile: ConfigMap;
 	}) {
+		this.#configMap = opts.configMap;
 		this.#configFilePath = opts.configFilePath;
-		this.#configMap = opts.configFile;
 	}
 
 	// Getters read from the environment variables, and then the config file.
@@ -71,32 +71,6 @@ export class Config {
 		return this.#configMap.workerId;
 	}
 
-	// Setters update the config file, and then write it to disk.
-
-	async setEnvironment(environment: Environment) {
-		this.#configMap.environment = environment;
-		this.#configMap.baseUrl = baseUrl(environment);
-		await this.#writeConfigFile();
-	}
-
-	async setToken(token: string | null) {
-		this.#configMap.token = token;
-		await this.#writeConfigFile();
-	}
-
-	async setWorkerId(workerId: string | null) {
-		this.#configMap.workerId = workerId;
-		await this.#writeConfigFile();
-	}
-
-	async #writeConfigFile() {
-		await fs.promises.writeFile(
-			this.#configFilePath,
-			JSON.stringify(this.#configMap, null, 2),
-			"utf-8",
-		);
-	}
-
 	get tokenInfo(): { token: string; spaceId: string; cellId: string } {
 		const token = this.token;
 		if (!token) {
@@ -107,47 +81,100 @@ export class Config {
 		return { token, spaceId, cellId };
 	}
 
+	/**
+	 * Update the config with a partial config map.
+	 *
+	 * This will write only the updated keys in the config file on disk. Not all
+	 * keys are written, since some current keys in the Config object may have
+	 * come from e.g. environment variables, rather than the original config
+	 * file.
+	 *
+	 * @param config The config update.
+	 */
+	async update(config: Partial<ConfigMap>) {
+		Object.assign(this.#configMap, config);
+
+		const currentConfigFile = await Config.#readConfigFile(
+			this.#configFilePath,
+		);
+		Object.assign(currentConfigFile, config);
+		await fs.promises.writeFile(
+			this.#configFilePath,
+			JSON.stringify(currentConfigFile, null, 2),
+			"utf-8",
+		);
+	}
+
 	static async load(opts: {
 		configFilePath: string;
 		processEnv: NodeJS.ProcessEnv;
 		flags: GlobalFlags;
 	}) {
 		const absConfigFilePath = path.resolve(process.cwd(), opts.configFilePath);
-		const configFile = await Config.#readConfigFile(absConfigFilePath);
+		const partialConfig = await Config.#readConfigFile(absConfigFilePath);
 
 		if (opts.processEnv.WORKERS_TOKEN) {
-			configFile.token = opts.processEnv.WORKERS_TOKEN;
+			partialConfig.token = opts.processEnv.WORKERS_TOKEN;
 		}
 		if (opts.processEnv.WORKERS_ENVIRONMENT) {
-			configFile.environment = parseEnvironment(
+			partialConfig.environment = parseEnvironment(
 				opts.processEnv.WORKERS_ENVIRONMENT,
 			);
 		}
 		if (opts.processEnv.WORKERS_WORKER_ID) {
-			configFile.workerId = opts.processEnv.WORKERS_WORKER_ID;
+			partialConfig.workerId = opts.processEnv.WORKERS_WORKER_ID;
 		}
 		if (opts.processEnv.WORKERS_BASE_URL) {
-			configFile.baseUrl = opts.processEnv.WORKERS_BASE_URL;
+			partialConfig.baseUrl = opts.processEnv.WORKERS_BASE_URL;
 		}
 
 		if (opts.flags.token) {
-			configFile.token = opts.flags.token;
+			partialConfig.token = opts.flags.token;
 		}
 		if (opts.flags.env) {
-			configFile.environment = parseEnvironment(opts.flags.env);
+			partialConfig.environment = parseEnvironment(opts.flags.env);
 		}
 		if (opts.flags["base-url"]) {
-			configFile.baseUrl = opts.flags["base-url"];
+			partialConfig.baseUrl = opts.flags["base-url"];
 		}
 		if (opts.flags["worker-id"]) {
-			configFile.workerId = opts.flags["worker-id"];
+			partialConfig.workerId = opts.flags["worker-id"];
+		}
+
+		partialConfig.baseUrl ??= baseUrlForEnvironment(
+			partialConfig.environment ?? "prod",
+		);
+
+		const environment = partialConfig.environment;
+		if (!environment) {
+			throw new Error("Environment is required");
+		}
+
+		const baseUrl = partialConfig.baseUrl;
+		if (!baseUrl) {
+			throw new Error("Base URL is required");
+		}
+
+		const token = partialConfig.token;
+		if (token === undefined) {
+			throw new Error("Token is required");
+		}
+
+		const workerId = partialConfig.workerId;
+		if (workerId === undefined) {
+			throw new Error("Worker ID is required");
 		}
 
-		configFile.baseUrl ??= baseUrl(configFile.environment ?? "prod");
+		const configMap: ConfigMap = {
+			environment,
+			baseUrl,
+			token,
+			workerId,
+		};
 
 		return new Config({
 			configFilePath: absConfigFilePath,
-			configFile: configFile as ConfigMap,
+			configMap,
 		});
 	}
 
@@ -168,7 +195,7 @@ export class Config {
 					token: null,
 					workerId: null,
 					environment: "prod",
-					baseUrl: baseUrl("prod"),
+					baseUrl: baseUrlForEnvironment("prod"),
 				};
 			} else {
 				throw error;
@@ -227,7 +254,7 @@ export function extractPayloadFromToken(token: string): {
 	}
 }
 
-function baseUrl(environment: Environment): string {
+function baseUrlForEnvironment(environment: Environment): string {
 	switch (environment) {
 		case "local":
 			return "http://localhost:3000";

package/src/cli/context.ts

@@ -3,24 +3,24 @@ import * as os from "node:os";
 import * as path from "node:path";
 import type { StricliAutoCompleteContext } from "@stricli/auto-complete";
 import type { CommandContext } from "@stricli/core";
-import { Writer } from "./writer.js";
+import { IO } from "./io.js";
 
 export interface LocalContext
 	extends CommandContext,
 		StricliAutoCompleteContext {
 	readonly fs: typeof fs;
+	readonly io: IO;
 	readonly os: typeof os;
 	readonly path: typeof path;
 	readonly process: NodeJS.Process;
-	readonly writer: Writer;
 }
 
 export function buildContext(process: NodeJS.Process): LocalContext {
 	return {
 		fs,
+		io: new IO({ debugEnabled: false }),
 		os,
 		path,
 		process,
-		writer: new Writer({ debugEnabled: false }),
 	};
 }

package/src/cli/deploy.ts

@@ -53,7 +53,7 @@ export async function deployWorker(
 
 	// Resolve absolute path
 	const absPath = path.resolve(process.cwd(), workerPath);
-	context.writer.debug(`Deploying worker from: ${absPath}`);
+	context.io.debug(`Deploying worker from: ${absPath}`);
 
 	// Create API client
 	const client = context.apiClient;
@@ -63,7 +63,7 @@ export async function deployWorker(
 	let workerId: string;
 
 	if ("workerId" in options) {
-		context.writer.writeErr(`Updating worker...`);
+		context.io.writeErr(`Updating worker...`);
 
 		workerId = options.workerId;
 
@@ -73,13 +73,13 @@ export async function deployWorker(
 			uploadUrl = res.url;
 			uploadFields = res.fields;
 		} else {
-			context.writer.writeErr(
+			context.io.writeErr(
 				"Failed to generate pre-signed upload URL for worker bundle:",
 			);
 			throw new Error(updateResult.error.message);
 		}
 	} else {
-		context.writer.writeErr(`Creating worker...`);
+		context.io.writeErr(`Creating worker...`);
 
 		const createResult = await client.createWorker(options.name);
 		if (Result.isSuccess(createResult)) {
@@ -93,20 +93,20 @@ export async function deployWorker(
 		}
 	}
 
-	context.writer.debug(`Generated upload URL: ${uploadUrl}`);
+	context.io.debug(`Generated upload URL: ${uploadUrl}`);
 
 	// Build the worker bundle
-	context.writer.writeErr("Building worker bundle...");
+	context.io.writeErr("Building worker bundle...");
 	const archivePath = await buildWorkerBundle(context, absPath);
-	context.writer.debug(`Created bundle at: ${archivePath}`);
+	context.io.debug(`Created bundle at: ${archivePath}`);
 
 	// Upload the bundle
-	context.writer.writeErr("Uploading bundle...");
+	context.io.writeErr("Uploading bundle...");
 	await uploadBundle(uploadUrl, uploadFields, archivePath);
-	context.writer.debug("Upload complete");
+	context.io.debug("Upload complete");
 
 	// Fetch and save capabilities
-	context.writer.writeErr("Fetching and saving worker capabilities...");
+	context.io.writeErr("Fetching and saving worker capabilities...");
 	const capabilitiesResult = await client.fetchAndSaveCapabilities(workerId);
 
 	if (Result.isSuccess(capabilitiesResult)) {
@@ -141,7 +141,7 @@ async function buildWorkerBundle(
 		platform: "node",
 	});
 
-	context.writer.debug(`Built bundle to: ${outdir}`);
+	context.io.debug(`Built bundle to: ${outdir}`);
 
 	// Create tar.gz archive
 	const archiveDir = fs.mkdtempSync("/tmp/workers-archive-");