@apollo-deploy/tesseract 1.9.0 → 2.0.0

package/dist/pipeline/intake.js

@@ -3,10 +3,10 @@
  *
  * This is the only intake path in Tesseract. No OpenAPI parsing.
  */
-import { readFileSync } from "node:fs";
-import { camelCase, pascalCase, kebabCase } from "change-case";
-import { deriveCleanMethodName } from "../utils/naming.js";
-import { validateManifest } from "../types/manifest.js";
+import { readFileSync } from 'node:fs';
+import { camelCase, pascalCase, kebabCase } from 'change-case';
+import { deriveCleanMethodName } from '../utils/naming.js';
+import { validateManifest } from '../types/manifest.js';
 // ── Entry point ──────────────────────────────────────────────────────────────
 export function intake(config) {
     let manifest;
@@ -15,17 +15,16 @@ export function intake(config) {
     }
     else {
         try {
-            const raw = readFileSync(config.input, "utf-8");
-            manifest = JSON.parse(raw);
+            manifest = JSON.parse(readFileSync(config.input, 'utf8'));
         }
-        catch (err) {
-            throw new Error(`Failed to read manifest at "${config.input}": ${err instanceof Error ? err.message : String(err)}`);
-        }
-        const validation = validateManifest(manifest);
-        if (!validation.valid) {
-            throw new Error(`Invalid manifest:\n  ${validation.errors.join("\n  ")}`);
+        catch (error) {
+            throw new Error(`Failed to read manifest at "${config.input}": ${error instanceof Error ? error.message : String(error)}`);
         }
     }
+    const validation = validateManifest(manifest);
+    if (!validation.valid) {
+        throw new Error(`Invalid manifest:\n  ${validation.errors.join('\n  ')}`);
+    }
     const schemaPackage = manifest.schemaPackage;
     const importPath = schemaPackage?.importPath ?? schemaPackage?.name;
     const externalRefNames = schemaPackage
@@ -38,11 +37,12 @@ export function intake(config) {
             isEnum: false,
             properties: [],
             ownership: {
-                kind: "external",
+                kind: 'external',
                 externalImport: {
                     packageName: schemaPackage.name,
                     importPath: importPath,
                     exportName: name,
+                    version: schemaPackage.version,
                 },
             },
         }))
@@ -56,7 +56,7 @@ export function intake(config) {
     const groups = [];
     const allInlineSchemas = [];
     for (const domain of manifest.domains) {
-        const { group, inlineSchemas } = buildOperationGroup(domain, schemas);
+        const { group, inlineSchemas } = buildOperationGroup(domain);
         groups.push(group);
         allInlineSchemas.push(...inlineSchemas);
     }
@@ -67,8 +67,9 @@ export function intake(config) {
         // Only set packageVersion when the caller explicitly supplied it.
         // When undefined the TypeScript adapter queries npm and bumps the patch.
         packageVersion: config.packageVersion,
+        versionBump: config.versionBump ?? manifest.info.versionBump ?? 'patch',
         description: manifest.info.description,
-        baseUrl: config.baseUrl ?? manifest.info.baseUrl ?? "http://localhost",
+        baseUrl: config.baseUrl ?? manifest.info.baseUrl ?? 'http://localhost',
         packageName: config.packageName ?? kebabCase(manifest.info.title).toLowerCase(),
         clientName: config.clientName ?? pascalCase(manifest.info.title),
         schemaPackage: schemaPackage
@@ -101,19 +102,68 @@ function collectExternalRefNames(manifest) {
                     scanSchemaForExternalRefs(resp, names);
                 }
             }
-            // Register sseReturnType as an external ref so it gets an import stub
-            if (route.sdk?.sseReturnType) {
-                names.add(pascalCase(route.sdk.sseReturnType));
-            }
+            collectNamedTypes(route.sdk?.sseReturnType, names);
+            collectNamedTypes(route.sdk?.returnType, names);
+        }
+    }
+    // Transitively pull nested refs from matching definitions (e.g. Pet → Tag)
+    // so dependent models are also imported from schemaPackage instead of
+    // regenerated locally.
+    const definitions = manifest.definitions ?? {};
+    const defByName = new Map(Object.entries(definitions).map(([k, v]) => [
+        pascalCase(k),
+        v,
+    ]));
+    let growing = true;
+    while (growing) {
+        growing = false;
+        for (const name of [...names]) {
+            const def = defByName.get(name);
+            if (!def)
+                continue;
+            const before = names.size;
+            scanSchemaForExternalRefs(def, names);
+            if (names.size > before)
+                growing = true;
         }
     }
     return names;
 }
