neon 2.1.2 → 2.29.1

package/dist/commands/operations.js

@@ -0,0 +1,28 @@
+import { fillSingleProject } from "../utils/enrichers.js";
+import { writer } from "../writer.js";
+const OPERATIONS_FIELDS = ["id", "action", "status", "created_at"];
+export const command = "operations";
+export const describe = "Manage operations";
+export const aliases = ["operation"];
+export const builder = (argv) => argv
+    .usage("$0 operations <sub-command> [options]")
+    .options({
+    "project-id": {
+        describe: "Project ID",
+        type: "string",
+    },
+})
+    .middleware(fillSingleProject)
+    .command("list", "List operations", (yargs) => yargs, (args) => list(args));
+export const handler = (args) => {
+    return args;
+};
+export const list = async (props) => {
+    const { data } = await props.apiClient.listProjectOperations({
+        projectId: props.projectId,
+        limit: props.limit,
+    });
+    writer(props).end(data.operations, {
+        fields: OPERATIONS_FIELDS,
+    });
+};

package/dist/commands/orgs.js

@@ -0,0 +1,24 @@
+import { writer } from "../writer.js";
+const ORG_FIELDS = ["id", "name"];
+export const command = "orgs";
+export const describe = "Manage organizations";
+export const aliases = ["org"];
+export const builder = (argv) => {
+    return argv.usage("$0 orgs <sub-command> [options]").command("list", "List organizations", (yargs) => yargs, async (args) => {
+        // @ts-expect-error: TODO - Assert `args` is `CommonProps`
+        await list(args);
+    });
+};
+export const handler = (args) => {
+    return args;
+};
+const list = async (props) => {
+    const out = writer(props);
+    const { data: { organizations }, } = await props.apiClient.getCurrentUserOrganizations();
+    out.write(organizations, {
+        fields: ORG_FIELDS,
+        title: "Organizations",
+        emptyMessage: "You are not a member of any organization.",
+    });
+    out.end();
+};

package/dist/commands/projects.js

