@getquick/site 0.0.0-stage → 0.1.1

package/src/ops/providers/ploi.mjs

@@ -0,0 +1,159 @@
+import { requestJson } from "./http.mjs";
+import { VERSION } from "../../version.mjs";
+
+const API_BASE_URL = "https://ploi.io/api";
+const MAX_PAGES = 100;
+
+export function createPloiClient(options) {
+  const token = required(options.token, "PLOI_API_TOKEN");
+  const fetchImplementation = options.fetchImplementation;
+
+  async function request(path, options = {}) {
+    const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+    return requestJson(withQuery(toApiUrl(path), options.query), {
+      fetchImplementation,
+      method: options.method,
+      body,
+      acceptedStatuses: options.acceptedStatuses,
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/json",
+        "User-Agent": `getquick-site/${VERSION}`,
+        ...(body === undefined && (!options.method || options.method === "GET")
+          ? {}
+          : { "Content-Type": "application/json" }),
+      },
+      errorMessage(response, payload) {
+        return payload.message || `Ploi request failed with HTTP ${response.status}.`;
+      },
+    });
+  }
+
+  async function list(path, options = {}) {
+    const items = [];
+    const visited = new Set();
+    let next = withQuery(toApiUrl(path), options.query);
+
+    while (next) {
+      if (visited.size >= (options.maxPages || MAX_PAGES)) {
+        throw new Error(`Ploi pagination exceeded ${options.maxPages || MAX_PAGES} pages.`);
+      }
+      if (visited.has(next)) throw new Error("Ploi pagination returned a repeated URL.");
+      visited.add(next);
+
+      const payload = await request(next);
+      if (!Array.isArray(payload.data)) {
+        throw new Error("Ploi paginated response did not contain a data array.");
+      }
+      items.push(...payload.data);
+      next = payload.links?.next || payload.meta?.next_page_url || null;
+      if (next) next = toApiUrl(next);
+    }
+
+    return items;
+  }
+
+  function prepareEndpoint(endpoint, options = {}) {
+    const path = fillPath(endpoint.path, options.pathParameters);
+    return {
+      method: endpoint.method,
+      url: withQuery(toApiUrl(path), options.query),
+      body: options.body,
+    };
+  }
+
+  return {
+    prepareEndpoint,
+    async executeEndpoint(endpoint, options = {}) {
+      const prepared = prepareEndpoint(endpoint, options);
+      if (options.paginate) {
+        if (endpoint.method !== "GET") {
+          throw new Error("Only GET operations can be paginated.");
+        }
+        return list(prepared.url, { maxPages: options.maxPages });
+      }
+      return request(prepared.url, {
+        method: prepared.method,
+        body: prepared.body,
+        acceptedStatuses: endpoint.acceptedStatuses,
+      });
+    },
+    async listServers() {
+      return list("/servers");
+    },
+    async getServer(serverId) {
+      return unwrap(await request(`/servers/${encodeURIComponent(serverId)}`));
+    },
+    async listSites(serverId) {
+      return list(`/servers/${encodeURIComponent(serverId)}/sites`);
+    },
+    async getSite(serverId, siteId) {
+      return unwrap(
+        await request(
+          `/servers/${encodeURIComponent(serverId)}/sites/${encodeURIComponent(siteId)}`,
+        ),
+      );
+    },
+  };
+}
+
+function fillPath(template, values = {}) {
+  const placeholders = [...template.matchAll(/\{([^}]+)\}/g)].map((match) => match[1]);
+  const unused = new Set(Object.keys(values));
+  let path = template;
+
+  for (const name of placeholders) {
+    const value = values[name];
+    if (value === undefined || value === null || String(value).trim() === "") {
+      throw new Error(`Ploi API operation requires --path ${name}=<value>.`);
+    }
+    unused.delete(name);
+    path = path.replaceAll(`{${name}}`, encodeURIComponent(String(value)));
+  }
+
+  if (unused.size > 0) {
+    throw new Error(
+      `Unknown path parameter${unused.size === 1 ? "" : "s"}: ${[...unused].join(", ")}.`,
+    );
+  }
+  return path;
+}
+
+function withQuery(url, query = {}) {
+  const result = new URL(url);
+  for (const [name, value] of Object.entries(query)) {
+    const values = Array.isArray(value) ? value : [value];
+    for (const entry of values) {
+      if (entry !== undefined && entry !== null) {
+        result.searchParams.append(name, String(entry));
+      }
+    }
+  }
+  return result.href;
+}
+
+function toApiUrl(path) {
+  let url = /^https?:\/\//.test(path)
+    ? new URL(path)
+    : path.startsWith("/api/")
+      ? new URL(path, new URL(API_BASE_URL).origin)
+      : new URL(`${API_BASE_URL}/${path.replace(/^\/+/, "")}`);
+
+  if (url.protocol === "http:" && url.hostname === "ploi.io") {
+    url = new URL(url.href);
+    url.protocol = "https:";
+  }
+  if (url.origin !== new URL(API_BASE_URL).origin || !url.pathname.startsWith("/api/")) {
+    throw new Error("Ploi returned an unexpected URL outside its API.");
+  }
+  return url.href;
+}
+
+function unwrap(payload) {
+  return payload.data ?? payload;
+}
+
+function required(value, environmentName) {
+  if (!value?.trim()) throw new Error(`${environmentName} is required.`);
+  return value.trim();
+}

