@prisma/cli 2.20.0 → 3.0.0-alpha.0

package/dist/lib/auth/auth-ops.js

@@ -0,0 +1,57 @@
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { requireComputeAuth } from "./guard.js";
+import { login } from "./login.js";
+//#region src/lib/auth/auth-ops.ts
+function decodeJwtPayload(token) {
+	try {
+		const payload = token.split(".")[1];
+		if (!payload) return {};
+		return JSON.parse(Buffer.from(payload, "base64url").toString("utf8"));
+	} catch {
+		return {};
+	}
+}
+async function performLogin(env) {
+	await login({
+		tokenStorage: new FileTokenStorage(env),
+		env
+	});
+}
+async function readAuthState(env) {
+	const tokens = await new FileTokenStorage(env).getTokens();
+	if (!tokens) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null,
+		linkedProjectId: null
+	};
+	const claims = decodeJwtPayload(tokens.accessToken);
+	const client = await requireComputeAuth(env);
+	let workspaceId = tokens.workspaceId;
+	let workspaceName = tokens.workspaceId;
+	if (client) try {
+		const { data } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: tokens.workspaceId } } });
+		if (data?.data?.id) workspaceId = data.data.id;
+		if (data?.data?.name) workspaceName = data.data.name;
+	} catch {}
+	return {
+		authenticated: true,
+		provider: null,
+		user: {
+			id: claims.sub ?? "",
+			name: claims.name ?? "",
+			email: claims.email ?? ""
+		},
+		workspace: {
+			id: workspaceId,
+			name: workspaceName
+		},
+		linkedProjectId: null
+	};
+}
+async function performLogout(env) {
+	await new FileTokenStorage(env).clearTokens();
+}
+//#endregion
+export { performLogin, performLogout, readAuthState };

package/dist/lib/auth/client.js

@@ -0,0 +1,22 @@
+import path from "node:path";
+import os from "node:os";
+//#region src/lib/auth/client.ts
+const CLIENT_ID = "cmm3lndn701oo0uefvxzo0ivw";
+const SERVICE_TOKEN_ENV_VAR = "PRISMA_API_TOKEN";
+const AUTH_FILE_ENV_VAR = "PRISMA_COMPUTE_AUTH_FILE";
+function getApiBaseUrl(env = process.env) {
+	return env.PRISMA_MANAGEMENT_API_URL?.trim() || "https://api.prisma.io";
+}
+function getAuthFilePath(env = process.env) {
+	const configured = env[AUTH_FILE_ENV_VAR];
+	if (configured?.trim()) return path.resolve(configured);
+	if (process.platform === "darwin") return path.join(os.homedir(), "Library", "Application Support", "prisma", "auth.json");
+	if (process.platform === "win32") {
+		const appData = env.APPDATA ?? path.join(os.homedir(), "AppData", "Roaming");
+		return path.join(appData, "prisma", "auth.json");
+	}
+	const xdgConfigHome = env.XDG_CONFIG_HOME ?? path.join(os.homedir(), ".config");
+	return path.join(xdgConfigHome, "prisma", "auth.json");
+}
+//#endregion
+export { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl, getAuthFilePath };

package/dist/lib/auth/guard.js

@@ -0,0 +1,34 @@
+import { CLIENT_ID, SERVICE_TOKEN_ENV_VAR, getApiBaseUrl } from "./client.js";
+import { FileTokenStorage } from "../../adapters/token-storage.js";
+import { createManagementApiClient, createManagementApiSdk } from "@prisma/management-api-sdk";
+//#region src/lib/auth/guard.ts
+/**
+* Resolve authentication and return a ManagementApiClient.
+*
+* Priority:
+*   1. PRISMA_API_TOKEN env var → service token (CI / headless)
+*   2. Stored OAuth tokens     → SDK with auto-refresh
+*
+* Returns null if not authenticated.
+*/
+async function requireComputeAuth(env = process.env) {
+	const rawToken = env[SERVICE_TOKEN_ENV_VAR];
+	if (rawToken !== void 0) {
+		const token = rawToken.trim();
+		if (token.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
+		return createManagementApiClient({
+			baseUrl: getApiBaseUrl(env),
+			token
+		});
+	}
+	const tokenStorage = new FileTokenStorage(env);
+	if (!await tokenStorage.getTokens()) return null;
+	return createManagementApiSdk({
+		clientId: CLIENT_ID,
+		redirectUri: "http://localhost:0/auth/callback",
+		tokenStorage,
+		apiBaseUrl: getApiBaseUrl(env)
+	}).client;
+}
+//#endregion
+export { requireComputeAuth };

package/dist/lib/auth/login.js

@@ -0,0 +1,117 @@
+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";
+//#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 server = http.createServer();
+	server.listen({
+		host: hostname,
+		port
+	});
+	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
+		});
+		const authResult = new Promise((resolve, reject) => {
+			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;
+				}
+				try {
+					await state.handleCallback(url);
+				} catch (error) {
+					res.statusCode = 400;
+					const message = error instanceof Error ? error.message : String(error);
+					res.end(message);
+					reject(error);
+					return;
+				}
+				res.setHeader("Content-Type", "text/html");
+				res.end(`<html><body style="font-family:system-ui;max-width:400px;margin:80px auto;text-align:center"><h2>✓ Signed in</h2><p>You may now close this tab and return to the terminal.</p></body></html>`);
+				resolve();
+			});
+		});
+		await state.openLoginPage();
+		await authResult;
+	} finally {
+		if (server.listening) await new Promise((resolve) => server.close(() => resolve()));
+	}
+}
+var LoginState = class {
+	latestVerifier;
+	latestState;
+	sdk;
+	openUrl;
+	constructor(options) {
+		this.options = options;
+		const tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
+		this.sdk = createManagementApiSdk({
+			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
+			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
+			tokenStorage,
+			apiBaseUrl: options.apiBaseUrl ?? getApiBaseUrl(options.env),
+			authBaseUrl: options.authBaseUrl
+		});
+		this.openUrl = options.openUrl ?? open;
+	}
+	async openLoginPage() {
+		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;
+		await this.openUrl(url);
+	}
+	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");
+		}
+	}
+	get host() {
+		return `${this.options.hostname}:${this.options.port}`;
+	}
+};
+//#endregion
+export { login };

