odoro 1.0.9 → 2.1.0

package/dist/chunk-LIKVHWB4.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+import { readFile, writeFile, appendFile, mkdir, chmod } from 'fs/promises';
+import { existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { platform, homedir } from 'os';
+import { randomUUID } from 'crypto';
+
+function checkDatabaseUrl(value) {
+  const url = value.trim();
+  if (url.length === 0) return "The URL cannot be empty.";
+  if (!/^postgres(ql)?:\/\//i.test(url)) {
+    return "A PostgreSQL URL starts with postgres:// or postgresql://";
+  }
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    return "This string is not a valid URL.";
+  }
+  if (parsed.hostname.length === 0) return "No host in this URL.";
+  if (parsed.pathname.replace(/^\//, "").length === 0) {
+    return "No database name: add it after the port, for example /my_project";
+  }
+  if (!/^(localhost|127\.0\.0\.1|\[::1\])$/i.test(parsed.hostname) && parsed.searchParams.get("sslmode") === "disable") {
+    return "sslmode=disable on a remote database: the traffic would go in the clear.";
+  }
+  return void 0;
+}
+async function writeDatabaseUrl(target, url) {
+  const path = join(target, ".env");
+  const line = `DATABASE_URL=${url}
+`;
+  if (!existsSync(path)) {
+    const example = join(target, ".env.example");
+    const base = existsSync(example) ? await readFile(example, "utf8") : "";
+    await writeFile(path, base.replace(/^DATABASE_URL=.*$/m, line.trimEnd()), "utf8");
+    if (!base.includes("DATABASE_URL=")) await appendFile(path, line, "utf8");
+    return;
+  }
+  const current = await readFile(path, "utf8");
+  await writeFile(
+    path,
+    current.includes("DATABASE_URL=") ? current.replace(/^DATABASE_URL=.*$/m, line.trimEnd()) : current + line,
+    "utf8"
+  );
+}
+async function assertEnvIgnored(target) {
+  const path = join(target, ".gitignore");
+  if (!existsSync(path)) {
+    return "No .gitignore: the .env file risks being versioned.";
+  }
+  const content = await readFile(path, "utf8");
+  const ignored = content.split("\n").map((line) => line.trim()).some((line) => line === ".env" || line === ".env*" || line === "*.env");
+  return ignored ? void 0 : ".env does not appear in the .gitignore: your credentials risk being versioned.";
+}
+var PROVIDER_PENDING = [
+  "Provisioning goes through @odoro-cli/cloud-sdk, installed separately:",
+  "",
+  "  npm install --save-dev @odoro-cli/cloud-sdk",
+  "  odoro db:login",
+  "  odoro db:create --env production",
+  "",
+  "It does not ship with odoro: this binary is downloaded on every project creation, and most projects use their own database."
+].join("\n");
+
+// src/db/sdk.ts
+var SDK_PACKAGE = "@odoro-cli/cloud-sdk";
+async function loadSdk() {
+  try {
+    const specifier = SDK_PACKAGE;
+    const sdk = await import(specifier);
+    return { ok: true, sdk };
+  } catch {
+    return {
+      ok: false,
+      reason: [
+        `${SDK_PACKAGE} could not be loaded.`,
+        "",
+        "It ships with odoro, so this is usually a partial install:",
+        "",
+        "  npm install",
+        "",
+        "Until it loads, a project can still bring its own PostgreSQL URL."
+      ].join("\n")
+    };
+  }
+}
+function configPath(env = processEnv()) {
+  const xdg = env["XDG_CONFIG_HOME"];
+  if (xdg !== void 0 && xdg.length > 0) return join(xdg, "odoro", "config.json");
+  if (platform() === "win32") {
+    const appData = env["APPDATA"];
+    if (appData !== void 0 && appData.length > 0) {
+      return join(appData, "odoro", "config.json");
+    }
+  }
+  return join(homedir(), ".config", "odoro", "config.json");
+}
+function processEnv() {
+  return process.env;
+}
+async function readUserConfig(path = configPath()) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch {
+    return {};
+  }
+}
+async function writeUserConfig(config, path = configPath()) {
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, `${JSON.stringify(config, null, 2)}
+`, "utf8");
+  if (platform() === "win32") return { path, restricted: false };
+  try {
+    await chmod(path, 384);
+    return { path, restricted: true };
+  } catch {
+    return { path, restricted: false };
+  }
+}
+async function storeToken(apiUrl, token, path = configPath()) {
+  const current = await readUserConfig(path);
+  return await writeUserConfig(
+    {
+      ...current,
+      tokens: { ...current.tokens, [apiUrl]: token },
+      defaultApiUrl: current.defaultApiUrl ?? apiUrl
+    },
+    path
+  );
+}
+async function findToken(apiUrl, path = configPath(), env = processEnv()) {
+  const fromEnv = env["ODORO_TOKEN"];
+  if (fromEnv !== void 0 && fromEnv.length > 0) return fromEnv;
+  const config = await readUserConfig(path);
+  return config.tokens?.[apiUrl];
+}
+var DEFAULT_API_URL = "https://db.odoro.dev";
+function idempotencyKey() {
+  return randomUUID();
+}
+var CANCELLED = /* @__PURE__ */ Symbol("cancelled");
+function cancelled(value) {
+  return value === CANCELLED;
+}
+async function ensureToken(prompts, apiUrl) {
+  const known = await findToken(apiUrl);
+  if (known !== void 0) return known;
+  prompts.log.info(`No token yet for ${apiUrl}. Create one at ${apiUrl}/tokens.`);
+  const value = await prompts.password({
+    message: "Platform token",
+    validate: (input) => input.startsWith("odk_") ? void 0 : "A token starts with odk_live_ or odk_test_"
+  });
+  if (prompts.isCancel(value)) return CANCELLED;
+  const report = await storeToken(apiUrl, value);
+  prompts.log.success(`Token recorded in ${report.path}`);
+  return value;
+}
+async function chooseEnvironment(prompts, client) {
+  const { projects } = await client.projects.list();
+  const all = projects.flatMap(
+    (project) => project.environments.map((environment) => ({
+      id: environment.id,
+      label: `${project.name} / ${environment.name}`
+    }))
+  );
+  if (all.length === 0) {
+    prompts.log.warn(
+      `No environment on this account. Create a project at ${DEFAULT_API_URL}, then run \`odoro db:create\`.`
+    );
+    return void 0;
+  }
+  const only = all[0];
+  if (all.length === 1 && only !== void 0) {
+    prompts.log.info(`Environment: ${only.label}`);
+    return only;
+  }
+  const picked = await prompts.select({
+    message: "Environment",
+    options: all.map((entry) => ({ value: entry.id, label: entry.label }))
+  });
+  if (prompts.isCancel(picked)) return CANCELLED;
+  return all.find((entry) => entry.id === picked);
+}
+async function chooseRegion(prompts, client) {
+  const { regions } = await client.regions.list();
+  if (regions.length === 0) return void 0;
+  const preferred = regions.includes("eu-central-1") ? "eu-central-1" : regions[0];
+  const picked = await prompts.select({
+    message: "Region",
+    initialValue: preferred,
+    options: regions.map((region) => ({ value: region, label: region }))
+  });
+  if (prompts.isCancel(picked)) return CANCELLED;
+  return picked;
+}
+async function provision(input) {
+  const abort = new AbortController();
+  const onInterrupt = () => abort.abort();
+  process.once("SIGINT", onInterrupt);
+  try {
+    const finished = await input.client.databases.createAndWait(
+      {
+        idempotencyKey: idempotencyKey(),
+        environmentId: input.environmentId,
+        ...input.name === void 0 ? {} : { name: input.name },
+        ...input.region === void 0 ? {} : { region: input.region }
+      },
+      { signal: abort.signal }
+    );
+    if (finished.state !== "succeeded") {
+      return {
+        ok: false,
+        reason: finished.error ?? `The operation ended in state "${finished.state}". \`odoro db:status\` will show where it stands.`
+      };
+    }
+    const databaseId = finished.subject;
+    if (databaseId === void 0) {
+      return {
+        ok: false,
+        reason: "The operation succeeded without naming the database it created. `odoro db:status` will show it."
+      };
+    }
+    const { connectionString } = await input.client.credentials.rotate({ databaseId });
+    return { ok: true, databaseId, connectionString };
+  } finally {
+    process.removeListener("SIGINT", onInterrupt);
+  }
+}
+
+export { DEFAULT_API_URL, PROVIDER_PENDING, SDK_PACKAGE, assertEnvIgnored, cancelled, checkDatabaseUrl, chooseEnvironment, chooseRegion, ensureToken, findToken, loadSdk, provision, storeToken, writeDatabaseUrl };

