prisma-sql 1.75.5 → 1.75.7

package/dist/collect-planner-stats.js

@@ -0,0 +1,694 @@
+#!/usr/bin/env node
+import { writeFile } from 'fs/promises';
+import { isAbsolute, resolve } from 'path';
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve2, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// 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,
+    (_k, v) => {
+      if (!v || typeof v !== "object" || Array.isArray(v)) return v;
+      const obj = v;
+      const out = {};
+      for (const k of Object.keys(obj).sort()) out[k] = obj[k];
+      return out;
+    },
+    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]";
+  }
+}
+
+// src/cardinality-planner.ts
+function quoteIdent(dialect, ident) {
+  return `"${ident.replace(/"/g, '""')}"`;
+}
+function createDatabaseExecutor(params) {
+  return __async(this, null, function* () {
+    const { databaseUrl} = params;
+    {
+      const postgres = yield import('postgres');
+      cleanDatabaseUrl(databaseUrl);
+      const sql = postgres.default(databaseUrl, { max: 1 });
+      return {
+        executor: {
+          query: (sqlStr, params2) => __async(null, null, function* () {
+            return yield sql.unsafe(sqlStr, params2 || []);
+          })
+        },
+        cleanup: () => __async(null, null, function* () {
+          yield sql.end();
+        })
+      };
+    }
+  });
+}
+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 _a;
+    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((_a = rows[0]) == null ? void 0 : _a.cnt);
+        if (!best || count > best.rowCount) {
+          best = { tableName: table, rowCount: count };
+        }
+      } catch (_) {
+      }
+    }
+    return best;
+  });
+}
+function measureRoundtripCost(params) {
+  return __async(this, null, function* () {
+    var _a, _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: ${(_a = largest == null ? void 0 : largest.tableName) != null ? _a : "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 (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`,
+    ``,
+    `export type RelationStats = typeof RELATION_STATS`,
+    ``,
+    `export const ROUNDTRIP_ROW_EQUIVALENT = ${artifacts.roundtripRowEquivalent}`,
+    ``,
+    `export const JSON_ROW_FACTOR = ${artifacts.jsonRowFactor.toFixed(2)}`,
+    ``
+  ].join("\n");
+}
+
+// src/collect-planner-stats.ts
+var CONNECT_TIMEOUT_MS = 1e4;
+function parseArgs(argv) {
+  const outputIdx = argv.indexOf("--output");
+  const clientIdx = argv.indexOf("--prisma-client");
+  const output = outputIdx !== -1 && argv[outputIdx + 1] ? argv[outputIdx + 1] : "./dist/prisma/generated/sql/planner.generated.js";
+  const clientPath = clientIdx !== -1 && argv[clientIdx + 1] ? argv[clientIdx + 1] : "@prisma/client";
+  return { output, clientPath };
+}
+function resolveOutput(output) {
+  return isAbsolute(output) ? output : resolve(process.cwd(), output);
+}
+function emitCJS(artifacts) {
+  const ts = emitPlannerGeneratedModule(artifacts);
+  return ts.replace(/^export const (\w+)/gm, "exports.$1").replace(/^import .*$/gm, "").trimStart();
+}
+function connectWithTimeout(databaseUrl, dialect) {
+  return __async(this, null, function* () {
+    let settled = false;
+    const connectPromise = createDatabaseExecutor({ databaseUrl}).then(
+      (conn) => {
+        if (settled) {
+          conn.cleanup().catch(() => {
+          });
+          throw new Error("Timed out");
+        }
+        return conn;
+      }
+    );
+    const timeoutPromise = new Promise((_, reject) => {
+      var _a;
+      const id = setTimeout(() => {
+        settled = true;
+        reject(new Error(`Connection timed out after ${CONNECT_TIMEOUT_MS}ms`));
+      }, CONNECT_TIMEOUT_MS);
+      (_a = id.unref) == null ? void 0 : _a.call(id);
+    });
+    try {
+      const result = yield Promise.race([connectPromise, timeoutPromise]);
+      settled = true;
+      return result;
+    } catch (err) {
+      settled = true;
+      throw err;
+    }
+  });
+}
+function main() {
+  return __async(this, null, function* () {
+    var _a, _b;
+    const { output, clientPath } = parseArgs(process.argv.slice(2));
+    const outputPath = resolveOutput(output);
+    const url = process.env.DATABASE_URL;
+    if (!url) {
+      console.warn(
+        "[prisma-sql] DATABASE_URL not set, skipping planner stats collection"
+      );
+      process.exit(0);
+    }
+    let executor;
+    let cleanup;
+    try {
+      const conn = yield connectWithTimeout(url, "postgres");
+      executor = conn.executor;
+      cleanup = conn.cleanup;
+    } catch (err) {
+      console.warn(
+        "[prisma-sql] Failed to connect:",
+        err instanceof Error ? err.message : err
+      );
+      process.exit(0);
+    }
+    try {
+      let dmmf;
+      try {
+        const client = __require(clientPath);
+        dmmf = (_b = (_a = client.Prisma) == null ? void 0 : _a.dmmf) != null ? _b : client.dmmf;
+        if (!(dmmf == null ? void 0 : dmmf.datamodel)) {
+          throw new Error(`Could not read dmmf.datamodel from ${clientPath}`);
+        }
+      } catch (err) {
+        throw new Error(
+          `Failed to load Prisma client from "${clientPath}": ${err instanceof Error ? err.message : err}`
+        );
+      }
+      const artifacts = yield collectPlannerArtifacts({
+        executor,
+        datamodel: dmmf.datamodel,
+        dialect: "postgres"
+      });
+      yield writeFile(outputPath, emitCJS(artifacts), "utf8");
+      console.log("[prisma-sql] \u2713 Planner stats written to", outputPath);
+    } catch (err) {
+      console.warn(
+        "[prisma-sql] Failed to collect stats:",
+        err instanceof Error ? err.message : err
+      );
+    } finally {
+      yield cleanup == null ? void 0 : cleanup();
+    }
+    process.exit(0);
+  });
+}
+main();
+//# sourceMappingURL=collect-planner-stats.js.map
+//# sourceMappingURL=collect-planner-stats.js.map