poe-code 3.0.285 → 3.0.287

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "3.0.285",
+  "version": "3.0.287",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "type": "module",
   "main": "./dist/index.js",

package/packages/toolcraft-openapi/dist/generate.d.ts

@@ -230,6 +230,9 @@ export type GeneratedPreflightBlock = {
     jsonParamName: string;
     nullParamName?: string;
     resolvedName: string;
+    definition: Extract<GeneratedParamDefinition, {
+        kind: "array";
+    }>;
     required: boolean;
 };
 interface SchemaOptionEntry {

package/packages/toolcraft-openapi/dist/generate.js

@@ -870,6 +870,7 @@ function createArrayParam(options) {
                 jsonParamName,
                 ...(emitsNullHelper ? { nullParamName } : {}),
                 resolvedName,
+                definition: directDefinition,
                 required: !optional
             }
         ],
@@ -1386,11 +1387,13 @@ function createCommandFile(options) {
     const usesMultipartFileInputs = options.bodyMode === "multipart" &&
         options.multipartBinaryFields !== undefined &&
         options.multipartBinaryFields.length > 0;
+    const usesArrayJsonValidation = options.preflightBlocks.some((block) => block.kind === "array");
     const usesBinaryOutput = options.responseMode === "binary";
     const usesRequestShapeVariable = usesMultipartFileInputs || usesBinaryOutput;
     const openApiImports = [
         "requestJson",
         "defineApiCommand",
+        ...(usesArrayJsonValidation ? ["validateArrayJsonHelperValue"] : []),
         ...(usesMultipartFileInputs ? ["prepareMultipartFileInputs"] : []),
         ...(usesBinaryOutput ? ["writeBinaryResponseOutput"] : [])
     ];

package/packages/toolcraft-openapi/dist/http.js

@@ -317,8 +317,57 @@ function decodeBase64Body(body) {
     if (typeof body !== "string") {
         throw new UserError("Base64 request bodies must be strings.");
     }
+    if (!isValidBase64(body)) {
+        throw new UserError("Base64 request bodies must contain valid base64 text.");
+    }
     return Uint8Array.from(Buffer.from(body, "base64")).buffer;
 }
+function isValidBase64(value) {
+    const paddingLength = getBase64PaddingLength(value);
+    if (paddingLength === null) {
+        return false;
+    }
+    const unpaddedLength = value.length - paddingLength;
+    if (unpaddedLength % 4 === 1) {
+        return false;
+    }
+    if (paddingLength > 0 && value.length % 4 !== 0) {
+        return false;
+    }
+    for (let index = 0; index < unpaddedLength; index += 1) {
+        if (!isBase64Character(value[index] ?? "")) {
+            return false;
+        }
+    }
+    const normalized = value.padEnd(value.length + ((4 - (value.length % 4)) % 4), "=");
+    return Buffer.from(value, "base64").toString("base64") === normalized;
+}
+function getBase64PaddingLength(value) {
+    let paddingLength = 0;
+    for (let index = value.length - 1; index >= 0 && value[index] === "="; index -= 1) {
+        paddingLength += 1;
+    }
+    if (paddingLength > 2) {
+        return null;
+    }
+    for (let index = 0; index < value.length - paddingLength; index += 1) {
+        if (value[index] === "=") {
+            return null;
+        }
+    }
+    return paddingLength;
+}
+function isBase64Character(value) {
+    if (value.length !== 1) {
+        return false;
+    }
+    const codePoint = value.charCodeAt(0);
+    return ((codePoint >= 0x41 && codePoint <= 0x5a) ||
+        (codePoint >= 0x61 && codePoint <= 0x7a) ||
+        (codePoint >= 0x30 && codePoint <= 0x39) ||
+        value === "+" ||
+        value === "/");
+}
 function decodeMultipartBinaryValue(value, fallbackFilename) {
     if (typeof value === "string") {
         return {
@@ -483,7 +532,12 @@ function parseResponseBody(text, contentType) {
     if (!isJsonContentType(contentType)) {
         return text;
     }
-    return JSON.parse(text);
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return text;
+    }
 }
 function extractErrorCode(body) {
     if (body === null || typeof body !== "object" || Array.isArray(body)) {

package/packages/toolcraft-openapi/dist/index.d.ts

@@ -19,4 +19,5 @@ export type { AuthProvider, CommandContributor, TokenSource } from "./auth/types
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export type { BearerTokenAuthOptions } from "./auth/bearer-token-auth.js";
 export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";
+export { validateArrayJsonHelperValue } from "./interpreter.js";
 export type { BinaryHttpResponse, HttpErrorRequest, HttpErrorResponse, HttpRequestOptions, QueryValue } from "./http.js";

package/packages/toolcraft-openapi/dist/index.js

@@ -10,3 +10,4 @@ export { renderOpenApiInspection } from "./render-inspection.js";
 export { commandsFromSpec, defineClientFromSpec, resolveOpenApiBaseUrl } from "./runtime.js";
 export { bearerTokenAuth } from "./auth/bearer-token-auth.js";
 export { HttpError, prepareMultipartFileInputs, requestJson, writeBinaryResponseOutput } from "./http.js";
+export { validateArrayJsonHelperValue } from "./interpreter.js";

package/packages/toolcraft-openapi/dist/interpreter.d.ts

@@ -1,6 +1,12 @@
 import { type RequestSectionKey } from "./request-shape.js";
-import type { GeneratedPreflightBlock, GeneratedRequestField, GeneratedRequestLocation, GeneratedRequestSectionRenders } from "./generate.js";
+import type { GeneratedParamDefinition, GeneratedPreflightBlock, GeneratedRequestField, GeneratedRequestLocation, GeneratedRequestSectionRenders } from "./generate.js";
+type GeneratedArrayDefinition = GeneratedParamDefinition & {
+    kind: "array";
+    itemDefinition: GeneratedParamDefinition;
+};
 export declare function renderPreflightBlock(block: GeneratedPreflightBlock): string[];
 export declare function executePreflightBlocks(blocks: ReadonlyArray<GeneratedPreflightBlock>, params: Readonly<Record<string, unknown>>): Record<string, unknown>;
+export declare function validateArrayJsonHelperValue(value: unknown, definition: GeneratedArrayDefinition, jsonParamName: string): void;
 export declare function renderRequestShape(requestFields: ReadonlyArray<GeneratedRequestField>, sectionRenders: GeneratedRequestSectionRenders, optionalSections: ReadonlySet<GeneratedRequestLocation>): string[];
 export declare function buildRequestShape(requestFields: ReadonlyArray<GeneratedRequestField>, sectionRenders: GeneratedRequestSectionRenders, optionalSections: ReadonlySet<GeneratedRequestLocation>, params: Readonly<Record<string, unknown>>, resolvedValues: Readonly<Record<string, unknown>>): Partial<Record<RequestSectionKey, unknown>>;
+export {};

package/packages/toolcraft-openapi/dist/interpreter.js

@@ -86,6 +86,7 @@ const PREFLIGHT_BLOCK_OPERATIONS = {
                 "      if (!Array.isArray(parsedJson)) {",
                 `        throw new UserError(${JSON.stringify(getInvalidArrayJsonMessage(block.jsonParamName, "Expected a JSON array."))});`,
                 "      }",
+                `      validateArrayJsonHelperValue(parsedJson, ${JSON.stringify(block.definition)}, ${JSON.stringify(block.jsonParamName)});`,
                 `      ${block.resolvedName} = parsedJson;`,
                 "    }",
                 ...(block.nullParamName === undefined
@@ -126,6 +127,7 @@ const PREFLIGHT_BLOCK_OPERATIONS = {
                 if (!Array.isArray(parsedJson)) {
                     throw new UserError(getInvalidArrayJsonMessage(block.jsonParamName, "Expected a JSON array."));
                 }
+                validateArrayJsonHelperValue(parsedJson, block.definition, block.jsonParamName);
                 resolved = parsedJson;
             }
             if (nullRequested) {
@@ -208,6 +210,107 @@ export function executePreflightBlocks(blocks, params) {
     }
     return resolvedValues;
 }
+export function validateArrayJsonHelperValue(value, definition, jsonParamName) {
+    const issue = findDefinitionIssue(value, definition, []);
+    if (issue !== undefined) {
+        throw new UserError(getInvalidArrayJsonMessage(jsonParamName, issue));
+    }
+}
+function findDefinitionIssue(value, definition, path) {
+    if (value === null) {
+        return definition.nullable === true || definition.kind === "json"
+            ? undefined
+            : `Expected ${expectedDefinition(definition)} at ${formatJsonPath(path)}.`;
+    }
+    switch (definition.kind) {
+        case "array":
+            return findArrayDefinitionIssue(value, definition, path);
+        case "boolean":
+            return typeof value === "boolean"
+                ? undefined
+                : `Expected boolean at ${formatJsonPath(path)}.`;
+        case "enum":
+            return definition.enumValues.includes(value)
+                ? undefined
+                : `Expected one of ${definition.enumValues.join(", ")} at ${formatJsonPath(path)}.`;
+        case "json":
+            return undefined;
+        case "number":
+            return findNumberDefinitionIssue(value, definition, path);
+        case "string":
+            return findStringDefinitionIssue(value, definition, path);
+    }
+}
+function findArrayDefinitionIssue(value, definition, path) {
+    if (!Array.isArray(value)) {
+        return `Expected array at ${formatJsonPath(path)}.`;
+    }
+    if (definition.minItems !== undefined && value.length < definition.minItems) {
+        return `Expected array with at least ${definition.minItems} items at ${formatJsonPath(path)}.`;
+    }
+    if (definition.maxItems !== undefined && value.length > definition.maxItems) {
+        return `Expected array with at most ${definition.maxItems} items at ${formatJsonPath(path)}.`;
+    }
+    for (const [index, item] of value.entries()) {
+        const issue = findDefinitionIssue(item, definition.itemDefinition, [...path, String(index)]);
+        if (issue !== undefined) {
+            return issue;
+        }
+    }
+    return undefined;
+}
+function findNumberDefinitionIssue(value, definition, path) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        return `Expected ${definition.jsonType === "integer" ? "integer" : "number"} at ${formatJsonPath(path)}.`;
+    }
+    if (definition.jsonType === "integer" && !Number.isInteger(value)) {
+        return `Expected integer at ${formatJsonPath(path)}.`;
+    }
+    if (definition.minimum !== undefined && value < definition.minimum) {
+        return `Expected number greater than or equal to ${definition.minimum} at ${formatJsonPath(path)}.`;
+    }
+    if (definition.maximum !== undefined && value > definition.maximum) {
+        return `Expected number less than or equal to ${definition.maximum} at ${formatJsonPath(path)}.`;
+    }
+    return undefined;
+}
+function findStringDefinitionIssue(value, definition, path) {
+    if (typeof value !== "string") {
+        return `Expected string at ${formatJsonPath(path)}.`;
+    }
+    if (definition.minLength !== undefined && value.length < definition.minLength) {
+        return `Expected string with length at least ${definition.minLength} at ${formatJsonPath(path)}.`;
+    }
+    if (definition.maxLength !== undefined && value.length > definition.maxLength) {
+        return `Expected string with length at most ${definition.maxLength} at ${formatJsonPath(path)}.`;
+    }
+    if (definition.pattern !== undefined) {
+        const pattern = compileDefinitionPattern(definition.pattern);
+        if (pattern === undefined || !pattern.test(value)) {
+            return `Expected string matching pattern ${definition.pattern} at ${formatJsonPath(path)}.`;
+        }
+    }
+    return undefined;
+}
+function compileDefinitionPattern(pattern) {
+    try {
+        return new RegExp(pattern, "u");
+    }
+    catch {
+        return undefined;
+    }
+}
+function expectedDefinition(definition) {
+    return definition.kind === "number" && definition.jsonType === "integer"
+        ? "integer"
+        : definition.kind;
+}
+function formatJsonPath(path) {
+    if (path.length === 0) {
+        return "the JSON array";
+    }
+    return path.map((segment) => `[${segment}]`).join("");
+}
 export function renderRequestShape(requestFields, sectionRenders, optionalSections) {
     const lines = [];
     for (const section of REQUEST_PARAM_SECTIONS) {