package/dist/chunk-QOVBLN7A.js

@@ -0,0 +1,241 @@
+#!/usr/bin/env node
+import { guessAliasPaths } from './chunk-T6RLHSCW.js';
+import { existsSync } from 'fs';
+import { readFile, mkdir, writeFile, rm } from 'fs/promises';
+import { join, resolve } from 'path';
+import { pathToFileURL } from 'url';
+import { build } from 'esbuild';
+
+var LINE = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=\s*(.*)$/;
+var REFERENCE = /\$\{([A-Za-z_][A-Za-z0-9_]*)\}|\$([A-Za-z_][A-Za-z0-9_]*)/g;
+function parseEnvDetailed(text) {
+  const values = {};
+  const literals = /* @__PURE__ */ new Set();
+  const lines = text.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    if (line === void 0) continue;
+    if (line.trim() === "" || line.trimStart().startsWith("#")) continue;
+    const found = LINE.exec(line);
+    const key = found?.[1];
+    if (key === void 0) continue;
+    const raw = (found?.[2] ?? "").trim();
+    const quote = raw[0];
+    if (quote !== '"' && quote !== "'" && quote !== "`") {
+      const comment = raw.search(/\s#/);
+      values[key] = comment === -1 ? raw : raw.slice(0, comment).trimEnd();
+      continue;
+    }
+    let body = raw.slice(1);
+    while (body.length === 0 || !body.endsWith(quote)) {
+      const next = lines[index + 1];
+      if (next === void 0) break;
+      index += 1;
+      body = `${body}
+${next}`;
+    }
+    const content = body.endsWith(quote) ? body.slice(0, -1) : body;
+    if (quote === "'") {
+      values[key] = content;
+      literals.add(key);
+      continue;
+    }
+    values[key] = content.replace(/\\n/g, "\n").replace(/\\r/g, "\r").replace(/\\t/g, "	").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+  }
+  return { values, literals };
+}
+function expand(values, environment, literals) {
+  const rendered = {};
+  for (const [key, value] of Object.entries(values)) {
+    if (literals.has(key)) {
+      rendered[key] = value;
+      continue;
+    }
+    rendered[key] = value.replace(REFERENCE, (whole, braced, bare) => {
+      const name = braced ?? bare;
+      if (name === void 0) return whole;
+      return rendered[name] ?? values[name] ?? environment[name] ?? "";
+    });
+  }
+  return rendered;
+}
+function envFilesFor(mode) {
+  return [".env", ".env.local", `.env.${mode}`, `.env.${mode}.local`];
+}
+async function loadEnv(directory, mode, prefix) {
+  const stacked = {};
+  const literals = /* @__PURE__ */ new Set();
+  const files = [];
+  for (const name of envFilesFor(mode)) {
+    const path = join(directory, name);
+    if (!existsSync(path)) continue;
+    files.push(name);
+    const read = parseEnvDetailed(await readFile(path, "utf8"));
+    Object.assign(stacked, read.values);
+    for (const key of Object.keys(read.values)) {
+      if (read.literals.has(key)) literals.add(key);
+      else literals.delete(key);
+    }
+  }
+  const all = expand(stacked, process.env, literals);
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && key in all) all[key] = value;
+  }
+  const client = {};
+  for (const [key, value] of Object.entries(all)) {
+    if (key.startsWith(prefix)) client[key] = value;
+  }
+  for (const [key, value] of Object.entries(process.env)) {
+    if (value !== void 0 && key.startsWith(prefix)) client[key] = value;
+  }
+  return { all, client, files };
+}
+function clientEnv(variables, mode, base) {
+  return {
+    MODE: mode,
+    // `DEV` and `PROD` cannot be deduced from the mode name alone: a `staging`
+    // mode builds as production and must behave like it.
+    DEV: mode === "development",
+    PROD: mode !== "development",
+    BASE_URL: base,
+    ...variables
+  };
+}
+function defineConfig(config) {
+  return config;
+}
+var CONFIG_FILES = ["odoro.config.ts", "odoro.config.js", "odoro.config.mjs"];
+async function importConfigFile(file, root) {
+  const directory = join(root, "node_modules", ".odoro");
+  const output = join(directory, `config.${Date.now().toString(36)}.mjs`);
+  await mkdir(directory, { recursive: true });
+  try {
+    const result = await build({
+      entryPoints: [file],
+      bundle: true,
+      format: "esm",
+      platform: "node",
+      target: "node20",
+      write: false,
+      // Only the project code is inlined; its dependencies stay external,
+      // otherwise the whole node_modules would have to be resolved to read
+      // three lines.
+      packages: "external",
+      // `packages: 'external'` is not enough: a `baseUrl` in the
+      // `tsconfig.json` makes bare imports be looked up from the project root,
+      // where `odoro.json` — the registry file — is found before the package.
+      // The import then stops being a package import, the rule above no longer
+      // applies, and the build fails on a `defineConfig` missing from a
+      // configuration file.
+      //
+      // Naming it explicitly puts it out of reach of that resolution. The list
+      // matters for projects already created: they still carry a `baseUrl`, and
+      // their tsconfig cannot be rewritten.
+      external: ["odoro"]
+    });
+    const code = result.outputFiles[0]?.text;
+    if (code === void 0) {
+      throw new Error(`[odoro] Configuration "${file}" produced no code.`);
+    }
+    await writeFile(output, code, "utf8");
+    const module = await import(pathToFileURL(output).href);
+    if (module.default === void 0) {
+      throw new Error(`[odoro] Configuration "${file}" must have a default export.`);
+    }
+    return module.default;
+  } finally {
+    await rm(output, { force: true });
+  }
+}
+function resolvePrerender(requested, root) {
+  if (requested === void 0 || requested === false) return void 0;
+  const raw = requested === true ? {} : Array.isArray(requested) ? { routes: requested } : requested;
+  return {
+    routes: raw.routes ?? [],
+    entry: resolve(root, raw.entry ?? "src/entry-server.tsx")
+  };
+}
+async function loadConfig(root, overrides = {}, defaultMode = "production") {
+  const absoluteRoot = resolve(root);
+  let file;
+  let loaded = {};
+  for (const candidate of CONFIG_FILES) {
+    const path = join(absoluteRoot, candidate);
+    if (existsSync(path)) {
+      file = path;
+      loaded = await importConfigFile(path, absoluteRoot);
+      break;
+    }
+  }
+  const merged = {
+    ...loaded,
+    ...overrides,
+    server: { ...loaded.server, ...overrides.server },
+    build: { ...loaded.build, ...overrides.build },
+    alias: { ...loaded.alias, ...overrides.alias },
+    define: { ...loaded.define, ...overrides.define }
+  };
+  const base = merged.base ?? "/";
+  const projectRoot = merged.root === void 0 ? absoluteRoot : resolve(absoluteRoot, merged.root);
+  const mode = merged.mode ?? defaultMode;
+  const envPrefix = merged.envPrefix ?? "ODORO_";
+  const envDir = merged.envDir === void 0 ? projectRoot : resolve(projectRoot, merged.envDir);
+  const environment = await loadEnv(envDir, mode, envPrefix);
+  for (const [key, value] of Object.entries(environment.all)) {
+    process.env[key] ??= value;
+  }
+  const https = merged.server?.https;
+  return {
+    root: projectRoot,
+    base: base.endsWith("/") ? base : `${base}/`,
+    publicDir: resolve(projectRoot, merged.publicDir ?? "public"),
+    outDir: resolve(projectRoot, merged.build?.outDir ?? "dist"),
+    server: {
+      port: merged.server?.port ?? 5180,
+      host: merged.server?.host ?? "localhost",
+      proxy: merged.server?.proxy ?? {},
+      https: https === void 0 ? void 0 : { ...https },
+      strictPort: merged.server?.strictPort ?? false,
+      open: merged.server?.open ?? false
+    },
+    build: {
+      outDir: merged.build?.outDir ?? "dist",
+      minify: merged.build?.minify ?? true,
+      sourcemap: merged.build?.sourcemap ?? true,
+      target: merged.build?.target ?? "es2022",
+      // On by default: a stylesheet holding every possible class is a
+      // generation accident, not an intention.
+      prune: merged.build?.prune ?? true,
+      safelist: merged.build?.safelist ?? [],
+      // On by default: the manifest only costs a file of a few lines, and
+      // preloading removes a cascade of requests nobody sees on a local machine
+      // and everybody suffers elsewhere.
+      manifest: merged.build?.manifest ?? true,
+      preload: merged.build?.preload ?? true,
+      prerender: resolvePrerender(merged.build?.prerender, projectRoot)
+    },
+    // The aliases declared in `tsconfig.json` are picked up automatically.
+    // Without that, a project following `odoro init` — which infers its prefix
+    // from the tsconfig — would have to redeclare the same alias here for the
+    // server to resolve it. Two places for the same truth, and an error that
+    // only shows up on the first import.
+    //
+    // The configuration wins: it is what you write to fix a case the inference
+    // does not catch.
+    alias: { ...await guessAliasPaths(projectRoot), ...merged.alias },
+    define: merged.define ?? {},
+    envPrefix,
+    envDir,
+    mode,
+    env: environment.all,
+    envClient: clientEnv(
+      environment.client,
+      mode,
+      base.endsWith("/") ? base : `${base}/`
+    ),
+    plugins: merged.plugins ?? [],
+    configFile: file
+  };
+}
+
+export { clientEnv, defineConfig, loadConfig, loadEnv };