prisma-sql 1.75.7 → 1.75.9

package/dist/generator.cjs

@@ -70,7 +70,7 @@ var require_package = __commonJS({
   "package.json"(exports$1, module) {
     module.exports = {
       name: "prisma-sql",
-      version: "1.75.7",
+      version: "1.75.9",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -7289,25 +7289,6 @@ function stableJson(value) {
     2
   );
 }
-function cleanDatabaseUrl(url) {
-  try {
-    const parsed = new URL(url);
-    parsed.search = "";
-    if (parsed.password) {
-      parsed.password = "***";
-    }
-    if (parsed.username && parsed.username.length > 0) {
-      if (parsed.username.length <= 3) {
-        parsed.username = "***";
-      } else {
-        parsed.username = parsed.username.slice(0, 3) + "***";
-      }
-    }
-    return parsed.toString();
-  } catch (error) {
-    return "[invalid-url]";
-  }
-}
 function createQueryKey(processedQuery) {
   return JSON.stringify(processedQuery, (key, value) => {
     if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -7334,17 +7315,19 @@ function countTotalQueries(queries) {
 function quoteIdent(dialect, ident) {
   return `"${ident.replace(/"/g, '""')}"`;
 }
-function createDatabaseExecutor(params) {
+function createDatabaseExecutor(options) {
   return __async(this, null, function* () {
-    const { databaseUrl, dialect } = params;
+    const { databaseUrl, dialect, connectTimeoutMs = 3e4 } = options;
     if (dialect === "postgres") {
       const postgres = yield import('postgres');
-      cleanDatabaseUrl(databaseUrl);
-      const sql = postgres.default(databaseUrl, { max: 1 });
+      const sql = postgres.default(databaseUrl, {
+        connect_timeout: Math.ceil(connectTimeoutMs / 1e3),
+        max: 1
+      });
       return {
         executor: {
-          query: (sqlStr, params2) => __async(null, null, function* () {
-            return yield sql.unsafe(sqlStr, params2 || []);
+          query: (q, params) => __async(null, null, function* () {
+            return yield sql.unsafe(q, params != null ? params : []);
           })
         },
         cleanup: () => __async(null, null, function* () {
@@ -7352,7 +7335,7 @@ function createDatabaseExecutor(params) {
         })
       };
     }
-    throw new Error(`Dialect ${dialect} not supported for stats collection`);
+    throw new Error(`createDatabaseExecutor does not support dialect: ${dialect}`);
   });
 }
 function extractMeasurableOneToManyEdges(datamodel) {
@@ -7823,6 +7806,7 @@ function emitPlannerGeneratedModule(artifacts) {
 }
 
 // src/code-emitter.ts
+var DB_CONNECT_TIMEOUT_MS = 5e3;
 function extractEnumMappings(datamodel) {
   const mappings = {};
   const fieldTypes = {};
@@ -7893,7 +7877,6 @@ function processAllModelDirectives(directiveResults, config) {
   }
   return { queries, skippedCount };
 }
-var DB_CONNECT_TIMEOUT_MS = 5e3;
 function generateClient(options) {
   return __async(this, null, function* () {
     var _a3;
@@ -7914,61 +7897,17 @@ function generateClient(options) {
     yield promises.mkdir(absoluteOutputDir, { recursive: true });
     let plannerArtifacts = options.plannerArtifacts;
     if (!plannerArtifacts) {
-      let executor = options.executor;
-      let cleanup;
-      if (!executor && datasourceUrl) {
-        let timedOut = false;
-        const timeoutHandle = new Promise((_, reject) => {
-          var _a4;
-          const id = setTimeout(() => {
-            timedOut = true;
-            reject(
-              new Error(
-                `DB connection timed out after ${DB_CONNECT_TIMEOUT_MS}ms`
-              )
-            );
-          }, DB_CONNECT_TIMEOUT_MS);
-          (_a4 = id.unref) == null ? void 0 : _a4.call(id);
-        });
-        try {
-          const dbConn = yield Promise.race([
-            createDatabaseExecutor({
-              databaseUrl: datasourceUrl,
-              dialect: config.dialect
-            }),
-            timeoutHandle
-          ]);
-          if (!timedOut) {
-            executor = dbConn.executor;
-            cleanup = dbConn.cleanup;
-          }
-        } catch (error) {
-          console.warn(
-            "\u26A0 Failed to connect:",
-            error instanceof Error ? error.message : error
-          );
-        }
-      }
-      if (executor) {
-        try {
-          console.log(
-            "\u{1F4CA} Collecting relation cardinalities and roundtrip cost..."
-          );
-          plannerArtifacts = yield collectPlannerArtifacts({
-            executor,
-            datamodel,
-            dialect: config.dialect
-          });
-        } catch (error) {
-          console.warn(
-            "\u26A0 Failed to collect stats:",
-            error instanceof Error ? error.message : error
-          );
-        } finally {
-          if (cleanup) {
-            yield cleanup();
-          }
-        }
+      const skipPlanner = process.env.PRISMA_SQL_SKIP_PLANNER === "1" || process.env.PRISMA_SQL_SKIP_PLANNER === "true";
+      if (skipPlanner) {
+        console.log(
+          "\u23ED Skipping planner stats collection (PRISMA_SQL_SKIP_PLANNER)"
+        );
+      } else {
+        plannerArtifacts = yield collectPlannerWithTimeout(
+          options,
+          config,
+          datasourceUrl
+        );
       }
     }
     if (!plannerArtifacts) {
@@ -8000,6 +7939,61 @@ function generateClient(options) {
     console.log(`\u2713 Output: ${outputPath}`);
   });
 }
+var PLANNER_TOTAL_TIMEOUT_MS = 15e3;
+function collectPlannerWithTimeout(options, config, datasourceUrl) {
+  return __async(this, null, function* () {
+    const timeoutMs = Number(process.env.PRISMA_SQL_PLANNER_TIMEOUT_MS) || PLANNER_TOTAL_TIMEOUT_MS;
+    let cleanup;
+    let settled = false;
+    const work = () => __async(null, null, function* () {
+      let executor = options.executor;
+      if (!executor && datasourceUrl) {
+        const dbConn = yield createDatabaseExecutor({
+          databaseUrl: datasourceUrl,
+          dialect: config.dialect,
+          connectTimeoutMs: DB_CONNECT_TIMEOUT_MS
+        });
+        executor = dbConn.executor;
+        cleanup = dbConn.cleanup;
+      }
+      if (!executor) return void 0;
+      console.log("\u{1F4CA} Collecting relation cardinalities and roundtrip cost...");
+      return yield collectPlannerArtifacts({
+        executor,
+        datamodel: options.datamodel,
+        dialect: config.dialect
+      });
+    });
+    const timeout = new Promise((resolve3) => {
+      const id = setTimeout(() => {
+        settled = true;
+        console.warn(
+          `\u26A0 Planner stats collection timed out after ${timeoutMs}ms, using defaults`
+        );
+        resolve3(void 0);
+      }, timeoutMs);
+      if (typeof id === "object" && "unref" in id) id.unref();
+    });
+    try {
+      const result = yield Promise.race([work(), timeout]);
+      if (settled) return void 0;
+      return result;
+    } catch (error) {
+      if (!settled) {
+        console.warn(
+          "\u26A0 Failed to collect planner stats:",
+          error instanceof Error ? error.message : error
+        );
+      }
+      return void 0;
+    } finally {
+      if (cleanup) {
+        yield cleanup().catch(() => {
+        });
+      }
+    }
+  });
+}
 function generateImports(runtimeImportPath) {
   return `import { 
   buildSQL,