@mtndev/cli 2.0.0 → 2.0.1

package/cjs/commands/db/create-readonly-user/postgres.cjs

@@ -1,9 +1,209 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-var _K4QNHRTPcjs = require('../../../__chunks/K4QNHRTP.cjs');
-require('../../../__chunks/NWZGFHKH.cjs');
-
-
-
-exports.applyPostgresReadonly = _K4QNHRTPcjs.applyPostgresReadonly; exports.listPostgresDatabases = _K4QNHRTPcjs.listPostgresDatabases;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../../../__chunks/VH7oDXx4.cjs");
+const require_commands_db_create_readonly_user_utils = require("./utils.cjs");
+let pg = require("pg");
+pg = require_rolldown_runtime.__toESM(pg, 1);
+//#region src/commands/db/create-readonly-user/postgres.js
+const { Client } = pg.default;
+/**
+* @typedef {import("./utils.js").ConnectionConfig} ConnectionConfig
+*/
+/**
+* @param {ConnectionConfig} config
+* @param {string} [database]
+* @returns {import("pg").Client}
+*/
+function createClient(config, database) {
+	return new Client({
+		host: config.host,
+		port: config.port,
+		user: config.user,
+		password: config.password,
+		database: database ?? (config.database || "postgres"),
+		ssl: config.ssl
+	});
+}
+/**
+* @param {import("pg").Client} client
+* @param {string} sql
+* @param {unknown[]} [params]
+*/
+async function query(client, sql, params) {
+	return client.query(sql, params);
+}
+/**
+* List non-template databases visible to the admin user.
+* @param {ConnectionConfig} config
+* @returns {Promise<string[]>}
+*/
+async function listPostgresDatabases(config) {
+	const client = createClient(config, config.database || "postgres");
+	await client.connect();
+	try {
+		return (await query(client, `SELECT datname
+       FROM pg_database
+       WHERE datistemplate = false
+       ORDER BY datname`)).rows.map((row) => row.datname).filter((name) => !require_commands_db_create_readonly_user_utils.isSystemDatabase({
+			engine: "postgres",
+			name
+		}));
+	} finally {
+		await client.end();
+	}
+}
+/**
+* Ensure a login role exists (create or update password).
+* @param {import("pg").Client} client
+* @param {{ username: string; password: string }} params
+* @returns {Promise<{ created: boolean; statements: string[] }>}
+*/
+async function ensureRole(client, params) {
+	const { username, password } = params;
+	const ident = require_commands_db_create_readonly_user_utils.quoteIdent({
+		engine: "postgres",
+		name: username
+	});
+	const passwordLiteral = require_commands_db_create_readonly_user_utils.quoteLiteral(password);
+	const existing = await query(client, "SELECT 1 FROM pg_roles WHERE rolname = $1", [username]);
+	/** @type {string[]} */
+	const statements = [];
+	if (existing.rowCount && existing.rowCount > 0) {
+		const sql = `ALTER ROLE ${ident} WITH LOGIN PASSWORD ${passwordLiteral}`;
+		statements.push(sql);
+		await query(client, sql);
+		return {
+			created: false,
+			statements
+		};
+	}
+	const sql = `CREATE ROLE ${ident} WITH LOGIN PASSWORD ${passwordLiteral}`;
+	statements.push(sql);
+	await query(client, sql);
+	return {
+		created: true,
+		statements
+	};
+}
+/**
+* Grant read-only privileges inside one database (schemas, tables, sequences, defaults).
+* @param {import("pg").Client} client
+* @param {{ username: string }} params
+* @returns {Promise<string[]>}
+*/
+async function grantReadonlyInDatabase(client, params) {
+	const { username } = params;
+	const ident = require_commands_db_create_readonly_user_utils.quoteIdent({
+		engine: "postgres",
+		name: username
+	});
+	/** @type {string[]} */
+	const statements = [];
+	const schemas = (await query(client, `SELECT nspname
+     FROM pg_namespace
+     WHERE nspname NOT IN ('pg_catalog', 'information_schema', 'pg_toast')
+       AND nspname NOT LIKE 'pg_temp_%'
+       AND nspname NOT LIKE 'pg_toast_temp_%'
+     ORDER BY nspname`)).rows.map((row) => row.nspname);
+	if (schemas.length === 0) schemas.push("public");
+	for (const schema of schemas) {
+		const schemaIdent = require_commands_db_create_readonly_user_utils.quoteIdent({
+			engine: "postgres",
+			name: schema
+		});
+		const grants = [
+			`GRANT USAGE ON SCHEMA ${schemaIdent} TO ${ident}`,
+			`GRANT SELECT ON ALL TABLES IN SCHEMA ${schemaIdent} TO ${ident}`,
+			`GRANT SELECT ON ALL SEQUENCES IN SCHEMA ${schemaIdent} TO ${ident}`,
+			`ALTER DEFAULT PRIVILEGES IN SCHEMA ${schemaIdent} GRANT SELECT ON TABLES TO ${ident}`,
+			`ALTER DEFAULT PRIVILEGES IN SCHEMA ${schemaIdent} GRANT SELECT ON SEQUENCES TO ${ident}`
+		];
+		for (const sql of grants) {
+			statements.push(sql);
+			await query(client, sql);
+		}
+	}
+	return statements;
+}
+/**
+* Create/update a Postgres role and grant read-only on one or all databases.
+* @param {{
+*   config: ConnectionConfig;
+*   username: string;
+*   password: string;
+*   databases: string[];
+*   dryRun?: boolean;
+*   verbose?: boolean;
+* }} params
+* @returns {Promise<{ created: boolean; statements: string[]; databases: string[] }>}
+*/
+async function applyPostgresReadonly(params) {
+	const { config, username, password, databases, dryRun = false, verbose = false } = params;
+	/** @type {string[]} */
+	const statements = [];
+	let created = false;
+	if (dryRun) {
+		const ident = require_commands_db_create_readonly_user_utils.quoteIdent({
+			engine: "postgres",
+			name: username
+		});
+		statements.push(`-- Would CREATE/ALTER ROLE ${ident} WITH LOGIN PASSWORD ***`);
+		for (const database of databases) {
+			const dbIdent = require_commands_db_create_readonly_user_utils.quoteIdent({
+				engine: "postgres",
+				name: database
+			});
+			statements.push(`GRANT CONNECT ON DATABASE ${dbIdent} TO ${ident}`);
+			statements.push(`-- In database ${database}: GRANT USAGE/SELECT on all user schemas + ALTER DEFAULT PRIVILEGES`);
+		}
+		return {
+			created: true,
+			statements,
+			databases
+		};
+	}
+	const adminDb = config.database || "postgres";
+	const adminClient = createClient(config, adminDb);
+	await adminClient.connect();
+	try {
+		if (verbose) console.log(`   Connected to Postgres as ${config.user}@${config.host}/${adminDb}`);
+		const roleResult = await ensureRole(adminClient, {
+			username,
+			password
+		});
+		created = roleResult.created;
+		statements.push(...roleResult.statements);
+		const ident = require_commands_db_create_readonly_user_utils.quoteIdent({
+			engine: "postgres",
+			name: username
+		});
+		for (const database of databases) {
+			const connectSql = `GRANT CONNECT ON DATABASE ${require_commands_db_create_readonly_user_utils.quoteIdent({
+				engine: "postgres",
+				name: database
+			})} TO ${ident}`;
+			statements.push(connectSql);
+			await query(adminClient, connectSql);
+		}
+	} finally {
+		await adminClient.end();
+	}
+	for (const database of databases) {
+		const dbClient = createClient(config, database);
+		await dbClient.connect();
+		try {
+			if (verbose) console.log(`   Granting read-only in database ${database}`);
+			const dbStatements = await grantReadonlyInDatabase(dbClient, { username });
+			statements.push(...dbStatements);
+		} finally {
+			await dbClient.end();
+		}
+	}
+	return {
+		created,
+		statements,
+		databases
+	};
+}
+//#endregion
+exports.applyPostgresReadonly = applyPostgresReadonly;
+exports.listPostgresDatabases = listPostgresDatabases;

