@spacefast/wpcloud-sdk 0.0.2

package/dist/runtime.js

@@ -0,0 +1,486 @@
+import { createHash } from "node:crypto";
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createClient, createConfig } from "./generated/client";
+const WP_CLOUD_REQUEST_TIMEOUT_MS = 30_000;
+const OPTIONAL_PATH_SEGMENT_PATTERN = /\[\/([^\]]+)\]/g;
+const SNAPSHOT_VERSION = 1;
+export class WpCloudRequestError extends Error {
+    status;
+    payload;
+    constructor(status, message, payload) {
+        super(message);
+        this.name = "WpCloudRequestError";
+        this.status = status;
+        this.payload = payload;
+    }
+}
+let defaultProviderName = null;
+export function setDefaultWpCloudProviderName(clientName) {
+    defaultProviderName = clientName?.trim().toLowerCase() || null;
+}
+let fakeFetchOverride = null;
+/**
+ * Test-only seam: route every wp.cloud call to an in-process fake instead of the network. Set in a
+ * suite's `beforeAll`, clear with `null` in `afterAll`. Used when the provider mode is `fake`; with
+ * no override installed, `fake` mode falls back to the shared default fake server. Mirrors the
+ * shape of {@link setDefaultWpCloudProviderName}.
+ */
+export function setWpCloudFakeFetch(fn) {
+    fakeFetchOverride = fn;
+}
+export const createClientConfig = (config) => ({
+    ...config,
+    fetch: wpCloudFetch,
+    bodySerializer: wpCloudFormBodySerializer,
+    headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        ...config?.headers,
+    },
+    requestValidator: prepareWpCloudRequest,
+    responseTransformer: extractData,
+});
+// Build a standalone WP.Cloud client bound to a specific account token (and
+// optional base URL). Use this to make calls under a tenant's own WP.Cloud
+// client instead of the global default; pass the returned client as the
+// `client` option to any generated SDK function, with the matching `{client}`
+// path name.
+export function createWpCloudClient(options) {
+    return createClient(createClientConfig(createConfig({
+        baseUrl: options.baseUrl ?? "https://atomic-api.wordpress.com/api/v1.0/",
+        throwOnError: true,
+        auth: options.auth,
+    })));
+}
+async function wpCloudFetch(input, init) {
+    const response = await wpCloudRawFetch(input, init);
+    return await handleWpCloudResponse(response);
+}
+export async function wpCloudRawFetch(input, init) {
+    const mode = wpCloudProviderMode();
+    if (mode === "fake") {
+        const fake = fakeFetchOverride ?? (await import("./fake/server.js")).defaultFakeFetch;
+        return await fake(input, init);
+    }
+    const snapshot = await buildWpCloudSnapshotRequest(input, init);
+    if (mode === "replay") {
+        return await replayWpCloudSnapshot(snapshot);
+    }
+    const response = await wpCloudNetworkFetch(input, init);
+    if (mode === "record") {
+        return await recordWpCloudSnapshot(snapshot, response);
+    }
+    return response;
+}
+async function wpCloudNetworkFetch(input, init) {
+    const controller = new AbortController();
+    let didTimeout = false;
+    const timeout = setTimeout(() => {
+        didTimeout = true;
+        controller.abort();
+    }, WP_CLOUD_REQUEST_TIMEOUT_MS);
+    const abort = () => controller.abort(init?.signal?.reason);
+    if (init?.signal?.aborted) {
+        abort();
+    }
+    else {
+        init?.signal?.addEventListener("abort", abort, { once: true });
+    }
+    let response;
+    try {
+        response = await fetch(input, { ...init, signal: controller.signal });
+    }
+    catch (error) {
+        if (didTimeout) {
+            throw new WpCloudRequestError(408, "wp_cloud_request_timeout", null);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+        init?.signal?.removeEventListener("abort", abort);
+    }
+    return response;
+}
+let manifestWriteQueue = Promise.resolve();
+function wpCloudProviderMode() {
+    const mode = (process.env.E2E_PROVIDER_MODE ??
+        process.env.WP_CLOUD_PROVIDER_MODE ??
+        "live").toLowerCase();
+    if (mode === "record" || mode === "replay" || mode === "fake") {
+        return mode;
+    }
+    return "live";
+}
+function wpCloudSnapshotDir() {
+    const baseDir = process.env.E2E_WPCLOUD_SNAPSHOT_DIR ?? process.env.WP_CLOUD_SNAPSHOT_DIR;
+    if (!baseDir) {
+        return undefined;
+    }
+    const snapshotCase = snapshotCaseName();
+    return snapshotCase ? path.join(baseDir, snapshotCase) : baseDir;
+}
+function requireWpCloudSnapshotDir() {
+    const dir = wpCloudSnapshotDir();
+    if (!dir) {
+        throw new WpCloudRequestError(599, "wp_cloud_snapshot_dir_required", null);
+    }
+    return dir;
+}
+async function buildWpCloudSnapshotRequest(input, init) {
+    const url = canonicalWpCloudSnapshotUrl(input);
+    const method = (init?.method ?? (input instanceof Request ? input.method : "GET")).toUpperCase();
+    const bodySha256 = sha256(await requestBodyForSnapshot(init?.body));
+    const key = sha256(`${method}\n${url}\n${bodySha256}`);
+    return {
+        key,
+        method,
+        url,
+        bodySha256,
+    };
+}
+function canonicalWpCloudSnapshotUrl(input) {
+    const rawUrl = input instanceof Request ? input.url : String(input);
+    const url = new URL(rawUrl);
+    url.searchParams.sort();
+    return url.toString();
+}
+async function requestBodyForSnapshot(body) {
+    if (body === undefined || body === null) {
+        return "";
+    }
+    if (typeof body === "string") {
+        return body;
+    }
+    if (body instanceof URLSearchParams) {
+        return body.toString();
+    }
+    if (body instanceof Blob) {
+        return await body.text();
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body).toString("base64");
+    }
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength).toString("base64");
+    }
+    return `[${body.constructor.name}]`;
+}
+async function replayWpCloudSnapshot(request) {
+    const snapshot = await readWpCloudSnapshot(request);
+    if (!snapshot) {
+        throw new WpCloudRequestError(599, `wp_cloud_snapshot_missing:${request.key}`, {
+            method: request.method,
+            url: request.url,
+            bodySha256: request.bodySha256,
+        });
+    }
+    assertSnapshotMatches(request, snapshot);
+    return new Response(Buffer.from(snapshot.response.bodyBase64, "base64"), {
+        status: snapshot.response.status,
+        statusText: snapshot.response.statusText,
+        headers: snapshot.response.headers,
+    });
+}
+async function recordWpCloudSnapshot(request, response) {
+    const body = Buffer.from(await response.arrayBuffer());
+    // The live caller gets the untouched body (it may need real values, e.g. an SFTP password to
+    // SSH in during the same run). Only what we PERSIST is scrubbed: create-site and friends return
+    // secrets in their JSON bodies, and these snapshots are committed as fixtures.
+    const storedBody = redactSnapshotResponseBody(body);
+    const bodyBase64 = storedBody.toString("base64");
+    const recordedAt = new Date().toISOString();
+    const headers = redactedResponseHeaders(response.headers);
+    const snapshot = {
+        version: SNAPSHOT_VERSION,
+        recordedAt,
+        ...request,
+        response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            bodyBase64,
+        },
+    };
+    const destination = wpCloudSnapshotWritePath(request);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeJsonAtomic(destination, snapshot);
+    await writeWpCloudSnapshotManifest({
+        ...request,
+        redactedUrl: redactedSnapshotUrl(request.url),
+        recordedAt,
+        response: {
+            status: response.status,
+            statusText: response.statusText,
+            headers,
+            bodySha256: sha256(bodyBase64),
+            bodyBytes: storedBody.byteLength,
+        },
+    });
+    return new Response(body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+    });
+}
+/** Keys whose values are secrets WP.Cloud returns in response bodies (create-site, sftp users, db). */
+const SENSITIVE_BODY_KEY = /pass(word)?|secret|private[_-]?key|privatekey|credential|sftp_pass|db_pass|one[_-]?time|onetime|otp|nonce|api[_-]?key|access[_-]?token/i;
+/**
+ * Scrub secrets from a recorded response body before it is written to a committed fixture, while
+ * preserving the JSON SHAPE (keys + types) that the fake provider keys off. Masks values under
+ * sensitive keys; runs the existing text scrub over remaining string leaves and non-JSON bodies.
+ */
+function redactSnapshotResponseBody(body) {
+    if (body.byteLength === 0) {
+        return body;
+    }
+    const text = body.toString("utf8");
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return Buffer.from(redactSensitiveText(text), "utf8");
+    }
+    return Buffer.from(JSON.stringify(maskSecretValues(parsed)), "utf8");
+}
+function maskSecretValues(value) {
+    if (Array.isArray(value)) {
+        return value.map(maskSecretValues);
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [key, child] of Object.entries(value)) {
+            out[key] =
+                SENSITIVE_BODY_KEY.test(key) && (typeof child === "string" || typeof child === "number")
+                    ? "[REDACTED]"
+                    : maskSecretValues(child);
+        }
+        return out;
+    }
+    if (typeof value === "string") {
+        return redactSensitiveText(value);
+    }
+    return value;
+}
+async function writeWpCloudSnapshotManifest(entry) {
+    manifestWriteQueue = manifestWriteQueue.then(async () => {
+        const manifestPath = wpCloudSnapshotManifestPath();
+        const manifest = await readWpCloudSnapshotManifest();
+        const entries = manifest.entries.filter((existing) => existing.key !== entry.key);
+        entries.push(entry);
+        entries.sort((left, right) => `${left.method} ${left.redactedUrl} ${left.bodySha256}`.localeCompare(`${right.method} ${right.redactedUrl} ${right.bodySha256}`));
+        const next = {
+            version: SNAPSHOT_VERSION,
+            case: snapshotCaseName(),
+            entries,
+        };
+        await mkdir(path.dirname(manifestPath), { recursive: true });
+        await writeJsonAtomic(manifestPath, next);
+    });
+    await manifestWriteQueue;
+}
+async function readWpCloudSnapshotManifest() {
+    try {
+        const parsed = JSON.parse(await readFile(wpCloudSnapshotManifestPath(), "utf8"));
+        return {
+            version: SNAPSHOT_VERSION,
+            case: typeof parsed?.case === "string" ? parsed.case : snapshotCaseName(),
+            entries: Array.isArray(parsed?.entries) ? parsed.entries : [],
+        };
+    }
+    catch (error) {
+        if (error && typeof error === "object" && "code" in error && error.code === "ENOENT") {
+            return {
+                version: SNAPSHOT_VERSION,
+                case: snapshotCaseName(),
+                entries: [],
+            };
+        }
+        throw error;
+    }
+}
+async function readWpCloudSnapshot(request) {
+    const results = await Promise.allSettled(wpCloudSnapshotReadPaths(request).map(async (snapshotPath) => JSON.parse(await readFile(snapshotPath, "utf8"))));
+    for (const result of results) {
+        if (result.status === "fulfilled") {
+            return result.value;
+        }
+        const error = result.reason;
+        if (!(error && typeof error === "object" && "code" in error && error.code === "ENOENT")) {
+            throw error;
+        }
+    }
+    return null;
+}
+function wpCloudSnapshotWritePath(request) {
+    return path.join(requireWpCloudSnapshotDir(), `${request.key}.json`);
+}
+function wpCloudSnapshotReadPaths(request) {
+    const dir = requireWpCloudSnapshotDir();
+    const paths = [path.join(dir, `${request.key}.json`)];
+    const baseDir = wpCloudSnapshotBaseDir();
+    if (baseDir && baseDir !== dir) {
+        paths.push(path.join(baseDir, `${request.key}.json`));
+    }
+    return paths;
+}
+function wpCloudSnapshotBaseDir() {
+    return process.env.E2E_WPCLOUD_SNAPSHOT_DIR ?? process.env.WP_CLOUD_SNAPSHOT_DIR;
+}
+function wpCloudSnapshotManifestPath() {
+    return path.join(requireWpCloudSnapshotDir(), "_manifest.json");
+}
+function snapshotCaseName() {
+    return sanitizeSnapshotCase(process.env.E2E_WPCLOUD_SNAPSHOT_CASE ?? process.env.WP_CLOUD_SNAPSHOT_CASE ?? "");
+}
+function sanitizeSnapshotCase(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replaceAll(/[^a-z0-9._-]+/g, "-")
+        .replaceAll(/^-+|-+$/g, "");
+}
+function redactedSnapshotUrl(value) {
+    const url = new URL(value);
+    for (const [name, current] of Array.from(url.searchParams.entries())) {
+        if (/token|secret|key|password|private|certificate|auth|cookie/i.test(name)) {
+            url.searchParams.set(name, "[REDACTED]");
+        }
+        else {
+            url.searchParams.set(name, redactSensitiveText(current));
+        }
+    }
+    return url.toString();
+}
+async function writeJsonAtomic(destination, value) {
+    const tempPath = `${destination}.${process.pid}.${Date.now()}.${Math.random()
+        .toString(16)
+        .slice(2)}.tmp`;
+    await writeFile(tempPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+    await rename(tempPath, destination);
+}
+function assertSnapshotMatches(request, snapshot) {
+    if (snapshot.version !== SNAPSHOT_VERSION ||
+        snapshot.method !== request.method ||
+        snapshot.url !== request.url ||
+        snapshot.bodySha256 !== request.bodySha256) {
+        throw new WpCloudRequestError(599, `wp_cloud_snapshot_mismatch:${request.key}`, {
+            method: request.method,
+            url: request.url,
+            bodySha256: request.bodySha256,
+        });
+    }
+}
+function redactedResponseHeaders(headers) {
+    const out = {};
+    for (const [name, value] of headers) {
+        const lowerName = name.toLowerCase();
+        if (lowerName === "set-cookie" || lowerName === "authorization" || lowerName === "auth") {
+            continue;
+        }
+        out[lowerName] = redactSensitiveText(value);
+    }
+    return out;
+}
+function redactSensitiveText(value) {
+    return value
+        .replace(/Bearer\s+[A-Za-z0-9._~+/-]+=*/gi, "Bearer [REDACTED]")
+        .replace(/Auth[=:]\s*[A-Za-z0-9._~+/-]+=*/gi, "Auth=[REDACTED]")
+        .replace(/token[=:]\s*["']?[A-Za-z0-9._~+/-]+=*["']?/gi, "token=[REDACTED]");
+}
+function sha256(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+async function handleWpCloudResponse(response) {
+    if (response.ok) {
+        return response;
+    }
+    const payload = await readErrorPayload(response);
+    const message = payload &&
+        typeof payload === "object" &&
+        "message" in payload &&
+        typeof payload.message === "string"
+        ? payload.message
+        : `wp_cloud_request_failed:${response.status}`;
+    throw new WpCloudRequestError(response.status, message, payload);
+}
+async function readErrorPayload(response) {
+    const text = await response.text();
+    if (!text) {
+        return null;
+    }
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
+}
+const ENVELOPE_DATA_KEYS = ["data", "datacenters", "versions"];
+async function extractData(value) {
+    if (value && typeof value === "object") {
+        if ("response_ticket_id" in value || "job_id" in value) {
+            return value;
+        }
+        for (const key of ENVELOPE_DATA_KEYS) {
+            if (key in value)
+                return value[key];
+        }
+    }
+    return value;
+}
+function wpCloudFormBodySerializer(body) {
+    const encodedForm = new URLSearchParams();
+    const append = (key, value) => {
+        if (value === undefined || value === null) {
+            return;
+        }
+        if (Array.isArray(value)) {
+            for (const [index, item] of value.entries()) {
+                append(item && typeof item === "object" && !Array.isArray(item)
+                    ? `${key}[${index}]`
+                    : `${key}[]`, item);
+            }
+            return;
+        }
+        if (typeof value === "object") {
+            for (const [childKey, childValue] of Object.entries(value)) {
+                append(`${key}[${childKey}]`, childValue);
+            }
+            return;
+        }
+        encodedForm.append(key, String(value));
+    };
+    for (const [key, value] of Object.entries(body)) {
+        append(key, value);
+    }
+    return encodedForm.toString();
+}
+async function prepareWpCloudRequest(options) {
+    if (!options || typeof options !== "object") {
+        return;
+    }
+    const request = options;
+    if (request.headers?.get("Content-Type")?.startsWith("application/x-www-form-urlencoded")) {
+        request.bodySerializer = wpCloudFormBodySerializer;
+    }
+    if (typeof request.url !== "string") {
+        return;
+    }
+    request.path ??= {};
+    if (defaultProviderName &&
+        request.url.includes("{client}") &&
+        request.path.client === undefined) {
+        request.path.client = defaultProviderName;
+    }
+    if (defaultProviderName &&
+        request.url.includes("{service}") &&
+        request.path.service === undefined) {
+        request.path.service = defaultProviderName;
+    }
+    request.url = request.url.replace(OPTIONAL_PATH_SEGMENT_PATTERN, (_segment, name) => {
+        const value = request.path?.[name];
+        return value === undefined || value === null ? "" : `/${encodeURIComponent(String(value))}`;
+    });
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@spacefast/wpcloud-sdk",
+  "version": "0.0.2",
+  "description": "Generated TypeScript client for the WP.Cloud API.",
+  "type": "module",
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "bun": "^1.3.11",
+    "node": ">=20"
+  },
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    "./generated/*": {
+      "types": "./dist/generated/*.d.ts",
+      "import": "./dist/generated/*.js",
+      "default": "./dist/generated/*.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime.d.ts",
+      "import": "./dist/runtime.js",
+      "default": "./dist/runtime.js"
+    },
+    "./fake": {
+      "types": "./dist/fake/index.d.ts",
+      "import": "./dist/fake/index.js",
+      "default": "./dist/fake/index.js"
+    }
+  },
+  "dependencies": {
+    "@hey-api/client-fetch": "0.13.1"
+  }
+}