create-db 1.1.5 → 1.2.0

package/README.md

@@ -38,6 +38,10 @@ npx create-db regions    # List available regions
 | `--interactive` | `-i` | Interactive mode to select a region |
 | `--json` | `-j` | Output machine-readable JSON |
 | `--env <path>` | `-e` | Write DATABASE_URL and CLAIM_URL to specified .env file |
+| `--ttl <duration>` | `-t` | Custom database TTL (`30m`, `1h` ... `24h`) |
+| `--copy` | `-c` | Copy connection string to clipboard |
+| `--quiet` | `-q` | Output only the connection string |
+| `--open` | `-o` | Open claim URL in browser |
 | `--help` | `-h` | Show help message |
 | `--version` | | Show version |
 
@@ -72,17 +76,37 @@ npx create-db -j
 npx create-db --env .env
 npx create-db -e .env.local
 
+# Set custom TTL
+npx create-db --ttl 1h
+npx create-db -t 12h
+
+# Copy connection string to clipboard
+npx create-db --copy
+npx create-db -c
+
+# Only print connection string
+npx create-db --quiet
+npx create-db -q
+
+# Open claim URL in browser
+npx create-db --open
+npx create-db -o
+
 # Combine flags
 npx create-db -r eu-central-1 -j
 npx create-db -i -e .env
+npx create-db -t 24h -c -o
 
 # List available regions
 npx create-db regions
