create-db 1.1.1-pr66-version-bump-19346362281.0 → 1.1.1-pr67-overhaul-20068192317.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-CFVkopQv.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-CFVkopQv.mjs";
+
+export { RegionSchema, create, createDbCli, isDatabaseError, isDatabaseSuccess, regions };

package/dist/src-CFVkopQv.mjs

@@ -0,0 +1,528 @@
+#!/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 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([
+	"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/analytics.ts
+const pendingAnalytics = [];
+async function sendAnalytics(eventName, properties, cliRunId, workerUrl) {
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), 5e3);
+	const promise = (async () => {
+		try {
+			await fetch(`${workerUrl}/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))]);
+}
+
+//#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 createDatabaseCore(region, createDbWorkerUrl, claimDbWorkerUrl, userAgent, cliRunId) {
+	const name = (/* @__PURE__ */ new Date()).toISOString();
+	const runId = cliRunId ?? randomUUID();
+	const resp = await fetch(`${createDbWorkerUrl}/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, createDbWorkerUrl);
+		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, createDbWorkerUrl);
+		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, createDbWorkerUrl);
+		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 = `${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, createDbWorkerUrl);
+	return {
+		success: true,
+		connectionString,
+		claimUrl,
+		deletionDate: expiryDate.toISOString(),
+		region: database?.region?.id || region,
+		name: database?.name ?? name,
+		projectId,
+		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",
+		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}`;
+		sendAnalyticsWithUrl("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 checkOnlineWithUrl();
+				const regions$1 = await getRegionsWithUrl();
+				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;
+				sendAnalyticsWithUrl("create_db:region_selected", {
+					region,
+					"selection-method": "interactive"
+				}, cliRunId);
+			} else if (input.region) {
+				await validateRegionWithUrl(region);
+				sendAnalyticsWithUrl("create_db:region_selected", {
+					region,
+					"selection-method": "flag"
+				}, cliRunId);
+			}
+			await checkOnlineWithUrl();
+			const result$1 = await createDatabaseCoreWithUrl(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 checkOnlineWithUrl();
+		intro(pc.bold(pc.cyan("🚀 Creating a Prisma Postgres database")));
+		if (input.interactive) {
+			const regions$1 = await getRegionsWithUrl();
+			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;
+			sendAnalyticsWithUrl("create_db:region_selected", {
+				region,
+				"selection-method": "interactive"
+			}, cliRunId);
+		} else if (input.region) {
+			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 createDatabaseCoreWithUrl(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 getRegionsWithUrl();
+		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 createDatabaseCoreWithUrl(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 getRegionsWithUrl();
+}
+
+//#endregion
+export { isDatabaseError as a, RegionSchema as i, createDbCli as n, isDatabaseSuccess as o, regions as r, create as t };