@common-stack/server-core 7.2.1-alpha.49 → 7.2.1-alpha.50

package/lib/index.d.ts

@@ -3,4 +3,3 @@ export * from './interfaces';
 export * from './constants';
 export * from './logger';
 export * from './utils';
-export * from './moleculer-generation';

package/lib/index.js

@@ -1 +1 @@
-export{Feature,featureCatalog}from'./connector/connector.js';export{GraphqlRootType}from'./interfaces/rules.js';export{TYPES}from'./constants/types.js';export{CACHE_CONTROL_DIRECTIVE}from'./constants/directives.js';export{logger}from'./logger/logger.js';export{getCurrentPreferences,transformPrefsToArray}from'./utils/preferences.js';export{generateQueryCacheKey}from'./utils/generate-query-cache-key.js';export{extractTenantId}from'./utils/extract-tenant-id.js';export{getDirectiveArgsFromSchema}from'./utils/get-directive-args-from-schema.js';export{buildActionPath,getActionName,getAllMethodNames,isExcludedMethod,toPascalCase}from'./moleculer-generation/serviceGenerationUtils.js';export{Moleculer}from'./moleculer-generation/moleculerEventHandler.js';export{createTypedAction,debugServiceParams,generateAutoInferredServiceActions,generateServiceActions,generateServiceActionsAndEvents,generateTypeSafeServiceActions,printServiceParams,verifyAllParamsDefined}from'./moleculer-generation/typedMoleculerService.js';export{ProxyService,generateProxyMethods}from'./moleculer-generation/typedProxyService.js';export{zodSchemasToMoleculer,zodToMoleculerParams}from'./moleculer-generation/zodToMoleculer.js';//# sourceMappingURL=index.js.map
+export{Feature,featureCatalog}from'./connector/connector.js';export{GraphqlRootType}from'./interfaces/rules.js';export{TYPES}from'./constants/types.js';export{CACHE_CONTROL_DIRECTIVE}from'./constants/directives.js';export{logger}from'./logger/logger.js';export{getCurrentPreferences,transformPrefsToArray}from'./utils/preferences.js';export{generateQueryCacheKey}from'./utils/generate-query-cache-key.js';export{extractTenantId}from'./utils/extract-tenant-id.js';export{getDirectiveArgsFromSchema}from'./utils/get-directive-args-from-schema.js';//# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@common-stack/server-core",
-    "version": "7.2.1-alpha.49",
+    "version": "7.2.1-alpha.50",
     "description": "common core for higher packages to depend on",
     "license": "ISC",
     "author": "CDMBase LLC",
@@ -34,7 +34,7 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "5d15f698177752229be196e4457e99c9dd4d26a5",
+    "gitHead": "86248ff51544d199dfe9b57471665d8c26d2817e",
     "typescript": {
         "definition": "lib/index.d.ts"
     }

package/lib/moleculer-generation/generateAllServiceSchemas.cjs