@@ -0,0 +1,372 @@
+import prompts from "prompts";
+import { isNeonApiError, messageFromBody } from "../api.js";
+import { updateContextFile } from "../context.js";
+import { isCi } from "../env.js";
+import { log } from "../log.js";
+import { projectCreateRequest, projectUpdateRequest, } from "../parameters.gen.js";
+import { getComputeUnits } from "../utils/compute_units.js";
+import { psql } from "../utils/psql.js";
+import { writer } from "../writer.js";
+export const PROJECT_FIELDS = [
+    "id",
+    "name",
+    "region_id",
+    "created_at",
+];
+export const REGIONS = [
+    "aws-us-west-2",
+    "aws-ap-southeast-1",
+    "aws-ap-southeast-2",
+    "aws-eu-central-1",
+    "aws-us-east-2",
+    "aws-us-east-1",
+    "azure-eastus2",
+];
+const PROJECTS_LIST_LIMIT = 100;
+export const command = "projects";
+export const describe = "Manage projects";
+export const aliases = ["project"];
+export const builder = (argv) => {
+    return argv
+        .usage("$0 projects <sub-command> [options]")
+        .middleware((args) => {
+        // Provide alias for analytics
+        args.projectId = args.id;
+    })
+        .command("list", "List projects", (yargs) => yargs.options({
+        "org-id": {
+            describe: "List projects of a given organization",
+            type: "string",
+        },
+        "recoverable-only": {
+            describe: "List only deleted projects within their deletion grace period",
+            type: "boolean",
+        },
+    }), async (args) => {
+        await handleMissingOrgId(args, list);
+    })
+        .command("create", "Create a project", (yargs) => yargs.options({
+        "block-public-connections": {
+            describe: projectCreateRequest["project.settings.block_public_connections"].description,
+            type: "boolean",
+        },
+        "block-vpc-connections": {
+            describe: projectCreateRequest["project.settings.block_vpc_connections"].description,
+            type: "boolean",
+        },
+        hipaa: {
+            describe: projectCreateRequest["project.settings.hipaa"]
+                .description,
+            type: "boolean",
+        },
+        name: {
+            describe: projectCreateRequest["project.name"].description,
+            type: "string",
+        },
+        "region-id": {
+            describe: `The region ID. Possible values: ${REGIONS.join(", ")}`,
+            type: "string",
+        },
+        "org-id": {
+            describe: "The project's organization ID",
+            type: "string",
+        },
+        psql: {
+            type: "boolean",
+            describe: "Connect to a new project via psql",
+            default: false,
+        },
+        fallback: {
+            type: "boolean",
+            describe: "Force the embedded TypeScript psql fallback (for testing)",
+            default: false,
+            hidden: true,
+        },
+        database: {
+            describe: projectCreateRequest["project.branch.database_name"]
+                .description,
+            type: "string",
+        },
+        role: {
+            describe: projectCreateRequest["project.branch.role_name"]
+                .description,
+            type: "string",
+        },
+        "set-context": {
+            type: "boolean",
+            describe: "Set the current context to the new project",
+            default: false,
+        },
+        cu: {
+            describe: 'The number of Compute Units. Could be a fixed size (e.g. "2") or a range delimited by a dash (e.g. "0.5-3").',
+            type: "string",
+        },
+    }), async (args) => {
+        await handleMissingOrgId(args, create);
+    })
+        .command("update <id>", "Update a project", (yargs) => yargs.options({
+        "block-vpc-connections": {
+            describe: projectUpdateRequest["project.settings.block_vpc_connections"].description +
+                " Use --block-vpc-connections=false to set the value to false.",
+            type: "boolean",
+        },
+        "block-public-connections": {
+            describe: projectUpdateRequest["project.settings.block_public_connections"].description +
+                " Use --block-public-connections=false to set the value to false.",
+            type: "boolean",
+        },
+        hipaa: {
+            describe: projectUpdateRequest["project.settings.hipaa"]
+                .description,
+            type: "boolean",
+        },
+        cu: {
+            describe: 'The number of Compute Units. Could be a fixed size (e.g. "2") or a range delimited by a dash (e.g. "0.5-3").',
+            type: "string",
+        },
+        name: {
+            describe: projectUpdateRequest["project.name"].description,
+            type: "string",
+        },
+    }), async (args) => {
+        await update(args);
+    })
+        .command("delete <id>", "Delete a project", (yargs) => yargs, async (args) => {
+        await deleteProject(args);
+    })
+        .command("recover <id>", "Recovers a deleted project during the deletion grace period", (yargs) => yargs, async (args) => {
+        await recover(args);
+    })
+        .command("get <id>", "Get a project", (yargs) => yargs, async (args) => {
+        await get(args);
+    });
+};
+export const handler = (args) => {
+    return args;
+};
+const list = async (props) => {
+    const getList = async (fn) => {
+        const result = [];
+        let cursor;
+        let end = false;
+        while (!end) {
+            const { data } = await fn({
+                limit: PROJECTS_LIST_LIMIT,
+                org_id: props.orgId,
+                recoverable: props.recoverableOnly,
+                cursor,
+            });
+            result.push(...data.projects);
+            cursor = data.pagination?.cursor;
+            log.debug("Got %d projects, with cursor: %s", data.projects.length, cursor);
+            if (data.projects.length < PROJECTS_LIST_LIMIT) {
+                end = true;
+            }
+        }
+        return result;
+    };
+    const ownedProjects = await getList(props.apiClient.listProjects);
+    const sharedProjects = props.orgId || props.recoverableOnly
+        ? []
+        : await getList(props.apiClient.listSharedProjects);
+    const out = writer(props);
+    out.write(ownedProjects, {
+        fields: props.recoverableOnly
+            ? [...PROJECT_FIELDS, "deleted_at", "recoverable_until"]
+            : PROJECT_FIELDS,
+        title: "Projects",
+        emptyMessage: props.recoverableOnly
+            ? "You don't have any recoverable projects."
+            : "You don't have any projects yet. See how to create a new project:\n> neon projects create --help",
+    });
+    if (!props.orgId && !props.recoverableOnly) {
+        // We don't list shared projects when listing recoverable projects
+        out.write(sharedProjects, {
+            fields: PROJECT_FIELDS,
+            title: "Shared with you",
+            emptyMessage: "No projects have been shared with you",
+        });
+    }
+    out.end();
+};
+const create = async (props) => {
+    const project = {};
+    if (props.hipaa !== undefined) {
+        if (!project.settings) {
+            project.settings = {};
+        }
+        project.settings.hipaa = props.hipaa;
+    }
+    if (props.blockPublicConnections !== undefined) {
+        if (!project.settings) {
+            project.settings = {};
+        }
+        project.settings.block_public_connections =
+            props.blockPublicConnections;
+    }
+    if (props.blockVpcConnections !== undefined) {
+        if (!project.settings) {
+            project.settings = {};
+        }
+        project.settings.block_vpc_connections = props.blockVpcConnections;
+    }
+    if (props.name) {
+        project.name = props.name;
+    }
+    if (props.regionId) {
+        project.region_id = props.regionId;
+    }
+    if (props.orgId) {
+        project.org_id = props.orgId;
+    }
+    project.branch = {};
+    if (props.database) {
+        project.branch.database_name = props.database;
+    }
+    if (props.role) {
+        project.branch.role_name = props.role;
+    }
+    if (props.cu) {
+        project.default_endpoint_settings = props.cu
+            ? getComputeUnits(props.cu)
+            : undefined;
+    }
+    const { data } = await props.apiClient.createProject({
+        project,
+    });
+    if (props.setContext) {
+        updateContextFile(props.contextFile, {
+            projectId: data.project.id,
+        });
+    }
+    const out = writer(props);
+    out.write(data.project, { fields: PROJECT_FIELDS, title: "Project" });
+    out.write(data.connection_uris, {
+        fields: ["connection_uri"],
+        title: "Connection URIs",
+    });
+    out.end();
+    if (props.psql) {
+        const connection_uri = data.connection_uris[0].connection_uri;
+        const psqlArgs = props["--"];
+        await psql(connection_uri, psqlArgs, {
+            mode: props.fallback ? "ts" : "auto",
+        });
+    }
+};
+const deleteProject = async (props) => {
+    const { data } = await props.apiClient.deleteProject(props.id);
+    writer(props).end(data.project, {
+        fields: PROJECT_FIELDS,
+    });
+};
+const update = async (props) => {
+    const project = {};
+    if (props.hipaa !== undefined) {
+        if (!project.settings) {
+            project.settings = {};
+        }
+        project.settings.hipaa = props.hipaa;
+    }
+    if (props.blockPublicConnections !== undefined) {
+        if (!project.settings) {
+            project.settings = {};
+        }
+        project.settings.block_public_connections =
+            props.blockPublicConnections;
+    }
+    if (props.blockVpcConnections !== undefined) {
+        if (!project.settings) {
+            project.settings = {};
+        }
+        project.settings.block_vpc_connections = props.blockVpcConnections;
+    }
+    if (props.name) {
+        project.name = props.name;
+    }
+    if (props.cu) {
+        project.default_endpoint_settings = props.cu
+            ? getComputeUnits(props.cu)
+            : undefined;
+    }
+    const { data } = await props.apiClient.updateProject(props.id, {
+        project,
+    });
+    writer(props).end(data.project, { fields: PROJECT_FIELDS });
+};
+const recover = async (props) => {
+    const { data } = await props.apiClient.recoverProject(props.id);
+    writer(props).end(data.project, { fields: PROJECT_FIELDS });
+};
+const get = async (props) => {
+    const { data } = await props.apiClient.getProject(props.id);
+    writer(props).end(data.project, { fields: PROJECT_FIELDS });
+};
+const handleMissingOrgId = async (args, cmd) => {
+    try {
+        await cmd(args);
+    }
+    catch (err) {
+        if (!isCi() && isOrgIdError(err)) {
+            const orgId = await selectOrg(args);
+            await cmd({ ...args, orgId });
+        }
+        else {
+            throw err;
+        }
+    }
+};
+const isOrgIdError = (err) => {
+    return (isNeonApiError(err) &&
+        err.status === 400 &&
+        messageFromBody(err.data)?.includes("org_id is required"));
+};
+const selectOrg = async (props) => {
+    const { data: { organizations }, } = await props.apiClient.getCurrentUserOrganizations();
+    if (!organizations?.length) {
+        throw new Error(`You don't belong to any organizations. Please create an organization first.`);
+    }
+    const { orgId } = await prompts({
+        onState: onPromptState,
+        type: "select",
+        name: "orgId",
+        message: `What organization would you like to use?`,
+        choices: organizations.map((org) => ({
+            title: `${org.name} (${org.id})`,
+            value: org.id,
+        })),
+        initial: 0,
+    });
+    const { save } = await prompts({
+        onState: onPromptState,
+        type: "confirm",
+        name: "save",
+        message: `Would you like to use this organization by default?`,
+        initial: true,
+    });
+    if (save) {
+        updateContextFile(props.contextFile, { orgId });
+        writer(props).text(`
+The organization ID has been saved in ${props.contextFile}
+
+If you'd like to change the default organization later, use
+
+    neonctl link --org-id <org_id>
+
+Or to clear the context file and forget the default organization
+
+    neonctl link --clear
+
+`);
+    }
+    return orgId;
+};
+const onPromptState = (state) => {
+    if (state.aborted) {
+        // If we don't re-enable the terminal cursor before exiting
+        // the program, the cursor will remain hidden
+        process.stdout.write("\x1B[?25h");
+        process.stdout.write("\n");
+        process.exit(1);
+    }
+};

