@prisma/cli 3.0.0-alpha.5 → 3.0.0-alpha.7

package/dist/lib/app/bun-project.js

@@ -1,5 +1,5 @@
-import path from "node:path";
 import { access, readFile } from "node:fs/promises";
+import path from "node:path";
 //#region src/lib/app/bun-project.ts
 async function readBunPackageJson(appPath) {
 	const packageJsonPath = path.join(appPath, "package.json");

package/dist/lib/app/local-dev.js

@@ -1,6 +1,6 @@
 import { readBunPackageEntrypoint, readBunPackageJson, resolveBunEntrypoint } from "./bun-project.js";
-import path from "node:path";
 import { access } from "node:fs/promises";
+import path from "node:path";
 import { spawn } from "node:child_process";
 //#region src/lib/app/local-dev.ts
 const NEXT_CONFIG_FILENAMES = [

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

@@ -1,6 +1,6 @@
 import { resolveBunEntrypoint } from "./bun-project.js";
-import path from "node:path";
 import { cp, readdir, readlink, rm, stat } from "node:fs/promises";
+import path from "node:path";
 import { AstroBuild, BunBuild, NextjsBuild, NuxtBuild, TanstackStartBuild } from "@prisma/compute-sdk";
 //#region src/lib/app/preview-build.ts
 const PREVIEW_BUILD_TYPES = [

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

@@ -1,38 +1,5 @@
-import { selectPrompt, textPrompt } from "../../shell/prompt.js";
+import "../../shell/prompt.js";
 //#region src/lib/app/preview-interaction.ts
-const CREATE_NEW_APP = "__create_new_app__";
 const PREVIEW_DEFAULT_REGION = "eu-central-1";
-function createPreviewDeployInteraction(context) {
-	return {
-		async selectService(services) {
-			const sorted = services.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
-			const selection = await selectPrompt({
-				input: context.runtime.stdin,
-				output: context.runtime.stderr,
-				message: "Select an app",
-				choices: [...sorted.map((service) => ({
-					label: service.name,
-					value: service.id
-				})), {
-					label: "Create a new app",
-					value: CREATE_NEW_APP
-				}]
-			});
-			return selection === CREATE_NEW_APP ? null : selection;
-		},
-		async provideServiceName() {
-			return textPrompt({
-				input: context.runtime.stdin,
-				output: context.runtime.stderr,
-				message: "App name",
-				placeholder: "hello-world",
-				validate: (value) => !value?.trim() ? "App name is required" : void 0
-			}).then((value) => value.trim());
-		},
-		async selectRegion(_regions) {
-			return PREVIEW_DEFAULT_REGION;
-		}
-	};
-}
 //#endregion
-export { PREVIEW_DEFAULT_REGION, createPreviewDeployInteraction };
+export { PREVIEW_DEFAULT_REGION };

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

@@ -14,25 +14,11 @@ function createPreviewAppProvider(client, options) {
 				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, options) {
 			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, options) {
 					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,
@@ -213,6 +213,94 @@ function createPreviewAppProvider(client, options) {
 		}
 	};
 }
+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/client.js

@@ -1,5 +1,5 @@
-import os from "node:os";
 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_SERVICE_TOKEN";

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 };

package/dist/lib/project/resolution.js

@@ -1,33 +1,44 @@
 import { CliError } from "../../shell/errors.js";
 import { canPrompt } from "../../shell/runtime.js";
-import path from "node:path";
 import { readFile } from "node:fs/promises";
+import path from "node:path";
 //#region src/lib/project/resolution.ts
 async function resolveProjectTarget(options) {
 	const projects = await options.listProjects();
-	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit");
+	const inferredName = await inferTargetName(options.context.runtime.cwd);
+	if (options.explicitProject) return rememberIfRequested(options, resolveExplicitProject(options.explicitProject, projects, options.workspace), "explicit", {
+		targetName: options.explicitProject,
+		targetNameSource: "explicit"
+	});
 	const platformMapping = await resolveDurablePlatformMapping();
 	if (platformMapping) return rememberIfRequested(options, platformMapping, "platform-mapping");
-	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
 	let staleRemembered = false;
-	if (remembered) {
-		const matched = projects.find((project) => project.id === remembered.id);
-		if (matched) return rememberIfRequested(options, matched, "remembered-local");
-		staleRemembered = true;
+	if (!options.allowCreate) {
+		const rememberedResult = await resolveRememberedProject(options, projects);
+		if (rememberedResult.target) return rememberedResult.target;
+		staleRemembered = rememberedResult.stale;
 	}
-	const packageName = await readPackageName(options.context.runtime.cwd);
+	const packageName = inferredName.source === "package-name" ? inferredName.name : null;
 	if (packageName) {
 		const matches = projects.filter((project) => projectMatchesPackageName(project, packageName));
-		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name");
-		if (matches.length > 1) return resolveAmbiguousProject(options, matches, "package-name");
+		if (matches.length === 1) return rememberIfRequested(options, matches[0], "package-name", {
+			targetName: packageName,
+			targetNameSource: "package-name"
+		});
+		if (matches.length > 1) return resolveAmbiguousProject(options, matches, packageName, "package-name");
 	}
 	if (options.allowCreate && options.createProject) {
-		const inferredName = packageName ?? path.basename(options.context.runtime.cwd);
-		if (inferredName) {
-			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName));
-			if (existing.length === 1) return rememberIfRequested(options, existing[0], "package-name");
-			if (existing.length > 1) return resolveAmbiguousProject(options, existing, "package-name");
-			return rememberIfRequested(options, await options.createProject(inferredName), "created");
+		if (inferredName.name) {
+			const existing = projects.filter((project) => projectMatchesPackageName(project, inferredName.name));
+			if (existing.length === 1) return rememberIfRequested(options, existing[0], inferredName.source, {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
+			if (existing.length > 1) return resolveAmbiguousProject(options, existing, inferredName.name, inferredName.source);
+			return rememberIfRequested(options, await options.createProject(inferredName.name), "created", {
+				targetName: inferredName.name,
+				targetNameSource: inferredName.source
+			});
 		}
 	}
 	if (options.prompt && canPrompt(options.context) && projects.length > 0) return rememberIfRequested(options, await options.prompt.select({
@@ -40,6 +51,25 @@ async function resolveProjectTarget(options) {
 	if (staleRemembered && projects.length > 1) throw localStateStaleError();
 	throw projectUnresolvedError();
 }
+async function resolveRememberedProject(options, projects) {
+	const remembered = await options.context.stateStore.readRememberedProject(options.workspace.id);
+	if (!remembered) return {
+		target: null,
+		stale: false
+	};
+	const matched = projects.find((project) => project.id === remembered.id);
+	if (!matched) return {
+		target: null,
+		stale: true
+	};
+	return {
+		target: await rememberIfRequested(options, matched, "remembered-local", {
+			targetName: remembered.name,
+			targetNameSource: "remembered-local"
+		}),
+		stale: false
+	};
+}
 function projectNotFoundError(projectRef, workspace) {
 	return new CliError({
 		code: "PROJECT_NOT_FOUND",
@@ -104,6 +134,20 @@ async function readPackageName(cwd) {
 		throw error;
 	}
 }
+async function inferTargetName(cwd) {
+	const packageName = await readPackageName(cwd);
+	if (packageName && isValidInferredTargetName(packageName)) return {
+		name: packageName,
+		source: "package-name"
+	};
+	return {
+		name: path.basename(cwd),
+		source: "directory-name"
+	};
+}
+function isValidInferredTargetName(value) {
+	return /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(value);
+}
 function sortProjects(projects) {
 	return projects.slice().sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id));
 }
@@ -113,14 +157,17 @@ function resolveExplicitProject(projectRef, projects, workspace) {
 	if (matches.length > 1) throw projectAmbiguousError(projectRef, matches);
 	throw projectNotFoundError(projectRef, workspace);
 }
-function resolveAmbiguousProject(options, matches, projectRef) {
+function resolveAmbiguousProject(options, matches, projectRef, targetNameSource) {
 	if (options.prompt && canPrompt(options.context)) return options.prompt.select({
 		message: "Select a project",
 		choices: sortProjects(matches).map((project) => ({
 			label: `${project.name} (${project.id})`,
 			value: project
 		}))
-	}).then((selected) => rememberIfRequested(options, selected, "prompt"));
+	}).then((selected) => rememberIfRequested(options, selected, "prompt", {
+		targetName: projectRef,
+		targetNameSource
+	}));
 	throw projectAmbiguousError(projectRef, matches);
 }
 function projectMatchesPackageName(project, packageName) {
@@ -129,7 +176,7 @@ function projectMatchesPackageName(project, packageName) {
 async function resolveDurablePlatformMapping() {
 	return null;
 }
-async function rememberIfRequested(options, project, projectSource) {
+async function rememberIfRequested(options, project, projectSource, resolutionDetails) {
 	if (options.remember) await options.context.stateStore.setRememberedProject({
 		id: project.id,
 		name: project.name,
@@ -138,7 +185,10 @@ async function rememberIfRequested(options, project, projectSource) {
 	return {
 		workspace: options.workspace,
 		project: toProjectSummary(project),
-		resolution: { projectSource }
+		resolution: {
+			projectSource,
+			...resolutionDetails
+		}
 	};
 }
 function toProjectSummary(project) {
@@ -148,4 +198,4 @@ function toProjectSummary(project) {
 	};
 }
 //#endregion
-export { resolveProjectTarget, sortProjects };
+export { inferTargetName, projectNotFoundError, resolveProjectTarget, sortProjects };

package/dist/presenters/app.js

@@ -25,7 +25,7 @@ function serializeAppBuild(result) {
 	return result;
 }
 function renderAppDeploy(context, descriptor, result) {
-	return renderShow({
+	const lines = renderShow({
 		title: "Deploying the selected app.",
 		descriptor,
 		fields: [
@@ -61,9 +61,12 @@ function renderAppDeploy(context, descriptor, result) {
 			}] : []
 		]
 	}, context.ui);
+	if (result.localPin?.written) lines.push(`Bound this directory in ${result.localPin.path}. Subsequent commands target the same Project.`);
+	return lines;
 }
 function serializeAppDeploy(result) {
-	return result;
+	const { localPin: _localPin, ...serialized } = result;
+	return serialized;
 }
 function renderAppUpdateEnv(context, descriptor, result) {
 	return renderShow({

package/dist/presenters/project.js

@@ -105,9 +105,12 @@ function renderGitDisconnect(context, descriptor, result) {
 function formatProjectSource(source) {
 	switch (source) {
 		case "explicit": return "explicit";
+		case "env": return "environment";
+		case "local-pin": return "local pin";
 		case "platform-mapping": return "platform mapping";
 		case "remembered-local": return "remembered local context";
 		case "package-name": return "package name";
+		case "directory-name": return "directory name";
 		case "created": return "created";
 		case "prompt": return "prompt";
 	}

package/dist/shell/command-meta.js

@@ -60,7 +60,7 @@ const DESCRIPTORS = [
 		id: "app",
 		path: ["prisma", "app"],
 		description: "Manage apps and deployments for a project",
-		examples: ["prisma-cli app deploy", "prisma-cli app deploy --app hello-world --build-type nextjs --http-port 3000"]
+		examples: ["prisma-cli app deploy", "prisma-cli app deploy --app my-app --framework nextjs --http-port 3000"]
 	},
 	{
 		id: "branch",
@@ -182,9 +182,9 @@ const DESCRIPTORS = [
 		description: "Creates a new deployment for the app",
 		examples: [
 			"prisma-cli app deploy",
-			"prisma-cli app deploy --app hello-world --env DATABASE_URL=postgresql://example",
-			"prisma-cli app deploy --app hello-world --build-type nextjs --http-port 3000",
-			"prisma-cli app deploy --app hello-world --build-type nuxt"
+			"prisma-cli app deploy --app my-app --env DATABASE_URL=postgresql://example",
+			"prisma-cli app deploy --app my-app --framework nextjs --http-port 3000",
+			"prisma-cli app deploy --branch feat-login --framework hono"
 		]
 	},
 	{

package/dist/shell/prompt.js

@@ -1,5 +1,5 @@
 import { usageError } from "./errors.js";
-import { isCancel, select, text } from "@clack/prompts";
+import { confirm, isCancel, select, text } from "@clack/prompts";
 //#region src/shell/prompt.ts
 async function selectPrompt(options) {
 	const promptOptions = options.choices.map((choice) => ({
@@ -26,6 +26,16 @@ async function textPrompt(options) {
 	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a value was entered.", "Re-run the command and provide a value to continue.");
 	return response;
 }
+async function confirmPrompt(options) {
+	const response = await confirm({
+		input: options.input,
+		output: options.output,
+		message: options.message,
+		initialValue: options.initialValue ?? false
+	});
+	if (isCancel(response)) throw usageError("Interactive prompt canceled", "The command was canceled before a confirmation was made.", "Re-run the command and choose an option to continue.");
+	return response;
+}
 function disposePromptState(_input) {}
 //#endregion
-export { disposePromptState, selectPrompt, textPrompt };
+export { confirmPrompt, disposePromptState, selectPrompt, textPrompt };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prisma/cli",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.7",
   "description": "Preview of the unified Prisma CLI.",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@clack/prompts": "^1.2.0",
-    "@prisma/compute-sdk": "^0.17.0",
+    "@prisma/compute-sdk": "^0.18.0",
     "c12": "4.0.0-beta.4",
     "@prisma/credentials-store": "^7.7.0",
     "@prisma/management-api-sdk": "^1.27.0",