@prisma/cli 3.0.0-dev.99.1 → 8.0.0-rc.2

package/dist/adapters/token-storage.js

@@ -1,418 +0,0 @@
-import { getAuthFilePath } from "../lib/auth/client.js";
-import fs from "node:fs/promises";
-import path from "node:path";
-import { randomUUID } from "node:crypto";
-import { CredentialsStore } from "@prisma/credentials-store";
-//#region src/adapters/token-storage.ts
-const REFRESH_LOCK_RETRY_MS = 100;
-const REFRESH_LOCK_STALE_MS = 3e4;
-const REFRESH_LOCK_WAIT_TIMEOUT_MS = 25e3;
-const EMPTY_AUTH_CONTEXT = {
-	activeWorkspaceId: null,
-	workspaces: {}
-};
-const UNKNOWN_WORKSPACE_NAME = "Unknown workspace";
-function getAuthContextFilePath(authFilePath) {
-	const extension = path.extname(authFilePath);
-	if (!extension) return `${authFilePath}.context.json`;
-	return `${authFilePath.slice(0, -extension.length)}.context${extension}`;
-}
-function findLatestValidTokens(allCredentials) {
-	for (let i = allCredentials.length - 1; i >= 0; i -= 1) {
-		const credential = allCredentials[i];
-		if (!credential) continue;
-		if (typeof credential.workspaceId !== "string" || credential.workspaceId.length === 0 || typeof credential.token !== "string" || credential.token.length === 0 || typeof credential.refreshToken !== "string" || credential.refreshToken.length === 0) continue;
-		return {
-			workspaceId: credential.workspaceId,
-			accessToken: credential.token,
-			refreshToken: credential.refreshToken
-		};
-	}
-	return null;
-}
-function storedCredentialToTokens(credential) {
-	if (!credential) return null;
-	if (typeof credential.workspaceId !== "string" || credential.workspaceId.length === 0 || typeof credential.token !== "string" || credential.token.length === 0 || typeof credential.refreshToken !== "string" || credential.refreshToken.length === 0) return null;
-	return {
-		workspaceId: credential.workspaceId,
-		accessToken: credential.token,
-		refreshToken: credential.refreshToken
-	};
-}
-function findTokensForWorkspace(allCredentials, workspaceId) {
-	return storedCredentialToTokens(allCredentials.find((credential) => credential?.workspaceId === workspaceId)) ?? null;
-}
-function tokensEqual(a, b) {
-	return a?.workspaceId === b?.workspaceId && a?.accessToken === b?.accessToken && a?.refreshToken === b?.refreshToken;
-}
-function sleep(ms, signal) {
-	signal?.throwIfAborted();
-	return new Promise((resolve, reject) => {
-		const onAbort = () => {
-			clearTimeout(timeout);
-			reject(signal?.reason);
-		};
-		const timeout = setTimeout(() => {
-			signal?.removeEventListener("abort", onAbort);
-			resolve();
-		}, ms);
-		signal?.addEventListener("abort", onAbort, { once: true });
-	});
-}
-var FileTokenStorage = class {
-	credentialsStore;
-	authFilePath;
-	contextFilePath;
-	lockFilePath;
-	constructor(env = process.env, signal, options = {}) {
-		this.signal = signal;
-		this.options = options;
-		const authFilePath = getAuthFilePath(env);
-		this.authFilePath = authFilePath;
-		this.contextFilePath = getAuthContextFilePath(authFilePath);
-		this.credentialsStore = new CredentialsStore(authFilePath);
-		this.lockFilePath = `${authFilePath}.lock`;
-	}
-	async getTokens() {
-		this.signal?.throwIfAborted();
-		try {
-			const credentials = await this.readCredentialsFromDisk();
-			const context = await this.readAuthContext();
-			if (context.state.activeWorkspaceId) return findTokensForWorkspace(credentials, context.state.activeWorkspaceId);
-			const latest = findLatestValidTokens(credentials);
-			if (!latest) return null;
-			if (!context.exists) {
-				await this.setActiveWorkspaceId(latest.workspaceId);
-				return latest;
-			}
-			return null;
-		} catch (_error) {
-			if (this.signal?.aborted) throw this.signal.reason;
-			return null;
-		}
-	}
-	async setTokens(tokens) {
-		if (this.options.lockSetTokens === false) {
-			await this.setTokensUnlocked(tokens);
-			return;
-		}
-		await this.withRefreshLock(() => this.setTokensUnlocked(tokens));
-	}
-	async setTokensUnlocked(tokens) {
-		this.signal?.throwIfAborted();
-		await this.credentialsStore.storeCredentials({
-			workspaceId: tokens.workspaceId,
-			token: tokens.accessToken,
-			refreshToken: tokens.refreshToken
-		});
-		this.signal?.throwIfAborted();
-		await this.rememberWorkspaceUnlocked(tokens.workspaceId, {
-			id: tokens.workspaceId,
-			name: tokens.workspaceId
-		});
-		await this.maybeActivateWorkspaceId(tokens.workspaceId);
-	}
-	async clearTokens() {
-		await this.withRefreshLock(() => this.clearTokensUnlocked());
-	}
-	async clearTokensUnlocked() {
-		this.signal?.throwIfAborted();
-		await fs.mkdir(path.dirname(this.authFilePath), { recursive: true });
-		this.signal?.throwIfAborted();
-		await fs.writeFile(this.authFilePath, `${JSON.stringify({ tokens: [] }, null, 2)}\n`, {
-			encoding: "utf8",
-			signal: this.signal
-		});
-		await this.clearAuthContext();
-		await this.credentialsStore.reloadCredentialsFromDisk();
-		this.signal?.throwIfAborted();
-	}
-	async clearTokensIfCurrent(tokens) {
-		this.signal?.throwIfAborted();
-		if (!tokensEqual(await this.getTokens(), tokens)) return;
-		await this.credentialsStore.deleteCredentials(tokens.workspaceId);
-		await this.removeRememberedWorkspace(tokens.workspaceId, { preserveActivePointer: true });
-		this.signal?.throwIfAborted();
-	}
-	async listWorkspaces() {
-		this.signal?.throwIfAborted();
-		const credentials = await this.readCredentialsFromDisk();
-		const context = await this.ensureMigratedAuthContext(credentials);
-		return credentials.map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null).map((tokens) => {
-			const cached = context.state.workspaces[tokens.workspaceId];
-			const id = typeof cached?.id === "string" && cached.id.trim().length > 0 ? cached.id.trim() : tokens.workspaceId;
-			const name = typeof cached?.name === "string" && cached.name.trim().length > 0 ? workspaceDisplayName(cached.name.trim(), tokens.workspaceId) : UNKNOWN_WORKSPACE_NAME;
-			const lastSeenAt = typeof cached?.lastSeenAt === "string" && cached.lastSeenAt.trim().length > 0 ? cached.lastSeenAt.trim() : null;
-			return {
-				id,
-				name,
-				credentialWorkspaceId: tokens.workspaceId,
-				active: context.state.activeWorkspaceId === tokens.workspaceId,
-				lastSeenAt
-			};
-		});
-	}
-	async listWorkspaceTokens() {
-		this.signal?.throwIfAborted();
-		return (await this.readCredentialsFromDisk()).map((credential) => storedCredentialToTokens(credential)).filter((tokens) => tokens !== null);
-	}
-	async useWorkspace(workspaceRef) {
-		return this.withRefreshLock(() => this.useWorkspaceUnlocked(workspaceRef));
-	}
-	async useWorkspaceUnlocked(workspaceRef) {
-		const ref = workspaceRef.trim();
-		if (!ref) throw new WorkspaceSelectionError("missing");
-		const workspaces = await this.listWorkspaces();
-		const context = await this.readAuthContext();
-		const previous = workspaces.find((workspace) => workspace.credentialWorkspaceId === context.state.activeWorkspaceId) ?? null;
-		const matches = workspaces.filter((workspace) => workspaceMatchesRef(workspace, ref));
-		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
-		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
-		const selected = matches[0];
-		await this.setActiveWorkspaceId(selected.credentialWorkspaceId);
-		return {
-			previous,
-			selected
-		};
-	}
-	async logoutWorkspace(workspaceRef) {
-		return this.withRefreshLock(() => this.logoutWorkspaceUnlocked(workspaceRef));
-	}
-	async logoutWorkspaceUnlocked(workspaceRef) {
-		const ref = workspaceRef.trim();
-		if (!ref) throw new WorkspaceSelectionError("missing");
-		const workspaces = await this.listWorkspaces();
-		const context = await this.readAuthContext();
-		const matches = workspaces.filter((workspace) => workspaceMatchesRef(workspace, ref));
-		if (matches.length === 0) throw new WorkspaceSelectionError("not-found", ref);
-		if (matches.length > 1) throw new WorkspaceSelectionError("ambiguous", ref, matches);
-		const workspace = matches[0];
-		const wasActive = context.state.activeWorkspaceId === workspace.credentialWorkspaceId;
-		await this.credentialsStore.deleteCredentials(workspace.credentialWorkspaceId);
-		this.signal?.throwIfAborted();
-		const remainingWorkspaces = workspaces.filter((candidate) => candidate.credentialWorkspaceId !== workspace.credentialWorkspaceId);
-		if (remainingWorkspaces.length === 0) {
-			await this.clearAuthContext();
-			return {
-				workspace,
-				wasActive,
-				activeWorkspace: null
-			};
-		}
-		delete context.state.workspaces[workspace.credentialWorkspaceId];
-		if (wasActive) context.state.activeWorkspaceId = null;
-		await this.writeAuthContext(context.state);
-		return {
-			workspace,
-			wasActive,
-			activeWorkspace: context.state.activeWorkspaceId === null ? null : remainingWorkspaces.find((candidate) => candidate.credentialWorkspaceId === context.state.activeWorkspaceId) ?? null
-		};
-	}
-	async rememberWorkspace(credentialWorkspaceId, workspace) {
-		await this.withRefreshLock(() => this.rememberWorkspaceUnlocked(credentialWorkspaceId, workspace));
-	}
-	async rememberWorkspaceUnlocked(credentialWorkspaceId, workspace) {
-		const context = await this.readAuthContext();
-		context.state.workspaces[credentialWorkspaceId] = {
-			id: workspace.id,
-			name: workspace.name,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-	}
-	async withRefreshLock(fn) {
-		const lockId = await this.acquireRefreshLock();
-		try {
-			return await fn();
-		} finally {
-			await this.releaseRefreshLock(lockId);
-		}
-	}
-	async acquireRefreshLock() {
-		const lockId = randomUUID();
-		const startedAt = Date.now();
-		const retryMs = this.options.lockRetryMs ?? REFRESH_LOCK_RETRY_MS;
-		const waitTimeoutMs = this.options.lockWaitTimeoutMs ?? REFRESH_LOCK_WAIT_TIMEOUT_MS;
-		this.signal?.throwIfAborted();
-		await fs.mkdir(path.dirname(this.lockFilePath), { recursive: true });
-		while (true) {
-			this.signal?.throwIfAborted();
-			if (await this.tryCreateRefreshLock(lockId)) return lockId;
-			if (await this.releaseStaleRefreshLock()) continue;
-			this.throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs);
-			await sleep(retryMs, this.signal);
-		}
-	}
-	async tryCreateRefreshLock(lockId) {
-		let lockFileCreated = false;
-		try {
-			const handle = await fs.open(this.lockFilePath, "wx");
-			lockFileCreated = true;
-			try {
-				this.signal?.throwIfAborted();
-				await handle.writeFile(lockId, { encoding: "utf8" });
-				this.signal?.throwIfAborted();
-			} finally {
-				await handle.close();
-			}
-			return true;
-		} catch (error) {
-			if (lockFileCreated) await fs.unlink(this.lockFilePath).catch(() => void 0);
-			if (error.code === "EEXIST") return false;
-			throw error;
-		}
-	}
-	async releaseStaleRefreshLock() {
-		const staleLockId = await this.getStaleRefreshLockId();
-		if (!staleLockId) return false;
-		await this.releaseRefreshLock(staleLockId);
-		return true;
-	}
-	throwIfRefreshLockWaitTimedOut(startedAt, waitTimeoutMs) {
-		if (Date.now() - startedAt < waitTimeoutMs) return;
-		throw new RefreshLockTimeoutError(this.lockFilePath, waitTimeoutMs);
-	}
-	async getStaleRefreshLockId() {
-		this.signal?.throwIfAborted();
-		const lockId = await fs.readFile(this.lockFilePath, {
-			encoding: "utf8",
-			signal: this.signal
-		}).catch((error) => {
-			if (this.signal?.aborted) throw error;
-			return null;
-		});
-		if (lockId === null) return null;
-		this.signal?.throwIfAborted();
-		const stats = await fs.stat(this.lockFilePath).catch(() => null);
-		this.signal?.throwIfAborted();
-		if (!stats) return null;
-		const staleMs = this.options.lockStaleMs ?? REFRESH_LOCK_STALE_MS;
-		return Date.now() - stats.mtimeMs > staleMs ? lockId : null;
-	}
-	async releaseRefreshLock(lockId) {
-		if (await fs.readFile(this.lockFilePath, { encoding: "utf8" }).catch(() => null) !== lockId) return;
-		await fs.unlink(this.lockFilePath).catch(() => {});
-	}
-	async readCredentialsFromDisk() {
-		this.signal?.throwIfAborted();
-		await this.credentialsStore.reloadCredentialsFromDisk();
-		this.signal?.throwIfAborted();
-		return await this.credentialsStore.getCredentials();
-	}
-	async ensureMigratedAuthContext(credentials) {
-		const context = await this.readAuthContext();
-		if (context.state.activeWorkspaceId || context.exists) return context;
-		const latest = findLatestValidTokens(credentials);
-		if (!latest) return context;
-		context.state.activeWorkspaceId = latest.workspaceId;
-		context.state.workspaces[latest.workspaceId] ??= {
-			id: latest.workspaceId,
-			name: latest.workspaceId,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-		return {
-			exists: true,
-			state: context.state
-		};
-	}
-	async setActiveWorkspaceId(workspaceId) {
-		const context = await this.readAuthContext();
-		context.state.activeWorkspaceId = workspaceId;
-		context.state.workspaces[workspaceId] ??= {
-			id: workspaceId,
-			name: workspaceId,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-	}
-	async maybeActivateWorkspaceId(workspaceId) {
-		const context = await this.readAuthContext();
-		if (this.options.activateOnSetTokens === false && context.exists && context.state.activeWorkspaceId && context.state.activeWorkspaceId !== workspaceId) return;
-		context.state.activeWorkspaceId = workspaceId;
-		context.state.workspaces[workspaceId] ??= {
-			id: workspaceId,
-			name: workspaceId,
-			lastSeenAt: (/* @__PURE__ */ new Date()).toISOString()
-		};
-		await this.writeAuthContext(context.state);
-	}
-	async removeRememberedWorkspace(workspaceId, options) {
-		const context = await this.readAuthContext();
-		delete context.state.workspaces[workspaceId];
-		if (!options.preserveActivePointer && context.state.activeWorkspaceId === workspaceId) context.state.activeWorkspaceId = null;
-		await this.writeAuthContext(context.state);
-	}
-	async readAuthContext() {
-		this.signal?.throwIfAborted();
-		const raw = await fs.readFile(this.contextFilePath, {
-			encoding: "utf8",
-			signal: this.signal
-		}).catch((error) => {
-			if (this.signal?.aborted) throw error;
-			if (error.code === "ENOENT") return null;
-			throw error;
-		});
-		if (raw === null) return {
-			exists: false,
-			state: structuredClone(EMPTY_AUTH_CONTEXT)
-		};
-		try {
-			const parsed = JSON.parse(raw);
-			return {
-				exists: true,
-				state: {
-					activeWorkspaceId: typeof parsed.activeWorkspaceId === "string" && parsed.activeWorkspaceId.trim().length > 0 ? parsed.activeWorkspaceId.trim() : null,
-					workspaces: parsed.workspaces && typeof parsed.workspaces === "object" && !Array.isArray(parsed.workspaces) ? parsed.workspaces : {}
-				}
-			};
-		} catch {
-			return {
-				exists: false,
-				state: structuredClone(EMPTY_AUTH_CONTEXT)
-			};
-		}
-	}
-	async writeAuthContext(state) {
-		this.signal?.throwIfAborted();
-		await fs.mkdir(path.dirname(this.contextFilePath), { recursive: true });
-		this.signal?.throwIfAborted();
-		await fs.writeFile(this.contextFilePath, `${JSON.stringify(state, null, 2)}\n`, {
-			encoding: "utf8",
-			signal: this.signal
-		});
-		this.signal?.throwIfAborted();
-	}
-	async clearAuthContext() {
-		await fs.unlink(this.contextFilePath).catch((error) => {
-			if (error.code === "ENOENT") return;
-			throw error;
-		});
-	}
-};
-var WorkspaceSelectionError = class extends Error {
-	constructor(reason, workspaceRef, matches = []) {
-		super(reason);
-		this.reason = reason;
-		this.workspaceRef = workspaceRef;
-		this.matches = matches;
-		this.name = "WorkspaceSelectionError";
-	}
-};
-var RefreshLockTimeoutError = class extends Error {
-	constructor(lockFilePath, waitTimeoutMs) {
-		super(`Timed out waiting ${waitTimeoutMs}ms for auth refresh lock at ${lockFilePath}`);
-		this.name = "RefreshLockTimeoutError";
-	}
-};
-function workspaceMatchesRef(workspace, ref) {
-	return workspace.credentialWorkspaceId === ref || workspace.id === ref || stripWorkspacePrefix(workspace.credentialWorkspaceId) === stripWorkspacePrefix(ref) || stripWorkspacePrefix(workspace.id) === stripWorkspacePrefix(ref) || workspace.name.toLowerCase() === ref.toLowerCase();
-}
-function stripWorkspacePrefix(value) {
-	return value.startsWith("wksp_") ? value.slice(5) : value;
-}
-function workspaceDisplayName(name, credentialWorkspaceId) {
-	return name === credentialWorkspaceId ? UNKNOWN_WORKSPACE_NAME : name;
-}
-//#endregion
-export { FileTokenStorage, WorkspaceSelectionError };

package/dist/cli2.js

@@ -1,119 +0,0 @@
-import { CliError } from "./shell/errors.js";
-import "./shell/prompt.js";
-import { attachCommandDescriptor } from "./shell/command-meta.js";
-import { addCompactGlobalFlags } from "./shell/global-flags.js";
-import { createShellUi } from "./shell/ui.js";
-import { configureRuntimeCommand, createCommandContext } from "./shell/runtime.js";
-import { formatUnexpectedError, writeHumanError, writeJsonError, writeJsonSuccess } from "./shell/output.js";
-import { createAppCommand } from "./commands/app/index.js";
-import { createAuthCommand } from "./commands/auth/index.js";
-import { createBranchCommand } from "./commands/branch/index.js";
-import { createDatabaseCommand } from "./commands/database/index.js";
-import { createGitCommand } from "./commands/git/index.js";
-import { createProjectCommand } from "./commands/project/index.js";
-import { getCliName, getCliVersion } from "./lib/version.js";
-import { runVersion } from "./controllers/version.js";
-import { createVersionCommand } from "./commands/version/index.js";
-import { maybeWriteCachedUpdateNotification } from "./shell/update-check.js";
-import process from "node:process";
-import { Command, CommanderError, Option } from "commander";
-//#region src/cli.ts
-async function runCli(options = {}) {
-	const runtime = resolveRuntime(options);
-	const program = createProgram(runtime);
-	process.exitCode = 0;
-	try {
-		await maybeWriteCachedUpdateNotification(runtime);
-		if (runtime.argv.includes("--version")) return await handleVersionFlag(runtime);
-		const bareHelpCommand = resolveBareHelpCommand(program, runtime.argv);
-		if (bareHelpCommand) {
-			runtime.stderr.write(bareHelpCommand.helpInformation());
-			return 0;
-		}
-		await program.parseAsync(runtime.argv, { from: "user" });
-		return process.exitCode ?? 0;
-	} catch (error) {
-		if (error instanceof CommanderError) return error.code === "commander.helpDisplayed" ? 0 : 2;
-		runtime.stderr.write(formatUnexpectedError(error, runtime.argv.includes("--trace")));
-		return 1;
-	} finally {
-		runtime.stdin;
-	}
-}
-function createProgram(runtime) {
-	const program = attachCommandDescriptor(configureRuntimeCommand(new Command(), runtime), "root");
-	addCompactGlobalFlags(program);
-	program.addOption(new Option("--version", "Print the CLI version and exit."));
-	program.name("prisma").showSuggestionAfterError();
-	program.addCommand(createVersionCommand(runtime));
-	program.addCommand(createAuthCommand(runtime));
-	program.addCommand(createProjectCommand(runtime));
-	program.addCommand(createGitCommand(runtime));
-	program.addCommand(createBranchCommand(runtime));
-	program.addCommand(createDatabaseCommand(runtime));
-	program.addCommand(createAppCommand(runtime));
-	return program;
-}
-async function handleVersionFlag(runtime) {
-	const wantsJson = runtime.argv.includes("--json");
-	const output = {
-		stdout: runtime.stdout,
-		stderr: runtime.stderr
-	};
-	try {
-		if (wantsJson) {
-			const success = await runVersion(await createCommandContext(runtime, buildVersionFlagFlags(runtime)));
-			writeJsonSuccess(output, {
-				command: success.command,
-				result: { version: success.result.cli.version },
-				warnings: success.warnings,
-				nextSteps: success.nextSteps
-			});
-			return 0;
-		}
-		const versionLine = `${getCliName()} ${getCliVersion()}`;
-		runtime.stdout.write(`${versionLine}\n`);
-		return 0;
-	} catch (error) {
-		if (error instanceof CliError) {
-			if (wantsJson) writeJsonError(output, "version", error);
-			else writeHumanError(output, createShellUi(runtime, buildVersionFlagFlags(runtime)), error, { trace: false });
-			return error.exitCode;
-		}
-		throw error;
-	}
-}
-function buildVersionFlagFlags(runtime) {
-	return {
-		json: runtime.argv.includes("--json"),
-		quiet: false,
-		verbose: false,
-		trace: false,
-		yes: false,
-		interactive: void 0,
-		color: void 0
-	};
-}
-function resolveBareHelpCommand(program, argv) {
-	if (argv.length === 0) return program;
-	if (argv.length !== 1) return null;
-	const candidate = program.commands.find((command) => command.name() === argv[0]) ?? null;
-	if (!candidate) return null;
-	if (candidate.commands.length === 0) return null;
-	return candidate;
-}
-function resolveRuntime(options) {
-	return {
-		argv: options.argv ?? process.argv.slice(2),
-		cwd: options.cwd ?? process.env.INIT_CWD ?? process.cwd(),
-		env: options.env ?? process.env,
-		signal: options.signal ?? new AbortController().signal,
-		stdin: options.stdin ?? process.stdin,
-		stdout: options.stdout ?? process.stdout,
-		stderr: options.stderr ?? process.stderr,
-		fixturePath: options.fixturePath,
-		stateDir: options.stateDir
-	};
-}
-//#endregion
-export { runCli };