@prisma/cli 3.0.0-alpha.0 → 3.0.0-alpha.10

package/dist/lib/app/preview-provider.js

@@ -1,9 +1,9 @@
 import { envVarNames } from "./env-vars.js";
 import { PreviewBuildStrategy } from "./preview-build.js";
 import path from "node:path";
-import { ApiError, ComputeClient } from "@prisma/compute-sdk";
+import { ApiError, CancelledError, ComputeClient, streamLogs } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-provider.ts
-function createPreviewAppProvider(client) {
+function createPreviewAppProvider(client, options) {
 	const sdk = new ComputeClient(client);
 	return {
 		async createProject(options) {
@@ -14,25 +14,11 @@ function createPreviewAppProvider(client) {
 				name: projectResult.value.name
 			};
 		},
-		async listApps(projectId) {
-			const servicesResult = await sdk.listServices({ projectId });
-			if (servicesResult.isErr()) throw new Error(servicesResult.error.message);
-			return (await Promise.all(servicesResult.value.map(async (service) => {
-				const detailResult = await sdk.showService({ serviceId: service.id });
-				return detailResult.isOk() ? detailResult.value : {
-					id: service.id,
-					name: service.name,
-					region: service.region,
-					latestVersionId: null,
-					serviceEndpointDomain: void 0
-				};
-			}))).map((service) => ({
-				id: service.id,
-				name: service.name,
-				region: service.region ?? null,
-				liveDeploymentId: service.latestVersionId ?? null,
-				liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
-			}));
+		async listApps(projectId, options) {
+			return listComputeServices(client, {
+				projectId,
+				branchGitName: options?.branchName
+			});
 		},
 		async removeApp(appId) {
 			const appResult = await sdk.showService({ serviceId: appId });
@@ -60,6 +46,20 @@ function createPreviewAppProvider(client) {
 			if (promoteResult.isErr()) throw new Error(promoteResult.error.message);
 		},
 		async deployApp(options) {
+			const resolvedApp = options.appId ? {
+				appId: options.appId,
+				appName: options.appName,
+				region: options.region
+			} : options.branchName && options.appName ? await createBranchApp(client, {
+				projectId: options.projectId,
+				branchName: options.branchName,
+				appName: options.appName,
+				region: options.region
+			}) : {
+				appId: void 0,
+				appName: options.appName,
+				region: options.region
+			};
 			const deployResult = await sdk.deploy({
 				strategy: new PreviewBuildStrategy({
 					appPath: path.resolve(options.cwd),
@@ -67,9 +67,9 @@ function createPreviewAppProvider(client) {
 					buildType: options.buildType
 				}),
 				projectId: options.projectId,
-				serviceId: options.appId,
-				serviceName: options.appName,
-				region: options.region,
+				serviceId: resolvedApp.appId,
+				serviceName: resolvedApp.appName,
+				region: resolvedApp.region,
 				portMapping: options.portMapping,
 				envVars: options.envVars,
 				timeoutSeconds: 120,
@@ -197,9 +197,110 @@ function createPreviewAppProvider(client) {
 					live: null
 				}
 			};
+		},
+		async streamDeploymentLogs(streamOptions) {
+			if (!options?.baseUrl || !options.getToken) throw new Error("Log streaming requires an authenticated API base URL and token.");
+			const result = await streamLogs({
+				baseUrl: options.baseUrl,
+				token: await options.getToken(),
+				versionId: streamOptions.deploymentId,
+				signal: streamOptions.signal
+			}, streamOptions.onRecord);
+			if (result.isErr()) {
+				if (CancelledError.is(result.error)) return;
+				throw result.error;
+			}
 		}
 	};
 }
+async function listBranches(client, options) {
+	const result = await client.GET("/v1/projects/{projectId}/branches", { params: {
+		path: { projectId: options.projectId },
+		query: { gitName: options.gitName }
+	} });
+	if (result.error || !result.data) throw apiCallError("Failed to list branches", result.response, result.error);
+	return result.data.data;
+}
+async function resolveOrCreateBranch(client, options) {
+	const existing = (await listBranches(client, options))[0];
+	if (existing) return existing;
+	const result = await client.POST("/v1/projects/{projectId}/branches", {
+		params: { path: { projectId: options.projectId } },
+		body: {
+			gitName: options.gitName,
+			isDefault: options.gitName === "main"
+		}
+	});
+	if (result.error || !result.data) {
+		if (result.response.status === 409) {
+			const raced = (await listBranches(client, options))[0];
+			if (raced) return raced;
+		}
+		throw apiCallError(`Failed to create branch "${options.gitName}"`, result.response, result.error);
+	}
+	return result.data.data;
+}
+async function listComputeServices(client, options) {
+	const services = [];
+	let cursor;
+	while (true) {
+		const result = await client.GET("/v1/compute-services", { params: { query: {
+			projectId: options.projectId,
+			branchGitName: options.branchGitName,
+			cursor
+		} } });
+		if (result.error || !result.data) throw apiCallError("Failed to list apps", result.response, result.error);
+		services.push(...result.data.data);
+		if (!result.data.pagination.hasMore || !result.data.pagination.nextCursor) break;
+		cursor = result.data.pagination.nextCursor;
+	}
+	return services.map((service) => ({
+		id: service.id,
+		name: service.name,
+		region: service.region.id ?? null,
+		branchId: service.branchId,
+		liveDeploymentId: service.latestVersionId ?? null,
+		liveUrl: toAbsoluteUrl(service.serviceEndpointDomain ?? null)
+	}));
+}
+async function createBranchApp(client, options) {
+	const branch = await resolveOrCreateBranch(client, {
+		projectId: options.projectId,
+		gitName: options.branchName
+	});
+	const result = await client.POST("/v1/compute-services", { body: {
+		projectId: options.projectId,
+		branchId: branch.id,
+		displayName: options.appName,
+		...options.region ? { regionId: options.region } : {}
+	} });
+	if (result.error || !result.data) {
+		if (result.response.status === 409) {
+			const matched = (await listComputeServices(client, {
+				projectId: options.projectId,
+				branchGitName: options.branchName
+			})).find((app) => app.name === options.appName);
+			if (matched) return {
+				appId: matched.id,
+				appName: matched.name,
+				region: matched.region ?? options.region
+			};
+		}
+		throw apiCallError(`Failed to create app "${options.appName}"`, result.response, result.error);
+	}
+	const service = result.data.data;
+	return {
+		appId: service.id,
+		appName: service.name,
+		region: service.region.id ?? options.region
+	};
+}
+function apiCallError(summary, response, error) {
+	if (response.status === 404) return /* @__PURE__ */ new Error("Resource Not Found");
+	const message = error.error?.message ?? `Management API returned HTTP ${response.status}.`;
+	const hint = error.error?.hint ? ` ${error.error.hint}` : "";
+	return /* @__PURE__ */ new Error(`${summary}: ${message}${hint}`);
+}
 async function findAppForDeployment(sdk, deploymentId) {
 	const projectsResult = await sdk.listProjects();
 	if (projectsResult.isErr()) throw new Error(projectsResult.error.message);

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

@@ -1,7 +1,9 @@
+import { SERVICE_TOKEN_ENV_VAR } from "./client.js";
 import { FileTokenStorage } from "../../adapters/token-storage.js";
 import { requireComputeAuth } from "./guard.js";
 import { login } from "./login.js";
 //#region src/lib/auth/auth-ops.ts
+const WORKSPACE_SUB_PREFIX = "workspace:";
 function decodeJwtPayload(token) {
 	try {
 		const payload = token.split(".")[1];
@@ -11,6 +13,17 @@ function decodeJwtPayload(token) {
 		return {};
 	}
 }
+function emailFromClaims(claims) {
+	const email = claims.email;
+	return typeof email === "string" && email.trim().length > 0 ? email.trim() : null;
+}
+function workspaceIdFromClaims(claims) {
+	const sub = claims.sub;
+	if (typeof sub !== "string") return null;
+	if (!sub.startsWith(WORKSPACE_SUB_PREFIX)) return null;
+	const id = sub.slice(10).trim();
+	return id.length > 0 ? id : null;
+}
 async function performLogin(env) {
 	await login({
 		tokenStorage: new FileTokenStorage(env),
@@ -18,36 +31,68 @@ async function performLogin(env) {
 	});
 }
 async function readAuthState(env) {
+	const rawServiceToken = env[SERVICE_TOKEN_ENV_VAR];
+	if (rawServiceToken !== void 0) {
+		const serviceToken = rawServiceToken.trim();
+		if (serviceToken.length === 0) throw new Error(`${SERVICE_TOKEN_ENV_VAR} is set but empty. Provide a valid token or unset the variable.`);
+		return readServiceTokenAuthState(serviceToken, env);
+	}
 	const tokens = await new FileTokenStorage(env).getTokens();
 	if (!tokens) return {
 		authenticated: false,
 		provider: null,
 		user: null,
-		workspace: null,
-		linkedProjectId: null
+		workspace: null
 	};
 	const claims = decodeJwtPayload(tokens.accessToken);
+	return buildAuthState({
+		workspaceIdFromCredential: tokens.workspaceId,
+		claims,
+		env
+	});
+}
+async function readServiceTokenAuthState(token, env) {
+	const claims = decodeJwtPayload(token);
+	const workspaceId = workspaceIdFromClaims(claims);
+	if (!workspaceId) return {
+		authenticated: false,
+		provider: null,
+		user: null,
+		workspace: null
+	};
+	return buildAuthState({
+		workspaceIdFromCredential: workspaceId,
+		claims,
+		env
+	});
+}
+async function buildAuthState({ workspaceIdFromCredential, claims, env }) {
+	let workspaceId = workspaceIdFromCredential;
+	let workspaceName = workspaceIdFromCredential;
 	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;
+		const { data, response } = await client.GET("/v1/workspaces/{id}", { params: { path: { id: workspaceIdFromCredential } } });
+		if (response?.status === 401) return {
+			authenticated: false,
+			provider: null,
+			user: null,
+			workspace: null
+		};
+		if (data?.data?.id) {
+			workspaceId = data.data.id;
+			workspaceName = data.data.id;
+		}
 		if (data?.data?.name) workspaceName = data.data.name;
 	} catch {}
+	const email = emailFromClaims(claims);
 	return {
 		authenticated: true,
 		provider: null,
-		user: {
-			id: claims.sub ?? "",
-			name: claims.name ?? "",
-			email: claims.email ?? ""
-		},
+		user: email ? { email } : null,
 		workspace: {
 			id: workspaceId,
 			name: workspaceName
-		},
-		linkedProjectId: null
+		}
 	};
 }
 async function performLogout(env) {

package/dist/lib/auth/client.js

@@ -2,7 +2,7 @@ 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 SERVICE_TOKEN_ENV_VAR = "PRISMA_SERVICE_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";

package/dist/lib/auth/guard.js

@@ -6,7 +6,7 @@ import { createManagementApiClient, createManagementApiSdk } from "@prisma/manag
 * Resolve authentication and return a ManagementApiClient.
 *
 * Priority:
-*   1. PRISMA_API_TOKEN env var → service token (CI / headless)
+*   1. PRISMA_SERVICE_TOKEN env var → service token (CI / headless)
 *   2. Stored OAuth tokens     → SDK with auto-refresh
 *
 * Returns null if not authenticated.

package/dist/lib/auth/login.js

@@ -47,8 +47,9 @@ async function login(options = {}) {
 					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>`);
+				const workspaceName = await state.resolveWorkspaceName();
+				res.setHeader("Content-Type", "text/html; charset=utf-8");
+				res.end(renderSuccessPage(workspaceName));
 				resolve();
 			});
 		});
@@ -63,13 +64,14 @@ var LoginState = class {
 	latestState;
 	sdk;
 	openUrl;
+	tokenStorage;
 	constructor(options) {
 		this.options = options;
-		const tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
+		this.tokenStorage = options.tokenStorage ?? new FileTokenStorage(options.env);
 		this.sdk = createManagementApiSdk({
 			clientId: options.clientId ?? "cmm3lndn701oo0uefvxzo0ivw",
 			redirectUri: `http://${options.hostname}:${options.port}/auth/callback`,
-			tokenStorage,
+			tokenStorage: this.tokenStorage,
 			apiBaseUrl: options.apiBaseUrl ?? getApiBaseUrl(options.env),
 			authBaseUrl: options.authBaseUrl
 		});
@@ -109,9 +111,118 @@ var LoginState = class {
 			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 } } });
+			const name = data?.data?.name;
+			return typeof name === "string" && name.trim().length > 0 ? name.trim() : null;
+		} catch {
+			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/project/local-pin.js

@@ -0,0 +1,51 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+//#region src/lib/project/local-pin.ts
+const LOCAL_RESOLUTION_PIN_RELATIVE_PATH = ".prisma/local.json";
+async function readLocalResolutionPin(cwd) {
+	try {
+		const raw = await readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), "utf8");
+		const parsed = JSON.parse(raw);
+		if (!isLocalResolutionPin(parsed)) return { kind: "invalid" };
+		return {
+			kind: "present",
+			pin: parsed
+		};
+	} catch (error) {
+		if (error.code === "ENOENT") return { kind: "missing" };
+		if (error instanceof SyntaxError) return { kind: "invalid" };
+		throw error;
+	}
+}
+async function writeLocalResolutionPin(cwd, pin) {
+	const prismaDir = path.join(cwd, ".prisma");
+	await mkdir(prismaDir, { recursive: true });
+	const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
+	const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
+	await writeFile(tmpPath, `${JSON.stringify(pin, null, 2)}\n`, "utf8");
+	await rename(tmpPath, pinPath);
+}
+async function ensureLocalResolutionPinGitignore(cwd) {
+	const gitignorePath = path.join(cwd, ".gitignore");
+	let existing = null;
+	try {
+		existing = await readFile(gitignorePath, "utf8");
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+	if (existing === null) {
+		await writeFile(gitignorePath, ".prisma/\n", "utf8");
+		return;
+	}
+	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return;
+	await writeFile(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, "utf8");
+}
+function isLocalResolutionPin(value) {
+	if (!value || typeof value !== "object") return false;
+	const keys = Object.keys(value);
+	if (keys.length !== 2 || !keys.includes("workspaceId") || !keys.includes("projectId")) return false;
+	const candidate = value;
+	return typeof candidate.workspaceId === "string" && candidate.workspaceId.trim().length > 0 && typeof candidate.projectId === "string" && candidate.projectId.trim().length > 0;
+}
+//#endregion
+export { LOCAL_RESOLUTION_PIN_RELATIVE_PATH, ensureLocalResolutionPinGitignore, readLocalResolutionPin, writeLocalResolutionPin };