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

package/dist/lib/auth/login.js

@@ -1,330 +0,0 @@
-import { getApiBaseUrl } from "./client.js";
-import { FileTokenStorage } from "../../adapters/token-storage.js";
-import open from "open";
-import { AuthError, createManagementApiSdk } from "@prisma/management-api-sdk";
-import events from "node:events";
-import http from "node:http";
-import readline from "node:readline/promises";
-//#region src/lib/auth/login.ts
-var AuthError$1 = class extends Error {
-	constructor(message) {
-		super(message);
-		this.name = "AuthError";
-	}
-};
-async function login(options = {}) {
-	const hostname = options.hostname ?? "localhost";
-	const port = options.port ?? 0;
-	const input = options.input ?? process.stdin;
-	const output = options.output ?? process.stderr;
-	const interactive = input.isTTY === true;
-	const server = http.createServer();
-	server.listen({
-		host: hostname,
-		port
-	});
-	const pasteAbort = new AbortController();
-	try {
-		const state = new LoginState({
-			hostname,
-			port: (await events.once(server, "listening").then(() => server.address())).port,
-			tokenStorage: options.tokenStorage,
-			clientId: options.clientId,
-			apiBaseUrl: options.apiBaseUrl,
-			authBaseUrl: options.authBaseUrl,
-			openUrl: options.openUrl,
-			env: options.env,
-			signal: options.signal,
-			output
-		});
-		let completed = false;
-		let completion;
-		const completeOnce = (url) => {
-			if (!completion) completion = state.handleCallback(url).then(() => {
-				completed = true;
-			}, (error) => {
-				completion = void 0;
-				throw error;
-			});
-			return completion;
-		};
-		const httpResult = new Promise((resolve, reject) => {
-			const onAbort = () => {
-				reject(options.signal?.reason);
-			};
-			options.signal?.addEventListener("abort", onAbort, { once: true });
-			const settle = (callback) => {
-				options.signal?.removeEventListener("abort", onAbort);
-				callback();
-			};
-			server.on("request", async (req, res) => {
-				const url = new URL(`http://${state.host}${req.url}`);
-				if (url.pathname !== "/auth/callback") {
-					res.statusCode = 404;
-					res.end("Not found");
-					return;
-				}
-				if (completed) {
-					const workspaceName = await state.resolveWorkspaceName();
-					res.setHeader("Content-Type", "text/html; charset=utf-8");
-					res.end(renderSuccessPage(workspaceName));
-					return;
-				}
-				try {
-					await completeOnce(url);
-					const workspaceName = await state.resolveWorkspaceName();
-					res.setHeader("Content-Type", "text/html; charset=utf-8");
-					res.end(renderSuccessPage(workspaceName));
-					settle(resolve);
-				} catch (error) {
-					res.statusCode = 400;
-					const message = error instanceof Error ? error.message : String(error);
-					res.end(message);
-					settle(() => reject(error));
-					return;
-				}
-			});
-		});
-		options.signal?.throwIfAborted();
-		const callbackResult = interactive ? Promise.race([httpResult, consumePastedCallback({
-			input,
-			output,
-			signal: pasteAbort.signal,
-			complete: completeOnce
-		})]) : httpResult;
-		await Promise.all([state.openLoginPage(interactive), callbackResult]);
-	} finally {
-		pasteAbort.abort();
-		if (server.listening) await new Promise((resolve) => server.close(() => resolve()));
-	}
-}
-async function consumePastedCallback(options) {
-	if (!options.input.isTTY) return;
-	const rl = readline.createInterface({
-		input: options.input,
-		output: options.output
-	});
-	try {
-		for (;;) {
-			const url = await readPastedCallbackUrl(rl, options);
-			if (url === null) return;
-			if (url === void 0) continue;
-			if (await tryCompletePastedCallback(url, options)) return;
-		}
-	} finally {
-		rl.close();
-	}
-}
-async function readPastedCallbackUrl(rl, options) {
-	let answer;
-	try {
-		answer = await rl.question("Paste the callback URL here: ", { signal: options.signal });
-	} catch (error) {
-		if (error?.name === "AbortError") return null;
-		throw error;
-	}
-	const trimmed = answer.trim().replace(/^["']|["']$/g, "");
-	try {
-		if (!trimmed) throw new Error("empty input");
-		return new URL(trimmed);
-	} catch {
-		options.output.write("That didn't look like a URL. Paste the full localhost callback URL and try again.\n");
-		return;
-	}
-}
-async function tryCompletePastedCallback(url, options) {
-	try {
-		await options.complete(url);
-		return true;
-	} catch (error) {
-		const message = error instanceof Error ? error.message : String(error);
-		options.output.write(`Sign-in didn't complete (${message}). Paste the callback URL to try again.\n`);
-		return false;
-	}
-}
-var LoginState = class {
-	latestVerifier;
-	latestState;
-	sdk;
-	openUrl;
-	tokenStorage;
-	output;
-	constructor(options) {
-		this.options = options;
-		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env, options.signal, { activateOnSetTokens: true });
-		this.sdk = createManagementApiSdk({
-			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
-			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
-			tokenStorage: this.tokenStorage,
-			apiBaseUrl: options.apiBaseUrl ?? getApiBaseUrl(options.env),
-			authBaseUrl: options.authBaseUrl
-		});
-		this.openUrl = options.openUrl ?? open;
-		this.output = options.output;
-	}
-	async openLoginPage(interactive) {
-		this.options.signal?.throwIfAborted();
-		const { url, state, verifier } = await this.sdk.getLoginUrl({
-			scope: "workspace:admin offline_access",
-			additionalParams: {
-				utm_source: "prisma-cli",
-				utm_medium: "command-login",
-				utm_campaign: "prisma-cli"
-			}
-		});
-		this.latestState = state;
-		this.latestVerifier = verifier;
-		this.options.signal?.throwIfAborted();
-		if (interactive) this.printLoginInstructions(url);
-		try {
-			await this.openUrl(url);
-		} catch (error) {
-			if (!interactive) throw error;
-		}
-		this.options.signal?.throwIfAborted();
-	}
-	printLoginInstructions(url) {
-		const output = this.output;
-		if (!output) return;
-		output.write(`\nOpen this URL to sign in: ${url}\n\nIf the browser opens on another machine, finish sign-in there. When it\nredirects to localhost, copy the full localhost URL from the address bar\nand paste it here.\n\n`);
-	}
-	async handleCallback(url) {
-		if (url.pathname !== "/auth/callback") throw new AuthError$1("Not a callback URL");
-		const params = url.searchParams;
-		const error = params.get("error");
-		if (error) {
-			const desc = params.get("error_description");
-			throw new AuthError$1(desc ? `${error}: ${desc}` : error);
-		}
-		if (!this.latestVerifier) throw new AuthError$1("No verifier found");
-		if (!this.latestState) throw new AuthError$1("No state found");
-		try {
-			await this.sdk.handleCallback({
-				callbackUrl: url,
-				verifier: this.latestVerifier,
-				expectedState: this.latestState
-			});
-		} catch (error) {
-			if (error instanceof AuthError) throw new AuthError$1(error.message);
-			throw new AuthError$1(error instanceof Error ? error.message : "Unknown error during login");
-		}
-	}
-	async resolveWorkspaceName() {
-		try {
-			const tokens = await this.tokenStorage.getTokens();
-			if (!tokens?.workspaceId) return null;
-			const { data } = await this.sdk.client.GET("/v1/workspaces/{id}", {
-				params: { path: { id: tokens.workspaceId } },
-				signal: this.options.signal
-			});
-			const name = data?.data?.name;
-			return typeof name === "string" && name.trim().length > 0 ? name.trim() : null;
-		} catch {
-			this.options.signal?.throwIfAborted();
-			return null;
-		}
-	}
-	get host() {
-		return `${this.options.hostname}:${this.options.port}`;
-	}
-};
-function renderSuccessPage(workspaceName) {
-	return `<!doctype html>
-<html lang="en">
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Prisma Developer Platform</title>
-  <style>
-    :root {
-      color-scheme: light dark;
-      --background: #ffffff;
-      --foreground: #1f2430;
-      --muted: #4f5665;
-      --mark-color: #050812;
-    }
-
-    @media (prefers-color-scheme: dark) {
-      :root {
-        --background: #050812;
-        --foreground: #f6f7fb;
-        --muted: #c5cad6;
-        --mark-color: #ffffff;
-      }
-    }
-
-    * {
-      box-sizing: border-box;
-    }
-
-    body {
-      min-height: 100vh;
-      margin: 0;
-      background: var(--background);
-      color: var(--foreground);
-      font-family: system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
-      display: grid;
-      grid-template-rows: 128px 1fr;
-    }
-
-    .mark {
-      align-self: end;
-      justify-self: center;
-      width: 36px;
-      height: 36px;
-      color: var(--mark-color);
-    }
-
-    .mark path {
-      fill: currentColor !important;
-    }
-
-    main {
-      align-self: center;
-      justify-self: center;
-      width: min(520px, calc(100vw - 48px));
-      margin-top: -128px;
-      text-align: center;
-    }
-
-    h1 {
-      margin: 0 0 12px;
-      font-size: 26px;
-      line-height: 1.2;
-      font-weight: 700;
-      letter-spacing: 0;
-    }
-
-    p {
-      margin: 0 auto;
-      max-width: 480px;
-      color: var(--muted);
-      font-size: 15px;
-      line-height: 1.55;
-      letter-spacing: 0;
-    }
-  </style>
-</head>
-<body>
-  <svg class="mark" width="36" height="36" viewBox="0 0 32 32" xmlns="http://www.w3.org/2000/svg"><path d="M25.21,24.21,12.739,27.928a.525.525,0,0,1-.667-.606L16.528,5.811a.43.43,0,0,1,.809-.094l8.249,17.661A.6.6,0,0,1,25.21,24.21Zm2.139-.878L17.8,2.883h0A1.531,1.531,0,0,0,16.491,2a1.513,1.513,0,0,0-1.4.729L4.736,19.648a1.592,1.592,0,0,0,.018,1.7l5.064,7.909a1.628,1.628,0,0,0,1.83.678l14.7-4.383a1.6,1.6,0,0,0,1-2.218Z" style="fill:#0c344b;fill-rule:evenodd"/></svg>
-  <main>
-    <h1>You're all set.</h1>
-    <p>${workspaceName ? `Your terminal is now connected to your ${escapeHtml(workspaceName)} workspace. Head back to your terminal to continue.` : "Your terminal is now connected to your Prisma workspace. Head back to your terminal to continue."}</p>
-  </main>
-</body>
-</html>`;
-}
-function escapeHtml(value) {
-	return value.replace(/[&<>"']/g, (char) => {
-		switch (char) {
-			case "&": return "&amp;";
-			case "<": return "&lt;";
-			case ">": return "&gt;";
-			case "\"": return "&quot;";
-			case "'": return "&#39;";
-			default: return char;
-		}
-	});
-}
-//#endregion
-export { login };

package/dist/lib/database/provider.js

@@ -1,167 +0,0 @@
-import { CliError } from "../../shell/errors.js";
-//#region src/lib/database/provider.ts
-function createManagementDatabaseProvider(client) {
-	return {
-		async listDatabases(options) {
-			const databases = [];
-			let cursor;
-			while (true) {
-				const result = await client.GET("/v1/databases", {
-					params: { query: {
-						projectId: options.projectId,
-						branchGitName: options.branchName,
-						cursor
-					} },
-					signal: options.signal
-				});
-				if (result.error || !result.data) throw databaseApiError("Failed to list databases", result.response, result.error);
-				databases.push(...result.data.data);
-				if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
-				cursor = result.data.pagination.nextCursor;
-			}
-			return databases.map((database) => normalizeDatabase(database, options.projectId));
-		},
-		async showDatabase(databaseId, options) {
-			const result = await client.GET("/v1/databases/{databaseId}", {
-				params: { path: { databaseId } },
-				signal: options?.signal
-			});
-			if (result.response?.status === 404) return null;
-			if (result.error || !result.data) throw databaseApiError("Failed to show database", result.response, result.error);
-			const database = result.data.data;
-			return normalizeDatabase(database, requireDatabaseProjectId(database, options?.projectId));
-		},
-		async createDatabase(options) {
-			const result = await client.POST("/v1/databases", {
-				body: {
-					projectId: options.projectId,
-					name: options.name,
-					source: { type: "empty" },
-					...options.branchName ? { branchGitName: options.branchName } : {},
-					...options.region ? { region: options.region } : {}
-				},
-				signal: options.signal
-			});
-			if (result.error || !result.data) throw databaseApiError("Failed to create database", result.response, result.error);
-			return normalizeCreatedDatabase(result.data.data, options.projectId);
-		},
-		async removeDatabase(databaseId, options) {
-			const result = await client.DELETE("/v1/databases/{databaseId}", {
-				params: { path: { databaseId } },
-				signal: options?.signal
-			});
-			if (result.error) throw databaseApiError("Failed to remove database", result.response, result.error);
-		},
-		async listConnections(databaseId, options) {
-			const result = await client.GET("/v1/databases/{databaseId}/connections", {
-				params: { path: { databaseId } },
-				signal: options?.signal
-			});
-			if (result.error || !result.data) throw databaseApiError("Failed to list database connections", result.response, result.error);
-			return result.data.data.map((connection) => normalizeConnection(connection, databaseId));
-		},
-		async createConnection(options) {
-			const result = await client.POST("/v1/databases/{databaseId}/connections", {
-				params: { path: { databaseId: options.databaseId } },
-				body: { name: options.name },
-				signal: options.signal
-			});
-			if (result.error || !result.data) throw databaseApiError("Failed to create database connection", result.response, result.error);
-			return normalizeCreatedConnection(result.data.data, options.databaseId);
-		},
-		async removeConnection(connectionId, options) {
-			const result = await client.DELETE("/v1/connections/{id}", {
-				params: { path: { id: connectionId } },
-				signal: options?.signal
-			});
-			if (result.error) throw databaseApiError("Failed to remove database connection", result.response, result.error);
-		}
-	};
-}
-function normalizeDatabase(database, fallbackProjectId) {
-	return {
-		id: database.id,
-		name: database.name,
-		projectId: database.projectId ?? fallbackProjectId,
-		branchId: database.branchId ?? database.branch?.id ?? null,
-		branchName: database.branchGitName ?? database.branchName ?? database.branch?.gitName ?? database.branch?.name ?? null,
-		region: normalizeRegion(database),
-		status: database.status ?? null,
-		isDefault: database.isDefault ?? null,
-		createdAt: database.createdAt ?? null
-	};
-}
-function normalizeConnection(connection, fallbackDatabaseId) {
-	return {
-		id: connection.id,
-		name: connection.name ?? connection.id,
-		databaseId: connection.databaseId ?? fallbackDatabaseId,
-		createdAt: connection.createdAt ?? null
-	};
-}
-function normalizeCreatedDatabase(database, fallbackProjectId) {
-	const rawConnection = database.connections?.[0];
-	if (!rawConnection) throw new CliError({
-		code: "DATABASE_CONNECTION_MISSING",
-		domain: "database",
-		summary: "Created database did not return a connection string",
-		why: "The Management API created the database but did not include the one-time connection payload.",
-		fix: "Create a connection explicitly with prisma-cli database connection create <database>.",
-		exitCode: 1,
-		nextSteps: [`prisma-cli database connection create ${database.id}`]
-	});
-	return {
-		database: normalizeDatabase(database, fallbackProjectId),
-		...normalizeCreatedConnection(rawConnection, database.id)
-	};
-}
-function normalizeCreatedConnection(connection, fallbackDatabaseId) {
-	const connectionString = extractConnectionString(connection);
-	if (!connectionString) throw new CliError({
-		code: "DATABASE_CONNECTION_STRING_MISSING",
-		domain: "database",
-		summary: "Created connection did not return a connection string",
-		why: "Database connection strings are one-time-view secrets, but the Management API did not include one in this create response.",
-		fix: "Create another database connection and store the returned URL immediately.",
-		exitCode: 1,
-		nextSteps: [`prisma-cli database connection create ${fallbackDatabaseId}`]
-	});
-	return {
-		connection: normalizeConnection(connection, fallbackDatabaseId),
-		connectionString
-	};
-}
-function normalizeRegion(database) {
-	if (typeof database.region === "string") return database.region;
-	return database.region?.id ?? database.regionId ?? null;
-}
-function requireDatabaseProjectId(database, fallbackProjectId) {
-	const projectId = database.projectId ?? fallbackProjectId;
-	if (projectId) return projectId;
-	throw new CliError({
-		code: "DATABASE_API_ERROR",
-		domain: "database",
-		summary: "Database response did not include a project id",
-		why: "The Management API returned database metadata without project context.",
-		fix: "Re-run with --trace for the underlying API response details.",
-		exitCode: 1,
-		nextSteps: []
-	});
-}
-function extractConnectionString(connection) {
-	return connection.endpoints?.pooled?.connectionString ?? connection.connectionString ?? connection.endpoints?.direct?.connectionString ?? connection.endpoints?.accelerate?.connectionString ?? null;
-}
-function databaseApiError(summary, response, error) {
-	const status = response?.status ?? 0;
-	return new CliError({
-		code: error?.error?.code ?? "DATABASE_API_ERROR",
-		domain: "database",
-		summary,
-		why: error?.error?.message ?? `The Management API returned status ${status || "unknown"}.`,
-		fix: error?.error?.hint ?? "Re-run with --trace for the underlying API response details.",
-		exitCode: 1,
-		nextSteps: []
-	});
-}
-//#endregion
-export { createManagementDatabaseProvider, normalizeConnection, normalizeDatabase };

package/dist/lib/diagnostics.js

@@ -1,15 +0,0 @@
-import { resolveLocalStateFilePath } from "../adapters/local-state.js";
-import { resolveStateDir } from "../shell/runtime.js";
-import { readLocalGitState } from "./git/local-status.js";
-//#region src/lib/diagnostics.ts
-async function collectCommandDiagnostics(context, options = {}) {
-	const stateDir = await resolveStateDir(context.runtime);
-	return {
-		cwd: context.runtime.cwd,
-		stateFilePath: resolveLocalStateFilePath(stateDir),
-		git: await readLocalGitState(context.runtime.cwd, context.runtime.signal),
-		durationMs: options.durationMs
-	};
-}
-//#endregion
-export { collectCommandDiagnostics };

package/dist/lib/fs/home-path.js

@@ -1,24 +0,0 @@
-import path from "node:path";
-//#region src/lib/fs/home-path.ts
-/**
-* Shortens a path under the user's home directory to `~/...` for display,
-* posix-style on every platform. Falls back to the Windows home variables
-* when `HOME` is unset (native cmd/PowerShell sessions).
-*/
-function shortenHomePath(value, env) {
-	const resolved = path.resolve(value);
-	const home = resolveHomeDirectory(env);
-	if (home && (resolved === home || resolved.startsWith(`${home}${path.sep}`))) {
-		const relative = path.relative(home, resolved).split(path.sep).join("/");
-		return relative ? `~/${relative}` : "~";
-	}
-	return resolved;
-}
-function resolveHomeDirectory(env) {
-	if (env.HOME) return path.resolve(env.HOME);
-	if (env.USERPROFILE) return path.resolve(env.USERPROFILE);
-	if (env.HOMEDRIVE && env.HOMEPATH) return path.resolve(`${env.HOMEDRIVE}${env.HOMEPATH}`);
-	return null;
-}
-//#endregion
-export { shortenHomePath };

package/dist/lib/git/local-branch.js

@@ -1,53 +0,0 @@
-import { access, readFile } from "node:fs/promises";
-import path from "node:path";
-//#region src/lib/git/local-branch.ts
-/**
-* Resolves the checked-out branch the way git does: the nearest `.git`
-* (directory or worktree file) from `cwd` upward owns the answer, so
-* monorepo commands run from inside a package see the repository branch.
-* Returns null for detached HEAD or when no repository contains `cwd`.
-*/
-async function readLocalGitBranch(cwd, signal) {
-	for (let directory = path.resolve(cwd);;) {
-		const headPath = await resolveGitHeadPath(path.join(directory, ".git"), signal);
-		if (headPath) return readBranchFromHead(headPath, signal);
-		const parent = path.dirname(directory);
-		if (parent === directory) return null;
-		directory = parent;
-	}
-}
-async function readBranchFromHead(headPath, signal) {
-	try {
-		const head = (await readFile(headPath, {
-			encoding: "utf8",
-			signal
-		})).trim();
-		if (head.startsWith("ref: refs/heads/")) return head.slice(16);
-	} catch (error) {
-		if (signal.aborted) throw error;
-	}
-	return null;
-}
-async function resolveGitHeadPath(gitPath, signal) {
-	signal.throwIfAborted();
-	try {
-		const raw = await readFile(gitPath, {
-			encoding: "utf8",
-			signal
-		});
-		if (raw.startsWith("gitdir:")) return path.join(path.resolve(path.dirname(gitPath), raw.slice(7).trim()), "HEAD");
-	} catch (error) {
-		if (signal.aborted) throw error;
-	}
-	signal.throwIfAborted();
-	try {
-		await access(path.join(gitPath, "HEAD"));
-		signal.throwIfAborted();
-		return path.join(gitPath, "HEAD");
-	} catch (error) {
-		if (signal.aborted) throw error;
-		return null;
-	}
-}
-//#endregion
-export { readLocalGitBranch };

package/dist/lib/git/local-status.js

@@ -1,57 +0,0 @@
-import { execFile } from "node:child_process";
-//#region src/lib/git/local-status.ts
-async function readLocalGitState(cwd, signal) {
-	signal.throwIfAborted();
-	if ((await runGit(cwd, ["rev-parse", "--is-inside-work-tree"], signal))?.trim() !== "true") return null;
-	const [ref, sha, status] = await Promise.all([
-		runGit(cwd, [
-			"symbolic-ref",
-			"--quiet",
-			"--short",
-			"HEAD"
-		], signal),
-		runGit(cwd, [
-			"rev-parse",
-			"--short",
-			"HEAD"
-		], signal),
-		runGit(cwd, ["status", "--porcelain"], signal)
-	]);
-	return {
-		ref: cleanGitValue(ref),
-		sha: cleanGitValue(sha),
-		dirty: status === null ? null : status.trim().length > 0
-	};
-}
-function runGit(cwd, args, signal) {
-	return new Promise((resolve, reject) => {
-		signal.throwIfAborted();
-		execFile("git", args, {
-			cwd,
-			signal,
-			timeout: 2e3
-		}, (error, stdout) => {
-			if (signal.aborted) {
-				reject(error);
-				return;
-			}
-			if (error) {
-				resolve(null);
-				return;
-			}
-			resolve(stdout);
-		}).on("error", (error) => {
-			if (signal.aborted) {
-				reject(error);
-				return;
-			}
-			resolve(null);
-		});
-	});
-}
-function cleanGitValue(value) {
-	const cleaned = value?.trim();
-	return cleaned ? cleaned : null;
-}
-//#endregion
-export { readLocalGitState };