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

package/dist/lib/project/interactive-setup.js

@@ -0,0 +1,56 @@
+import { usageError } from "../../shell/errors.js";
+import { selectPrompt, textPrompt } from "../../shell/prompt.js";
+import { inferTargetName, sortProjects } from "./resolution.js";
+import { toProjectSummary, validateProjectSetupNameText } from "./setup.js";
+//#region src/lib/project/interactive-setup.ts
+async function promptForProjectSetupChoice(options) {
+	const sortedProjects = sortProjects(options.projects);
+	const projectNames = sortedProjects.map((project) => project.name);
+	const duplicateNames = new Set(projectNames.filter((name, index) => projectNames.indexOf(name) !== index));
+	const choice = await selectPrompt({
+		input: options.context.runtime.stdin,
+		output: options.context.runtime.stderr,
+		message: "Which Project should this directory use?",
+		choices: [
+			...sortedProjects.map((project) => ({
+				label: duplicateNames.has(project.name) ? `${project.name} (${project.id})` : project.name,
+				value: {
+					kind: "project",
+					project
+				}
+			})),
+			{
+				label: "Create a new Project",
+				value: { kind: "create" }
+			},
+			{
+				label: "Cancel",
+				value: { kind: "cancel" }
+			}
+		]
+	});
+	if (choice.kind === "cancel") throw usageError("Project setup canceled", options.cancel.why, options.cancel.fix, options.cancel.nextSteps, "project");
+	if (choice.kind === "project") return {
+		project: toProjectSummary(choice.project),
+		action: "linked",
+		targetName: choice.project.name,
+		targetNameSource: "prompt"
+	};
+	const suggestedName = await inferTargetName(options.context.runtime.cwd, options.context.runtime.signal);
+	const rawName = await textPrompt({
+		input: options.context.runtime.stdin,
+		output: options.context.runtime.stderr,
+		message: "Project name",
+		placeholder: suggestedName.name,
+		validate: (value) => validateProjectSetupNameText(value, suggestedName.name)
+	});
+	const projectName = rawName.trim() || suggestedName.name;
+	return {
+		project: toProjectSummary(await options.createProject(projectName)),
+		action: "created",
+		targetName: projectName,
+		targetNameSource: rawName.trim() ? "prompt" : suggestedName.source
+	};
+}
+//#endregion
+export { promptForProjectSetupChoice };

package/dist/lib/project/local-pin.js

@@ -1,44 +1,193 @@
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path from "node:path";
+import { Result, TaggedError, UnhandledException } from "better-result";
 //#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 {