package/dist/output/patterns.js

@@ -0,0 +1,93 @@
+import { formatDescriptorLabel } from "../shell/command-meta.js";
+import { maskValue, padDisplay, renderSummaryLine } from "../shell/ui.js";
+import stringWidth from "string-width";
+//#region src/output/patterns.ts
+function renderList(input, ui) {
+	const keyWidth = Math.max(stringWidth(`${input.parentContext.key}:`), ...input.items.map((item) => stringWidth(`⚬ ${item.noun}:`)), stringWidth("Read more"));
+	const lines = renderCardTitle(input.descriptor, input.title, ui);
+	lines.push(renderCardRow(ui, keyWidth, input.parentContext.key, input.parentContext.value));
+	if (input.items.length === 0) lines.push(renderPlainCardLine(ui, ui.dim(input.emptyMessage)));
+	else for (const item of input.items) lines.push(renderCardRow(ui, keyWidth, `⚬ ${item.noun}`, formatListItemValue(ui, item)));
+	lines.push(renderCardDivider(ui));
+	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	return lines;
+}
+function serializeList(input) {
+	return {
+		context: input.context,
+		items: input.items.map((item) => ({
+			name: item.label,
+			id: item.id,
+			status: item.status
+		})),
+		count: input.items.length
+	};
+}
+function renderShow(input, ui) {
+	const keyWidth = Math.max(...input.fields.map((field) => stringWidth(`${field.key}:`)), stringWidth("Read more"));
+	const lines = renderCardTitle(input.descriptor, input.title, ui);
+	for (const field of input.fields) lines.push(renderCardRow(ui, keyWidth, field.key, formatValue(ui, field.value, field.tone, field.sensitive)));
+	lines.push(renderCardDivider(ui));
+	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	return lines;
+}
+function renderMutate(input, ui) {
+	const rows = [...input.context, {
+		key: "mode",
+		value: "apply",
+		tone: "dim"
+	}];
+	const keyWidth = Math.max(...rows.map((row) => stringWidth(`${row.key}:`)), stringWidth("Read more"));
+	const lines = renderCardTitle(input.descriptor, input.title, ui);
+	for (const row of rows) lines.push(renderCardRow(ui, keyWidth, row.key, formatValue(ui, row.value, row.tone, row.sensitive)));
+	lines.push(renderCardDivider(ui));
+	lines.push(renderReadMore(ui, keyWidth, input.descriptor));
+	lines.push("");
+	lines.push(`${ui.warning("◇")} ${input.operationDescription}...`);
+	lines.push(renderSummaryLine(ui, "success", `Applied ${input.operationCount} operation(s)`));
+	for (const detail of input.details) lines.push(`  ${detail}`);
+	for (const alert of input.alerts ?? []) {
+		lines.push("");
+		lines.push(renderSummaryLine(ui, alert.tone, alert.text));
+	}
+	return lines;
+}
+function renderCardTitle(descriptor, title, ui) {
+	return [`${ui.strong(formatDescriptorLabel(descriptor))} ${ui.dim("→")} ${ui.dim(title)}`, ""];
+}
+function renderCardRow(ui, keyWidth, key, value) {
+	return `${renderCardRail(ui)}  ${ui.accent(padDisplay(`${key}:`, keyWidth))}  ${value}`;
+}
+function renderPlainCardLine(ui, text) {
+	return `${renderCardRail(ui)}  ${text}`;
+}
+function renderCardDivider(ui) {
+	return renderCardRail(ui);
+}
+function renderReadMore(ui, keyWidth, descriptor) {
+	return `${renderCardRail(ui)}  ${ui.accent(padDisplay("Read more", keyWidth))}  ${ui.link(descriptor.docsPath ?? "")}`;
+}
+function renderCardRail(ui) {
+	return ui.dim("│");
+}
+function formatListItemValue(ui, item) {
+	const annotation = renderAnnotation(ui, item.status);
+	return annotation ? `${item.label} ${annotation}` : item.label;
+}
+function renderAnnotation(ui, status) {
+	if (status === "active") return ui.success("(active)");
+	if (status === "linked") return ui.accent("(linked)");
+	if (status === "default") return ui.dim("(default)");
+	return "";
+}
+function formatValue(ui, value, tone = "default", sensitive = false) {
+	const resolvedValue = sensitive ? maskValue(value) : value;
+	if (tone === "success") return ui.success(resolvedValue);
+	if (tone === "warning") return ui.warning(resolvedValue);
+	if (tone === "error") return ui.error(resolvedValue);
+	if (tone === "link") return ui.link(resolvedValue);
+	if (tone === "dim") return ui.dim(resolvedValue);
+	return resolvedValue;
+}
+//#endregion
+export { renderList, renderMutate, renderShow, serializeList };