@rehearsal-db/core 0.1.0-beta.14 → 0.1.0-beta.16

package/src/project/setup.mjs

@@ -1,474 +0,0 @@
-/**
- * Purpose: Plan and apply conservative first-run Rehearsal scaffolding without
- * contacting hosted services or overwriting project-owned files.
- */
-
-import { randomUUID } from "node:crypto";
-import { createConnection, createServer } from "node:net";
-import {
-  access,
-  mkdir,
-  open,
-  readFile,
-  rename,
-  rm,
-  writeFile,
-} from "node:fs/promises";
-import { basename, dirname, join, relative, resolve } from "node:path";
-import {
-  findRehearsalConfigPath,
-  inspectDetectedProject,
-  loadRehearsalConfig,
-  renderDetectedConfig,
-  renderDetectedPostgresqlConfig,
-} from "./configuration.mjs";
-import { resolveRuntimeTarget } from "../targets/target.mjs";
-export {
-  assertSupportedRehearsalNodeRuntime,
-  inspectRehearsalNodeRuntime,
-} from "../shared/node_runtime.mjs";
-import { assertSupportedRehearsalNodeRuntime } from "../shared/node_runtime.mjs";
-
-const CONFIG_PATH = "rehearsal.config.mjs";
-const LOCAL_SUPABASE_CONFIG_PATH =
-  "infrastructure/rehearsal/supabase/config.toml";
-const GITIGNORE_PATH = ".gitignore";
-const PORT_OFFSETS = Object.freeze({
-  shadow: 0,
-  api: 1,
-  database: 2,
-  studio: 3,
-  smtp: 4,
-  pooler: 9,
-});
-
-const pathExists = (path) =>
-  access(path)
-    .then(() => true)
-    .catch((error) => {
-      if (error?.code === "ENOENT") return false;
-      throw error;
-    });
-
-const readOptionalFile = async (path) => {
-  try {
-    return await readFile(path, "utf8");
-  } catch (error) {
-    if (error?.code === "ENOENT") return null;
-    throw error;
-  }
-};
-
-const canConnectToPort = (port) =>
-  new Promise((resolveAvailability) => {
-    const socket = createConnection({ host: "127.0.0.1", port });
-    const finish = (result) => {
-      socket.destroy();
-      resolveAvailability(result);
-    };
-    socket.setTimeout(500);
-    socket.once("connect", () => finish(true));
-    socket.once("error", () => finish(false));
-    socket.once("timeout", () => finish(false));
-  });
-
-const canBindToPort = (port) =>
-  new Promise((resolveAvailability) => {
-    const server = createServer();
-    server.unref();
-    server.once("error", () => resolveAvailability(false));
-    server.listen({ host: "127.0.0.1", port, exclusive: true }, () => {
-      server.close(() => resolveAvailability(true));
-    });
-  });
-
-export const isRehearsalPortAvailable = async (port) => {
-  if (await canConnectToPort(port)) return false;
-  return canBindToPort(port);
-};
-
-export const findAvailableRehearsalPorts = async ({
-  isAvailable = isRehearsalPortAvailable,
-} = {}) => {
-  for (let base = 58_320; base <= 65_520; base += 20) {
-    const entries = Object.entries(PORT_OFFSETS).map(([name, offset]) => [
-      name,
-      base + offset,
-    ]);
-    const availability = await Promise.all(
-      entries.map(([, port]) => isAvailable(port)),
-    );
-    if (availability.every(Boolean)) return Object.fromEntries(entries);
-  }
-  throw new Error(
-    "Rehearsal could not find an available local port block between 58320 and 65529.",
-  );
-};
-
-const databaseMajorVersionFrom = (source) => {
-  const match = /^\s*major_version\s*=\s*(\d+)\s*(?:#.*)?$/imu.exec(
-    source ?? "",
-  );
-  return match ? Number(match[1]) : 17;
-};
-
-export const renderSafeLocalSupabaseConfig = ({
-  projectId,
-  applicationUrl,
-  ports,
-  databaseMajorVersion = 17,
-}) => `# Generated by Rehearsal for a disposable, local-only runtime.
-# Review project-specific Auth or Storage additions before enabling them here.
-project_id = ${JSON.stringify(projectId)}
-
-[api]
-enabled = true
-port = ${ports.api}
-schemas = ["public"]
-extra_search_path = ["public", "extensions"]
-
-[db]
-port = ${ports.database}
-shadow_port = ${ports.shadow}
-major_version = ${databaseMajorVersion}
-
-[db.pooler]
-enabled = false
-port = ${ports.pooler}
-
-[db.migrations]
-enabled = true
-schema_paths = []
-
-[db.seed]
-enabled = false
-sql_paths = []
-
-[studio]
-enabled = true
-port = ${ports.studio}
-api_url = "http://127.0.0.1"
-
-[local_smtp]
-enabled = false
-port = ${ports.smtp}
-
-[auth]
-enabled = true
-site_url = ${JSON.stringify(applicationUrl)}
-enable_signup = false
-
-[storage]
-enabled = true
-
-[realtime]
-enabled = false
-
-[edge_runtime]
-enabled = false
-
-[analytics]
-enabled = false
-`;
-
-export const appendRehearsalGitignoreEntries = (source) => {
-  const original = source ?? "";
-  const lines = new Set(
-    original
-      .split(/\r?\n/u)
-      .map((line) => line.trim())
-      .filter(Boolean),
-  );
-  const entries = [".rehearsal/", ".env.rehearsal-service.local"];
-  const missing = entries.filter(
-    (entry) =>
-      !lines.has(entry) &&
-      !lines.has(`/${entry}`) &&
-      !lines.has(entry.replace(/\/$/u, "")),
-  );
-  if (missing.length === 0) return original;
-  const prefix =
-    original && !original.endsWith("\n") ? `${original}\n` : original;
-  const separator = prefix && !prefix.endsWith("\n\n") ? "\n" : "";
-  return `${prefix}${separator}# Rehearsal local artifacts\n${missing.join("\n")}\n`;
-};
-
-const findExistingConfigPath = async ({ projectRoot, configPath }) => {
-  try {
-    return await findRehearsalConfigPath({ projectRoot, configPath });
-  } catch (error) {
-    if (
-      String(error?.message ?? error).startsWith("No Rehearsal configuration")
-    ) {
-      return null;
-    }
-    throw error;
-  }
-};
-
-const deriveSupabasePorts = (runtimePorts) => ({
-  shadow: runtimePorts.database - 2,
-  api: runtimePorts.api,
-  database: runtimePorts.database,
-  studio: runtimePorts.studio,
-  smtp: runtimePorts.database + 2,
-  pooler: runtimePorts.database + 7,
-});
-
-const applyGitignoreChange = async (file) => {
-  if (file.action === "unchanged") return;
-  if (file.action === "create") {
-    await writeFile(file.absolutePath, file.content, {
-      flag: "wx",
-      mode: file.mode,
-    });
-    return;
-  }
-
-  const lockPath = `${file.absolutePath}.rehearsal.lock`;
-  let lock;
-  let temporaryPath;
-  try {
-    lock = await open(lockPath, "wx", 0o600);
-    const current = await readOptionalFile(file.absolutePath);
-    if (current !== file.originalContent) {
-      throw new Error(
-        ".gitignore changed after the setup preview; rerun rehearsal setup before writing.",
-      );
-    }
-    temporaryPath = join(
-      dirname(file.absolutePath),
-      `.${basename(file.absolutePath)}.rehearsal-${process.pid}-${randomUUID()}.tmp`,
-    );
-    await writeFile(temporaryPath, file.content, {
-      flag: "wx",
-      mode: file.mode,
-    });
-    await rename(temporaryPath, file.absolutePath);
-    temporaryPath = null;
-  } catch (error) {
-    if (error?.code === "EEXIST" && !lock) {
-      throw new Error(
-        "Another Rehearsal process is updating .gitignore; rerun setup after it finishes.",
-      );
-    }
-    throw error;
-  } finally {
-    if (temporaryPath) await rm(temporaryPath, { force: true });
-    if (lock) {
-      await lock.close();
-      await rm(lockPath, { force: true });
-    }
-  }
-};
-
-const assertCreateTargetAvailable = async (file) => {
-  if (file.action === "create" && (await pathExists(file.absolutePath))) {
-    throw new Error(
-      `Rehearsal setup will not overwrite the existing file at ${file.path}.`,
-    );
-  }
-};
-
-export const planRehearsalSetup = async ({
-  projectRoot = process.cwd(),
-  configPath,
-  isPortAvailable,
-  target,
-} = {}) => {
-  const root = resolve(projectRoot);
-  const detected = await inspectDetectedProject({ projectRoot: root });
-  const existingConfigPath = await findExistingConfigPath({
-    projectRoot: root,
-    configPath,
-  });
-  const existing = existingConfigPath
-    ? await loadRehearsalConfig({ projectRoot: root, configPath })
-    : null;
-  const requestedTarget = resolveRuntimeTarget(
-    target ?? existing?.config.runtime.target ?? "supabase",
-  ).id;
-  const runtimeTarget = existing?.config.runtime.target ?? requestedTarget;
-  if (existing && target && runtimeTarget !== requestedTarget) {
-    throw new Error(
-      `The existing Rehearsal configuration targets ${runtimeTarget}; setup will not replace it with ${requestedTarget}.`,
-    );
-  }
-  const ports = existing
-    ? runtimeTarget === "supabase"
-      ? deriveSupabasePorts(existing.config.runtime.ports)
-      : { database: existing.config.runtime.ports.database }
-    : await findAvailableRehearsalPorts({
-        ...(isPortAvailable ? { isAvailable: isPortAvailable } : {}),
-      });
-  const applicationUrl =
-    existing?.config.runtime.applicationUrl ?? "http://localhost:5175";
-  const projectId =
-    existing?.config.runtime.projectId ?? `${detected.projectName}-rehearsal`;
-  const sourceSupabaseConfig =
-    runtimeTarget === "supabase"
-      ? await readOptionalFile(join(root, "supabase/config.toml"))
-      : null;
-  const originalGitignore = await readOptionalFile(join(root, GITIGNORE_PATH));
-  const nextGitignore = appendRehearsalGitignoreEntries(originalGitignore);
-  const rehearsalConfigPath = existing?.paths.rehearsalConfig;
-  const localSupabasePath = rehearsalConfigPath
-    ? relative(root, rehearsalConfigPath)
-    : LOCAL_SUPABASE_CONFIG_PATH;
-  const localSupabaseExists = rehearsalConfigPath
-    ? await pathExists(rehearsalConfigPath)
-    : false;
-  const files = [
-    {
-      path: existingConfigPath
-        ? relative(root, existingConfigPath)
-        : CONFIG_PATH,
-      absolutePath: existingConfigPath ?? join(root, CONFIG_PATH),
-      action: existingConfigPath ? "unchanged" : "create",
-      mode: 0o600,
-      content: existingConfigPath
-        ? null
-        : runtimeTarget === "supabase"
-          ? renderDetectedConfig(detected, {
-              applicationUrl,
-              ports,
-            })
-          : renderDetectedPostgresqlConfig(detected, {
-              applicationUrl,
-              databasePort: ports.database,
-            }),
-    },
-    ...(runtimeTarget === "supabase"
-      ? [
-          {
-            path: localSupabasePath,
-            absolutePath:
-              rehearsalConfigPath ?? join(root, LOCAL_SUPABASE_CONFIG_PATH),
-            action: localSupabaseExists ? "unchanged" : "create",
-            mode: 0o600,
-            content: localSupabaseExists
-              ? null
-              : renderSafeLocalSupabaseConfig({
-                  projectId,
-                  applicationUrl,
-                  ports,
-                  databaseMajorVersion:
-                    databaseMajorVersionFrom(sourceSupabaseConfig),
-                }),
-          },
-        ]
-      : []),
-    {
-      path: GITIGNORE_PATH,
-      absolutePath: join(root, GITIGNORE_PATH),
-      action:
-        nextGitignore === (originalGitignore ?? "")
-          ? "unchanged"
-          : originalGitignore === null
-            ? "create"
-            : "update",
-      mode: 0o644,
-      originalContent: originalGitignore,
-      content: nextGitignore,
-    },
-  ];
-  return {
-    projectRoot: root,
-    configurationPath: existingConfigPath
-      ? relative(root, existingConfigPath)
-      : CONFIG_PATH,
-    project: detected.projectName,
-    projectId,
-    target: runtimeTarget,
-    applicationUrl,
-    detected,
-    ports: runtimeTarget === "supabase" ? ports : { database: ports.database },
-    requiresAvailablePorts: files.some(
-      (file) =>
-        file.action === "create" &&
-        [CONFIG_PATH, localSupabasePath].includes(file.path),
-    ),
-    isPortAvailable: isPortAvailable ?? isRehearsalPortAvailable,
-    files,
-    safety: [
-      "hosted access remains disabled",
-      runtimeTarget === "supabase"
-        ? "the Supabase runtime binds to dedicated local ports"
-        : "PostgreSQL binds only to a dedicated loopback port",
-      ...(runtimeTarget === "supabase"
-        ? [
-            "external identity providers, realtime, edge functions, and analytics start disabled",
-          ]
-        : [
-            "the runtime uses an already-installed official PostgreSQL image and never pulls implicitly",
-          ]),
-      "configuration files are never overwritten and .gitignore updates are concurrency-checked",
-    ],
-  };
-};
-
-export const applyRehearsalSetup = async (plan) => {
-  assertSupportedRehearsalNodeRuntime();
-  const unavailablePorts = plan.requiresAvailablePorts
-    ? (
-        await Promise.all(
-          Object.values(plan.ports).map(async (port) => ({
-            port,
-            available: await plan.isPortAvailable(port),
-          })),
-        )
-      ).filter(({ available }) => !available)
-    : [];
-  if (unavailablePorts.length) {
-    throw new Error(
-      `Rehearsal setup ports became occupied after the preview (${unavailablePorts.map(({ port }) => port).join(", ")}); rerun setup to choose another local port block.`,
-    );
-  }
-  for (const file of plan.files) await assertCreateTargetAvailable(file);
-  const gitignore = plan.files.find((file) => file.path === GITIGNORE_PATH);
-  if (gitignore) await applyGitignoreChange(gitignore);
-  for (const file of plan.files.filter(
-    (entry) => entry.action !== "unchanged" && entry.path !== GITIGNORE_PATH,
-  )) {
-    await mkdir(dirname(file.absolutePath), { recursive: true, mode: 0o700 });
-    await writeFile(file.absolutePath, file.content, {
-      flag: file.action === "create" ? "wx" : "w",
-      mode: file.mode,
-    });
-  }
-  return {
-    projectRoot: plan.projectRoot,
-    files: plan.files.map((file) => ({
-      path: relative(plan.projectRoot, file.absolutePath),
-      action: file.action,
-    })),
-  };
-};
-
-export const summarizeRehearsalSetup = (plan, { mode }) => ({
-  mode,
-  configurationPath: plan.configurationPath,
-  configurationAction:
-    plan.files.find((file) => file.path === plan.configurationPath)?.action ??
-    "unchanged",
-  rootConfigGenerationSkipped: plan.configurationPath !== CONFIG_PATH,
-  project: plan.project,
-  projectId: plan.projectId,
-  target: plan.target,
-  applicationUrl: plan.applicationUrl,
-  detected: plan.detected,
-  ports:
-    plan.target === "supabase"
-      ? {
-          api: plan.ports.api,
-          database: plan.ports.database,
-          studio: plan.ports.studio,
-        }
-      : { database: plan.ports.database },
-  files: plan.files.map((file) => ({ path: file.path, action: file.action })),
-  safety: plan.safety,
-  nextAction:
-    mode === "written"
-      ? `Review ${plan.configurationPath}, including its commands and sanitization policy path, then run rehearsal doctor.`
-      : "Review this plan, then rerun rehearsal setup --write to create it.",
-});

