@asad_dev/leo-generator 1.6.0

package/dist/utils/interfaceGenerator.js

@@ -0,0 +1,158 @@
+"use strict";
+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`;
+            interfaceContent += `export interface ${nestedInterfaceName} {\n`;
+            field.objectProperties.forEach((prop) => {
+                // Skip _id field
+                if (prop.name.toLowerCase() === "_id") {
+                    return;
+                }
+                const optionalMarker = prop.isOptional ? "?" : "";
+                const tsType = mapToTypeScriptType(prop);
+                interfaceContent += `  ${prop.name}${optionalMarker}: ${tsType};\n`;
+            });
+            interfaceContent += `}\n\n`;
+        }
+    });
+    // Generate enum types
+    fields.forEach((field) => {
+        if (field.type.toLowerCase() === "enum" &&
+            field.enumValues &&
+            field.enumValues.length > 0) {
+            const enumName = `${toCamelCase(field.name)}Enum`;
+            interfaceContent += `export enum ${enumName} {\n`;
+            field.enumValues.forEach(value => {
+                // Handle special characters in enum keys if necessary, simplified for now
+                const key = value.toUpperCase().replace(/[^A-Z0-9]/g, '_');
+                interfaceContent += `  ${key} = '${value}',\n`;
+            });
+            interfaceContent += `}\n\n`;
+        }
+    });
+    // Generate filterable interface
+    const filterableFields = fields.filter(f => f.type.toLowerCase() === "string" || f.type.toLowerCase() === "enum");
+    if (filterableFields.length > 0) {
+        interfaceContent += `export interface I${camelCaseName}Filterables {\n`;
+        interfaceContent += `  searchTerm?: string;\n`;
+        filterableFields.forEach((field) => {
+            let tsType = mapToTypeScriptType(field);
+            // Use enum type if applicable
+            if (field.type.toLowerCase() === "enum" &&
+                field.enumValues &&
+                field.enumValues.length > 0) {
+                tsType = `${toCamelCase(field.name)}Enum`;
+            }
+            interfaceContent += `  ${field.name}?: ${tsType};\n`;
+        });
+        interfaceContent += `}\n\n`;
+    }
+    // Generate main interface
+    interfaceContent += `export interface I${camelCaseName} {\n`;
+    interfaceContent += `  _id: Types.ObjectId;\n`;
+    if (fields.length > 0) {
+        fields.forEach((field) => {
+            // Skip _id field as it's already included
+            if (field.name.toLowerCase() === "_id") {
+                return;
+            }
+            const optionalMarker = field.isOptional ? "?" : "";
+            let tsType = mapToTypeScriptType(field);
+            // Use enum type if applicable
+            if (field.type.toLowerCase() === "enum" &&
+                field.enumValues &&
+                field.enumValues.length > 0) {
+                tsType = `${toCamelCase(field.name)}Enum`;
+            }
+            interfaceContent += `  ${field.name}${optionalMarker}: ${tsType};\n`;
+        });
+    }
+    else {
+        interfaceContent += `  // Define interface properties here\n`;
+    }
+    interfaceContent += `}\n\n`;
+    // Generate model interface
+    interfaceContent += `export type ${camelCaseName}Model = Model<I${camelCaseName}, {}, {}>;\n`;
+    return interfaceContent;
+}
+// Helper function to convert to camelCase
+function toCamelCase(str) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+}
+// Helper function to map field definitions to TypeScript types
+function mapToTypeScriptType(field) {
+    var _a, _b, _c;
+    switch (field.type.toLowerCase()) {
+        case "string":
+            return "string";
+        case "number":
+            return "number";
+        case "boolean":
+            return "boolean";
+        case "date":
+            return "Date";
+        case "enum":
+            if (field.enumValues && field.enumValues.length > 0) {
+                return `${toCamelCase(field.name)}Enum`;
+            }
+            return "string";
+        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)) {
+                // Array of objects with defined structure
+                const nestedInterfaceName = `${toCamelCase(field.name)}Item`;
+                return `${nestedInterfaceName}[]`;
+            }
+            else if (field.arrayItemType) {
+                // Array with specified item type
+                switch (field.arrayItemType.toLowerCase()) {
+                    case "string":
+                        return "string[]";
+                    case "number":
+                        return "number[]";
+                    case "boolean":
+                        return "boolean[]";
+                    case "date":
+                        return "Date[]";
+                    case "objectid":
+                    case "id":
+                        return "Types.ObjectId[]";
+                    default:
+                        return "string[]"; // Default to string[] instead of any[]
+                }
+            }
+            else if (field.ref && field.type.toLowerCase() === "array") {
+                // Handle array of references (e.g., products:array:objectid:Product)
+                return "Types.ObjectId[]";
+            }
+            else {
+                return "string[]"; // Default to string[] instead of any[]
+            }
+        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("; ")} }`;
+            }
+            else {
+                return "Record<string, any>";
+            }
+        case "objectid":
+        case "id":
+            return "Types.ObjectId";
+        default:
+            return "string"; // Default to string instead of any
+    }
+}

package/dist/utils/modelGenerator.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateModelContent = generateModelContent;
+function generateModelContent(camelCaseName, folderName, fields) {
+    let modelContent = `import { Schema, model } from 'mongoose';\nimport { I${camelCaseName}, ${camelCaseName}Model } from './${folderName}.interface';\n\n`;
+    // Generate nested schemas
+    const nestedSchemas = generateNestedSchemas(fields);
+    modelContent += nestedSchemas;
+    modelContent += `const ${folderName}Schema = new Schema<I${camelCaseName}, ${camelCaseName}Model>({\n`;
+    // Add fields to schema
+    if (fields.length > 0) {
+        fields.forEach((field) => {
+            // Skip _id field as it's automatically handled by MongoDB
+            if (field.name.toLowerCase() === "_id") {
+                return;
+            }
+            let schemaType = mapToMongooseType(field);
+            if (!schemaType)
+                return; // Skip if empty (like for _id)
+            let additionalProps = "";
+            // Add required property if marked as required
+            if (field.isRequired) {
+                additionalProps += ", required: true";
+            }
+            // Add default value for enum if it has values
+            if (field.type.toLowerCase() === "enum" &&
+                field.enumValues &&
+                field.enumValues.length > 0) {
+                additionalProps += `, default: '${field.enumValues[0]}'`;
+            }
+            modelContent += `  ${field.name}: ${schemaType}${additionalProps},\n`;
+        });
+    }
+    else {
+        modelContent += "  // Define schema fields here\n";
+    }
+    modelContent += `}, {\n  timestamps: true\n});\n\nexport const ${camelCaseName} = model<I${camelCaseName}, ${camelCaseName}Model>('${camelCaseName}', ${folderName}Schema);\n`;
+    return modelContent;
+}
+// Helper function to generate nested schemas for complex types
+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`;
+            nestedSchemas += `const ${nestedSchemaName} = new Schema({\n`;
+            field.objectProperties.forEach((prop) => {
+                // Skip _id field
+                if (prop.name.toLowerCase() === "_id") {
+                    return;
+                }
+                let schemaType = mapToMongooseType(prop);
+                let additionalProps = "";
+                if (prop.isRequired) {
+                    additionalProps += ", required: true";
+                }
+                nestedSchemas += `  ${prop.name}: ${schemaType}${additionalProps},\n`;
+            });
+            nestedSchemas += `}, { _id: false });\n\n`;
+        }
+    });
+    return nestedSchemas;
+}
+// Helper function to map field definitions to Mongoose schema types
+function mapToMongooseType(field) {
+    var _a, _b, _c;
+    // Skip _id field as it's automatically handled by MongoDB
+    if (field.name.toLowerCase() === "_id") {
+        return ""; // Skip this field
+    }
+    switch (field.type.toLowerCase()) {
+        case "string":
+            return "{ type: String }";
+        case "number":
+            return "{ type: Number }";
+        case "boolean":
+            return "{ type: Boolean }";
+        case "date":
+            return "{ type: Date }";
+        case "enum":
+            if (field.enumValues && field.enumValues.length > 0) {
+                return `{ type: String, enum: ['${field.enumValues.join("', '")}'] }`;
+            }
+            return "{ type: String }";
+        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)) {
+                // Array of objects with defined structure
+                const nestedSchemaName = `${field.name}ItemSchema`;
+                return `[${nestedSchemaName}]`;
+            }
+            else if (field.arrayItemType) {
+                // Array with specified item type
+                switch (field.arrayItemType.toLowerCase()) {
+                    case "string":
+                        return "{ type: [String] }";
+                    case "number":
+                        return "{ type: [Number] }";
+                    case "boolean":
+                        return "{ type: [Boolean] }";
+                    case "date":
+                        return "{ type: [Date] }";
+                    case "objectid":
+                    case "id":
+                        return `{ type: [Schema.Types.ObjectId], ref: '${field.ref || "Document"}' }`;
+                    default:
+                        return "{ type: [String] }"; // Default to String instead of Mixed
+                }
+            }
+            else if (field.ref) {
+                // Handle array of references (e.g., products:array:objectid:Product)
+                return `{ type: [Schema.Types.ObjectId], ref: '${field.ref}' }`;
+            }
+            else {
+                return "{ type: [String] }"; // Default to String instead of Mixed
+            }
+        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(", ")} }`;
+            }
+            else {
+                return "{ type: Schema.Types.Mixed }";
+            }
+        case "objectid":
+        case "id":
+            return field.ref
+                ? `{ type: Schema.Types.ObjectId, ref: '${field.ref}' }`
+                : "{ type: Schema.Types.ObjectId }";
+        default:
+            return "{ type: String }"; // Default to String instead of Mixed
+    }
+}

package/dist/utils/postmanApi.js

@@ -0,0 +1,113 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updatePostmanCollectionViaApi = updatePostmanCollectionViaApi;
+/**
+ * Updates an existing Postman collection via the Postman API.
+ * It fetches the existing collection, finds the folder for the current module,
+ * and replaces it or adds it to the collection.
+ */
+function updatePostmanCollectionViaApi(moduleName, newCollectionData, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apiKey, collectionId } = config;
+        const url = `https://api.getpostman.com/collections/${collectionId}`;
+        try {
+            console.log(`🚀 Connecting to Postman API for collection: ${collectionId}...`);
+            // 1. Fetch current collection
+            const getResponse = yield fetch(url, {
+                headers: {
+                    "X-Api-Key": apiKey
+                }
+            });
+            if (!getResponse.ok) {
+                const errorData = yield getResponse.json();
+                throw new Error(`Failed to fetch collection: ${JSON.stringify(errorData)}`);
+            }
+            const currentData = yield getResponse.json();
+            const collection = currentData.collection;
+            console.log(`📦 Collection Keys: ${Object.keys(collection).join(", ")}`);
+            // Handle variables - Postman API is very strict about variable structure
+            if (collection.variable) {
+                console.log(`🔍 Found ${collection.variable.length} variables in collection.`);
+                if (collection.variable.length > 0) {
+                    console.log(`📄 Sample Variable [0]: ${JSON.stringify(collection.variable[0])}`);
+                }
+                const allowedTypes = ["string", "secret", "boolean", "number", "any"];
+                // Filter and sanitize variables
+                const validVariables = collection.variable
+                    .map((v) => {
+                    var _a;
+                    const currentType = (_a = v.type) === null || _a === void 0 ? void 0 : _a.toLowerCase();
+                    if (!currentType || !allowedTypes.includes(currentType)) {
+                        // Force to 'string' if invalid or missing
+                        const newType = "string";
+                        console.log(`  🔧 Variable '${v.key}' has invalid/missing type: '${v.type || "N/A"}'. Setting to '${newType}'.`);
+                        return Object.assign(Object.assign({}, v), { type: newType });
+                    }
+                    return v;
+                })
+                    .filter((v) => v.key && v.type); // Remove any variables without key or type
+                // Only keep variable array if it has valid entries
+                if (validVariables.length > 0) {
+                    collection.variable = validVariables;
+                }
+                else {
+                    console.log("  🗑️ Removing empty/invalid variable array");
+                    delete collection.variable;
+                }
+            }
+            else {
+                console.log("ℹ️ No variables found in retrieved collection.");
+            }
+            // 2. Prepare the new folder for this module
+            // The generator creates a collection where 'item' is the list of requests
+            const moduleFolderName = `${moduleName} API`;
+            const newModuleFolder = {
+                name: moduleFolderName,
+                item: newCollectionData.item
+            };
+            // 3. Update or Add the folder in the existing collection
+            if (!collection.item) {
+                collection.item = [];
+            }
+            const existingFolderIndex = collection.item.findIndex((item) => item.name === moduleFolderName);
+            if (existingFolderIndex !== -1) {
+                console.log(`📝 Updating existing folder: ${moduleFolderName} in Postman collection`);
+                collection.item[existingFolderIndex] = newModuleFolder;
+            }
+            else {
+                console.log(`➕ Adding new folder: ${moduleFolderName} to Postman collection`);
+                collection.item.push(newModuleFolder);
+            }
+            // Debug: Log a snippet of what we are sending
+            console.log(`📤 Sending PUT request to Postman API...`);
+            // console.log(`📤 Variable snippet: ${JSON.stringify(collection.variable?.slice(0, 1))}`);
+            // 4. Send the updated collection back to Postman
+            const putResponse = yield fetch(url, {
+                method: "PUT",
+                headers: {
+                    "X-Api-Key": apiKey,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify({ collection })
+            });
+            if (!putResponse.ok) {
+                const errorData = yield putResponse.json();
+                throw new Error(`Failed to update collection: ${JSON.stringify(errorData)}`);
+            }
+            console.log(`✅ Postman collection updated successfully via API!`);
+        }
+        catch (error) {
+            console.error("❌ Error updating Postman collection via API:", error instanceof Error ? error.message : String(error));
+            throw error;
+        }
+    });
+}