package/dist/commands/psql.js

@@ -0,0 +1,62 @@
+import { EndpointType } from "../utils/api_enums.js";
+import { fillSingleProject } from "../utils/enrichers.js";
+import { handler as connectionStringHandler, SSL_MODES, } from "./connection_string.js";
+export const command = "psql [branch]";
+export const describe = "Connect to a database via psql";
+export const builder = (argv) => {
+    return argv
+        .usage("$0 psql [branch] [options] [-- psql-args]")
+        .example("$0 psql", "Connect to the default branch via psql")
+        .example("$0 psql main", "Connect to the main branch via psql")
+        .example('$0 psql main -- -c "SELECT 1"', "Run a single query against the main branch")
+        .example("$0 psql main@2024-01-01T00:00:00Z", "Connect to the main branch at a specific point in time")
+        .positional("branch", {
+        describe: `Branch name or id. Defaults to the default branch if omitted. Can be written in the point-in-time format: "branch@timestamp" or "branch@lsn"`,
+        type: "string",
+    })
+        .options({
+        "project-id": {
+            type: "string",
+            describe: "Project ID",
+        },
+        "role-name": {
+            type: "string",
+            describe: "Role name",
+        },
+        "database-name": {
+            type: "string",
+            describe: "Database name",
+        },
+        pooled: {
+            type: "boolean",
+            describe: "Use pooled connection",
+            default: false,
+        },
+        "endpoint-type": {
+            type: "string",
+            choices: Object.values(EndpointType),
+            describe: "Endpoint type",
+        },
+        ssl: {
+            type: "string",
+            choices: SSL_MODES,
+            default: "require",
+            describe: "SSL mode",
+        },
+        fallback: {
+            type: "boolean",
+            describe: "Force the embedded TypeScript psql fallback (for testing)",
+            default: false,
+            hidden: true,
+        },
+    })
+        .middleware(fillSingleProject);
+};
+export const handler = async (props) => {
+    await connectionStringHandler({
+        ...props,
+        psql: true,
+        prisma: false,
+        extended: false,
+    });
+};

