@prisma/cli 3.0.0-beta.3 → 3.0.0-beta.30

package/dist/controllers/bucket.js

@@ -0,0 +1,278 @@
+import { CliError, authRequiredError, workspaceRequiredError } from "../shell/errors.js";
+import { projectResolutionErrorToCliError, resolveProjectTarget } from "../lib/project/resolution.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+import { requireAuthenticatedAuthState } from "./auth.js";
+import { listFixtureWorkspaceProjects, listRealWorkspaceProjects } from "./project.js";
+import { createManagementBucketProvider, normalizeBucket, normalizeKey } from "../lib/bucket/provider.js";
+//#region src/controllers/bucket.ts
+function isRealMode(context) {
+	return !context.runtime.fixturePath && !context.runtime.env.PRISMA_CLI_MOCK_FIXTURE_PATH;
+}
+async function runBucketList(context, flags) {
+	const { provider, target } = await requireBucketContext(context, flags, "bucket list");
+	const buckets = await provider.listBuckets({
+		projectId: target.project.id,
+		branchName: flags.branchName,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "bucket.list",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			branchName: flags.branchName ?? null,
+			verboseContext: target,
+			buckets
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runBucketCreate(context, flags) {
+	const { provider, target } = await requireBucketContext(context, flags, "bucket create");
+	const bucket = await provider.createBucket({
+		projectId: target.project.id,
+		name: flags.name?.trim() || void 0,
+		branchGitName: flags.branchName,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "bucket.create",
+		result: {
+			projectId: target.project.id,
+			projectName: target.project.name,
+			verboseContext: target,
+			bucket
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runBucketDelete(context, bucketId, flags) {
+	const id = bucketId.trim();
+	if (!id) throw new CliError({
+		code: "USAGE_ERROR",
+		domain: "bucket",
+		summary: "Bucket id required",
+		why: "Bucket deletion needs a bucket id.",
+		fix: "Pass the bucket id to delete.",
+		exitCode: 2,
+		nextSteps: ["prisma-cli bucket list"]
+	});
+	if (flags.confirm !== id) throw new CliError({
+		code: "CONFIRMATION_REQUIRED",
+		domain: "bucket",
+		summary: "Confirm bucket deletion",
+		why: "Deleting this bucket permanently removes all objects and access keys.",
+		fix: `Rerun with --confirm ${id}.`,
+		exitCode: 2,
+		nextSteps: [`prisma-cli bucket delete ${id} --confirm ${id}`],
+		meta: {
+			expectedConfirm: id,
+			receivedConfirm: flags.confirm ?? null
+		}
+	});
+	await (await requireBucketProviderOnly(context)).deleteBucket(id, { signal: context.runtime.signal });
+	return {
+		command: "bucket.delete",
+		result: { bucket: { id } },
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runBucketKeyList(context, bucketId) {
+	const id = bucketId.trim();
+	if (!id) throw new CliError({
+		code: "USAGE_ERROR",
+		domain: "bucket",
+		summary: "Bucket id required",
+		why: "Bucket key listing needs a bucket id.",
+		fix: "Pass the bucket id.",
+		exitCode: 2,
+		nextSteps: ["prisma-cli bucket list"]
+	});
+	return {
+		command: "bucket.key.list",
+		result: {
+			bucketId: id,
+			keys: await (await requireBucketProviderOnly(context)).listKeys(id, { signal: context.runtime.signal })
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runBucketKeyCreate(context, bucketId, flags) {
+	const id = bucketId.trim();
+	if (!id) throw new CliError({
+		code: "USAGE_ERROR",
+		domain: "bucket",
+		summary: "Bucket id required",
+		why: "Bucket key creation needs a bucket id.",
+		fix: "Pass the bucket id.",
+		exitCode: 2,
+		nextSteps: ["prisma-cli bucket list"]
+	});
+	const role = resolveKeyRole(flags.role);
+	const created = await (await requireBucketProviderOnly(context)).createKey({
+		bucketId: id,
+		name: flags.name?.trim() || void 0,
+		role,
+		signal: context.runtime.signal
+	});
+	return {
+		command: "bucket.key.create",
+		result: {
+			bucketId: id,
+			key: created.key,
+			secretAccessKey: created.secretAccessKey,
+			accessKeyId: created.accessKeyId,
+			endpoint: created.endpoint,
+			bucketName: created.bucketName
+		},
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function runBucketKeyDelete(context, bucketId, keyId) {
+	const bktId = bucketId.trim();
+	const kId = keyId.trim();
+	if (!bktId || !kId) throw new CliError({
+		code: "USAGE_ERROR",
+		domain: "bucket",
+		summary: "Bucket id and key id required",
+		why: "Bucket key deletion needs both a bucket id and a key id.",
+		fix: "Pass the bucket id and key id.",
+		exitCode: 2,
+		nextSteps: ["prisma-cli bucket key list <bucketId>"]
+	});
+	await (await requireBucketProviderOnly(context)).deleteKey(bktId, kId, { signal: context.runtime.signal });
+	return {
+		command: "bucket.key.delete",
+		result: { key: { id: kId } },
+		warnings: [],
+		nextSteps: []
+	};
+}
+async function resolveBucketProvider(context) {
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+		if (!client) throw authRequiredError();
+		return createManagementBucketProvider(client);
+	}
+	return createFixtureBucketProvider(context);
+}
+async function requireBucketContext(context, flags, commandName) {
+	const workspace = (await requireAuthenticatedAuthState(context)).workspace;
+	if (!workspace) throw workspaceRequiredError();
+	if (isRealMode(context)) {
+		const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+		if (!client) throw authRequiredError();
+		const targetResult = await resolveProjectTarget({
+			context,
+			workspace,
+			explicitProject: flags.projectRef,
+			listProjects: () => listRealWorkspaceProjects(client, workspace, context.runtime.signal),
+			commandName
+		});
+		if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+		return {
+			provider: createManagementBucketProvider(client),
+			target: targetResult.value
+		};
+	}
+	const targetResult = await resolveProjectTarget({
+		context,
+		workspace,
+		explicitProject: flags.projectRef,
+		listProjects: async () => listFixtureWorkspaceProjects(context, workspace),
+		commandName
+	});
+	if (targetResult.isErr()) throw projectResolutionErrorToCliError(targetResult.error);
+	return {
+		provider: createFixtureBucketProvider(context),
+		target: targetResult.value
+	};
+}
+async function requireBucketProviderOnly(context) {
+	await requireAuthenticatedAuthState(context);
+	return resolveBucketProvider(context);
+}
+function createFixtureBucketProvider(context) {
+	return {
+		async listBuckets(options) {
+			return context.api.listBucketsForProject(options.projectId, options.branchName).map((bucket) => normalizeBucket(bucket));
+		},
+		async createBucket(options) {
+			const created = context.api.createBucket({
+				projectId: options.projectId,
+				name: options.name,
+				branchGitName: options.branchGitName
+			});
+			if (!created) throw branchNotFoundError(options.branchGitName ?? "");
+			return normalizeBucket(created);
+		},
+		async deleteBucket(bucketId) {
+			if (!context.api.deleteBucket(bucketId)) throw bucketNotFoundError(bucketId);
+		},
+		async listKeys(bucketId) {
+			if (!context.api.getBucket(bucketId)) throw bucketNotFoundError(bucketId);
+			return context.api.listBucketKeys(bucketId).map((key) => normalizeKey(key));
+		},
+		async createKey(options) {
+			const created = context.api.createBucketKey({
+				bucketId: options.bucketId,
+				name: options.name,
+				role: options.role
+			});
+			if (!created) throw bucketNotFoundError(options.bucketId);
+			return {
+				key: normalizeKey(created.key),
+				secretAccessKey: created.secretAccessKey,
+				accessKeyId: created.accessKeyId,
+				endpoint: created.endpoint,
+				bucketName: created.bucketName
+			};
+		},
+		async deleteKey(bucketId, keyId) {
+			if (!context.api.deleteBucketKey(bucketId, keyId)) throw keyNotFoundError(keyId, bucketId);
+		}
+	};
+}
+function resolveKeyRole(role) {
+	return role === "read" ? "read" : "read_write";
+}
+function branchNotFoundError(branchGitName) {
+	return new CliError({
+		code: "BRANCH_NOT_FOUND",
+		domain: "bucket",
+		summary: "Branch not found",
+		why: `No branch matched "${branchGitName}" in the resolved project.`,
+		fix: "Pass a branch git name from prisma-cli branch list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli branch list"]
+	});
+}
+function bucketNotFoundError(bucketId) {
+	return new CliError({
+		code: "BUCKET_NOT_FOUND",
+		domain: "bucket",
+		summary: "Bucket not found",
+		why: `No bucket matched "${bucketId}".`,
+		fix: "Pass a bucket id from prisma-cli bucket list.",
+		exitCode: 1,
+		nextSteps: ["prisma-cli bucket list"]
+	});
+}
+function keyNotFoundError(keyId, bucketId) {
+	return new CliError({
+		code: "BUCKET_KEY_NOT_FOUND",
+		domain: "bucket",
+		summary: "Bucket key not found",
+		why: `No key matched "${keyId}" for bucket "${bucketId}".`,
+		fix: "Pass a key id from prisma-cli bucket key list <bucketId>.",
+		exitCode: 1,
+		nextSteps: [`prisma-cli bucket key list ${bucketId}`]
+	});
+}
+//#endregion
+export { runBucketCreate, runBucketDelete, runBucketKeyCreate, runBucketKeyDelete, runBucketKeyList, runBucketList };

package/dist/controllers/build.js

@@ -0,0 +1,88 @@
+import { CliError, authRequiredError } from "../shell/errors.js";
+import { writeJsonEvent } from "../shell/output.js";
+import { requireComputeAuth } from "../lib/auth/guard.js";
+//#region src/controllers/build.ts
+async function runBuildLogs(context, buildId, options = {}) {
+	const client = await requireComputeAuth(context.runtime.env, context.runtime.signal);
+	if (!client) throw authRequiredError(["prisma-cli auth login"]);
+	if (!context.flags.json && !context.flags.quiet) context.output.stderr.write(`build logs → Streaming logs for build ${buildId}\n\n`);
+	const { data, response } = await client.GET("/v1/builds/{buildId}/logs", {
+		params: {
+			path: { buildId },
+			query: {
+				...options.follow ? { follow: "true" } : {},
+				...options.cursor ? { cursor: options.cursor } : {}
+			}
+		},
+		parseAs: "stream",
+		signal: context.runtime.signal
+	});
+	const body = data;
+	if (!response.ok || !body) throw buildLogsRequestError(buildId, response.status);
+	let sawError = false;
+	await forEachNdjsonRecord(body, (record) => {
+		if (record.type === "terminal" && record.kind === "error") sawError = true;
+		writeBuildLogRecord(context, record);
+	});
+	if (sawError) process.exitCode = 1;
+}
+function writeBuildLogRecord(context, record) {
+	if (context.flags.json) {
+		writeJsonEvent(context.output, {
+			type: record.type,
+			command: "build.logs",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+			data: record
+		});
+		return;
+	}
+	if (record.type === "log") {
+		const stream = record.source === "stderr" || record.level === "error" ? context.output.stderr : context.output.stdout;
+		stream.write(record.text);
+		if (!record.text.endsWith("\n")) stream.write("\n");
+		return;
+	}
+	if (record.code !== "end") context.output.stderr.write(`${record.message}\n`);
+}
+/** Reads a newline-delimited JSON body line by line, parsing each into a record. */
+async function forEachNdjsonRecord(body, onRecord) {
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
+	for (;;) {
+		const { done, value } = await reader.read();
+		if (value) buffer += decoder.decode(value, { stream: true });
+		let newlineIndex = buffer.indexOf("\n");
+		while (newlineIndex !== -1) {
+			const line = buffer.slice(0, newlineIndex).trim();
+			buffer = buffer.slice(newlineIndex + 1);
+			if (line) onRecord(JSON.parse(line));
+			newlineIndex = buffer.indexOf("\n");
+		}
+		if (done) {
+			const tail = buffer.trim();
+			if (tail) onRecord(JSON.parse(tail));
+			return;
+		}
+	}
+}
+function buildLogsRequestError(buildId, status) {
+	if (status === 404) return new CliError({
+		code: "BUILD_NOT_FOUND",
+		domain: "app",
+		summary: `Build ${buildId} was not found`,
+		why: "The build does not exist, or your workspace does not have access to it.",
+		fix: "Check the build id, or run prisma-cli auth login to switch to the workspace that owns it.",
+		exitCode: 1
+	});
+	return new CliError({
+		code: "BUILD_LOGS_FAILED",
+		domain: "app",
+		summary: `Failed to read logs for build ${buildId}`,
+		why: `The Management API returned HTTP ${status}.`,
+		fix: "Retry the command, or rerun with --trace for more detail.",
+		exitCode: 1
+	});
+}
+//#endregion
+export { runBuildLogs };