poe-code 3.0.378 → 3.0.379

package/package.json

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

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

@@ -150,6 +150,7 @@ interface GeneratedCommandExample {
     params: Record<string, unknown>;
 }
 interface GeneratedParamDefinitionMetadata {
+    additionalProperties?: boolean;
     defaultValue?: unknown;
     format?: string;
     jsonType?: "integer";
@@ -177,7 +178,16 @@ interface GeneratedArrayParamDefinition extends GeneratedParamDefinitionMetadata
 interface GeneratedJsonParamDefinition extends GeneratedParamDefinitionMetadata {
     kind: "json";
 }
-export type GeneratedParamDefinition = GeneratedScalarParamDefinition | GeneratedEnumParamDefinition | GeneratedArrayParamDefinition | GeneratedJsonParamDefinition;
+interface GeneratedObjectParamDefinition extends GeneratedParamDefinitionMetadata {
+    kind: "object";
+    properties: readonly GeneratedObjectPropertyDefinition[];
+}
+interface GeneratedObjectPropertyDefinition {
+    name: string;
+    optional: boolean;
+    definition: GeneratedParamDefinition;
+}
+export type GeneratedParamDefinition = GeneratedScalarParamDefinition | GeneratedEnumParamDefinition | GeneratedArrayParamDefinition | GeneratedObjectParamDefinition | GeneratedJsonParamDefinition;
 type GeneratedParamScope = "cli" | "mcp" | "sdk";
 type GeneratedEnumValue = string | number | boolean;
 export type GeneratedValueReference = {

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

@@ -57,6 +57,10 @@ const SCHEMA_OPTION_SOURCES = [
         key: "description",
         get: (param) => param.description
     },
+    {
+        key: "additionalProperties",
+        get: (param) => param.definition.additionalProperties
+    },
     {
         key: "default",
         get: (param) => param.definition.defaultValue
@@ -660,7 +664,7 @@ function assertSupportedPathParameterSerialization(parameter, operationId) {
     throw new UserError(`Operation ${JSON.stringify(operationId)} path parameter ${JSON.stringify(parameter.name)} uses unsupported serialization. Path parameters must use style "simple" with explode false in v1.`);
 }
 function createBodyField(document, name, schema, optional, operationId) {
-    if (isComplexJsonBodySchema(document, schema, operationId, `request body field ${JSON.stringify(name)}`)) {
+    if (shouldUseJsonBodyField(document, schema, operationId, `request body field ${JSON.stringify(name)}`)) {
         return createJsonBodyField({
             document,
             name,
@@ -683,6 +687,25 @@ function createBodyField(document, name, schema, optional, operationId) {
         location: "body"
     });
 }
+function shouldUseJsonBodyField(document, schema, operationId, context) {
+    if (isUnconstrainedJsonSchema(schema)) {
+        return true;
+    }
+    if (getCompositionKeyword(schema) !== undefined || Array.isArray(schema.type)) {
+        return true;
+    }
+    if (schema.type === "object") {
+        return typeof schema.additionalProperties === "object";
+    }
+    if (schema.properties !== undefined || schema.additionalProperties !== undefined) {
+        return true;
+    }
+    if (schema.type !== "array" || schema.items === undefined) {
+        return false;
+    }
+    const itemSchema = resolveBodySchema(document, schema.items, operationId, `${context} items`);
+    return shouldUseJsonBodyField(document, itemSchema, operationId, `${context} items`);
+}
 function isComplexJsonBodySchema(document, schema, operationId, context) {
     if (isUnconstrainedJsonSchema(schema)) {
         return true;
@@ -896,7 +919,10 @@ const FIELD_ASSEMBLERS = {
             ...options,
             location: "body"
         }),
-        object: (options) => createJsonBodyField(options),
+        object: (options) => createScalarParam({
+            ...options,
+            location: "body"
+        }),
         scalar: (options) => createScalarParam({
             ...options,
             location: "body"
@@ -990,6 +1016,15 @@ function createParamDefinition(document, schema, operationId, context) {
             ...(schema.nullable === true ? { nullable: true } : {})
         };
     }
+    if (schema.type === "object") {
+        return {
+            kind: "object",
+            properties: createObjectPropertyDefinitions(document, schema, operationId, context),
+            additionalProperties: schema.additionalProperties !== false,
+            ...(schema.default === undefined ? {} : { defaultValue: schema.default }),
+            ...(schema.nullable === true ? { nullable: true } : {})
+        };
+    }
     const scalarDefinition = isOpenApiScalarType(schema.type)
         ? SCHEMA_TYPE_TO_KIND[schema.type]
         : undefined;
@@ -1021,6 +1056,27 @@ function createParamDefinition(document, schema, operationId, context) {
     }
     throw new UserError(`Operation ${JSON.stringify(operationId)} uses unsupported ${context}. Supported shapes in this milestone are string, number, integer, boolean, enum, and arrays of those values.`);
 }
+function createObjectPropertyDefinitions(document, schema, operationId, context) {
+    const required = new Set(schema.required ?? []);
+    const properties = [];
+    for (const [name, property] of Object.entries(schema.properties ?? {})) {
+        const propertySchema = resolveBodySchema(document, property, operationId, `${context}.properties.${name}`);
+        if (propertySchema.readOnly === true) {
+            continue;
+        }
+        properties.push({
+            name,
+            optional: !required.has(name),
+            definition: shouldUseJsonBodyField(document, propertySchema, operationId, `${context}.properties.${name}`)
+                ? {
+                    kind: "json",
+                    ...(propertySchema.nullable === true ? { nullable: true } : {})
+                }
+                : createParamDefinition(document, propertySchema, operationId, `${context}.properties.${name}`)
+        });
+    }
+    return properties;
+}
 function assertPathTemplateParameters(path, parameters, operationId) {
     const placeholders = new Set(collectPathPlaceholders(path));
     for (const placeholder of placeholders) {
@@ -1600,6 +1656,7 @@ const DEFINITION_RENDERERS = {
     enum: (definition, options) => renderSchemaCall("S.Enum", renderConstArray(definition.enumValues), options),
     json: (_definition) => renderSchemaCall("S.Json"),
     number: (_definition, options) => renderSchemaCall("S.Number", options),
+    object: (definition, options) => renderSchemaCall("S.Object", renderObjectDefinitionShape(definition), options),
     string: (_definition, options) => renderSchemaCall("S.String", options)
 };
 function renderSchemaCall(builder, ...args) {
@@ -1612,6 +1669,16 @@ function renderSchemaOptions(param) {
 function renderConstArray(values) {
     return `${JSON.stringify(values)} as const`;
 }
+function renderObjectDefinitionShape(definition) {
+    if (definition.properties.length === 0) {
+        return "{}";
+    }
+    return `{ ${definition.properties.map(renderObjectDefinitionProperty).join(", ")} }`;
+}
+function renderObjectDefinitionProperty(property) {
+    const schema = renderDefinition(property.definition, undefined, undefined, undefined);
+    return `${renderObjectKey(property.name)}: ${property.optional ? `S.Optional(${schema})` : schema}`;
+}
 function renderObjectKey(name) {
     if (name === "__proto__") {
         return `[${JSON.stringify(name)}]`;

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

@@ -237,6 +237,8 @@ function findDefinitionIssue(value, definition, path) {
             return undefined;
         case "number":
             return findNumberDefinitionIssue(value, definition, path);
+        case "object":
+            return findObjectDefinitionIssue(value, definition, path);
         case "string":
             return findStringDefinitionIssue(value, definition, path);
     }
@@ -259,6 +261,35 @@ function findArrayDefinitionIssue(value, definition, path) {
     }
     return undefined;
 }
+function findObjectDefinitionIssue(value, definition, path) {
+    if (!isJsonObject(value)) {
+        return `Expected object at ${formatJsonPath(path)}.`;
+    }
+    const knownProperties = new Set(definition.properties.map((property) => property.name));
+    for (const property of definition.properties) {
+        if (!Object.prototype.hasOwnProperty.call(value, property.name)) {
+            if (property.optional) {
+                continue;
+            }
+            return `Expected required property ${JSON.stringify(property.name)} at ${formatJsonPath(path)}.`;
+        }
+        const issue = findDefinitionIssue(value[property.name], property.definition, [
+            ...path,
+            property.name
+        ]);
+        if (issue !== undefined) {
+            return issue;
+        }
+    }
+    if (definition.additionalProperties === false) {
+        for (const key of Object.keys(value)) {
+            if (!knownProperties.has(key)) {
+                return `Unexpected property ${JSON.stringify(key)} at ${formatJsonPath(path)}.`;
+            }
+        }
+    }
+    return undefined;
+}
 function findNumberDefinitionIssue(value, definition, path) {
     if (typeof value !== "number" || !Number.isFinite(value)) {
         return `Expected ${definition.jsonType === "integer" ? "integer" : "number"} at ${formatJsonPath(path)}.`;
@@ -292,6 +323,9 @@ function findStringDefinitionIssue(value, definition, path) {
     }
     return undefined;
 }
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 function compileDefinitionPattern(pattern) {
     try {
         return new RegExp(pattern, "u");

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

@@ -112,6 +112,13 @@ const RUNTIME_DEFINITION_BUILDERS = {
     enum: (definition, options) => options === undefined ? S.Enum(definition.enumValues) : S.Enum(definition.enumValues, options),
     json: (_definition) => S.Json(),
     number: (_definition, options) => options === undefined ? S.Number() : S.Number(options),
+    object: (definition, options) => {
+        const shape = Object.fromEntries(definition.properties.map((property) => {
+            const propertySchema = createRuntimeDefinition(property.definition, undefined, undefined, undefined);
+            return [property.name, property.optional ? S.Optional(propertySchema) : propertySchema];
+        }));
+        return options === undefined ? S.Object(shape) : S.Object(shape, options);
+    },
     string: (_definition, options) => options === undefined ? S.String() : S.String(options)
 };
 function createRuntimeSchemaOptions(definition, description, shortFlag, scope, global) {