@gscdump/cli 0.37.3 → 0.37.5

package/dist/_chunks/native-duckdb.mjs

@@ -0,0 +1,46 @@
+import { rm } from "node:fs/promises";
+import { dateColumnsFor } from "@gscdump/engine/schema";
+import { sqlEscape } from "@gscdump/engine/sql";
+import { dateReplaceClause } from "@gscdump/engine/sql-fragments";
+function parquetFileListSql(filePaths) {
+	return filePaths.map((filePath) => `'${sqlEscape(filePath)}'`).join(", ");
+}
+async function loadDuckDB() {
+	return import("@duckdb/node-api");
+}
+async function readParquetRows(filePaths, table) {
+	const { DuckDBInstance } = await loadDuckDB();
+	const instance = await DuckDBInstance.create(":memory:");
+	const conn = await instance.connect();
+	try {
+		const replace = dateReplaceClause(dateColumnsFor(table), "string");
+		return (await conn.runAndReadAll(`SELECT * ${replace} FROM read_parquet([${parquetFileListSql(filePaths)}], union_by_name=true)`)).getRowObjects();
+	} finally {
+		conn.closeSync();
+		instance.closeSync();
+	}
+}
+async function materializeParquetTables(outPath, tables, force = false) {
+	if (force) await rm(outPath, { force: true });
+	const { DuckDBInstance } = await loadDuckDB();
+	const instance = await DuckDBInstance.create(outPath);
+	const conn = await instance.connect();
+	const results = [];
+	try {
+		for (const input of tables) {
+			const replace = dateReplaceClause(dateColumnsFor(input.table), "date");
+			await conn.run(`CREATE OR REPLACE TABLE ${input.table} AS SELECT * ${replace} FROM read_parquet([${parquetFileListSql(input.filePaths)}], union_by_name=true)`);
+			const rows = (await conn.runAndReadAll(`SELECT count(*)::BIGINT AS n FROM ${input.table}`)).getRowObjects();
+			results.push({
+				table: input.table,
+				files: input.filePaths.length,
+				rows: Number(rows[0]?.n ?? 0)
+			});
+		}
+	} finally {
+		conn.closeSync();
+		instance.closeSync();
+	}
+	return results;
+}
+export { materializeParquetTables, readParquetRows };

package/dist/_chunks/profile.mjs