package/cjs/commands/db/create-readonly-user/schema.cjs

@@ -1,12 +1,39 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-var _H74JSDBUcjs = require('../../../__chunks/H74JSDBU.cjs');
-
-
-
-
-
-exports.DEFAULT_MYSQL_HOST_PATTERN = _H74JSDBUcjs.DEFAULT_MYSQL_HOST_PATTERN; exports.DEFAULT_READONLY_USERNAME = _H74JSDBUcjs.DEFAULT_READONLY_USERNAME; exports.ENGINES = _H74JSDBUcjs.ENGINES; exports.createReadonlyUserOptionsSchema = _H74JSDBUcjs.createReadonlyUserOptionsSchema;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let zod = require("zod");
+//#region src/commands/db/create-readonly-user/schema.js
+/**
+* Supported database engines.
+* @type {readonly ["postgres", "mysql"]}
+*/
+const ENGINES = ["postgres", "mysql"];
+/**
+* Zod schema for `db create-readonly-user` options.
+*/
+const createReadonlyUserOptionsSchema = zod.z.object({
+	engine: zod.z.enum(["postgres", "mysql"]).optional().describe("Database engine (postgres or mysql); inferred from --url when omitted"),
+	url: zod.z.string().optional().describe("Admin connection URL (postgres://… or mysql://…). Defaults to DATABASE_URL / MYSQL_URL / POSTGRES_URL."),
+	database: zod.z.string().optional().describe("Target database name, or \"all\" for every non-system database"),
+	username: zod.z.string().optional().describe("Read-only username to create (default: readonly)"),
+	password: zod.z.string().optional().describe("Password for the new user (generated when omitted)"),
+	hostPattern: zod.z.string().optional().describe("MySQL user host pattern (default: %)"),
+	ssl: zod.z.boolean().optional().describe("Force SSL on/off. Default: off for localhost, on (loose) for remote hosts."),
+	yes: zod.z.boolean().optional().default(false).describe("Skip the confirmation prompt"),
+	dryRun: zod.z.boolean().optional().default(false).describe("Print the SQL plan without applying it"),
+	verbose: zod.z.boolean().optional().default(false).describe("Enable verbose logging")
+});
+/**
+* @typedef {z.infer<typeof createReadonlyUserOptionsSchema>} CreateReadonlyUserOptions
+*/
+/**
+* Default username when none is provided.
+*/
+const DEFAULT_READONLY_USERNAME = "readonly";
+/**
+* Default MySQL host pattern (any client host).
+*/
+const DEFAULT_MYSQL_HOST_PATTERN = "%";
+//#endregion
+exports.DEFAULT_MYSQL_HOST_PATTERN = DEFAULT_MYSQL_HOST_PATTERN;
+exports.DEFAULT_READONLY_USERNAME = DEFAULT_READONLY_USERNAME;
+exports.ENGINES = ENGINES;
+exports.createReadonlyUserOptionsSchema = createReadonlyUserOptionsSchema;

