odoro 1.0.9 → 2.1.0

package/dist/commands-UOWN3IK4.js

@@ -0,0 +1,181 @@
+#!/usr/bin/env node
+import { storeToken, chooseEnvironment, cancelled, chooseRegion, writeDatabaseUrl, assertEnvIgnored, SDK_PACKAGE, loadSdk, findToken } from './chunk-LIKVHWB4.js';
+import { info, success, colors, warn, error } from './chunk-7ZB5MAM6.js';
+import { randomBytes } from 'crypto';
+
+var DEFAULT_API_URL = "https://db.odoro.dev";
+function idempotencyKey() {
+  return randomBytes(24).toString("hex");
+}
+async function connect(options) {
+  const apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+  const load = await loadSdk();
+  if (!load.ok) {
+    error(load.reason);
+    return void 0;
+  }
+  const token = await findToken(apiUrl);
+  if (token === void 0) {
+    error(
+      `No token for ${apiUrl}.
+
+  odoro db:login
+
+Or provide it through the ODORO_TOKEN variable, which is what a
+continuous integration does.`
+    );
+    return void 0;
+  }
+  return { client: load.sdk.createClient({ baseUrl: apiUrl, token }), sdk: load.sdk };
+}
+async function loginCommand(options) {
+  const apiUrl = options.apiUrl ?? DEFAULT_API_URL;
+  const prompts = await import('@clack/prompts');
+  const value = await prompts.password({
+    message: `Token for ${apiUrl}`,
+    validate: (input) => input.startsWith("odk_") ? void 0 : "A token starts with odk_live_ or odk_test_"
+  });
+  if (prompts.isCancel(value)) {
+    info("Cancelled.");
+    return 0;
+  }
+  const report = await storeToken(apiUrl, value);
+  success(`Token recorded in ${colors.dim(report.path)}`);
+  if (!report.restricted) {
+    warn(
+      "The restrictive file permissions could not be set on this system: check that this directory is neither shared nor synchronised."
+    );
+  }
+  return 0;
+}
+async function statusCommand(options) {
+  const connection = await connect(options);
+  if (connection === void 0) return 1;
+  const { databases } = await connection.client.databases.list(
+    options.env === void 0 ? {} : { environmentId: options.env }
+  );
+  if (databases.length === 0) {
+    info("No database. `odoro db:create` provisions one.");
+    return 0;
+  }
+  for (const database of databases) {
+    const state = database.state === "ready" ? colors.green(database.state) : database.state === "failed" || database.state === "quarantined" ? colors.red(database.state) : colors.dim(database.state);
+    console.log(`  ${database.id}  ${state}  ${colors.dim(database.region)}`);
+  }
+  return 0;
+}
+async function createCommand(options) {
+  const connection = await connect(options);
+  if (connection === void 0) return 1;
+  const prompts = await import('@clack/prompts');
+  let environmentId = options.env;
+  if (environmentId === void 0) {
+    const chosen = await chooseEnvironment(prompts, connection.client);
+    if (cancelled(chosen) || chosen === void 0) return 1;
+    environmentId = chosen.id;
+  }
+  let region = options.region;
+  if (region === void 0) {
+    const chosen = await chooseRegion(prompts, connection.client);
+    if (cancelled(chosen)) return 1;
+    region = chosen;
+  }
+  const spinner = prompts.spinner();
+  spinner.start(`Provisioning in ${region ?? "the default region"}`);
+  const abort = new AbortController();
+  const onInterrupt = () => abort.abort();
+  process.once("SIGINT", onInterrupt);
+  try {
+    const finished = await connection.client.databases.createAndWait(
+      {
+        idempotencyKey: idempotencyKey(),
+        environmentId,
+        ...region === void 0 ? {} : { region }
+      },
+      { signal: abort.signal }
+    );
+    spinner.stop("Database provisioned");
+    const databaseId = finished.subject;
+    if (databaseId === void 0) {
+      warn(
+        "The operation succeeded without naming the created database. `odoro db:status` will show it."
+      );
+      return 0;
+    }
+    const { connectionString } = await connection.client.credentials.rotate({
+      databaseId
+    });
+    await writeDatabaseUrl(options.root, connectionString);
+    success("DATABASE_URL written to .env");
+    const risk = await assertEnvIgnored(options.root);
+    if (risk !== void 0) warn(risk);
+    return 0;
+  } catch (cause) {
+    spinner.stop("Provisioning interrupted");
+    if (abort.signal.aborted) {
+      info(
+        "Wait abandoned. The provisioning carries on: `odoro db:status` will show its outcome."
+      );
+      return 0;
+    }
+    error(describe(cause, connection.sdk));
+    return 1;
+  } finally {
+    process.off("SIGINT", onInterrupt);
+  }
+}
+async function branchCommand(options) {
+  const connection = await connect(options);
+  if (connection === void 0) return 1;
+  if (options.from === void 0 || options.name === void 0) {
+    error("Usage: `odoro db:branch --from production --name preview-42`");
+    return 1;
+  }
+  const prompts = await import('@clack/prompts');
+  const spinner = prompts.spinner();
+  spinner.start(`Branching from ${options.from}`);
+  try {
+    const finished = await connection.client.databases.branchAndWait({
+      idempotencyKey: idempotencyKey(),
+      parentEnvironmentId: options.from,
+      name: options.name,
+      // Without a declared rule, the platform refuses. We do not guess in its
+      // place: a rule invented here would anonymise the wrong column, or none.
+      anonymization: []
+    });
+    spinner.stop("Branch created");
+    info(`Database: ${finished.subject ?? "see odoro db:status"}`);
+    return 0;
+  } catch (cause) {
+    spinner.stop("Branch refused");
+    error(describe(cause, connection.sdk));
+    return 1;
+  }
+}
+function describe(cause, sdk) {
+  if (sdk.isApiError(cause, "VALIDATION")) {
+    const errors = cause.options?.errors;
+    return [
+      "The request was refused:",
+      ...(errors ?? []).map(({ field, message }) => `  ${field} \u2014 ${message}`)
+    ].join("\n");
+  }
+  if (sdk.isApiError(cause, "RATE_LIMIT")) {
+    return "Too many requests. The routes that provision are deliberately rate limited: every creation costs.";
+  }
+  if (sdk.isApiError(cause, "UNAUTHORIZED")) {
+    return `Token refused. \`odoro db:login\` records another one.`;
+  }
+  return cause instanceof Error ? cause.message : String(cause);
+}
+var DB_HELP = [
+  "  db:login              Record a platform token",
+  "  db:status             List the databases of the project",
+  "  db:create             Provision a database and write .env",
+  "                        (--env and --region skip the questions)",
+  "  db:branch --from <e> --name <n>",
+  "                        Create a per-branch preview",
+  `                        (requires ${SDK_PACKAGE})`
+].join("\n");
+
+export { DB_HELP, branchCommand, createCommand, loginCommand, statusCommand };