@asad_dev/leo-generator 1.6.0 → 1.6.2

package/dist/index.js

@@ -530,17 +530,17 @@ function main() {
                 postmanCollectionId: config.postmanCollectionId
             }, hasFile);
         });
-        // Documentation update command
         program
             .command("update-docs")
             .alias("docs")
             .description("Update Postman and Swagger documentation for existing modules")
+            .argument("[modules...]", "Specific modules to update (optional)")
             .option("--modules-dir <path>", "Path to modules directory", "src/app/modules")
             .option("--no-postman", "Skip Postman collection generation")
             .option("--no-swagger", "Skip Swagger documentation generation")
             .option("--postman-dir <path>", "Custom Postman output directory", "postman")
             .option("--swagger-file <path>", "Custom Swagger file path", "swagger.json")
-            .action((options) => __awaiter(this, void 0, void 0, function* () {
+            .action((modules, options) => __awaiter(this, void 0, void 0, function* () {
             yield (0, documentationUpdater_1.updateExistingModulesDocumentation)(options.modulesDir, {
                 updatePostman: options.postman !== false,
                 updateSwagger: options.swagger !== false,
@@ -548,7 +548,7 @@ function main() {
                 swaggerFile: options.swaggerFile,
                 postmanApiKey: config.postmanApiKey,
                 postmanCollectionId: config.postmanCollectionId
-            });
+            }, modules);
         }));
         // Legacy support - direct module generation (backward compatibility)
         program

package/dist/utils/documentationUpdater.js

@@ -84,16 +84,25 @@ function updateAllDocumentation(moduleName_1, fields_1) {
     });
 }
 function updateExistingModulesDocumentation() {
-    return __awaiter(this, arguments, void 0, function* (modulesDir = "src/app/modules", options = {}) {
+    return __awaiter(this, arguments, void 0, function* (modulesDir = "src/app/modules", options = {}, targetModules = []) {
         const fullModulesPath = path.join(process.cwd(), modulesDir);
         if (!fs.existsSync(fullModulesPath)) {
             console.error(`❌ Modules directory not found: ${fullModulesPath}`);
             return;
         }
         console.log("🔄 Scanning existing modules for documentation updates...");
-        const moduleDirectories = fs.readdirSync(fullModulesPath, { withFileTypes: true })
+        let moduleDirectories = fs.readdirSync(fullModulesPath, { withFileTypes: true })
             .filter(dirent => dirent.isDirectory())
             .map(dirent => dirent.name);
+        // Filter if target modules are specified
+        if (targetModules && targetModules.length > 0) {
+            const targets = targetModules.map(m => m.toLowerCase());
+            moduleDirectories = moduleDirectories.filter(dir => targets.includes(dir.toLowerCase()));
+            if (moduleDirectories.length === 0) {
+                console.warn(`⚠️  None of the specified modules were found: ${targetModules.join(', ')}`);
+                return;
+            }
+        }
         let updatedCount = 0;
         // Process modules sequentially to avoid race conditions with Postman API
         for (const moduleDir of moduleDirectories) {
@@ -149,7 +158,9 @@ function extractFieldsFromInterface(interfaceFilePath) {
         }
         const fields = [];
         // Extract nested interface definitions first
-        const nestedInterfaces = extractNestedInterfaces(interfaceContent);
+        const camelCaseName = toCamelCase(moduleName);
+        const mainInterfaceName = `I${camelCaseName}`;
+        const nestedInterfaces = extractNestedInterfaces(interfaceContent, mainInterfaceName);
         // Extract enum definitions from the interface file
         const enumDefinitions = extractEnumDefinitions(interfaceContent);
         // Find the main interface definition (starts with 'I' and is the main entity interface)
@@ -225,15 +236,15 @@ function extractEnumDefinitions(content) {
     return enumMap;
 }
 // Extract nested interface definitions
-function extractNestedInterfaces(content) {
+function extractNestedInterfaces(content, mainInterfaceName) {
     const nestedInterfaces = new Map();
     // Find all interface definitions using a more robust approach
     const interfaceRegex = /export interface (\w+)\s*\{([\s\S]*?)\}/g;
     let match;
     while ((match = interfaceRegex.exec(content)) !== null) {
         const [, interfaceName, interfaceBody] = match;
-        // Skip the main interface (starts with 'I' and has more than 1 character after 'I')
-        if (interfaceName.startsWith('I') && interfaceName.length > 1 && interfaceName !== 'ItemsItem') {
+        // Skip the main interface
+        if (mainInterfaceName && interfaceName === mainInterfaceName) {
             continue;
         }
         // Skip type definitions

package/dist/utils/fieldParser.js

@@ -126,7 +126,40 @@ function parseFieldDefinitions(args) {
                                 isOptional,
                                 objectProperties,
                             });
-                            console.log(`Added field with ${objectProperties.length} properties`);
+                            console.log(`Added array:object field with ${objectProperties.length} properties`);
+                        }
+                        else if (type === "object" && parts.length > 2) {
+                            console.log(`Processing object field: ${name}`);
+                            const objectProperties = [];
+                            for (let j = 2; j < parts.length; j += 2) {
+                                if (j + 1 < parts.length) {
+                                    let propName = parts[j];
+                                    const propType = parts[j + 1];
+                                    console.log(`  Property: ${propName}:${propType}`);
+                                    const propIsOptional = propName.endsWith("?");
+                                    const propIsRequired = propName.endsWith("!");
+                                    if (propIsOptional) {
+                                        propName = propName.slice(0, -1);
+                                    }
+                                    if (propIsRequired) {
+                                        propName = propName.slice(0, -1);
+                                    }
+                                    objectProperties.push({
+                                        name: propName,
+                                        type: propType,
+                                        isOptional: propIsOptional,
+                                        isRequired: propIsRequired,
+                                    });
+                                }
+                            }
+                            fields.push({
+                                name,
+                                type,
+                                isRequired,
+                                isOptional,
+                                objectProperties,
+                            });
+                            console.log(`Added object field with ${objectProperties.length} properties`);
                         }
                         else if (type === "array" && parts.length > 2) {
                             // Handle array of references (e.g., products:array:objectid:Product)

package/dist/utils/interfaceGenerator.js

@@ -3,13 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateInterfaceContent = generateInterfaceContent;
 function generateInterfaceContent(camelCaseName, fields) {
     let interfaceContent = `import { Model, Types } from 'mongoose';\n\n`;
-    // Generate nested interfaces for array of objects
     fields.forEach((field) => {
-        var _a, _b;
-        if (field.type.toLowerCase() === "array" &&
-            ((_a = field.ref) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "object" &&
-            ((_b = field.objectProperties) === null || _b === void 0 ? void 0 : _b.length)) {
-            const nestedInterfaceName = `${toCamelCase(field.name)}Item`;
+        var _a, _b, _c;
+        const isArrayObject = field.type.toLowerCase() === "array" && ((_a = field.ref) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "object";
+        const isObjectWithProps = field.type.toLowerCase() === "object" && ((_b = field.objectProperties) === null || _b === void 0 ? void 0 : _b.length);
+        if ((isArrayObject || isObjectWithProps) && ((_c = field.objectProperties) === null || _c === void 0 ? void 0 : _c.length)) {
+            const nestedInterfaceName = isObjectWithProps
+                ? `I${toCamelCase(field.name)}`
+                : `${toCamelCase(field.name)}Item`;
             interfaceContent += `export interface ${nestedInterfaceName} {\n`;
             field.objectProperties.forEach((prop) => {
                 // Skip _id field
@@ -139,12 +140,8 @@ function mapToTypeScriptType(field) {
         case "object":
             if ((_c = field.objectProperties) === null || _c === void 0 ? void 0 : _c.length) {
                 // Object with defined properties
-                return `{ ${field.objectProperties
-                    .map((prop) => {
-                    const optionalMarker = prop.isOptional ? "?" : "";
-                    return `${prop.name}${optionalMarker}: ${mapToTypeScriptType(prop)}`;
-                })
-                    .join("; ")} }`;
+                const nestedInterfaceName = `I${toCamelCase(field.name)}`;
+                return nestedInterfaceName;
             }
             else {
                 return "Record<string, any>";

package/dist/utils/modelGenerator.js

@@ -41,11 +41,12 @@ function generateModelContent(camelCaseName, folderName, fields) {
 function generateNestedSchemas(fields) {
     let nestedSchemas = "";
     fields.forEach((field) => {
-        var _a, _b;
-        if (field.type.toLowerCase() === "array" &&
-            ((_a = field.ref) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "object" &&
-            ((_b = field.objectProperties) === null || _b === void 0 ? void 0 : _b.length)) {
-            const nestedSchemaName = `${field.name}ItemSchema`;
+        var _a, _b, _c;
+        const isArrayObject = field.type.toLowerCase() === "array" && ((_a = field.ref) === null || _a === void 0 ? void 0 : _a.toLowerCase()) === "object";
+        const isObjectWithProps = field.type.toLowerCase() === "object" && ((_b = field.objectProperties) === null || _b === void 0 ? void 0 : _b.length);
+        if ((isArrayObject || isObjectWithProps) && ((_c = field.objectProperties) === null || _c === void 0 ? void 0 : _c.length)) {
+            const isArray = field.type.toLowerCase() === "array";
+            const nestedSchemaName = isArray ? `${field.name}ItemSchema` : `${field.name}Schema`;
             nestedSchemas += `const ${nestedSchemaName} = new Schema({\n`;
             field.objectProperties.forEach((prop) => {
                 // Skip _id field
@@ -120,11 +121,8 @@ function mapToMongooseType(field) {
         case "object":
             if ((_c = field.objectProperties) === null || _c === void 0 ? void 0 : _c.length) {
                 // Object with defined properties
-                return `{ ${field.objectProperties
-                    .map((prop) => {
-                    return `${prop.name}: ${mapToMongooseType(prop)}`;
-                })
-                    .join(", ")} }`;
+                const nestedSchemaName = `${field.name}Schema`;
+                return nestedSchemaName;
             }
             else {
                 return "{ type: Schema.Types.Mixed }";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@asad_dev/leo-generator",
-  "version": "1.6.0",
+  "version": "1.6.2",
   "description": "Enhanced Express module generator with Mongoose models, automated Postman Cloud sync, and Swagger documentation",
   "main": "dist/index.js",
   "bin": {