package/cjs/commands/db/create-readonly-user/utils.cjs

@@ -1,22 +1,160 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-
-
-
-
-
-
-
-
-var _NWZGFHKHcjs = require('../../../__chunks/NWZGFHKH.cjs');
-
-
-
-
-
-
-
-
-
-
-exports.buildReadonlyUrl = _NWZGFHKHcjs.buildReadonlyUrl; exports.detectEngineFromUrl = _NWZGFHKHcjs.detectEngineFromUrl; exports.generatePassword = _NWZGFHKHcjs.generatePassword; exports.isSystemDatabase = _NWZGFHKHcjs.isSystemDatabase; exports.parseConnectionUrl = _NWZGFHKHcjs.parseConnectionUrl; exports.quoteIdent = _NWZGFHKHcjs.quoteIdent; exports.quoteLiteral = _NWZGFHKHcjs.quoteLiteral; exports.resolveAdminUrl = _NWZGFHKHcjs.resolveAdminUrl; exports.resolveSsl = _NWZGFHKHcjs.resolveSsl;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let crypto = require("crypto");
+//#region src/commands/db/create-readonly-user/utils.js
+/**
+* @typedef {"postgres" | "mysql"} Engine
+*/
+/**
+* @typedef {Object} ConnectionConfig
+* @property {Engine} engine
+* @property {string} host
+* @property {number} port
+* @property {string} user
+* @property {string} password
+* @property {string} database
+* @property {boolean | object} ssl
+* @property {string} [url]
+*/
+/**
+* Generate a URL-safe random password.
+* @param {{ length?: number }} [params]
+* @returns {string}
+*/
+function generatePassword(params = {}) {
+	const { length = 24 } = params;
+	const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz23456789!@#$%^&*";
+	const bytes = (0, crypto.randomBytes)(length);
+	let result = "";
+	for (let i = 0; i < length; i += 1) {
+		const byte = bytes[i] ?? 0;
+		result += alphabet[byte % 65];
+	}
+	return result;
+}
+/**
+* Detect engine from a connection URL scheme.
+* @param {string} url
+* @returns {Engine | null}
+*/
+function detectEngineFromUrl(url) {
+	const trimmed = url.trim().toLowerCase();
+	if (trimmed.startsWith("postgres://") || trimmed.startsWith("postgresql://")) return "postgres";
+	if (trimmed.startsWith("mysql://") || trimmed.startsWith("mysql2://")) return "mysql";
+	return null;
+}
+/**
+* Resolve an admin URL from flags / common env vars.
+* @param {{ url?: string; engine?: Engine }} params
+* @returns {string | null}
+*/
+function resolveAdminUrl(params) {
+	const { url, engine } = params;
+	if (url) return url;
+	if (engine === "mysql") return process.env.MYSQL_URL ?? process.env.DATABASE_URL ?? process.env.MYSQL_DATABASE_URL ?? null;
+	if (engine === "postgres") return process.env.DATABASE_URL ?? process.env.POSTGRES_URL ?? process.env.POSTGRESQL_URL ?? null;
+	return process.env.DATABASE_URL ?? process.env.POSTGRES_URL ?? process.env.POSTGRESQL_URL ?? process.env.MYSQL_URL ?? process.env.MYSQL_DATABASE_URL ?? null;
+}
+/**
+* Decide SSL settings: remote hosts get loose SSL by default (RDS-friendly).
+* @param {{ host: string; sslOption?: boolean }} params
+* @returns {boolean | object}
+*/
+function resolveSsl(params) {
+	const { host, sslOption } = params;
+	if (sslOption === true) return { rejectUnauthorized: false };
+	if (sslOption === false) return false;
+	if (host === "localhost" || host === "127.0.0.1" || host === "::1" || host === "0.0.0.0") return false;
+	return { rejectUnauthorized: false };
+}
+/**
+* Parse a postgres/mysql connection URL into a config object.
+* @param {{ url: string; engine?: Engine; sslOption?: boolean }} params
+* @returns {ConnectionConfig}
+*/
+function parseConnectionUrl(params) {
+	const { url, engine: engineOption, sslOption } = params;
+	const engine = engineOption ?? detectEngineFromUrl(url);
+	if (!engine) throw new Error(`Could not detect engine from URL. Pass --engine postgres|mysql. URL starts with: ${url.slice(0, 24)}…`);
+	let parsed;
+	try {
+		parsed = new URL(url);
+	} catch {
+		throw new Error(`Invalid connection URL: ${url}`);
+	}
+	const defaultPort = engine === "postgres" ? 5432 : 3306;
+	const port = parsed.port ? Number.parseInt(parsed.port, 10) : defaultPort;
+	const database = decodeURIComponent(parsed.pathname.replace(/^\//, "")) || (engine === "postgres" ? "postgres" : "");
+	const host = parsed.hostname || "localhost";
+	const user = decodeURIComponent(parsed.username || "");
+	const password = decodeURIComponent(parsed.password || "");
+	if (!user) throw new Error("Connection URL is missing a username");
+	return {
+		engine,
+		host,
+		port: Number.isFinite(port) ? port : defaultPort,
+		user,
+		password,
+		database,
+		ssl: resolveSsl({
+			host,
+			sslOption
+		}),
+		url
+	};
+}
+/**
+* Build a client connection URL for the new read-only user.
+* @param {{
+*   engine: Engine;
+*   host: string;
+*   port: number;
+*   username: string;
+*   password: string;
+*   database: string;
+* }} params
+* @returns {string}
+*/
+function buildReadonlyUrl(params) {
+	const { engine, host, port, username, password, database } = params;
+	return `${engine === "postgres" ? "postgresql" : "mysql"}://${`${encodeURIComponent(username)}:${encodeURIComponent(password)}`}@${host}:${port}${database ? `/${encodeURIComponent(database)}` : "/"}`;
+}
+/**
+* Quote an identifier for the given engine (not for string literals).
+* @param {{ engine: Engine; name: string }} params
+* @returns {string}
+*/
+function quoteIdent(params) {
+	const { engine, name } = params;
+	if (engine === "postgres") return `"${name.replace(/"/g, "\"\"")}"`;
+	return `\`${name.replace(/`/g, "``")}\``;
+}
+/**
+* Escape a string literal for SQL (single-quote doubling).
+* Prefer parameterized queries when the driver supports them for DDL.
+* @param {string} value
+* @returns {string}
+*/
+function quoteLiteral(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+* System / template databases to skip when granting "all".
+* @param {{ engine: Engine; name: string }} params
+* @returns {boolean}
+*/
+function isSystemDatabase(params) {
+	const { engine, name } = params;
+	const lower = name.toLowerCase();
+	if (engine === "postgres") return lower === "template0" || lower === "template1" || lower === "rdsadmin" || lower === "cloudsqladmin";
+	return lower === "information_schema" || lower === "performance_schema" || lower === "mysql" || lower === "sys" || lower === "innodb" || lower === "#mysql50#lost+found";
+}
+//#endregion
+exports.buildReadonlyUrl = buildReadonlyUrl;
+exports.detectEngineFromUrl = detectEngineFromUrl;
+exports.generatePassword = generatePassword;
+exports.isSystemDatabase = isSystemDatabase;
+exports.parseConnectionUrl = parseConnectionUrl;
+exports.quoteIdent = quoteIdent;
+exports.quoteLiteral = quoteLiteral;
+exports.resolveAdminUrl = resolveAdminUrl;
+exports.resolveSsl = resolveSsl;

package/cjs/commands/db/index.cjs

@@ -1,44 +1,46 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _DTQ2LB3Icjs = require('../../__chunks/DTQ2LB3I.cjs');
-require('../../__chunks/W6K7BV74.cjs');
-
-
-var _LXDF5QVZcjs = require('../../__chunks/LXDF5QVZ.cjs');
-require('../../__chunks/3A5ZYU5M.cjs');
-require('../../__chunks/K4QNHRTP.cjs');
-
-
-
-
-
-var _H74JSDBUcjs = require('../../__chunks/H74JSDBU.cjs');
-
-
-
-
-
-
-
-
-
-
-var _NWZGFHKHcjs = require('../../__chunks/NWZGFHKH.cjs');
-require('../../__chunks/CMUD7LLN.cjs');
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-exports.DEFAULT_MYSQL_HOST_PATTERN = _H74JSDBUcjs.DEFAULT_MYSQL_HOST_PATTERN; exports.DEFAULT_READONLY_USERNAME = _H74JSDBUcjs.DEFAULT_READONLY_USERNAME; exports.ENGINES = _H74JSDBUcjs.ENGINES; exports.buildReadonlyUrl = _NWZGFHKHcjs.buildReadonlyUrl; exports.createReadonlyUserCommand = _LXDF5QVZcjs.createReadonlyUserCommand; exports.createReadonlyUserOptionsSchema = _H74JSDBUcjs.createReadonlyUserOptionsSchema; exports.detectEngineFromUrl = _NWZGFHKHcjs.detectEngineFromUrl; exports.generatePassword = _NWZGFHKHcjs.generatePassword; exports.isSystemDatabase = _NWZGFHKHcjs.isSystemDatabase; exports.parseConnectionUrl = _NWZGFHKHcjs.parseConnectionUrl; exports.quoteIdent = _NWZGFHKHcjs.quoteIdent; exports.quoteLiteral = _NWZGFHKHcjs.quoteLiteral; exports.registerDbCommands = _DTQ2LB3Icjs.registerDbCommands; exports.resolveAdminUrl = _NWZGFHKHcjs.resolveAdminUrl; exports.resolveSsl = _NWZGFHKHcjs.resolveSsl;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_commands_db_create_readonly_user_utils = require("./create-readonly-user/utils.cjs");
+const require_commands_db_create_readonly_user_schema = require("./create-readonly-user/schema.cjs");
+const require_commands_db_create_readonly_user_handler = require("./create-readonly-user/handler.cjs");
+require("./create-readonly-user/index.cjs");
+//#region src/commands/db/index.js
+/**
+* Register the `db` command group and its subcommands on the root program.
+* @param {import('commander').Command} program
+*/
+function registerDbCommands(program) {
+	program.command("db").summary("Database operational commands").description("Database operational helpers (MySQL and Postgres)").command("create-readonly-user").summary("Create a read-only database user").description("Create (or update) a read-only database user on MySQL or Postgres. Interactively pick a single database or all databases, then print a connection URL.").option("-e, --engine <engine>", "Database engine: postgres or mysql (inferred from --url when omitted)").option("-u, --url <url>", "Admin connection URL (defaults to DATABASE_URL / MYSQL_URL / POSTGRES_URL)").option("-d, --database <name>", "Target database name, or \"all\" for every non-system database").option("--username <name>", "Read-only username to create (default: readonly)").option("--password <password>", "Password for the new user (generated when omitted)").option("--host-pattern <pattern>", "MySQL user host pattern (default: %)").option("--ssl", "Force SSL on (loose verify — useful for RDS)").option("--no-ssl", "Force SSL off").option("-y, --yes", "Skip the confirmation prompt").option("--dry-run", "Print the SQL plan without applying it").option("-v, --verbose", "Enable verbose logging").action(async (options) => {
+		/** @type {boolean | undefined} */
+		let ssl;
+		if (options.ssl === true) ssl = true;
+		else if (options.noSsl === true) ssl = false;
+		await require_commands_db_create_readonly_user_handler.createReadonlyUserCommand({
+			engine: options.engine,
+			url: options.url,
+			database: options.database,
+			username: options.username,
+			password: options.password,
+			hostPattern: options.hostPattern,
+			ssl,
+			yes: options.yes ?? false,
+			dryRun: options.dryRun ?? false,
+			verbose: options.verbose ?? false
+		});
+	});
+}
+//#endregion
+exports.DEFAULT_MYSQL_HOST_PATTERN = require_commands_db_create_readonly_user_schema.DEFAULT_MYSQL_HOST_PATTERN;
+exports.DEFAULT_READONLY_USERNAME = require_commands_db_create_readonly_user_schema.DEFAULT_READONLY_USERNAME;
+exports.ENGINES = require_commands_db_create_readonly_user_schema.ENGINES;
+exports.buildReadonlyUrl = require_commands_db_create_readonly_user_utils.buildReadonlyUrl;
+exports.createReadonlyUserCommand = require_commands_db_create_readonly_user_handler.createReadonlyUserCommand;
+exports.createReadonlyUserOptionsSchema = require_commands_db_create_readonly_user_schema.createReadonlyUserOptionsSchema;
+exports.detectEngineFromUrl = require_commands_db_create_readonly_user_utils.detectEngineFromUrl;
+exports.generatePassword = require_commands_db_create_readonly_user_utils.generatePassword;
+exports.isSystemDatabase = require_commands_db_create_readonly_user_utils.isSystemDatabase;
+exports.parseConnectionUrl = require_commands_db_create_readonly_user_utils.parseConnectionUrl;
+exports.quoteIdent = require_commands_db_create_readonly_user_utils.quoteIdent;
+exports.quoteLiteral = require_commands_db_create_readonly_user_utils.quoteLiteral;
+exports.registerDbCommands = registerDbCommands;
+exports.resolveAdminUrl = require_commands_db_create_readonly_user_utils.resolveAdminUrl;
+exports.resolveSsl = require_commands_db_create_readonly_user_utils.resolveSsl;

package/cjs/commands/doppler/handler.cjs

@@ -1,11 +1,95 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true});
-
-var _GU3R54MKcjs = require('../../__chunks/GU3R54MK.cjs');
-require('../../__chunks/NFXQNOQH.cjs');
-require('../../__chunks/JB7T7PKQ.cjs');
-require('../../__chunks/CMUD7LLN.cjs');
-require('../../__chunks/NIMXXHJQ.cjs');
-require('../../__chunks/FRHST54J.cjs');
-
-
-exports.dopplerCommand = _GU3R54MKcjs.dopplerCommand;
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_rolldown_runtime = require("../../__chunks/VH7oDXx4.cjs");
+const require_commands_doppler_schema = require("./schema.cjs");
+const require_commands_doppler_utils = require("./utils.cjs");
+const require_commands_doppler_set_secret = require("./set-secret.cjs");
+let chalk = require("chalk");
+chalk = require_rolldown_runtime.__toESM(chalk, 1);
+let zod = require("zod");
+//#region src/commands/doppler/handler.js
+/**
+* Main doppler command handler
+* @param {unknown} options - Command options (will be validated)
+*/
+async function dopplerCommand(options) {
+	try {
+		const rawOptions = options ?? {};
+		if (rawOptions.help || !rawOptions.action) {
+			console.log(chalk.default.bold(`\nUsage: @mtndev/cli doppler [options] <action>`));
+			console.log(require_commands_doppler_schema.dopplerCommandMetadata.description);
+			console.log(chalk.default.bold("\nOptions:"));
+			Object.entries(require_commands_doppler_schema.dopplerCommandMetadata.options).forEach(([key, optionMeta]) => {
+				const meta = optionMeta;
+				const alias = meta?.alias ? chalk.default.cyan(`, -${meta.alias}`) : "";
+				const defaultValue = meta?.default ?? false;
+				console.log(chalk.default.cyan(`  --${key}`) + alias + `  ${meta.description} (default: ${defaultValue})`);
+			});
+			console.log("");
+			return;
+		}
+		const validatedOptions = require_commands_doppler_schema.dopplerCommandOptionsSchema.parse(options);
+		const { action, verbose } = validatedOptions;
+		if (action === "set") require_commands_doppler_utils.checkDopplerAuth(verbose);
+		else require_commands_doppler_utils.checkDependencies(verbose);
+		if (action === "download") {
+			const { environments } = validatedOptions;
+			await require_commands_doppler_utils.downloadConfigs({
+				environments,
+				verbose
+			});
+		} else if (action === "upload") {
+			const { environments } = validatedOptions;
+			await require_commands_doppler_utils.uploadConfigs({
+				environments,
+				verbose
+			});
+		} else if (action === "clone") {
+			const { from, to, force, environments } = validatedOptions;
+			await require_commands_doppler_utils.cloneProject({
+				from,
+				to,
+				environments,
+				force,
+				verbose
+			});
+		} else if (action === "set") {
+			const { project, environment, config, name, value, yes } = validatedOptions;
+			await require_commands_doppler_set_secret.setSecretInteractive({
+				project,
+				environment,
+				config,
+				name,
+				value,
+				yes,
+				verbose
+			});
+		}
+		console.log(chalk.default.green(`\n✅ Doppler ${action} completed successfully!`));
+	} catch (error) {
+		if (error instanceof zod.ZodError) {
+			console.error(chalk.default.red(`\n❌ Invalid command options:`));
+			error.errors.forEach((err) => {
+				console.error(chalk.default.red(`   ${err.path.join(".")}: ${err.message}`));
+			});
+			process.exit(1);
+		}
+		const action = options?.action || "operation";
+		const verbose = options?.verbose || false;
+		console.error(chalk.default.red(`\n❌ Doppler ${action} failed:`));
+		if (error instanceof Error) {
+			console.error(chalk.default.red(`   ${error.message}`));
+			if (verbose && error.stack) {
+				console.error(chalk.default.gray("\nStack trace:"));
+				console.error(chalk.default.gray(error.stack));
+			}
+		} else console.error(chalk.default.red(`   ${String(error)}`));
+		console.error(chalk.default.yellow("\n💡 Troubleshooting tips:"));
+		console.error(chalk.default.yellow("   • Ensure Doppler CLI is installed (brew install dopplerhq/cli/doppler)"));
+		console.error(chalk.default.yellow("   • Make sure you're logged in (doppler login)"));
+		console.error(chalk.default.yellow("   • Verify project is configured (doppler setup)"));
+		console.error(chalk.default.yellow("   • Use --verbose for detailed error information\n"));
+		process.exit(1);
+	}
+}
+//#endregion
+exports.dopplerCommand = dopplerCommand;