create-db 1.0.10 → 1.1.0

package/index.js

@@ -10,31 +10,49 @@ import chalk from "chalk";
 
 dotenv.config();
 
-const CLI_RUN_ID = randomUUID();
-
 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";
 
-async function sendAnalyticsToWorker(eventName, properties) {
+// Track pending analytics promises to ensure they complete before exit
+const pendingAnalytics = [];
+
+async function sendAnalyticsToWorker(eventName, properties, cliRunId) {
   const controller = new AbortController();
-  const timer = setTimeout(() => controller.abort(), 2000);
-  try {
-    const payload = {
-      eventName,
-      properties: { distinct_id: CLI_RUN_ID, ...(properties || {}) },
-    };
-    await fetch(`${CREATE_DB_WORKER_URL}/analytics`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify(payload),
-      signal: controller.signal,
-    });
-  } catch (error) {
-  } finally {
-    clearTimeout(timer);
-  }
+  const timer = setTimeout(() => controller.abort(), 5000);
+
+  const analyticsPromise = (async () => {
+    try {
+      const payload = {
+        eventName,
+        properties: { distinct_id: cliRunId, ...(properties || {}) },
+      };
+      await fetch(`${CREATE_DB_WORKER_URL}/analytics`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        signal: controller.signal,
+      });
+    } catch (error) {
+      // Silently fail - analytics shouldn't block CLI
+    } finally {
+      clearTimeout(timer);
+    }
+  })();
+
+  pendingAnalytics.push(analyticsPromise);
+  return analyticsPromise;
+}
+
+// Wait for all pending analytics with a timeout
+async function flushAnalytics(maxWaitMs = 500) {
+  if (pendingAnalytics.length === 0) return;
+
+  const timeout = new Promise((resolve) => setTimeout(resolve, maxWaitMs));
+  const allAnalytics = Promise.all(pendingAnalytics);
+
+  await Promise.race([allAnalytics, timeout]);
 }
 
 async function detectUserLocation() {
@@ -73,7 +91,7 @@ const REGION_COORDINATES = {
   "us-west-1": { lat: 37.7749, lng: -122.4194 }, // N. California
 };
 
-function getRegionClosestToLocation(userLocation) {
+export function getRegionClosestToLocation(userLocation) {
   if (!userLocation) return null;
 
   const userLat = parseFloat(userLocation.latitude);
@@ -135,11 +153,12 @@ async function isOffline() {
         `Check your internet connection or visit ${chalk.green("https://www.prisma-status.com/\n")}`
       )
     );
+    await flushAnalytics();
     process.exit(1);
   }
 }
 
