@andocorp/cli 0.1.3 → 0.3.0

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");
+}

package/dist/api-operations.js

@@ -0,0 +1,344 @@
+import { ANDO_PUBLIC_API_OPERATIONS, ANDO_PUBLIC_API_SPEC, resolveAndoPublicApiBaseUrl, } from "@andocorp/sdk";
+import { hasFlag } from "./args.js";
+import { printJson } from "./output.js";
+const OPERATION_ENTRIES = Object.entries(ANDO_PUBLIC_API_OPERATIONS).map(([id, operation]) => ({
+    id: id,
+    operation,
+}));
+function normalizeApiPath(path) {
+    const withLeadingSlash = path.startsWith("/") ? path : `/${path}`;
+    const withoutTrailingSlash = withLeadingSlash.length > 1 ? withLeadingSlash.replace(/\/+$/, "") : "/";
+    if (withoutTrailingSlash.startsWith("/api/v1/")) {
+        return withoutTrailingSlash.slice("/api/v1".length);
+    }
+    if (withoutTrailingSlash === "/api/v1") {
+        return "/";
+    }
+    if (withoutTrailingSlash.startsWith("/v1/")) {
+        return withoutTrailingSlash.slice("/v1".length);
+    }
+    return withoutTrailingSlash === "/v1" ? "/" : withoutTrailingSlash;
+}
+function parseApiPath(rawPath) {
+    try {
+        const url = new URL(rawPath);
+        return {
+            path: normalizeApiPath(url.pathname),
+            queryString: url.search.startsWith("?") ? url.search.slice(1) : url.search,
+        };
+    }
+    catch {
+        const queryIndex = rawPath.indexOf("?");
+        if (queryIndex < 0) {
+            return {
+                path: normalizeApiPath(rawPath),
+                queryString: "",
+            };
+        }
+        return {
+            path: normalizeApiPath(rawPath.slice(0, queryIndex)),
+            queryString: rawPath.slice(queryIndex + 1),
+        };
+    }
+}
+function normalizeTemplate(path) {
+    return normalizeApiPath(path).replace(/:([A-Za-z0-9_]+)/g, "{$1}");
+}
+function splitRawQuery(rawTarget) {
+    const queryIndex = rawTarget.indexOf("?");
+    if (queryIndex < 0) {
+        return {
+            path: rawTarget,
+            queryString: "",
+        };
+    }
+    return {
+        path: rawTarget.slice(0, queryIndex),
+        queryString: rawTarget.slice(queryIndex + 1),
+    };
+}
+function operationPublicPath(operation) {
+    return operation.publicPath;
+}
+function matchTemplatePath(template, actualPath) {
+    const templateSegments = normalizeTemplate(template).split("/").filter(Boolean);
+    const actualSegments = normalizeApiPath(actualPath).split("/").filter(Boolean);
+    if (templateSegments.length !== actualSegments.length) {
+        return null;
+    }
+    const parameters = {};
+    for (let index = 0; index < templateSegments.length; index += 1) {
+        const templateSegment = templateSegments[index];
+        const actualSegment = actualSegments[index];
+        if (templateSegment == null || actualSegment == null) {
+            return null;
+        }
+        const parameterMatch = templateSegment.match(/^\{([A-Za-z0-9_]+)\}$/);
+        if (parameterMatch != null) {
+            const parameterName = parameterMatch[1];
+            if (parameterName == null) {
+                return null;
+            }
+            parameters[parameterName] = decodeURIComponent(actualSegment);
+            continue;
+        }
+        if (templateSegment !== actualSegment) {
+            return null;
+        }
+    }
+    return parameters;
+}
+function findOperationIdMatches(rawTarget) {
+    const parsedTarget = splitRawQuery(rawTarget);
+    if (parsedTarget.path.includes("/") || parsedTarget.path.includes(":")) {
+        return [];
+    }
+    const entry = OPERATION_ENTRIES.find((operationEntry) => operationEntry.id === parsedTarget.path);
+    if (entry == null) {
+        return [];
+    }
+    return [
+        {
+            ...entry,
+            concretePath: normalizeApiPath(entry.operation.path),
+            pathParameters: {},
+            queryString: parsedTarget.queryString,
+        },
+    ];
+}
+function findOperationMatches(rawPath) {
+    const operationIdMatches = findOperationIdMatches(rawPath);
+    if (operationIdMatches.length > 0) {
+        return operationIdMatches;
+    }
+    const parsedPath = parseApiPath(rawPath);
+    const matches = [];
+    for (const entry of OPERATION_ENTRIES) {
+        const templateMatch = matchTemplatePath(entry.operation.path, parsedPath.path);
+        if (templateMatch != null) {
+            matches.push({
+                ...entry,
+                concretePath: parsedPath.path,
+                pathParameters: templateMatch,
+                queryString: parsedPath.queryString,
+            });
+            continue;
+        }
+        if (normalizeTemplate(operationPublicPath(entry.operation)) ===
+            normalizeTemplate(parsedPath.path)) {
+            matches.push({
+                ...entry,
+                concretePath: normalizeApiPath(entry.operation.path),
+                pathParameters: {},
+                queryString: parsedPath.queryString,
+            });
+        }
+    }
+    return matches;
+}
+function formatOperationPath(template, pathParameters) {
+    let path = normalizeApiPath(template);
+    for (const [name, value] of Object.entries(pathParameters)) {
+        path = path.replace(`{${name}}`, encodeURIComponent(value));
+    }
+    return path;
+}
+export function matchingOperations(rawPath) {
+    const matches = findOperationMatches(rawPath);
+    if (matches.length === 0) {
+        throw new Error(`No public API operation matches ${rawPath}.`);
+    }
+    return matches;
+}
+export function selectOperation(rawPath, matches, method) {
+    const methodMatches = matches.filter((match) => match.operation.method === method);
+    if (methodMatches.length === 1) {
+        return methodMatches[0];
+    }
+    if (methodMatches.length > 1) {
+        throw new Error(`Multiple ${method} operations match ${rawPath}.`);
+    }
+    const availableMethods = [
+        ...new Set(matches.map((match) => match.operation.method)),
+    ].join(", ");
+    throw new Error(availableMethods === ""
+        ? `No public API operation matches ${rawPath}.`
+        : `No ${method} operation matches ${rawPath}. Available methods: ${availableMethods}.`);
+}
+export function operationCanUseConcretePath(match) {
+    for (const parameterName of match.operation.pathParameters) {
+        const value = match.pathParameters[parameterName];
+        if (value == null ||
+            value === `{${parameterName}}` ||
+            value === `:${parameterName}`) {
+            return false;
+        }
+    }
+    return true;
+}
+function isPathParameterAssignment(match, assignment) {
+    return new Set(match.operation.pathParameters).has(assignment.fieldPath);
+}
+function pathParameterValue(assignment) {
+    const value = assignment.value;
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return String(value);
+    }
+    throw new Error(`Path parameter ${assignment.fieldPath} must be a scalar value.`);
+}
+export function applyPathParameterAssignments(params) {
+    if (operationCanUseConcretePath(params.match)) {
+        return {
+            bodyAssignments: params.bodyAssignments,
+            match: params.match,
+        };
+    }
+    const bodyAssignments = [];
+    const pathParameters = { ...params.match.pathParameters };
+    for (const assignment of params.bodyAssignments) {
+        if (isPathParameterAssignment(params.match, assignment)) {
+            pathParameters[assignment.fieldPath] = pathParameterValue(assignment);
+            continue;
+        }
+        bodyAssignments.push(assignment);
+    }
+    return {
+        bodyAssignments,
+        match: {
+            ...params.match,
+            concretePath: formatOperationPath(params.match.operation.path, pathParameters),
+            pathParameters,
+        },
+    };
+}
+function formatAllowed(values) {
+    return values.length === 0 ? "none" : values.join(", ");
+}
+function assertAllowedQueryParameters(match, queryNames) {
+    const allowed = new Set(match.operation.queryParameters);
+    for (const name of queryNames) {
+        if (!allowed.has(name)) {
+            throw new Error(`Unknown query parameter "${name}" for ${match.id}. Supported query parameters: ${formatAllowed(match.operation.queryParameters)}.`);
+        }
+    }
+}
+function assertAllowedHeaderParameters(match, headerNames) {
+    const allowed = new Set(match.operation.headerParameters.map((headerName) => headerName.toLowerCase()));
+    for (const name of headerNames) {
+        if (!allowed.has(name.toLowerCase())) {
+            throw new Error(`Unknown header "${name}" for ${match.id}. Supported headers: ${formatAllowed(match.operation.headerParameters)}.`);
+        }
+    }
+}
+export function validateOperationInputs(params) {
+    if (params.body !== undefined && params.match.operation.requestBodySchema == null) {
+        throw new Error(`${params.match.id} does not accept a request body.`);
+    }
+    const pathQuery = new URLSearchParams(params.match.queryString);
+    assertAllowedQueryParameters(params.match, [
+        ...pathQuery.keys(),
+        ...params.inlineQuery.keys(),
+    ]);
+    assertAllowedHeaderParameters(params.match, Object.keys(params.headers));
+}
+export function selectedMatches(matches, requestedMethod) {
+    if (requestedMethod == null) {
+        return matches;
+    }
+    const methodMatches = matches.filter((match) => match.operation.method === requestedMethod);
+    return methodMatches.length > 0 ? methodMatches : matches;
+}
+function applySearchParams(url, params) {
+    for (const [name, value] of params) {
+        url.searchParams.append(name, value);
+    }
+}
+export function buildOperationUrl(params) {
+    const baseUrl = resolveAndoPublicApiBaseUrl(params.apiHost);
+    const url = new URL(`${baseUrl}${params.concretePath}`);
+    applySearchParams(url, new URLSearchParams(params.pathQueryString));
+    applySearchParams(url, params.inlineQuery);
+    return url.toString();
+}
+export function listOperations(parsedArgs) {
+    if (hasFlag(parsedArgs, "json")) {
+        printJson(OPERATION_ENTRIES.map(({ id, operation }) => ({
+            id,
+            method: operation.method,
+            path: operation.path,
+            public_path: operationPublicPath(operation),
+            ga_status: operation.gaStatus,
+            public_api_disposition: operation.publicApiDisposition,
+            request_body_schema: operation.requestBodySchema,
+            response_schema: operation.responseSchema,
+        })));
+        return;
+    }
+    process.stdout.write(OPERATION_ENTRIES.map(({ id, operation }) => [
+        operation.method,
+        operationPublicPath(operation),
+        id,
+        operation.publicApiDisposition,
+    ].join("\t")).join("\n") + "\n");
+}
+export function printEndpointHelp(rawPath, matches) {
+    const lines = [`ando api ${rawPath}`, "", "Operations:"];
+    for (const { id, operation } of matches) {
+        lines.push(`  ${operation.method.padEnd(6)} ${operationPublicPath(operation).padEnd(44)} ${id}`);
+        lines.push(`         status: ${operation.publicApiDisposition}`);
+        lines.push(`         path params: ${formatAllowed(operation.pathParameters)}`);
+        lines.push(`         query params: ${formatAllowed(operation.queryParameters)}`);
+        lines.push(`         headers: ${formatAllowed(operation.headerParameters)}`);
+        lines.push(`         request body: ${operation.requestBodySchema ?? "none"}`);
+        lines.push(`         response: ${operation.responseSchema}`);
+    }
+    lines.push("");
+    lines.push("Syntax:");
+    lines.push("  name==value       query string parameter");
+    lines.push("  Header:Value      declared request header");
+    lines.push("  field=value       JSON body string field");
+    lines.push("  field:=json       JSON body field parsed as JSON");
+    lines.push("  --data <json|->   complete JSON request body or stdin");
+    lines.push("");
+    lines.push("Targets can be public paths or operation IDs from `ando api ls`.");
+    lines.push("For operation ID targets, supply required path parameters as name=value.");
+    lines.push("");
+    lines.push(`Spec: ando api ${rawPath} --spec`);
+    process.stdout.write(`${lines.join("\n")}\n`);
+}
+export function buildOperationSpec(matches) {
+    const paths = {};
+    for (const { id, operation } of matches) {
+        const path = operation.path;
+        const method = operation.method.toLowerCase();
+        const pathItem = paths[path] ?? {};
+        pathItem[method] = {
+            operationId: id,
+            routeId: operation.routeId,
+            gaStatus: operation.gaStatus,
+            publicApiDisposition: operation.publicApiDisposition,
+            compatibilityMode: operation.compatibilityMode,
+            migrationTarget: operation.migrationTarget,
+            rateLimitPolicy: operation.rateLimitPolicy,
+            selectedRuntime: operation.selectedRuntime,
+            targetRuntime: operation.targetRuntime,
+            pathParameters: operation.pathParameters,
+            queryParameters: operation.queryParameters,
+            headerParameters: operation.headerParameters,
+            requestBodySchema: operation.requestBodySchema,
+            responseSchema: operation.responseSchema,
+        };
+        paths[path] = pathItem;
+    }
+    return {
+        openapi: ANDO_PUBLIC_API_SPEC.openapi,
+        info: {
+            title: ANDO_PUBLIC_API_SPEC.title,
+            version: ANDO_PUBLIC_API_SPEC.version,
+        },
+        servers: ANDO_PUBLIC_API_SPEC.servers,
+        paths,
+    };
+}