package/src/project/support_report.mjs

@@ -1,105 +0,0 @@
-/**
- * Build a copy-ready, data-free support report. The report intentionally omits
- * project names, paths, command output, environment-variable names, row data,
- * migration contents, and baseline identifiers.
- */
-
-import { spawnSync } from "node:child_process";
-import { arch, platform, release } from "node:os";
-import {
-  REHEARSAL_VERSION,
-  redactDiagnosticValue,
-} from "../shared/diagnostics.mjs";
-import { runRehearsalDoctor } from "../runtime/plan.mjs";
-
-export const REHEARSAL_SUPPORT_URL =
-  "https://github.com/Ddupasquier/rehearsal-db/issues/new?template=bug.yml";
-
-const safeEnvironment = () =>
-  Object.fromEntries(
-    ["HOME", "LANG", "LC_ALL", "PATH", "SHELL", "TMPDIR"].flatMap((key) =>
-      process.env[key] === undefined ? [] : [[key, process.env[key]]],
-    ),
-  );
-
-const runVersionCommand = (command, args) =>
-  spawnSync(command, args, {
-    encoding: "utf8",
-    env: safeEnvironment(),
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: 5_000,
-  });
-
-const inspectTool = ({ command, args, runCommand }) => {
-  const result = runCommand(command, args);
-  if (result.error?.code === "ENOENT") return { status: "not_installed" };
-  if (result.status !== 0) return { status: "unavailable" };
-  const version = String(result.stdout || result.stderr)
-    .trim()
-    .split(/\r?\n/u)[0]
-    .slice(0, 200);
-  return {
-    status: "available",
-    version: redactDiagnosticValue(version || "version not reported"),
-  };
-};
-
-export const collectRehearsalSupportReport = async (
-  options = {},
-  {
-    runDoctor = runRehearsalDoctor,
-    runCommand = runVersionCommand,
-    system = {
-      platform: platform(),
-      release: release(),
-      architecture: arch(),
-      node: process.versions.node,
-    },
-  } = {},
-) => {
-  const doctor = await runDoctor(options);
-  return {
-    rehearsalVersion: REHEARSAL_VERSION,
-    system,
-    tools: {
-      npm: inspectTool({ command: "npm", args: ["--version"], runCommand }),
-      supabase: inspectTool({
-        command: "supabase",
-        args: ["--version"],
-        runCommand,
-      }),
-      dockerClient: inspectTool({
-        command: "docker",
-        args: ["--version"],
-        runCommand,
-      }),
-      dockerServer: inspectTool({
-        command: "docker",
-        args: ["info", "--format", "{{.ServerVersion}}"],
-        runCommand,
-      }),
-    },
-    readiness: {
-      state: doctor.state,
-      checks: doctor.checks.map(({ id, label, status, remediation }) => ({
-        id,
-        label,
-        status,
-        ...(status === "fail" && remediation ? { remediation } : {}),
-      })),
-      quarantinedHostedVariableCount:
-        doctor.ambientHostedVariables?.presentButQuarantined.length ?? 0,
-    },
-    privacy: {
-      omits: [
-        "row values",
-        "credentials",
-        "project paths",
-        "migration SQL",
-        "baseline identifiers",
-      ],
-      reviewBeforeSharing: true,
-    },
-    supportUrl: REHEARSAL_SUPPORT_URL,
-  };
-};