-function getCommandName() {
+export 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";
@@ -205,6 +224,7 @@ Examples:
   ${chalk.gray(`npx ${CLI_NAME} --env --region us-east-1`)}
   ${chalk.gray(`npx ${CLI_NAME} --env >> .env`)}
 `);
+  await flushAnalytics();
   process.exit(0);
 }
 
@@ -384,7 +404,7 @@ function handleError(message, extra = "") {
   process.exit(1);
 }
 
-async function promptForRegion(defaultRegion, userAgent) {
+async function promptForRegion(defaultRegion, userAgent, cliRunId) {
   let regions;
   try {
     regions = await getRegions();
@@ -405,20 +425,31 @@ async function promptForRegion(defaultRegion, userAgent) {
 
   if (region === null) {
     cancel(chalk.red("Operation cancelled."));
+    await flushAnalytics();
     process.exit(0);
   }
 
-  void sendAnalyticsToWorker("create_db:region_selected", {
-    command: CLI_NAME,
-    region: region,
-    "selection-method": "interactive",
-    "user-agent": userAgent,
-  });
+  void sendAnalyticsToWorker(
+    "create_db:region_selected",
+    {
+      command: CLI_NAME,
+      region: region,
+      "selection-method": "interactive",
+      "user-agent": userAgent,
+    },
+    cliRunId
+  );
 
   return region;
 }
 
-async function createDatabase(name, region, userAgent, silent = false) {
+async function createDatabase(
+  name,
+  region,
+  userAgent,
+  cliRunId,
+  silent = false
+) {
   let s;
   if (!silent) {
     s = spinner();
@@ -431,7 +462,8 @@ async function createDatabase(name, region, userAgent, silent = false) {
     body: JSON.stringify({
       region,
       name,
-      utm_source: userAgent || CLI_NAME,
+      utm_source: CLI_NAME,
+      userAgent,
     }),
   });
 
@@ -451,14 +483,19 @@ async function createDatabase(name, region, userAgent, silent = false) {
       );
     }
 
-    void sendAnalyticsToWorker("create_db:database_creation_failed", {
-      command: CLI_NAME,
-      region: region,
-      "error-type": "rate_limit",
-      "status-code": 429,
-      "user-agent": userAgent,
-    });
+    void sendAnalyticsToWorker(
+      "create_db:database_creation_failed",
+      {
+        command: CLI_NAME,
+        region: region,
+        "error-type": "rate_limit",
+        "status-code": 429,
+        "user-agent": userAgent,
+      },
+      cliRunId
+    );
 
+    await flushAnalytics();
     process.exit(1);
   }
 
@@ -480,20 +517,24 @@ async function createDatabase(name, region, userAgent, silent = false) {
       s.stop("Unexpected response from create service.");
     }
 
-    void sendAnalyticsToWorker("create_db:database_creation_failed", {
-      command: CLI_NAME,
-      region,
-      "error-type": "invalid_json",
-      "status-code": resp.status,
-      "user-agent": userAgent,
-    });
+    void sendAnalyticsToWorker(
+      "create_db:database_creation_failed",
+      {
+        command: CLI_NAME,
+        region,
+        "error-type": "invalid_json",
+        "status-code": resp.status,
+        "user-agent": userAgent,
+      },
+      cliRunId
+    );
 
+    await flushAnalytics();
     process.exit(1);
   }
 
   const database = result.data ? result.data.database : result.databases?.[0];
   const projectId = result.data ? result.data.id : result.id;
-  const prismaConn = database?.connectionString;
 
   const directConnDetails = result.data
     ? database?.apiKeys?.[0]?.directConnection
@@ -519,8 +560,7 @@ async function createDatabase(name, region, userAgent, silent = false) {
 
   if (silent && !result.error) {
     const jsonResponse = {
-      connectionString: prismaConn,
-      directConnectionString: directConn,
+      connectionString: directConn,
       claimUrl: claimUrl,
       deletionDate: expiryDate.toISOString(),
       region: database?.region?.id || region,
@@ -551,14 +591,19 @@ async function createDatabase(name, region, userAgent, silent = false) {
       );
     }
 
-    void sendAnalyticsToWorker("create_db:database_creation_failed", {
-      command: CLI_NAME,
-      region: region,
-      "error-type": "api_error",
-      "error-message": result.error.message,
-      "user-agent": userAgent,
-    });
+    void sendAnalyticsToWorker(
+      "create_db:database_creation_failed",
+      {
+        command: CLI_NAME,
+        region: region,
+        "error-type": "api_error",
+        "error-message": result.error.message,
+        "user-agent": userAgent,
+      },
+      cliRunId
+    );
 
+    await flushAnalytics();
     process.exit(1);
   }
 
@@ -568,57 +613,50 @@ async function createDatabase(name, region, userAgent, silent = false) {
 
   const expiryFormatted = expiryDate.toLocaleString();
 
+  log.message("");
+  log.info(chalk.bold("Database Connection"));
   log.message("");
 
-  log.info(chalk.bold("Connect to your database →"));
-
-  if (prismaConn) {
-    log.message(
-      chalk.magenta("  Use this connection string optimized for Prisma ORM:")
-    );
-    log.message("  " + chalk.yellow(prismaConn));
-    log.message("");
-  }
-
+  // Direct connection (only output this one)
   if (directConn) {
-    log.message(
-      chalk.cyan("  Use this connection string for everything else:")
-    );
+    log.message(chalk.cyan("  Connection String:"));
     log.message("  " + chalk.yellow(directConn));
     log.message("");
   } else {
-    log.warning(
-      chalk.yellow(
-        "Direct connection details are not available in the API response."
-      )
-    );
+    log.warning(chalk.yellow("  Connection details are not available."));
+    log.message("");
   }
 
+
+  // Claim database section
   const clickableUrl = terminalLink(claimUrl, claimUrl, { fallback: false });
-  log.success(`${chalk.bold("Claim your database →")}`);
-  log.message(
-    chalk.cyan("  Want to keep your database? Claim for free via this link:")
-  );
+  log.success(chalk.bold("Claim Your Database"));
+  log.message(chalk.cyan("  Keep your database for free:"));
   log.message("  " + chalk.yellow(clickableUrl));
   log.message(
     chalk.italic(
       chalk.gray(
-        "  Your database will be deleted on " +
-          expiryFormatted +
-          " if not claimed."
+        `  Database will be deleted on ${expiryFormatted} if not claimed.`
       )
     )
   );
 
-  void sendAnalyticsToWorker("create_db:database_created", {
-    command: CLI_NAME,
-    region,
-    utm_source: CLI_NAME,
-  });
+  void sendAnalyticsToWorker(
+    "create_db:database_created",
+    {
+      command: CLI_NAME,
+      region,
+      utm_source: CLI_NAME,
+    },
+    cliRunId
+  );
 }
 
-async function main() {
+export async function main() {
   try {
+    // Generate unique ID for this CLI run
+    const cliRunId = randomUUID();
+
     const rawArgs = process.argv.slice(2);
 
     const { flags } = await parseArgs();
@@ -631,22 +669,27 @@ async function main() {
       userAgent = `${userEnvVars.PRISMA_ACTOR_NAME}/${userEnvVars.PRISMA_ACTOR_PROJECT}`;
     }
 
-    void sendAnalyticsToWorker("create_db:cli_command_ran", {
-      command: CLI_NAME,
-      "full-command": `${CLI_NAME} ${rawArgs.join(" ")}`.trim(),
-      "has-region-flag": rawArgs.includes("--region") || rawArgs.includes("-r"),
-      "has-interactive-flag":
-        rawArgs.includes("--interactive") || rawArgs.includes("-i"),
-      "has-help-flag": rawArgs.includes("--help") || rawArgs.includes("-h"),
-      "has-list-regions-flag": rawArgs.includes("--list-regions"),
-      "has-json-flag": rawArgs.includes("--json") || rawArgs.includes("-j"),
-      "has-env-flag": rawArgs.includes("--env") || rawArgs.includes("-e"),
-      "has-user-agent-from-env": !!userAgent,
-      "node-version": process.version,
-      platform: process.platform,
-      arch: process.arch,
-      "user-agent": userAgent,
-    });
+    void sendAnalyticsToWorker(
+      "create_db:cli_command_ran",
+      {
+        command: CLI_NAME,
+        "full-command": `${CLI_NAME} ${rawArgs.join(" ")}`.trim(),
+        "has-region-flag":
+          rawArgs.includes("--region") || rawArgs.includes("-r"),
+        "has-interactive-flag":
+          rawArgs.includes("--interactive") || rawArgs.includes("-i"),
+        "has-help-flag": rawArgs.includes("--help") || rawArgs.includes("-h"),
+        "has-list-regions-flag": rawArgs.includes("--list-regions"),
+        "has-json-flag": rawArgs.includes("--json") || rawArgs.includes("-j"),
+        "has-env-flag": rawArgs.includes("--env") || rawArgs.includes("-e"),
+        "has-user-agent-from-env": !!userAgent,
+        "node-version": process.version,
+        platform: process.platform,
+        arch: process.arch,
+        "user-agent": userAgent,
+      },
+      cliRunId
+    );
 
     if (!flags.help && !flags.json) {
       await isOffline();
@@ -666,18 +709,23 @@ async function main() {
 
     if (flags["list-regions"]) {
       await listRegions();
+      await flushAnalytics();
       process.exit(0);
     }
 
     if (flags.region) {
       region = flags.region;
 
-      void sendAnalyticsToWorker("create_db:region_selected", {
-        command: CLI_NAME,
-        region: region,
-        "selection-method": "flag",
-        "user-agent": userAgent,
-      });
+      void sendAnalyticsToWorker(
+        "create_db:region_selected",
+        {
+          command: CLI_NAME,
+          region: region,
+          "selection-method": "flag",
+          "user-agent": userAgent,
+        },
+        cliRunId
+      );
     }
 
     if (flags.interactive) {
@@ -687,12 +735,19 @@ async function main() {
     if (flags.json) {
       try {
         if (chooseRegionPrompt) {
-          region = await promptForRegion(region, userAgent);
+          region = await promptForRegion(region, userAgent, cliRunId);
         } else {
           await validateRegion(region, true);
         }
-        const result = await createDatabase(name, region, userAgent, true);
+        const result = await createDatabase(
+          name,
+          region,
+          userAgent,
+          cliRunId,
+          true
+        );
         console.log(JSON.stringify(result, null, 2));
+        await flushAnalytics();
         process.exit(0);
       } catch (e) {
         console.log(
@@ -702,6 +757,7 @@ async function main() {
             2
           )
         );
+        await flushAnalytics();
         process.exit(1);
       }
     }
@@ -709,20 +765,29 @@ async function main() {
     if (flags.env) {
       try {
         if (chooseRegionPrompt) {
-          region = await promptForRegion(region, userAgent);
+          region = await promptForRegion(region, userAgent, cliRunId);
         } else {
           await validateRegion(region, true);
         }
-        const result = await createDatabase(name, region, userAgent, true);
+        const result = await createDatabase(
+          name,
+          region,
+          userAgent,
+          cliRunId,
+          true
+        );
         if (result.error) {
           console.error(result.message || "Unknown error");
+          await flushAnalytics();
           process.exit(1);
         }
-        console.log(`DATABASE_URL="${result.directConnectionString}"`);
+        console.log(`DATABASE_URL="${result.connectionString}"`);
         console.error("\n# Claim your database at: " + result.claimUrl);
+        await flushAnalytics();
         process.exit(0);
       } catch (e) {
         console.error(e?.message || String(e));
+        await flushAnalytics();
         process.exit(1);
       }
     }
@@ -737,18 +802,35 @@ async function main() {
       )
     );
     if (chooseRegionPrompt) {
-      region = await promptForRegion(region, userAgent);
+      region = await promptForRegion(region, userAgent, cliRunId);
     }
 
     region = await validateRegion(region);
 
-    await createDatabase(name, region, userAgent);
+    await createDatabase(name, region, userAgent, cliRunId);
 
     outro("");
+    await flushAnalytics();
   } catch (error) {
     console.error("Error:", error.message);
+    await flushAnalytics();
     process.exit(1);
   }
 }
 
-main();
+// Run main() if this file is being executed directly
+const isDirectExecution =
+  import.meta.url.endsWith("/index.js") ||
+  process.argv[1] === import.meta.url.replace("file://", "") ||
+  process.argv[1].includes("create-db") ||
+  process.argv[1].includes("create-pg") ||
+  process.argv[1].includes("create-postgres");
+
+if (isDirectExecution && !process.env.__CREATE_DB_EXECUTING) {
+  process.env.__CREATE_DB_EXECUTING = "true";
+  main().catch(console.error);
+}
+
+// if (import.meta.url.endsWith('/index.js') || process.argv[1] === import.meta.url.replace('file://', '')) {
+//   main().catch(console.error);
+// }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "create-db",
-  "version": "1.0.10",
+  "version": "1.1.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",
-  "author": "",
+  "author": "prisma",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/prisma/create-db.git"
@@ -40,5 +40,15 @@
     "index.js",
     "README.md",
     "analytics.js"
-  ]
+  ],
+  "devDependencies": {
+    "execa": "^9.6.0",
+    "vitest": "^3.2.4"
+  },
+  "scripts": {
+    "test": "vitest run --reporter=verbose",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "test:clean": "vitest run"
+  }
 }