create-db 1.1.1-pr66-version-bump-19346362281.0 → 1.1.1-pr67-overhaul-19905444027.0

package/dist/cli.d.mts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { n as createDbCli } from "./src-CWxeHoyI.mjs";
+
+//#region src/cli.ts
+createDbCli().run();
+
+//#endregion
+export {  };

package/dist/index.d.mts

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+import * as trpc_cli0 from "trpc-cli";
+import z$1 from "zod";
+
+//#region src/types.d.ts
+declare const RegionSchema: z$1.ZodEnum<{
+  "ap-southeast-1": "ap-southeast-1";
+  "ap-northeast-1": "ap-northeast-1";
+  "eu-central-1": "eu-central-1";
+  "eu-west-3": "eu-west-3";
+  "us-east-1": "us-east-1";
+  "us-west-1": "us-west-1";
+}>;
+type RegionId = z$1.infer<typeof RegionSchema>;
+interface Region {
+  id: string;
+  name?: string;
+  status: string;
+}
+interface DatabaseResult {
+  success: true;
+  connectionString: string | null;
+  claimUrl: string;
+  deletionDate: string;
+  region: string;
+  name: string;
+  projectId: string;
+  userAgent?: string;
+}
+interface DatabaseError {
+  success: false;
+  error: string;
+  message: string;
+  raw?: string;
+  details?: unknown;
+  status?: number;
+}
+type CreateDatabaseResult = DatabaseResult | DatabaseError;
+declare function isDatabaseError(result: CreateDatabaseResult): result is DatabaseError;
+declare function isDatabaseSuccess(result: CreateDatabaseResult): result is DatabaseResult;
+interface ProgrammaticCreateOptions {
+  region?: RegionId;
+  userAgent?: string;
+}
+//#endregion
+//#region src/index.d.ts
+declare function createDbCli(): trpc_cli0.TrpcCli;
+/**
+ * Create a new Prisma Postgres database programmatically.
+ *
+ * @param options - Options for creating the database
+ * @param options.region - The AWS region for the database (optional)
+ * @param options.userAgent - Custom user agent string (optional)
+ * @returns A promise that resolves to either a {@link DatabaseResult} or {@link DatabaseError}
+ *
+ * @example
+ * ```typescript
+ * import { create } from "create-db";
+ *
+ * const result = await create({ region: "us-east-1" });
+ *
+ * if (result.success) {
+ *   console.log(`Connection string: ${result.connectionString}`);
+ *   console.log(`Claim URL: ${result.claimUrl}`);
+ * } else {
+ *   console.error(`Error: ${result.message}`);
+ * }
+ * ```
+ */
+declare function create(options?: ProgrammaticCreateOptions): Promise<CreateDatabaseResult>;
+/**
+ * List available Prisma Postgres regions programmatically.
+ *
+ * @example
+ * ```typescript
+ * import { regions } from "create-db";
+ *
+ * const availableRegions = await regions();
+ * console.log(availableRegions);
+ * ```
+ */
+declare function regions(): Promise<Region[]>;
+//#endregion
+export { type CreateDatabaseResult, type DatabaseError, type DatabaseResult, type ProgrammaticCreateOptions, type Region, type RegionId, RegionSchema, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };

package/dist/index.mjs

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