+const BUILT_IN_TYPES = new Set([
+    'Array',
+    'Record',
+    'Promise',
+    'AsyncIterable',
+    'SSEEvent',
+    'Date',
+    'ReadonlyArray',
+    'Map',
+    'Set',
+    'Partial',
+    'Pick',
+    'Omit',
+    'Required',
+    'Readonly',
+]);
+function collectNamedTypes(type, out) {
+    if (!type)
+        return;
+    const unquoted = type.replace(/(["'`])(?:\\.|(?!\1).)*\1/g, '');
+    for (const name of unquoted.match(/\b[A-Z][A-Za-z0-9_]*\b/g) ?? []) {
+        if (!BUILT_IN_TYPES.has(name))
+            out.add(name);
+    }
+}
 function scanSchemaForExternalRefs(schema, out) {
     const s = schema;
-    if (typeof s.$ref === "string") {
-        if (!s.$ref.startsWith("#")) {
-            out.add(pascalCase(s.$ref.split("/").pop()));
+    if (typeof s.$ref === 'string') {
+        // Bare refs (`User`) and local definition refs (`#/definitions/User`,
+        // `#/$defs/User`) all resolve to a named type. When schemaPackage is set,
+        // intake treats those names as external imports instead of regenerating.
+        const ref = s.$ref;
+        const isLocalDef = ref.startsWith('#/definitions/') || ref.startsWith('#/$defs/');
+        if (!ref.startsWith('#') || isLocalDef) {
+            out.add(pascalCase(ref.split('/').pop()));
         }
         return;
     }
@@ -122,12 +172,12 @@ function scanSchemaForExternalRefs(schema, out) {
         for (const v of Object.values(props))
             scanSchemaForExternalRefs(v, out);
     }
-    if (s.additionalProperties && typeof s.additionalProperties === "object") {
+    if (s.additionalProperties && typeof s.additionalProperties === 'object') {
         scanSchemaForExternalRefs(s.additionalProperties, out);
     }
     if (s.items)
         scanSchemaForExternalRefs(s.items, out);
-    for (const key of ["allOf", "oneOf", "anyOf"]) {
+    for (const key of ['allOf', 'oneOf', 'anyOf']) {
         const arr = s[key];
         if (Array.isArray(arr)) {
             for (const m of arr)
@@ -141,17 +191,28 @@ function buildSchemas(definitions) {
 }
 function jsonSchemaToDefinition(name, schema) {
     const s = schema;
-    if ("enum" in s && Array.isArray(s.enum)) {
+    if ('enum' in s && Array.isArray(s.enum)) {
+        const values = s.enum;
+        if (values.every((value) => typeof value === 'string' || typeof value === 'number')) {
+            return {
+                name,
+                description: s.description,
+                isEnum: true,
+                enumValues: values,
+                properties: [],
+            };
+        }
         return {
             name,
             description: s.description,
-            isEnum: true,
-            enumValues: s.enum.filter((v) => v !== null),
+            isEnum: false,
+            isUnionType: true,
+            unionMembers: [...new Set(values.map((value) => JSON.stringify(value)))],
             properties: [],
             isTypeAlias: true,
         };
     }
-    if ("oneOf" in s && Array.isArray(s.oneOf)) {
+    if ('oneOf' in s && Array.isArray(s.oneOf)) {
         return {
             name,
             description: s.description,
@@ -162,7 +223,7 @@ function jsonSchemaToDefinition(name, schema) {
             isTypeAlias: true,
         };
     }
-    if ("anyOf" in s && Array.isArray(s.anyOf)) {
+    if ('anyOf' in s && Array.isArray(s.anyOf)) {
         return {
             name,
             description: s.description,
@@ -173,11 +234,11 @@ function jsonSchemaToDefinition(name, schema) {
             isTypeAlias: true,
         };
     }
-    if ("allOf" in s && Array.isArray(s.allOf)) {
+    if ('allOf' in s && Array.isArray(s.allOf)) {
         const members = s.allOf;
         if (members.length === 2) {
-            const refMember = members.find((m) => "$ref" in m);
-            const objectMember = members.find((m) => !("$ref" in m) && m.type === "object");
+            const refMember = members.find((m) => '$ref' in m);
+            const objectMember = members.find((m) => !('$ref' in m) && m.type === 'object');
             if (refMember && objectMember) {
                 const baseDef = jsonSchemaToDefinition(name, objectMember);
                 return { ...baseDef, extends: jsonSchemaToType(refMember) };
@@ -193,7 +254,7 @@ function jsonSchemaToDefinition(name, schema) {
             isTypeAlias: true,
         };
     }
-    if (s.type === "object") {
+    if (s.type === 'object') {
         const required = new Set(Array.isArray(s.required) ? s.required : []);
         const rawProps = s.properties ?? {};
         const properties = Object.entries(rawProps).map(([propName, propSchema]) => {
@@ -207,12 +268,16 @@ function jsonSchemaToDefinition(name, schema) {
                 format: ps.format,
                 readOnly: ps.readOnly,
                 writeOnly: ps.writeOnly,
+                deprecated: ps.deprecated,
+                defaultValue: ps.default,
             };
         });
         const ap = s.additionalProperties;
-        const additionalPropertiesType = ap && typeof ap === "object"
-            ? jsonSchemaToType(ap)
-            : undefined;
+        const additionalPropertiesType = ap === true
+            ? 'unknown'
+            : ap && typeof ap === 'object'
+                ? jsonSchemaToType(ap)
+                : undefined;
         return {
             name,
             description: s.description,
@@ -226,77 +291,102 @@ function jsonSchemaToDefinition(name, schema) {
         description: s.description,
         isEnum: false,
         isTypeAlias: true,
+        aliasType: jsonSchemaToType(schema),
         properties: [],
     };
 }
 // ── Type string conversion ───────────────────────────────────────────────────
 export function jsonSchemaToType(schema) {
-    const s = schema;
-    if ("$ref" in s && typeof s.$ref === "string") {
-        return pascalCase(s.$ref.split("/").pop());
+    const value = schema;
+    let type;
+    if (typeof value.$ref === 'string') {
+        type = pascalCase(value.$ref.split('/').pop());
     }
-    if ("enum" in s && Array.isArray(s.enum) && s.enum.length > 0) {
-        return s.enum.map((v) => JSON.stringify(v)).join(" | ");
+    else if (Array.isArray(value.enum) && value.enum.length > 0) {
+        type = [...new Set(value.enum.map((item) => JSON.stringify(item)))].join(' | ');
     }
-    if (Array.isArray(s.allOf))
-        return s.allOf.map(jsonSchemaToType).join(" & ");
-    if (Array.isArray(s.oneOf)) {
-        const members = [...new Set(s.oneOf.map(jsonSchemaToType).filter(Boolean))];
-        return members.join(" | ");
+    else if (Array.isArray(value.allOf)) {
+        type = uniqueTypes(value.allOf).join(' & ');
     }
-    if (Array.isArray(s.anyOf)) {
-        const members = [...new Set(s.anyOf.map(jsonSchemaToType).filter(Boolean))];
-        return members.join(" | ");
+    else if (Array.isArray(value.oneOf)) {
+        type = uniqueTypes(value.oneOf).join(' | ');
     }
-    const type = s.type;
-    if (type === "object") {
-        const required = new Set(Array.isArray(s.required) ? s.required : []);
-        const rawProps = s.properties;
-        if (rawProps) {
-            const entries = Object.entries(rawProps)
-                .map(([k, v]) => `${k}${required.has(k) ? "" : "?"}: ${jsonSchemaToType(v)}`)
-                .join("; ");
-            const ap = s.additionalProperties;
-            if (ap && typeof ap === "object") {
-                return `{ ${entries}; [key: string]: ${jsonSchemaToType(ap)} }`;
-            }
-            return entries ? `{ ${entries} }` : "Record<string, unknown>";
+    else if (Array.isArray(value.anyOf)) {
+        type = uniqueTypes(value.anyOf).join(' | ');
+    }
+    else {
+        type = schemaType(value);
+    }
+    if (value.nullable === true &&
+        !type.split('|').some((part) => part.trim() === 'null')) {
+        return `${type.includes('|') || type.includes('&') ? `(${type})` : type} | null`;
+    }
+    return type;
+}
+function uniqueTypes(schemas) {
+    return [...new Set(schemas.map(jsonSchemaToType))];
+}
+function schemaType(schema) {
+    switch (schema.type) {
+        case 'object':
+            return objectType(schema);
+        case 'array': {
+            const items = schema.items;
+            return `Array<${items ? jsonSchemaToType(items) : 'unknown'}>`;
+        }
+        case 'string':
+        case 'date':
+            return 'string';
+        case 'number':
+            return 'number';
+        case 'integer':
+            return 'integer';
+        case 'boolean':
+            return 'boolean';
+        case 'null':
+            return 'null';
+        case 'never':
+            return 'never';
+        case 'nullable': {
+            const definition = schema.def;
+            return definition?.innerType
+                ? `${jsonSchemaToType(definition.innerType)} | null`
+                : 'unknown | null';
         }
-        if (s.additionalProperties && typeof s.additionalProperties === "object") {
-            return `Record<string, ${jsonSchemaToType(s.additionalProperties)}>`;
+        case 'union': {
+            const options = schema.options;
+            return options ? uniqueTypes(options).join(' | ') : 'unknown';
         }
-        return "Record<string, unknown>";
-    }
-    if (type === "array") {
-        const items = s.items;
-        return `Array<${items ? jsonSchemaToType(items) : "unknown"}>`;
-    }
-    if (type === "string" || type === "date")
-        return "string";
-    if (type === "number" || type === "integer")
-        return "number";
-    if (type === "boolean")
-        return "boolean";
-    if (type === "null")
-        return "null";
-    if (type === "never")
-        return "never";
-    if (type === "nullable") {
-        const def = s.def;
-        if (def?.innerType)
-            return jsonSchemaToType(def.innerType) + " | null";
-        return "unknown | null";
-    }
-    if (type === "union") {
-        const options = s.options;
-        if (options)
-            return options.map(jsonSchemaToType).join(" | ");
-    }
-    return "unknown";
+        default:
+            return 'unknown';
+    }
+}
+function objectType(schema) {
+    const properties = schema.properties;
+    const additionalProperties = schema.additionalProperties;
+    if (!properties) {
+        return additionalProperties && typeof additionalProperties === 'object'
+            ? `Record<string, ${jsonSchemaToType(additionalProperties)}>`
+            : 'Record<string, unknown>';
+    }
+    const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+    const entries = Object.entries(properties).map(([name, property]) => `${typePropertyName(name)}${required.has(name) ? '' : '?'}: ${jsonSchemaToType(property)}`);
+    if (additionalProperties === true) {
+        entries.push('[key: string]: unknown');
+    }
+    else if (additionalProperties && typeof additionalProperties === 'object') {
+        entries.push(`[key: string]: ${jsonSchemaToType(additionalProperties)}`);
+    }
+    return entries.length
+        ? `{ ${entries.join('; ')} }`
+        : 'Record<string, unknown>';
+}
+function typePropertyName(name) {
+    return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name) ? name : JSON.stringify(name);
 }
 // ── Group / operation building ───────────────────────────────────────────────
 function isComplexInlineSchema(s) {
-    if (s.type === "object") {
+    if (s.type === 'object') {
         // An object with only additionalProperties (no explicit `properties`) is
         // representable as an inline `Record<string, V>` type — no need to hoist it
         // into a named inline schema, which would lose the response type entirely.
@@ -307,7 +397,7 @@ function isComplexInlineSchema(s) {
     if (Array.isArray(s.allOf))
         return true;
     // anyOf / oneOf that is just `SomeRef | null` is not complex — emit inline
-    for (const key of ["anyOf", "oneOf"]) {
+    for (const key of ['anyOf', 'oneOf']) {
         const arr = s[key];
         if (!Array.isArray(arr))
             continue;
@@ -321,12 +411,12 @@ function isComplexInlineSchema(s) {
 function isNullableRefUnion(members) {
     if (members.length !== 2)
         return false;
-    const refMember = members.find((m) => "$ref" in m);
-    const nullMember = members.find((m) => m.type === "null");
+    const refMember = members.find((m) => '$ref' in m);
+    const nullMember = members.find((m) => m.type === 'null');
     return !!refMember && !!nullMember;
 }
-function buildOperationGroup(domain, _schemas) {
-    const domainName = domain.domain ?? domain.prefix;
+function buildOperationGroup(domain) {
+    const domainName = domain.domain ?? domain.prefix.split('/').filter(Boolean).pop() ?? 'root';
     const name = camelCase(domainName);
     const fileName = domain.fileName ?? kebabCase(domainName);
     const allInlineSchemas = [];
@@ -337,12 +427,12 @@ function buildOperationGroup(domain, _schemas) {
         const { operation, inlineSchemas } = buildOperation(route, name, domain.prefix);
         operations.push({
             ...operation,
-            visibility: route.sdk?.internal ? "internal" : "public",
+            visibility: route.sdk?.internal ? 'internal' : 'public',
         });
         for (const s of inlineSchemas) {
             allInlineSchemas.push({
                 ...s,
-                ownership: { kind: "generated", domainFile: fileName },
+                ownership: { kind: 'generated', domainFile: fileName },
             });
         }
     }
@@ -350,20 +440,17 @@ function buildOperationGroup(domain, _schemas) {
         group: {
             name,
             fileName,
-            interfaceName: pascalCase(domainName) + "API",
-            factoryName: "create" + pascalCase(domainName) + "API",
+            interfaceName: pascalCase(domainName) + 'API',
+            factoryName: 'create' + pascalCase(domainName) + 'API',
             description: domain.description,
-            visibility: domain.stability === "internal" ? "internal" : "public",
+            visibility: domain.stability === 'internal' ? 'internal' : 'public',
             operations,
         },
         inlineSchemas: allInlineSchemas,
     };
 }
 function buildOperation(route, groupName, domainPrefix) {
-    const prefix = (route.sdk?.prefix ?? domainPrefix).replace(/\/$/, "");
-    // When route.url is '/' it means the route URL exactly matched the domain
-    // prefix — avoid doubling the slash (e.g. /signal/projects + / = /signal/projects/).
-    const fullUrl = route.url === "/" ? prefix || "/" : prefix + route.url;
+    const fullUrl = joinRoutePath(route.sdk?.prefix ?? domainPrefix, route.url);
     const httpMethod = (Array.isArray(route.method) ? route.method[0] : route.method).toUpperCase();
     const pathParams = extractPathParams(fullUrl, route.schema?.params);
     const querySchema = route.schema?.querystring ?? route.schema?.query;
@@ -372,32 +459,26 @@ function buildOperation(route, groupName, domainPrefix) {
     const inlineSchemas = [];
     const name = route.sdk?.methodName ??
         deriveCleanMethodName({
-            operationId: route.schema?.operationId ?? route.sdk?.operationId,
+            operationId: route.sdk?.operationId ?? route.schema?.operationId,
             summary: route.schema?.summary,
-            path: route.url.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, "{$1}"),
+            path: route.url.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, '{$1}'),
             httpMethod: httpMethod.toLowerCase(),
             tagName: groupName,
         });
     // Response type
-    let responseType = "void";
-    let statusCode = 200;
-    // SDK config override: explicit returnType takes priority over schema derivation.
-    // Useful for paginated list endpoints that return a wrapper but should expose the inner array type.
-    if (route.sdk?.returnType) {
-        responseType = route.sdk.returnType;
-    }
-    else {
-        const successResponse = pickSuccessResponse(route.schema?.response);
-        if (successResponse) {
-            const { schema: successSchema, statusCode: sc } = successResponse;
-            statusCode = sc;
-            const rs = successSchema;
-            if (rs.type === "null" ||
-                (rs.type === "object" && !rs.properties && !rs.$ref && !rs.additionalProperties)) {
-                responseType = "void";
-            }
-            else if (typeof rs.$ref !== "string" && isComplexInlineSchema(rs)) {
-                const typeName = pascalCase(name) + "Response";
+    const successResponse = pickSuccessResponse(route.schema?.response);
+    let statusCode = successResponse?.statusCode ?? 200;
+    let responseType = route.sdk?.returnType ?? 'void';
+    if (!route.sdk?.returnType && successResponse) {
+        const successSchema = successResponse.schema;
+        const schema = successSchema;
+        if (schema.type !== 'null' &&
+            !(schema.type === 'object' &&
+                !schema.properties &&
+                !schema.$ref &&
+                !schema.additionalProperties)) {
+            if (typeof schema.$ref !== 'string' && isComplexInlineSchema(schema)) {
+                const typeName = `${pascalCase(name)}Response`;
                 inlineSchemas.push(jsonSchemaToDefinition(typeName, successSchema));
                 responseType = typeName;
             }
@@ -406,35 +487,47 @@ function buildOperation(route, groupName, domainPrefix) {
             }
         }
     }
-    // Request body
+    // Request body — empty object schemas (no properties / $ref / additionalProperties)
+    // are treated as "no body planned", matching void response handling. Domain
+    // templates still emit an empty JSON body (`{}`) for body-capable methods.
     let requestBody;
     if (route.schema?.body) {
         const bodySchema = route.schema.body;
         const bs = bodySchema;
-        let bodyType;
-        if (typeof bs.$ref !== "string" && isComplexInlineSchema(bs)) {
-            const typeName = pascalCase(name) + "Input";
-            inlineSchemas.push(jsonSchemaToDefinition(typeName, bodySchema));
-            bodyType = typeName;
-        }
-        else {
-            bodyType = jsonSchemaToType(bodySchema);
+        const isEmptyBodySchema = bs.type === 'null' ||
+            (bs.type === 'object' &&
+                !bs.properties &&
+                !bs.$ref &&
+                !bs.additionalProperties &&
+                !bs.allOf &&
+                !bs.anyOf &&
+                !bs.oneOf);
+        if (!isEmptyBodySchema) {
+            let bodyType;
+            if (typeof bs.$ref !== 'string' && isComplexInlineSchema(bs)) {
+                const typeName = pascalCase(name) + 'Input';
+                inlineSchemas.push(jsonSchemaToDefinition(typeName, bodySchema));
+                bodyType = typeName;
+            }
+            else {
+                bodyType = jsonSchemaToType(bodySchema);
+            }
+            requestBody = {
+                type: bodyType,
+                required: true,
+                contentType: route.sdk?.transport === 'multipart'
+                    ? 'multipart/form-data'
+                    : route.sdk?.transport === 'binary'
+                        ? 'application/octet-stream'
+                        : (route.schema?.consumes?.[0] ?? 'application/json'),
+            };
         }
-        requestBody = {
-            type: bodyType,
-            required: true,
-            contentType: route.sdk?.transport === "multipart"
-                ? "multipart/form-data"
-                : route.sdk?.transport === "binary"
-                    ? "application/octet-stream"
-                    : "application/json",
-        };
     }
     // Query type
     let queryType;
     if (querySchema) {
         const qs = querySchema;
-        if (typeof qs.$ref === "string") {
+        if (typeof qs.$ref === 'string') {
             queryType = jsonSchemaToType(querySchema);
         }
         else if (queryParams.length > 0) {
@@ -443,31 +536,37 @@ function buildOperation(route, groupName, domainPrefix) {
     }
     // Required headers from sdk config
     if (route.sdk?.requiredHeaders) {
-        for (const rh of route.sdk.requiredHeaders) {
-            headerParams.push({
-                name: camelCase(rh.paramName),
-                originalName: rh.name,
-                type: "string",
+        for (const header of route.sdk.requiredHeaders) {
+            const existingIndex = headerParams.findIndex(({ originalName }) => originalName.toLowerCase() === header.name.toLowerCase());
+            const parameter = {
+                name: safeParamName(camelCase(header.paramName)),
+                originalName: header.name,
+                type: 'string',
                 required: true,
-                description: rh.description,
-            });
+                description: header.description,
+            };
+            if (existingIndex >= 0)
+                headerParams[existingIndex] = parameter;
+            else
+                headerParams.push(parameter);
         }
     }
     // Header type (inline object type from headerParams)
     let headerType;
     if (headerParams.length > 0) {
         const props = headerParams.map((p) => {
-            const opt = p.required ? "" : "?";
+            const opt = p.required ? '' : '?';
             return `${p.name}${opt}: ${p.type}`;
         });
-        headerType = `{ ${props.join("; ")} }`;
+        headerType = `{ ${props.join('; ')} }`;
     }
+    const isEventStream = route.sse ?? route.sdk?.transport === 'stream';
     return {
         operation: {
             name,
-            operationId: route.schema?.operationId ?? route.sdk?.operationId,
+            operationId: route.sdk?.operationId ?? route.schema?.operationId,
             summary: route.schema?.summary,
-            description: route.schema?.description ?? route.sdk?.description,
+            description: route.sdk?.description ?? route.schema?.description,
             httpMethod,
             path: fastifyPathToIR(fullUrl, pathParams),
             pathParams,
@@ -481,12 +580,13 @@ function buildOperation(route, groupName, domainPrefix) {
             responseType,
             statusCode,
             deprecated: route.sdk?.deprecated ? true : false,
-            deprecationMessage: typeof route.sdk?.deprecated === "string"
+            deprecationMessage: typeof route.sdk?.deprecated === 'string'
                 ? route.sdk.deprecated
                 : undefined,
             timeoutMs: route.sdk?.timeout,
-            visibility: "public",
-            isEventStream: route.sse ?? route.sdk?.transport === "stream",
+            visibility: 'public',
+            isEventStream,
+            eventSchema: isEventStream ? responseType : undefined,
             sseReturnType: route.sdk?.sseReturnType,
         },
         inlineSchemas,
@@ -494,61 +594,61 @@ function buildOperation(route, groupName, domainPrefix) {
 }
 // ── Parameter extraction ─────────────────────────────────────────────────────
 const TS_RESERVED_WORDS = new Set([
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "enum",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "new",
-    "null",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-    "as",
-    "implements",
-    "interface",
-    "let",
-    "package",
-    "private",
-    "protected",
-    "public",
-    "static",
-    "yield",
-    "type",
+    'break',
+    'case',
+    'catch',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'else',
+    'enum',
+    'export',
+    'extends',
+    'false',
+    'finally',
+    'for',
+    'function',
+    'if',
+    'import',
+    'in',
+    'instanceof',
+    'new',
+    'null',
+    'return',
+    'super',
+    'switch',
+    'this',
+    'throw',
+    'true',
+    'try',
+    'typeof',
+    'var',
+    'void',
+    'while',
+    'with',
+    'as',
+    'implements',
+    'interface',
+    'let',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'static',
+    'yield',
+    'type',
 ]);
 /** Parameter names reserved by the generated method signatures. */
 const FIXED_PARAM_NAMES = new Set([
-    "input",
-    "query",
-    "headerOptions",
-    "cookies",
-    "options",
+    'input',
+    'query',
+    'headerOptions',
+    'cookies',
+    'options',
 ]);
 function safeParamName(name) {
     if (TS_RESERVED_WORDS.has(name) || FIXED_PARAM_NAMES.has(name)) {
@@ -561,7 +661,7 @@ function extractPathParams(url, paramsSchema) {
     if (urlParams.length === 0)
         return [];
     const s = paramsSchema;
-    const props = typeof s?.properties === "object" && !Array.isArray(s?.properties)
+    const props = typeof s?.properties === 'object' && !Array.isArray(s?.properties)
         ? s.properties
         : undefined;
     const required = new Set(Array.isArray(s?.required) ? s.required : []);
@@ -570,8 +670,8 @@ function extractPathParams(url, paramsSchema) {
         return {
             name: safeParamName(camelCase(paramName)),
             originalName: paramName,
-            type: propSchema ? jsonSchemaToType(propSchema) : "string",
-            required: required.size === 0 || required.has(paramName),
+            type: propSchema ? jsonSchemaToType(propSchema) : 'string',
+            required: true,
             description: propSchema
                 ? propSchema.description
                 : undefined,
@@ -582,12 +682,12 @@ function extractQueryParams(querySchema) {
     if (!querySchema)
         return [];
     const s = querySchema;
-    if (s.type !== "object" || !s.properties)
+    if (s.type !== 'object' || !s.properties)
         return [];
     const required = new Set(Array.isArray(s.required) ? s.required : []);
     const props = s.properties;
     return Object.entries(props).map(([name, schema]) => ({
-        name: camelCase(name),
+        name: safeParamName(camelCase(name)),
         originalName: name,
         type: jsonSchemaToType(schema),
         required: required.has(name),
@@ -596,25 +696,25 @@ function extractQueryParams(querySchema) {
     }));
 }
 const SYSTEM_HEADERS = new Set([
-    "content-type",
-    "content-length",
-    "transfer-encoding",
-    "host",
-    "accept",
-    "accept-encoding",
+    'content-type',
+    'content-length',
+    'transfer-encoding',
+    'host',
+    'accept',
+    'accept-encoding',
 ]);
 function extractHeaderParams(headersSchema) {
     if (!headersSchema)
         return [];
     const s = headersSchema;
-    if (s.type !== "object" || !s.properties)
+    if (s.type !== 'object' || !s.properties)
         return [];
     const required = new Set(Array.isArray(s.required) ? s.required : []);
     const props = s.properties;
     return Object.entries(props)
         .filter(([name]) => !SYSTEM_HEADERS.has(name.toLowerCase()))
         .map(([name, schema]) => ({
-        name: camelCase(name),
+        name: safeParamName(camelCase(name)),
         originalName: name,
         type: jsonSchemaToType(schema),
         required: required.has(name),
@@ -622,27 +722,31 @@ function extractHeaderParams(headersSchema) {
     }));
 }
 // ── Helpers ──────────────────────────────────────────────────────────────────
+function joinRoutePath(prefix, routePath) {
+    const left = prefix === '/' ? '' : prefix.replace(/\/$/, '');
+    const right = routePath === '/' ? '' : `/${routePath.replace(/^\//, '')}`;
+    return `${left}${right}` || '/';
+}
 function fastifyPathToIR(url, pathParams) {
     const nameMap = new Map(pathParams.map((p) => [p.originalName, p.name]));
     return url.replace(/:([a-zA-Z_][a-zA-Z0-9_]*)/g, (_, raw) => {
         const name = nameMap.get(raw) ?? raw;
-        return "${" + name + "}";
+        return '${' + name + '}';
     });
 }
 function pickSuccessResponse(response) {
     if (!response)
         return undefined;
-    for (const [code, schema] of [
-        [200, response["200"] ?? response[200]],
-        [201, response["201"] ?? response[201]],
-        [202, response["202"] ?? response[202]],
-        [204, response["204"] ?? response[204]],
-        [200, response["2xx"]],
-        [200, response["default"]],
-    ]) {
-        if (schema)
-            return { schema, statusCode: code };
-    }
+    const numeric = Object.entries(response)
+        .map(([code, schema]) => ({ statusCode: Number(code), schema }))
+        .filter(({ statusCode }) => statusCode >= 200 && statusCode < 300)
+        .sort((left, right) => left.statusCode - right.statusCode)[0];
+    if (numeric)
+        return numeric;
+    if (response['2xx'])
+        return { schema: response['2xx'], statusCode: 200 };
+    if (response.default)
+        return { schema: response.default, statusCode: 200 };
     return undefined;
 }
 //# sourceMappingURL=intake.js.map