@@ -1,628 +0,0 @@
-#!/usr/bin/env node
-/**
- * Generate Zod schemas for ALL service interfaces (CommonJS version)
- *
- * This script can be run from:
- * 1. Local project: node scripts/generateAllServiceSchemas.cjs
- * 2. As npm script: Add to package.json scripts and run via npm/yarn
- * 3. From node_modules: npx @common-stack/server-core generateAllServiceSchemas
- *
- * Configuration is loaded from cdecode-config.json in the project root.
- * All paths in the config are relative to the project root.
- *
- * @example package.json script
- * "scripts": {
- *   "generateSchemas": "node node_modules/@common-stack/server-core/lib/moleculer-generation/generateAllServiceSchemas.cjs"
- * }
- */
-
-const fs = require('fs');
-const path = require('path');
-const ts = require('typescript');
-
-// Determine the project root - use current working directory (where the command is run)
-// This works whether the script is in local scripts/ or node_modules/
-const projectRoot = process.cwd();
-
-// Load configuration from cdecode-config.json in the project root
-const configPath = path.join(projectRoot, 'cdecode-config.json');
-let serviceConfig = {};
-
-if (fs.existsSync(configPath)) {
-    try {
-        const fullConfig = JSON.parse(fs.readFileSync(configPath, 'utf8'));
-        serviceConfig = fullConfig.serviceSchemas || {};
-        console.log('✅ Loaded configuration from cdecode-config.json');
-    } catch (error) {
-        console.warn('⚠️  Could not parse cdecode-config.json, using defaults');
-    }
-} else {
-    console.warn('⚠️  cdecode-config.json not found in project root, using defaults');
-}
-
-// Apply configuration with defaults (all paths relative to project root)
-const SERVICES_DIR = path.join(projectRoot, serviceConfig.servicesDir || 'packages/common/src/services');
-const OUTPUT_FILE = path.join(
-    projectRoot,
-    serviceConfig.outputFile || 'packages/common/src/generated/service-schemas.ts',
-);
-
-// Validate that SERVICES_DIR exists
-if (!fs.existsSync(SERVICES_DIR)) {
-    console.error(`❌ Error: Services directory not found: ${SERVICES_DIR}`);
-    console.error(`   Current working directory: ${projectRoot}`);
-    console.error(`   Expected path (from config): ${serviceConfig.servicesDir || 'packages/common/src/services'}`);
-    console.error('\n   Make sure:');
-    console.error('   1. You are running this script from the project root');
-    console.error('   2. The servicesDir path in cdecode-config.json is correct');
-    process.exit(1);
-}
-
-const SKIP_SERVICES = serviceConfig.skipServices || [
-    'AuthBackendClient',
-    'PubSub',
-    'RedisCacheManager',
-    'InngestClient',
-    'JSONContributionRegistry',
-    'PageStore',
-    'PublisherEventService',
-];
-const KNOWN_ENUMS = serviceConfig.knownEnums || [];
-const CONST_ENUM_SCHEMAS = serviceConfig.constEnumSchemas || ['ConfigurationTarget', 'ConfigurationScope'];
-
-/**
- * Calculate relative path from outputFile to graphqlSchemasPath
- */
-function calculateRelativeImportPath() {
-    if (!serviceConfig.outputFile || !serviceConfig.graphqlSchemasPath) {
-        return './generated-zod-schemas';
-    }
-
-    const outputDir = path.dirname(path.join(projectRoot, serviceConfig.outputFile));
-    const graphqlSchemaPath = path.join(projectRoot, serviceConfig.graphqlSchemasPath);
-
-    // Calculate relative path
-    const relativePath = path.relative(outputDir, graphqlSchemaPath);
-
-    // Remove .ts extension and ensure it starts with ./
-    const withoutExt = relativePath.replace(/\.ts$/, '');
-    return withoutExt.startsWith('.') ? withoutExt : `./${withoutExt}`;
-}
-
-const GRAPHQL_SCHEMAS_IMPORT_PATH = calculateRelativeImportPath();
-
-/**
- * Dynamically discover all available GraphQL Zod schemas from graphql-zod-schemas.ts
- * This scans for exported schema functions and extracts their type names
- */
-function discoverGraphQLZodTypes() {
-    const graphqlSchemaFile = serviceConfig.graphqlSchemasPath
-        ? path.join(projectRoot, serviceConfig.graphqlSchemasPath)
-        : path.join(projectRoot, 'packages/common/src/generated/generated-zod-schemas.ts');
-
-    // Check if file exists
-    if (!fs.existsSync(graphqlSchemaFile)) {
-        console.warn('⚠️  graphql-zod-schemas.ts not found, using empty set for GraphQL types');
-        return new Set();
-    }
-
-    const content = fs.readFileSync(graphqlSchemaFile, 'utf8');
-    const graphqlTypes = new Set();
-
-    // Match all exported schema function names
-    // Pattern: export function SomeTypeInputSchema() or export function SomeTypeSchema()
-    const schemaFunctionPattern = /export function ([A-Z][a-zA-Z0-9]+)Schema\(\)/g;
-    let match;
-
-    while ((match = schemaFunctionPattern.exec(content)) !== null) {
-        const schemaName = match[1];
-
-        // Convert schema function name back to interface name
-        // Examples:
-        // - UserTokenInputSchema -> IUserTokenInput
-        // - UserAuth0UpdateFieldsSchema -> IUserAuth0UpdateFields
-        // - ConfigurationNodeInputSchema -> IConfigurationNodeInput
-
-        // Skip enum schemas (they don't have 'Input' suffix typically and are in CONST_ENUM_SCHEMAS)
-        if (CONST_ENUM_SCHEMAS.includes(schemaName)) {
-            continue;
-        }
-
-        // Add 'I' prefix to convert to interface name
-        const interfaceName = 'I' + schemaName;
-        graphqlTypes.add(interfaceName);
-    }
-
-    return graphqlTypes;
-}
-
-// Dynamically discover available GraphQL Zod types
-const GRAPHQL_ZOD_TYPES = discoverGraphQLZodTypes();
-
-function findServiceInterfaces() {
-    const files = fs.readdirSync(SERVICES_DIR).filter((f) => f.endsWith('.ts') && f !== 'index.ts');
-    const services = [];
-
-    files.forEach((file) => {
-        const content = fs.readFileSync(path.join(SERVICES_DIR, file), 'utf8');
-        const interfaceMatch = content.match(/export interface (I[A-Z][a-zA-Z0-9]*Service)/);
-
-        if (interfaceMatch) {
-            const serviceName = interfaceMatch[1];
-            if (!SKIP_SERVICES.includes(serviceName.replace(/^I/, ''))) {
-                services.push({
-                    name: serviceName,
-                    file: file,
-                    path: path.join(SERVICES_DIR, file),
-                });
-            }
-        }
-    });
-
-    return services;
-}
-
-/**
- * Parse a TypeScript source file and extract method signatures from an interface
- * Now includes support for resolving inherited interface methods
- */
-function parseServiceInterface(filePath, interfaceName) {
-    const sourceCode = fs.readFileSync(filePath, 'utf8');
-    const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
-
-    const methods = [];
-    const usedEnums = new Set();
-    const parsedInterfaces = new Set(); // Track parsed interfaces to avoid infinite recursion
-
-    /**
-     * Extract methods from an interface node
-     */
-    function extractMethodsFromInterface(node, currentSourceFile) {
-        node.members.forEach((member) => {
-            if (ts.isMethodSignature(member) && member.name) {
-                const methodName = member.name.getText(currentSourceFile);
-                const parameters = [];
-
-                if (member.parameters) {
-                    member.parameters.forEach((param) => {
-                        const paramName = param.name.getText(currentSourceFile);
-                        const paramType = param.type ? param.type.getText(currentSourceFile) : 'any';
-                        const isOptional = !!param.questionToken;
-
-                        // Skip destructured parameters - treat the whole param as passthrough object
-                        if (ts.isObjectBindingPattern(param.name)) {
-                            // This is a destructured parameter like { user, accessToken }
-                            // Use the type instead
-                            parameters.push({
-                                name: '_destructured',
-                                type: paramType,
-                                isOptional,
-                                isDestructured: true,
-                            });
-                            return;
-                        }
-
-                        // Check if type is a known enum or const enum
-                        KNOWN_ENUMS.forEach((enumName) => {
-                            if (paramType.includes(enumName)) {
-                                usedEnums.add(enumName);
-                            }
-                        });
-                        CONST_ENUM_SCHEMAS.forEach((enumName) => {
-                            if (paramType.includes(enumName)) {
-                                usedEnums.add(enumName);
-                            }
-                        });
-
-                        parameters.push({
-                            name: paramName,
-                            type: paramType,
-                            isOptional,
-                        });
-                    });
-                }
-
-                // Only add if method doesn't already exist (child interface overrides parent)
-                if (!methods.find((m) => m.name === methodName)) {
-                    methods.push({
-                        name: methodName,
-                        parameters,
-                    });
-                }
-            }
-        });
-    }
-
-    /**
-     * Resolve and parse extended interfaces
-     */
-    function resolveExtendedInterfaces(node, currentSourceFile) {
-        if (node.heritageClauses) {
-            node.heritageClauses.forEach((heritage) => {
-                heritage.types.forEach((type) => {
-                    const baseInterfaceName = type.expression.getText(currentSourceFile);
-                    
-                    // Skip if already parsed (prevent infinite recursion)
-                    if (parsedInterfaces.has(baseInterfaceName)) {
-                        return;
-                    }
-                    parsedInterfaces.add(baseInterfaceName);
-
-                    // Try to find the base interface in common locations
-                    // projectRoot is process.cwd() - where the command is run from (project root)
-                    const possiblePaths = [
-                        // Most common: IBaseService in project's packages/common/src/repositories/
-                        path.join(projectRoot, 'packages/common/src/repositories/IBaseService.ts'),
-                        // Alternative: in store-mongo package
-                        path.join(projectRoot, 'packages/common-store-mongo/src/interfaces/base-service.ts'),
-                        // Same directory as current service file
-                        path.join(path.dirname(filePath), baseInterfaceName + '.ts'),
-                        // Direct filename match in repositories folder
-                        path.join(projectRoot, 'packages/common/src/repositories', baseInterfaceName + '.ts'),
-                    ];
-
-                    for (const possiblePath of possiblePaths) {
-                        if (fs.existsSync(possiblePath)) {
-                            try {
-                                const baseSourceCode = fs.readFileSync(possiblePath, 'utf8');
-                                const baseSourceFile = ts.createSourceFile(
-                                    possiblePath,
-                                    baseSourceCode,
-                                    ts.ScriptTarget.Latest,
-                                    true,
-                                );
-
-                                // Find the base interface and extract its methods
-                                function visitBase(baseNode) {
-                                    if (
-                                        ts.isInterfaceDeclaration(baseNode) &&
-                                        baseNode.name.text === baseInterfaceName
-                                    ) {
-                                        // First, resolve any interfaces this base interface extends
-                                        resolveExtendedInterfaces(baseNode, baseSourceFile);
-                                        // Then extract methods from this base interface
-                                        extractMethodsFromInterface(baseNode, baseSourceFile);
-                                    }
-                                    ts.forEachChild(baseNode, visitBase);
-                                }
-
-                                visitBase(baseSourceFile);
-                                break; // Found the file, no need to check other paths
-                            } catch (error) {
-                                // Continue to next possible path
-                                console.warn(`⚠️  Could not parse base interface ${baseInterfaceName} from ${possiblePath}:`, error.message);
-                            }
-                        }
-                    }
-                });
-            });
-        }
-    }
-
-    function visit(node) {
-        if (ts.isInterfaceDeclaration(node) && node.name.text === interfaceName) {
-            parsedInterfaces.add(interfaceName);
-            
-            // First, resolve extended interfaces (inheritance hierarchy)
-            resolveExtendedInterfaces(node, sourceFile);
-            
-            // Then extract methods from this interface (to allow overrides)
-            extractMethodsFromInterface(node, sourceFile);
-        }
-
-        ts.forEachChild(node, visit);
-    }
-
-    visit(sourceFile);
-    return { methods, usedEnums: Array.from(usedEnums) };
-}
-
-/**
- * Generate Zod schema string for a parameter type
- */
-function generateZodType(paramType, isOptional, paramName = '') {
-    let zodType;
-
-    // Handle union types like "string | null | undefined"
-    if (paramType.includes('|')) {
-        const types = paramType.split('|').map(t => t.trim());
-        const hasNull = types.includes('null');
-        const hasUndefined = types.includes('undefined');
-        const nonNullableTypes = types.filter(t => t !== 'null' && t !== 'undefined');
-        
-        if (nonNullableTypes.length === 1) {
-            // Single non-nullable type with null/undefined
-            zodType = generateZodType(nonNullableTypes[0], false, paramName);
-            if (hasNull || hasUndefined) {
-                return `${zodType}.optional().nullable()`;
-            }
-            return zodType;
-        } else if (nonNullableTypes.length > 1) {
-            // Multiple types - generate z.union() for known types
-            // This handles cases like "IExtensionIdentifier | string"
-            const unionTypes = nonNullableTypes.map(type => {
-                // Check if it's a GraphQL type
-                if (GRAPHQL_ZOD_TYPES.has(type)) {
-                    const schemaName = type.replace(/^I/, '') + 'Schema';
-                    return `${schemaName}()`;
-                }
-                // Handle primitive types
-                if (type === 'string') return 'z.string()';
-                if (type === 'number') return 'z.number()';
-                if (type === 'boolean') return 'z.boolean()';
-                // Default to passthrough
-                return 'PassthroughObjectSchema';
-            });
-            
-            return `z.union([${unionTypes.join(', ')}])`;
-        }
-    }
-
-    // Handle array types
-    if (paramType.includes('[]')) {
-        const innerType = paramType.replace('[]', '').trim();
-        const innerZodType = generateZodType(innerType, false, paramName);
-        zodType = `z.array(${innerZodType})`;
-    }
-    // Handle known enums
-    else if (KNOWN_ENUMS.some((e) => paramType.includes(e))) {
-        const enumName = KNOWN_ENUMS.find((e) => paramType.includes(e));
-        zodType = `z.nativeEnum(${enumName})`;
-    }
-    // Handle const enums (use schema functions from graphql-zod-schemas)
-    else if (CONST_ENUM_SCHEMAS.some((e) => paramType.includes(e))) {
-        const enumName = CONST_ENUM_SCHEMAS.find((e) => paramType.includes(e));
-        zodType = `${enumName}Schema()`;
-    }
-    // Handle primitive types
-    else if (paramType === 'string') {
-        zodType = 'z.string()';
-    } else if (paramType === 'number') {
-        zodType = 'z.number()';
-    } else if (paramType === 'boolean') {
-        zodType = 'z.boolean()';
-    } else if (paramType === 'any') {
-        zodType = 'z.any()';
-    }
-    // Handle Date
-    else if (paramType === 'Date') {
-        zodType = 'z.date()';
-    }
-    // Check if it's a GraphQL type with existing Zod schema
-    else if (GRAPHQL_ZOD_TYPES.has(paramType)) {
-        // Use the GraphQL-generated schema function
-        const schemaName = paramType.replace(/^I/, '') + 'Schema';
-        zodType = `${schemaName}()`;
-    }
-    // Handle Promise types (return type, not for validation)
-    else if (paramType.startsWith('Promise<')) {
-        zodType = 'z.any()';
-    }
-    // Use reusable schemas for common parameter names
-    // Make complex objects optional by default to avoid strict validation errors
-    else if (paramName === 'context' || paramName === 'userContext') {
-        zodType = 'ContextSchema.optional()';
-    } else if (paramName === 'resource') {
-        zodType = 'ResourceSchema.optional()';
-    } else if (paramName === 'options' || paramName === 'paginationOptions') {
-        zodType = 'OptionsSchema.optional()';
-    } else if (paramName === 'data' || paramName === 'updateData') {
-        zodType = 'DataSchema.optional()';
-    } else if (paramName === 'input') {
-        zodType = 'InputSchema.optional()';
-    } else if (paramName === 'filter' || paramName === 'criteria' || paramName === 'additionalFilters') {
-        zodType = 'FilterSchema.optional()';
-    } else if (paramName === 'where') {
-        zodType = 'WhereSchema.optional()';
-    } else if (paramName === 'request') {
-        zodType = 'RequestSchema.optional()';
-    }
-    // Default: treat as object and make it optional
-    else {
-        zodType = 'PassthroughObjectSchema.optional()';
-    }
-
-    // Only add .optional() if not already added and isOptional is true
-    return isOptional && !zodType.includes('.optional()') ? `${zodType}.optional()` : zodType;
-}
-
-function generateServiceSchemas() {
-    const services = findServiceInterfaces();
-
-    console.log(`\n🔍 Found ${services.length} service interfaces\n`);
-
-    // Parse all services and collect used enums and GraphQL types
-    const allUsedEnums = new Set();
-    const allUsedGraphQLTypes = new Set();
-    const allUsedConstEnumSchemas = new Set(); // Track const enum schemas
-    const servicesWithMethods = [];
-
-    services.forEach((service) => {
-        const { methods, usedEnums } = parseServiceInterface(service.path, service.name);
-        usedEnums.forEach((e) => {
-            if (CONST_ENUM_SCHEMAS.includes(e)) {
-                allUsedConstEnumSchemas.add(e);
-            } else {
-                allUsedEnums.add(e);
-            }
-        });
-
-        // Track which GraphQL types are actually used
-        methods.forEach((method) => {
-            method.parameters.forEach((param) => {
-                if (GRAPHQL_ZOD_TYPES.has(param.type)) {
-                    allUsedGraphQLTypes.add(param.type);
-                }
-                // Check in array types
-                if (param.type.includes('[]')) {
-                    const innerType = param.type.replace('[]', '').trim();
-                    if (GRAPHQL_ZOD_TYPES.has(innerType)) {
-                        allUsedGraphQLTypes.add(innerType);
-                    }
-                }
-                // Check in union types (e.g., "IExtensionIdentifier | string")
-                if (param.type.includes('|')) {
-                    const types = param.type.split('|').map(t => t.trim());
-                    types.forEach(type => {
-                        // Remove null and undefined
-                        if (type !== 'null' && type !== 'undefined' && GRAPHQL_ZOD_TYPES.has(type)) {
-                            allUsedGraphQLTypes.add(type);
-                        }
-                    });
-                }
-            });
-        });
-
-        servicesWithMethods.push({
-            ...service,
-            methods,
-        });
-    });
-
-    // Start generating output
-    let output = `// AUTO-GENERATED FILE - DO NOT EDIT
-// Generated from service interfaces in packages/common/src/services/
-// Run: yarn generateGraphql to regenerate
-
-import { z } from 'zod';
-`;
-
-    // Import GraphQL Zod schemas (including const enum schemas)
-    const allGraphQLSchemas = new Set([...allUsedGraphQLTypes, ...allUsedConstEnumSchemas]);
-    if (allGraphQLSchemas.size > 0) {
-        output += `\n// Import GraphQL-generated Zod schemas for detailed validation\nimport {\n`;
-        allGraphQLSchemas.forEach((typeName) => {
-            const schemaName = typeName.replace(/^I/, '') + 'Schema';
-            output += `    ${schemaName},\n`;
-        });
-        output += `} from '${GRAPHQL_SCHEMAS_IMPORT_PATH}';\n`;
-    }
-
-    // Import used enums (only regular enums, not const enums)
-    if (allUsedEnums.size > 0) {
-        output += `\n// Import enums\nimport {\n`;
-        allUsedEnums.forEach((enumName) => {
-            output += `    ${enumName},\n`;
-        });
-        output += `} from 'common/server';\n`;
-    }
-
-    output += `
-/**
- * Centralized Zod schemas for all service interfaces
- * 
- * Each service has its schemas exported as {ServiceName}Schemas
- * Use with zodSchemasToMoleculer() for Moleculer parameter validation
- * 
- * Example:
- * \`\`\`typescript
- * import { AccountServiceSchemas, zodSchemasToMoleculer } from 'common/server';
- * const paramOverrides = zodSchemasToMoleculer(AccountServiceSchemas);
- * \`\`\`
- */
-
-// Reusable schemas for common parameter types
-const PassthroughObjectSchema = z.object({}).passthrough();
-const ContextSchema = PassthroughObjectSchema;
-const ResourceSchema = PassthroughObjectSchema;
-const OptionsSchema = PassthroughObjectSchema;
-const DataSchema = PassthroughObjectSchema;
-const InputSchema = PassthroughObjectSchema;
-const FilterSchema = PassthroughObjectSchema;
-const WhereSchema = PassthroughObjectSchema;
-const RequestSchema = PassthroughObjectSchema;
-
-`;
-
-    // Generate schemas for each service
-    servicesWithMethods.forEach((service) => {
-        const schemaName = service.name.replace(/^I/, '').replace(/Service$/, 'Service');
-        const serviceName = service.name.replace(/^I/, ''); // e.g., "TagService"
-
-        output += `/**
- * Zod schemas for ${service.name}
- * Source: ${service.file}
- */
-export const ${schemaName}Schemas = {
-    /** Moleculer service topic/name - safe for minification */
-    topic: '${serviceName}' as const,
-`;
-
-        if (service.methods.length === 0) {
-            output += `    // No methods found\n`;
-        } else {
-            // Group methods by name to handle overloads (keep last signature)
-            const methodMap = new Map();
-            service.methods.forEach((method) => {
-                methodMap.set(method.name, method);
-            });
-
-            // Generate schemas for unique methods
-            methodMap.forEach((method, methodName) => {
-                if (method.parameters.length === 0) {
-                    output += `    ${methodName}: PassthroughObjectSchema,\n`;
-                } else {
-                    // Check if this method has only destructured params
-                    const hasOnlyDestructured = method.parameters.length === 1 && method.parameters[0].isDestructured;
-
-                    if (hasOnlyDestructured) {
-                        // For destructured params, use the type directly
-                        const param = method.parameters[0];
-                        const zodType = generateZodType(param.type, param.isOptional, param.name);
-                        output += `    ${methodName}: ${zodType},\n`;
-                    } else {
-                        output += `    ${methodName}: z.object({\n`;
-                        method.parameters.forEach((param) => {
-                            if (!param.isDestructured) {
-                                const zodType = generateZodType(param.type, param.isOptional, param.name);
-                                output += `        ${param.name}: ${zodType},\n`;
-                            }
-                        });
-                        output += `    }),\n`;
-                    }
-                }
-            });
-        }
-
-        output += `};\n\n`;
-    });
-
-    // Generate aggregated export with explicit type annotation to avoid TS7056 error
-    output += `/**
- * All service schemas aggregated
- * Type annotation prevents TypeScript from inferring overly complex types
- */
-export const AllServiceSchemas: Record<string, Record<string, any>> = {\n`;
-
-    servicesWithMethods.forEach((service) => {
-        const schemaName = service.name.replace(/^I/, '').replace(/Service$/, 'Service');
-        output += `    ${service.name}: ${schemaName}Schemas,\n`;
-    });
-
-    output += `};\n`;
-
-    // Write the file
-    fs.writeFileSync(OUTPUT_FILE, output, 'utf8');
-
-    console.log(`✅ Generated schemas for ${services.length} services`);
-
-    // Count total methods
-    const totalMethods = servicesWithMethods.reduce((sum, s) => sum + s.methods.length, 0);
-    console.log(`📊 Total methods: ${totalMethods}`);
-    console.log(`📝 Output: ${path.relative(process.cwd(), OUTPUT_FILE)}\n`);
-
-    return services.length;
-}
-
-// Export for CommonJS
-module.exports = { generateServiceSchemas };
-
-// CLI execution
-if (require.main === module) {
-    try {
-        generateServiceSchemas();
-    } catch (error) {
-        console.error('❌ Error generating service schemas:', error);
-        process.exit(1);
-    }
-}