+
+# List available regions as JSON
+npx create-db regions --json
 ```
 
 ### JSON Output
 
-When using `--json`, the output includes:
+When using `--json` with `create`, the output includes:
 
 ```json
 {
@@ -96,6 +120,18 @@ When using `--json`, the output includes:
 }
 ```
 
+When using `--json` with `regions`, the output is an array of region objects:
+
+```json
+[
+  {
+    "id": "us-east-1",
+    "name": "US East (N. Virginia)",
+    "status": "available"
+  }
+]
+```
+
 ### Environment File Output
 
 When using `--env`, the following variables are appended to the specified file:
@@ -139,6 +175,7 @@ if (result.success) {
 |--------|------|-------------|
 | `region` | `RegionId` | AWS region for the database (optional, defaults to `us-east-1`) |
 | `userAgent` | `string` | Custom user agent string for tracking (optional) |
+| `ttl` | `string` | TTL string (`30m`, `1h` ... `24h`) |
 
 ### `regions()`
 

package/dist/cli.mjs

@@ -1,8 +1,19 @@
 #!/usr/bin/env node
-import { n as createDbCli } from "./src-DR107zU6.mjs";
+import { n as createDbCli } from "./src-CYG5L8Ei.mjs";
 
 //#region src/cli.ts
-createDbCli().run();
+function simplifyHelpFlags(command) {
+	for (const option of command.options ?? []) {
+		if (!option.flags) continue;
+		option.flags = option.flags.replace(" [boolean]", "").replace(" [string]", " [value]").replace(" <string>", " <value>");
+		if (option.long === "--ttl" || option.flags.includes("--ttl")) option.flags = option.flags.replace("<value>", "<duration>").replace("[value]", "[duration]");
+	}
+	for (const subcommand of command.commands ?? []) simplifyHelpFlags(subcommand);
+}
+const cli = createDbCli();
+const program = cli.buildProgram();
+simplifyHelpFlags(program);
+cli.run(void 0, program);
 
 //#endregion
 export {  };

package/dist/index.d.mts

@@ -46,6 +46,7 @@ declare function isDatabaseSuccess(result: CreateDatabaseResult): result is Data
 interface ProgrammaticCreateOptions {
   region?: RegionId;
   userAgent?: string;
+  ttl?: string;
 }
 //#endregion
 //#region src/cli/flags.d.ts
@@ -64,10 +65,22 @@ declare const CreateFlags: z.ZodObject<{
   interactive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
   json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
   env: z.ZodOptional<z.ZodString>;
+  ttl: z.ZodOptional<z.ZodPipe<z.ZodTransform<unknown, unknown>, z.ZodPipe<z.ZodString, z.ZodTransform<number, string>>>>;
+  copy: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  quiet: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+  open: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
   userAgent: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /** Inferred type from CreateFlags schema. */
 type CreateFlagsInput = z.infer<typeof CreateFlags>;
+/**
+ * Zod schema for CLI flags used by the `regions` command.
+ */
+declare const RegionsFlags: z.ZodObject<{
+  json: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/** Inferred type from RegionsFlags schema. */
+type RegionsFlagsInput = z.infer<typeof RegionsFlags>;
 //#endregion
 //#region src/index.d.ts
 /**
@@ -99,4 +112,4 @@ declare function create(options?: ProgrammaticCreateOptions): Promise<CreateData
  */
 declare function regions(): Promise<Region[]>;
 //#endregion
-export { type CreateDatabaseResult, CreateFlags, type CreateFlagsInput, type DatabaseError, type DatabaseResult, type ProgrammaticCreateOptions, type Region, type RegionId, RegionSchema, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };
+export { type CreateDatabaseResult, CreateFlags, type CreateFlagsInput, type DatabaseError, type DatabaseResult, type ProgrammaticCreateOptions, type Region, type RegionId, RegionSchema, RegionsFlags, type RegionsFlagsInput, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };

package/dist/index.mjs

@@ -1,4 +1,4 @@
 #!/usr/bin/env node
-import { a as RegionSchema, i as CreateFlags, n as createDbCli, o as isDatabaseError, r as regions, s as isDatabaseSuccess, t as create } from "./src-DR107zU6.mjs";
+import { a as RegionsFlags, c as isDatabaseSuccess, i as CreateFlags, n as createDbCli, o as RegionSchema, r as regions, s as isDatabaseError, t as create } from "./src-CYG5L8Ei.mjs";
 
-export { CreateFlags, RegionSchema, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };
+export { CreateFlags, RegionSchema, RegionsFlags, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };

package/dist/{src-DR107zU6.mjs → src-CYG5L8Ei.mjs}

@@ -8,6 +8,7 @@ import fs from "fs";
 import path from "path";
 import dotenv from "dotenv";
 import pc from "picocolors";
+import { spawnSync } from "child_process";
 import terminalLink from "terminal-link";
 
 //#region src/types.ts
@@ -26,8 +27,54 @@ function isDatabaseSuccess(result) {
 	return result.success;
 }
 
+//#endregion
+//#region src/utils/ttl.ts
+const HOUR_TTL_PATTERN = /^([1-9]|1\d|2[0-4])h$/;
+const MIN_TTL_MS = 1800 * 1e3;
+const MAX_TTL_MS = 1440 * 60 * 1e3;
+const ONE_HOUR_MS = 3600 * 1e3;
+const TTL_HELP_DESCRIPTION = "Auto-delete after (30m, 1h-24h)";
+const TTL_ALLOWED_VALUES_TEXT = "30m, or 1h-24h";
+const TTL_RANGE_TEXT = "30m to 24h";
+const TTL_EXAMPLES_TEXT = [
+	"Examples:",
+	"npx create-db --ttl 24h",
+	"npx create-db --ttl 8h",
+	"npx create-db --ttl 1h",
+	"npx create-db --ttl 30m"
+].join("\n");
+function parseTtlToMilliseconds(value) {
+	const normalized = value.trim().toLowerCase();
+	if (normalized === "30m") return MIN_TTL_MS;
+	const match = HOUR_TTL_PATTERN.exec(normalized);
+	if (!match) return null;
+	return Number(match[1]) * ONE_HOUR_MS;
+}
+function buildTtlCliError(message) {
+	return [
+		message,
+		`Allowed values are ${TTL_ALLOWED_VALUES_TEXT}.`,
+		"",
+		TTL_EXAMPLES_TEXT
+	].join("\n");
+}
+
 //#endregion
 //#region src/cli/flags.ts
+const TTL_MISSING_VALUE_SENTINEL = "__create_db_ttl_missing_value__";
+const TtlFlag = z.preprocess((value) => value === true ? TTL_MISSING_VALUE_SENTINEL : value, z.string().superRefine((value, ctx) => {
+	if (value === TTL_MISSING_VALUE_SENTINEL) {
+		ctx.addIssue({
+			code: "custom",
+			message: buildTtlCliError("Could not create database: --ttl was provided without a value.")
+		});
+		return;
+	}
+	if (parseTtlToMilliseconds(value) === null) ctx.addIssue({
+		code: "custom",
+		message: buildTtlCliError(`Could not create database: --ttl value "${value}" is invalid.`)
+	});
+}).transform((value) => parseTtlToMilliseconds(value))).optional().describe(TTL_HELP_DESCRIPTION).meta({ alias: "t" });
 /**
 * Zod schema for CLI flags used by the `create` command.
 */
@@ -36,8 +83,19 @@ const CreateFlags = z.object({
 	interactive: z.boolean().optional().default(false).describe("Run in interactive mode to select a region").meta({ alias: "i" }),
 	json: z.boolean().optional().default(false).describe("Output machine-readable JSON").meta({ alias: "j" }),
 	env: z.string().optional().describe("Write DATABASE_URL and CLAIM_URL to the specified .env file").meta({ alias: "e" }),
-	userAgent: z.string().optional().describe("Custom user agent string (e.g. 'test/test')").meta({ alias: "u" })
+	ttl: TtlFlag,
+	copy: z.boolean().optional().default(false).describe("Copy the connection string to your clipboard").meta({ alias: "c" }),
+	quiet: z.boolean().optional().default(false).describe("Only output the connection string").meta({ alias: "q" }),
+	open: z.boolean().optional().default(false).describe("Open the claim URL in your browser").meta({ alias: "o" }),
+	userAgent: z.string().optional().describe("Custom user agent string (e.g. 'test/test')").meta({
+		alias: "u",
+		hidden: true
+	})
 });
+/**
+* Zod schema for CLI flags used by the `regions` command.
+*/
+const RegionsFlags = z.object({ json: z.boolean().optional().default(false).describe("Output machine-readable JSON").meta({ alias: "j" }) });
 
 //#endregion
 //#region src/utils/analytics.ts
@@ -78,19 +136,21 @@ function getCommandName() {
 	if (executable.includes("create-postgres")) return "create-postgres";
 	return "create-db";
 }
-async function createDatabaseCore(region, createDbWorkerUrl, claimDbWorkerUrl, userAgent, cliRunId, source) {
+async function createDatabaseCore(region, createDbWorkerUrl, claimDbWorkerUrl, userAgent, cliRunId, source, ttlMs) {
 	const name = (/* @__PURE__ */ new Date()).toISOString();
 	const runId = cliRunId ?? randomUUID();
+	const payload = {
+		region,
+		name,
+		utm_source: getCommandName(),
+		userAgent,
+		source: source || "cli"
+	};
+	if (typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0) payload.ttlMs = Math.floor(ttlMs);
 	const resp = await fetch(`${createDbWorkerUrl}/create`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
-		body: JSON.stringify({
-			region,
-			name,
-			utm_source: getCommandName(),
-			userAgent,
-			source: source || "cli"
-		})
+		body: JSON.stringify(payload)
 	});
 	if (resp.status === 429) {
 		sendAnalytics("create_db:database_creation_failed", {
@@ -159,7 +219,8 @@ async function createDatabaseCore(region, createDbWorkerUrl, claimDbWorkerUrl, u
 	const directDbName = directConnDetails?.database || "postgres";
 	const connectionString = directConnDetails && directHost ? `postgresql://${directUser}:${directPass}@${directHost}${directPort}/${directDbName}?sslmode=require` : null;
 	const claimUrl = `${claimDbWorkerUrl}/claim?projectID=${projectId}&utm_source=${userAgent || getCommandName()}&utm_medium=cli`;
