micro-contracts 0.16.4 → 0.17.0

package/dist/generator/templateProcessor.js

@@ -1,821 +0,0 @@
-/**
- * Template Processor
- *
- * Provides Handlebars template loading and processing for code generation.
- * Supports custom templates for server routes, frontend clients, etc.
- */
-import fs from 'fs';
-import path from 'path';
-import Handlebars from 'handlebars';
-import { isReference, getRefName } from '../types.js';
-// =============================================================================
-// Template Processor
-// =============================================================================
-/**
- * Load and compile a template
- */
-export function loadTemplate(templatePath) {
-    if (!fs.existsSync(templatePath)) {
-        throw new Error(`Template not found: ${templatePath}`);
-    }
-    const content = fs.readFileSync(templatePath, 'utf-8');
-    return Handlebars.compile(content);
-}
-/**
- * Resolve template path following priority order:
- * 1. spec/{module}/templates/{templateName}
- * 2. spec/default/templates/{templateName}
- *
- * Returns null if not found (no built-in fallback)
- */
-export function resolveTemplatePath(options) {
-    const { specDir, moduleName, templateName } = options;
-    // Priority 1: Module-specific template
-    const moduleTemplatePath = path.join(specDir, moduleName, 'templates', templateName);
-    if (fs.existsSync(moduleTemplatePath)) {
-        return moduleTemplatePath;
-    }
-    // Priority 2: Default templates
-    const defaultTemplatePath = path.join(specDir, 'default', 'templates', templateName);
-    if (fs.existsSync(defaultTemplatePath)) {
-        return defaultTemplatePath;
-    }
-    // No built-in fallback
-    return null;
-}
-/**
- * Load template with automatic resolution
- */
-export function loadTemplateWithResolution(options) {
-    const templatePath = resolveTemplatePath(options);
-    if (!templatePath) {
-        // Try absolute/relative path as fallback
-        const absolutePath = path.resolve(options.templateName);
-        if (fs.existsSync(absolutePath)) {
-            return loadTemplate(absolutePath);
-        }
-        throw new Error(`Template not found: ${options.templateName}\n` +
-            `Searched in:\n` +
-            `  - ${path.join(options.specDir, options.moduleName, 'templates', options.templateName)}\n` +
-            `  - ${path.join(options.specDir, 'default', 'templates', options.templateName)}\n` +
-            `  - ${absolutePath}\n` +
-            `\nRun 'micro-contracts init' to create starter templates.`);
-    }
-    return loadTemplate(templatePath);
-}
-/**
- * Get default template content (built-in - for backward compatibility only)
- * @deprecated Use loadTemplateWithResolution instead
- */
-export function getDefaultTemplate(type) {
-    switch (type) {
-        case 'server':
-            return DEFAULT_SERVER_TEMPLATE;
-        case 'frontend':
-            return DEFAULT_FRONTEND_TEMPLATE;
-        case 'services':
-            return DEFAULT_SERVICES_TEMPLATE;
-    }
-}
-/**
- * Build template context from spec and overlay result
- */
-export function buildTemplateContext(spec, moduleName, options = {}) {
-    const servicesPath = options.servicesPath || `fastify.services.${moduleName}`;
-    const contractPackage = options.contractPackage || `@project/contract/${moduleName}`;
-    const extensionInfo = options.extensionInfo
-        ? Array.from(options.extensionInfo.values())
-        : [];
-    const appliedOverlays = options.appliedOverlays || [];
-    const routes = extractRoutes(spec, extensionInfo);
-    const services = extractServices(routes);
-    const schemaNames = Object.keys(spec.components?.schemas || {});
-    // Extract base URL from OpenAPI servers
-    const baseUrl = extractBaseUrl(spec);
-    // Extract service types for imports (e.g., 'UserServiceApi')
-    const serviceTypes = services.map(s => `${s.name}ServiceApi`);
-    // Extract schema types needed for imports
-    const schemaTypes = extractSchemaTypes(routes);
-    // Extract unique overlays with their parameters (deduplicated)
-    const uniqueOverlays = extractUniqueOverlays(routes);
-    // Extract screen contexts when screen mode is enabled
-    const screens = options.screen ? extractScreens(spec) : [];
-    return {
-        moduleName,
-        spec,
-        title: spec.info.title,
-        version: spec.info.version,
-        baseUrl,
-        extensionInfo,
-        appliedOverlays,
-        servicesPath,
-        contractPackage,
-        routes,
-        services,
-        serviceTypes,
-        schemaTypes,
-        schemaNames,
-        uniqueOverlays,
-        screens,
-    };
-}
-/**
- * Extract unique overlays from routes (deduplicated by overlay name)
- */
-function extractUniqueOverlays(routes) {
-    const overlayMap = new Map();
-    for (const route of routes) {
-        for (const ext of route.extensions) {
-            if (!overlayMap.has(ext.value)) {
-                // Find params for this overlay
-                const params = route.extensionParams.filter(p => p.extensionName === ext.value);
-                overlayMap.set(ext.value, params);
-            }
-        }
-    }
-    return Array.from(overlayMap.entries()).map(([name, params]) => ({ name, params }));
-}
-/**
- * Extract base URL from OpenAPI servers field
- * Returns path portion only (e.g., '/api' from 'http://localhost:3000/api')
- */
-function extractBaseUrl(spec) {
-    const servers = spec.servers;
-    if (!servers || servers.length === 0) {
-        return '';
-    }
-    const serverUrl = servers[0].url;
-    try {
-        // Try to parse as full URL
-        const url = new URL(serverUrl);
-        // Return pathname, removing trailing slash
-        return url.pathname.replace(/\/$/, '');
-    }
-    catch {
-        // If not a valid URL, assume it's already a path
-        return serverUrl.replace(/\/$/, '');
-    }
-}
-/**
- * Extract all schema types needed for client imports
- */
-function extractSchemaTypes(routes) {
-    const types = new Set();
-    types.add('ProblemDetails'); // Always needed for error handling
-    for (const route of routes) {
-        if (route.requestBody?.schemaName) {
-            types.add(route.requestBody.schemaName);
-        }
-        for (const resp of route.responses) {
-            if (resp.schemaName) {
-                types.add(resp.schemaName);
-            }
-        }
-        // Add params type (path + query parameters) for templates that need it
-        if (route.pathParams.length > 0 || route.queryParams.length > 0) {
-            types.add(`${route.typeNameBase}Params`);
-        }
-        // Add unified input type (for service-aligned templates)
-        types.add(`${route.typeNameBase}Input`);
-    }
-    return Array.from(types).sort();
-}
-/**
- * Process template with context
- */
-export function processTemplate(template, context) {
-    return template(context);
-}
-/**
- * Generate code using template
- */
-export function generateWithTemplate(templatePath, defaultType, context) {
-    let template;
-    if (templatePath && fs.existsSync(templatePath)) {
-        template = loadTemplate(templatePath);
-    }
-    else {
-        template = Handlebars.compile(getDefaultTemplate(defaultType));
-    }
-    return processTemplate(template, context);
-}
-// =============================================================================
-// Route Extraction
-// =============================================================================
-function extractRoutes(spec, extensionInfo) {
-    const routes = [];
-    const methods = ['get', 'post', 'put', 'patch', 'delete'];
-    for (const [apiPath, pathItem] of Object.entries(spec.paths)) {
-        for (const method of methods) {
-            const operation = pathItem[method];
-            if (!operation)
-                continue;
-            // Canonical extension names only
-            const service = operation['x-micro-contracts-service'];
-            const serviceMethod = operation['x-micro-contracts-method'];
-            if (!service || !serviceMethod)
-                continue;
-            const operationId = operation.operationId || `${method}${apiPath.replace(/[^a-zA-Z0-9]/g, '')}`;
-            const typeNameBase = `${service}_${serviceMethod}`;
-            const fastifyPath = apiPath.replace(/\{([^}]+)\}/g, ':$1');
-            const serviceKey = service.charAt(0).toLowerCase() + service.slice(1);
-            // Extract extensions and their parameters
-            const extensions = [];
-            const extensionParams = [];
-            for (const info of extensionInfo) {
-                const extValue = operation[info.marker];
-                if (extValue) {
-                    const matches = Array.isArray(extValue)
-                        ? extValue.includes(info.name)
-                        : extValue === info.name;
-                    if (matches) {
-                        const registryName = markerToRegistryName(info.marker);
-                        extensions.push({
-                            marker: info.marker,
-                            value: info.name,
-                            registryKey: `${registryName}.${info.name}`,
-                        });
-                        // Add parameters injected by this extension
-                        for (const param of info.injectedParameters) {
-                            // Map OpenAPI 'in' values to HTTP request property names
-                            const locationMap = {
-                                header: 'headers',
-                                query: 'query',
-                                path: 'params',
-                            };
-                            extensionParams.push({
-                                extensionName: info.name,
-                                name: param.name,
-                                location: locationMap[param.in] || 'headers',
-                                tsType: parameterToTsType(param),
-                                required: param.required || false,
-                            });
-                        }
-                    }
-                }
-            }
-            // Extract parameters
-            const allParams = operation.parameters || [];
-            const queryParams = allParams
-                .filter((p) => !isReference(p) && p.in === 'query')
-                .map(p => ({ name: p.name, required: p.required || false }));
-            const pathParams = allParams
-                .filter((p) => !isReference(p) && p.in === 'path')
-                .map(p => ({ name: p.name, required: true }));
-            // Extract request body
-            let requestBody;
-            if (operation.requestBody) {
-                const reqBody = isReference(operation.requestBody)
-                    ? null // Simplified - would need to resolve
-                    : operation.requestBody;
-                if (reqBody?.content?.['application/json']?.schema) {
-                    const schema = reqBody.content['application/json'].schema;
-                    const schemaName = isReference(schema)
-                        ? getRefName(schema.$ref)
-                        : operationId + 'Body';
-                    requestBody = { schemaName, required: reqBody.required || false };
-                }
-            }
-            // Extract responses
-            const responses = [];
-            for (const [statusCode, response] of Object.entries(operation.responses)) {
-                const resp = isReference(response) ? null : response;
-                if (resp?.content?.['application/json']?.schema) {
-                    const schema = resp.content['application/json'].schema;
-                    const schemaName = isReference(schema) ? getRefName(schema.$ref) : undefined;
-                    responses.push({ statusCode, schemaName });
-                }
-                else {
-                    responses.push({ statusCode });
-                }
-            }
-            // Client URL pattern: /users/{id} -> /users/${params.id}
-            const clientUrlPattern = apiPath.replace(/\{([^}]+)\}/g, '${params.$1}');
-            // Client URL pattern using input object: /users/{id} -> /users/${input.id}
-            const clientUrlPatternInput = apiPath.replace(/\{([^}]+)\}/g, '${input.$1}');
-            // Calculate type names
-            const responseType = responses.length > 0 && responses[0].schemaName
-                ? responses[0].schemaName
-                : 'void';
-            const requestType = requestBody?.schemaName;
-            // Params type combines both path and query parameters
-            const paramsType = (pathParams.length > 0 || queryParams.length > 0) ? `${typeNameBase}Params` : undefined;
-            // Unified input type name (matches contract service API)
-            const inputType = `${typeNameBase}Input`;
-            routes.push({
-                path: apiPath,
-                fastifyPath,
-                clientUrlPattern,
-                clientUrlPatternInput,
-                method,
-                httpMethod: method.toUpperCase(),
-                operationId,
-                service,
-                serviceKey,
-                serviceMethod,
-                summary: operation.summary,
-                tags: operation.tags || [],
-                isPublished: operation['x-micro-contracts-published'] === true,
-                extensions,
-                extensionParams,
-                queryParams,
-                pathParams,
-                requestBody,
-                responses,
-                typeNameBase,
-                responseType,
-                requestType,
-                paramsType,
-                inputType,
-            });
-        }
-    }
-    return routes;
-}
-function extractServices(routes) {
-    const serviceMap = new Map();
-    for (const route of routes) {
-        if (!serviceMap.has(route.service)) {
-            serviceMap.set(route.service, {
-                name: route.service,
-                key: route.serviceKey,
-                methods: [],
-            });
-        }
-        const service = serviceMap.get(route.service);
-        if (!service.methods.includes(route.serviceMethod)) {
-            service.methods.push(route.serviceMethod);
-        }
-    }
-    return Array.from(serviceMap.values()).sort((a, b) => a.name.localeCompare(b.name));
-}
-function markerToRegistryName(marker) {
-    const name = marker.replace(/^x-/, '');
-    return name.replace(/-([a-z])/g, (_, c) => c.toUpperCase()) + 'Registry';
-}
-/**
- * Convert OpenAPI parameter to TypeScript type
- */
-function parameterToTsType(param) {
-    if (!param.schema)
-        return 'unknown';
-    const schema = param.schema;
-    switch (schema.type) {
-        case 'string':
-            return 'string';
-        case 'integer':
-        case 'number':
-            return 'number';
-        case 'boolean':
-            return 'boolean';
-        case 'array':
-            return 'unknown[]';
-        default:
-            return 'unknown';
-    }
-}
-// =============================================================================
-// Screen Extraction
-// =============================================================================
-/**
- * Build an operationId → route path lookup from spec paths
- */
-function buildOperationRouteMap(spec) {
-    const map = new Map();
-    for (const [apiPath, pathItem] of Object.entries(spec.paths)) {
-        for (const method of ['get', 'post', 'put', 'patch', 'delete']) {
-            const operation = pathItem[method];
-            if (operation?.operationId) {
-                map.set(operation.operationId, apiPath);
-            }
-        }
-    }
-    return map;
-}
-/**
- * Extract {param} segments from a route path.
- */
-function extractPathParams(route) {
-    const matches = route.matchAll(/\{(\w+)\}/g);
-    return [...matches].map(m => m[1]);
-}
-/**
- * Resolve raw x-event (string | object | $ref) into InlineEventDefinition.
- */
-function resolveInlineEvent(raw, eventDefs, defaultType) {
-    if (raw == null)
-        return undefined;
-    if (typeof raw === 'string') {
-        return { name: raw, type: defaultType };
-    }
-    if (typeof raw === 'object' && '$ref' in raw && typeof raw.$ref === 'string') {
-        const ref = raw.$ref;
-        if (!ref.startsWith('#/components/x-event-defs/')) {
-            return { name: ref, type: defaultType };
-        }
-        const defName = ref.split('/').pop();
-        const resolved = eventDefs[defName];
-        if (!resolved)
-            return { name: defName, type: defaultType };
-        return {
-            name: resolved.name ?? defName,
-            type: resolved.type ?? defaultType,
-            params: resolved.params,
-        };
-    }
-    return {
-        name: raw.name ?? '',
-        type: raw.type ?? defaultType,
-        params: raw.params,
-    };
-}
-/**
- * Auto-derive params from path parameters when no explicit params are set.
- * Only applies to 'get' (screen path params) and 'link' (target route params).
- */
-function deriveEventParams(event, placement, context) {
-    if (event.params)
-        return event;
-    const route = placement === 'get' ? context.routePath : context.targetRoute;
-    if (route) {
-        const params = extractPathParams(route);
-        if (params.length > 0) {
-            event.params = Object.fromEntries(params.map(p => [p, 'string']));
-        }
-    }
-    return event;
-}
-/**
- * Extract schema $ref name from a mutation operation's request body.
- */
-function extractSchemaRef(operation) {
-    if (!operation.requestBody)
-        return '';
-    if (isReference(operation.requestBody)) {
-        return getRefName(operation.requestBody.$ref);
-    }
-    const jsonContent = operation.requestBody.content?.['application/json'];
-    if (jsonContent?.schema && isReference(jsonContent.schema)) {
-        return getRefName(jsonContent.schema.$ref);
-    }
-    return '';
-}
-/**
- * Extract screen contexts from OpenAPI spec.
- * Parses GET operations that have x-screen-id into ScreenContext objects.
- */
-function extractScreens(spec) {
-    const screens = [];
-    const operationRouteMap = buildOperationRouteMap(spec);
-    const components = (spec.components ?? {});
-    const eventDefs = (components['x-event-defs'] ?? {});
-    for (const [apiPath, pathItem] of Object.entries(spec.paths)) {
-        const operation = pathItem.get;
-        if (!operation)
-            continue;
-        const screenId = operation['x-screen-id'];
-        if (!screenId)
-            continue;
-        const screenConst = operation['x-screen-const'] || '';
-        const screenName = operation['x-screen-name'] || '';
-        const operationId = operation.operationId || '';
-        const supportsBack = operation['x-back-navigation'] === true;
-        // Legacy x-events (backward compat)
-        const legacyEvents = operation['x-events'] || [];
-        // Inline x-event on GET (screen_view)
-        let screenEvent = resolveInlineEvent(operation['x-event'], eventDefs, 'screen_view');
-        if (screenEvent) {
-            deriveEventParams(screenEvent, 'get', { routePath: apiPath });
-        }
-        const requiresAuth = Array.isArray(operation.security)
-            ? operation.security.length > 0 && operation.security.some(s => Object.keys(s).length > 0)
-            : false;
-        let viewModelSchema = operation['x-view-model'] || '';
-        if (!viewModelSchema) {
-            const response200 = operation.responses?.['200'];
-            if (response200 && !isReference(response200)) {
-                const jsonContent = response200.content?.['application/json'];
-                if (jsonContent?.schema && isReference(jsonContent.schema)) {
-                    viewModelSchema = getRefName(jsonContent.schema.$ref);
-                }
-            }
-        }
-        // Navigation links from 200 response (with optional inline x-event)
-        const links = [];
-        const response200 = operation.responses?.['200'];
-        if (response200 && !isReference(response200)) {
-            const responseLinks = response200.links;
-            if (responseLinks) {
-                for (const [linkName, linkObj] of Object.entries(responseLinks)) {
-                    if (linkObj.operationId) {
-                        const targetRoute = operationRouteMap.get(linkObj.operationId) || '';
-                        let linkEvent = resolveInlineEvent(linkObj['x-event'], eventDefs, 'user_action');
-                        if (linkEvent) {
-                            deriveEventParams(linkEvent, 'link', { routePath: apiPath, targetRoute });
-                        }
-                        links.push({
-                            name: linkName,
-                            targetRoute,
-                            targetOperationId: linkObj.operationId,
-                            event: linkEvent,
-                        });
-                    }
-                }
-            }
-        }
-        // Mutation operations (post/put/patch/delete)
-        const actions = [];
-        const mutationMethods = ['post', 'put', 'patch', 'delete'];
-        for (const method of mutationMethods) {
-            const mutationOp = pathItem[method];
-            if (!mutationOp)
-                continue;
-            const actionEvent = resolveInlineEvent(mutationOp['x-event'], eventDefs, 'user_action');
-            actions.push({
-                method,
-                operationId: mutationOp.operationId ?? '',
-                summary: mutationOp.summary ?? '',
-                schemaRef: extractSchemaRef(mutationOp),
-                event: actionEvent,
-            });
-        }
-        // x-interactions
-        const rawInteractions = (operation['x-interactions'] ?? []);
-        const interactions = rawInteractions.map(i => {
-            const { name, description, 'x-event': rawEvent, ...extras } = i;
-            return {
-                name: name ?? '',
-                description: description ?? '',
-                event: resolveInlineEvent(rawEvent, eventDefs, 'user_action'),
-                extras,
-            };
-        });
-        screens.push({
-            route: apiPath,
-            screenConst,
-            screenId,
-            screenName,
-            operationId,
-            supportsBack,
-            viewModelSchema,
-            links,
-            events: legacyEvents,
-            screenEvent,
-            actions,
-            interactions,
-            pathParams: extractPathParams(apiPath),
-            requiresAuth,
-        });
-    }
-    return screens;
-}
-// =============================================================================
-// Register Handlebars Helpers
-// =============================================================================
-// Comparison helpers
-Handlebars.registerHelper('eq', (a, b) => a === b);
-Handlebars.registerHelper('ne', (a, b) => a !== b);
-Handlebars.registerHelper('gt', (a, b) => a > b);
-Handlebars.registerHelper('gte', (a, b) => a >= b);
-Handlebars.registerHelper('lt', (a, b) => a < b);
-Handlebars.registerHelper('lte', (a, b) => a <= b);
-Handlebars.registerHelper('and', function (...args) {
-    const options = args.pop();
-    return args.every(Boolean);
-});
-Handlebars.registerHelper('or', function (...args) {
-    const options = args.pop();
-    return args.some(Boolean);
-});
-// Array/Object helpers
-Handlebars.registerHelper('length', (arr) => arr?.length || 0);
-Handlebars.registerHelper('first', (arr) => arr?.[0]);
-Handlebars.registerHelper('last', (arr) => arr?.[arr?.length - 1]);
-Handlebars.registerHelper('join', (arr, sep) => arr?.join(sep) || '');
-Handlebars.registerHelper('includes', (arr, val) => arr?.includes(val));
-Handlebars.registerHelper('keys', (obj) => Object.keys(obj || {}));
-Handlebars.registerHelper('values', (obj) => Object.values(obj || {}));
-// String helpers
-Handlebars.registerHelper('uppercase', (str) => str?.toUpperCase());
-Handlebars.registerHelper('lowercase', (str) => str?.toLowerCase());
-Handlebars.registerHelper('capitalize', (str) => str?.charAt(0).toUpperCase() + str?.slice(1));
-Handlebars.registerHelper('camelCase', (str) => {
-    return str?.replace(/[-_]([a-z])/g, (_match, c) => c.toUpperCase());
-});
-Handlebars.registerHelper('pascalCase', (str) => {
-    const camel = str?.replace(/[-_]([a-z])/g, (_match, c) => c.toUpperCase());
-    return camel?.charAt(0).toUpperCase() + camel?.slice(1);
-});
-Handlebars.registerHelper('kebabCase', (str) => {
-    return str?.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-});
-Handlebars.registerHelper('snakeCase', (str) => {
-    return str?.replace(/([a-z])([A-Z])/g, '$1_$2').replace(/-/g, '_').toLowerCase();
-});
-// Ref helper
-Handlebars.registerHelper('refName', (ref) => {
-    return typeof ref === 'string' ? ref.split('/').pop() : '';
-});
-// JSON helper
-Handlebars.registerHelper('json', (obj) => JSON.stringify(obj, null, 2));
-// Screen event helpers
-Handlebars.registerHelper('hasEvent', (ctx) => !!(ctx?.screenEvent || ctx?.links?.some((l) => l.event) ||
-    ctx?.actions?.some((a) => a.event) ||
-    ctx?.interactions?.some((i) => i.event)));
-Handlebars.registerHelper('eventParamsSignature', (params) => {
-    if (!params)
-        return '';
-    return Object.entries(params)
-        .map(([k, v]) => `${k}: ${v === 'integer' ? 'number' : v}`)
-        .join(', ');
-});
-// Conditional block helpers
-Handlebars.registerHelper('ifCond', function (v1, operator, v2, options) {
-    switch (operator) {
-        case '==': return v1 == v2 ? options.fn(this) : options.inverse(this);
-        case '===': return v1 === v2 ? options.fn(this) : options.inverse(this);
-        case '!=': return v1 != v2 ? options.fn(this) : options.inverse(this);
-        case '!==': return v1 !== v2 ? options.fn(this) : options.inverse(this);
-        case '<': return v1 < v2 ? options.fn(this) : options.inverse(this);
-        case '<=': return v1 <= v2 ? options.fn(this) : options.inverse(this);
-        case '>': return v1 > v2 ? options.fn(this) : options.inverse(this);
-        case '>=': return v1 >= v2 ? options.fn(this) : options.inverse(this);
-        default: return options.inverse(this);
-    }
-});
-// =============================================================================
-// Default Templates
-// =============================================================================
-const DEFAULT_SERVER_TEMPLATE = `/**
- * Auto-generated Fastify routes from OpenAPI specification
- * Generated from: {{spec.info.title}} v{{spec.info.version}}
- * DO NOT EDIT MANUALLY
- */
-
-import type { FastifyInstance } from 'fastify';
-import { allSchemas } from '{{contractPackage}}/schemas';
-import * as types from '{{contractPackage}}/schemas';
-
-export async function registerRoutes(fastify: FastifyInstance): Promise<void> {
-  // Register all schemas from contract package
-  for (const schema of allSchemas) {
-    fastify.addSchema(schema);
-  }
-
-  // Service references from {{servicesPath}}
-  const { {{#each services}}{{key}}{{#unless @last}}, {{/unless}}{{/each}} } = {{servicesPath}};
-{{#if extensionInfo.length}}
-
-  // Extension registries
-{{#each extensionInfo}}
-  const {{camelCase marker}}Registry = fastify.{{camelCase marker}}Registry;
-{{/each}}
-{{/if}}
-
-{{#each routes}}
-  // {{summary}}
-  // {{uppercase method}} {{path}}{{#if isPublished}} (published){{/if}}
-  fastify.{{method}}('{{fastifyPath}}', {
-{{#if queryParams.length}}
-    schema: {
-      querystring: { $ref: '{{typeNameBase}}Query#' },
-{{/if}}
-{{#if pathParams.length}}
-{{#unless queryParams.length}}
-    schema: {
-{{/unless}}
-      params: { $ref: '{{typeNameBase}}Params#' },
-{{/if}}
-{{#if requestBody}}
-{{#unless (or queryParams.length pathParams.length)}}
-    schema: {
-{{/unless}}
-      body: { $ref: '{{requestBody.schemaName}}#' },
-{{/if}}
-{{#if responses.length}}
-{{#unless (or queryParams.length pathParams.length requestBody)}}
-    schema: {
-{{/unless}}
-      response: {
-{{#each responses}}
-{{#if schemaName}}
-        {{statusCode}}: { $ref: '{{schemaName}}#' },
-{{/if}}
-{{/each}}
-      },
-{{/if}}
-{{#if (or queryParams.length pathParams.length requestBody responses.length)}}
-    },
-{{/if}}
-{{#if extensions.length}}
-    preHandler: [
-{{#each extensions}}
-      {{registryKey}},
-{{/each}}
-    ],
-{{/if}}
-  }, async (req, reply) => {
-    return {{serviceKey}}.{{serviceMethod}}({{#if pathParams.length}}req.params as types.{{typeNameBase}}Params{{/if}}{{#if queryParams.length}}{{#if pathParams.length}}, {{/if}}req.query as types.{{typeNameBase}}Query{{/if}}{{#if requestBody}}{{#if (or pathParams.length queryParams.length)}}, {{/if}}req.body as types.{{requestBody.schemaName}}{{/if}});
-  });
-
-{{/each}}
-}
-`;
-const DEFAULT_FRONTEND_TEMPLATE = `/**
- * Auto-generated API client from OpenAPI specification
- * Generated from: {{spec.info.title}} v{{spec.info.version}}
- * DO NOT EDIT MANUALLY
- */
-
-import type * as types from '{{contractPackage}}/schemas';
-
-const BASE_URL = '';
-
-async function fetchApi<T>(
-  url: string,
-  options: RequestInit = {}
-): Promise<T> {
-  const response = await fetch(BASE_URL + url, {
-    ...options,
-    headers: {
-      'Content-Type': 'application/json',
-      ...options.headers,
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(\`API error: \${response.status}\`);
-  }
-
-  if (response.status === 204) {
-    return undefined as T;
-  }
-
-  return response.json();
-}
-
-{{#each routes}}
-/**
- * {{summary}}
- * {{uppercase method}} {{path}}
- */
-export async function {{operationId}}(
-{{#if pathParams.length}}
-  params: types.{{typeNameBase}}Params,
-{{/if}}
-{{#if queryParams.length}}
-  query?: Partial<types.{{typeNameBase}}Query>,
-{{/if}}
-{{#if requestBody}}
-  body: types.{{requestBody.schemaName}},
-{{/if}}
-): Promise<{{#with (first responses)}}{{#if schemaName}}types.{{schemaName}}{{else}}void{{/if}}{{/with}}> {
-{{#if pathParams.length}}
-  let url = '{{path}}'.replace(/\\{([^}]+)\\}/g, (_, key) => String((params as Record<string, unknown>)[key]));
-{{else}}
-  let url = '{{path}}';
-{{/if}}
-{{#if queryParams.length}}
-  if (query) {
-    const searchParams = new URLSearchParams();
-    for (const [key, value] of Object.entries(query)) {
-      if (value !== undefined) {
-        searchParams.set(key, String(value));
-      }
-    }
-    const qs = searchParams.toString();
-    if (qs) url += '?' + qs;
-  }
-{{/if}}
-  return fetchApi<{{#with (first responses)}}{{#if schemaName}}types.{{schemaName}}{{else}}void{{/if}}{{/with}}>(url, {
-    method: '{{uppercase method}}',
-{{#if requestBody}}
-    body: JSON.stringify(body),
-{{/if}}
-  });
-}
-
-{{/each}}
-`;
-const DEFAULT_SERVICES_TEMPLATE = `/**
- * Service interfaces
- * Auto-generated from OpenAPI specification
- * DO NOT EDIT MANUALLY
- */
-
-import type * as types from '../schemas/types.js';
-
-{{#each services}}
-/**
- * {{name}} interface
- */
-export interface {{name}}ServiceApi {
-{{#each methods}}
-  {{this}}(...args: unknown[]): Promise<unknown>;
-{{/each}}
-}
-
-{{/each}}
-`;
-export { DEFAULT_SERVER_TEMPLATE, DEFAULT_FRONTEND_TEMPLATE, DEFAULT_SERVICES_TEMPLATE };
-//# sourceMappingURL=templateProcessor.js.map