+var LocalResolutionPinInvalidJsonError = class extends TaggedError("LocalResolutionPinInvalidJsonError")() {
+	constructor(cause) {
+		super({
+			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} contains invalid JSON.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinInvalidShapeError = class extends TaggedError("LocalResolutionPinInvalidShapeError")() {
+	constructor() {
+		super({
+			message: `${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} must contain workspaceId and projectId string fields only.`,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinReadAbortedError = class extends TaggedError("LocalResolutionPinReadAbortedError")() {
+	constructor(cause) {
+		super({
+			message: `Reading ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinSerializationError = class extends TaggedError("LocalResolutionPinSerializationError")() {
+	constructor(cause) {
+		super({
+			message: `Could not serialize ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinWriteAbortedError = class extends TaggedError("LocalResolutionPinWriteAbortedError")() {
+	constructor(cause) {
+		super({
+			message: `Writing ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH} was aborted.`,
+			cause,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinWriteFailedError = class extends TaggedError("LocalResolutionPinWriteFailedError")() {
+	constructor(operation, cause) {
+		super({
+			message: `Could not write ${LOCAL_RESOLUTION_PIN_RELATIVE_PATH}.`,
+			cause,
+			operation,
+			pinPath: LOCAL_RESOLUTION_PIN_RELATIVE_PATH
+		});
+	}
+};
+var LocalResolutionPinGitignoreUpdateAbortedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateAbortedError")() {
+	constructor(cause) {
+		super({
+			message: "Updating .gitignore for the local Project binding was aborted.",
+			cause,
+			gitignorePath: ".gitignore"
+		});
+	}
+};
+var LocalResolutionPinGitignoreUpdateFailedError = class extends TaggedError("LocalResolutionPinGitignoreUpdateFailedError")() {
+	constructor(operation, cause) {
+		super({
+			message: "Could not update .gitignore for the local Project binding.",
+			cause,
+			operation,
+			gitignorePath: ".gitignore"
+		});
+	}
+};
+async function readLocalResolutionPin(cwd, signal) {
+	return Result.gen(async function* () {
+		yield* ensureLocalResolutionPinReadNotAborted(signal);
+		const file = yield* Result.await(readLocalResolutionPinFile(cwd, signal));
+		if (file.kind === "missing") return Result.ok({ kind: "missing" });
+		const parsed = yield* parseLocalResolutionPin(file.raw);
+		if (!isLocalResolutionPin(parsed)) return Result.err(new LocalResolutionPinInvalidShapeError());
+		return Result.ok({
 			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) {
+		});
+	});
+}
+function ensureLocalResolutionPinReadNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinReadAbortedError(cause)
+	});
+}
+async function readLocalResolutionPinFile(cwd, signal) {
+	const readResult = await Result.tryPromise({
+		try: () => readFile(path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH), {
+			encoding: "utf8",
+			signal
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinReadAbortedError(cause) : new UnhandledException({ cause })
+	});
+	if (readResult.isErr()) {
+		if (readResult.error instanceof UnhandledException && readResult.error.cause.code === "ENOENT") return Result.ok({ kind: "missing" });
+		return Result.err(readResult.error);
+	}
+	return Result.ok({
+		kind: "present",
+		raw: readResult.value
+	});
+}
+function parseLocalResolutionPin(raw) {
+	return Result.try({
+		try: () => JSON.parse(raw),
+		catch: (cause) => cause instanceof SyntaxError ? new LocalResolutionPinInvalidJsonError(cause) : new UnhandledException({ cause })
+	});
+}
+async function writeLocalResolutionPin(cwd, pin, signal) {
+	return Result.gen(async function* () {
+		const prismaDir = path.join(cwd, ".prisma");
+		yield* ensureLocalResolutionPinWriteNotAborted(signal);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => mkdir(prismaDir, { recursive: true }), "create-directory", signal));
+		const pinPath = path.join(cwd, LOCAL_RESOLUTION_PIN_RELATIVE_PATH);
+		const tmpPath = path.join(prismaDir, `local.${process.pid}.${Date.now()}.tmp`);
+		const serialized = yield* serializeLocalResolutionPin(pin);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => writeFile(tmpPath, serialized, {
+			encoding: "utf8",
+			signal
+		}), "write-temp-file", signal));
+		yield* ensureLocalResolutionPinWriteNotAborted(signal);
+		yield* Result.await(writeLocalResolutionPinBoundary(() => rename(tmpPath, pinPath), "rename-temp-file", signal));
+		return Result.ok(void 0);
+	});
+}
+async function ensureLocalResolutionPinGitignore(cwd, signal) {
 	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");
+	const notAborted = ensureLocalResolutionPinGitignoreUpdateNotAborted(signal);
+	if (notAborted.isErr()) return Result.err(notAborted.error);
+	const existingResult = await Result.tryPromise({
+		try: () => readFile(gitignorePath, {
+			encoding: "utf8",
+			signal
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("read", cause)
+	});
+	if (existingResult.isErr()) if (existingResult.error instanceof LocalResolutionPinGitignoreUpdateFailedError && existingResult.error.cause.code === "ENOENT") existing = null;
+	else return Result.err(existingResult.error);
+	else existing = existingResult.value;
+	if (existing === null) return writeLocalResolutionPinGitignore(gitignorePath, ".prisma/\n", signal);
+	if (existing.split(/\r?\n/).map((line) => line.trim()).some((line) => line === ".prisma/" || line === ".prisma/local.json")) return Result.ok(void 0);
+	return writeLocalResolutionPinGitignore(gitignorePath, existing.endsWith("\n") ? `${existing}.prisma/\n` : `${existing}\n.prisma/\n`, signal);
+}
+function ensureLocalResolutionPinWriteNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinWriteAbortedError(cause)
+	});
+}
+function serializeLocalResolutionPin(pin) {
+	return Result.try({
+		try: () => `${JSON.stringify(pin, null, 2)}\n`,
+		catch: (cause) => new LocalResolutionPinSerializationError(cause)
+	});
+}
+function writeLocalResolutionPinBoundary(run, operation, signal) {
+	return Result.tryPromise({
+		try: async () => {
+			await run();
+		},
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinWriteAbortedError(cause) : new LocalResolutionPinWriteFailedError(operation, cause)
+	});
+}
+function ensureLocalResolutionPinGitignoreUpdateNotAborted(signal) {
+	return Result.try({
+		try: () => signal?.throwIfAborted(),
+		catch: (cause) => new LocalResolutionPinGitignoreUpdateAbortedError(cause)
+	});
+}
+function writeLocalResolutionPinGitignore(gitignorePath, contents, signal) {
+	return Result.tryPromise({
+		try: () => writeFile(gitignorePath, contents, {
+			encoding: "utf8",
+			signal
+		}),
+		catch: (cause) => signal?.aborted ? new LocalResolutionPinGitignoreUpdateAbortedError(cause) : new LocalResolutionPinGitignoreUpdateFailedError("write", cause)
+	});
 }
 function isLocalResolutionPin(value) {
 	if (!value || typeof value !== "object") return false;