orcaq 1.0.32 → 1.1.1

package/.output/server/chunks/_/native-backup-jobs.mjs

@@ -0,0 +1,1302 @@
+import { c as createError, e as createSshTunnel } from '../nitro/nitro.mjs';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { once } from 'node:events';
+import { createWriteStream, createReadStream } from 'node:fs';
+import { mkdtemp, writeFile, stat, mkdir, readFile, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, basename } from 'node:path';
+import { D as DatabaseClientType } from './db-connection.mjs';
+import { c as createTableAdapter } from './tables.factory.mjs';
+
+const POSTGRES_FORMAT_OPTIONS = [
+  {
+    format: "custom",
+    fileExtension: ".dump",
+    fileKind: "archive",
+    label: "PostgreSQL custom archive (.dump)",
+    importTool: "pg_restore"
+  },
+  {
+    format: "plain",
+    fileExtension: ".sql",
+    fileKind: "sql",
+    label: "PostgreSQL plain SQL script (.sql)",
+    importTool: "psql"
+  }
+];
+const MYSQL_FORMAT_OPTIONS = [
+  {
+    format: "plain",
+    fileExtension: ".sql",
+    fileKind: "sql",
+    label: "MySQL SQL dump (.sql)",
+    importTool: "mysql"
+  }
+];
+const SQLITE_FORMAT_OPTIONS = [
+  {
+    format: "plain",
+    fileExtension: ".sql",
+    fileKind: "sql",
+    label: "SQLite SQL dump (.sql)",
+    importTool: "sqlite3"
+  }
+];
+const POSTGRES_CAPABILITY = {
+  supported: true,
+  formatOptions: POSTGRES_FORMAT_OPTIONS,
+  defaultExportFormat: "custom",
+  exportToolCandidates: ["pg_dump"],
+  importToolCandidates: ["pg_restore", "psql"],
+  label: "PostgreSQL native backup"
+};
+const MYSQL_CAPABILITY = {
+  supported: true,
+  formatOptions: MYSQL_FORMAT_OPTIONS,
+  defaultExportFormat: "plain",
+  exportToolCandidates: ["mysqlpump", "mysqldump"],
+  importToolCandidates: ["mysql"],
+  label: "MySQL SQL dump"
+};
+const SQLITE_CAPABILITY = {
+  supported: true,
+  formatOptions: SQLITE_FORMAT_OPTIONS,
+  defaultExportFormat: "plain",
+  exportToolCandidates: ["sqlite3"],
+  importToolCandidates: ["sqlite3"],
+  label: "SQLite SQL dump"
+};
+const ORACLE_UNSUPPORTED_REASON = "Oracle Data Pump writes dump files through a server-side DIRECTORY object. HeraQ needs explicit Oracle DIRECTORY and artifact retrieval configuration before expdp/impdp can be exposed as a downloadable native backup flow.";
+function getNativeBackupCapability(type) {
+  switch (type) {
+    case DatabaseClientType.POSTGRES:
+      return POSTGRES_CAPABILITY;
+    case DatabaseClientType.MYSQL:
+    case DatabaseClientType.MARIADB:
+      return {
+        ...MYSQL_CAPABILITY,
+        label: type === DatabaseClientType.MARIADB ? "MariaDB SQL dump" : MYSQL_CAPABILITY.label
+      };
+    case DatabaseClientType.SQLITE3:
+      return SQLITE_CAPABILITY;
+    case DatabaseClientType.ORACLE:
+      return {
+        supported: false,
+        formatOptions: [
+          {
+            format: "custom",
+            fileExtension: ".dmp",
+            fileKind: "archive",
+            label: "Oracle Data Pump dump (.dmp)",
+            importTool: "impdp"
+          }
+        ],
+        defaultExportFormat: "custom",
+        exportToolCandidates: ["expdp"],
+        importToolCandidates: ["impdp"],
+        label: "Oracle Data Pump dump",
+        reason: ORACLE_UNSUPPORTED_REASON
+      };
+    default:
+      return {
+        supported: false,
+        formatOptions: [],
+        defaultExportFormat: null,
+        exportToolCandidates: [],
+        importToolCandidates: [],
+        label: "Native backup",
+        reason: type ? `${type} native backup is not supported in this release.` : "Select a connection to use native backup tools."
+      };
+  }
+}
+function resolveNativeExportFormat(type, requestedFormat) {
+  const capability = getNativeBackupCapability(type);
+  if (!capability.supported || !capability.defaultExportFormat) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: capability.reason || `${type} native backup is not supported.`
+    });
+  }
+  if (!requestedFormat || requestedFormat === "native") {
+    return capability.defaultExportFormat;
+  }
+  if (requestedFormat !== "plain" && requestedFormat !== "custom") {
+    throw createError({
+      statusCode: 400,
+      statusMessage: `${requestedFormat} export format is not supported for ${type}.`
+    });
+  }
+  if (!capability.formatOptions.some((option) => option.format === requestedFormat)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: `${requestedFormat} export format is not supported for ${type}.`
+    });
+  }
+  return requestedFormat;
+}
+function getNativeBackupFormatOption(type, requestedFormat) {
+  const capability = getNativeBackupCapability(type);
+  const resolvedFormat = resolveNativeExportFormat(type, requestedFormat);
+  return capability.formatOptions.find(
+    (option) => option.format === resolvedFormat
+  );
+}
+function getNativeBackupFileExtension(type, requestedFormat) {
+  return getNativeBackupFormatOption(type, requestedFormat).fileExtension;
+}
+function getNativeBackupFileKind(type, requestedFormat) {
+  return getNativeBackupFormatOption(type, requestedFormat).fileKind;
+}
+function getNativeBackupImportTool(type, fileName) {
+  const capability = getNativeBackupCapability(type);
+  const extension = fileName.toLowerCase().split(".").pop();
+  const matched = capability.formatOptions.find(
+    (option) => option.fileExtension.toLowerCase() === `.${extension}`
+  );
+  if (!matched) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: `Unsupported backup file type for ${type}: ${fileName}`
+    });
+  }
+  return matched.importTool;
+}
+function sanitizeBackupFileSegment(value) {
+  return value.replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/-+/g, "-");
+}
+function buildNativeBackupFileName(databaseName, type, now = /* @__PURE__ */ new Date(), requestedFormat) {
+  const capability = getNativeBackupCapability(type);
+  if (!capability.supported) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: capability.reason || `${type} native backup is not supported.`
+    });
+  }
+  const timestamp = now.toISOString().replace(/[:.]/g, "-");
+  return `${sanitizeBackupFileSegment(databaseName)}_${timestamp}${getNativeBackupFileExtension(type, requestedFormat)}`;
+}
+function assertNativeBackupSupported(type) {
+  const capability = getNativeBackupCapability(type);
+  if (!capability.supported || !type) {
+    throw createError({
+      statusCode: 501,
+      statusMessage: capability.reason || `${type || "Unknown"} native backup is not supported.`
+    });
+  }
+}
+
+const NATIVE_BACKUP_TTL_MS = 30 * 60 * 1e3;
+const DEFAULT_PORTS = {
+  [DatabaseClientType.POSTGRES]: 5432,
+  [DatabaseClientType.MYSQL]: 3306,
+  [DatabaseClientType.MARIADB]: 3306,
+  [DatabaseClientType.SQLITE3]: 0
+};
+const nativeBackupJobs = /* @__PURE__ */ new Map();
+function getDefaultPort(type) {
+  var _a;
+  return (_a = DEFAULT_PORTS[type]) != null ? _a : 5432;
+}
+function resolveDatabaseName(params) {
+  return params.databaseName || params.database || params.serviceName || params.username || (params.filePath ? basename(params.filePath) : "") || "database";
+}
+function parseConnectionString(connectionString, type) {
+  if (!connectionString) {
+    return {};
+  }
+  const url = new URL(connectionString);
+  const pathname = url.pathname.replace(/^\/+/, "");
+  return {
+    host: url.hostname,
+    port: parseInt(url.port || `${getDefaultPort(type)}`, 10),
+    username: decodeURIComponent(url.username || ""),
+    password: decodeURIComponent(url.password || ""),
+    database: pathname
+  };
+}
+async function writeSslFiles(tempDir, ssl) {
+  if (!(ssl == null ? void 0 : ssl.mode) || ssl.mode === "disable") {
+    return void 0;
+  }
+  const sslDir = join(tempDir, "ssl");
+  const files = {};
+  await mkdir(sslDir, { recursive: true });
+  if (ssl.ca) {
+    files.caPath = join(sslDir, "ca.pem");
+  }
+  if (ssl.cert) {
+    files.certPath = join(sslDir, "client-cert.pem");
+  }
+  if (ssl.key) {
+    files.keyPath = join(sslDir, "client-key.pem");
+  }
+  await Promise.all(
+    [
+      files.caPath ? writeFile(files.caPath, ssl.ca || "", "utf8") : void 0,
+      files.certPath ? writeFile(files.certPath, ssl.cert || "", "utf8") : void 0,
+      files.keyPath ? writeFile(files.keyPath, ssl.key || "", "utf8") : void 0
+    ].filter(Boolean)
+  );
+  return files;
+}
+async function resolveCliConnection(params, tempDir) {
+  var _a;
+  const type = params.type;
+  if (!type) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Database type is required for native backup jobs."
+    });
+  }
+  if (type === DatabaseClientType.SQLITE3) {
+    if (!params.filePath) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "SQLite native backup requires a file path."
+      });
+    }
+    return {
+      filePath: params.filePath
+    };
+  }
+  const fromUrl = parseConnectionString(params.dbConnectionString, type);
+  const host = params.host || fromUrl.host;
+  const port = parseInt(
+    params.port || `${fromUrl.port || getDefaultPort(type)}`,
+    10
+  );
+  const username = params.username || fromUrl.username;
+  const password = params.password || fromUrl.password;
+  const database = params.serviceName || params.database || fromUrl.database;
+  if (!host) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "Host is required for native backup jobs."
+    });
+  }
+  let finalHost = host;
+  let finalPort = port;
+  let closeTunnel;
+  if ((_a = params.ssh) == null ? void 0 : _a.enabled) {
+    const tunnel = await createSshTunnel(params.ssh, host, port);
+    finalHost = tunnel.localHost;
+    finalPort = tunnel.localPort;
+    closeTunnel = tunnel.close;
+  }
+  return {
+    host: finalHost,
+    port: finalPort,
+    username,
+    password,
+    database,
+    ssl: params.ssl,
+    sslFiles: await writeSslFiles(tempDir, params.ssl),
+    closeTunnel
+  };
+}
+function parseHumanBytes(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  if (!value) {
+    return null;
+  }
+  const match = value.trim().match(/^([\d.]+)\s*([KMGT]?B)$/i);
+  if (!match) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? parsed : null;
+  }
+  const numericValue = Number(match[1]);
+  const unit = match[2].toUpperCase();
+  const multiplier = {
+    B: 1,
+    KB: 1024,
+    MB: 1024 ** 2,
+    GB: 1024 ** 3,
+    TB: 1024 ** 4
+  }[unit] || 1;
+  return Math.round(numericValue * multiplier);
+}
+function resolveDefaultSchemas(type, params) {
+  switch (type) {
+    case DatabaseClientType.POSTGRES:
+      return ["public"];
+    case DatabaseClientType.MYSQL:
+    case DatabaseClientType.MARIADB:
+      return [params.database || resolveDatabaseName(params)];
+    default:
+      return [];
+  }
+}
+async function estimateExportBytes(params) {
+  var _a;
+  if (!params.type) {
+    return void 0;
+  }
+  if (params.type === DatabaseClientType.SQLITE3 && params.filePath) {
+    try {
+      const fileStat = await stat(params.filePath);
+      return fileStat.size;
+    } catch {
+      return void 0;
+    }
+  }
+  try {
+    const tableAdapter = await createTableAdapter(params.type, params);
+    const schemas = ((_a = params.options.schemas) == null ? void 0 : _a.length) && params.type === DatabaseClientType.POSTGRES ? params.options.schemas : resolveDefaultSchemas(params.type, params);
+    let totalBytes = 0;
+    for (const schema of schemas) {
+      const tables = await tableAdapter.getOverviewTables(schema);
+      tables.forEach((table) => {
+        totalBytes += parseHumanBytes(table.total_size) || 0;
+      });
+    }
+    return totalBytes || void 0;
+  } catch {
+    return void 0;
+  }
+}
+function getMysqlSslMode(mode) {
+  switch (mode) {
+    case "preferred":
+      return "PREFERRED";
+    case "require":
+      return "REQUIRED";
+    case "verify-ca":
+      return "VERIFY_CA";
+    case "verify-full":
+      return "VERIFY_IDENTITY";
+    default:
+      return void 0;
+  }
+}
+function buildPostgresEnv(connection) {
+  var _a, _b, _c, _d;
+  return {
+    ...process.env,
+    ...connection.password ? { PGPASSWORD: connection.password } : {},
+    ...((_a = connection.ssl) == null ? void 0 : _a.mode) && connection.ssl.mode !== "disable" ? { PGSSLMODE: connection.ssl.mode } : {},
+    ...((_b = connection.sslFiles) == null ? void 0 : _b.caPath) ? { PGSSLROOTCERT: connection.sslFiles.caPath } : {},
+    ...((_c = connection.sslFiles) == null ? void 0 : _c.certPath) ? { PGSSLCERT: connection.sslFiles.certPath } : {},
+    ...((_d = connection.sslFiles) == null ? void 0 : _d.keyPath) ? { PGSSLKEY: connection.sslFiles.keyPath } : {}
+  };
+}
+function buildMysqlEnv(connection) {
+  return {
+    ...process.env,
+    ...connection.password ? { MYSQL_PWD: connection.password } : {}
+  };
+}
+function appendMysqlSslArgs(args, connection) {
+  var _a, _b, _c, _d;
+  const sslMode = getMysqlSslMode((_a = connection.ssl) == null ? void 0 : _a.mode);
+  if (sslMode) {
+    args.push(`--ssl-mode=${sslMode}`);
+  }
+  if ((_b = connection.sslFiles) == null ? void 0 : _b.caPath) {
+    args.push(`--ssl-ca=${connection.sslFiles.caPath}`);
+  }
+  if ((_c = connection.sslFiles) == null ? void 0 : _c.certPath) {
+    args.push(`--ssl-cert=${connection.sslFiles.certPath}`);
+  }
+  if ((_d = connection.sslFiles) == null ? void 0 : _d.keyPath) {
+    args.push(`--ssl-key=${connection.sslFiles.keyPath}`);
+  }
+}
+function toDbProgress(bytesProcessed, bytesTotal, min = 15, max = 90) {
+  if (!bytesTotal || bytesTotal <= 0) {
+    return null;
+  }
+  const ratio = Math.max(0, Math.min(bytesProcessed / bytesTotal, 1));
+  return Math.round(min + ratio * (max - min));
+}
+function createMissingCommandError(command) {
+  const error = new Error(
+    `${command} is not installed on the runtime host.`
+  );
+  error.cliCode = "CLI_NOT_FOUND";
+  return error;
+}
+function isMissingCommandError(error) {
+  return error instanceof Error && error.cliCode === "CLI_NOT_FOUND";
+}
+function collectLines(onLine) {
+  let buffer = "";
+  return (chunk) => {
+    buffer += chunk.toString();
+    while (buffer.includes("\n")) {
+      const newLineIndex = buffer.indexOf("\n");
+      const line = buffer.slice(0, newLineIndex).trim();
+      buffer = buffer.slice(newLineIndex + 1);
+      if (line) {
+        onLine == null ? void 0 : onLine(line);
+      }
+    }
+  };
+}
+async function runCommandToFile({
+  command,
+  args,
+  env,
+  outputPath,
+  onBytes,
+  onStderrLine
+}) {
+  var _a, _b;
+  const child = spawn(command, args, {
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  const output = createWriteStream(outputPath);
+  const parseStderr = collectLines(onStderrLine);
+  let stderr = "";
+  let writtenBytes = 0;
+  (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+    writtenBytes += chunk.length;
+    onBytes == null ? void 0 : onBytes(writtenBytes);
+    output.write(chunk);
+  });
+  (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+    stderr += chunk.toString();
+    parseStderr(chunk);
+  });
+  const code = await new Promise((resolve, reject) => {
+    child.once("close", (exitCode) => resolve(exitCode));
+    child.once("error", (error) => {
+      reject(
+        error.code === "ENOENT" ? createMissingCommandError(command) : error
+      );
+    });
+    output.once("error", (error) => {
+      child.kill("SIGTERM");
+      reject(error);
+    });
+  });
+  output.end();
+  await once(output, "finish");
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `${command} exited with code ${code}`);
+  }
+  return {
+    bytesWritten: writtenBytes,
+    stderr: stderr.trim()
+  };
+}
+async function runCommandWithInputFile({
+  command,
+  args,
+  env,
+  inputPath,
+  onBytes,
+  onStderrLine
+}) {
+  var _a;
+  const child = spawn(command, args, {
+    env,
+    stdio: ["pipe", "ignore", "pipe"]
+  });
+  const input = createReadStream(inputPath);
+  const parseStderr = collectLines(onStderrLine);
+  let stderr = "";
+  let streamedBytes = 0;
+  input.on("data", (chunk) => {
+    streamedBytes += chunk.length;
+    onBytes == null ? void 0 : onBytes(streamedBytes);
+  });
+  input.on("error", (error) => {
+    var _a2;
+    (_a2 = child.stdin) == null ? void 0 : _a2.destroy(error);
+  });
+  (_a = child.stderr) == null ? void 0 : _a.on("data", (chunk) => {
+    stderr += chunk.toString();
+    parseStderr(chunk);
+  });
+  input.pipe(child.stdin);
+  const code = await new Promise((resolve, reject) => {
+    child.once("close", (exitCode) => resolve(exitCode));
+    child.once("error", (error) => {
+      reject(
+        error.code === "ENOENT" ? createMissingCommandError(command) : error
+      );
+    });
+    input.once("error", (error) => {
+      child.kill("SIGTERM");
+      reject(error);
+    });
+  });
+  if (code !== 0) {
+    throw new Error(stderr.trim() || `${command} exited with code ${code}`);
+  }
+  return {
+    bytesRead: streamedBytes,
+    stderr: stderr.trim()
+  };
+}
+async function runCommandCapture({
+  command,
+  args,
+  env,
+  onStderrLine
+}) {
+  var _a, _b;
+  const child = spawn(command, args, {
+    env,
+    stdio: ["ignore", "pipe", "pipe"]
+  });
+  let stdout = "";
+  let stderr = "";
+  const parseStderr = collectLines(onStderrLine);
+  (_a = child.stdout) == null ? void 0 : _a.on("data", (chunk) => {
+    stdout += chunk.toString();
+  });
+  (_b = child.stderr) == null ? void 0 : _b.on("data", (chunk) => {
+    stderr += chunk.toString();
+    parseStderr(chunk);
+  });
+  const closePromise = once(child, "close");
+  const errorPromise = once(child, "error").catch(() => null);
+  const result = await Promise.race([
+    closePromise.then(([code]) => ({ code })),
+    errorPromise.then((value) => {
+      if (!value) {
+        return Promise.reject(new Error("Unknown command failure."));
+      }
+      const [error] = value;
+      return Promise.reject(
+        error.code === "ENOENT" ? createMissingCommandError(command) : error
+      );
+    })
+  ]);
+  if (result.code !== 0) {
+    throw new Error(
+      stderr.trim() || `${command} exited with code ${result.code}`
+    );
+  }
+  return { stdout: stdout.trim(), stderr: stderr.trim() };
+}
+function updateJob(jobId, patch) {
+  const current = nativeBackupJobs.get(jobId);
+  if (!current) {
+    return;
+  }
+  nativeBackupJobs.set(jobId, {
+    ...current,
+    ...patch
+  });
+}
+function getJob(jobId) {
+  return nativeBackupJobs.get(jobId);
+}
+function scheduleCleanup(jobId) {
+  var _a, _b, _c;
+  const record = getJob(jobId);
+  if (!record) {
+    return;
+  }
+  (_b = (_a = record.cleanupTimer) == null ? void 0 : _a.refresh) == null ? void 0 : _b.call(_a);
+  if (record.cleanupTimer) {
+    clearTimeout(record.cleanupTimer);
+  }
+  const timer = setTimeout(() => {
+    void destroyNativeBackupJob(jobId);
+  }, NATIVE_BACKUP_TTL_MS);
+  (_c = timer.unref) == null ? void 0 : _c.call(timer);
+  updateJob(jobId, { cleanupTimer: timer });
+}
+async function destroyNativeBackupJob(jobId) {
+  const record = getJob(jobId);
+  if (!record) {
+    return;
+  }
+  if (record.cleanupTimer) {
+    clearTimeout(record.cleanupTimer);
+  }
+  nativeBackupJobs.delete(jobId);
+  await rm(record.tempDir, { recursive: true, force: true });
+}
+function quoteMysqlIdentifier(identifier) {
+  return `\`${identifier.replace(/`/g, "``")}\``;
+}
+async function maybeResetMysqlDatabase(connection, options) {
+  if (!options.clean || options.dataOnly || !connection.database) {
+    return;
+  }
+  const args = [
+    "--protocol=TCP",
+    "--host",
+    connection.host || "127.0.0.1",
+    "--port",
+    String(connection.port || 3306),
+    "--user",
+    connection.username || "",
+    "--execute",
+    `DROP DATABASE IF EXISTS ${quoteMysqlIdentifier(connection.database)}; CREATE DATABASE ${quoteMysqlIdentifier(connection.database)};`
+  ];
+  appendMysqlSslArgs(args, connection);
+  await runCommandCapture({
+    command: "mysql",
+    args,
+    env: buildMysqlEnv(connection)
+  });
+}
+async function maybeResetSqliteDatabase(connection, options) {
+  if (!options.clean || options.dataOnly || !connection.filePath) {
+    return;
+  }
+  await rm(connection.filePath, { force: true });
+}
+async function maybeFilterSqliteDumpForDataOnly(outputPath) {
+  const content = await readFile(outputPath, "utf8");
+  const filtered = content.split("\n").filter((line) => {
+    const trimmed = line.trim();
+    return trimmed === "PRAGMA foreign_keys=OFF;" || trimmed === "BEGIN TRANSACTION;" || trimmed === "COMMIT;" || trimmed.startsWith("INSERT INTO ");
+  }).join("\n");
+  await writeFile(outputPath, `${filtered}
+`, "utf8");
+}
+async function runPostgresExport(command, connection, params, artifactPath, estimatedBytes, updateProgress) {
+  const exportFormat = resolveNativeExportFormat(
+    DatabaseClientType.POSTGRES,
+    params.options.format
+  );
+  const isPlainSql = exportFormat === "plain";
+  const args = [
+    "--verbose",
+    `--format=${isPlainSql ? "plain" : "custom"}`,
+    "--host",
+    connection.host || "127.0.0.1",
+    "--port",
+    String(connection.port || 5432),
+    "--username",
+    connection.username || "",
+    "--dbname",
+    connection.database || resolveDatabaseName(params)
+  ];
+  if (params.options.scope === "schema-only") {
+    args.push("--schema-only");
+  }
+  if (params.options.scope === "data-only") {
+    args.push("--data-only");
+  }
+  (params.options.schemas || []).forEach((schema) => {
+    args.push("--schema", schema);
+  });
+  (params.options.tables || []).forEach((table) => {
+    args.push("--table", table);
+  });
+  if (params.options.noOwner) {
+    args.push("--no-owner");
+  }
+  if (params.options.noPrivileges) {
+    args.push("--no-privileges");
+  }
+  if (params.options.clean) {
+    args.push("--clean");
+  }
+  if (params.options.createDb) {
+    args.push("--create");
+  }
+  await runCommandToFile({
+    command,
+    args,
+    env: buildPostgresEnv(connection),
+    outputPath: artifactPath,
+    onBytes: (bytesWritten) => {
+      updateProgress(
+        toDbProgress(bytesWritten, estimatedBytes),
+        `Streaming ${command} ${isPlainSql ? "SQL script" : "archive"}...`,
+        bytesWritten
+      );
+    },
+    onStderrLine: (line) => {
+      updateProgress(null, line);
+    }
+  });
+}
+function getMysqlExportCandidates(params) {
+  var _a, _b;
+  const capability = getNativeBackupCapability(params.type);
+  if (params.options.scope !== "full" || (((_a = params.options.tables) == null ? void 0 : _a.length) || 0) > 0 || ((_b = params.options.schemas) == null ? void 0 : _b.length)) {
+    return capability.exportToolCandidates.filter((tool) => tool === "mysqldump");
+  }
+  return capability.exportToolCandidates;
+}
+async function runMysqlExport(command, connection, params, artifactPath, estimatedBytes, updateProgress) {
+  var _a;
+  const database = connection.database || resolveDatabaseName(params);
+  const args = [
+    "--protocol=TCP",
+    "--host",
+    connection.host || "127.0.0.1",
+    "--port",
+    String(connection.port || 3306),
+    "--user",
+    connection.username || ""
+  ];
+  appendMysqlSslArgs(args, connection);
+  if (command === "mysqlpump") {
+    args.push("--default-parallelism=2");
+  } else {
+    args.push("--single-transaction", "--routines", "--triggers", "--events");
+  }
+  if (params.options.scope === "schema-only") {
+    args.push("--no-data");
+  }
+  if (params.options.scope === "data-only") {
+    args.push("--no-create-info");
+  }
+  if (params.options.clean) {
+    args.push("--add-drop-table");
+  }
+  if (params.options.createDb || !((_a = params.options.tables) == null ? void 0 : _a.length)) {
+    args.push("--databases", database);
+  } else {
+    args.push(database);
+  }
+  (params.options.tables || []).forEach((table) => {
+    args.push(table);
+  });
+  await runCommandToFile({
+    command,
+    args,
+    env: buildMysqlEnv(connection),
+    outputPath: artifactPath,
+    onBytes: (bytesWritten) => {
+      updateProgress(
+        toDbProgress(bytesWritten, estimatedBytes),
+        `Streaming ${command} SQL dump...`,
+        bytesWritten
+      );
+    },
+    onStderrLine: (line) => {
+      updateProgress(null, line);
+    }
+  });
+}
+async function runSqliteExport(command, connection, params, artifactPath, estimatedBytes, updateProgress) {
+  var _a;
+  const dumpCommand = params.options.scope === "schema-only" ? ".schema" : ".dump";
+  const args = [connection.filePath || "", dumpCommand];
+  if ((_a = params.options.tables) == null ? void 0 : _a.length) {
+    args.push(...params.options.tables);
+  }
+  await runCommandToFile({
+    command,
+    args,
+    env: process.env,
+    outputPath: artifactPath,
+    onBytes: (bytesWritten) => {
+      updateProgress(
+        toDbProgress(bytesWritten, estimatedBytes),
+        "Streaming sqlite3 dump...",
+        bytesWritten
+      );
+    }
+  });
+  if (params.options.scope === "data-only") {
+    updateProgress(92, "Filtering SQLite dump to INSERT statements only...");
+    await maybeFilterSqliteDumpForDataOnly(artifactPath);
+  }
+}
+async function runPostgresImport(command, connection, params, updateProgress) {
+  const env = buildPostgresEnv(connection);
+  if (command === "psql") {
+    const fileStat = await stat(params.uploadPath);
+    const args2 = [
+      "--host",
+      connection.host || "127.0.0.1",
+      "--port",
+      String(connection.port || 5432),
+      "--username",
+      connection.username || "",
+      "--dbname",
+      connection.database || resolveDatabaseName(params)
+    ];
+    if (params.options.exitOnError !== false) {
+      args2.push("--set", "ON_ERROR_STOP=1");
+    }
+    await runCommandWithInputFile({
+      command,
+      args: args2,
+      env,
+      inputPath: params.uploadPath,
+      onBytes: (bytesRead) => {
+        updateProgress(
+          toDbProgress(bytesRead, fileStat.size),
+          "Streaming SQL into psql...",
+          bytesRead
+        );
+      },
+      onStderrLine: (line) => {
+        updateProgress(null, line);
+      }
+    });
+    return;
+  }
+  const listArgs = ["--list", params.uploadPath];
+  const { stdout } = await runCommandCapture({
+    command: "pg_restore",
+    args: listArgs,
+    env
+  });
+  const estimatedSteps = Math.max(
+    stdout.split("\n").filter((line) => line.trim() && !line.startsWith(";")).length,
+    1
+  );
+  let processedSteps = 0;
+  const args = [
+    "--verbose",
+    "--host",
+    connection.host || "127.0.0.1",
+    "--port",
+    String(connection.port || 5432),
+    "--username",
+    connection.username || "",
+    "--dbname",
+    connection.database || resolveDatabaseName(params)
+  ];
+  if (params.options.clean) {
+    args.push("--clean");
+  }
+  if (params.options.createDb) {
+    args.push("--create");
+  }
+  if (params.options.dataOnly) {
+    args.push("--data-only");
+  }
+  if (params.options.schemaOnly) {
+    args.push("--schema-only");
+  }
+  if (params.options.exitOnError !== false) {
+    args.push("--exit-on-error");
+  }
+  if (params.options.jobs && params.options.jobs > 1) {
+    args.push("--jobs", String(params.options.jobs));
+  }
+  args.push(params.uploadPath);
+  await runCommandCapture({
+    command: "pg_restore",
+    args,
+    env,
+    onStderrLine: (line) => {
+      processedSteps += 1;
+      updateProgress(
+        Math.min(95, Math.round(15 + processedSteps / estimatedSteps * 75)),
+        line
+      );
+    }
+  });
+  updateProgress(95, `Processed ${estimatedSteps} pg_restore entries.`);
+}
+async function runMysqlImport(connection, params, updateProgress) {
+  await maybeResetMysqlDatabase(connection, params.options);
+  const fileStat = await stat(params.uploadPath);
+  const args = [
+    "--protocol=TCP",
+    "--host",
+    connection.host || "127.0.0.1",
+    "--port",
+    String(connection.port || 3306),
+    "--user",
+    connection.username || ""
+  ];
+  appendMysqlSslArgs(args, connection);
+  if (connection.database) {
+    args.push(connection.database);
+  }
+  await runCommandWithInputFile({
+    command: "mysql",
+    args,
+    env: buildMysqlEnv(connection),
+    inputPath: params.uploadPath,
+    onBytes: (bytesRead) => {
+      updateProgress(
+        toDbProgress(bytesRead, fileStat.size),
+        "Streaming SQL into mysql...",
+        bytesRead
+      );
+    },
+    onStderrLine: (line) => {
+      updateProgress(null, line);
+    }
+  });
+}
+async function runSqliteImport(connection, params, updateProgress) {
+  await maybeResetSqliteDatabase(connection, params.options);
+  const fileStat = await stat(params.uploadPath);
+  await runCommandWithInputFile({
+    command: "sqlite3",
+    args: [connection.filePath || ""],
+    env: process.env,
+    inputPath: params.uploadPath,
+    onBytes: (bytesRead) => {
+      updateProgress(
+        toDbProgress(bytesRead, fileStat.size),
+        "Streaming SQL into sqlite3...",
+        bytesRead
+      );
+    },
+    onStderrLine: (line) => {
+      updateProgress(null, line);
+    }
+  });
+}
+async function withCommandFallback(candidates, run) {
+  let lastMissingError = null;
+  for (const command of candidates) {
+    try {
+      return await run(command);
+    } catch (error) {
+      if (isMissingCommandError(error)) {
+        lastMissingError = error;
+        continue;
+      }
+      throw error;
+    }
+  }
+  throw lastMissingError || new Error("No supported native backup tool is available.");
+}
+function createJobRecord(jobId, operation, type, tempDir, tool) {
+  return {
+    jobId,
+    operation,
+    status: "queued",
+    stage: "queued",
+    databaseType: type,
+    tool,
+    progress: 0,
+    message: "Queued",
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    tempDir
+  };
+}
+async function runNativeExportJob(jobId, params) {
+  var _a;
+  const record = getJob(jobId);
+  if (!record || !params.type) {
+    return;
+  }
+  const startedAt = Date.now();
+  let connection = null;
+  try {
+    updateJob(jobId, {
+      status: "running",
+      stage: "preparing",
+      progress: 5,
+      message: "Preparing native backup job..."
+    });
+    connection = await resolveCliConnection(params, record.tempDir);
+    const estimatedBytes = await estimateExportBytes(params);
+    const capability = getNativeBackupCapability(params.type);
+    await withCommandFallback(
+      params.type === DatabaseClientType.MYSQL || params.type === DatabaseClientType.MARIADB ? getMysqlExportCandidates(params) : capability.exportToolCandidates,
+      async (command) => {
+        updateJob(jobId, {
+          stage: "starting",
+          progress: 10,
+          tool: command,
+          message: `Starting ${command}...`
+        });
+        if (params.type === DatabaseClientType.POSTGRES) {
+          await runPostgresExport(
+            command,
+            connection,
+            params,
+            record.artifactPath || "",
+            estimatedBytes,
+            (progress, message, bytes) => {
+              var _a2, _b;
+              const previousProgress = (_b = (_a2 = getJob(jobId)) == null ? void 0 : _a2.progress) != null ? _b : null;
+              updateJob(jobId, {
+                stage: "dumping",
+                progress: progress != null ? progress : previousProgress,
+                bytesProcessed: bytes,
+                bytesTotal: estimatedBytes,
+                message
+              });
+            }
+          );
+          return;
+        }
+        if (params.type === DatabaseClientType.MYSQL || params.type === DatabaseClientType.MARIADB) {
+          await runMysqlExport(
+            command,
+            connection,
+            params,
+            record.artifactPath || "",
+            estimatedBytes,
+            (progress, message, bytes) => {
+              var _a2, _b;
+              const previousProgress = (_b = (_a2 = getJob(jobId)) == null ? void 0 : _a2.progress) != null ? _b : null;
+              updateJob(jobId, {
+                stage: "dumping",
+                progress: progress != null ? progress : previousProgress,
+                bytesProcessed: bytes,
+                bytesTotal: estimatedBytes,
+                message
+              });
+            }
+          );
+          return;
+        }
+        if (params.type === DatabaseClientType.SQLITE3) {
+          await runSqliteExport(
+            command,
+            connection,
+            params,
+            record.artifactPath || "",
+            estimatedBytes,
+            (progress, message, bytes) => {
+              var _a2, _b;
+              const previousProgress = (_b = (_a2 = getJob(jobId)) == null ? void 0 : _a2.progress) != null ? _b : null;
+              updateJob(jobId, {
+                stage: "dumping",
+                progress: progress != null ? progress : previousProgress,
+                bytesProcessed: bytes,
+                bytesTotal: estimatedBytes,
+                message
+              });
+            }
+          );
+          return;
+        }
+      }
+    );
+    const fileStat = await stat(record.artifactPath || "");
+    updateJob(jobId, {
+      status: "completed",
+      stage: "completed",
+      progress: 100,
+      bytesProcessed: fileStat.size,
+      bytesTotal: fileStat.size,
+      message: `Backup is ready. ${fileStat.size} bytes generated.`,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: Date.now() - startedAt,
+      downloadReady: true,
+      downloadUrl: `/api/database-export/jobs/${jobId}/download`
+    });
+  } catch (error) {
+    updateJob(jobId, {
+      status: "error",
+      stage: "error",
+      progress: null,
+      error: error instanceof Error ? error.message : "Export failed.",
+      message: error instanceof Error ? error.message : "Export failed.",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: Date.now() - startedAt
+    });
+  } finally {
+    await ((_a = connection == null ? void 0 : connection.closeTunnel) == null ? void 0 : _a.call(connection));
+    scheduleCleanup(jobId);
+  }
+}
+async function runNativeImportJob(jobId, params) {
+  var _a;
+  const record = getJob(jobId);
+  if (!record || !params.type) {
+    return;
+  }
+  const startedAt = Date.now();
+  let connection = null;
+  try {
+    updateJob(jobId, {
+      status: "running",
+      stage: "preparing",
+      progress: 5,
+      message: "Preparing native restore job..."
+    });
+    connection = await resolveCliConnection(params, record.tempDir);
+    const capability = getNativeBackupCapability(params.type);
+    const importToolCandidates = params.type === DatabaseClientType.POSTGRES ? [getNativeBackupImportTool(params.type, params.uploadFileName)] : capability.importToolCandidates;
+    await withCommandFallback(importToolCandidates, async (command) => {
+      updateJob(jobId, {
+        stage: "starting",
+        progress: 10,
+        tool: command,
+        message: `Starting ${command}...`
+      });
+      if (params.type === DatabaseClientType.POSTGRES) {
+        await runPostgresImport(
+          command,
+          connection,
+          params,
+          (progress, message, bytes) => {
+            var _a2, _b;
+            const previousProgress = (_b = (_a2 = getJob(jobId)) == null ? void 0 : _a2.progress) != null ? _b : null;
+            updateJob(jobId, {
+              stage: "restoring",
+              progress: progress != null ? progress : previousProgress,
+              bytesProcessed: bytes,
+              message
+            });
+          }
+        );
+        return;
+      }
+      if (params.type === DatabaseClientType.MYSQL || params.type === DatabaseClientType.MARIADB) {
+        await runMysqlImport(
+          connection,
+          params,
+          (progress, message, bytes) => {
+            var _a2, _b;
+            const previousProgress = (_b = (_a2 = getJob(jobId)) == null ? void 0 : _a2.progress) != null ? _b : null;
+            updateJob(jobId, {
+              stage: "restoring",
+              progress: progress != null ? progress : previousProgress,
+              bytesProcessed: bytes,
+              message
+            });
+          }
+        );
+        return;
+      }
+      if (params.type === DatabaseClientType.SQLITE3) {
+        await runSqliteImport(
+          connection,
+          params,
+          (progress, message, bytes) => {
+            var _a2, _b;
+            const previousProgress = (_b = (_a2 = getJob(jobId)) == null ? void 0 : _a2.progress) != null ? _b : null;
+            updateJob(jobId, {
+              stage: "restoring",
+              progress: progress != null ? progress : previousProgress,
+              bytesProcessed: bytes,
+              message
+            });
+          }
+        );
+      }
+    });
+    updateJob(jobId, {
+      status: "completed",
+      stage: "completed",
+      progress: 100,
+      message: `${params.uploadFileName} restored successfully.`,
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: Date.now() - startedAt
+    });
+  } catch (error) {
+    updateJob(jobId, {
+      status: "error",
+      stage: "error",
+      progress: null,
+      error: error instanceof Error ? error.message : "Import failed.",
+      message: error instanceof Error ? error.message : "Import failed.",
+      completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      duration: Date.now() - startedAt
+    });
+  } finally {
+    await ((_a = connection == null ? void 0 : connection.closeTunnel) == null ? void 0 : _a.call(connection));
+    scheduleCleanup(jobId);
+  }
+}
+async function startNativeExportJob(params) {
+  assertNativeBackupSupported(params.type);
+  const tempDir = await mkdtemp(join(tmpdir(), "heraq-native-export-"));
+  const jobId = randomUUID();
+  const artifactName = buildNativeBackupFileName(
+    resolveDatabaseName(params),
+    params.type,
+    /* @__PURE__ */ new Date(),
+    params.options.format
+  );
+  const fileKind = getNativeBackupFileKind(params.type, params.options.format);
+  const record = createJobRecord(
+    jobId,
+    "export",
+    params.type,
+    tempDir,
+    "pending"
+  );
+  nativeBackupJobs.set(jobId, {
+    ...record,
+    artifactPath: join(tempDir, artifactName),
+    artifactContentType: fileKind === "sql" ? "application/sql; charset=utf-8" : "application/octet-stream",
+    downloadFileName: artifactName
+  });
+  void runNativeExportJob(jobId, params);
+  return {
+    jobId,
+    statusUrl: `/api/database-export/jobs/${jobId}`,
+    downloadUrl: `/api/database-export/jobs/${jobId}/download`
+  };
+}
+async function startNativeImportJob(params) {
+  assertNativeBackupSupported(params.type);
+  const tempDir = await mkdtemp(join(tmpdir(), "heraq-native-import-"));
+  const jobId = randomUUID();
+  const uploadPath = join(tempDir, params.uploadFileName);
+  const record = createJobRecord(
+    jobId,
+    "import",
+    params.type,
+    tempDir,
+    "pending"
+  );
+  await writeFile(uploadPath, params.fileData);
+  nativeBackupJobs.set(jobId, {
+    ...record,
+    uploadPath
+  });
+  void runNativeImportJob(jobId, {
+    ...params,
+    uploadPath
+  });
+  return {
+    jobId,
+    statusUrl: `/api/database-import/jobs/${jobId}`
+  };
+}
+function getNativeBackupJobSnapshot(jobId) {
+  const record = getJob(jobId);
+  if (!record) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Backup job not found or has expired."
+    });
+  }
+  return {
+    jobId: record.jobId,
+    operation: record.operation,
+    status: record.status,
+    stage: record.stage,
+    databaseType: record.databaseType,
+    tool: record.tool,
+    progress: record.progress,
+    message: record.message,
+    bytesProcessed: record.bytesProcessed,
+    bytesTotal: record.bytesTotal,
+    startedAt: record.startedAt,
+    completedAt: record.completedAt,
+    duration: record.duration,
+    downloadReady: record.downloadReady,
+    downloadFileName: record.downloadFileName,
+    downloadUrl: record.downloadUrl,
+    warnings: record.warnings,
+    error: record.error
+  };
+}
+function getNativeExportDownload(jobId) {
+  const record = getJob(jobId);
+  if (!record || record.operation !== "export" || !record.artifactPath) {
+    throw createError({
+      statusCode: 404,
+      statusMessage: "Export artifact not found or has expired."
+    });
+  }
+  if (record.status !== "completed") {
+    throw createError({
+      statusCode: 409,
+      statusMessage: "Export artifact is not ready yet."
+    });
+  }
+  return {
+    filePath: record.artifactPath,
+    fileName: record.downloadFileName || basename(record.artifactPath),
+    contentType: record.artifactContentType || "application/octet-stream"
+  };
+}
+
+export { getNativeExportDownload as a, startNativeImportJob as b, getNativeBackupJobSnapshot as g, startNativeExportJob as s };
+//# sourceMappingURL=native-backup-jobs.mjs.map