toolcraft-openapi 0.0.59 → 0.0.61

package/dist/generate.d.ts

@@ -126,6 +126,7 @@ export interface GeneratedCommand {
     idempotencyHeader?: string;
     rawResponse?: boolean;
     confirm: boolean;
+    positional: string[];
     params: GeneratedParam[];
     paramsSchemaOptions?: GeneratedObjectSchemaOptions;
     preflightBlocks: GeneratedPreflightBlock[];
@@ -150,6 +151,7 @@ interface GeneratedCommandExample {
     params: Record<string, unknown>;
 }
 interface GeneratedParamDefinitionMetadata {
+    additionalProperties?: boolean;
     defaultValue?: unknown;
     format?: string;
     jsonType?: "integer";
@@ -177,7 +179,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/dist/generate.js

@@ -21,16 +21,6 @@ const NULL_HELPER_SUPPORT = {
     query: { array: false, scalar: false }
 };
 const TRANSPORT_PARAMS = [
-    {
-        paramName: "dryRun",
-        sourceName: "dryRun",
-        location: "transport",
-        description: "Print the HTTP request and exit without sending it.",
-        scope: ["cli", "sdk"],
-        global: true,
-        optional: true,
-        definition: { kind: "boolean" }
-    },
     {
         paramName: "verbose",
         sourceName: "verbose",
@@ -57,6 +47,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
@@ -275,6 +269,7 @@ function createGeneratedCommand(document, entry) {
     const noun = createSafeGeneratedNoun(deriveNoun(operation, entry.path, operationId));
     const verb = deriveVerb(entry.method, entry.path, operation, operationId, noun);
     const collected = collectParams(document, entry, operation, operationId, auth, response.mode);
+    const positional = collectPathPositionals(entry.path, collected.params, operationId);
     const methodDefaults = METHOD_DEFAULTS[entry.method];
     const exportName = `${toCamelCase(noun)}${toPascalCase(verb)}Command`;
     const filePath = `${noun}/${verb}.ts`;
@@ -295,6 +290,7 @@ function createGeneratedCommand(document, entry) {
         contentType: collected.contentType,
         multipartBinaryFields: collected.multipartBinaryFields,
         confirm: methodDefaults?.confirm === true,
+        positional,
         params: collected.params,
         paramsSchemaOptions: collected.paramsSchemaOptions,
         preflightBlocks: collected.preflightBlocks,
@@ -303,6 +299,28 @@ function createGeneratedCommand(document, entry) {
         optionalSections: collected.optionalSections
     };
 }
+function collectPathPositionals(pathTemplate, params, operationId) {
+    const pathParamNames = new Set(params.filter((param) => param.location === "path").map((param) => param.sourceName));
+    const positionals = [];
+    for (const segment of pathTemplate.split("/")) {
+        if (!segment.startsWith("{") || !segment.endsWith("}")) {
+            continue;
+        }
+        const sourceName = segment.slice(1, -1);
+        if (!pathParamNames.has(sourceName)) {
+            throw new UserError(`Operation ${JSON.stringify(operationId)} path parameter ${JSON.stringify(sourceName)} is missing from generated params.`);
+        }
+        const param = params.find((candidate) => candidate.location === "path" && candidate.sourceName === sourceName);
+        if (param === undefined) {
+            continue;
+        }
+        if (param.definition.kind === "array" && positionals.length < pathParamNames.size - 1) {
+            throw new UserError(`Operation ${JSON.stringify(operationId)} path parameter ${JSON.stringify(sourceName)} is an array and can only be the final positional argument.`);
+        }
+        positionals.push(param.paramName);
+    }
+    return positionals;
+}
 function resolveOperationBaseUrl(operation, operationId) {
     if (operation.servers === undefined) {
         return undefined;
@@ -660,7 +678,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 +701,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 +933,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 +1030,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 +1070,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) {
@@ -1433,6 +1503,9 @@ function createCommandFile(options) {
     if (options.confirm) {
         lines.push("  confirm: true,");
     }
+    if (options.positional.length > 0) {
+        lines.push(`  positional: ${JSON.stringify(options.positional)},`);
+    }
     lines.push("  params: S.Object({");
     lines.push(...renderParamLines(options.params));
     lines.push(options.paramsSchemaOptions?.additionalProperties === false
@@ -1494,7 +1567,6 @@ function createCommandFile(options) {
     }
     lines.push("      tokenSource,");
     lines.push("      fetch,");
-    lines.push("      dryRun: params.dryRun,");
     lines.push("      verbose: params.verbose,");
     if (options.rawResponse === true) {
         lines.push("      rawResponse: params.rawResponse,");
@@ -1600,6 +1672,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 +1685,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)}]`;
@@ -1739,7 +1822,7 @@ function createIndexFile(commands) {
     if (groups.length === 0) {
         return {
             path: "index.ts",
-            contents: createGeneratedTypeScriptFile(["export {};", ""])
+            contents: createGeneratedTypeScriptFile(["export const generatedCommands = [] as const;", ""])
         };
     }
     const lines = createGeneratedTypeScriptFileLines();
@@ -1759,6 +1842,8 @@ function createIndexFile(commands) {
         lines.push("});");
         lines.push("");
     }
+    lines.push(`export const generatedCommands = [${groups.map(({ noun }) => toCamelCase(noun)).join(", ")}] as const;`);
+    lines.push("");
     return {
         path: "index.ts",
         contents: lines.join("\n")
@@ -1771,11 +1856,11 @@ function createCliFile(theme) {
             "#!/usr/bin/env node",
             ...createGeneratedTypeScriptFileLines(),
             'import { configureTheme, runCLI } from "toolcraft/cli";',
-            'import * as groups from "./index.js";',
+            'import { generatedCommands } from "./index.js";',
             "",
             `configureTheme({ brand: ${JSON.stringify(theme.brand)}, label: ${JSON.stringify(theme.label)} });`,
             "",
-            "await runCLI(Object.values(groups));",
+            "await runCLI([...generatedCommands]);",
             ""
         ].join("\n")
     };

package/dist/http.d.ts

@@ -24,7 +24,6 @@ export interface HttpRequestOptions {
     multipartBinaryFields?: readonly string[];
     responseMode?: "json" | "text" | "binary";
     accept?: string;
-    dryRun?: boolean;
     verbose?: boolean;
     signal?: AbortSignal;
     rawResponse?: boolean;
@@ -41,7 +40,6 @@ export interface HttpRequestOptions {
         key?: string;
         createKey?: () => string;
     };
-    writeStdout?: (chunk: string) => void;
     writeStderr?: (chunk: string) => void;
 }
 export interface BinaryHttpResponse {

package/dist/http.js

@@ -28,13 +28,7 @@ export async function requestJson(options) {
         }
         : {};
     const headers = createHeaders(token, hasBody, { ...options.headers, ...idempotencyHeader }, options.accept, options.bodyMode, options.contentType);
-    const writeStdout = options.writeStdout ?? process.stdout.write.bind(process.stdout);
     const writeStderr = options.writeStderr ?? process.stderr.write.bind(process.stderr);
-    const requestLine = `${method} ${redactSensitiveQueryValues(url)}`;
-    if (options.dryRun) {
-        writeStdout(formatDryRunOutput(requestLine, headers, options.body));
-        return undefined;
-    }
     if (options.verbose) {
         writeStderr(formatTranscriptLines(formatVerboseRequestTranscript(method, url, headers, options.body)));
     }
@@ -453,20 +447,6 @@ function createHttpErrorRequest(method, url, headers, body) {
 function serializeHeaders(headers) {
     return Object.fromEntries(headers.entries());
 }
-function formatDryRunOutput(requestLine, headers, body) {
-    const lines = [
-        requestLine,
-        ...Object.entries(headers).map(([key, value]) => {
-            const headerValue = redactHeaderValue(key, value);
-            return `${key}: ${headerValue}`;
-        }),
-        ""
-    ];
-    if (body !== undefined) {
-        lines.push(JSON.stringify(body));
-    }
-    return `${lines.join("\n")}\n`;
-}
 function formatVerboseRequestTranscript(method, url, headers, body) {
     const lines = [
         `→ ${method} ${redactSensitiveQueryValues(url)}`,

package/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/dist/runtime.js

@@ -62,6 +62,7 @@ function createRuntimeCommand(command) {
         ...(command.description === undefined ? {} : { description: command.description }),
         scope: RUNTIME_COMMAND_SCOPE,
         ...(command.confirm ? { confirm: true } : {}),
+        ...(command.positional.length > 0 ? { positional: command.positional } : {}),
         params: paramsSchema,
         handler: createRuntimeHandler(command)
     });
@@ -88,7 +89,6 @@ function createRuntimeHandler(command) {
             multipartBinaryFields: command.multipartBinaryFields,
             tokenSource,
             fetch,
-            dryRun: params.dryRun,
             verbose: params.verbose,
             ...preparedRequestShape
         });
@@ -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) {

package/node_modules/toolcraft-design/dist/components/help-formatter-plain.js

@@ -100,7 +100,7 @@ export function formatColumns(opts) {
             return [`${firstIndent}${row.left}`];
         }
         const rightLines = wrapWords(row.right, rightWidth);
-        if (row.left.length > leftWidth) {
+        if (row.left.length >= leftWidth) {
             return [
                 `${firstIndent}${row.left}`,
                 ...rightLines.map((line) => `${continuationIndent}${line}`)

package/node_modules/toolcraft-design/dist/components/help-formatter.js

@@ -159,7 +159,7 @@ export function formatColumns(opts) {
             return [`${firstIndent}${row.left}`];
         }
         const rightLines = wrapWords(row.right, rightWidth);
-        if (visibleWidth(row.left) > leftWidth) {
+        if (visibleWidth(row.left) >= leftWidth) {
             return [
                 `${firstIndent}${row.left}`,
                 ...rightLines.map((line) => `${continuationIndent}${line}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "toolcraft-openapi",
-  "version": "0.0.59",
+  "version": "0.0.61",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -28,7 +28,7 @@
     "toolcraft-openapi-generate": "dist/bin/generate.js"
   },
   "dependencies": {
-    "toolcraft": "0.0.59",
+    "toolcraft": "0.0.61",
     "auth-store": "^0.0.1",
     "fast-string-width": "^3.0.2",
     "fast-wrap-ansi": "^0.2.0",