@andocorp/cli 0.2.0 → 0.3.0

package/dist/api-command.js

@@ -0,0 +1,187 @@
+import { requestAndoPublicApi, } from "@andocorp/sdk";
+import { buildBodyFromAssignments, defaultReadStdin, flagValue, parseInlineInputs, readDataFlagBody, } from "./api-inputs.js";
+import { applyPathParameterAssignments, buildOperationSpec, buildOperationUrl, listOperations, matchingOperations, operationCanUseConcretePath, printEndpointHelp, selectOperation, selectedMatches, validateOperationInputs, } from "./api-operations.js";
+import { hasFlag } from "./args.js";
+import { printJson } from "./output.js";
+import { getConfiguredApiHost } from "./session.js";
+import { DEFAULT_CLI_REQUEST_TIMEOUT_MS } from "./timeouts.js";
+function getRequestedMethod(parsedArgs) {
+    return flagValue(parsedArgs, "method", "X")?.toUpperCase();
+}
+function printApiCommandHelp() {
+    process.stdout.write(`
+ando api
+
+Usage:
+  ando api ls [--json]
+  ando api <path|operation-id> [--method|-X <method>] [--data|-d <json|-] [name==value] [Header:Value] [field=value] [field:=json]
+  ando api <path|operation-id> --help
+  ando api <path|operation-id> --spec
+
+Examples:
+  ando api ls
+  ando api searchMessages q==incident mode==semantic
+  ando api getMember memberId=<member-id>
+  ando api /v1/search/messages q==incident mode==semantic
+  ando api /v1/conversations/<conversation-id>/messages markdown_content="hello" Idempotency-Key:<key>
+  echo '{"markdown_content":"hello"}' | ando api /v1/conversations/<conversation-id>/messages --data -
+
+Input syntax:
+  name==value       query string parameter
+  Header:Value      declared request header
+  field=value       JSON body string field
+  field:=json       JSON body field parsed as JSON
+  --data <json>     complete JSON request body
+  --data -          read complete JSON request body from stdin
+
+Targets can be public paths or operation IDs from "ando api ls".
+For operation ID targets, supply required path parameters as name=value.
+`.trim() + "\n");
+}
+function formatErrorDetail(value) {
+    return typeof value === "string" ? value : JSON.stringify(value, null, 2);
+}
+function printResponse(response) {
+    if (response.empty) {
+        process.stdout.write(`${response.status} ${response.statusText}\n`);
+        return;
+    }
+    if (typeof response.body === "string") {
+        process.stdout.write(response.body.endsWith("\n") ? response.body : `${response.body}\n`);
+        return;
+    }
+    printJson(response.body);
+}
+function requestBodyFromInputs(params) {
+    if (params.dataBody !== undefined && params.assignmentBody !== undefined) {
+        throw new Error("Use either --data or inline body fields, not both.");
+    }
+    return params.dataBody !== undefined ? params.dataBody : params.assignmentBody;
+}
+function rejectMixedBodySourcesBeforeRead(params) {
+    if (params.inlineBodyFieldCount > 0 && hasFlag(params.parsedArgs, "data", "d")) {
+        throw new Error("Use either --data or inline body fields, not both.");
+    }
+}
+function selectPathParameterMatch(params) {
+    if (params.requestedMethod != null) {
+        return selectOperation(params.rawPath, params.matches, params.requestedMethod);
+    }
+    const match = params.matches[0];
+    if (match == null) {
+        throw new Error(`No public API operation matches ${params.rawPath}.`);
+    }
+    return match;
+}
+function createRawApiTimeoutSignal() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => {
+        controller.abort(new Error(`[ando-cli] api request timed out after ${DEFAULT_CLI_REQUEST_TIMEOUT_MS}ms`));
+    }, DEFAULT_CLI_REQUEST_TIMEOUT_MS);
+    return {
+        signal: controller.signal,
+        clear: () => {
+            clearTimeout(timeout);
+        },
+    };
+}
+async function prepareApiRequest(params) {
+    const inlineInputs = parseInlineInputs(params.parsedArgs.positionals.slice(2));
+    const pathParameterMatch = selectPathParameterMatch({
+        matches: params.matches,
+        rawPath: params.rawPath,
+        requestedMethod: params.requestedMethod,
+    });
+    const pathParameterInputs = applyPathParameterAssignments({
+        bodyAssignments: inlineInputs.bodyAssignments,
+        match: pathParameterMatch,
+    });
+    rejectMixedBodySourcesBeforeRead({
+        parsedArgs: params.parsedArgs,
+        inlineBodyFieldCount: pathParameterInputs.bodyAssignments.length,
+    });
+    const dataBody = await readDataFlagBody({
+        parsedArgs: params.parsedArgs,
+        readStdin: params.readStdin,
+    });
+    const assignmentBody = pathParameterInputs.bodyAssignments.length > 0
+        ? buildBodyFromAssignments(pathParameterInputs.bodyAssignments)
+        : undefined;
+    const body = requestBodyFromInputs({ assignmentBody, dataBody });
+    const method = params.requestedMethod ?? (body === undefined ? "GET" : "POST");
+    const selectedMatch = selectOperation(params.rawPath, params.matches, method);
+    const { match } = applyPathParameterAssignments({
+        bodyAssignments: inlineInputs.bodyAssignments,
+        match: selectedMatch,
+    });
+    if (!operationCanUseConcretePath(match)) {
+        throw new Error(`Supply concrete path values before calling ${match.id}. Use ${match.operation.pathParameters.map((name) => `${name}=<value>`).join(" ")}.`);
+    }
+    validateOperationInputs({
+        body,
+        headers: inlineInputs.headers,
+        inlineQuery: inlineInputs.query,
+        match,
+    });
+    const config = await params.loadConfig();
+    return {
+        apiKey: config.apiKey,
+        body,
+        headers: inlineInputs.headers,
+        method,
+        url: buildOperationUrl({
+            apiHost: getConfiguredApiHost(params.parsedArgs, config.apiHost ?? null),
+            concretePath: match.concretePath,
+            pathQueryString: match.queryString,
+            inlineQuery: inlineInputs.query,
+        }),
+    };
+}
+async function runPreparedRequest(params) {
+    const timeout = createRawApiTimeoutSignal();
+    try {
+        const response = await params.requestApi({
+            ...params.request,
+            signal: params.request.signal ?? timeout.signal,
+        });
+        if (!response.ok) {
+            const detail = response.empty ? "" : `\n${formatErrorDetail(response.body)}`;
+            throw new Error(`Public API request failed: ${response.status} ${response.statusText}${detail}`);
+        }
+        printResponse(response);
+    }
+    finally {
+        timeout.clear();
+    }
+}
+export async function runApiCommand({ parsedArgs, loadConfig, requestApi = requestAndoPublicApi, readStdin = defaultReadStdin, }) {
+    const rawPath = parsedArgs.positionals[1];
+    if (rawPath == null || rawPath === "help") {
+        printApiCommandHelp();
+        return;
+    }
+    if (rawPath === "ls" || rawPath === "list") {
+        listOperations(parsedArgs);
+        return;
+    }
+    const matches = matchingOperations(rawPath);
+    const requestedMethod = getRequestedMethod(parsedArgs);
+    const visibleMatches = selectedMatches(matches, requestedMethod);
+    if (hasFlag(parsedArgs, "help", "h")) {
+        printEndpointHelp(rawPath, visibleMatches);
+        return;
+    }
+    if (hasFlag(parsedArgs, "spec")) {
+        printJson(buildOperationSpec(visibleMatches));
+        return;
+    }
+    const request = await prepareApiRequest({
+        loadConfig,
+        matches,
+        parsedArgs,
+        rawPath,
+        readStdin,
+        requestedMethod,
+    });
+    await runPreparedRequest({ request, requestApi });
+}

