create-db 1.1.1-pr67-overhaul-19905444027.0 → 1.1.1-pr67-overhaul-20068192317.0

package/dist/cli.mjs

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

package/dist/index.mjs

@@ -1,4 +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";
+import { a as isDatabaseError, i as RegionSchema, n as createDbCli, o as isDatabaseSuccess, r as regions, t as create } from "./src-CFVkopQv.mjs";
 
 export { RegionSchema, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };

package/dist/{src-CWxeHoyI.mjs → src-CFVkopQv.mjs}

@@ -4,11 +4,11 @@ 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";
+import path from "path";
 
 //#region src/types.ts
 const RegionSchema = z$1.enum([
@@ -27,43 +27,14 @@ function isDatabaseSuccess(result) {
 }
 
 //#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
-	}
-};
+//#region src/analytics.ts
 const pendingAnalytics = [];
-async function sendAnalytics(eventName, properties, cliRunId) {
+async function sendAnalytics(eventName, properties, cliRunId, workerUrl) {
 	const controller = new AbortController();
 	const timer = setTimeout(() => controller.abort(), 5e3);
 	const promise = (async () => {
 		try {
-			await fetch(`${CREATE_DB_WORKER_URL}/analytics`, {
+			await fetch(`${workerUrl}/analytics`, {
 				method: "POST",
 				headers: { "Content-Type": "application/json" },
 				body: JSON.stringify({
@@ -85,93 +56,19 @@ async function flushAnalytics(maxWaitMs = 500) {
 	if (pendingAnalytics.length === 0) return;
 	await Promise.race([Promise.all(pendingAnalytics), new Promise((resolve) => setTimeout(resolve, maxWaitMs))]);
 }
+
+//#endregion
+//#region src/database.ts
 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) {
+async function createDatabaseCore(region, createDbWorkerUrl, claimDbWorkerUrl, userAgent, cliRunId) {
 	const name = (/* @__PURE__ */ new Date()).toISOString();
 	const runId = cliRunId ?? randomUUID();
-	const resp = await fetch(`${CREATE_DB_WORKER_URL}/create`, {
+	const resp = await fetch(`${createDbWorkerUrl}/create`, {
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({
@@ -186,7 +83,7 @@ async function createDatabaseCore(region, userAgent, cliRunId) {
 			region,
 			"error-type": "rate_limit",
 			"status-code": 429
-		}, runId);
+		}, runId, createDbWorkerUrl);
 		return {
 			success: false,
 			error: "rate_limit_exceeded",
@@ -204,7 +101,7 @@ async function createDatabaseCore(region, userAgent, cliRunId) {
 			region,
 			"error-type": "invalid_json",
 			"status-code": resp.status
-		}, runId);
+		}, runId, createDbWorkerUrl);
 		return {
 			success: false,
 			error: "invalid_json",
@@ -218,7 +115,7 @@ async function createDatabaseCore(region, userAgent, cliRunId) {
 			region,
 			"error-type": "api_error",
 			"error-message": result.error.message
-		}, runId);
+		}, runId, createDbWorkerUrl);
 		return {
 			success: false,
 			error: "api_error",
@@ -237,12 +134,12 @@ async function createDatabaseCore(region, userAgent, cliRunId) {
 	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 claimUrl = `${claimDbWorkerUrl}/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);
+	}, runId, createDbWorkerUrl);
 	return {
 		success: true,
 		connectionString,
@@ -254,6 +151,173 @@ async function createDatabaseCore(region, userAgent, cliRunId) {
 		userAgent
 	};
 }
+
+//#endregion
+//#region src/env-utils.ts
+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;
+}
+
+//#endregion
+//#region src/geolocation.ts
+const TEST_LOCATION = null;
+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
+	}
+};
+/**
+* Calculate the great-circle distance between two points on Earth using the Haversine formula.
+* @param lat1 Latitude of first point in degrees
+* @param lng1 Longitude of first point in degrees
+* @param lat2 Latitude of second point in degrees
+* @param lng2 Longitude of second point in degrees
+* @returns Distance in kilometers
+*/
+function calculateHaversineDistance(lat1, lng1, lat2, lng2) {
+	const EARTH_RADIUS_KM = 6371;
+	const toRadians = (degrees) => degrees * Math.PI / 180;
+	const lat1Rad = toRadians(lat1);
+	const lat2Rad = toRadians(lat2);
+	const deltaLatRad = toRadians(lat2 - lat1);
+	const deltaLngRad = toRadians(lng2 - lng1);
+	const a = Math.sin(deltaLatRad / 2) ** 2 + Math.cos(lat1Rad) * Math.cos(lat2Rad) * Math.sin(deltaLngRad / 2) ** 2;
+	return EARTH_RADIUS_KM * (2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a)));
+}
+/**
+* Detect user's location via IP geolocation API or test location override.
+* Returns null if detection fails or times out.
+*/
+async function detectUserLocation() {
+	if (TEST_LOCATION !== null) return {
+		country: "TEST",
+		continent: "TEST",
+		city: "Test City",
+		region: "Test Region",
+		latitude: TEST_LOCATION.latitude,
+		longitude: TEST_LOCATION.longitude
+	};
+	const controller = new AbortController();
+	const timeout = setTimeout(() => controller.abort(), 3e3);
+	try {
+		const response = await fetch("https://ipapi.co/json/", {
+			method: "GET",
+			headers: { "User-Agent": "create-db-cli/1.0" },
+			signal: controller.signal
+		});
+		if (!response.ok) return null;
+		const data = await response.json();
+		if (typeof data.latitude !== "number" || typeof data.longitude !== "number" || !Number.isFinite(data.latitude) || !Number.isFinite(data.longitude)) return null;
+		return {
+			country: data.country_code,
+			continent: data.continent_code,
+			city: data.city,
+			region: data.region,
+			latitude: data.latitude,
+			longitude: data.longitude
+		};
+	} catch {
+		return null;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+/**
+* Find the closest AWS region to a given location using Haversine distance.
+* Returns null if the location is invalid or missing coordinates.
+*/
+function getRegionClosestToLocation(userLocation) {
+	if (!userLocation || userLocation.latitude == null || userLocation.longitude == null) return null;
+	const userLat = typeof userLocation.latitude === "number" ? userLocation.latitude : parseFloat(String(userLocation.latitude));
+	const userLng = typeof userLocation.longitude === "number" ? userLocation.longitude : parseFloat(String(userLocation.longitude));
+	if (!Number.isFinite(userLat) || !Number.isFinite(userLng)) return null;
+	let closestRegion = null;
+	let minDistance = Infinity;
+	for (const [regionId, coords] of Object.entries(REGION_COORDINATES)) {
+		const distance = calculateHaversineDistance(userLat, userLng, coords.lat, coords.lng);
+		if (distance < minDistance) {
+			minDistance = distance;
+			closestRegion = regionId;
+		}
+	}
+	return closestRegion;
+}
+
+//#endregion
+//#region src/regions.ts
+async function checkOnline(workerUrl) {
+	try {
+		if (!(await fetch(`${workerUrl}/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`));
+		throw new Error("Cannot reach API server");
+	}
+}
+async function getRegions(workerUrl) {
+	const res = await fetch(`${workerUrl}/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, workerUrl) {
+	const regionIds = (await getRegions(workerUrl)).map((r) => r.id);
+	if (!regionIds.includes(region)) throw new Error(`Invalid region: ${region}. Available regions: ${regionIds.join(", ")}`);
+	return region;
+}
+
+//#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 sendAnalyticsWithUrl = (eventName, properties, cliRunId) => sendAnalytics(eventName, properties, cliRunId, CREATE_DB_WORKER_URL);
+const checkOnlineWithUrl = async () => {
+	try {
+		await checkOnline(CREATE_DB_WORKER_URL);
+	} catch {
+		await flushAnalytics();
+		process.exit(1);
+	}
+};
+const getRegionsWithUrl = () => getRegions(CREATE_DB_WORKER_URL);
+const validateRegionWithUrl = (region) => validateRegion(region, CREATE_DB_WORKER_URL);
+const createDatabaseCoreWithUrl = (region, userAgent, cliRunId) => createDatabaseCore(region, CREATE_DB_WORKER_URL, CLAIM_DB_WORKER_URL, userAgent, cliRunId);
 const router = os.router({
 	create: os.meta({
 		description: "Create a new Prisma Postgres database",
@@ -269,7 +333,7 @@ const router = os.router({
 		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", {
+		sendAnalyticsWithUrl("create_db:cli_command_ran", {
 			command: CLI_NAME,
 			"has-region-flag": !!input.region,
 			"has-interactive-flag": input.interactive,
@@ -286,8 +350,8 @@ const router = os.router({
 		const envEnabled = typeof envPath === "string" && envPath.trim().length > 0;
 		if (input.json || envEnabled) {
 			if (input.interactive) {
-				await checkOnline();
-				const regions$1 = await getRegions();
+				await checkOnlineWithUrl();
+				const regions$1 = await getRegionsWithUrl();
 				const selectedRegion = await select({
 					message: "Choose a region:",
 					options: regions$1.map((r) => ({
@@ -302,19 +366,19 @@ const router = os.router({
 					process.exit(0);
 				}
 				region = selectedRegion;
-				sendAnalytics("create_db:region_selected", {
+				sendAnalyticsWithUrl("create_db:region_selected", {
 					region,
 					"selection-method": "interactive"
 				}, cliRunId);
 			} else if (input.region) {
-				await validateRegion(region);
-				sendAnalytics("create_db:region_selected", {
+				await validateRegionWithUrl(region);
+				sendAnalyticsWithUrl("create_db:region_selected", {
 					region,
 					"selection-method": "flag"
 				}, cliRunId);
 			}
-			await checkOnline();
-			const result$1 = await createDatabaseCore(region, userAgent, cliRunId);
+			await checkOnlineWithUrl();
+			const result$1 = await createDatabaseCoreWithUrl(region, userAgent, cliRunId);
 			await flushAnalytics();
 			if (input.json) {
 				console.log(JSON.stringify(result$1, null, 2));
@@ -344,10 +408,10 @@ const router = os.router({
 			}
 			return;
 		}
-		await checkOnline();
+		await checkOnlineWithUrl();
 		intro(pc.bold(pc.cyan("🚀 Creating a Prisma Postgres database")));
 		if (input.interactive) {
-			const regions$1 = await getRegions();
+			const regions$1 = await getRegionsWithUrl();
 			const selectedRegion = await select({
 				message: "Choose a region:",
 				options: regions$1.map((r) => ({
@@ -362,20 +426,20 @@ const router = os.router({
 				process.exit(0);
 			}
 			region = selectedRegion;
-			sendAnalytics("create_db:region_selected", {
+			sendAnalyticsWithUrl("create_db:region_selected", {
 				region,
 				"selection-method": "interactive"
 			}, cliRunId);
 		} else if (input.region) {
-			await validateRegion(region);
-			sendAnalytics("create_db:region_selected", {
+			await validateRegionWithUrl(region);
+			sendAnalyticsWithUrl("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);
+		const result = await createDatabaseCoreWithUrl(region, userAgent, cliRunId);
 		if (!result.success) {
 			s.stop(pc.red(`Error: ${result.message}`));
 			await flushAnalytics();
@@ -403,7 +467,7 @@ const router = os.router({
 		await flushAnalytics();
 	}),
 	regions: os.meta({ description: "List available Prisma Postgres regions" }).handler(async () => {
-		const regions$1 = await getRegions();
+		const regions$1 = await getRegionsWithUrl();
 		log.message("");
 		log.info(pc.bold(pc.cyan("Available Prisma Postgres regions:")));
 		log.message("");
@@ -443,7 +507,7 @@ createRouterClient(router, { context: {} });
 * ```
 */
 async function create(options) {
-	return createDatabaseCore(options?.region || "us-east-1", options?.userAgent);
+	return createDatabaseCoreWithUrl(options?.region || "us-east-1", options?.userAgent);
 }
 /**
 * List available Prisma Postgres regions programmatically.
@@ -457,7 +521,7 @@ async function create(options) {
 * ```
 */
 async function regions() {
-	return getRegions();
+	return getRegionsWithUrl();
 }
 
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-db",
-  "version": "1.1.1-pr67-overhaul-19905444027.0",
+  "version": "1.1.1-pr67-overhaul-20068192317.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": {