@@ -0,0 +1,290 @@
+import { __exportAll, getConfigDir, setConfigDir, useCliRuntime } from "./config.mjs";
+import { resolveCliEnvironment } from "./environment.mjs";
+import { OUTPUT_ARGS, applyOutputMode, displayPath, logger, noSubcommandSelected } from "./utils.mjs";
+import process from "node:process";
+import { defineCommand } from "citty";
+import fs from "node:fs";
+import fs$1 from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { confirm, isCancel } from "@clack/prompts";
+var profile_exports = /* @__PURE__ */ __exportAll({
+	adoptCurrentConfigAsProfile: () => adoptCurrentConfigAsProfile,
+	applyProfileFromCli: () => applyProfileFromCli,
+	createProfile: () => createProfile,
+	getProfileDir: () => getProfileDir,
+	listProfiles: () => listProfiles,
+	profileCommand: () => profileCommand,
+	profileNameFromEmail: () => profileNameFromEmail,
+	resolveActiveProfile: () => resolveActiveProfile,
+	setActiveProfile: () => setActiveProfile
+});
+const ROOT_DIR = path.join(os.homedir(), ".config", "gscdump");
+const PROFILES_DIR = path.join(ROOT_DIR, "profiles");
+const ACTIVE_MARKER = path.join(ROOT_DIR, "active-profile");
+function getProfileDir(name) {
+	return path.join(PROFILES_DIR, name);
+}
+function readActiveMarkerSync() {
+	if (!fs.existsSync(ACTIVE_MARKER)) return null;
+	return fs.readFileSync(ACTIVE_MARKER, "utf-8").trim() || null;
+}
+function resolveActiveProfile() {
+	return useCliRuntime().activeProfileOverride ?? resolveCliEnvironment().profile ?? readActiveMarkerSync();
+}
+function applyProfileFromCli(opts) {
+	if (opts.configDir) {
+		setConfigDir(opts.configDir);
+		useCliRuntime().configDirOverridden = true;
+		return;
+	}
+	if (opts.profile) {
+		useCliRuntime().activeProfileOverride = opts.profile;
+		setConfigDir(getProfileDir(opts.profile));
+		return;
+	}
+	const envProfile = opts.envProfile ?? resolveCliEnvironment().profile;
+	if (envProfile) {
+		setConfigDir(getProfileDir(envProfile));
+		return;
+	}
+	const marker = readActiveMarkerSync();
+	if (marker) setConfigDir(getProfileDir(marker));
+}
+async function setActiveProfile(name) {
+	await fs$1.mkdir(ROOT_DIR, {
+		recursive: true,
+		mode: 448
+	});
+	if (name == null) {
+		await fs$1.rm(ACTIVE_MARKER, { force: true });
+		return;
+	}
+	await fs$1.writeFile(ACTIVE_MARKER, name, { mode: 384 });
+}
+async function listProfiles() {
+	return fs$1.readdir(PROFILES_DIR).then((entries) => entries.filter((e) => !e.startsWith(".")).sort()).catch(() => []);
+}
+async function createProfile(name) {
+	const dir = getProfileDir(name);
+	await fs$1.mkdir(dir, {
+		recursive: true,
+		mode: 448
+	});
+	return dir;
+}
+function profileNameFromEmail(email) {
+	return email.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+async function adoptCurrentConfigAsProfile(name) {
+	const runtime = useCliRuntime();
+	if (runtime.configDirOverridden) return null;
+	if (resolveActiveProfile()) return null;
+	const currentDir = getConfigDir();
+	const targetDir = getProfileDir(name);
+	if (currentDir === targetDir) return targetDir;
+	await fs$1.mkdir(targetDir, {
+		recursive: true,
+		mode: 448
+	});
+	for (const f of ["tokens.json", "config.json"]) {
+		const src = path.join(currentDir, f);
+		const dst = path.join(targetDir, f);
+		if (await fs$1.stat(src).then(() => true).catch(() => false)) await fs$1.rename(src, dst);
+	}
+	await setActiveProfile(name);
+	runtime.activeProfileOverride = name;
+	setConfigDir(targetDir);
+	return targetDir;
+}
+const listCmd = defineCommand({
+	meta: {
+		name: "list",
+		description: "List configured profiles"
+	},
+	args: { ...OUTPUT_ARGS },
+	async run({ args }) {
+		const { json } = applyOutputMode(args);
+		const names = await listProfiles();
+		const active = resolveActiveProfile();
+		if (json) {
+			console.log(JSON.stringify({
+				active,
+				profiles: names
+			}, null, 2));
+			return;
+		}
+		if (names.length === 0) {
+			logger.warn(`No profiles in ${PROFILES_DIR}`);
+			logger.info("Run `gscdump auth login` to create one automatically, or `gscdump profile create <name>`");
+			return;
+		}
+		for (const n of names) console.log(`${n === active ? "*" : " "} ${n}`);
+	}
+});
+const profileCommand = defineCommand({
+	meta: {
+		name: "profile",
+		description: "Manage gscdump profiles (per-account token + config dirs)"
+	},
+	subCommands: {
+		list: listCmd,
+		path: defineCommand({
+			meta: {
+				name: "path",
+				description: "Print the config directory for a profile"
+			},
+			args: { name: {
+				type: "positional",
+				required: false,
+				description: "Profile name (default: active)"
+			} },
+			async run({ args }) {
+				const name = args.name ? String(args.name) : resolveActiveProfile();
+				if (!name) {
+					logger.error("No profile specified and none active (set --profile, GSCDUMP_PROFILE, or run `gscdump profile use <name>`)");
+					process.exit(1);
+				}
+				console.log(getProfileDir(name));
+			}
+		}),
+		current: defineCommand({
+			meta: {
+				name: "current",
+				description: "Print the active profile name"
+			},
+			async run() {
+				const active = resolveActiveProfile();
+				if (!active) process.exit(1);
+				console.log(active);
+			}
+		}),
+		use: defineCommand({
+			meta: {
+				name: "use",
+				description: "Set the persisted active profile (subsequent commands no longer need --profile)"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				name: {
+					type: "positional",
+					required: true,
+					description: "Profile name"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const name = String(args.name);
+				const dir = getProfileDir(name);
+				if (!await fs$1.stat(dir).then(() => true).catch(() => false)) {
+					logger.error(`Profile not found: ${name}`);
+					logger.info(`Create it with: gscdump profile create ${name}`);
+					process.exit(1);
+				}
+				await setActiveProfile(name);
+				logger.success(`Active profile: ${name}`);
+			}
+		}),
+		create: defineCommand({
+			meta: {
+				name: "create",
+				description: "Create an empty profile directory"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				"name": {
+					type: "positional",
+					required: true,
+					description: "Profile name"
+				},
+				"no-use": {
+					type: "boolean",
+					default: false,
+					description: "Do not mark the new profile as active"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const name = String(args.name);
+				const dir = await createProfile(name);
+				if (!args["no-use"]) await setActiveProfile(name);
+				logger.success(`Created profile: ${name}${args["no-use"] ? "" : " (active)"}`);
+				logger.info(displayPath(dir));
+			}
+		}),
+		clear: defineCommand({
+			meta: {
+				name: "clear",
+				description: "Clear the persisted active profile (commands fall back to root config dir)"
+			},
+			args: { ...OUTPUT_ARGS },
+			async run({ args }) {
+				applyOutputMode(args);
+				await setActiveProfile(null);
+				logger.success("Cleared active profile");
+			}
+		}),
+		delete: defineCommand({
+			meta: {
+				name: "delete",
+				description: "Remove a profile directory (tokens + config)"
+			},
+			args: {
+				...OUTPUT_ARGS,
+				name: {
+					type: "positional",
+					required: true,
+					description: "Profile name"
+				},
+				yes: {
+					type: "boolean",
+					alias: "y",
+					default: false,
+					description: "Skip confirmation"
+				}
+			},
+			async run({ args }) {
+				applyOutputMode(args);
+				const name = String(args.name);
+				const dir = getProfileDir(name);
+				if (!await fs$1.stat(dir).then(() => true).catch(() => false)) {
+					logger.error(`Profile not found: ${name}`);
+					process.exit(1);
+				}
+				if (!args.yes) {
+					const ok = await confirm({
+						message: `Delete profile "${name}" at ${dir}? Tokens and config will be lost.`,
+						initialValue: false
+					});
+					if (isCancel(ok) || !ok) {
+						logger.info("Cancelled");
+						process.exit(0);
+					}
+				}
+				await fs$1.rm(dir, {
+					recursive: true,
+					force: true
+				});
+				if (readActiveMarkerSync() === name) await setActiveProfile(null);
+				logger.success(`Removed profile: ${name}`);
+			}
+		})
+	},
+	async run({ args }) {
+		if (!noSubcommandSelected("profile", [
+			"list",
+			"path",
+			"current",
+			"use",
+			"create",
+			"clear",
+			"delete"
+		])) return;
+		await listCmd.run?.({
+			args,
+			cmd: listCmd,
+			rawArgs: []
+		});
+	}
+});
+export { adoptCurrentConfigAsProfile, applyProfileFromCli, profileNameFromEmail, profile_exports, resolveActiveProfile };