package/dist/api-inputs.js

@@ -0,0 +1,223 @@
+import { getStringFlag, hasFlag } from "./args.js";
+const PUSH_SEGMENT = Symbol("push");
+export function flagValue(parsedArgs, longName, shortName) {
+    if (!hasFlag(parsedArgs, longName, shortName)) {
+        return undefined;
+    }
+    const value = getStringFlag(parsedArgs, longName, shortName);
+    if (value == null || value.trim() === "") {
+        throw new Error(shortName == null
+            ? `--${longName} requires a value.`
+            : `--${longName}/-${shortName} requires a value.`);
+    }
+    return value;
+}
+function splitAtDelimiter(value, delimiter, index) {
+    return [value.slice(0, index), value.slice(index + delimiter.length)];
+}
+function findInlineDelimiter(value) {
+    const delimiters = [":=", "==", ":", "="];
+    let selected = null;
+    for (const delimiter of delimiters) {
+        const index = value.indexOf(delimiter);
+        if (index < 0) {
+            continue;
+        }
+        if (selected == null ||
+            index < selected.index ||
+            (index === selected.index && delimiter.length > selected.delimiter.length)) {
+            selected = {
+                delimiter,
+                index,
+            };
+        }
+    }
+    return selected;
+}
+function parseJsonLiteral(rawValue, label) {
+    try {
+        return JSON.parse(rawValue);
+    }
+    catch {
+        throw new Error(`${label} must be valid JSON.`);
+    }
+}
+export function parseInlineInputs(tokens) {
+    const bodyAssignments = [];
+    const headers = {};
+    const query = new URLSearchParams();
+    for (const token of tokens) {
+        const inlineDelimiter = findInlineDelimiter(token);
+        if (inlineDelimiter == null) {
+            throw new Error(`Could not parse API argument "${token}". Use name==value for query, Header:Value for headers, or field=value for JSON body fields.`);
+        }
+        const [name, value] = splitAtDelimiter(token, inlineDelimiter.delimiter, inlineDelimiter.index);
+        if (inlineDelimiter.delimiter === ":=") {
+            bodyAssignments.push({
+                fieldPath: name,
+                value: parseJsonLiteral(value, `${name}:=`),
+            });
+            continue;
+        }
+        if (inlineDelimiter.delimiter === "==") {
+            query.append(name, value);
+            continue;
+        }
+        if (inlineDelimiter.delimiter === ":" && /^[A-Za-z0-9-]+$/.test(name)) {
+            headers[name] = value;
+            continue;
+        }
+        if (inlineDelimiter.delimiter === "=") {
+            bodyAssignments.push({ fieldPath: name, value });
+            continue;
+        }
+        throw new Error(`Could not parse API argument "${token}". Use name==value for query, Header:Value for headers, or field=value for JSON body fields.`);
+    }
+    return {
+        bodyAssignments,
+        headers,
+        query,
+    };
+}
+function parseBodyPath(path) {
+    const segments = [];
+    let current = "";
+    for (let index = 0; index < path.length; index += 1) {
+        const character = path[index];
+        if (character === ".") {
+            if (current !== "") {
+                segments.push(current);
+                current = "";
+            }
+            continue;
+        }
+        if (character === "[") {
+            if (current !== "") {
+                segments.push(current);
+                current = "";
+            }
+            const closingIndex = path.indexOf("]", index + 1);
+            if (closingIndex < 0) {
+                throw new Error(`Invalid body field path "${path}".`);
+            }
+            const bracketSegment = path.slice(index + 1, closingIndex);
+            if (bracketSegment === "") {
+                segments.push(PUSH_SEGMENT);
+            }
+            else if (/^\d+$/.test(bracketSegment)) {
+                segments.push(Number.parseInt(bracketSegment, 10));
+            }
+            else {
+                segments.push(bracketSegment);
+            }
+            index = closingIndex;
+            continue;
+        }
+        current += character;
+    }
+    if (current !== "") {
+        segments.push(current);
+    }
+    if (segments.length === 0) {
+        throw new Error("Body field path cannot be empty.");
+    }
+    return segments;
+}
+function createPathContainer(nextSegment) {
+    return nextSegment === PUSH_SEGMENT || typeof nextSegment === "number" ? [] : {};
+}
+function isJsonContainer(value) {
+    return typeof value === "object" && value !== null;
+}
+function setArrayBodyPath(params) {
+    if (params.isLast) {
+        if (params.segment === PUSH_SEGMENT) {
+            params.current.push(params.value);
+            return params.current;
+        }
+        params.current[params.segment] = params.value;
+        return params.current;
+    }
+    const container = createPathContainer(params.nextSegment);
+    if (params.segment === PUSH_SEGMENT) {
+        params.current.push(container);
+        return container;
+    }
+    const existing = params.current[params.segment];
+    if (isJsonContainer(existing)) {
+        return existing;
+    }
+    params.current[params.segment] = container;
+    return container;
+}
+function setObjectBodyPath(params) {
+    if (params.isLast) {
+        params.current[params.segment] = params.value;
+        return params.current;
+    }
+    const existing = params.current[params.segment];
+    if (isJsonContainer(existing)) {
+        return existing;
+    }
+    const container = createPathContainer(params.nextSegment);
+    params.current[params.segment] = container;
+    return container;
+}
+function setBodyPath(target, fieldPath, value) {
+    const segments = parseBodyPath(fieldPath);
+    let current = target;
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        const nextSegment = segments[index + 1];
+        const isLast = index === segments.length - 1;
+        if (segment == null) {
+            throw new Error(`Invalid body field path "${fieldPath}".`);
+        }
+        if (Array.isArray(current)) {
+            if (typeof segment === "string") {
+                throw new Error(`Invalid object key in array body field path "${fieldPath}".`);
+            }
+            current = setArrayBodyPath({
+                current,
+                fieldPath,
+                isLast,
+                nextSegment,
+                segment,
+                value,
+            });
+            continue;
+        }
+        if (segment === PUSH_SEGMENT || typeof segment === "number") {
+            throw new Error(`Invalid array segment in body field path "${fieldPath}".`);
+        }
+        current = setObjectBodyPath({
+            current,
+            isLast,
+            nextSegment,
+            segment,
+            value,
+        });
+    }
+}
+export function buildBodyFromAssignments(assignments) {
+    const body = {};
+    for (const assignment of assignments) {
+        setBodyPath(body, assignment.fieldPath, assignment.value);
+    }
+    return body;
+}
+export async function readDataFlagBody(params) {
+    const data = flagValue(params.parsedArgs, "data", "d");
+    if (data == null) {
+        return undefined;
+    }
+    const rawBody = data === "-" ? await params.readStdin() : data;
+    return parseJsonLiteral(rawBody, "--data");
+}
+export async function defaultReadStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+}