neon 8.11.1 → 8.11.2

package/dist/_chunks/bucket-BCdryTkD.js

@@ -0,0 +1,409 @@
+import { t as __exportAll } from "./rolldown-runtime-8H4AJuhK.js";
+import { log } from "../log.js";
+import { isNeonApiError, retryOnLock } from "../api.js";
+import { createProjectBranchBucket, deleteProjectBranchBucket, deleteProjectBranchBucketObject, deleteProjectBranchBucketObjectsByPrefix, getProjectBranchBucketObject, listProjectBranchBucketObjects, listProjectBranchBuckets, presignUpload } from "../storage_api.js";
+import { writer } from "../writer.js";
+import { branchIdFromProps, fillSingleProject } from "../utils/enrichers.js";
+import { createReadStream, createWriteStream } from "node:fs";
+import { basename } from "node:path";
+import { stat, unlink } from "node:fs/promises";
+import { pipeline } from "node:stream/promises";
+//#region src/commands/bucket.ts
+var bucket_exports = /* @__PURE__ */ __exportAll({
+	aliases: () => aliases,
+	builder: () => builder,
+	command: () => command,
+	describe: () => describe,
+	handler: () => handler,
+	resolveListDelimiter: () => resolveListDelimiter,
+	splitBucketTarget: () => splitBucketTarget
+});
+const OBJECT_FIELDS = [
+	"key",
+	"size",
+	"last_modified",
+	"etag"
+];
+const BUCKET_FIELDS = ["name", "access_level"];
+const ACCESS_LEVELS = ["private", "public_read"];
+const MAX_OBJECT_BYTES = 104857600;
+const scopeOptions = {
+	"project-id": {
+		describe: "Project ID",
+		type: "string"
+	},
+	branch: {
+		describe: "Branch ID or name",
+		type: "string"
+	}
+};
+const splitBucketTarget = (target) => {
+	const slash = target.indexOf("/");
+	if (slash === -1) return {
+		bucket: target,
+		rest: ""
+	};
+	return {
+		bucket: target.slice(0, slash),
+		rest: target.slice(slash + 1)
+	};
+};
+const command = "buckets";
+const describe = "Manage branch object-storage buckets and their objects";
+const aliases = ["bucket"];
+const builder = (argv) => argv.usage("$0 bucket <sub-command> [options]").options({ "project-id": {
+	describe: "Project ID",
+	type: "string"
+} }).middleware(fillSingleProject).command("create <name>", "Create a bucket on a branch", (yargs) => yargs.usage("$0 bucket create <name> [options]").positional("name", {
+	describe: "The bucket name to create",
+	type: "string",
+	demandOption: true
+}).options({
+	...scopeOptions,
+	"access-level": {
+		describe: "The visibility of the bucket",
+		type: "string",
+		choices: ACCESS_LEVELS,
+		default: "private"
+	}
+}), (args) => createBucket(args)).command({
+	command: "list",
+	aliases: ["ls"],
+	describe: "List the buckets on a branch",
+	builder: (yargs) => yargs.usage("$0 bucket list [options]").options(scopeOptions),
+	handler: (args) => listBuckets(args)
+}).command({
+	command: "delete <name>",
+	aliases: ["rm"],
+	describe: "Delete a bucket from a branch",
+	builder: (yargs) => yargs.usage("$0 bucket delete <name> [options]").positional("name", {
+		describe: "The bucket name to delete",
+		type: "string",
+		demandOption: true
+	}).options(scopeOptions),
+	handler: (args) => deleteBucket(args)
+}).command("object", "List, download, upload or delete objects in a bucket", (yargs) => yargs.usage("$0 bucket object <sub-command> [options]").command({
+	command: "list <target>",
+	aliases: ["ls"],
+	describe: "List objects in a bucket. By default folders are collapsed (like \"aws s3 ls\"); pass --recursive for a flat listing of every key",
+	builder: (yargs) => yargs.usage("$0 bucket object list <bucket>[/<prefix>] [options]").positional("target", {
+		describe: "The bucket to list, optionally with a key prefix: <bucket>[/<prefix>]",
+		type: "string",
+		demandOption: true
+	}).options({
+		...scopeOptions,
+		recursive: {
+			describe: "List every key flat, descending into nested folders (no delimiter). Mutually exclusive with --delimiter. Mirrors \"aws s3 ls --recursive\"",
+			type: "boolean",
+			default: false
+		},
+		delimiter: {
+			describe: "Collapse keys sharing this prefix separator into folders. Defaults to \"/\" (folder view); ignored when --recursive is set",
+			type: "string"
+		},
+		cursor: {
+			describe: "Pagination cursor returned as next_cursor by a previous call",
+			type: "string"
+		},
+		limit: {
+			describe: "Maximum number of items (objects + folders) to return",
+			type: "number"
+		}
+	}),
+	handler: (args) => listObjects(args)
+}).command("get <target>", "Download an object from a bucket to a local file", (yargs) => yargs.usage("$0 bucket object get <bucket>/<key> [options]").positional("target", {
+	describe: "The object to download: <bucket>/<key>",
+	type: "string",
+	demandOption: true
+}).options({
+	...scopeOptions,
+	file: {
+		describe: "Path to write the downloaded object to (defaults to the object filename in the current directory)",
+		type: "string"
+	}
+}), (args) => getObject(args)).command("put <target>", "Upload a local file to a bucket as an object", (yargs) => yargs.usage("$0 bucket object put <bucket>/<key> [options]").positional("target", {
+	describe: "The object to upload to: <bucket>/<key>",
+	type: "string",
+	demandOption: true
+}).options({
+	...scopeOptions,
+	file: {
+		describe: "Path to the local file to upload",
+		type: "string",
+		demandOption: true
+	},
+	"content-type": {
+		describe: "Content-Type to store the object with (e.g. text/plain)",
+		type: "string"
+	}
+}), (args) => putObject(args)).command({
+	command: "delete <target>",
+	aliases: ["rm"],
+	describe: "Delete an object, or every object under a prefix",
+	builder: (yargs) => yargs.usage("$0 bucket object delete <bucket>/<key> [options]").positional("target", {
+		describe: "The object to delete: <bucket>/<key>, or <bucket>/<prefix>/ with --recursive",
+		type: "string",
+		demandOption: true
+	}).options({
+		...scopeOptions,
+		recursive: {
+			describe: "Delete every object under the given prefix. The prefix must end with \"/\"",
+			type: "boolean",
+			default: false
+		}
+	}),
+	handler: (args) => deleteObject(args)
+}).strictCommands());
+const handler = (args) => {
+	return args;
+};
+const createBucket = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const { data } = await retryOnLock(() => createProjectBranchBucket(props.apiClient, {
+		projectId: props.projectId,
+		branchId,
+		name: props.name,
+		accessLevel: props.accessLevel
+	}));
+	log.info(`Bucket "${data.bucket.name}" (${data.bucket.access_level}) created on branch ${branchId}`);
+};
+const listBuckets = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const { data } = await listProjectBranchBuckets(props.apiClient, {
+		projectId: props.projectId,
+		branchId
+	});
+	if (props.output === "json" || props.output === "yaml") {
+		writer(props).end(data.buckets, { fields: BUCKET_FIELDS });
+		return;
+	}
+	writer(props).end(data.buckets, {
+		fields: BUCKET_FIELDS,
+		title: "buckets",
+		emptyMessage: "No buckets found."
+	});
+};
+const deleteBucket = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	try {
+		await retryOnLock(() => deleteProjectBranchBucket(props.apiClient, {
+			projectId: props.projectId,
+			branchId,
+			bucketName: props.name
+		}));
+	} catch (err) {
+		if (isNeonApiError(err) && err.status === 404) throw new Error(`Bucket "${props.name}" not found on branch ${branchId}.`);
+		throw err;
+	}
+	log.info(`Bucket "${props.name}" deleted from branch ${branchId}`);
+};
+const resolveListDelimiter = (props) => {
+	if (props.recursive && props.delimiter !== void 0) throw new Error("--recursive and --delimiter cannot be used together. Use --recursive for a flat listing, or --delimiter to collapse on a separator.");
+	if (props.recursive) return;
+	if (props.delimiter !== void 0) return props.delimiter;
+	return "/";
+};
+const listObjects = async (props) => {
+	const delimiter = resolveListDelimiter(props);
+	const branchId = await branchIdFromProps(props);
+	const { bucket, rest } = splitBucketTarget(props.target);
+	const { data } = await listProjectBranchBucketObjects(props.apiClient, {
+		projectId: props.projectId,
+		branchId,
+		bucketName: bucket,
+		prefix: rest === "" ? void 0 : rest,
+		delimiter,
+		cursor: props.cursor,
+		limit: props.limit
+	});
+	if (props.output === "json" || props.output === "yaml") {
+		writer(props).end(data, { fields: [
+			"folders",
+			"objects",
+			"prefix",
+			"next_cursor",
+			"is_truncated"
+		] });
+		return;
+	}
+	const w = writer(props);
+	if (data.folders.length > 0) w.write(data.folders.map((name) => ({ name })), {
+		fields: ["name"],
+		title: "folders"
+	});
+	w.write(data.objects, {
+		fields: OBJECT_FIELDS,
+		title: "objects",
+		emptyMessage: "No objects found."
+	});
+	w.end();
+	if (data.is_truncated && data.next_cursor) log.info(`More results available. Re-run with --cursor ${data.next_cursor} to fetch the next page.`);
+};
+const filenameFromContentDisposition = (contentDisposition, key) => {
+	if (contentDisposition) {
+		const extended = /filename\*=(?:UTF-8'')?([^;]+)/i.exec(contentDisposition);
+		if (extended?.[1]) try {
+			return basename(decodeURIComponent(extended[1].trim()));
+		} catch {}
+		const plain = /filename="?([^";]+)"?/i.exec(contentDisposition);
+		if (plain?.[1]) return basename(plain[1].trim());
+	}
+	return basename(key) || key;
+};
+const serverErrorMessage = (body) => {
+	const message = body?.message;
+	return typeof message === "string" && message.trim() !== "" ? message : void 0;
+};
+const streamErrorMessage = async (stream) => {
+	if (typeof stream?.[Symbol.asyncIterator] !== "function") return;
+	try {
+		const chunks = [];
+		for await (const chunk of stream) chunks.push(Buffer.from(chunk));
+		return serverErrorMessage(JSON.parse(Buffer.concat(chunks).toString()));
+	} catch {
+		return;
+	}
+};
+const objectNotFoundFallback = (key, bucket, branchId) => `Object "${key}" not found in bucket "${bucket}" on branch ${branchId}.`;
+const objectNotFoundMessage = (err, key, bucket, branchId) => {
+	if (isNeonApiError(err)) {
+		const serverMessage = serverErrorMessage(err.data);
+		if (serverMessage !== void 0) return serverMessage;
+	}
+	return objectNotFoundFallback(key, bucket, branchId);
+};
+const fileToWebStream = (path) => {
+	const source = createReadStream(path);
+	return new ReadableStream({
+		start(controller) {
+			source.on("data", (chunk) => {
+				const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : new Uint8Array(chunk);
+				controller.enqueue(bytes);
+				if ((controller.desiredSize ?? 0) <= 0) source.pause();
+			});
+			source.on("end", () => {
+				controller.close();
+			});
+			source.on("error", (err) => {
+				controller.error(err instanceof Error ? err : new Error(String(err)));
+			});
+		},
+		pull() {
+			source.resume();
+		},
+		cancel() {
+			source.destroy();
+		}
+	});
+};
+const getObject = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const { bucket, rest: key } = splitBucketTarget(props.target);
+	if (key === "") throw new Error("Object target must be in the form <bucket>/<key>.");
+	let response;
+	try {
+		response = await getProjectBranchBucketObject(props.apiClient, {
+			projectId: props.projectId,
+			branchId,
+			bucketName: bucket,
+			objectKey: key
+		});
+	} catch (err) {
+		if (isNeonApiError(err) && err.status === 404) {
+			const serverMessage = await streamErrorMessage(err.data);
+			throw new Error(serverMessage ?? objectNotFoundFallback(key, bucket, branchId));
+		}
+		throw err;
+	}
+	const contentDisposition = response.headers["content-disposition"];
+	const destination = props.file ?? filenameFromContentDisposition(contentDisposition, key);
+	try {
+		await pipeline(response.data, createWriteStream(destination));
+	} catch (err) {
+		await unlink(destination).catch(() => void 0);
+		throw err;
+	}
+	log.info(`Object "${key}" downloaded from bucket "${bucket}" on branch ${branchId} to ${destination}`);
+};
+const putObject = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const { bucket, rest: key } = splitBucketTarget(props.target);
+	if (bucket === "" || key === "") throw new Error("Object target must be in the form <bucket>/<key>.");
+	let fileSize;
+	try {
+		const fileStat = await stat(props.file);
+		if (!fileStat.isFile()) throw new Error(`"${props.file}" is not a regular file.`);
+		fileSize = fileStat.size;
+	} catch (err) {
+		if (err?.code === "ENOENT") throw new Error(`File "${props.file}" does not exist.`);
+		throw err;
+	}
+	if (fileSize > MAX_OBJECT_BYTES) throw new Error(`File "${props.file}" is ${fileSize} bytes, which exceeds the ${MAX_OBJECT_BYTES}-byte (100 MB) single-upload limit. Larger objects are not supported yet.`);
+	let presign;
+	try {
+		({data: presign} = await presignUpload(props.apiClient, {
+			projectId: props.projectId,
+			branchId,
+			bucketName: bucket,
+			objectKey: key,
+			contentType: props.contentType
+		}));
+	} catch (err) {
+		if (isNeonApiError(err)) {
+			const status = err.status;
+			if (status === 404) throw new Error(objectNotFoundMessage(err, key, bucket, branchId));
+			const serverMessage = serverErrorMessage(err.data);
+			throw new Error(serverMessage ?? `Failed to presign upload for "${key}" in bucket "${bucket}" on branch ${branchId}${status !== void 0 ? ` (HTTP ${status})` : ""}: ${err.message}`);
+		}
+		throw err;
+	}
+	const upload = {
+		method: "PUT",
+		headers: {
+			...presign.headers,
+			"Content-Length": String(fileSize)
+		},
+		body: fileToWebStream(props.file),
+		redirect: "error",
+		duplex: "half"
+	};
+	let uploadResponse;
+	try {
+		uploadResponse = await fetch(presign.url, upload);
+	} catch (err) {
+		throw new Error(`Failed to upload "${props.file}" to "${key}" in bucket "${bucket}" on branch ${branchId}: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!uploadResponse.ok) throw new Error(`Failed to upload "${props.file}" to "${key}" in bucket "${bucket}" on branch ${branchId} (HTTP ${uploadResponse.status}): Request failed with status code ${uploadResponse.status}`);
+	log.info(`File "${props.file}" uploaded to "${key}" in bucket "${bucket}" on branch ${branchId}`);
+};
+const deleteObject = async (props) => {
+	const branchId = await branchIdFromProps(props);
+	const { bucket, rest } = splitBucketTarget(props.target);
+	if (props.recursive) {
+		if (rest === "") throw new Error("Recursive delete requires a non-empty prefix ending in \"/\".");
+		if (!rest.endsWith("/")) throw new Error(`Recursive delete requires a prefix ending in "/" (got "${rest}").`);
+		const { data } = await retryOnLock(() => deleteProjectBranchBucketObjectsByPrefix(props.apiClient, {
+			projectId: props.projectId,
+			branchId,
+			bucketName: bucket,
+			prefix: rest
+		}));
+		log.info(`Deleted ${data.deleted} object(s) under prefix "${rest}" from bucket "${bucket}" on branch ${branchId}`);
+		return;
+	}
+	if (rest === "") throw new Error("Object target must be in the form <bucket>/<key>.");
+	try {
+		await retryOnLock(() => deleteProjectBranchBucketObject(props.apiClient, {
+			projectId: props.projectId,
+			branchId,
+			bucketName: bucket,
+			objectKey: rest
+		}));
+	} catch (err) {
+		if (isNeonApiError(err) && err.status === 404) throw new Error(objectNotFoundMessage(err, rest, bucket, branchId));
+		throw err;
+	}
+	log.info(`Object "${rest}" deleted from bucket "${bucket}" on branch ${branchId}`);
+};
+//#endregion
+export { describe as a, splitBucketTarget as c, command as i, bucket_exports as n, handler as o, builder as r, resolveListDelimiter as s, aliases as t };