orcaq 1.1.6 → 1.1.7

package/.output/server/chunks/_/{native-backup-jobs.mjs → service.mjs}

@@ -1,23 +1,22 @@
-import { c as createError, f 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 { stat, mkdir, writeFile, readFile, rm, mkdtemp } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
-import { join, basename } from 'node:path';
+import { basename, join } from 'node:path';
 import { D as DatabaseClientType } from './database-client-type.mjs';
-import { e as ensureNativeBackupOperationAvailable, a as assertNativeBackupSupported, b as buildNativeBackupFileName, c as getNativeBackupFileKind, d as getNativeBackupCapability, f as getNativeBackupImportTool, r as resolveNativeExportFormat } from './native-backup.mjs';
+import { c as createError, f as createSshTunnel } from '../nitro/nitro.mjs';
 import { c as createTableAdapter } from './tables.factory.mjs';
+import { spawn } from 'node:child_process';
+import { once } from 'node:events';
+import { createWriteStream, createReadStream } from 'node:fs';
+import { a as getNativeBackupCapability, r as resolveNativeExportFormat, e as ensureNativeBackupOperationAvailable, b as assertNativeBackupSupported, c as buildNativeBackupFileName, d as getNativeBackupFileKind, f as getNativeBackupImportTool } from './runtime.mjs';
+import { c as createJobRecord, s as setJob, b as getJob, u as updateJob, d as scheduleCleanup } from './registry.mjs';
 
-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;
@@ -235,6 +234,7 @@ function toDbProgress(bytesProcessed, bytesTotal, min = 15, max = 90) {
   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.`
@@ -399,77 +399,47 @@ async function runCommandCapture({
   }
   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;
+async function withCommandFallback(candidates, run, requestedRuntime) {
+  var _a;
+  const requestedExecutablePath = (_a = requestedRuntime == null ? void 0 : requestedRuntime.executablePath) == null ? void 0 : _a.trim();
+  if (requestedExecutablePath) {
+    if (!(requestedRuntime == null ? void 0 : requestedRuntime.tool)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: "A native tool must be selected when a custom executable path is provided."
+      });
+    }
+    if (!candidates.includes(requestedRuntime.tool)) {
+      throw createError({
+        statusCode: 400,
+        statusMessage: `${requestedRuntime.tool} cannot be used for this request.`
+      });
+    }
+    return run({
+      tool: requestedRuntime.tool,
+      command: requestedExecutablePath,
+      displayName: requestedExecutablePath
+    });
   }
-  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;
+  let lastMissingError = null;
+  for (const command of candidates) {
+    try {
+      return await run({
+        tool: command,
+        command,
+        displayName: command
+      });
+    } catch (error) {
+      if (isMissingCommandError(error)) {
+        lastMissingError = error;
+        continue;
+      }
+      throw error;
+    }
   }
-  await rm(connection.filePath, { force: true });
+  throw lastMissingError || new Error("No supported native backup tool is available.");
 }
+
 async function maybeFilterSqliteDumpForDataOnly(outputPath) {
   const content = await readFile(outputPath, "utf8");
   const filtered = content.split("\n").filter((line) => {
@@ -479,7 +449,7 @@ async function maybeFilterSqliteDumpForDataOnly(outputPath) {
   await writeFile(outputPath, `${filtered}
 `, "utf8");
 }
-async function runPostgresExport(command, connection, params, artifactPath, estimatedBytes, updateProgress) {
+async function runPostgresExport(invocation, connection, params, artifactPath, estimatedBytes, updateProgress) {
   const exportFormat = resolveNativeExportFormat(
     DatabaseClientType.POSTGRES,
     params.options.format
@@ -522,14 +492,14 @@ async function runPostgresExport(command, connection, params, artifactPath, esti
     args.push("--create");
   }
   await runCommandToFile({
-    command,
+    command: invocation.command,
     args,
     env: buildPostgresEnv(connection),
     outputPath: artifactPath,
     onBytes: (bytesWritten) => {
       updateProgress(
         toDbProgress(bytesWritten, estimatedBytes),
-        `Streaming ${command} ${isPlainSql ? "SQL script" : "archive"}...`,
+        `Streaming ${invocation.tool} ${isPlainSql ? "SQL script" : "archive"}...`,
         bytesWritten
       );
     },
@@ -546,7 +516,7 @@ function getMysqlExportCandidates(params) {
   }
   return capability.exportToolCandidates;
 }
-async function runMysqlExport(command, connection, params, artifactPath, estimatedBytes, updateProgress) {
+async function runMysqlExport(invocation, connection, params, artifactPath, estimatedBytes, updateProgress) {
   var _a;
   const database = connection.database || resolveDatabaseName(params);
   const args = [
@@ -559,7 +529,7 @@ async function runMysqlExport(command, connection, params, artifactPath, estimat
     connection.username || ""
   ];
   appendMysqlSslArgs(args, connection);
-  if (command === "mysqlpump") {
+  if (invocation.tool === "mysqlpump") {
     args.push("--default-parallelism=2");
   } else {
     args.push("--single-transaction", "--routines", "--triggers", "--events");
@@ -582,14 +552,14 @@ async function runMysqlExport(command, connection, params, artifactPath, estimat
     args.push(table);
   });
   await runCommandToFile({
-    command,
+    command: invocation.command,
     args,
     env: buildMysqlEnv(connection),
     outputPath: artifactPath,
     onBytes: (bytesWritten) => {
       updateProgress(
         toDbProgress(bytesWritten, estimatedBytes),
-        `Streaming ${command} SQL dump...`,
+        `Streaming ${invocation.tool} SQL dump...`,
         bytesWritten
       );
     },
@@ -598,7 +568,7 @@ async function runMysqlExport(command, connection, params, artifactPath, estimat
     }
   });
 }
-async function runSqliteExport(command, connection, params, artifactPath, estimatedBytes, updateProgress) {
+async function runSqliteExport(invocation, connection, params, artifactPath, estimatedBytes, updateProgress) {
   var _a;
   const dumpCommand = params.options.scope === "schema-only" ? ".schema" : ".dump";
   const args = [connection.filePath || "", dumpCommand];
@@ -606,7 +576,7 @@ async function runSqliteExport(command, connection, params, artifactPath, estima
     args.push(...params.options.tables);
   }
   await runCommandToFile({
-    command,
+    command: invocation.command,
     args,
     env: process.env,
     outputPath: artifactPath,
@@ -623,9 +593,41 @@ async function runSqliteExport(command, connection, params, artifactPath, estima
     await maybeFilterSqliteDumpForDataOnly(artifactPath);
   }
 }
-async function runPostgresImport(command, connection, params, updateProgress) {
+
+function quoteMysqlIdentifier(identifier) {
+  return `\`${identifier.replace(/`/g, "``")}\``;
+}
+async function maybeResetMysqlDatabase(invocation, connection, params) {
+  if (!params.options.clean || params.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: invocation.command,
+    args,
+    env: buildMysqlEnv(connection)
+  });
+}
+async function maybeResetSqliteDatabase(connection, params) {
+  if (!params.options.clean || params.options.dataOnly || !connection.filePath) {
+    return;
+  }
+  await rm(connection.filePath, { force: true });
+}
+async function runPostgresImport(invocation, connection, params, updateProgress) {
   const env = buildPostgresEnv(connection);
-  if (command === "psql") {
+  if (invocation.tool === "psql") {
     const fileStat = await stat(params.uploadPath);
     const args2 = [
       "--host",
@@ -641,7 +643,7 @@ async function runPostgresImport(command, connection, params, updateProgress) {
       args2.push("--set", "ON_ERROR_STOP=1");
     }
     await runCommandWithInputFile({
-      command,
+      command: invocation.command,
       args: args2,
       env,
       inputPath: params.uploadPath,
@@ -660,7 +662,7 @@ async function runPostgresImport(command, connection, params, updateProgress) {
   }
   const listArgs = ["--list", params.uploadPath];
   const { stdout } = await runCommandCapture({
-    command: "pg_restore",
+    command: invocation.command,
     args: listArgs,
     env
   });
@@ -700,7 +702,7 @@ async function runPostgresImport(command, connection, params, updateProgress) {
   }
   args.push(params.uploadPath);
   await runCommandCapture({
-    command: "pg_restore",
+    command: invocation.command,
     args,
     env,
     onStderrLine: (line) => {
@@ -713,8 +715,8 @@ async function runPostgresImport(command, connection, params, updateProgress) {
   });
   updateProgress(95, `Processed ${estimatedSteps} pg_restore entries.`);
 }
-async function runMysqlImport(connection, params, updateProgress) {
-  await maybeResetMysqlDatabase(connection, params.options);
+async function runMysqlImport(invocation, connection, params, updateProgress) {
+  await maybeResetMysqlDatabase(invocation, connection, params);
   const fileStat = await stat(params.uploadPath);
   const args = [
     "--protocol=TCP",
@@ -730,7 +732,7 @@ async function runMysqlImport(connection, params, updateProgress) {
     args.push(connection.database);
   }
   await runCommandWithInputFile({
-    command: "mysql",
+    command: invocation.command,
     args,
     env: buildMysqlEnv(connection),
     inputPath: params.uploadPath,
@@ -746,11 +748,11 @@ async function runMysqlImport(connection, params, updateProgress) {
     }
   });
 }
-async function runSqliteImport(connection, params, updateProgress) {
-  await maybeResetSqliteDatabase(connection, params.options);
+async function runSqliteImport(invocation, connection, params, updateProgress) {
+  await maybeResetSqliteDatabase(connection, params);
   const fileStat = await stat(params.uploadPath);
   await runCommandWithInputFile({
-    command: "sqlite3",
+    command: invocation.command,
     args: [connection.filePath || ""],
     env: process.env,
     inputPath: params.uploadPath,
@@ -766,35 +768,7 @@ async function runSqliteImport(connection, params, updateProgress) {
     }
   });
 }
-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);
@@ -815,16 +789,16 @@ async function runNativeExportJob(jobId, params) {
     const capability = getNativeBackupCapability(params.type);
     await withCommandFallback(
       params.type === DatabaseClientType.MYSQL || params.type === DatabaseClientType.MARIADB ? getMysqlExportCandidates(params) : capability.exportToolCandidates,
-      async (command) => {
+      async (invocation) => {
         updateJob(jobId, {
           stage: "starting",
           progress: 10,
-          tool: command,
-          message: `Starting ${command}...`
+          tool: invocation.displayName,
+          message: `Starting ${invocation.displayName}...`
         });
         if (params.type === DatabaseClientType.POSTGRES) {
           await runPostgresExport(
-            command,
+            invocation,
             connection,
             params,
             record.artifactPath || "",
@@ -845,7 +819,7 @@ async function runNativeExportJob(jobId, params) {
         }
         if (params.type === DatabaseClientType.MYSQL || params.type === DatabaseClientType.MARIADB) {
           await runMysqlExport(
-            command,
+            invocation,
             connection,
             params,
             record.artifactPath || "",
@@ -866,7 +840,7 @@ async function runNativeExportJob(jobId, params) {
         }
         if (params.type === DatabaseClientType.SQLITE3) {
           await runSqliteExport(
-            command,
+            invocation,
             connection,
             params,
             record.artifactPath || "",
@@ -883,9 +857,9 @@ async function runNativeExportJob(jobId, params) {
               });
             }
           );
-          return;
         }
-      }
+      },
+      params.runtime
     );
     const fileStat = await stat(record.artifactPath || "");
     updateJob(jobId, {
@@ -933,65 +907,71 @@ async function runNativeImportJob(jobId, params) {
     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
-            });
-          }
-        );
-      }
-    });
+    await withCommandFallback(
+      importToolCandidates,
+      async (invocation) => {
+        updateJob(jobId, {
+          stage: "starting",
+          progress: 10,
+          tool: invocation.displayName,
+          message: `Starting ${invocation.displayName}...`
+        });
+        if (params.type === DatabaseClientType.POSTGRES) {
+          await runPostgresImport(
+            invocation,
+            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(
+            invocation,
+            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(
+            invocation,
+            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
+              });
+            }
+          );
+        }
+      },
+      params.runtime
+    );
     updateJob(jobId, {
       status: "completed",
       stage: "completed",
@@ -1016,7 +996,12 @@ async function runNativeImportJob(jobId, params) {
   }
 }
 async function startNativeExportJob(params) {
-  await ensureNativeBackupOperationAvailable(params.type, "export");
+  await ensureNativeBackupOperationAvailable(
+    params.type,
+    "export",
+    void 0,
+    params.runtime
+  );
   assertNativeBackupSupported(params.type);
   const tempDir = await mkdtemp(join(tmpdir(), "heraq-native-export-"));
   const jobId = randomUUID();
@@ -1034,7 +1019,7 @@ async function startNativeExportJob(params) {
     tempDir,
     "pending"
   );
-  nativeBackupJobs.set(jobId, {
+  setJob(jobId, {
     ...record,
     artifactPath: join(tempDir, artifactName),
     artifactContentType: fileKind === "sql" ? "application/sql; charset=utf-8" : "application/octet-stream",
@@ -1051,7 +1036,8 @@ async function startNativeImportJob(params) {
   await ensureNativeBackupOperationAvailable(
     params.type,
     "import",
-    params.uploadFileName
+    params.uploadFileName,
+    params.runtime
   );
   assertNativeBackupSupported(params.type);
   const tempDir = await mkdtemp(join(tmpdir(), "heraq-native-import-"));
@@ -1065,7 +1051,7 @@ async function startNativeImportJob(params) {
     "pending"
   );
   await writeFile(uploadPath, params.fileData);
-  nativeBackupJobs.set(jobId, {
+  setJob(jobId, {
     ...record,
     uploadPath
   });
@@ -1078,55 +1064,6 @@ async function startNativeImportJob(params) {
     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
+export { startNativeImportJob as a, startNativeExportJob as s };
+//# sourceMappingURL=service.mjs.map