@asad_dev/leo-generator 1.6.0

package/dist/utils/swaggerGenerator.js

@@ -0,0 +1,444 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSwaggerPaths = generateSwaggerPaths;
+exports.generateSwaggerSchemas = generateSwaggerSchemas;
+exports.updateSwaggerFile = updateSwaggerFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function generateSwaggerPaths(moduleName, fields) {
+    const camelCaseName = toCamelCase(moduleName);
+    const folderName = camelCaseName.toLowerCase();
+    const schema = generateSwaggerSchema(camelCaseName, fields);
+    const createSchema = generateSwaggerCreateSchema(camelCaseName, fields);
+    const updateSchema = generateSwaggerUpdateSchema(camelCaseName, fields);
+    return {
+        [`/${folderName}`]: {
+            post: {
+                tags: [camelCaseName],
+                summary: `Create a new ${camelCaseName}`,
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: `#/components/schemas/${camelCaseName}Create`
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "201": {
+                        description: `${camelCaseName} created successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean" },
+                                        message: { type: "string" },
+                                        data: {
+                                            $ref: `#/components/schemas/${camelCaseName}`
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "400": {
+                        description: "Bad request"
+                    }
+                }
+            },
+            get: {
+                tags: [camelCaseName],
+                summary: `Get all ${camelCaseName}s`,
+                responses: {
+                    "200": {
+                        description: `List of ${camelCaseName}s retrieved successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean" },
+                                        message: { type: "string" },
+                                        data: {
+                                            type: "array",
+                                            items: {
+                                                $ref: `#/components/schemas/${camelCaseName}`
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        [`/${folderName}/{id}`]: {
+            get: {
+                tags: [camelCaseName],
+                summary: `Get ${camelCaseName} by ID`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        required: true,
+                        schema: {
+                            type: "string"
+                        },
+                        description: `${camelCaseName} ID`
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: `${camelCaseName} retrieved successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean" },
+                                        message: { type: "string" },
+                                        data: {
+                                            $ref: `#/components/schemas/${camelCaseName}`
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        description: `${camelCaseName} not found`
+                    }
+                }
+            },
+            patch: {
+                tags: [camelCaseName],
+                summary: `Update ${camelCaseName}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        required: true,
+                        schema: {
+                            type: "string"
+                        },
+                        description: `${camelCaseName} ID`
+                    }
+                ],
+                requestBody: {
+                    required: true,
+                    content: {
+                        "application/json": {
+                            schema: {
+                                $ref: `#/components/schemas/${camelCaseName}Update`
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    "200": {
+                        description: `${camelCaseName} updated successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean" },
+                                        message: { type: "string" },
+                                        data: {
+                                            $ref: `#/components/schemas/${camelCaseName}`
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        description: `${camelCaseName} not found`
+                    }
+                }
+            },
+            delete: {
+                tags: [camelCaseName],
+                summary: `Delete ${camelCaseName}`,
+                parameters: [
+                    {
+                        name: "id",
+                        in: "path",
+                        required: true,
+                        schema: {
+                            type: "string"
+                        },
+                        description: `${camelCaseName} ID`
+                    }
+                ],
+                responses: {
+                    "200": {
+                        description: `${camelCaseName} deleted successfully`,
+                        content: {
+                            "application/json": {
+                                schema: {
+                                    type: "object",
+                                    properties: {
+                                        success: { type: "boolean" },
+                                        message: { type: "string" },
+                                        data: {
+                                            $ref: `#/components/schemas/${camelCaseName}`
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    "404": {
+                        description: `${camelCaseName} not found`
+                    }
+                }
+            }
+        }
+    };
+}
+function generateSwaggerSchemas(moduleName, fields) {
+    const camelCaseName = toCamelCase(moduleName);
+    const schemas = {};
+    // Generate nested schemas for complex types
+    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 = `${toCamelCase(field.name)}Item`;
+            schemas[nestedSchemaName] = generateSwaggerSchema(nestedSchemaName, field.objectProperties);
+        }
+    });
+    // Main schema
+    schemas[camelCaseName] = generateSwaggerSchema(camelCaseName, fields);
+    schemas[`${camelCaseName}Create`] = generateSwaggerCreateSchema(camelCaseName, fields);
+    schemas[`${camelCaseName}Update`] = generateSwaggerUpdateSchema(camelCaseName, fields);
+    return schemas;
+}
+function generateSwaggerSchema(schemaName, fields) {
+    const properties = {
+        _id: {
+            type: "string",
+            description: "MongoDB ObjectId"
+        }
+    };
+    const required = ["_id"];
+    fields.forEach(field => {
+        if (field.name.toLowerCase() === "_id")
+            return;
+        properties[field.name] = mapFieldToSwaggerProperty(field);
+        if (field.isRequired) {
+            required.push(field.name);
+        }
+    });
+    // Add timestamps
+    properties.createdAt = {
+        type: "string",
+        format: "date-time",
+        description: "Creation timestamp"
+    };
+    properties.updatedAt = {
+        type: "string",
+        format: "date-time",
+        description: "Last update timestamp"
+    };
+    return {
+        type: "object",
+        properties,
+        required
+    };
+}
+function generateSwaggerCreateSchema(schemaName, fields) {
+    const properties = {};
+    const required = [];
+    fields.forEach(field => {
+        if (field.name.toLowerCase() === "_id")
+            return;
+        properties[field.name] = mapFieldToSwaggerProperty(field);
+        if (field.isRequired) {
+            required.push(field.name);
+        }
+    });
+    return {
+        type: "object",
+        properties,
+        required
+    };
+}
+function generateSwaggerUpdateSchema(schemaName, fields) {
+    const properties = {};
+    fields.forEach(field => {
+        if (field.name.toLowerCase() === "_id")
+            return;
+        properties[field.name] = mapFieldToSwaggerProperty(field);
+    });
+    return {
+        type: "object",
+        properties
+    };
+}
+function mapFieldToSwaggerProperty(field) {
+    var _a, _b, _c, _d;
+    switch (field.type.toLowerCase()) {
+        case "string":
+            return {
+                type: "string",
+                description: `${field.name} field`
+            };
+        case "number":
+            return {
+                type: "number",
+                description: `${field.name} field`
+            };
+        case "boolean":
+            return {
+                type: "boolean",
+                description: `${field.name} field`
+            };
+        case "date":
+            return {
+                type: "string",
+                format: "date-time",
+                description: `${field.name} field`
+            };
+        case "enum":
+            return {
+                type: "string",
+                enum: field.enumValues || [],
+                description: `${field.name} field`
+            };
+        case "array":
+            if (((_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 = `${toCamelCase(field.name)}Item`;
+                return {
+                    type: "array",
+                    items: {
+                        $ref: `#/components/schemas/${nestedSchemaName}`
+                    },
+                    description: `Array of ${field.name} objects`
+                };
+            }
+            else if (((_c = field.arrayItemType) === null || _c === void 0 ? void 0 : _c.toLowerCase()) === "objectid") {
+                return {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    },
+                    description: `Array of ${field.name} references`
+                };
+            }
+            else {
+                return {
+                    type: "array",
+                    items: {
+                        type: "string"
+                    },
+                    description: `Array of ${field.name} items`
+                };
+            }
+        case "object":
+            if ((_d = field.objectProperties) === null || _d === void 0 ? void 0 : _d.length) {
+                const nestedProperties = {};
+                field.objectProperties.forEach(prop => {
+                    nestedProperties[prop.name] = mapFieldToSwaggerProperty(prop);
+                });
+                return {
+                    type: "object",
+                    properties: nestedProperties,
+                    description: `${field.name} object`
+                };
+            }
+            else {
+                return {
+                    type: "object",
+                    description: `${field.name} object`
+                };
+            }
+        case "objectid":
+        case "id":
+            return {
+                type: "string",
+                description: `${field.name} reference ID`
+            };
+        default:
+            return {
+                type: "string",
+                description: `${field.name} field`
+            };
+    }
+}
+function updateSwaggerFile(moduleName, fields, swaggerFilePath = "swagger.json") {
+    const fullPath = path.join(process.cwd(), swaggerFilePath);
+    let swaggerDoc = {
+        openapi: "3.0.0",
+        info: {
+            title: "API Documentation",
+            version: "1.0.0",
+            description: "Generated API documentation"
+        },
+        paths: {},
+        components: {
+            schemas: {}
+        }
+    };
+    // Load existing swagger file if it exists
+    if (fs.existsSync(fullPath)) {
+        try {
+            const existingContent = fs.readFileSync(fullPath, "utf-8");
+            swaggerDoc = JSON.parse(existingContent);
+        }
+        catch (error) {
+            console.warn("Could not parse existing swagger file, creating new one");
+        }
+    }
+    // Generate new paths and schemas
+    const newPaths = generateSwaggerPaths(moduleName, fields);
+    const newSchemas = generateSwaggerSchemas(moduleName, fields);
+    // Merge with existing
+    swaggerDoc.paths = Object.assign(Object.assign({}, swaggerDoc.paths), newPaths);
+    swaggerDoc.components.schemas = Object.assign(Object.assign({}, swaggerDoc.components.schemas), newSchemas);
+    // Write updated swagger file
+    fs.writeFileSync(fullPath, JSON.stringify(swaggerDoc, null, 2));
+    console.log(`✅ Swagger documentation updated: ${fullPath}`);
+}
+function toCamelCase(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/dist/utils/validationGenerator.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateValidationContent = generateValidationContent;
+function generateValidationContent(camelCaseName, fields) {
+    let validationContent = `import { z } from 'zod';\n\n`;
+    // Add nested schemas 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 nestedSchemaName = `${field.name}ItemSchema`;
+            validationContent += `const ${nestedSchemaName} = z.object({\n`;
+            // Add properties from the objectProperties array
+            field.objectProperties.forEach((prop) => {
+                // Skip _id field
+                if (prop.name.toLowerCase() === "_id") {
+                    return;
+                }
+                let zodType = mapToZodType(prop.type, prop);
+                // Add required/optional modifiers
+                if (prop.isRequired) {
+                    // Already required by default in Zod
+                }
+                else if (prop.isOptional) {
+                    zodType += ".optional()";
+                }
+                validationContent += `  ${prop.name}: ${zodType},\n`;
+            });
+            validationContent += `});\n\n`;
+        }
+    });
+    validationContent += `export const ${camelCaseName}Validations = {\n`;
+    // Create validation schema for create operation
+    validationContent += `  create: z.object({\n`;
+    validationContent += `    body: z.object({\n`;
+    // Add validation for each field
+    if (fields.length > 0) {
+        fields.forEach((field) => {
+            // Skip _id field
+            if (field.name.toLowerCase() === "_id") {
+                return;
+            }
+            let zodType = mapToZodType(field.type, field);
+            // Add required/optional modifiers
+            if (field.isRequired) {
+                // Already required by default in Zod
+            }
+            else if (field.isOptional) {
+                zodType += ".optional()";
+            }
+            validationContent += `      ${field.name}: ${zodType},\n`;
+        });
+    }
+    else {
+        validationContent += `      // Add validation fields\n`;
+    }
+    validationContent += `    }),\n`;
+    // Add params validation for ID
+    validationContent += `    params: z.object({\n`;
+    validationContent += `      id: z.string(),\n`;
+    validationContent += `    }).optional(),\n`;
+    validationContent += `  }),\n\n`;
+    // Add update validation schema (similar to create but all fields optional)
+    validationContent += `  update: z.object({\n`;
+    validationContent += `    body: z.object({\n`;
+    if (fields.length > 0) {
+        fields.forEach((field) => {
+            // Skip _id field
+            if (field.name.toLowerCase() === "_id") {
+                return;
+            }
+            let zodType = mapToZodType(field.type, field);
+            // All fields are optional in update
+            zodType += ".optional()";
+            validationContent += `      ${field.name}: ${zodType},\n`;
+        });
+    }
+    else {
+        validationContent += `      // Add validation fields\n`;
+    }
+    validationContent += `    }),\n`;
+    // Add params validation for ID
+    validationContent += `    params: z.object({\n`;
+    validationContent += `      id: z.string(),\n`;
+    validationContent += `    }),\n`;
+    validationContent += `  }),\n\n`;
+    // Add getById validation schema
+    validationContent += `  getById: z.object({\n`;
+    validationContent += `    params: z.object({\n`;
+    validationContent += `      id: z.string(),\n`;
+    validationContent += `    }),\n`;
+    validationContent += `  }),\n\n`;
+    // Add getAll validation schema with pagination
+    validationContent += `  getAll: z.object({\n`;
+    validationContent += `    query: z.object({\n`;
+    validationContent += `      page: z.string().optional(),\n`;
+    validationContent += `      limit: z.string().optional(),\n`;
+    validationContent += `      sortBy: z.string().optional(),\n`;
+    validationContent += `      sortOrder: z.string().optional(),\n`;
+    validationContent += `    }).optional(),\n`;
+    validationContent += `  }),\n\n`;
+    // Add delete validation schema
+    validationContent += `  delete: z.object({\n`;
+    validationContent += `    params: z.object({\n`;
+    validationContent += `      id: z.string(),\n`;
+    validationContent += `    }),\n`;
+    validationContent += `  }),\n`;
+    validationContent += `};\n`;
+    return validationContent;
+}
+// Helper function to map types to Zod validators
+function mapToZodType(type, field) {
+    var _a;
+    switch (type.toLowerCase()) {
+        case "string":
+            if ((field === null || field === void 0 ? void 0 : field.enumValues) && field.enumValues.length > 0) {
+                return `z.enum(['${field.enumValues.join("', '")}'])`;
+            }
+            return "z.string()";
+        case "number":
+            return "z.number()";
+        case "boolean":
+            return "z.boolean()";
+        case "date":
+            return "z.string().datetime()";
+        case "enum":
+            if ((field === null || field === void 0 ? void 0 : field.enumValues) && field.enumValues.length > 0) {
+                return `z.enum(['${field.enumValues.join("', '")}'])`;
+            }
+            return "z.string()";
+        case "array":
+            if (field === null || field === void 0 ? void 0 : field.ref) {
+                if (field.ref.toLowerCase() === "object" &&
+                    ((_a = field.objectProperties) === null || _a === void 0 ? void 0 : _a.length)) {
+                    // Array of objects with defined structure
+                    const nestedSchemaName = `${field.name}ItemSchema`;
+                    return `z.array(${nestedSchemaName})`;
+                }
+                else {
+                    // Array of references to other models (e.g., products:array:objectid:Product)
+                    return "z.array(z.string())";
+                }
+            }
+            else if (field === null || field === void 0 ? void 0 : field.arrayItemType) {
+                if (field.arrayItemType.toLowerCase() === "string") {
+                    return "z.array(z.string())";
+                }
+                else if (field.arrayItemType.toLowerCase() === "number") {
+                    return "z.array(z.number())";
+                }
+                else if (field.arrayItemType.toLowerCase() === "boolean") {
+                    return "z.array(z.boolean())";
+                }
+                else {
+                    return "z.array(z.string())";
+                }
+            }
+            else {
+                return "z.array(z.any())";
+            }
+        case "object":
+            return "z.record(z.string(), z.any())";
+        case "objectid":
+        case "id":
+            return "z.string()"; // ObjectId as string
+        default:
+            return "z.any()";
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@asad_dev/leo-generator",
+  "version": "1.6.0",
+  "description": "Enhanced Express module generator with Mongoose models, automated Postman Cloud sync, and Swagger documentation",
+  "main": "dist/index.js",
+  "bin": {
+    "leo-generate": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "ENHANCEMENTS.md",
+    "CHANGELOG.md",
+    "COMMAND_REFERENCE.md",
+    "SYNTAX_SUPPORT_SUMMARY.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unknow69/leo-generator.git"
+  },
+  "homepage": "https://github.com/unknow69/leo-generator#readme",
+  "bugs": {
+    "url": "https://github.com/unknow69/leo-generator/issues"
+  },
+  "scripts": {
+    "build": "tsc && npm run copy-templates",
+    "copy-templates": "if not exist dist\\templates mkdir dist\\templates && xcopy /E /I /Y src\\templates\\*.hbs dist\\templates\\",
+    "prepublishOnly": "npm run build",
+    "postinstall": "node -e \"try { require('fs').chmodSync(require('path').join(__dirname, 'dist/index.js'), '755') } catch(e) {}\""
+  },
+  "keywords": [
+    "leo",
+    "messi",
+    "goat",
+    "express",
+    "mongoose",
+    "generator",
+    "module",
+    "cli",
+    "postman",
+    "swagger",
+    "api",
+    "documentation",
+    "typescript",
+    "crud"
+  ],
+  "author": "Asaduzzaman",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^11.1.0",
+    "handlebars": "^4.7.8"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.5",
+    "@types/handlebars": "^4.1.0",
+    "typescript": "^5.3.3"
+  }
+}