package/dist/commands/roles.js

@@ -0,0 +1,65 @@
+import { retryOnLock } from "../api.js";
+import { branchIdFromProps, fillSingleProject } from "../utils/enrichers.js";
+import { writer } from "../writer.js";
+const ROLES_FIELDS = ["name", "created_at"];
+export const command = "roles";
+export const describe = "Manage roles";
+export const aliases = ["role"];
+export const builder = (argv) => argv
+    .usage("$0 roles <sub-command> [options]")
+    .options({
+    "project-id": {
+        describe: "Project ID",
+        type: "string",
+    },
+    branch: {
+        describe: "Branch ID or name",
+        type: "string",
+    },
+})
+    .middleware(fillSingleProject)
+    .command("list", "List roles", (yargs) => yargs, (args) => list(args))
+    .command("create", "Create a role", (yargs) => yargs.options({
+    name: {
+        describe: "Role name",
+        type: "string",
+        demandOption: true,
+    },
+    "no-login": {
+        describe: "Create a passwordless role that cannot login",
+        boolean: true,
+    },
+}), (args) => create(args))
+    .command("delete <role>", "Delete a role", (yargs) => yargs, (args) => deleteRole(args));
+export const handler = (args) => {
+    return args;
+};
+export const list = async (props) => {
+    const branchId = await branchIdFromProps(props);
+    const { data } = await props.apiClient.listProjectBranchRoles(props.projectId, branchId);
+    writer(props).end(data.roles, {
+        fields: ROLES_FIELDS,
+    });
+};
+export const create = async (props) => {
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.createProjectBranchRole(props.projectId, branchId, {
+        role: {
+            name: props.name,
+            no_login: props["no-login"],
+        },
+    }));
+    writer(props).end(data.role, {
+        fields: ROLES_FIELDS,
+    });
+};
+export const deleteRole = async (props) => {
+    const branchId = await branchIdFromProps(props);
+    const { data } = await retryOnLock(() => props.apiClient.deleteProjectBranchRole(props.projectId, branchId, props.role));
+    // A 204 (role already gone) carries no body; only a 200 returns the role.
+    if (data) {
+        writer(props).end(data.role, {
+            fields: ROLES_FIELDS,
+        });
+    }
+};