-	const expiryDate = new Date(Date.now() + 1440 * 60 * 1e3);
+	const ttlMsToUse = typeof ttlMs === "number" && Number.isFinite(ttlMs) && ttlMs > 0 ? Math.floor(ttlMs) : 1440 * 60 * 1e3;
+	const expiryDate = new Date(Date.now() + ttlMsToUse);
 	sendAnalytics("create_db:database_created", {
 		region,
 		utm_source: getCommandName()
@@ -371,10 +432,11 @@ function validateRegionId(region) {
 * @param userAgent - Optional custom user agent string
 * @param cliRunId - Optional unique identifier for this CLI run
 * @param source - Whether called from CLI or programmatic API
+* @param ttlMs - Optional database lifetime in milliseconds
 * @returns A promise resolving to the database creation result
 */
-function createDatabase(region, userAgent, cliRunId, source) {
-	return createDatabaseCore(region, CREATE_DB_WORKER_URL, CLAIM_DB_WORKER_URL, userAgent, cliRunId, source);
+function createDatabase(region, userAgent, cliRunId, source, ttlMs) {
+	return createDatabaseCore(region, CREATE_DB_WORKER_URL, CLAIM_DB_WORKER_URL, userAgent, cliRunId, source, ttlMs);
 }
 
 //#endregion
@@ -475,12 +537,110 @@ function writeEnvFile(envPath, connectionString, claimUrl) {
 		};
 	}
 }
+/**
+* Copy text to the system clipboard.
+* @param text - Text to copy
+*/
+function copyToClipboard(text) {
+	const commands = process.platform === "darwin" ? [{
+		command: "pbcopy",
+		args: []
+	}] : process.platform === "win32" ? [{
+		command: "cmd",
+		args: ["/c", "clip"]
+	}] : [
+		{
+			command: "wl-copy",
+			args: []
+		},
+		{
+			command: "xclip",
+			args: ["-selection", "clipboard"]
+		},
+		{
+			command: "xsel",
+			args: ["--clipboard", "--input"]
+		}
+	];
+	const errors = [];
+	for (const { command, args } of commands) {
+		const result = spawnSync(command, args, {
+			input: text,
+			encoding: "utf8",
+			stdio: [
+				"pipe",
+				"ignore",
+				"pipe"
+			]
+		});
+		if (result.status === 0) return { success: true };
+		if (result.error) errors.push(`${command}: ${result.error.message}`);
+		else if (result.stderr?.trim()) errors.push(`${command}: ${result.stderr.trim()}`);
+	}
+	return {
+		success: false,
+		error: errors[0] || "No clipboard command is available on this system."
+	};
+}
+/**
+* Open a URL in the user's default browser.
+* @param url - URL to open
+*/
+function openUrlInBrowser(url) {
+	const command = process.platform === "darwin" ? {
+		command: "open",
+		args: [url]
+	} : process.platform === "win32" ? {
+		command: "cmd",
+		args: [
+			"/c",
+			"start",
+			"",
+			url
+		]
+	} : {
+		command: "xdg-open",
+		args: [url]
+	};
+	const result = spawnSync(command.command, command.args, { stdio: "ignore" });
+	if (result.status === 0) return { success: true };
+	if (result.error) return {
+		success: false,
+		error: result.error.message
+	};
+	return {
+		success: false,
+		error: `Command failed: ${command.command}`
+	};
+}
 
 //#endregion
 //#region src/cli/commands/create.ts
+function applyCopyFlag(result, quiet) {
+	if (!result.connectionString) {
+		printError("Connection string is unavailable, cannot copy to clipboard.");
+		process.exit(1);
+	}
+	const copyResult = copyToClipboard(result.connectionString);
+	if (!copyResult.success) {
+		printError(`Failed to copy connection string: ${copyResult.error}`);
+		process.exit(1);
+	}
+	if (!quiet) printSuccess("Copied connection string to clipboard");
+}
+function applyOpenFlag(result, quiet) {
+	const openResult = openUrlInBrowser(result.claimUrl);
+	if (!openResult.success) {
+		printError(`Failed to open claim URL: ${openResult.error}`);
+		process.exit(1);
+	}
+	if (!quiet) printSuccess("Opened claim URL in browser");
+}
 async function handleCreate(input) {
 	const cliRunId = randomUUID();
 	const CLI_NAME = getCommandName();
+	const ttlMs = input.ttl;
+	const interactiveMode = input.interactive && !input.quiet;
 	let userAgent = input.userAgent;
 	if (!userAgent) {
 		const userEnvVars = readUserEnvFile();
@@ -492,6 +652,11 @@ async function handleCreate(input) {
 		"has-interactive-flag": input.interactive,
 		"has-json-flag": input.json,
 		"has-env-flag": !!input.env,
+		"has-ttl-flag": input.ttl !== void 0,
+		"has-copy-flag": input.copy,
+		"has-quiet-flag": input.quiet,
+		"has-open-flag": input.open,
+		"ttl-ms": ttlMs,
 		"user-agent": userAgent || void 0,
 		"node-version": process.version,
 		platform: process.platform,
@@ -501,8 +666,8 @@ async function handleCreate(input) {
 	if (!input.region) region = getRegionClosestToLocation(await detectUserLocation()) ?? region;
 	const envPath = input.env;
 	const envEnabled = typeof envPath === "string" && envPath.trim().length > 0;
-	if (input.json || envEnabled) {
-		if (input.interactive) {
+	if (input.json || envEnabled || input.quiet) {
+		if (interactiveMode) {
 			await ensureOnline();
 			const regions$1 = await fetchRegions();
 			const selectedRegion = await select({
@@ -531,7 +696,7 @@ async function handleCreate(input) {
 			}, cliRunId);
 		}
 		await ensureOnline();
-		const result$1 = await createDatabase(region, userAgent, cliRunId);
+		const result$1 = await createDatabase(region, userAgent, cliRunId, "cli", ttlMs);
 		await flushAnalytics();
 		if (input.json) {
 			printJson(result$1);
@@ -542,12 +707,17 @@ async function handleCreate(input) {
 			printError(result$1.message);
 			process.exit(1);
 		}
-		const writeResult = writeEnvFile(envPath, result$1.connectionString, result$1.claimUrl);
-		if (!writeResult.success) {
-			printError(`Failed to write environment variables to ${envPath}: ${writeResult.error}`);
-			process.exit(1);
+		if (envEnabled) {
+			const writeResult = writeEnvFile(envPath, result$1.connectionString, result$1.claimUrl);
+			if (!writeResult.success) {
+				printError(`Failed to write environment variables to ${envPath}: ${writeResult.error}`);
+				process.exit(1);
+			}
+			if (!input.quiet) printSuccess(`Wrote DATABASE_URL and CLAIM_URL to ${envPath}`);
 		}
-		printSuccess(`Wrote DATABASE_URL and CLAIM_URL to ${envPath}`);
+		if (input.quiet) console.log(result$1.connectionString ?? "");
+		if (input.copy) applyCopyFlag(result$1, input.quiet);
+		if (input.open) applyOpenFlag(result$1, input.quiet);
 		return;
 	}
 	await ensureOnline();
@@ -581,7 +751,7 @@ async function handleCreate(input) {
 	}
 	const spinner$1 = createSpinner();
 	spinner$1.start(region);
-	const result = await createDatabase(region, userAgent, cliRunId);
+	const result = await createDatabase(region, userAgent, cliRunId, "cli", ttlMs);
 	if (!result.success) {
 		spinner$1.error(result.message);
 		await flushAnalytics();
@@ -589,14 +759,20 @@ async function handleCreate(input) {
 	}
 	spinner$1.success();
 	printDatabaseResult(result);
+	if (input.copy) applyCopyFlag(result, false);
+	if (input.open) applyOpenFlag(result, false);
 	showOutro();
 	await flushAnalytics();
 }
 
 //#endregion
 //#region src/cli/commands/regions.ts
-async function handleRegions() {
+async function handleRegions(input) {
 	const regions$1 = await fetchRegions();
+	if (input.json) {
+		printJson(regions$1);
+		return;
+	}
 	log.message("");
 	log.info(pc.bold(pc.cyan("Available Prisma Postgres regions:")));
 	log.message("");
@@ -611,7 +787,7 @@ const router = os.router({
 		description: "Create a new Prisma Postgres database",
 		default: true
 	}).input(CreateFlags).handler(async ({ input }) => handleCreate(input)),
-	regions: os.meta({ description: "List available Prisma Postgres regions" }).handler(async () => handleRegions())
+	regions: os.meta({ description: "List available Prisma Postgres regions" }).input(RegionsFlags).handler(async ({ input }) => handleRegions(input))
 });
 /**
 * Create and return the CLI instance for create-db.
@@ -638,7 +814,13 @@ function createDbCli() {
 * ```
 */
 async function create(options) {
-	return createDatabase(options?.region || "us-east-1", options?.userAgent, void 0, "programmatic");
+	const ttlMs = typeof options?.ttl === "string" ? parseTtlToMilliseconds(options.ttl) : void 0;
+	if (typeof options?.ttl === "string" && ttlMs === null) return {
+		success: false,
+		error: "invalid_ttl",
+		message: `Invalid ttl "${options.ttl}". Allowed range is ${TTL_RANGE_TEXT}.`
+	};
+	return createDatabase(options?.region || "us-east-1", options?.userAgent, void 0, "programmatic", ttlMs ?? void 0);
 }
 /**
 * List available Prisma Postgres regions programmatically.
@@ -654,4 +836,4 @@ async function regions() {
 }
 
 //#endregion
-export { RegionSchema as a, CreateFlags as i, createDbCli as n, isDatabaseError as o, regions as r, isDatabaseSuccess as s, create as t };
+export { RegionsFlags as a, isDatabaseSuccess as c, CreateFlags as i, createDbCli as n, RegionSchema as o, regions as r, isDatabaseError as s, create as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-db",
-  "version": "1.1.5",
+  "version": "1.2.0",
   "description": "Instantly create a temporary Prisma Postgres database with one command, then claim and persist it in your Prisma Data Platform project when ready.",
   "type": "module",
   "exports": {
@@ -41,11 +41,11 @@
     "@clack/prompts": "^0.11.0",
     "@orpc/server": "^1.12.2",
     "dotenv": "^17.2.3",
+    "execa": "^9.6.1",
     "picocolors": "^1.1.1",
     "terminal-link": "^5.0.0",
-    "trpc-cli": "^0.12.1",
-    "zod": "^4.1.13",
-    "execa": "^9.6.1"
+    "trpc-cli": "^0.12.4",
+    "zod": "^4.1.13"
   },
   "publishConfig": {
     "access": "public"