lurqrun 0.1.6 → 0.1.8

package/dist/chunk-2WD4QAH4.js

@@ -0,0 +1,116 @@
+import { createRequire as __lurqCreateRequire } from 'node:module'; const require = __lurqCreateRequire(import.meta.url);
+import {
+  stackResolutions
+} from "./chunk-4JHDSVIN.js";
+import {
+  getConfig
+} from "./chunk-GRJXQBQZ.js";
+import {
+  init_esm_shims
+} from "./chunk-I3M2KJXB.js";
+
+// src/db/stackResolutions.ts
+init_esm_shims();
+import { eq, sql } from "drizzle-orm";
+function stackKey(members) {
+  return [...members].map((m) => `${m.name}@${m.version}`).sort().join("|");
+}
+async function getStackResolution(db, key) {
+  const [row] = await db.select().from(stackResolutions).where(eq(stackResolutions.setKey, key)).limit(1);
+  return row ?? null;
+}
+async function recordStackResolution(db, entry) {
+  const key = stackKey(entry.members);
+  await db.insert(stackResolutions).values({
+    setKey: key,
+    packages: entry.members,
+    names: entry.members.map((m) => m.name),
+    resolved: entry.resolved,
+    reason: entry.reason ?? null,
+    detail: entry.detail ?? null,
+    resolvedAt: /* @__PURE__ */ new Date()
+  }).onConflictDoUpdate({
+    target: stackResolutions.setKey,
+    set: {
+      resolved: sql`excluded.resolved`,
+      reason: sql`excluded.reason`,
+      detail: sql`excluded.detail`,
+      resolvedAt: sql`excluded.resolved_at`
+    }
+  });
+}
+
+// src/pipeline/resolveCheck.ts
+init_esm_shims();
+import { execFile } from "child_process";
+import { mkdtemp, rm, writeFile } from "fs/promises";
+import { tmpdir } from "os";
+import { join } from "path";
+import { promisify } from "util";
+var execFileP = promisify(execFile);
+var active = 0;
+var waiting = [];
+async function acquire(limit) {
+  if (active < limit) active++;
+  else await new Promise((resolve) => waiting.push(resolve));
+  let released = false;
+  return () => {
+    if (released) return;
+    released = true;
+    const next = waiting.shift();
+    if (next) next();
+    else active--;
+  };
+}
+async function resolveSet(specs, opts = {}) {
+  const config = getConfig();
+  const release = await acquire(opts.concurrency ?? config.LURQ_RESOLVE_CONCURRENCY);
+  const dir = await mkdtemp(join(tmpdir(), "lurq-resolve-"));
+  try {
+    const dependencies = {};
+    for (const s of specs) dependencies[s.name] = s.version ?? "latest";
+    await writeFile(
+      join(dir, "package.json"),
+      // A version is required or npm reports `lurq-resolve@undefined` in its
+      // error output, which then reads as if our scaffold were part of the
+      // user's stack.
+      JSON.stringify({ name: "lurq-resolve", version: "0.0.0", private: true, dependencies })
+    );
+    const args = ["install", "--package-lock-only", "--no-audit", "--no-fund"];
+    const cacheDir = opts.cacheDir ?? config.LURQ_NPM_CACHE_DIR;
+    if (cacheDir) args.push("--cache", cacheDir);
+    await execFileP("npm", args, {
+      cwd: dir,
+      timeout: opts.timeoutMs ?? config.LURQ_RESOLVE_TIMEOUT_MS
+    });
+    return { resolved: true, reason: null };
+  } catch (err) {
+    const msg = err.stderr ?? err.message ?? "";
+    if (/ERESOLVE/i.test(msg)) {
+      return { resolved: false, reason: "ERESOLVE", detail: summarizeEresolve(msg) };
+    }
+    throw err;
+  } finally {
+    release();
+    await rm(dir, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+function summarizeEresolve(stderr, maxChars = 600) {
+  const keep = stderr.split("\n").map((l) => l.replace(/^npm (error|ERR!)\s*/, "").trim()).filter(
+    (l) => l.length > 0 && // Our own scaffold is not part of anyone's stack; naming it in a verdict
+    // just invites a reader to go looking for a package that does not exist.
+    !l.startsWith("While resolving: lurq-resolve") && /^(While resolving|Found|Could not resolve|Conflicting peer dependency|peer |dependency )/i.test(
+      l
+    )
+  );
+  const text = (keep.length > 0 ? keep : ["npm could not resolve this set"]).join("; ");
+  return text.length > maxChars ? `${text.slice(0, maxChars - 1)}\u2026` : text;
+}
+
+export {
+  stackKey,
+  getStackResolution,
+  recordStackResolution,
+  resolveSet
+};