prisma-sql 1.75.9 → 1.75.10

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.9",
+      version: "1.75.10",
       description: "Convert Prisma queries to optimized SQL with type safety. 2-7x faster than Prisma Client.",
       main: "dist/index.cjs",
       module: "dist/index.js",
@@ -7244,38 +7244,6 @@ function generateSQL2(directive) {
 }
 
 // src/utils/pure-utils.ts
-function toNumberOrZero(v) {
-  if (typeof v === "number" && Number.isFinite(v)) return v;
-  if (typeof v === "bigint") return Number(v);
-  if (typeof v === "string" && v.trim() !== "") {
-    const n = Number(v);
-    if (Number.isFinite(n)) return n;
-  }
-  return 0;
-}
-function clampStatsMonotonic(avg, p95, p99, max, coverage) {
-  const safeAvg = Math.max(1, avg);
-  const safeP95 = Math.max(safeAvg, p95);
-  const safeP99 = Math.max(safeP95, p99);
-  const safeMax = Math.max(safeP99, max);
-  const safeCoverage = Math.max(0, Math.min(1, coverage));
-  return {
-    avg: safeAvg,
-    p95: safeP95,
-    p99: safeP99,
-    max: safeMax,
-    coverage: safeCoverage
-  };
-}
-function normalizeStats(row) {
-  return clampStatsMonotonic(
-    toNumberOrZero(row.avg),
-    toNumberOrZero(row.p95),
-    toNumberOrZero(row.p99),
-    toNumberOrZero(row.max),
-    toNumberOrZero(row.coverage)
-  );
-}
 function stableJson(value) {
   return JSON.stringify(
     value,
@@ -7312,486 +7280,6 @@ function countTotalQueries(queries) {
 }
 
 // src/cardinality-planner.ts
-function quoteIdent(dialect, ident) {
-  return `"${ident.replace(/"/g, '""')}"`;
-}
-function createDatabaseExecutor(options) {
-  return __async(this, null, function* () {
-    const { databaseUrl, dialect, connectTimeoutMs = 3e4 } = options;
-    if (dialect === "postgres") {
-      const postgres = yield import('postgres');
-      const sql = postgres.default(databaseUrl, {
-        connect_timeout: Math.ceil(connectTimeoutMs / 1e3),
-        max: 1
-      });
-      return {
-        executor: {
-          query: (q, params) => __async(null, null, function* () {
-            return yield sql.unsafe(q, params != null ? params : []);
-          })
-        },
-        cleanup: () => __async(null, null, function* () {
-          yield sql.end();
-        })
-      };
-    }
-    throw new Error(`createDatabaseExecutor does not support dialect: ${dialect}`);
-  });
-}
-function extractMeasurableOneToManyEdges(datamodel) {
-  const modelByName = new Map(datamodel.models.map((m) => [m.name, m]));
-  const edges = [];
-  for (const parent of datamodel.models) {
-    const pkFields = parent.fields.filter((f) => f.isId);
-    if (pkFields.length === 0) continue;
-    pkFields.map((f) => f.dbName || f.name);
-    const parentTable = parent.dbName || parent.name;
-    for (const f of parent.fields) {
-      if (!f.relationName) continue;
-      if (!f.isList) continue;
-      const child = modelByName.get(f.type);
-      if (!child) continue;
-      const childRelField = child.fields.find(
-        (cf) => cf.relationName === f.relationName && cf.type === parent.name
-      );
-      if (!childRelField) continue;
-      const fkFieldNames = childRelField.relationFromFields || [];
-      if (fkFieldNames.length === 0) continue;
-      const fkFields = fkFieldNames.map((name) => {
-        const fld = child.fields.find((x) => x.name === name);
-        return fld ? fld.dbName || fld.name : name;
-      });
-      const refFieldNames = childRelField.relationToFields || [];
-      if (refFieldNames.length === 0) continue;
-      const references = refFieldNames.map((name) => {
-        const fld = parent.fields.find((x) => x.name === name);
-        return fld ? fld.dbName || fld.name : name;
-      });
-      if (fkFields.length !== references.length) continue;
-      const childTable = child.dbName || child.name;
-      edges.push({
-        parentModel: parent.name,
-        relName: f.name,
-        childModel: child.name,
-        parentTable,
-        childTable,
-        parentPkColumns: references,
-        childFkColumns: fkFields,
-        isMany: true
-      });
-    }
-  }
-  return edges;
-}
-function buildPostgresStatsSql(edge) {
-  const childTable = quoteIdent("postgres", edge.childTable);
-  const parentTable = quoteIdent("postgres", edge.parentTable);
-  const groupCols = edge.childFkColumns.map((c) => quoteIdent("postgres", c)).join(", ");
-  return `
-WITH counts AS (
-  SELECT ${groupCols}, COUNT(*) AS cnt
-  FROM ${childTable}
-  GROUP BY ${groupCols}
-),
-total_parents AS (
-  SELECT COUNT(*) AS total FROM ${parentTable}
-)
-SELECT
-  AVG(cnt)::float AS avg,
-  MAX(cnt)::int AS max,
-  PERCENTILE_CONT(0.95) WITHIN GROUP (ORDER BY cnt)::float AS p95,
-  PERCENTILE_CONT(0.99) WITHIN GROUP (ORDER BY cnt)::float AS p99,
-  (SELECT COUNT(*) FROM counts)::float / GREATEST(1, (SELECT total FROM total_parents)) AS coverage
-FROM counts
-`.trim();
-}
-function buildSqliteStatsSql(edge) {
-  const childTable = quoteIdent("sqlite", edge.childTable);
-  const parentTable = quoteIdent("sqlite", edge.parentTable);
-  const groupCols = edge.childFkColumns.map((c) => quoteIdent("sqlite", c)).join(", ");
-  return `
-WITH counts AS (
-  SELECT ${groupCols}, COUNT(*) AS cnt
-  FROM ${childTable}
-  GROUP BY ${groupCols}
-),
-n AS (
-  SELECT COUNT(*) AS total FROM counts
-),
-parent_n AS (
-  SELECT COUNT(*) AS total FROM ${parentTable}
-),
-ordered AS (
-  SELECT cnt
-  FROM counts
-  ORDER BY cnt
-)
-SELECT
-  (SELECT AVG(cnt) FROM counts) AS avg,
-  (SELECT MAX(cnt) FROM counts) AS max,
-  (
-    SELECT cnt
-    FROM ordered
-    LIMIT 1
-    OFFSET (
-      SELECT
-        CASE
-          WHEN total <= 1 THEN 0
-          ELSE CAST((0.95 * (total - 1)) AS INT)
-        END
-      FROM n
-    )
-  ) AS p95,
-  (
-    SELECT cnt
-    FROM ordered
-    LIMIT 1
-    OFFSET (
-      SELECT
-        CASE
-          WHEN total <= 1 THEN 0
-          ELSE CAST((0.99 * (total - 1)) AS INT)
-        END
-      FROM n
-    )
-  ) AS p99,
-  CAST((SELECT total FROM n) AS FLOAT) / MAX(1, (SELECT total FROM parent_n)) AS coverage
-`.trim();
-}
-function buildFanoutStatsSql(dialect, edge) {
-  return dialect === "postgres" ? buildPostgresStatsSql(edge) : buildSqliteStatsSql(edge);
-}
-function findLargestTable(params) {
-  return __async(this, null, function* () {
-    var _a3;
-    const { executor, dialect, datamodel } = params;
-    let best = null;
-    for (const model of datamodel.models) {
-      const table = quoteIdent(dialect, model.dbName || model.name);
-      try {
-        const rows = yield executor.query(`SELECT COUNT(*) AS cnt FROM ${table}`);
-        const count = toNumberOrZero((_a3 = rows[0]) == null ? void 0 : _a3.cnt);
-        if (!best || count > best.rowCount) {
-          best = { tableName: table, rowCount: count };
-        }
-      } catch (_) {
-      }
-    }
-    return best;
-  });
-}
-function measureRoundtripCost(params) {
-  return __async(this, null, function* () {
-    var _a3, _b;
-    const { executor, dialect, datamodel } = params;
-    const WARMUP = 5;
-    const SAMPLES = 15;
-    for (let i = 0; i < WARMUP; i++) {
-      yield executor.query("SELECT 1");
-    }
-    const roundtripTimes = [];
-    for (let i = 0; i < SAMPLES; i++) {
-      const start = performance.now();
-      yield executor.query("SELECT 1");
-      roundtripTimes.push(performance.now() - start);
-    }
-    roundtripTimes.sort((a, b) => a - b);
-    const medianRoundtrip = roundtripTimes[Math.floor(SAMPLES / 2)];
-    console.log(
-      `  [roundtrip] SELECT 1 times (ms): min=${roundtripTimes[0].toFixed(3)} median=${medianRoundtrip.toFixed(3)} max=${roundtripTimes[SAMPLES - 1].toFixed(3)}`
-    );
-    const largest = yield findLargestTable({ executor, dialect, datamodel });
-    if (!largest || largest.rowCount < 50) {
-      console.log(
-        `  [roundtrip] Largest table: ${(_a3 = largest == null ? void 0 : largest.tableName) != null ? _a3 : "none"} (${(_b = largest == null ? void 0 : largest.rowCount) != null ? _b : 0} rows) \u2014 too small, using default 50`
-      );
-      return 50;
-    }
-    console.log(
-      `  [roundtrip] Using table ${largest.tableName} (${largest.rowCount} rows)`
-    );
-    return estimateFromQueryPairRatio({
-      executor,
-      tableName: largest.tableName,
-      tableRowCount: largest.rowCount
-    });
-  });
-}
-function estimateFromQueryPairRatio(params) {
-  return __async(this, null, function* () {
-    const { executor, tableName, tableRowCount } = params;
-    const WARMUP = 5;
-    const SAMPLES = 10;
-    const smallLimit = 1;
-    const largeLimit = Math.min(1e3, tableRowCount);
-    for (let i = 0; i < WARMUP; i++) {
-      yield executor.query(`SELECT * FROM ${tableName} LIMIT ${largeLimit}`);
-    }
-    const smallTimes = [];
-    for (let i = 0; i < SAMPLES; i++) {
-      const start = performance.now();
-      yield executor.query(`SELECT * FROM ${tableName} LIMIT ${smallLimit}`);
-      smallTimes.push(performance.now() - start);
-    }
-    smallTimes.sort((a, b) => a - b);
-    const medianSmall = smallTimes[Math.floor(SAMPLES / 2)];
-    const largeTimes = [];
-    let actualLargeRows = 0;
-    for (let i = 0; i < SAMPLES; i++) {
-      const start = performance.now();
-      const rows = yield executor.query(
-        `SELECT * FROM ${tableName} LIMIT ${largeLimit}`
-      );
-      largeTimes.push(performance.now() - start);
-      actualLargeRows = rows.length;
-    }
-    largeTimes.sort((a, b) => a - b);
-    const medianLarge = largeTimes[Math.floor(SAMPLES / 2)];
-    const rowDiff = actualLargeRows - smallLimit;
-    const timeDiff = medianLarge - medianSmall;
-    console.log(
-      `  [roundtrip] LIMIT ${smallLimit}: median=${medianSmall.toFixed(3)}ms`
-    );
-    console.log(
-      `  [roundtrip] LIMIT ${largeLimit} (got ${actualLargeRows}): median=${medianLarge.toFixed(3)}ms`
-    );
-    console.log(
-      `  [roundtrip] Time diff: ${timeDiff.toFixed(3)}ms for ${rowDiff} rows`
-    );
-    if (rowDiff < 50 || timeDiff <= 0.05) {
-      console.log(
-        `  [roundtrip] Insufficient signal (need \u226550 row diff and >0.05ms time diff), defaulting to 50`
-      );
-      return 50;
-    }
-    const perRow = timeDiff / rowDiff;
-    const sequentialTimes = [];
-    for (let i = 0; i < SAMPLES; i++) {
-      const start = performance.now();
-      yield executor.query(`SELECT * FROM ${tableName} LIMIT ${smallLimit}`);
-      yield executor.query(`SELECT * FROM ${tableName} LIMIT ${smallLimit}`);
-      yield executor.query(`SELECT * FROM ${tableName} LIMIT ${smallLimit}`);
-      sequentialTimes.push(performance.now() - start);
-    }
-    sequentialTimes.sort((a, b) => a - b);
-    const median3Sequential = sequentialTimes[Math.floor(SAMPLES / 2)];
-    const marginalQueryCost = (median3Sequential - medianSmall) / 2;
-    console.log(
-      `  [roundtrip] 3x sequential LIMIT 1: median=${median3Sequential.toFixed(3)}ms`
-    );
-    console.log(`  [roundtrip] Single query: ${medianSmall.toFixed(3)}ms`);
-    console.log(
-      `  [roundtrip] Marginal query cost: ${marginalQueryCost.toFixed(3)}ms`
-    );
-    console.log(`  [roundtrip] Per-row cost: ${perRow.toFixed(4)}ms`);
-    const equivalent = Math.round(marginalQueryCost / perRow);
-    console.log(`  [roundtrip] Raw equivalent: ${equivalent} rows`);
-    const clamped = Math.max(10, Math.min(500, equivalent));
-    console.log(`  [roundtrip] Final (clamped): ${clamped} rows`);
-    return clamped;
-  });
-}
-function measureJsonOverhead(params) {
-  return __async(this, null, function* () {
-    const { executor, tableName, tableRowCount } = params;
-    const WARMUP = 3;
-    const SAMPLES = 10;
-    const limit = Math.min(500, tableRowCount);
-    const rawSql = `SELECT * FROM ${tableName} LIMIT ${limit}`;
-    const colsResult = yield executor.query(
-      `SELECT column_name FROM information_schema.columns WHERE table_name = ${tableName.replace(/"/g, "'")} LIMIT 10`
-    );
-    let aggSql;
-    if (colsResult.length >= 3) {
-      const cols = colsResult.slice(0, 6).map((r) => `"${r.column_name}"`);
-      const aggExprs = cols.map((c) => `array_agg(${c})`).join(", ");
-      const groupCol = cols[0];
-      aggSql = `SELECT ${groupCol}, ${aggExprs} FROM ${tableName} GROUP BY ${groupCol} LIMIT ${limit}`;
-    } else {
-      aggSql = `SELECT json_agg(t) FROM (SELECT * FROM ${tableName} LIMIT ${limit}) t`;
-    }
-    for (let i = 0; i < WARMUP; i++) {
-      yield executor.query(rawSql);
-      yield executor.query(aggSql);
-    }
-    const rawTimes = [];
-    for (let i = 0; i < SAMPLES; i++) {
-      const start = performance.now();
-      yield executor.query(rawSql);
-      rawTimes.push(performance.now() - start);
-    }
-    rawTimes.sort((a, b) => a - b);
-    const medianRaw = rawTimes[Math.floor(SAMPLES / 2)];
-    const aggTimes = [];
-    for (let i = 0; i < SAMPLES; i++) {
-      const start = performance.now();
-      yield executor.query(aggSql);
-      aggTimes.push(performance.now() - start);
-    }
-    aggTimes.sort((a, b) => a - b);
-    const medianAgg = aggTimes[Math.floor(SAMPLES / 2)];
-    const factor = medianRaw > 0.01 ? medianAgg / medianRaw : 3;
-    console.log(`  [json] Raw ${limit} rows: ${medianRaw.toFixed(3)}ms`);
-    console.log(`  [json] array_agg grouped: ${medianAgg.toFixed(3)}ms`);
-    console.log(`  [json] Overhead factor: ${factor.toFixed(2)}x`);
-    return Math.max(1.5, Math.min(8, factor));
-  });
-}
-function collectPostgresStatsFromCatalog(params) {
-  return __async(this, null, function* () {
-    const { executor, datamodel } = params;
-    const edges = extractMeasurableOneToManyEdges(datamodel);
-    const out = {};
-    const tablesToAnalyze = /* @__PURE__ */ new Set();
-    for (const edge of edges) {
-      tablesToAnalyze.add(edge.parentTable);
-      tablesToAnalyze.add(edge.childTable);
-    }
-    for (const table of tablesToAnalyze) {
-      try {
-        yield executor.query(`ANALYZE ${quoteIdent("postgres", table)}`);
-      } catch (_) {
-      }
-    }
-    const tableStatsQuery = `
-    SELECT
-      c.relname as table_name,
-      c.reltuples::bigint as row_count
-    FROM pg_class c
-    JOIN pg_namespace n ON n.oid = c.relnamespace
-    WHERE c.relkind = 'r'
-      AND n.nspname NOT IN ('pg_catalog', 'information_schema')
-  `;
-    const tableStats = yield executor.query(tableStatsQuery, []);
-    const rowCounts = /* @__PURE__ */ new Map();
-    for (const row of tableStats) {
-      const tableName = String(row.table_name);
-      const count = toNumberOrZero(row.row_count);
-      rowCounts.set(tableName, count);
-    }
-    for (const edge of edges) {
-      const parentRows = rowCounts.get(edge.parentTable) || 0;
-      const childRows = rowCounts.get(edge.childTable) || 0;
-      if (parentRows === 0 || childRows === 0) {
-        if (!out[edge.parentModel]) out[edge.parentModel] = {};
-        out[edge.parentModel][edge.relName] = {
-          avg: 1,
-          p95: 1,
-          p99: 1,
-          max: 1,
-          coverage: 0
-        };
-        continue;
-      }
-      const fkColumn = edge.childFkColumns[0];
-      const statsQuery = `
-      SELECT
-        s.n_distinct,
-        s.correlation,
-        (s.most_common_freqs)[1] as max_freq
-      FROM pg_stats s
-      WHERE s.tablename = $1
-        AND s.attname = $2
-        AND s.schemaname NOT IN ('pg_catalog', 'information_schema')
-    `;
-      const statsRows = yield executor.query(statsQuery, [
-        edge.childTable,
-        fkColumn
-      ]);
-      let avg;
-      let p95;
-      let p99;
-      let max;
-      let coverage;
-      if (statsRows.length > 0) {
-        const stats = statsRows[0];
-        const nDistinct = toNumberOrZero(stats.n_distinct);
-        const correlation = stats.correlation !== null ? Number(stats.correlation) : 0;
-        const maxFreq = stats.max_freq !== null ? Number(stats.max_freq) : null;
-        const distinctCount = nDistinct < 0 ? Math.abs(nDistinct) * childRows : nDistinct > 0 ? nDistinct : parentRows;
-        avg = distinctCount > 0 ? childRows / distinctCount : childRows / parentRows;
-        coverage = Math.min(1, distinctCount / parentRows);
-        const skewFactor = Math.abs(correlation) > 0.5 ? 2.5 : 1.5;
-        p95 = avg * skewFactor;
-        p99 = avg * (skewFactor * 1.3);
-        max = maxFreq ? Math.ceil(childRows * maxFreq) : Math.ceil(p99 * 1.5);
-      } else {
-        avg = childRows / parentRows;
-        coverage = 1;
-        p95 = avg * 2;
-        p99 = avg * 3;
-        max = avg * 5;
-      }
-      if (!out[edge.parentModel]) out[edge.parentModel] = {};
-      out[edge.parentModel][edge.relName] = clampStatsMonotonic(
-        Math.ceil(avg),
-        Math.ceil(p95),
-        Math.ceil(p99),
-        Math.ceil(max),
-        coverage
-      );
-    }
-    return out;
-  });
-}
-function collectPreciseCardinalities(params) {
-  return __async(this, null, function* () {
-    const { executor, datamodel, dialect } = params;
-    const edges = extractMeasurableOneToManyEdges(datamodel);
-    const out = {};
-    for (const edge of edges) {
-      const sql = buildFanoutStatsSql(dialect, edge);
-      const rows = yield executor.query(sql, []);
-      const row = rows[0] || {};
-      const stats = normalizeStats(row);
-      if (!out[edge.parentModel]) out[edge.parentModel] = {};
-      out[edge.parentModel][edge.relName] = stats;
-    }
-    return out;
-  });
-}
-function collectRelationCardinalities(params) {
-  return __async(this, null, function* () {
-    const { executor, datamodel, dialect, mode = "precise" } = params;
-    if (dialect === "postgres" && mode === "fast") {
-      const stats = yield collectPostgresStatsFromCatalog({ executor, datamodel });
-      let allTrivial = true;
-      for (const model of Object.values(stats)) {
-        for (const rel of Object.values(model)) {
-          if (rel.avg > 1 || rel.coverage > 0.5) {
-            allTrivial = false;
-            break;
-          }
-        }
-        if (!allTrivial) break;
-      }
-      if (allTrivial && Object.keys(stats).length > 0) {
-        console.warn("\u26A0 Catalog stats look stale, falling back to precise mode");
-        return collectPreciseCardinalities({ executor, datamodel, dialect });
-      }
-      return stats;
-    }
-    return collectPreciseCardinalities({ executor, datamodel, dialect });
-  });
-}
-function collectPlannerArtifacts(params) {
-  return __async(this, null, function* () {
-    const { executor, datamodel, dialect, mode } = params;
-    const largest = yield findLargestTable({ executor, dialect, datamodel });
-    const [relationStats, roundtripRowEquivalent, jsonRowFactor] = yield Promise.all([
-      collectRelationCardinalities({ executor, datamodel, dialect, mode }),
-      measureRoundtripCost({ executor, dialect, datamodel }),
-      largest && largest.rowCount >= 50 && dialect === "postgres" ? measureJsonOverhead({
-        executor,
-        tableName: largest.tableName,
-        tableRowCount: largest.rowCount
-      }) : Promise.resolve(1.5)
-    ]);
-    console.log(`  Roundtrip cost: ~${roundtripRowEquivalent} row equivalents`);
-    console.log(`  JSON overhead factor: ${jsonRowFactor.toFixed(2)}x`);
-    return { relationStats, roundtripRowEquivalent, jsonRowFactor };
-  });
-}
 function emitPlannerGeneratedModule(artifacts) {
   return [
     `export const RELATION_STATS = ${stableJson(artifacts.relationStats)} as const`,
@@ -7806,7 +7294,6 @@ function emitPlannerGeneratedModule(artifacts) {
 }
 
 // src/code-emitter.ts
-var DB_CONNECT_TIMEOUT_MS = 5e3;
 function extractEnumMappings(datamodel) {
   const mappings = {};
   const fieldTypes = {};
@@ -7879,8 +7366,8 @@ function processAllModelDirectives(directiveResults, config) {
 }
 function generateClient(options) {
   return __async(this, null, function* () {
-    var _a3;
-    const { datamodel, outputDir, config, datasourceUrl } = options;
+    var _a3, _b;
+    const { datamodel, outputDir, config } = options;
     const runtimeImportPath = (_a3 = options.runtimeImportPath) != null ? _a3 : "prisma-sql";
     setGlobalDialect(config.dialect);
     const models = schemaParser.convertDMMFToModels(datamodel);
@@ -7895,28 +7382,11 @@ function generateClient(options) {
     );
     const absoluteOutputDir = path.resolve(process.cwd(), outputDir);
     yield promises.mkdir(absoluteOutputDir, { recursive: true });
-    let plannerArtifacts = options.plannerArtifacts;
-    if (!plannerArtifacts) {
-      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) {
-      plannerArtifacts = {
-        relationStats: {},
-        roundtripRowEquivalent: 73,
-        jsonRowFactor: 1.5
-      };
-    }
+    const plannerArtifacts = (_b = options.plannerArtifacts) != null ? _b : {
+      relationStats: {},
+      roundtripRowEquivalent: 73,
+      jsonRowFactor: 1.5
+    };
     const plannerCode = emitPlannerGeneratedModule(plannerArtifacts);
     const plannerPath = path.join(absoluteOutputDir, "planner.generated.ts");
     yield promises.writeFile(plannerPath, plannerCode);
@@ -7939,61 +7409,6 @@ 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, 
@@ -9078,9 +8493,7 @@ generatorHelper.generatorHandler({
       yield generateClient({
         datamodel: dmmf.datamodel,
         outputDir,
-        config,
-        datasourceUrl
-      });
+        config});
       console.info("\u2713 Generated SQL client successfully");
     });
   }