package/dist/src-CWxeHoyI.mjs

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+import { cancel, intro, isCancel, log, outro, select, spinner } from "@clack/prompts";
+import { createRouterClient, os } from "@orpc/server";
+import { randomUUID } from "crypto";
+import dotenv from "dotenv";
+import fs from "fs";
+import path from "path";
+import pc from "picocolors";
+import terminalLink from "terminal-link";
+import { createCli } from "trpc-cli";
+import z$1, { z } from "zod";
+
+//#region src/types.ts
+const RegionSchema = z$1.enum([
+	"ap-southeast-1",
+	"ap-northeast-1",
+	"eu-central-1",
+	"eu-west-3",
+	"us-east-1",
+	"us-west-1"
+]);
+function isDatabaseError(result) {
+	return !result.success;
+}
+function isDatabaseSuccess(result) {
+	return result.success;
+}
+
+//#endregion
+//#region src/index.ts
+dotenv.config({ quiet: true });
+const CREATE_DB_WORKER_URL = process.env.CREATE_DB_WORKER_URL || "https://create-db-temp.prisma.io";
+const CLAIM_DB_WORKER_URL = process.env.CLAIM_DB_WORKER_URL || "https://create-db.prisma.io";
+const REGION_COORDINATES = {
+	"ap-southeast-1": {
+		lat: 1.3521,
+		lng: 103.8198
+	},
+	"ap-northeast-1": {
+		lat: 35.6762,
+		lng: 139.6503
+	},
+	"eu-central-1": {
+		lat: 50.1109,
+		lng: 8.6821
+	},
+	"eu-west-3": {
+		lat: 48.8566,
+		lng: 2.3522
+	},
+	"us-east-1": {
+		lat: 38.9072,
+		lng: -77.0369
+	},
+	"us-west-1": {
+		lat: 37.7749,
+		lng: -122.4194
+	}
+};
+const pendingAnalytics = [];
+async function sendAnalytics(eventName, properties, cliRunId) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), 5e3);
+	const promise = (async () => {
+		try {
+			await fetch(`${CREATE_DB_WORKER_URL}/analytics`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({
+					eventName,
+					properties: {
+						distinct_id: cliRunId,
+						...properties
+					}
+				}),
+				signal: controller.signal
+			});
+		} catch {} finally {
+			clearTimeout(timer);
+		}
+	})();
+	pendingAnalytics.push(promise);
+}
+async function flushAnalytics(maxWaitMs = 500) {
+	if (pendingAnalytics.length === 0) return;
+	await Promise.race([Promise.all(pendingAnalytics), new Promise((resolve) => setTimeout(resolve, maxWaitMs))]);
+}
+function getCommandName() {
+	const executable = process.argv[1] || "create-db";
+	if (executable.includes("create-pg")) return "create-pg";
+	if (executable.includes("create-postgres")) return "create-postgres";
+	return "create-db";
+}
+async function detectUserLocation() {
+	try {
+		const response = await fetch("https://ipapi.co/json/", {
+			method: "GET",
+			headers: { "User-Agent": "create-db-cli/1.0" }
+		});
+		if (!response.ok) return null;
+		const data = await response.json();
+		return {
+			country: data.country_code,
+			continent: data.continent_code,
+			city: data.city,
+			region: data.region,
+			latitude: data.latitude,
+			longitude: data.longitude
+		};
+	} catch {
+		return null;
+	}
+}
+function getRegionClosestToLocation(userLocation) {
+	if (!userLocation) return null;
+	const userLat = parseFloat(String(userLocation.latitude));
+	const userLng = parseFloat(String(userLocation.longitude));
+	if (isNaN(userLat) || isNaN(userLng)) return null;
+	let closestRegion = null;
+	let minDistance = Infinity;
+	for (const [region, coordinates] of Object.entries(REGION_COORDINATES)) {
+		const latDiff = (userLat - coordinates.lat) * Math.PI / 180;
+		const lngDiff = (userLng - coordinates.lng) * Math.PI / 180;
+		const a = Math.sin(latDiff / 2) ** 2 + Math.cos(userLat * Math.PI / 180) * Math.cos(coordinates.lat * Math.PI / 180) * Math.sin(lngDiff / 2) ** 2;
+		const distance = 6371 * 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a));
+		if (distance < minDistance) {
+			minDistance = distance;
+			closestRegion = region;
+		}
+	}
+	return closestRegion;
+}
+function readUserEnvFile() {
+	const envPath = path.join(process.cwd(), ".env");
+	if (!fs.existsSync(envPath)) return {};
+	const envContent = fs.readFileSync(envPath, "utf8");
+	const envVars = {};
+	for (const line of envContent.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed && !trimmed.startsWith("#")) {
+			const [key, ...valueParts] = trimmed.split("=");
+			if (key && valueParts.length > 0) {
+				const value = valueParts.join("=").replace(/^["']|["']$/g, "");
+				envVars[key.trim()] = value.trim();
+			}
+		}
+	}
+	return envVars;
+}
+async function checkOnline() {
+	try {
+		if (!(await fetch(`${CREATE_DB_WORKER_URL}/health`)).ok) throw new Error("API not available");
+	} catch {
+		console.error(pc.bold(pc.red("\n✖ Error: Cannot reach Prisma Postgres API server.\n")));
+		console.error(pc.dim(`Check your internet connection or visit ${pc.green("https://www.prisma-status.com/")}\n`));
+		await flushAnalytics();
+		process.exit(1);
+	}
+}
+async function getRegions() {
+	const res = await fetch(`${CREATE_DB_WORKER_URL}/regions`);
+	if (!res.ok) throw new Error(`Failed to fetch regions. Status: ${res.status} ${res.statusText}`);
+	const data = await res.json();
+	return (Array.isArray(data) ? data : data.data ?? []).filter((region) => region.status === "available");
+}
+async function validateRegion(region) {
+	const regionIds = (await getRegions()).map((r) => r.id);
+	if (!regionIds.includes(region)) throw new Error(`Invalid region: ${region}. Available regions: ${regionIds.join(", ")}`);
+	return region;
+}
+async function createDatabaseCore(region, userAgent, cliRunId) {
+	const name = (/* @__PURE__ */ new Date()).toISOString();
+	const runId = cliRunId ?? randomUUID();
+	const resp = await fetch(`${CREATE_DB_WORKER_URL}/create`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			region,
+			name,
+			utm_source: getCommandName(),
+			userAgent
+		})
+	});
+	if (resp.status === 429) {
+		sendAnalytics("create_db:database_creation_failed", {
+			region,
+			"error-type": "rate_limit",
+			"status-code": 429
+		}, runId);
+		return {
+			success: false,
+			error: "rate_limit_exceeded",
+			message: "We're experiencing a high volume of requests. Please try again later.",
+			status: 429
+		};
+	}
+	let result;
+	let raw = "";
+	try {
+		raw = await resp.text();
+		result = JSON.parse(raw);
+	} catch {
+		sendAnalytics("create_db:database_creation_failed", {
+			region,
+			"error-type": "invalid_json",
+			"status-code": resp.status
+		}, runId);
+		return {
+			success: false,
+			error: "invalid_json",
+			message: "Unexpected response from create service.",
+			raw,
+			status: resp.status
+		};
+	}
+	if (result.error) {
+		sendAnalytics("create_db:database_creation_failed", {
+			region,
+			"error-type": "api_error",
+			"error-message": result.error.message
+		}, runId);
+		return {
+			success: false,
+			error: "api_error",
+			message: result.error.message || "Unknown error",
+			details: result.error,
+			status: result.error.status ?? resp.status
+		};
+	}
+	const database = result.data?.database ?? result.databases?.[0];
+	const projectId = result.data?.id ?? result.id ?? "";
+	const apiKeys = database?.apiKeys;
+	const directConnDetails = result.data ? apiKeys?.[0]?.directConnection : result.databases?.[0]?.apiKeys?.[0]?.ppgDirectConnection;
+	const directUser = directConnDetails?.user ? encodeURIComponent(String(directConnDetails.user)) : "";
+	const directPass = directConnDetails?.pass ? encodeURIComponent(String(directConnDetails.pass)) : "";
+	const directHost = directConnDetails?.host;
+	const directPort = directConnDetails?.port ? `:${directConnDetails.port}` : "";
+	const directDbName = directConnDetails?.database || "postgres";
+	const connectionString = directConnDetails && directHost ? `postgresql://${directUser}:${directPass}@${directHost}${directPort}/${directDbName}?sslmode=require` : null;
+	const claimUrl = `${CLAIM_DB_WORKER_URL}/claim?projectID=${projectId}&utm_source=${userAgent || getCommandName()}&utm_medium=cli`;
+	const expiryDate = new Date(Date.now() + 1440 * 60 * 1e3);
+	sendAnalytics("create_db:database_created", {
+		region,
+		utm_source: getCommandName()
+	}, runId);
+	return {
+		success: true,
+		connectionString,
+		claimUrl,
+		deletionDate: expiryDate.toISOString(),
+		region: database?.region?.id || region,
+		name: database?.name ?? name,
+		projectId,
+		userAgent
+	};
+}
+const router = os.router({
+	create: os.meta({
+		description: "Create a new Prisma Postgres database",
+		default: true
+	}).input(z.object({
+		region: RegionSchema.optional().describe("AWS region for the database").meta({ alias: "r" }),
+		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" })
+	})).handler(async ({ input }) => {
+		const cliRunId = randomUUID();
+		const CLI_NAME = getCommandName();
+		let userAgent;
+		const userEnvVars = readUserEnvFile();
+		if (userEnvVars.PRISMA_ACTOR_NAME && userEnvVars.PRISMA_ACTOR_PROJECT) userAgent = `${userEnvVars.PRISMA_ACTOR_NAME}/${userEnvVars.PRISMA_ACTOR_PROJECT}`;
+		sendAnalytics("create_db:cli_command_ran", {
+			command: CLI_NAME,
+			"has-region-flag": !!input.region,
+			"has-interactive-flag": input.interactive,
+			"has-json-flag": input.json,
+			"has-env-flag": !!input.env,
+			"has-user-agent-from-env": !!userAgent,
+			"node-version": process.version,
+			platform: process.platform,
+			arch: process.arch
+		}, cliRunId);
+		let region = input.region ?? "us-east-1";
+		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) {
+				await checkOnline();
+				const regions$1 = await getRegions();
+				const selectedRegion = await select({
+					message: "Choose a region:",
+					options: regions$1.map((r) => ({
+						value: r.id,
+						label: r.name || r.id
+					})),
+					initialValue: regions$1.find((r) => r.id === region)?.id || regions$1[0]?.id
+				});
+				if (isCancel(selectedRegion)) {
+					cancel(pc.red("Operation cancelled."));
+					await flushAnalytics();
+					process.exit(0);
+				}
+				region = selectedRegion;
+				sendAnalytics("create_db:region_selected", {
+					region,
+					"selection-method": "interactive"
+				}, cliRunId);
+			} else if (input.region) {
+				await validateRegion(region);
+				sendAnalytics("create_db:region_selected", {
+					region,
+					"selection-method": "flag"
+				}, cliRunId);
+			}
+			await checkOnline();
+			const result$1 = await createDatabaseCore(region, userAgent, cliRunId);
+			await flushAnalytics();
+			if (input.json) {
+				console.log(JSON.stringify(result$1, null, 2));
+				return;
+			}
+			if (!result$1.success) {
+				console.error(result$1.message);
+				process.exit(1);
+			}
+			try {
+				const targetEnvPath = envPath;
+				const lines = [
+					`DATABASE_URL="${result$1.connectionString ?? ""}"`,
+					`CLAIM_URL="${result$1.claimUrl}"`,
+					""
+				];
+				let prefix = "";
+				if (fs.existsSync(targetEnvPath)) {
+					const existing = fs.readFileSync(targetEnvPath, "utf8");
+					if (existing.length > 0 && !existing.endsWith("\n")) prefix = "\n";
+				}
+				fs.appendFileSync(targetEnvPath, prefix + lines.join("\n"), { encoding: "utf8" });
+				console.log(pc.green(`Wrote DATABASE_URL and CLAIM_URL to ${targetEnvPath}`));
+			} catch (err) {
+				console.error(pc.red(`Failed to write environment variables to ${envPath}: ${err instanceof Error ? err.message : String(err)}`));
+				process.exit(1);
+			}
+			return;
+		}
+		await checkOnline();
+		intro(pc.bold(pc.cyan("🚀 Creating a Prisma Postgres database")));
+		if (input.interactive) {
+			const regions$1 = await getRegions();
+			const selectedRegion = await select({
+				message: "Choose a region:",
+				options: regions$1.map((r) => ({
+					value: r.id,
+					label: r.name || r.id
+				})),
+				initialValue: regions$1.find((r) => r.id === region)?.id || regions$1[0]?.id
+			});
+			if (isCancel(selectedRegion)) {
+				cancel(pc.red("Operation cancelled."));
+				await flushAnalytics();
+				process.exit(0);
+			}
+			region = selectedRegion;
+			sendAnalytics("create_db:region_selected", {
+				region,
+				"selection-method": "interactive"
+			}, cliRunId);
+		} else if (input.region) {
+			await validateRegion(region);
+			sendAnalytics("create_db:region_selected", {
+				region,
+				"selection-method": "flag"
+			}, cliRunId);
+		}
+		const s = spinner();
+		s.start(`Creating database in ${pc.cyan(region)}...`);
+		const result = await createDatabaseCore(region, userAgent, cliRunId);
+		if (!result.success) {
+			s.stop(pc.red(`Error: ${result.message}`));
+			await flushAnalytics();
+			process.exit(1);
+		}
+		s.stop(pc.green("Database created successfully!"));
+		const expiryFormatted = new Date(result.deletionDate).toLocaleString();
+		const clickableUrl = terminalLink(result.claimUrl, result.claimUrl, { fallback: false });
+		log.message("");
+		log.info(pc.bold("Database Connection"));
+		log.message("");
+		if (result.connectionString) {
+			log.message(pc.cyan("  Connection String:"));
+			log.message("  " + pc.yellow(result.connectionString));
+			log.message("");
+		} else {
+			log.warning(pc.yellow("  Connection details are not available."));
+			log.message("");
+		}
+		log.success(pc.bold("Claim Your Database"));
+		log.message(pc.cyan("  Keep your database for free:"));
+		log.message("  " + pc.yellow(clickableUrl));
+		log.message(pc.italic(pc.dim(`  Database will be deleted on ${expiryFormatted} if not claimed.`)));
+		outro(pc.dim("Done!"));
+		await flushAnalytics();
+	}),
+	regions: os.meta({ description: "List available Prisma Postgres regions" }).handler(async () => {
+		const regions$1 = await getRegions();
+		log.message("");
+		log.info(pc.bold(pc.cyan("Available Prisma Postgres regions:")));
+		log.message("");
+		for (const r of regions$1) log.message(`  ${pc.green(r.id)} - ${r.name || r.id}`);
+		log.message("");
+	})
+});
+function createDbCli() {
+	return createCli({
+		router,
+		name: getCommandName(),
+		version: "1.1.0",
+		description: "Instantly create a temporary Prisma Postgres database"
+	});
+}
+createRouterClient(router, { context: {} });
+/**
+* Create a new Prisma Postgres database programmatically.
+*
+* @param options - Options for creating the database
+* @param options.region - The AWS region for the database (optional)
+* @param options.userAgent - Custom user agent string (optional)
+* @returns A promise that resolves to either a {@link DatabaseResult} or {@link DatabaseError}
+*
+* @example
+* ```typescript
+* import { create } from "create-db";
+*
+* const result = await create({ region: "us-east-1" });
+*
+* if (result.success) {
+*   console.log(`Connection string: ${result.connectionString}`);
+*   console.log(`Claim URL: ${result.claimUrl}`);
+* } else {
+*   console.error(`Error: ${result.message}`);
+* }
+* ```
+*/
+async function create(options) {
+	return createDatabaseCore(options?.region || "us-east-1", options?.userAgent);
+}
+/**
+* List available Prisma Postgres regions programmatically.
+*
+* @example
+* ```typescript
+* import { regions } from "create-db";
+*
+* const availableRegions = await regions();
+* console.log(availableRegions);
+* ```
+*/
+async function regions() {
+	return getRegions();
+}
+
+//#endregion
+export { isDatabaseError as a, RegionSchema as i, createDbCli as n, isDatabaseSuccess as o, regions as r, create as t };

