@common-stack/server-core 7.2.1-alpha.37 → 7.2.1-alpha.39

package/lib/moleculer-generation/generateAllServiceSchemas.cjs

@@ -0,0 +1,522 @@
+#!/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
+ */
+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();
+
+    function visit(node) {
+        if (ts.isInterfaceDeclaration(node) && node.name.text === interfaceName) {
+            node.members.forEach((member) => {
+                if (ts.isMethodSignature(member) && member.name) {
+                    const methodName = member.name.getText(sourceFile);
+                    const parameters = [];
+
+                    if (member.parameters) {
+                        member.parameters.forEach((param) => {
+                            const paramName = param.name.getText(sourceFile);
+                            const paramType = param.type ? param.type.getText(sourceFile) : '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,
+                            });
+                        });
+                    }
+
+                    methods.push({
+                        name: methodName,
+                        parameters,
+                    });
+                }
+            });
+        }
+
+        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 - create union
+            const schemas = nonNullableTypes.map(t => generateZodType(t, false, paramName));
+            zodType = `z.union([${schemas.join(', ')}])`;
+            if (hasNull || hasUndefined) {
+                return `${zodType}.optional().nullable()`;
+            }
+            return zodType;
+        }
+    }
+
+    // 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
+    else if (paramName === 'context' || paramName === 'userContext') {
+        zodType = 'ContextSchema';
+    } else if (paramName === 'resource') {
+        zodType = 'ResourceSchema';
+    } else if (paramName === 'options' || paramName === 'paginationOptions') {
+        zodType = 'OptionsSchema';
+    } else if (paramName === 'data' || paramName === 'updateData') {
+        zodType = 'DataSchema';
+    } else if (paramName === 'input') {
+        zodType = 'InputSchema';
+    } else if (paramName === 'filter' || paramName === 'criteria' || paramName === 'additionalFilters') {
+        zodType = 'FilterSchema';
+    } else if (paramName === 'where') {
+        zodType = 'WhereSchema';
+    } else if (paramName === 'request') {
+        zodType = 'RequestSchema';
+    }
+    // Default: treat as object
+    else {
+        zodType = 'PassthroughObjectSchema';
+    }
+
+    return isOptional ? `${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);
+                    }
+                }
+            });
+        });
+
+        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);
+    }
+}

package/package.json

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