package/dist/args.js

@@ -0,0 +1,71 @@
+function isFlagValue(value) {
+    return value != null && (value === "-" || !value.startsWith("-"));
+}
+function setFlagWithOptionalValue(flags, name, argv, index) {
+    const nextValue = argv[index + 1];
+    if (isFlagValue(nextValue)) {
+        flags.set(name, nextValue);
+        return index + 1;
+    }
+    flags.set(name, true);
+    return index;
+}
+function parseLongFlag(flags, argv, index) {
+    const value = argv[index] ?? "";
+    const flag = value.slice(2);
+    const separatorIndex = flag.indexOf("=");
+    if (separatorIndex >= 0) {
+        flags.set(flag.slice(0, separatorIndex), flag.slice(separatorIndex + 1));
+        return index;
+    }
+    return setFlagWithOptionalValue(flags, flag, argv, index);
+}
+function parseShortFlag(flags, argv, index) {
+    const value = argv[index] ?? "";
+    const shortFlags = value.slice(1);
+    if (shortFlags.length <= 1) {
+        return setFlagWithOptionalValue(flags, shortFlags, argv, index);
+    }
+    for (const shortFlag of shortFlags.slice(0, -1)) {
+        flags.set(shortFlag, true);
+    }
+    return setFlagWithOptionalValue(flags, shortFlags.at(-1) ?? "", argv, index);
+}
+export function parseArgs(argv) {
+    const flags = new Map();
+    const positionals = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const value = argv[index];
+        if (value == null) {
+            continue;
+        }
+        if (!value.startsWith("-")) {
+            positionals.push(value);
+            continue;
+        }
+        if (value.startsWith("--")) {
+            index = parseLongFlag(flags, argv, index);
+            continue;
+        }
+        index = parseShortFlag(flags, argv, index);
+    }
+    return {
+        flags,
+        positionals,
+    };
+}
+export function getStringFlag(parsedArgs, longName, shortName) {
+    const longValue = parsedArgs.flags.get(longName);
+    if (typeof longValue === "string") {
+        return longValue;
+    }
+    if (shortName == null) {
+        return undefined;
+    }
+    const shortValue = parsedArgs.flags.get(shortName);
+    return typeof shortValue === "string" ? shortValue : undefined;
+}
+export function hasFlag(parsedArgs, longName, shortName) {
+    return (parsedArgs.flags.has(longName) ||
+        (shortName != null && parsedArgs.flags.has(shortName)));
+}