@project-ajax/sdk 0.0.50 → 0.0.52

package/src/cli/config.ts

@@ -1,12 +1,13 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
+import type { GlobalFlags } from "./flags.js";
 
 export const Environments = ["local", "staging", "dev", "prod"] as const;
 export type Environment = (typeof Environments)[number];
 
-interface ConfigFile {
-	environment?: Environment;
-	baseUrl?: string;
+interface ConfigMap {
+	environment: Environment;
+	baseUrl: string;
 	token: string | null;
 	workerId: string | null;
 }
@@ -41,66 +42,56 @@ export class TokenNotSetError extends Error {
  * | WORKERS_BASE_URL     | baseUrl     | The base URL to use |
  */
 export class Config {
-	readonly #configFile: ConfigFile;
+	readonly #configMap: ConfigMap;
 	readonly #configFilePath: string;
-	readonly #env: NodeJS.ProcessEnv;
 
 	constructor(opts: {
 		configFilePath: string;
-		configFile: ConfigFile;
-		processEnv: NodeJS.ProcessEnv;
+		configFile: ConfigMap;
 	}) {
 		this.#configFilePath = opts.configFilePath;
-		this.#configFile = opts.configFile;
-		this.#env = opts.processEnv;
+		this.#configMap = opts.configFile;
 	}
 
 	// Getters read from the environment variables, and then the config file.
 
 	get baseUrl() {
-		return this.#env.WORKERS_BASE_URL ?? this.#configFile.baseUrl;
+		return this.#configMap.baseUrl;
 	}
 
 	get token() {
-		return this.#env.WORKERS_TOKEN ?? this.#configFile.token;
+		return this.#configMap.token;
 	}
 
 	get environment() {
-		return this.#env.WORKERS_ENVIRONMENT
-			? parseEnvironment(this.#env.WORKERS_ENVIRONMENT)
-			: this.#configFile.environment;
+		return this.#configMap.environment;
 	}
 
 	get workerId() {
-		return this.#env.WORKERS_WORKER_ID ?? this.#configFile.workerId;
+		return this.#configMap.workerId;
 	}
 
 	// Setters update the config file, and then write it to disk.
 
 	async setEnvironment(environment: Environment) {
-		this.#configFile.environment = environment;
-		await this.#writeConfigFile();
-	}
-
-	async setBaseUrl(baseUrl: string) {
-		this.#configFile.baseUrl = baseUrl;
+		this.#configMap.environment = environment;
 		await this.#writeConfigFile();
 	}
 
 	async setToken(token: string | null) {
-		this.#configFile.token = token;
+		this.#configMap.token = token;
 		await this.#writeConfigFile();
 	}
 
 	async setWorkerId(workerId: string | null) {
-		this.#configFile.workerId = workerId;
+		this.#configMap.workerId = workerId;
 		await this.#writeConfigFile();
 	}
 
 	async #writeConfigFile() {
 		await fs.promises.writeFile(
 			this.#configFilePath,
-			JSON.stringify(this.#configFile, null, 2),
+			JSON.stringify(this.#configMap, null, 2),
 			"utf-8",
 		);
 	}
@@ -118,28 +109,66 @@ export class Config {
 	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);
+
+		if (opts.processEnv.WORKERS_TOKEN) {
+			configFile.token = opts.processEnv.WORKERS_TOKEN;
+		}
+		if (opts.processEnv.WORKERS_ENVIRONMENT) {
+			configFile.environment = parseEnvironment(
+				opts.processEnv.WORKERS_ENVIRONMENT,
+			);
+		}
+		if (opts.processEnv.WORKERS_WORKER_ID) {
+			configFile.workerId = opts.processEnv.WORKERS_WORKER_ID;
+		}
+		if (opts.processEnv.WORKERS_BASE_URL) {
+			configFile.baseUrl = opts.processEnv.WORKERS_BASE_URL;
+		}
+
+		if (opts.flags.token) {
+			configFile.token = opts.flags.token;
+		}
+		if (opts.flags.env) {
+			configFile.environment = parseEnvironment(opts.flags.env);
+		}
+		if (opts.flags["base-url"]) {
+			configFile.baseUrl = opts.flags["base-url"];
+		}
+		if (opts.flags["worker-id"]) {
+			configFile.workerId = opts.flags["worker-id"];
+		}
+
+		configFile.baseUrl ??= baseUrl(configFile.environment ?? "prod");
+
 		return new Config({
 			configFilePath: absConfigFilePath,
-			configFile,
-			processEnv: opts.processEnv,
+			configFile: configFile as ConfigMap,
 		});
 	}
 
 	static async #readConfigFile(configFilePath: string) {
-		let configFile: ConfigFile;
+		let configFile: Partial<ConfigMap>;
 		try {
 			const configContents = await fs.promises.readFile(
 				configFilePath,
 				"utf-8",
 			);
 
-			configFile = JSON.parse(configContents) as ConfigFile;
+			configFile = JSON.parse(configContents) as Partial<ConfigMap>;
 		} catch (error) {
 			if (isENOENT(error)) {
-				configFile = { token: null, workerId: null };
+				// The default, non-logged in configuration before overrides are
+				// applied from environment variables, and then flags.
+				configFile = {
+					token: null,
+					workerId: null,
+					environment: "prod",
+					baseUrl: baseUrl("prod"),
+				};
 			} else {
 				throw error;
 			}
@@ -196,3 +225,16 @@ export function extractPayloadFromToken(token: string): {
 		throw new Error("Failed to parse token payload.");
 	}
 }
+
+function baseUrl(environment: Environment): string {
+	switch (environment) {
+		case "local":
+			return "http://localhost:3000";
+		case "staging":
+			return "https://staging.notion.so";
+		case "dev":
+			return "https://dev.notion.so";
+		case "prod":
+			return "https://www.notion.so";
+	}
+}

package/src/cli/flags.ts

@@ -1,9 +1,14 @@
 import type { TypedFlagParameter } from "@stricli/core";
+import { type Environment, Environments } from "./config.js";
 import type { LocalContext } from "./context.js";
 
 export interface GlobalFlags {
 	config?: string;
 	debug: boolean;
+	env?: Environment;
+	"base-url"?: string;
+	token?: string;
+	"worker-id"?: string;
 }
 
 export const globalFlags: {
@@ -23,6 +28,30 @@ export const globalFlags: {
 		brief: "Enable debug logging",
 		default: false,
 	},
+	env: {
+		kind: "enum",
+		values: Environments,
+		brief: "The environment to use for the command",
+		optional: true,
+	},
+	"base-url": {
+		kind: "parsed",
+		parse: String,
+		brief: "The base URL to use for all API requests",
+		optional: true,
+	},
+	token: {
+		kind: "parsed",
+		parse: String,
+		brief: "The token to use for authentication",
+		optional: true,
+	},
+	"worker-id": {
+		kind: "parsed",
+		parse: String,
+		brief: "The ID of the worker to use for the command",
+		optional: true,
+	},
 };
 
 export interface FormatFlags {

package/src/cli/handler.ts

@@ -25,13 +25,14 @@ export function buildHandler<const FLAGS, const ARGS extends BaseArgs = []>(
 		...args: ARGS
 	) {
 		const configFilePath =
-			this.process.env.WORKERS_CONFIG_FILE_PATH ??
 			flags.config ??
+			this.process.env.WORKERS_CONFIG_FILE_PATH ??
 			"./workers.json";
 
 		const config = await Config.load({
 			configFilePath,
 			processEnv: process.env,
+			flags,
 		});
 
 		this.writer.debugEnabled = flags.debug;
@@ -53,11 +54,7 @@ export function buildAuthedHandler<
 	return buildHandler(function (flags: FLAGS, ...args: ARGS) {
 		// Check token first - this will throw TokenNotSetError with helpful message if not authenticated
 		const { token, cellId } = this.config.tokenInfo;
-
 		const environment = this.config.environment;
-		if (!environment) {
-			throw new Error("Unexpected error: Environment not set");
-		}
 
 		const client = new ApiClient({
 			token,