@vertz/openapi 0.1.2 → 0.1.4

package/bin/openapi.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env bun
-import { runCLI } from '../src/cli';
+import { runCLI } from '../dist/cli.js';
 
 const result = await runCLI(process.argv.slice(2));
 

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   loadSpec,
   parseOpenAPI,
   resolveConfig
-} from "./shared/chunk-h8tb765a.js";
+} from "./shared/chunk-070f9ezy.js";
 
 // src/cli.ts
 function parseArgs(args) {

package/dist/index.d.ts

@@ -17,6 +17,8 @@ interface ParsedResource {
 interface ParsedOperation {
 	operationId: string;
 	methodName: string;
+	/** PascalCase prefix for generated type names (shorter than operationId for path-heavy IDs). */
+	typePrefix?: string;
 	method: HttpMethod;
 	path: string;
 	pathParams: ParsedParameter[];
@@ -26,6 +28,8 @@ interface ParsedOperation {
 	responseStatus: number;
 	tags: string[];
 	security?: OperationSecurity;
+	streamingFormat?: "sse" | "ndjson";
+	jsonResponse?: ParsedSchema;
 }
 interface OperationSecurity {
 	required: boolean;
@@ -181,7 +185,7 @@ declare function jsonSchemaToZod(schema: Record<string, unknown>, namedSchemas:
 /**
 * Generate resource SDK files for all resources + a barrel index.
 */
-declare function generateResources(resources: ParsedResource[]): GeneratedFile[];
+declare function generateResources(resources: ParsedResource[], schemas?: ParsedSchema[]): GeneratedFile[];
 /**
 * Generate Zod schema files for all resources + barrel index.
 */

package/dist/index.js

@@ -21,7 +21,7 @@ import {
   sanitizeIdentifier,
   sanitizeTypeName,
   writeIncremental
-} from "./shared/chunk-h8tb765a.js";
+} from "./shared/chunk-070f9ezy.js";
 export {
   writeIncremental,
   sanitizeTypeName,

package/dist/shared/{chunk-h8tb765a.js → chunk-070f9ezy.js}

@@ -42,6 +42,15 @@ function groupOperations(operations, strategy, options) {
 
 // src/generators/client-generator.ts
 function camelCase(name) {
+  const leadingUpper = name.match(/^[A-Z]+/);
+  if (leadingUpper) {
+    const prefix = leadingUpper[0];
+    if (prefix.length >= name.length)
+      return name.toLowerCase();
+    if (prefix.length > 1) {
+      return prefix.slice(0, -1).toLowerCase() + name.slice(prefix.length - 1);
+    }
+  }
   return name.charAt(0).toLowerCase() + name.slice(1);
 }
 function generateAuthField(scheme) {
@@ -228,6 +237,33 @@ ${lines.join(`
 }
 `;
 }
+function collectCircularRefs(schema, refs = new Set) {
+  if (typeof schema.$circular === "string") {
+    refs.add(schema.$circular);
+    return refs;
+  }
+  if (Array.isArray(schema.anyOf)) {
+    for (const member of schema.anyOf) {
+      collectCircularRefs(member, refs);
+    }
+  }
+  if (Array.isArray(schema.oneOf)) {
+    for (const member of schema.oneOf) {
+      collectCircularRefs(member, refs);
+    }
+  }
+  if (schema.type === "array" && schema.items && typeof schema.items === "object") {
+    collectCircularRefs(schema.items, refs);
+  }
+  if (schema.properties && typeof schema.properties === "object") {
+    for (const propSchema of Object.values(schema.properties)) {
+      if (propSchema && typeof propSchema === "object") {
+        collectCircularRefs(propSchema, refs);
+      }
+    }
+  }
+  return refs;
+}
 function mapPrimitive(type) {
   if (type === "string")
     return "string";
@@ -241,14 +277,26 @@ var VALID_IDENTIFIER = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
 function isValidIdentifier(name) {
   return VALID_IDENTIFIER.test(name);
 }
+function toPascalCase(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9]+/g, " ").trim();
+  if (!cleaned)
+    return "_";
+  const segments = cleaned.split(/\s+/).filter(Boolean);
+  const result = segments.map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  return /^[0-9]/.test(result) ? `_${result}` : result;
+}
+function getTypePrefix(op) {
+  return op.typePrefix ?? toPascalCase(op.operationId);
+}
 
 // src/generators/resource-generator.ts
-function generateResources(resources) {
+function generateResources(resources, schemas = []) {
   const files = [];
+  const componentNames = new Set(schemas.filter((s) => s.name).map((s) => s.name));
   for (const resource of resources) {
     files.push({
       path: `resources/${resource.identifier}.ts`,
-      content: generateResourceFile(resource)
+      content: generateResourceFile(resource, componentNames)
     });
   }
   const exports = resources.map((r) => `export { create${r.name}Resource } from './${r.identifier}';`).join(`
@@ -257,12 +305,16 @@ function generateResources(resources) {
 ` });
   return files;
 }
-function generateResourceFile(resource) {
+function generateResourceFile(resource, componentNames) {
   const lines = [];
-  const typeImports = collectTypeImports(resource);
+  const { resourceImports, componentImports } = collectTypeImports(resource, componentNames);
   lines.push("import type { FetchClient, FetchResponse } from '@vertz/fetch';");
-  if (typeImports.size > 0) {
-    const sorted = [...typeImports].sort();
+  if (componentImports.size > 0) {
+    const sorted = [...componentImports].sort();
+    lines.push(`import type { ${sorted.join(", ")} } from '../types/components';`);
+  }
+  if (resourceImports.size > 0) {
+    const sorted = [...resourceImports].sort();
     lines.push(`import type { ${sorted.join(", ")} } from '../types/${resource.identifier}';`);
   }
   lines.push("");
@@ -270,7 +322,23 @@ function generateResourceFile(resource) {
   lines.push("  return {");
   validateUniqueMethodNames(resource);
   for (const op of resource.operations) {
-    lines.push(`    ${generateMethod(op)},`);
+    if (op.streamingFormat && op.jsonResponse) {
+      const jsonOp = {
+        ...op,
+        streamingFormat: undefined,
+        jsonResponse: undefined,
+        response: op.jsonResponse
+      };
+      lines.push(`    ${generateMethod(jsonOp)},`);
+      const streamOp = {
+        ...op,
+        methodName: op.methodName + "Stream",
+        jsonResponse: undefined
+      };
+      lines.push(`    ${generateMethod(streamOp)},`);
+    } else {
+      lines.push(`    ${generateMethod(op)},`);
+    }
   }
   lines.push("  };");
   lines.push("}");
@@ -281,6 +349,12 @@ function generateResourceFile(resource) {
 function generateMethod(op) {
   const params = buildParams(op);
   const returnType = buildReturnType(op);
+  if (op.streamingFormat) {
+    const call2 = buildStreamingCall(op);
+    return `/** @throws {FetchError} on non-2xx response */
+    ${op.methodName}: (${params}): ${returnType} =>
+      ${call2}`;
+  }
   const call = buildCall(op);
   return `${op.methodName}: (${params}): ${returnType} =>
       ${call}`;
@@ -296,14 +370,24 @@ function validateUniqueMethodNames(resource) {
     }
   }
   const duplicates = [...seen.entries()].filter(([, ids]) => ids.length > 1);
-  if (duplicates.length === 0)
-    return;
-  const details = duplicates.map(([name, ids]) => `  - "${name}" used by: ${ids.join(", ")}`).join(`
+  if (duplicates.length > 0) {
+    const details = duplicates.map(([name, ids]) => `  - "${name}" used by: ${ids.join(", ")}`).join(`
 `);
-  throw new Error(`Duplicate method name${duplicates.length > 1 ? "s" : ""} ${duplicates.map(([n]) => `"${n}"`).join(", ")} in resource "${resource.name}". ` + `Each operation within a resource must have a unique method name.
+    const rawTags = [...new Set(resource.operations.flatMap((op) => op.tags))];
+    const tagHint = rawTags.length > 0 ? ` (tags: ${rawTags.map((t) => `"${t}"`).join(", ")})` : "";
+    throw new Error(`Duplicate method name${duplicates.length > 1 ? "s" : ""} ${duplicates.map(([n]) => `"${n}"`).join(", ")} in resource "${resource.name}"${tagHint}. ` + `Each operation within a resource must have a unique method name.
 ${details}
 
 ` + `Fix: use excludeTags to skip this tag, use a different groupBy strategy, ` + `or provide operationIds.overrides to rename conflicting operations.`);
+  }
+  for (const op of resource.operations) {
+    if (op.streamingFormat && op.jsonResponse) {
+      const streamName = op.methodName + "Stream";
+      if (seen.has(streamName)) {
+        throw new Error(`Method name collision: dual-content operation "${op.operationId}" generates ` + `"${streamName}" which conflicts with existing method "${streamName}" in resource "${resource.name}".`);
+      }
+    }
+  }
 }
 function buildParams(op) {
   const parts = [];
@@ -318,9 +402,16 @@ function buildParams(op) {
     const queryName = deriveQueryName(op);
     parts.push(`query?: ${queryName}`);
   }
+  if (op.streamingFormat) {
+    parts.push("options?: { signal?: AbortSignal }");
+  }
   return parts.join(", ");
 }
 function buildReturnType(op) {
+  if (op.streamingFormat) {
+    const typeName = deriveStreamingTypeName(op);
+    return `AsyncGenerator<${typeName}>`;
+  }
   if (op.responseStatus === 204)
     return "Promise<FetchResponse<void>>";
   if (op.response?.name) {
@@ -334,7 +425,7 @@ function buildReturnType(op) {
     return "Promise<FetchResponse<unknown[]>>";
   }
   if (op.response) {
-    const name = capitalize(op.operationId) + "Response";
+    const name = getTypePrefix(op) + "Response";
     return `Promise<FetchResponse<${name}>>`;
   }
   return "Promise<FetchResponse<void>>";
@@ -351,6 +442,28 @@ function buildCall(op) {
   }
   return `client.${method}(${args.join(", ")})`;
 }
+function buildStreamingCall(op) {
+  const typeName = deriveStreamingTypeName(op);
+  const path = buildPath(op);
+  const props = [
+    `method: '${op.method}'`,
+    `path: ${path}`,
+    `format: '${op.streamingFormat}'`
+  ];
+  if (op.requestBody)
+    props.push("body");
+  if (op.queryParams.length > 0)
+    props.push("query");
+  props.push("signal: options?.signal");
+  return `client.requestStream<${typeName}>({ ${props.join(", ")} })`;
+}
+function deriveStreamingTypeName(op) {
+  if (op.response?.name)
+    return sanitizeTypeName(op.response.name);
+  if (op.response)
+    return toPascalCase(op.operationId) + "Event";
+  return "unknown";
+}
 function buildPath(op) {
   if (op.pathParams.length === 0) {
     return `'${op.path}'`;
@@ -361,35 +474,70 @@ function buildPath(op) {
   }
   return `\`${path}\``;
 }
-function collectTypeImports(resource) {
-  const types = new Set;
+function collectTypeImports(resource, componentNames) {
+  const resourceImports = new Set;
+  const componentImports = new Set;
   for (const op of resource.operations) {
+    if (op.response) {
+      for (const ref of collectCircularRefs(op.response.jsonSchema)) {
+        if (componentNames.has(ref))
+          componentImports.add(ref);
+      }
+    }
+    if (op.requestBody) {
+      for (const ref of collectCircularRefs(op.requestBody.jsonSchema)) {
+        if (componentNames.has(ref))
+          componentImports.add(ref);
+      }
+    }
     if (op.responseStatus !== 204 && op.response) {
-      if (op.response.name) {
-        types.add(sanitizeTypeName(op.response.name));
+      if (op.streamingFormat) {
+        const streamTypeName = deriveStreamingTypeName(op);
+        if (streamTypeName !== "unknown") {
+          if (componentNames.has(streamTypeName)) {
+            componentImports.add(streamTypeName);
+          } else {
+            resourceImports.add(streamTypeName);
+          }
+        }
+      } else {
+        const name = op.response.name ? sanitizeTypeName(op.response.name) : getTypePrefix(op) + "Response";
+        if (componentNames.has(name)) {
+          componentImports.add(name);
+        } else {
+          resourceImports.add(name);
+        }
+      }
+    }
+    if (op.jsonResponse) {
+      const name = op.jsonResponse.name ? sanitizeTypeName(op.jsonResponse.name) : getTypePrefix(op) + "Response";
+      if (componentNames.has(name)) {
+        componentImports.add(name);
       } else {
-        types.add(capitalize(op.operationId) + "Response");
+        resourceImports.add(name);
       }
     }
     if (op.requestBody) {
-      types.add(deriveInputName(op));
+      const name = deriveInputName(op);
+      if (componentNames.has(name)) {
+        componentImports.add(name);
+      } else {
+        resourceImports.add(name);
+      }
     }
     if (op.queryParams.length > 0) {
-      types.add(deriveQueryName(op));
+      resourceImports.add(deriveQueryName(op));
     }
   }
-  return types;
+  return { resourceImports, componentImports };
 }
 function deriveInputName(op) {
   if (op.requestBody?.name)
     return sanitizeTypeName(op.requestBody.name);
-  return capitalize(op.operationId) + "Input";
+  return getTypePrefix(op) + "Input";
 }
 function deriveQueryName(op) {
-  return capitalize(op.operationId) + "Query";
-}
-function capitalize(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
+  return getTypePrefix(op) + "Query";
 }
 
 // src/generators/json-schema-to-zod.ts
@@ -534,13 +682,25 @@ function zodPrimitive(type, schema) {
 function generateSchemas(resources, schemas) {
   const files = [];
   const namedSchemas = buildNamedSchemaMap(schemas);
+  if (schemas.length > 0) {
+    files.push({
+      path: "schemas/components.ts",
+      content: generateComponentSchemas(schemas, namedSchemas)
+    });
+  }
   for (const resource of resources) {
     const content = generateResourceSchemas(resource, namedSchemas);
     files.push({ path: `schemas/${resource.identifier}.ts`, content });
   }
-  const exports = resources.map((r) => `export * from './${r.identifier}';`).join(`
-`);
-  files.push({ path: "schemas/index.ts", content: exports + `
+  const barrelLines = [];
+  if (schemas.length > 0) {
+    barrelLines.push("export * from './components';");
+  }
+  for (const r of resources) {
+    barrelLines.push(`export * from './${r.identifier}';`);
+  }
+  files.push({ path: "schemas/index.ts", content: barrelLines.join(`
+`) + `
 ` });
   return files;
 }
@@ -553,30 +713,51 @@ function buildNamedSchemaMap(schemas) {
   }
   return map;
 }
+function generateComponentSchemas(schemas, namedSchemas) {
+  const lines = [];
+  lines.push("import { z } from 'zod';");
+  lines.push("");
+  for (const s of schemas) {
+    if (s.name) {
+      const varName = toSchemaVarName(s.name);
+      const zod = jsonSchemaToZod(s.jsonSchema, namedSchemas);
+      lines.push(`export const ${varName} = ${zod};`);
+      lines.push("");
+    }
+  }
+  return lines.join(`
+`);
+}
 function generateResourceSchemas(resource, namedSchemas) {
   const lines = [];
   lines.push("import { z } from 'zod';");
   lines.push("");
   const emitted = new Set;
+  const componentImports = new Set;
   for (const op of resource.operations) {
+    collectOperationComponentRefs(op, componentImports, namedSchemas);
     if (op.response) {
       const varName = deriveResponseSchemaName(op);
       if (!emitted.has(varName)) {
         emitted.add(varName);
-        const schema = op.response.jsonSchema;
-        const effectiveSchema = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : schema;
-        const zod = jsonSchemaToZod(effectiveSchema, namedSchemas);
-        lines.push(`export const ${varName} = ${zod};`);
-        lines.push("");
+        if (!isComponentSchemaVar(varName, namedSchemas)) {
+          const schema = op.response.jsonSchema;
+          const effectiveSchema = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : schema;
+          const zod = jsonSchemaToZod(effectiveSchema, namedSchemas);
+          lines.push(`export const ${varName} = ${zod};`);
+          lines.push("");
+        }
       }
     }
     if (op.requestBody) {
       const varName = deriveInputSchemaName(op);
       if (!emitted.has(varName)) {
         emitted.add(varName);
-        const zod = jsonSchemaToZod(op.requestBody.jsonSchema, namedSchemas);
-        lines.push(`export const ${varName} = ${zod};`);
-        lines.push("");
+        if (!isComponentSchemaVar(varName, namedSchemas)) {
+          const zod = jsonSchemaToZod(op.requestBody.jsonSchema, namedSchemas);
+          lines.push(`export const ${varName} = ${zod};`);
+          lines.push("");
+        }
       }
     }
     if (op.queryParams.length > 0) {
@@ -588,9 +769,37 @@ function generateResourceSchemas(resource, namedSchemas) {
       }
     }
   }
+  const actualImports = [...componentImports].sort();
+  if (actualImports.length > 0) {
+    lines.splice(2, 0, `import { ${actualImports.join(", ")} } from './components';`, "");
+  }
   return lines.join(`
 `);
 }
+function collectOperationComponentRefs(op, imports, namedSchemas) {
+  const schemas = [];
+  if (op.response)
+    schemas.push(op.response.jsonSchema);
+  if (op.requestBody)
+    schemas.push(op.requestBody.jsonSchema);
+  for (const param of op.queryParams)
+    schemas.push(param.schema);
+  for (const schema of schemas) {
+    const refs = collectCircularRefs(schema);
+    for (const ref of refs) {
+      const varName = namedSchemas.get(ref);
+      if (varName)
+        imports.add(varName);
+    }
+  }
+}
+function isComponentSchemaVar(varName, namedSchemas) {
+  for (const componentVarName of namedSchemas.values()) {
+    if (componentVarName === varName)
+      return true;
+  }
+  return false;
+}
 function buildQueryZodSchema(op, namedSchemas) {
   const entries = op.queryParams.map((param) => {
     let zod = jsonSchemaToZod(param.schema, namedSchemas);
@@ -607,18 +816,19 @@ ${entries.join(`,
 function deriveResponseSchemaName(op) {
   if (op.response?.name)
     return toSchemaVarName(op.response.name);
-  return toSchemaVarName(op.operationId + "Response");
+  return toSchemaVarName(getTypePrefix(op) + "Response");
 }
 function deriveInputSchemaName(op) {
   if (op.requestBody?.name)
     return toSchemaVarName(op.requestBody.name);
-  return toSchemaVarName(op.operationId + "Input");
+  return toSchemaVarName(getTypePrefix(op) + "Input");
 }
 function deriveQuerySchemaName(op) {
-  return toSchemaVarName(op.operationId + "Query");
+  return toSchemaVarName(getTypePrefix(op) + "Query");
 }
 function toSchemaVarName(name) {
-  const camel = name.charAt(0).toLowerCase() + name.slice(1);
+  const sanitized = sanitizeTypeName(name);
+  const camel = sanitized.charAt(0).toLowerCase() + sanitized.slice(1);
   return camel + "Schema";
 }
 
@@ -626,13 +836,25 @@ function toSchemaVarName(name) {
 function generateTypes(resources, schemas) {
   const files = [];
   const namedSchemas = buildNamedSchemaMap2(schemas);
+  if (schemas.length > 0) {
+    files.push({
+      path: "types/components.ts",
+      content: generateComponentTypes(schemas, namedSchemas)
+    });
+  }
   for (const resource of resources) {
     const content = generateResourceTypes(resource, namedSchemas);
     files.push({ path: `types/${resource.identifier}.ts`, content: content || "" });
   }
-  const exports = resources.map((r) => `export * from './${r.identifier}';`).join(`
-`);
-  files.push({ path: "types/index.ts", content: exports + `
+  const barrelLines = [];
+  if (schemas.length > 0) {
+    barrelLines.push("export * from './components';");
+  }
+  for (const r of resources) {
+    barrelLines.push(`export * from './${r.identifier}';`);
+  }
+  files.push({ path: "types/index.ts", content: barrelLines.join(`
+`) + `
 ` });
   return files;
 }
@@ -645,24 +867,44 @@ function buildNamedSchemaMap2(schemas) {
   }
   return map;
 }
+function generateComponentTypes(schemas, namedSchemas) {
+  const interfaces = [];
+  for (const s of schemas) {
+    if (s.name) {
+      interfaces.push(generateInterface(s.name, s.jsonSchema, namedSchemas));
+    }
+  }
+  return interfaces.join(`
+`);
+}
 function generateResourceTypes(resource, namedSchemas) {
   const interfaces = [];
   const emitted = new Set;
+  const componentImports = new Set;
   for (const op of resource.operations) {
+    collectOperationCircularRefs(op, componentImports, namedSchemas);
     if (op.response) {
       const name = deriveResponseName(op);
       if (!emitted.has(name)) {
         emitted.add(name);
-        const schema = op.response.jsonSchema;
-        const effectiveSchema = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : schema;
-        interfaces.push(generateInterface(name, effectiveSchema, namedSchemas));
+        if (namedSchemas.has(name)) {
+          componentImports.add(name);
+        } else {
+          const schema = op.response.jsonSchema;
+          const effectiveSchema = schema.type === "array" && schema.items && typeof schema.items === "object" ? schema.items : schema;
+          interfaces.push(generateInterface(name, effectiveSchema, namedSchemas));
+        }
       }
     }
     if (op.requestBody) {
       const name = deriveInputName2(op);
       if (!emitted.has(name)) {
         emitted.add(name);
-        interfaces.push(generateInterface(name, op.requestBody.jsonSchema, namedSchemas));
+        if (namedSchemas.has(name)) {
+          componentImports.add(name);
+        } else {
+          interfaces.push(generateInterface(name, op.requestBody.jsonSchema, namedSchemas));
+        }
       }
     }
     if (op.queryParams.length > 0) {
@@ -673,21 +915,52 @@ function generateResourceTypes(resource, namedSchemas) {
       }
     }
   }
-  return interfaces.join(`
+  const lines = [];
+  const actualImports = [...componentImports].filter((name) => namedSchemas.has(name)).sort();
+  if (actualImports.length > 0) {
+    lines.push(`import type { ${actualImports.join(", ")} } from './components';`);
+    lines.push("");
+  }
+  lines.push(interfaces.join(`
+`));
+  return lines.join(`
 `);
 }
+function collectOperationCircularRefs(op, imports, namedSchemas) {
+  if (op.response) {
+    const refs = collectCircularRefs(op.response.jsonSchema);
+    for (const ref of refs) {
+      if (namedSchemas.has(ref))
+        imports.add(ref);
+    }
+  }
+  if (op.requestBody) {
+    const refs = collectCircularRefs(op.requestBody.jsonSchema);
+    for (const ref of refs) {
+      if (namedSchemas.has(ref))
+        imports.add(ref);
+    }
+  }
+  for (const param of op.queryParams) {
+    const refs = collectCircularRefs(param.schema);
+    for (const ref of refs) {
+      if (namedSchemas.has(ref))
+        imports.add(ref);
+    }
+  }
+}
 function deriveResponseName(op) {
   if (op.response?.name)
     return sanitizeTypeName(op.response.name);
-  return capitalize2(op.operationId) + "Response";
+  return getTypePrefix(op) + "Response";
 }
 function deriveInputName2(op) {
   if (op.requestBody?.name)
     return sanitizeTypeName(op.requestBody.name);
-  return capitalize2(op.operationId) + "Input";
+  return getTypePrefix(op) + "Input";
 }
 function deriveQueryName2(op) {
-  return capitalize2(op.operationId) + "Query";
+  return getTypePrefix(op) + "Query";
 }
 function generateQueryInterface(name, op, namedSchemas) {
   const lines = op.queryParams.map((param) => {
@@ -696,15 +969,13 @@ function generateQueryInterface(name, op, namedSchemas) {
     const safeKey = isValidIdentifier(param.name) ? param.name : `'${param.name.replace(/'/g, "\\'")}'`;
     return `  ${safeKey}${optional}: ${tsType};`;
   });
+  lines.push("  [key: string]: unknown;");
   return `export interface ${sanitizeTypeName(name)} {
 ${lines.join(`
 `)}
 }
 `;
 }
-function capitalize2(s) {
-  return s.charAt(0).toUpperCase() + s.slice(1);
-}
 
 // src/generators/index.ts
 function generateAll(spec, options) {
@@ -712,7 +983,7 @@ function generateAll(spec, options) {
   const opts = { schemas: false, baseURL: "", ...options };
   const files = [];
   files.push(...generateTypes(resources, schemas));
-  files.push(...generateResources(resources));
+  files.push(...generateResources(resources, schemas));
   files.push(generateClient(resources, {
     baseURL: opts.baseURL,
     securitySchemes: spec.securitySchemes
@@ -930,6 +1201,50 @@ function detectCrudMethod(method, path) {
   }
   return;
 }
+function deriveTypePrefix(operationId, path) {
+  const withoutController = operationId.replace(/^[A-Za-z0-9]+Controller[_.-]+/, "");
+  const words = splitWords2(withoutController).map((w) => w.toLowerCase());
+  if (words.length > 1 && words.at(-1) && HTTP_METHOD_WORDS.has(words.at(-1))) {
+    words.pop();
+  }
+  const pathWordList = [];
+  for (const segment of getPathSegments(path)) {
+    const name = isPathParam(segment) ? segment.slice(1, -1) : segment;
+    for (const w of splitWords2(name)) {
+      pathWordList.push(w.toLowerCase());
+    }
+  }
+  const cutIndex = findPathSuffixStart(words, pathWordList);
+  const meaningful = cutIndex >= 2 ? words.slice(0, cutIndex) : words;
+  return meaningful.map((w) => w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function findPathSuffixStart(words, pathWords) {
+  if (pathWords.length === 0)
+    return words.length;
+  for (let start = 1;start < words.length; start++) {
+    if (isSuffixMatchingPath(words, start, pathWords)) {
+      return start;
+    }
+  }
+  return words.length;
+}
+function isSuffixMatchingPath(words, start, pathWords) {
+  let pathIdx = 0;
+  for (let i = start;i < words.length; i++) {
+    let found = false;
+    while (pathIdx < pathWords.length) {
+      if (words[i] === pathWords[pathIdx]) {
+        pathIdx++;
+        found = true;
+        break;
+      }
+      pathIdx++;
+    }
+    if (!found)
+      return false;
+  }
+  return true;
+}
 function normalizeOperationId(operationId, method, path, config, context) {
   if (config?.overrides?.[operationId]) {
     return config.overrides[operationId];
@@ -1130,6 +1445,20 @@ function getJsonContentSchema(value) {
   }
   return mediaType.schema;
 }
+function getStreamingContentSchema(value) {
+  if (!isRecord2(value) || !isRecord2(value.content)) {
+    return;
+  }
+  const sse = value.content["text/event-stream"];
+  if (isRecord2(sse)) {
+    return { schema: isRecord2(sse.schema) ? sse.schema : undefined, format: "sse" };
+  }
+  const ndjson = value.content["application/x-ndjson"];
+  if (isRecord2(ndjson)) {
+    return { schema: isRecord2(ndjson.schema) ? ndjson.schema : undefined, format: "ndjson" };
+  }
+  return;
+}
 function extractRefName(schema) {
   if (typeof schema.$ref === "string") {
     const segments = schema.$ref.split("/");
@@ -1163,9 +1492,26 @@ function pickSuccessResponse(operation, spec) {
     return { status: 200 };
   }
   const resolvedResponse = resolveOpenAPIObject(first.response, spec);
+  const jsonSchema = getJsonContentSchema(resolvedResponse);
+  const streaming = getStreamingContentSchema(resolvedResponse);
+  if (streaming && jsonSchema) {
+    return {
+      status: first.status,
+      schema: jsonSchema,
+      streamingFormat: streaming.format,
+      streamingSchema: streaming.schema
+    };
+  }
+  if (streaming) {
+    return {
+      status: first.status,
+      schema: streaming.schema,
+      streamingFormat: streaming.format
+    };
+  }
   return {
     status: first.status,
-    schema: getJsonContentSchema(resolvedResponse)
+    schema: jsonSchema
   };
 }
 function getCombinedParameters(pathItem, operation, spec) {
@@ -1300,6 +1646,7 @@ function parseOpenAPI(spec) {
       const parsed = {
         operationId,
         methodName: normalizeOperationId(operationId, method.toUpperCase(), path),
+        typePrefix: deriveTypePrefix(operationId, path),
         method: method.toUpperCase(),
         path,
         pathParams,
@@ -1311,9 +1658,17 @@ function parseOpenAPI(spec) {
       };
       if (security)
         parsed.security = security;
+      if (successResponse.streamingFormat) {
+        parsed.streamingFormat = successResponse.streamingFormat;
+        if (successResponse.streamingSchema) {
+          parsed.response = resolveSchemaForOutput(successResponse.streamingSchema, spec, version);
+          parsed.jsonResponse = successResponse.schema ? resolveSchemaForOutput(successResponse.schema, spec, version) : undefined;
+        }
+      }
       operations.push(parsed);
     }
   }
+  deduplicateTypePrefixes(operations);
   return {
     operations,
     schemas: collectComponentSchemas(spec, version),
@@ -1321,6 +1676,26 @@ function parseOpenAPI(spec) {
     version
   };
 }
+function deduplicateTypePrefixes(operations) {
+  const seen = new Map;
+  for (const op of operations) {
+    if (!op.typePrefix)
+      continue;
+    const existing = seen.get(op.typePrefix);
+    if (existing) {
+      existing.push(op);
+    } else {
+      seen.set(op.typePrefix, [op]);
+    }
+  }
+  for (const [, ops] of seen) {
+    if (ops.length > 1) {
+      for (const op of ops) {
+        op.typePrefix = undefined;
+      }
+    }
+  }
+}
 
 // src/writer/incremental.ts
 import { createHash } from "node:crypto";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertz/openapi",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "OpenAPI 3.x parser and TypeScript SDK generator for Vertz",
   "license": "MIT",
   "repository": {