@stacksjs/ts-cloud 0.7.93 → 0.7.95

package/dist/{chunk-y5wrqyyz.js → chunk-3d4204h1.js}

@@ -45,7 +45,7 @@ import {
   resolveSiteKind,
   resolveUiSource,
   siteInstallBase
-} from "./chunk-fbwcv2vf.js";
+} from "./chunk-xp3txtg9.js";
 import {
   artifactKey,
   buildCloudFormationTemplate,
@@ -39487,6 +39487,10 @@ async function resolveServerDashboardData(config6, environment2, options = {}) {
 }
 
 // src/deploy/dashboard-database.ts
+var EXTERNAL_ENGINES = new Set(["singlestore", "vitess"]);
+function isExternalEngine(engine) {
+  return EXTERNAL_ENGINES.has(engine);
+}
 var SOCKETS = {
   mysql: "/var/lib/pantry/mysql/mysqld.sock",
   mariadb: "/var/lib/pantry/mariadb/mariadbd.sock"
@@ -39499,6 +39503,10 @@ function normalizeEngine(engine) {
     return "postgres";
   if (engine === "mariadb")
     return "mariadb";
+  if (engine === "singlestore")
+    return "singlestore";
+  if (engine === "vitess")
+    return "vitess";
   return "mysql";
 }
 function resolveDbEngine(config6) {
@@ -39525,6 +39533,8 @@ function pgExec(sql, database) {
   return [`${pgAdminCommand(database)} -tA <<'TS_CLOUD_PG_EOF'`, ...sql, "TS_CLOUD_PG_EOF"];
 }
 function buildListScript(engine, database) {
+  if (engine === "vitess")
+    return buildVitessListScript(database);
   if (engine === "postgres") {
     return pgExec([
       "SELECT 'DB=' || datname FROM pg_database WHERE datistemplate = false;",
@@ -39536,6 +39546,72 @@ function buildListScript(engine, database) {
     "SELECT DISTINCT CONCAT('USER=', User) FROM mysql.user WHERE User NOT IN ('root', 'mysql.sys', 'mysql.session', 'mysql.infoschema', 'debian-sys-maint');"
   ]);
 }
+function externalMysqlExec(sql, database, port) {
+  const host2 = database?.host ?? "127.0.0.1";
+  const user = database?.username ?? "root";
+  const pass = database?.password ?? "";
+  const tls = database?.ssl === false ? "" : " --ssl-mode=PREFERRED";
+  const shq = (v) => `'${String(v).replace(/'/g, `'\\''`)}'`;
+  const env = pass ? `MYSQL_PWD=${shq(pass)} ` : "";
+  return [
+    `${env}mysql -h ${shq(host2)} -P ${database?.port ?? port} -u ${shq(user)}${tls} --batch --skip-column-names <<'TS_CLOUD_SQL_EOF'`,
+    ...sql,
+    "TS_CLOUD_SQL_EOF"
+  ];
+}
+var VTGATE_DEFAULT_PORT = 15306;
+function buildVitessListScript(database) {
+  const script = externalMysqlExec(["SHOW KEYSPACES;"], database, VTGATE_DEFAULT_PORT);
+  script[0] = `${script[0]} | sed 's/^/DB=/'`;
+  return script;
+}
+function buildVitessTopologyScript(database) {
+  return externalMysqlExec([
+    `SHOW KEYSPACES;`,
+    `SHOW VITESS_SHARDS;`,
+    `SHOW VITESS_TABLETS;`
+  ], database, VTGATE_DEFAULT_PORT);
+}
+function parseVitessTopology(output) {
+  const keyspaces = [];
+  const shards = [];
+  const tablets = [];
+  for (const rawLine of output.split(`
+`)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    const cols = line.split("\t").map((c) => c.trim()).filter(Boolean);
+    if (cols.length >= 6) {
+      const [cell, keyspace, shard, type, state, alias, hostname] = cols;
+      tablets.push({
+        cell: cell ?? "",
+        keyspace: keyspace ?? "",
+        shard: shard ?? "",
+        type: type ?? "",
+        state: state ?? "",
+        alias: alias ?? "",
+        hostname: hostname ?? ""
+      });
+      continue;
+    }
+    if (cols.length === 1) {
+      const only = cols[0];
+      if (only.includes("/")) {
+        const [keyspace, shard] = only.split("/");
+        if (keyspace && shard)
+          shards.push({ keyspace, shard });
+      } else {
+        keyspaces.push(only);
+      }
+    }
+  }
+  return {
+    keyspaces: [...new Set(keyspaces)].filter(Boolean).sort(),
+    shards,
+    tablets
+  };
+}
 function buildCreateDatabaseScript(engine, name, database) {
   if (engine === "postgres") {
     return pgExec([
@@ -39612,18 +39688,31 @@ async function runDb(config6, environment2, commands, comment) {
     stderr: result2.perInstance?.[0]?.error ?? result2.error ?? ""
   };
 }
+function externalEngineRefusal(engine, action) {
+  const where = engine === "vitess" ? "Create a keyspace with `vtctldclient CreateKeyspace`, and manage vtgate credentials on the cluster." : "Use the provider console or the cluster's own admin connection.";
+  return {
+    ok: false,
+    error: `${action} is not available for ${engine}: it is an external cluster, so this box has no engine to administer. ${where}`
+  };
+}
 async function listDatabases(config6, environment2) {
   const engine = resolveDbEngine(config6);
+  if (isExternalEngine(engine) && engine !== "vitess")
+    return { ...externalEngineRefusal(engine, "Listing databases"), engine, databases: [], users: [] };
   const r = await runDb(config6, environment2, buildListScript(engine, resolveAppDatabase(config6)), "ts-cloud db:list");
   const parsed = r.ok && r.stdout ? parseDbList(r.stdout) : { databases: [], users: [] };
   return { ...r, engine, ...parsed };
 }
 async function createDatabase(config6, environment2, name) {
   const engine = resolveDbEngine(config6);
+  if (isExternalEngine(engine))
+    return externalEngineRefusal(engine, "Creating a database");
   return runDb(config6, environment2, buildCreateDatabaseScript(engine, name, resolveAppDatabase(config6)), `ts-cloud db:create ${name}`);
 }
 async function createDatabaseUser(config6, environment2, input) {
   const engine = resolveDbEngine(config6);
+  if (isExternalEngine(engine))
+    return externalEngineRefusal(engine, "Creating a database user");
   return runDb(config6, environment2, buildCreateUserScript(engine, input, resolveAppDatabase(config6)), `ts-cloud db:user ${input.username}`);
 }
 var DB_BACKUP_DIR = "/var/backups/ts-cloud/databases";
@@ -39667,6 +39756,8 @@ async function backupDatabase(config6, environment2, name) {
   if (!isValidDbIdentifier(name))
     return { ok: false, error: "Database name must be a valid identifier.", database: name };
   const engine = resolveDbEngine(config6);
+  if (isExternalEngine(engine))
+    return { ...externalEngineRefusal(engine, "Backing up"), database: name };
   const r = await runDb(config6, environment2, buildBackupScript(engine, name, DB_BACKUP_DIR, resolveAppDatabase(config6)), `ts-cloud db:backup ${name}`);
   return { ...r, database: name };
 }
@@ -39675,6 +39766,233 @@ async function listDatabaseBackups(config6, environment2) {
   const backups = r.ok && r.stdout ? parseBackups(r.stdout) : [];
   return { ...r, backups };
 }
+async function describeVitess(config6, environment2) {
+  const engine = resolveDbEngine(config6);
+  const empty = { keyspaces: [], shards: [], tablets: [] };
+  if (engine !== "vitess")
+    return { ok: false, error: "The configured database engine is not Vitess.", engine, ...empty };
+  const r = await runDb(config6, environment2, buildVitessTopologyScript(resolveAppDatabase(config6)), "ts-cloud vitess:topology");
+  const parsed = r.ok && r.stdout ? parseVitessTopology(r.stdout) : empty;
+  return { ...r, engine, ...parsed };
+}
+function unhealthyTablets(tablets) {
+  return tablets.filter((t) => t.state.toUpperCase() !== "SERVING");
+}
+function shardsMissingPrimary(topology2) {
+  const withPrimary = new Set(topology2.tablets.filter((t) => t.type.toUpperCase() === "PRIMARY" && t.state.toUpperCase() === "SERVING").map((t) => `${t.keyspace}/${t.shard}`));
+  return topology2.shards.filter((s) => !withPrimary.has(`${s.keyspace}/${s.shard}`));
+}
+
+// src/deploy/dashboard-vitess.ts
+var VTCTLDCLIENT_BIN = "/usr/local/bin/vtctldclient";
+var DEFAULT_VTCTLDCLIENT_VERSION = "21.0.0";
+function sh(value2) {
+  return `'${String(value2).split("'").join("'\\''")}'`;
+}
+function resolveVitessConfig(config6) {
+  return resolveAppDatabase(config6)?.vitess ?? {};
+}
+function isValidKeyspaceName(value2) {
+  return /^[A-Za-z_][A-Za-z0-9_]{0,63}$/.test(value2);
+}
+function isValidMigrationUuid(value2) {
+  return /^[0-9a-f]{8}(?:_[0-9a-f]{4}){3}_[0-9a-f]{12}$/i.test(value2);
+}
+function buildVtctldClientInstallScript(version3 = DEFAULT_VTCTLDCLIENT_VERSION) {
+  const v = sh(version3);
+  return [
+    `if ${VTCTLDCLIENT_BIN} --version 2>/dev/null | grep -q ${v}; then echo "vtctldclient ${version3} already installed"; else`,
+    "  command -v curl >/dev/null 2>&1 || (apt-get update -y && apt-get install -y curl ca-certificates)",
+    '  if [ "$(uname -m)" != "x86_64" ]; then',
+    '    echo "vtctldclient: Vitess publishes only an x86_64 release tarball; this box is $(uname -m). Build from source or install via pantry." >&2',
+    "    exit 1",
+    "  fi",
+    '  tmp="$(mktemp -d)"',
+    `  api="https://api.github.com/repos/vitessio/vitess/releases/tags/v${version3}"`,
+    `  url="$(curl -fsSL "$api" | grep -oE '"browser_download_url"[[:space:]]*:[[:space:]]*"[^"]+vitess-[0-9][^"]*\\.tar\\.gz"' | head -1 | sed -E 's/.*"(https[^"]+)"/\\1/')"`,
+    '  if [ -z "$url" ]; then echo "vtctldclient: no release tarball found for v' + version3 + '" >&2; rm -rf "$tmp"; exit 1; fi',
+    `  curl -fsSL "$url" | tar -xz -C "$tmp" --strip-components=2 --wildcards --occurrence=1 '*/bin/vtctldclient' || true`,
+    '  if [ ! -s "$tmp/vtctldclient" ]; then',
+    '    echo "vtctldclient: could not extract the binary from $url" >&2',
+    '    rm -rf "$tmp"; exit 1',
+    "  fi",
+    `  install -m 0755 "$tmp/vtctldclient" ${VTCTLDCLIENT_BIN}`,
+    '  rm -rf "$tmp"',
+    `  echo "installed vtctldclient ${version3}"`,
+    "fi"
+  ];
+}
+function vtctldCommand(vitess) {
+  if (!vitess.vtctldAddr)
+    return null;
+  return `${VTCTLDCLIENT_BIN} --server ${sh(vitess.vtctldAddr)}`;
+}
+function buildCreateKeyspaceScript(vitess, name, options = {}) {
+  const base = vtctldCommand(vitess);
+  if (!base)
+    return null;
+  const sharded = options.sharded ? " --sharded" : "";
+  return [`${base} CreateKeyspace${sharded} ${sh(name)}`];
+}
+function buildApplyVSchemaScript(vitess, keyspace, vschemaJson) {
+  const base = vtctldCommand(vitess);
+  if (!base)
+    return null;
+  return [
+    'vschema_tmp="$(mktemp)"',
+    `cat > "$vschema_tmp" <<'TS_CLOUD_VSCHEMA_EOF'`,
+    vschemaJson,
+    "TS_CLOUD_VSCHEMA_EOF",
+    `${base} ApplyVSchema --vschema-file "$vschema_tmp" ${sh(keyspace)}`,
+    'rm -f "$vschema_tmp"'
+  ];
+}
+function buildApplySchemaScript(database, sql, strategy2 = "vitess") {
+  return externalMysqlExec([`SET @@ddl_strategy='${strategy2}';`, sql.endsWith(";") ? sql : `${sql};`], database, VTGATE_DEFAULT_PORT);
+}
+function buildMigrationsScript(database, keyspace) {
+  const statements = keyspace ? [`USE ${keyspace.replace(/[^A-Z0-9_]/gi, "")};`, "SHOW VITESS_MIGRATIONS;"] : ["SHOW VITESS_MIGRATIONS;"];
+  const script = externalMysqlExec(statements, database, VTGATE_DEFAULT_PORT);
+  script[0] = script[0].replace(" --skip-column-names", "");
+  return script;
+}
+function parseMigrations(output) {
+  const lines = output.split(`
+`).map((l) => l.trimEnd()).filter((l) => l.trim().length > 0);
+  if (lines.length === 0)
+    return [];
+  const header3 = lines[0].split("\t").map((c) => c.trim());
+  const col = (name) => header3.indexOf(name);
+  const columns = {
+    uuid: col("migration_uuid"),
+    keyspace: col("keyspace"),
+    shard: col("shard"),
+    table: col("mysql_table"),
+    status: col("migration_status"),
+    strategy: col("strategy"),
+    added: col("added_timestamp"),
+    completed: col("completed_timestamp"),
+    progress: col("progress")
+  };
+  if (columns.uuid === -1)
+    return [];
+  const rows = [];
+  for (const line of lines.slice(1)) {
+    const cells = line.split("\t");
+    const at = (i) => i >= 0 ? (cells[i] ?? "").trim() : "";
+    const uuid = at(columns.uuid);
+    if (!uuid)
+      continue;
+    rows.push({
+      uuid,
+      keyspace: at(columns.keyspace),
+      shard: at(columns.shard),
+      table: at(columns.table),
+      status: at(columns.status),
+      strategy: at(columns.strategy),
+      added: at(columns.added),
+      completed: at(columns.completed),
+      progress: at(columns.progress)
+    });
+  }
+  return rows;
+}
+function failedMigrations(migrations2) {
+  return migrations2.filter((m) => m.status.toLowerCase() === "failed");
+}
+function runningMigrations(migrations2) {
+  return migrations2.filter((m) => ["running", "queued", "ready"].includes(m.status.toLowerCase()));
+}
+function buildMigrationActionScript(database, uuid, action) {
+  const verb = action.toUpperCase();
+  return externalMysqlExec([`ALTER VITESS_MIGRATION '${uuid}' ${verb};`], database, VTGATE_DEFAULT_PORT);
+}
+function requireVitess(config6) {
+  if (resolveDbEngine(config6) !== "vitess")
+    return { ok: false, error: "The configured database engine is not Vitess." };
+  return null;
+}
+function requireControlPlane(vitess) {
+  if (!vitess.vtctldAddr) {
+    return {
+      ok: false,
+      error: "No vtctld address is configured. Creating keyspaces and applying a VSchema are topology operations that vtgate cannot perform. " + "Set `infrastructure.appDatabase.vitess.vtctldAddr` (for example `vtctld.internal:15999`) and redeploy."
+    };
+  }
+  return null;
+}
+async function installVtctldClient(config6, environment2) {
+  const wrong = requireVitess(config6);
+  if (wrong)
+    return wrong;
+  const vitess = resolveVitessConfig(config6);
+  return runDb(config6, environment2, buildVtctldClientInstallScript(vitess.clientVersion), "ts-cloud vitess:install-client");
+}
+async function createKeyspace(config6, environment2, name, options = {}) {
+  const wrong = requireVitess(config6);
+  if (wrong)
+    return { ...wrong, keyspace: name };
+  if (!isValidKeyspaceName(name))
+    return { ok: false, error: "Keyspace name must be a valid identifier.", keyspace: name };
+  const vitess = resolveVitessConfig(config6);
+  const missing = requireControlPlane(vitess);
+  if (missing)
+    return { ...missing, keyspace: name };
+  const script = buildCreateKeyspaceScript(vitess, name, options);
+  if (!script)
+    return { ...requireControlPlane({}), keyspace: name };
+  const r = await runDb(config6, environment2, script, `ts-cloud vitess:create-keyspace ${name}`);
+  return { ...r, keyspace: name };
+}
+async function applyVSchema(config6, environment2, keyspace, vschemaJson) {
+  const wrong = requireVitess(config6);
+  if (wrong)
+    return { ...wrong, keyspace };
+  if (!isValidKeyspaceName(keyspace))
+    return { ok: false, error: "Keyspace name must be a valid identifier.", keyspace };
+  try {
+    const parsed = JSON.parse(vschemaJson);
+    if (!parsed || typeof parsed !== "object")
+      return { ok: false, error: "The VSchema must be a JSON object.", keyspace };
+  } catch (error2) {
+    return { ok: false, error: `The VSchema is not valid JSON: ${error2?.message ?? error2}`, keyspace };
+  }
+  const vitess = resolveVitessConfig(config6);
+  const missing = requireControlPlane(vitess);
+  if (missing)
+    return { ...missing, keyspace };
+  const script = buildApplyVSchemaScript(vitess, keyspace, vschemaJson);
+  if (!script)
+    return { ...requireControlPlane({}), keyspace };
+  const r = await runDb(config6, environment2, script, `ts-cloud vitess:apply-vschema ${keyspace}`);
+  return { ...r, keyspace };
+}
+async function applySchemaChange(config6, environment2, sql) {
+  const wrong = requireVitess(config6);
+  if (wrong)
+    return wrong;
+  if (!sql.trim())
+    return { ok: false, error: "No SQL was provided." };
+  const vitess = resolveVitessConfig(config6);
+  return runDb(config6, environment2, buildApplySchemaScript(resolveAppDatabase(config6), sql, vitess.ddlStrategy ?? "vitess"), "ts-cloud vitess:apply-schema");
+}
+async function listMigrations(config6, environment2, keyspace) {
+  const wrong = requireVitess(config6);
+  if (wrong)
+    return { ...wrong, migrations: [], failed: [], running: [] };
+  const r = await runDb(config6, environment2, buildMigrationsScript(resolveAppDatabase(config6), keyspace), "ts-cloud vitess:migrations");
+  const migrations2 = r.ok && r.stdout ? parseMigrations(r.stdout) : [];
+  return { ...r, migrations: migrations2, failed: failedMigrations(migrations2), running: runningMigrations(migrations2) };
+}
+async function actOnMigration(config6, environment2, uuid, action) {
+  const wrong = requireVitess(config6);
+  if (wrong)
+    return { ...wrong, uuid };
+  if (!isValidMigrationUuid(uuid))
+    return { ok: false, error: "Migration UUID is not in the expected format.", uuid };
+  const r = await runDb(config6, environment2, buildMigrationActionScript(resolveAppDatabase(config6), uuid, action), `ts-cloud vitess:migration ${action} ${uuid}`);
+  return { ...r, uuid };
+}
 
 // src/deploy/dashboard-policy.ts
 var FAIL_CLOSED = {
@@ -39914,6 +40232,13 @@ var POLICIES = {
   "DELETE /api/firewall": { capability: "fleet:manage" },
   "GET /api/databases": { capability: "data:read" },
   "POST /api/databases": { capability: "data:admin" },
+  "GET /api/databases/vitess": { capability: "data:read" },
+  "GET /api/databases/vitess/migrations": { capability: "data:read" },
+  "POST /api/databases/vitess/migrations/action": { capability: "data:admin" },
+  "POST /api/databases/vitess/keyspaces": { capability: "data:admin" },
+  "POST /api/databases/vitess/vschema": { capability: "data:admin" },
+  "POST /api/databases/vitess/schema": { capability: "data:admin" },
+  "POST /api/databases/vitess/install-client": { capability: "data:admin" },
   "GET /api/databases/backups": { capability: "backups:read" },
   "POST /api/databases/backup": { capability: "backups:create" },
   "POST /api/databases/users": { capability: "data:admin" },
@@ -48887,6 +49212,45 @@ data: ${JSON.stringify({ cursor: position, at: new Date().toISOString() })}
               }, 422);
             return json15({ ...await createDatabase(config6, environment2, name), name });
           }
+          if (url.pathname === "/api/databases/vitess" && req.method === "GET") {
+            const topology2 = await describeVitess(config6, environment2);
+            return json15({
+              ...topology2,
+              unhealthy: unhealthyTablets(topology2.tablets),
+              missingPrimary: shardsMissingPrimary(topology2)
+            });
+          }
+          if (url.pathname === "/api/databases/vitess/migrations" && req.method === "GET") {
+            const keyspace = url.searchParams.get("keyspace") ?? undefined;
+            return json15(await listMigrations(config6, environment2, keyspace));
+          }
+          if (url.pathname === "/api/databases/vitess/migrations/action" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const uuid = String(body.uuid ?? "").trim();
+            const action = String(body.action ?? "");
+            if (!["retry", "cancel", "cleanup", "complete"].includes(action))
+              return json15({ ok: false, error: "Unknown migration action." }, 422);
+            return json15(await actOnMigration(config6, environment2, uuid, action));
+          }
+          if (url.pathname === "/api/databases/vitess/keyspaces" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const name = String(body.name ?? "").trim();
+            const sharded = body.sharded === true;
+            return json15(await createKeyspace(config6, environment2, name, { sharded }));
+          }
+          if (url.pathname === "/api/databases/vitess/vschema" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const keyspace = String(body.keyspace ?? "").trim();
+            const vschema = typeof body.vschema === "string" ? body.vschema : JSON.stringify(body.vschema ?? null);
+            return json15(await applyVSchema(config6, environment2, keyspace, vschema));
+          }
+          if (url.pathname === "/api/databases/vitess/schema" && req.method === "POST") {
+            const body = await readJsonBody(req);
+            const sql = String(body.sql ?? "");
+            return json15(await applySchemaChange(config6, environment2, sql));
+          }
+          if (url.pathname === "/api/databases/vitess/install-client" && req.method === "POST")
+            return json15(await installVtctldClient(config6, environment2));
           if (url.pathname === "/api/databases/backups" && req.method === "GET")
             return json15(await listDatabaseBackups(config6, environment2));
           if (url.pathname === "/api/databases/backup" && req.method === "POST") {