package/package.json

@@ -1,8 +1,20 @@
 {
   "name": "create-db",
-  "version": "1.1.1-pr66-version-bump-19346362281.0",
+  "version": "1.1.1-pr67-overhaul-19905444027.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.",
-  "main": "index.js",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs"
+    },
+    "./cli": {
+      "import": "./dist/cli.mjs"
+    }
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
   "author": "prisma",
   "repository": {
     "type": "git",
@@ -20,32 +32,38 @@
     "temporary"
   ],
   "license": "ISC",
-  "type": "module",
   "bin": {
-    "create-db": "./index.js",
-    "create-postgres": "./index.js",
-    "create-pg": "./index.js"
+    "create-db": "./dist/cli.mjs",
+    "create-postgres": "./dist/cli.mjs",
+    "create-pg": "./dist/cli.mjs"
   },
   "dependencies": {
     "@clack/prompts": "^0.11.0",
-    "chalk": "^4.1.2",
-    "clipboardy": "^4.0.0",
-    "dotenv": "^16.6.1",
-    "terminal-link": "^4.0.0"
+    "@orpc/server": "^1.12.2",
+    "dotenv": "^17.2.3",
+    "picocolors": "^1.1.1",
+    "terminal-link": "^5.0.0",
+    "trpc-cli": "^0.12.1",
+    "zod": "^4.1.13",
+    "execa": "^9.6.1"
   },
   "publishConfig": {
     "access": "public"
   },
   "files": [
-    "index.js",
-    "README.md",
-    "analytics.js"
+    "dist",
+    "README.md"
   ],
   "devDependencies": {
-    "execa": "^9.6.0",
-    "vitest": "^3.2.4"
+    "@types/node": "^24.10.1",
+    "tsdown": "0.17.0-beta.5",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.15"
   },
   "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
     "test": "vitest run --reporter=verbose",
     "test:watch": "vitest watch",
     "test:coverage": "vitest run --coverage",