poe-code 3.0.288 → 3.0.290

package/package.json

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

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

@@ -1230,7 +1230,12 @@ function resolveEquivalentCompositionSchema(document, schema, operationId, conte
     const { anyOf: _anyOf, oneOf: _oneOf, ...wrapper } = schema;
     void _anyOf;
     void _oneOf;
-    return { ...wrapper, ...createSchemaFromEquivalentShape(firstShape) };
+    const enumValues = collectEquivalentCompositionEnumValues(resolved);
+    return {
+        ...wrapper,
+        ...createSchemaFromEquivalentShape(firstShape),
+        ...(enumValues === undefined ? {} : { enum: enumValues })
+    };
 }
 function getEquivalentSchemaShape(schema) {
     if (getCompositionKeyword(schema) !== undefined || Array.isArray(schema.type)) {
@@ -1250,6 +1255,20 @@ function createSchemaFromEquivalentShape(shape) {
     }
     return { type: "array", items: createSchemaFromEquivalentShape(shape.slice("array:".length)) };
 }
+function collectEquivalentCompositionEnumValues(schemas) {
+    if (schemas.some((schema) => schema.enum === undefined)) {
+        return undefined;
+    }
+    const values = [];
+    for (const schema of schemas) {
+        for (const value of schema.enum ?? []) {
+            if (!values.some((existing) => Object.is(existing, value))) {
+                values.push(value);
+            }
+        }
+    }
+    return values.length === 0 ? undefined : values;
+}
 function normalizeNullableTypeArray(schema) {
     if (!Array.isArray(schema.type)) {
         return schema;

package/packages/toolcraft-openapi/dist/mock/fetch.js

@@ -34,6 +34,10 @@ export async function mockFetch(options) {
             body: parsedBody,
             at: new Date()
         });
+        const parameterErrors = validateRequestParameters(operation, requestUrl, headers, document);
+        if (parameterErrors.length > 0) {
+            return jsonResponse(422, { errors: parameterErrors });
+        }
         if (operation.requestBodySchema !== undefined && parsedBody !== undefined) {
             const errors = validateAgainstSchema(parsedBody, operation.requestBodySchema, document, "$");
             if (errors.length > 0) {
@@ -46,7 +50,7 @@ export async function mockFetch(options) {
         const fixture = await fixtureLoader(operation.operationId);
         if (fixture !== undefined) {
             const status = fixture.status ?? operation.defaultStatus;
-            const responseSchema = operation.responseSchemas.get(status);
+            const responseSchema = findResponseSchema(operation.responseSchemas, status);
             if (responseSchema !== undefined && fixture.body !== undefined) {
                 const errors = validateAgainstSchema(fixture.body, responseSchema, document, "$response");
                 if (errors.length > 0) {
@@ -110,13 +114,16 @@ function compileOperations(document) {
             const operationId = resolvedOperation.operationId ?? `${method.toUpperCase()} ${pathTemplate}`;
             const { defaultStatus, defaultExample, responseSchemas } = pickResponseMetadata(resolvedOperation, document);
             const { schema: requestBodySchema, required: requestBodyRequired } = pickRequestBody(resolvedOperation, document);
+            const pathParameterNames = collectPathParameterNames(pathTemplate);
             compiled.push({
                 method: method.toUpperCase(),
                 pathTemplate,
                 pathRegex: pathTemplateToRegex(pathTemplate),
+                pathParameterNames,
                 pathSpecificity: countPathPlaceholders(pathTemplate),
                 operationId,
                 operation: resolvedOperation,
+                parameters: collectCompiledParameters(pathItem.parameters, resolvedOperation.parameters, document),
                 defaultStatus,
                 defaultExample,
                 requestBodySchema,
@@ -131,14 +138,31 @@ function compileOperations(document) {
     return compiled;
 }
 function countPathPlaceholders(template) {
-    return (template.match(/\{[^}]+\}/g) ?? []).length;
+    return collectPathParameterNames(template).length;
 }
 function pathTemplateToRegex(template) {
     // Escape regex metacharacters except for "{...}" placeholders, which become non-slash captures.
     const pattern = template.replace(/[.*+?^${}()|[\]\\]/g, (match) => match === "{" || match === "}" ? match : `\\${match}`);
-    const withParams = pattern.replace(/\{[^}]+\}/g, "[^/]+");
+    const withParams = pattern.replace(/\{[^}]+\}/g, "([^/]+)");
     return new RegExp(`^${withParams}$`);
 }
+function collectPathParameterNames(template) {
+    const names = [];
+    let index = 0;
+    while (index < template.length) {
+        const start = template.indexOf("{", index);
+        if (start === -1) {
+            break;
+        }
+        const end = template.indexOf("}", start + 1);
+        if (end === -1) {
+            break;
+        }
+        names.push(template.slice(start + 1, end));
+        index = end + 1;
+    }
+    return names;
+}
 function resolveOperation(operation, document) {
     if (isReference(operation)) {
         return resolveReference(operation, document);
@@ -147,10 +171,11 @@ function resolveOperation(operation, document) {
 }
 function pickResponseMetadata(operation, document) {
     const responses = operation.responses ?? {};
-    const responseSchemas = new Map();
+    const responseSchemas = [];
+    const successResponses = [];
     for (const [code, response] of Object.entries(responses)) {
-        const status = parseInt(code, 10);
-        if (!Number.isFinite(status) || response === undefined) {
+        const status = parseResponseStatus(code);
+        if (status === undefined || response === undefined) {
             continue;
         }
         const resolved = isReference(response)
@@ -158,27 +183,46 @@ function pickResponseMetadata(operation, document) {
             : response;
         const schema = extractResponseSchema(resolved, document);
         if (schema !== undefined) {
-            responseSchemas.set(status, schema);
+            responseSchemas.push({ ...status, schema });
+        }
+        if (isSuccessStatus(status.status)) {
+            successResponses.push({ status: status.status, response });
         }
     }
-    const successCodes = Object.keys(responses)
-        .map((code) => parseInt(code, 10))
-        .filter((code) => Number.isFinite(code) && code >= 200 && code < 300)
-        .sort((a, b) => a - b);
-    if (successCodes.length === 0) {
+    successResponses.sort((a, b) => a.status - b.status);
+    const firstSuccess = successResponses[0];
+    if (firstSuccess === undefined) {
         return { defaultStatus: 200, defaultExample: undefined, responseSchemas };
     }
-    const status = successCodes[0];
-    const response = responses[String(status)];
-    const resolvedResponse = response !== undefined && isReference(response)
-        ? resolveReference(response, document)
-        : response;
+    const resolvedResponse = isReference(firstSuccess.response)
+        ? resolveReference(firstSuccess.response, document)
+        : firstSuccess.response;
     return {
-        defaultStatus: status,
+        defaultStatus: firstSuccess.status,
         defaultExample: extractExample(resolvedResponse, document),
         responseSchemas
     };
 }
+function parseResponseStatus(code) {
+    if (code.length === 3 && code[1]?.toUpperCase() === "X" && code[2]?.toUpperCase() === "X") {
+        const family = Number(code[0]);
+        return Number.isInteger(family) && family >= 1 && family <= 5
+            ? { status: family * 100, range: true }
+            : undefined;
+    }
+    if (code.length !== 3 || [...code].some((character) => character < "0" || character > "9")) {
+        return undefined;
+    }
+    return { status: Number(code), range: false };
+}
+function isSuccessStatus(status) {
+    return status >= 200 && status < 300;
+}
+function findResponseSchema(schemas, status) {
+    return (schemas.find((candidate) => !candidate.range && candidate.status === status)?.schema ??
+        schemas.find((candidate) => candidate.range && Math.floor(status / 100) === candidate.status / 100)
+            ?.schema);
+}
 function extractResponseSchema(response, document) {
     if (response === undefined) {
         return undefined;
@@ -211,6 +255,95 @@ function pickRequestBody(operation, document) {
         : media.schema;
     return { schema, required: resolved.required === true };
 }
+function collectCompiledParameters(pathParameters, operationParameters, document) {
+    const parameters = new Map();
+    for (const raw of [...(pathParameters ?? []), ...(operationParameters ?? [])]) {
+        const parameter = isReference(raw)
+            ? resolveReference(raw, document)
+            : raw;
+        if (parameter.in !== "path" && parameter.in !== "query" && parameter.in !== "header") {
+            continue;
+        }
+        parameters.set(`${parameter.in}:${parameter.name}`, {
+            name: parameter.name,
+            location: parameter.in,
+            required: parameter.in === "path" || parameter.required === true,
+            schema: parameter.schema
+        });
+    }
+    return [...parameters.values()];
+}
+function validateRequestParameters(operation, requestUrl, headers, document) {
+    const pathValues = collectPathParameterValues(operation, requestUrl.pathname);
+    const errors = [];
+    for (const parameter of operation.parameters) {
+        const pointer = `$${parameter.location}/${parameter.name}`;
+        const value = readParameterValue(parameter, requestUrl, headers, pathValues);
+        if (value === undefined) {
+            if (parameter.required) {
+                errors.push(`${pointer}: required`);
+            }
+            continue;
+        }
+        if (parameter.schema !== undefined) {
+            errors.push(...validateAgainstSchema(value, parameter.schema, document, pointer));
+        }
+    }
+    return errors;
+}
+function collectPathParameterValues(operation, pathname) {
+    const match = operation.pathRegex.exec(pathname);
+    const values = new Map();
+    if (match === null) {
+        return values;
+    }
+    for (let index = 0; index < operation.pathParameterNames.length; index++) {
+        const value = match[index + 1];
+        if (value !== undefined) {
+            values.set(operation.pathParameterNames[index], decodeUrlComponent(value));
+        }
+    }
+    return values;
+}
+function readParameterValue(parameter, requestUrl, headers, pathValues) {
+    switch (parameter.location) {
+        case "path":
+            return coerceParameterValue(parameter.schema, pathValues.get(parameter.name));
+        case "query": {
+            const values = requestUrl.searchParams.getAll(parameter.name);
+            if (values.length === 0) {
+                return undefined;
+            }
+            return schemaAcceptsArray(parameter.schema) ? coerceParameterValues(values) : values[0];
+        }
+        case "header":
+            return coerceParameterValue(parameter.schema, headers[parameter.name.toLowerCase()]);
+    }
+}
+function coerceParameterValue(schema, value) {
+    if (value === undefined || !schemaAcceptsArray(schema)) {
+        return value;
+    }
+    return coerceParameterValues([value]);
+}
+function coerceParameterValues(values) {
+    return values.flatMap((value) => value.split(","));
+}
+function schemaAcceptsArray(schema) {
+    if (schema === undefined || isReference(schema)) {
+        return false;
+    }
+    const type = schema.type;
+    return Array.isArray(type) ? type.includes("array") : type === "array";
+}
+function decodeUrlComponent(value) {
+    try {
+        return decodeURIComponent(value);
+    }
+    catch {
+        return value;
+    }
+}
 function extractExample(response, document) {
     if (response === undefined) {
         return undefined;
@@ -265,7 +398,7 @@ function resolveReference(reference, document) {
     const segments = ref
         .slice(2)
         .split("/")
-        .map((segment) => segment.replace(/~1/g, "/").replace(/~0/g, "~"));
+        .map(decodeReferenceSegment);
     let current = document;
     for (const segment of segments) {
         if (current === null || typeof current !== "object") {
@@ -281,6 +414,16 @@ function resolveReference(reference, document) {
     }
     return current;
 }
+function decodeReferenceSegment(segment) {
+    let decoded = segment;
+    try {
+        decoded = decodeURIComponent(segment);
+    }
+    catch {
+        decoded = segment;
+    }
+    return decoded.replace(/~1/g, "/").replace(/~0/g, "~");
+}
 function validateAgainstSchema(value, schema, document, pointer) {
     const resolved = isReference(schema)
         ? resolveReference(schema, document)
@@ -334,11 +477,36 @@ function validateAgainstSchema(value, schema, document, pointer) {
             errors.push(...validateAgainstSchema(value[i], resolved.items, document, `${pointer}/${i}`));
         }
     }
+    if (typeof value === "number") {
+        validateNumberConstraints(value, resolved, pointer, errors);
+    }
+    if (typeof value === "string") {
+        validateStringConstraints(value, resolved, pointer, errors);
+    }
     if (resolved.enum !== undefined && !resolved.enum.includes(value)) {
         errors.push(`${pointer}: not in enum`);
     }
     return errors;
 }
+function validateNumberConstraints(value, schema, pointer, errors) {
+    if (schema.minimum !== undefined && value < schema.minimum) {
+        errors.push(`${pointer}: expected value to be >= ${schema.minimum}`);
+    }
+    if (schema.maximum !== undefined && value > schema.maximum) {
+        errors.push(`${pointer}: expected value to be <= ${schema.maximum}`);
+    }
+}
+function validateStringConstraints(value, schema, pointer, errors) {
+    if (schema.minLength !== undefined && value.length < schema.minLength) {
+        errors.push(`${pointer}: expected length to be >= ${schema.minLength}`);
+    }
+    if (schema.maxLength !== undefined && value.length > schema.maxLength) {
+        errors.push(`${pointer}: expected length to be <= ${schema.maxLength}`);
+    }
+    if (schema.pattern !== undefined && !new RegExp(schema.pattern).test(value)) {
+        errors.push(`${pointer}: expected value to match pattern ${schema.pattern}`);
+    }
+}
 function normalizeTypes(schema) {
     const type = schema.type;
     if (type === undefined) {