package/src/ops/ui.mjs

@@ -0,0 +1,84 @@
+import {
+  autocomplete,
+  cancel,
+  confirm,
+  intro,
+  isCancel,
+  outro,
+  select,
+  spinner,
+} from "@clack/prompts";
+
+export async function chooseCommand(endpoints) {
+  intro("gq operations");
+  const command = await select({
+    message: "What would you like to inspect?",
+    options: [
+      { value: "context", label: "Project context" },
+      { value: "servers", label: "Ploi servers" },
+      { value: "sites", label: "Ploi sites" },
+      { value: "ploi-api", label: "Browse the Ploi API" },
+      { value: "accounts", label: "Cloudflare accounts" },
+      { value: "zones", label: "Cloudflare zones" },
+      { value: "dns", label: "Cloudflare DNS records" },
+    ],
+  });
+  if (isCancel(command)) return cancelled();
+
+  if (command === "ploi-api") {
+    const operation = await autocomplete({
+      message: "Choose a Ploi operation",
+      placeholder: "Search 225 operations…",
+      maxItems: 10,
+      options: endpoints.map((endpoint) => ({
+        value: endpoint.id,
+        label: endpoint.id,
+        hint: `${endpoint.method} ${endpoint.path}`,
+      })),
+    });
+    if (isCancel(operation)) return cancelled();
+    outro("Operation selected");
+    return ["ploi", "api", "describe", operation, "--json"];
+  }
+
+  outro("Running command");
+  return {
+    context: ["context", "show"],
+    servers: ["ploi", "servers", "list"],
+    sites: ["ploi", "sites", "list"],
+    accounts: ["cloudflare", "accounts", "list"],
+    zones: ["cloudflare", "zones", "list"],
+    dns: ["cloudflare", "dns", "list"],
+  }[command];
+}
+
+export async function confirmMutation({ operation, method, url }) {
+  const answer = await confirm({
+    message: `${method} ${url}\nRun ${operation}?`,
+    initialValue: false,
+  });
+  if (isCancel(answer) || !answer) {
+    cancel("Operation cancelled. No request was sent.");
+    return false;
+  }
+  return true;
+}
+
+export async function withSpinner(message, callback, enabled) {
+  if (!enabled) return callback();
+  const progress = spinner();
+  progress.start(message);
+  try {
+    const result = await callback();
+    progress.stop("Done");
+    return result;
+  } catch (error) {
+    progress.error("Failed");
+    throw error;
+  }
+}
+
+function cancelled() {
+  cancel("Operation cancelled.");
+  return null;
+}

package/src/run.mjs

@@ -0,0 +1,45 @@
+import { log } from "@clack/prompts";
+import { runCli } from "./ops/cli.mjs";
+
+// The whole CLI behind one in-process call: every provider request goes
+// through `fetch`, every child process through `exec`, and every value a
+// command needs from its surroundings comes from `cwd` and `env`; no command
+// reads the process's own environment or directory. bin/gq.mjs is the only
+// caller that wires in the real ones. Resolves to the process exit code.
+export async function run(
+  argv,
+  {
+    cwd,
+    env = {},
+    fetch = unavailable("fetch"),
+    exec = unavailable("exec"),
+    stdout,
+    stderr,
+    interactive = false,
+  } = {},
+) {
+  if (typeof cwd !== "string" || cwd === "") throw new TypeError("run() requires a cwd.");
+  if (typeof stdout?.write !== "function" || typeof stderr?.write !== "function") {
+    throw new TypeError("run() requires stdout and stderr streams.");
+  }
+  const io = {
+    out: (line) => stdout.write(`${line}\n`),
+    err: (line) => stderr.write(`${line}\n`),
+  };
+
+  try {
+    await runCli(argv, { cwd, env, fetch, exec, io, interactive });
+    return 0;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (interactive) log.error(message);
+    else io.err(`gq: ${message}`);
+    return 1;
+  }
+}
+
+function unavailable(name) {
+  return () => {
+    throw new Error(`run() was called without ${name}, and this command needs it.`);
+  };
+}

package/src/version.mjs

@@ -0,0 +1,3 @@
+import packageJson from "../package.json" with { type: "json" };
+
+export const VERSION = packageJson.version;