fix: file-level import type in main.ts; drop | undefined from optional query property types

- Main client file emits `import type { … }` for type-only imports instead
  of per-name `import { type X, type Y }` — matches consumer convention.
- Optional query/header params now emit `name?: T` instead of `name?: T | undefined`;
  optionality is conveyed by `?:` alone. Pairs with rest-client's
  CommandQuery constraint (`UndefinedOnPartialDeep<JsonObject>`) which
  allows undefined values across the wire boundary.
- Adds regression tests covering import shape, optional query types, and
  AllInputs membership.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: maxholman

__tests__/__snapshots__/nullables.test.ts.snap

@@ -23,7 +23,9 @@ export const nullConstSchema = inputNullConstSchema;
 `;
 
 exports[`header parameters 1`] = `
-"export type UploadStatus = "pending" | "complete";
+"import type { UndefinedOnPartialDeep } from "type-fest";
+
+export type UploadStatus = "pending" | "complete";
 export type UploadDataCommandHeader = {
         "content-type": "application/json" | "text/csv" | "application/xml";
         "content-length": \`\${number}\`;
@@ -33,11 +35,13 @@ export type UploadDataCommandParams = {
         uploadId: string;
     };
 export type UploadDataCommandInput = UploadDataCommandParams;
+export type InputUploadDataCommandResponse = UndefinedOnPartialDeep<UploadStatus>;
 "
 `;
 
 exports[`header parameters 2`] = `
 "import { Command } from "@block65/rest-client";
+import type { UndefinedOnPartialDeep } from "type-fest";
 import type { UploadDataCommandHeader, UploadDataCommandInput, UploadStatus } from "./types.js";
 
 /**
@@ -53,10 +57,10 @@ function encodePath(strings: TemplateStringsArray, ...values: string[]): string
  * UploadDataCommand
  *
  */
-export class UploadDataCommand extends Command<UploadDataCommandInput, UploadStatus, never, UploadDataCommandHeader> {
+export class UploadDataCommand extends Command<UndefinedOnPartialDeep<UploadDataCommandInput>, UploadStatus, never, UploadDataCommandHeader> {
     public override method = "post" as const;
 
-    constructor(input: UploadDataCommandInput, headers: UploadDataCommandHeader) {
+    constructor(input: UndefinedOnPartialDeep<UploadDataCommandInput>, headers: UploadDataCommandHeader) {
         const {uploadId } = input;
         super(encodePath\`/uploads/\${uploadId}\`, undefined, undefined, headers);
     }
@@ -137,16 +141,19 @@ export const nullableImageSchema = v.union([v.pipe(v.string(), v.trim()), v.null
 `;
 
 exports[`query and header integer params coerce strings to numbers 1`] = `
-"export type Dummy = string;
+"import type { UndefinedOnPartialDeep } from "type-fest";
+
+export type Dummy = string;
 export type ExpireTime = number;
 export type ListFilesCommandQuery = {
         exp: \`\${number}\`;
-        limit?: \`\${number}\` | undefined;
+        limit?: \`\${number}\`;
     };
 export type ListFilesCommandHeader = {
         "x-rate-limit": \`\${number}\`;
     };
 export type ListFilesCommandInput = ListFilesCommandQuery;
+export type InputListFilesCommandResponse = UndefinedOnPartialDeep<Dummy>;
 "
 `;
 

__tests__/codegen-regressions.test.ts

@@ -0,0 +1,151 @@
+import type { oas31 } from "openapi3-ts";
+import { expect, test } from "vitest";
+import { processOpenApiDocument } from "../lib/process-document.ts";
+
+const respOk = {
+	"200": {
+		description: "OK",
+		content: { "application/json": { schema: { type: "string" } } },
+	},
+} as const;
+
+test("main.ts emits file-level `import type` for type-only imports", async () => {
+	const schema: oas31.OpenAPIObject = {
+		openapi: "3.1.0",
+		info: { title: "Test", version: "1.0.0" },
+		paths: {
+			"/one": {
+				post: {
+					operationId: "oneCommand",
+					requestBody: {
+						content: {
+							"application/json": {
+								schema: {
+									type: "object",
+									properties: { x: { type: "string" } },
+								},
+							},
+						},
+					},
+					responses: respOk,
+				},
+			},
+		},
+	};
+
+	const result = await processOpenApiDocument("/tmp/whatever", schema);
+	const mainText = result.mainFile.getText();
+
+	expect(mainText).toMatch(
+		/import type \{[^}]*OneCommandInput[^}]*\}\s+from\s+"\.\/types\.js"/,
+	);
+	expect(mainText).toMatch(
+		/import type \{[^}]*UndefinedOnPartialDeep[^}]*\}\s+from\s+"type-fest"/,
+	);
+	expect(mainText).not.toMatch(/import \{[^}]*type\s+OneCommandInput/);
+	expect(mainText).not.toMatch(/import \{[^}]*type\s+UndefinedOnPartialDeep[^}]*\}\s+from\s+"type-fest"/);
+});
+
+test("optional query params do not carry `| undefined` in their property type", async () => {
+	const schema: oas31.OpenAPIObject = {
+		openapi: "3.1.0",
+		info: { title: "Test", version: "1.0.0" },
+		paths: {
+			"/files": {
+				get: {
+					operationId: "listFilesCommand",
+					parameters: [
+						{
+							name: "purpose",
+							in: "query",
+							required: false,
+							schema: { type: "string" },
+						},
+						{
+							name: "limit",
+							in: "query",
+							required: false,
+							schema: { type: "integer", minimum: 1, maximum: 100 },
+						},
+					],
+					responses: respOk,
+				},
+			},
+		},
+	};
+
+	const result = await processOpenApiDocument("/tmp/whatever", schema);
+	const typesText = result.typesFile.getText();
+	const queryBlock =
+		typesText.match(/export type ListFilesCommandQuery = \{[\s\S]*?\};/)?.[0] ??
+		"";
+
+	expect(queryBlock).toContain("purpose?: string");
+	expect(queryBlock).toContain("limit?: `${number}`");
+	expect(queryBlock).not.toContain("undefined");
+});
+
+test("AllInputs union includes every command's Input (no silent drops)", async () => {
+	const schema: oas31.OpenAPIObject = {
+		openapi: "3.1.0",
+		info: { title: "Test", version: "1.0.0" },
+		paths: {
+			"/with-body": {
+				post: {
+					operationId: "withBodyCommand",
+					requestBody: {
+						content: {
+							"application/json": {
+								schema: {
+									type: "object",
+									properties: { x: { type: "string" } },
+								},
+							},
+						},
+					},
+					responses: respOk,
+				},
+			},
+			"/empty-a": {
+				get: { operationId: "alphaCommand", responses: respOk },
+			},
+			"/empty-b": {
+				get: { operationId: "betaCommand", responses: respOk },
+			},
+			"/empty-c": {
+				get: { operationId: "gammaCommand", responses: respOk },
+			},
+			"/with-query": {
+				get: {
+					operationId: "withQueryCommand",
+					parameters: [
+						{
+							name: "q",
+							in: "query",
+							required: false,
+							schema: { type: "string" },
+						},
+					],
+					responses: respOk,
+				},
+			},
+		},
+	};
+
+	const result = await processOpenApiDocument("/tmp/whatever", schema);
+	const mainText = result.mainFile.getText();
+	const commandsText = result.commandsFile.getText();
+
+	const allInputsBlock =
+		mainText.match(/type AllInputs =[\s\S]*?;/)?.[0] ?? "";
+
+	const commandNames = [
+		...commandsText.matchAll(/^export class (\w+Command) extends Command</gm),
+	].map((m) => m[1] ?? "");
+
+	expect(commandNames.length).toBeGreaterThan(0);
+	const missing = commandNames.filter(
+		(name) => !allInputsBlock.includes(`${name}Input`),
+	);
+	expect(missing).toEqual([]);
+});

__tests__/fixtures/docker/commands-validated.ts

@@ -3,7 +3,7 @@
  *
  * WARN: Do not edit directly.
  *
- * Generated on 2026-05-11T06:13:31.281Z
+ * Generated on 2026-05-18T09:28:16.280Z
  *
  */
 /** eslint-disable max-classes */