neon 3.0.0 → 3.1.0

package/dist/storage_api.js

@@ -1,147 +1,133 @@
-// Typed client helpers for the branch object-storage (bucket/object) API.
-//
-// These endpoints are part of the Neon object-storage surface (the "Buckets"
-// tag in the public API). They are not yet exposed as typed methods on
-// `@neon/sdk`, so the request/response types and the thin call helpers live
-// here. They are implemented on top of the API client's low-level `request()`
-// method, which reuses the exact same authentication, base URL, headers and
-// retry behaviour as every other neonctl command. When the SDK gains these
-// methods, the call sites in `src/commands/bucket.ts` can switch over with no
-// behavioural change.
+//#region src/storage_api.ts
 const bucketsPath = (projectId, branchId) => `/projects/${encodeURIComponent(projectId)}/branches/${encodeURIComponent(branchId)}/buckets`;
 const bucketPath = (projectId, branchId, bucketName) => `${bucketsPath(projectId, branchId)}/${encodeURIComponent(bucketName)}`;
 /**
- * Create a bucket on a branch.
- *
- * @request POST /projects/{project_id}/branches/{branch_id}/buckets
- */
-export const createProjectBranchBucket = (apiClient, { projectId, branchId, name, accessLevel, }) => {
-    const body = { name };
-    // Omit access_level entirely so the server default (`private`) applies.
-    if (accessLevel !== undefined) {
-        body.access_level = accessLevel;
-    }
-    return apiClient.request({
-        path: bucketsPath(projectId, branchId),
-        method: "POST",
-        body,
-        format: "json",
-        secure: true,
-    });
+* Create a bucket on a branch.
+*
+* @request POST /projects/{project_id}/branches/{branch_id}/buckets
+*/
+const createProjectBranchBucket = (apiClient, { projectId, branchId, name, accessLevel }) => {
+	const body = { name };
+	if (accessLevel !== void 0) body.access_level = accessLevel;
+	return apiClient.request({
+		path: bucketsPath(projectId, branchId),
+		method: "POST",
+		body,
+		format: "json",
+		secure: true
+	});
 };
 /**
- * List the buckets on a branch.
- *
- * @request GET /projects/{project_id}/branches/{branch_id}/buckets
- */
-export const listProjectBranchBuckets = (apiClient, { projectId, branchId }) => apiClient.request({
-    path: bucketsPath(projectId, branchId),
-    method: "GET",
-    format: "json",
-    secure: true,
+* List the buckets on a branch.
+*
+* @request GET /projects/{project_id}/branches/{branch_id}/buckets
+*/
+const listProjectBranchBuckets = (apiClient, { projectId, branchId }) => apiClient.request({
+	path: bucketsPath(projectId, branchId),
+	method: "GET",
+	format: "json",
+	secure: true
 });
 /**
- * Delete a bucket from a branch.
- *
- * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}
- */
-export const deleteProjectBranchBucket = (apiClient, { projectId, branchId, bucketName, }) => apiClient.request({
-    path: bucketPath(projectId, branchId, bucketName),
-    method: "DELETE",
-    secure: true,
+* Delete a bucket from a branch.
+*
+* @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}
+*/
+const deleteProjectBranchBucket = (apiClient, { projectId, branchId, bucketName }) => apiClient.request({
+	path: bucketPath(projectId, branchId, bucketName),
+	method: "DELETE",
+	secure: true
 });
 /**
- * List objects (and collapsed folders) in a bucket on a branch.
- *
- * @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects
- */
-export const listProjectBranchBucketObjects = (apiClient, { projectId, branchId, bucketName, ...query }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects`,
-    method: "GET",
-    query,
-    format: "json",
-    secure: true,
+* List objects (and collapsed folders) in a bucket on a branch.
+*
+* @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects
+*/
+const listProjectBranchBucketObjects = (apiClient, { projectId, branchId, bucketName, ...query }) => apiClient.request({
+	path: `${bucketPath(projectId, branchId, bucketName)}/objects`,
+	method: "GET",
+	query,
+	format: "json",
+	secure: true
 });
 /**
- * Download an object's raw bytes from a bucket on a branch.
- *
- * The server returns the body as `application/octet-stream` with a
- * `Content-Disposition: attachment` header; the helper requests the body as a
- * stream (`responseType: 'stream'`), so `.data` is a Node `Readable` the caller
- * can pipe straight to disk without buffering the whole object in memory. The
- * response headers are returned alongside so the caller can derive a filename
- * from `Content-Disposition`.
- *
- * The object key may contain `/`; it is percent-encoded into a single path
- * segment so nested keys are routed to the `{object_key}` parameter.
- *
- * @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/download
- */
-export const getProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey, }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/download`,
-    method: "GET",
-    format: "stream",
-    secure: true,
+* Download an object's raw bytes from a bucket on a branch.
+*
+* The server returns the body as `application/octet-stream` with a
+* `Content-Disposition: attachment` header; the helper requests the body as a
+* stream (`responseType: 'stream'`), so `.data` is a Node `Readable` the caller
+* can pipe straight to disk without buffering the whole object in memory. The
+* response headers are returned alongside so the caller can derive a filename
+* from `Content-Disposition`.
+*
+* The object key may contain `/`; it is percent-encoded into a single path
+* segment so nested keys are routed to the `{object_key}` parameter.
+*
+* @request GET /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/download
+*/
+const getProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey }) => apiClient.request({
+	path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/download`,
+	method: "GET",
+	format: "stream",
+	secure: true
 });
 /**
- * Delete an object from a bucket on a branch.
- *
- * The object key may contain `/`; it is percent-encoded into a single path
- * segment so nested keys are routed to the `{object_key}` parameter.
- *
- * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}
- */
-export const deleteProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey, }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}`,
-    method: "DELETE",
-    secure: true,
+* Delete an object from a bucket on a branch.
+*
+* The object key may contain `/`; it is percent-encoded into a single path
+* segment so nested keys are routed to the `{object_key}` parameter.
+*
+* @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}
+*/
+const deleteProjectBranchBucketObject = (apiClient, { projectId, branchId, bucketName, objectKey }) => apiClient.request({
+	path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}`,
+	method: "DELETE",
+	secure: true
 });
 /**
- * Delete every object under a key prefix (folder) in a bucket on a branch.
- *
- * `prefix` must be non-empty and end with `/`; every object on this branch
- * whose key starts with the prefix is soft-deleted in a single call.
- *
- * @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects-by-prefix
- */
-export const deleteProjectBranchBucketObjectsByPrefix = (apiClient, { projectId, branchId, bucketName, prefix, }) => apiClient.request({
-    path: `${bucketPath(projectId, branchId, bucketName)}/objects-by-prefix`,
-    method: "DELETE",
-    query: { prefix },
-    format: "json",
-    secure: true,
+* Delete every object under a key prefix (folder) in a bucket on a branch.
+*
+* `prefix` must be non-empty and end with `/`; every object on this branch
+* whose key starts with the prefix is soft-deleted in a single call.
+*
+* @request DELETE /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects-by-prefix
+*/
+const deleteProjectBranchBucketObjectsByPrefix = (apiClient, { projectId, branchId, bucketName, prefix }) => apiClient.request({
+	path: `${bucketPath(projectId, branchId, bucketName)}/objects-by-prefix`,
+	method: "DELETE",
+	query: { prefix },
+	format: "json",
+	secure: true
 });
 /**
- * Request a presigned PUT URL for uploading an object to a bucket on a branch.
- *
- * Returns the URL, the headers that must accompany the PUT for the signature to
- * verify, and the expiry. The actual upload (a `PUT` to the returned `url` with
- * the returned `headers` and the file stream) is performed by the caller, NOT
- * through this api-client, since it targets the branch S3 data-plane endpoint
- * rather than the console API. No SigV4 or credential handling happens here.
- *
- * The object key may contain `/`; it is percent-encoded into a single path
- * segment so nested keys are routed to the `{object_key}` parameter.
- *
- * This targets the unified presign endpoint, passing `operation: "upload"` to
- * request a presigned PUT. (The same endpoint also serves `download`, but that
- * path is API-only and has no neonctl command.)
- *
- * @request POST /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/presign
- */
-export const presignUpload = (apiClient, { projectId, branchId, bucketName, objectKey, contentType, expiresInSeconds, }) => {
-    const body = { operation: "upload" };
-    if (contentType !== undefined) {
-        body.content_type = contentType;
-    }
-    if (expiresInSeconds !== undefined) {
-        body.expires_in_seconds = expiresInSeconds;
-    }
-    return apiClient.request({
-        path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/presign`,
-        method: "POST",
-        body,
-        format: "json",
-        secure: true,
-    });
+* Request a presigned PUT URL for uploading an object to a bucket on a branch.
+*
+* Returns the URL, the headers that must accompany the PUT for the signature to
+* verify, and the expiry. The actual upload (a `PUT` to the returned `url` with
+* the returned `headers` and the file stream) is performed by the caller, NOT
+* through this api-client, since it targets the branch S3 data-plane endpoint
+* rather than the console API. No SigV4 or credential handling happens here.
+*
+* The object key may contain `/`; it is percent-encoded into a single path
+* segment so nested keys are routed to the `{object_key}` parameter.
+*
+* This targets the unified presign endpoint, passing `operation: "upload"` to
+* request a presigned PUT. (The same endpoint also serves `download`, but that
+* path is API-only and has no neonctl command.)
+*
+* @request POST /projects/{project_id}/branches/{branch_id}/buckets/{bucket_name}/objects/{object_key}/presign
+*/
+const presignUpload = (apiClient, { projectId, branchId, bucketName, objectKey, contentType, expiresInSeconds }) => {
+	const body = { operation: "upload" };
+	if (contentType !== void 0) body.content_type = contentType;
+	if (expiresInSeconds !== void 0) body.expires_in_seconds = expiresInSeconds;
+	return apiClient.request({
+		path: `${bucketPath(projectId, branchId, bucketName)}/objects/${encodeURIComponent(objectKey)}/presign`,
+		method: "POST",
+		body,
+		format: "json",
+		secure: true
+	});
 };
+//#endregion
+export { createProjectBranchBucket, deleteProjectBranchBucket, deleteProjectBranchBucketObject, deleteProjectBranchBucketObjectsByPrefix, getProjectBranchBucketObject, listProjectBranchBucketObjects, listProjectBranchBuckets, presignUpload };

package/dist/test_utils/fixtures.js

@@ -1,121 +1,102 @@
-import { fork } from "node:child_process";
-import { createServer } from "node:http";
+import { log } from "../log.js";
 import { join } from "node:path";
+import { createServer } from "node:http";
+import { fork } from "node:child_process";
 import emocks from "emocks";
 import express from "express";
 import strip from "strip-ansi";
-import { expect, test as originalTest } from "vitest";
-import { log } from "../log";
+import { expect, test as test$1 } from "vitest";
+//#region src/test_utils/fixtures.ts
 /**
- * Reserve a localhost port and close its listener, returning a URL that is guaranteed to
- * refuse connections right now. Lets a test drive the CLI into a real `ECONNREFUSED`
- * (the same shape a network blip produces) deterministically and fast.
- */
+* Reserve a localhost port and close its listener, returning a URL that is guaranteed to
+* refuse connections right now. Lets a test drive the CLI into a real `ECONNREFUSED`
+* (the same shape a network blip produces) deterministically and fast.
+*/
 const reserveClosedPort = () => new Promise((resolve, reject) => {
-    const probe = createServer();
-    probe.on("error", reject);
-    probe.listen(0, "127.0.0.1", () => {
-        const { port } = probe.address();
-        probe.close((err) => {
-            if (err) {
-                reject(err);
-            }
-            else {
-                resolve(`http://127.0.0.1:${port}`);
-            }
-        });
-    });
+	const probe = createServer();
+	probe.on("error", reject);
+	probe.listen(0, "127.0.0.1", () => {
+		const { port } = probe.address();
+		probe.close((err) => {
+			if (err) reject(err);
+			else resolve(`http://127.0.0.1:${port}`);
+		});
+	});
 });
-export const test = originalTest.extend({
-    runMockServer: async ({}, use) => {
-        let startedServer;
-        await use(async (mockDir) => {
-            const app = express();
-            app.use(express.json());
-            app.use("/", emocks(join(process.cwd(), "mocks", mockDir), {
-                "404": (_req, res) => res.status(404).send({ message: "Not Found" }),
-            }));
-            const server = await new Promise((resolve) => {
-                const s = app.listen(0, () => {
-                    log.debug("Mock server listening at %d", s.address().port);
-                    resolve(s);
-                });
-            });
-            startedServer = server;
-            return server;
-        });
-        // `unreachableHost` tests never start the server, so only close it when it ran.
-        const server = startedServer;
-        if (server) {
-            await new Promise((resolve, reject) => {
-                server.close((err) => {
-                    if (err) {
-                        reject(err instanceof Error ? err : new Error(String(err)));
-                    }
-                    else {
-                        resolve();
-                    }
-                });
-            });
-        }
-    },
-    testCliCommand: async ({ runMockServer }, use) => {
-        await use(async (args, options = {}) => {
-            const apiHost = options.unreachableHost
-                ? await reserveClosedPort()
-                : `http://localhost:${(await runMockServer(options.mockDir || "main")).address().port}`;
-            let output = "";
-            let error = "";
-            const cp = fork(join(process.cwd(), "./dist/index.js"), [
-                "--api-host",
-                apiHost,
-                "--output",
-                options.output ?? (options.outputTable ? "table" : "yaml"),
-                "--api-key",
-                "test-key",
-                "--no-analytics",
-                ...args,
-            ], {
-                stdio: "pipe",
-                ...(options.cwd ? { cwd: options.cwd } : {}),
-                env: {
-                    PATH: `${join(process.cwd(), "mocks/bin")}:${process.env.PATH}`,
-                    ...(options.env ?? {}),
-                },
-            });
-            return new Promise((resolve, reject) => {
-                cp.stdout?.on("data", (data) => {
-                    output += data.toString();
-                });
-                cp.stderr?.on("data", (data) => {
-                    error += data.toString();
-                    log.error(data.toString());
-                });
-                cp.on("error", (err) => {
-                    log.error(err);
-                    throw err;
-                });
-                cp.on("close", (code) => {
-                    try {
-                        expect(code).toBe(options?.code ?? 0);
-                        expect(output).toMatchSnapshot();
-                        if (options.stderr !== undefined) {
-                            expect(strip(error).replace(/\s+/g, " ").trim()).toEqual(typeof options.stderr === "string"
-                                ? options.stderr
-                                    .toString()
-                                    .replace(/\s+/g, " ")
-                                : options.stderr);
-                        }
-                        resolve();
-                    }
-                    catch (err) {
-                        reject(err instanceof Error ? err : new Error(String(err)));
-                    }
-                });
-            }).catch((err) => {
-                log.error(err);
-                throw err;
-            });
-        });
-    },
+const test = test$1.extend({
+	runMockServer: async ({}, use) => {
+		let startedServer;
+		await use(async (mockDir) => {
+			const app = express();
+			app.use(express.json());
+			app.use("/", emocks(join(process.cwd(), "mocks", mockDir), { "404": (_req, res) => res.status(404).send({ message: "Not Found" }) }));
+			const server = await new Promise((resolve) => {
+				const s = app.listen(0, () => {
+					log.debug("Mock server listening at %d", s.address().port);
+					resolve(s);
+				});
+			});
+			startedServer = server;
+			return server;
+		});
+		const server = startedServer;
+		if (server) await new Promise((resolve, reject) => {
+			server.close((err) => {
+				if (err) reject(err instanceof Error ? err : new Error(String(err)));
+				else resolve();
+			});
+		});
+	},
+	testCliCommand: async ({ runMockServer }, use) => {
+		await use(async (args, options = {}) => {
+			const apiHost = options.unreachableHost ? await reserveClosedPort() : `http://localhost:${(await runMockServer(options.mockDir || "main")).address().port}`;
+			let output = "";
+			let error = "";
+			const cp = fork(join(process.cwd(), "./dist/index.js"), [
+				"--api-host",
+				apiHost,
+				"--output",
+				options.output ?? (options.outputTable ? "table" : "yaml"),
+				"--api-key",
+				"test-key",
+				"--no-analytics",
+				...args
+			], {
+				stdio: "pipe",
+				...options.cwd ? { cwd: options.cwd } : {},
+				env: {
+					PATH: `${join(process.cwd(), "mocks/bin")}:${process.env.PATH}`,
+					...options.env ?? {}
+				}
+			});
+			return new Promise((resolve, reject) => {
+				cp.stdout?.on("data", (data) => {
+					output += data.toString();
+				});
+				cp.stderr?.on("data", (data) => {
+					error += data.toString();
+					log.error(data.toString());
+				});
+				cp.on("error", (err) => {
+					log.error(err);
+					throw err;
+				});
+				cp.on("close", (code) => {
+					try {
+						expect(code).toBe(options?.code ?? 0);
+						expect(output).toMatchSnapshot();
+						if (options.stderr !== void 0) expect(strip(error).replace(/\s+/g, " ").trim()).toEqual(typeof options.stderr === "string" ? options.stderr.toString().replace(/\s+/g, " ") : options.stderr);
+						resolve();
+					} catch (err) {
+						reject(err instanceof Error ? err : new Error(String(err)));
+					}
+				});
+			}).catch((err) => {
+				log.error(err);
+				throw err;
+			});
+		});
+	}
 });
+//#endregion
+export { test };

package/dist/test_utils/oauth_server.js

@@ -1,9 +1,12 @@
+import { log } from "../log.js";
 import { OAuth2Server } from "oauth2-mock-server";
-import { log } from "../log";
-export const startOauthServer = async () => {
-    const server = new OAuth2Server();
-    await server.issuer.keys.generate("RS256");
-    await server.start(0, "localhost");
-    log.debug("Started OAuth server on port %d", server.address().port);
-    return server;
+//#region src/test_utils/oauth_server.ts
+const startOauthServer = async () => {
+	const server = new OAuth2Server();
+	await server.issuer.keys.generate("RS256");
+	await server.start(0, "localhost");
+	log.debug("Started OAuth server on port %d", server.address().port);
+	return server;
 };
+//#endregion
+export { startOauthServer };

package/dist/test_utils/project_dir.js

@@ -0,0 +1,33 @@
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+//#region src/test_utils/project_dir.ts
+/** The lockfile each package manager is recognised by. */
+const LOCKFILE = {
+	npm: "package-lock.json",
+	pnpm: "pnpm-lock.yaml",
+	yarn: "yarn.lock",
+	bun: "bun.lock"
+};
+/**
+* A throwaway project directory that `resolvePackageManager` will read as `pm`.
+*
+* The `.git` marker models a repository root, which is what a real project has
+* and what the lockfile walk uses as its boundary. Tests that need the
+* no-repository case should build the directory themselves rather than reach for
+* this.
+*/
+const makeProjectDir = (pm) => {
+	const dir = mkdtempSync(join(tmpdir(), "neon-project-"));
+	mkdirSync(join(dir, ".git"));
+	writeFileSync(join(dir, LOCKFILE[pm]), "");
+	return {
+		dir,
+		cleanup: () => rmSync(dir, {
+			recursive: true,
+			force: true
+		})
+	};
+};
+//#endregion
+export { makeProjectDir };