wrekenfile-converter 2.0.0 → 2.0.3

package/README.md

@@ -77,6 +77,30 @@ const variables = {}; // Optionally provide Postman environment variables
 const wrekenfileYaml = generateWrekenfileFromPostman(collection, variables);
 ```
 
+---
+
+## CLI: Convert Postman Collection to Wrekenfile (Local/Dev Only)
+
+A standalone CLI script is provided for local development to convert a Postman collection JSON to a Wrekenfile YAML file. This script is **not included in the published library** and is safe to use only in your own repo.
+
+**Usage:**
+
+```bash
+npx ts-node src/cli/cli-postman-to-wrekenfile.ts <postman_collection.json> <output_wrekenfile.yaml> [postman_environment.json]
+```
+
+Real example
+
+```
+npx ts-node src/cli/cli-postman-to-wrekenfile.ts examples/transact_bridge_postman.json wrekenfile.yaml
+```
+
+- The third argument (environment file) is optional.
+- Prints helpful usage and error messages.
+- Does not affect library builds or usage as a dependency.
+
+---
+
 ### Validate a Wrekenfile
 
 ```typescript
@@ -182,4 +206,43 @@ mini-wrekenfiles/               # Generated mini chunks (if you save them)
 
 ## License
 
-MIT 
+MIT 
+
+# Wrekenfile Tools
+
+## Generate Wrekenfile from OpenAPI
+
+You can generate a Wrekenfile YAML from an OpenAPI (YAML or JSON) spec using the CLI:
+
+```
+npx ts-node src/cli/cli-openapi-to-wrekenfile.ts --input <openapi.yaml|json> [--output <wrekenfile.yaml>] [--cwd <dir>]
+```
+
+- `--input` or `-i`: Path to your OpenAPI YAML or JSON file (required)
+- `--output` or `-o`: Path to output Wrekenfile YAML (optional, defaults to `output_wrekenfile.yaml`)
+- `--cwd`: Working directory for resolving $refs (optional, defaults to the input file's directory)
+
+**Example:**
+```
+npx ts-node src/cli/cli-openapi-to-wrekenfile.ts --input examples/p3id_swagger.json --output wrekenfile.yaml --cwd .
+```
+
+---
+
+## Generate Mini Wrekenfiles from a Wrekenfile
+
+You can generate mini Wrekenfiles for each endpoint from a main Wrekenfile YAML using the CLI:
+
+```
+npx ts-node src/cli/cli-mini-wrekenfile-generator.ts --input <wrekenfile.yaml> [--output <dir>]
+```
+
+- `--input` or `-i`: Path to your main Wrekenfile YAML (required)
+- `--output` or `-o`: Output directory for mini Wrekenfiles (optional, defaults to `./mini-wrekenfiles`)
+
+**Example:**
+```
+npx ts-node src/cli/cli-mini-wrekenfile-generator.ts --input wrekenfile.yaml --output ./mini-wrekenfiles
+```
+
+This will generate one mini Wrekenfile per endpoint in the specified output directory. 

package/dist/cli/cli-mini-wrekenfile-generator.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/cli-mini-wrekenfile-generator.js

@@ -0,0 +1,107 @@
+#!/usr/bin/env node
+"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;
+    };
+})();
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const mini_wrekenfile_generator_1 = require("../mini-wrekenfile-generator");
+function printUsage() {
+    console.log('Usage: npx ts-node src/cli/cli-mini-wrekenfile-generator.ts --input <wrekenfile.yaml> [--output <dir>]');
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--input' || args[i] === '-i') {
+            opts.input = args[++i];
+        }
+        else if (args[i] === '--output' || args[i] === '-o') {
+            opts.output = args[++i];
+        }
+    }
+    return opts;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = parseArgs();
+        if (!opts.input) {
+            printUsage();
+            process.exit(1);
+        }
+        const inputPath = path.resolve(opts.input);
+        const outputDir = opts.output ? path.resolve(opts.output) : path.resolve('./mini-wrekenfiles');
+        if (!fs.existsSync(inputPath)) {
+            console.error(`Input file not found: ${inputPath}`);
+            process.exit(1);
+        }
+        let wrekenfileContent;
+        try {
+            wrekenfileContent = fs.readFileSync(inputPath, 'utf8');
+        }
+        catch (err) {
+            console.error('Failed to read input file:', err);
+            process.exit(1);
+        }
+        let miniWrekenfiles;
+        try {
+            miniWrekenfiles = (0, mini_wrekenfile_generator_1.generateMiniWrekenfiles)(wrekenfileContent);
+        }
+        catch (err) {
+            console.error('Failed to generate mini Wrekenfiles:', err);
+            process.exit(1);
+        }
+        try {
+            (0, mini_wrekenfile_generator_1.saveMiniWrekenfiles)(miniWrekenfiles, outputDir);
+            console.log(`Generated ${miniWrekenfiles.length} mini Wrekenfiles in ${outputDir}`);
+            for (const mini of miniWrekenfiles) {
+                console.log(`  - ${mini.metadata.filename}`);
+            }
+        }
+        catch (err) {
+            console.error('Failed to save mini Wrekenfiles:', err);
+            process.exit(1);
+        }
+    });
+}
+main();

package/dist/cli/cli-openapi-to-wrekenfile.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/cli-openapi-to-wrekenfile.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+"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;
+    };
+})();
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const js_yaml_1 = require("js-yaml");
+const openapi_to_wreken_1 = require("../openapi-to-wreken");
+function printUsage() {
+    console.log(`Usage: npx ts-node src/cli/cli-openapi-to-wrekenfile.ts --input <openapi.yaml|json> [--output <wrekenfile.yaml>] [--cwd <dir>]`);
+}
+function parseArgs() {
+    const args = process.argv.slice(2);
+    const opts = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--input' || args[i] === '-i') {
+            opts.input = args[++i];
+        }
+        else if (args[i] === '--output' || args[i] === '-o') {
+            opts.output = args[++i];
+        }
+        else if (args[i] === '--cwd') {
+            opts.cwd = args[++i];
+        }
+    }
+    return opts;
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const opts = parseArgs();
+        if (!opts.input) {
+            printUsage();
+            process.exit(1);
+        }
+        const inputPath = path.resolve(opts.input);
+        const outputPath = path.resolve(opts.output || 'output_wrekenfile.yaml');
+        const baseDir = opts.cwd ? path.resolve(opts.cwd) : path.dirname(inputPath);
+        if (!fs.existsSync(inputPath)) {
+            console.error(`Input file not found: ${inputPath}`);
+            process.exit(1);
+        }
+        let openapiSpec;
+        try {
+            const raw = fs.readFileSync(inputPath, 'utf8');
+            if (inputPath.endsWith('.json')) {
+                openapiSpec = JSON.parse(raw);
+            }
+            else {
+                openapiSpec = (0, js_yaml_1.load)(raw);
+            }
+        }
+        catch (err) {
+            console.error('Failed to load OpenAPI file:', err);
+            process.exit(1);
+        }
+        let wrekenfileYaml;
+        try {
+            wrekenfileYaml = (0, openapi_to_wreken_1.generateWrekenfile)(openapiSpec, baseDir);
+        }
+        catch (err) {
+            console.error('Failed to generate Wrekenfile:', err);
+            process.exit(1);
+        }
+        try {
+            fs.writeFileSync(outputPath, wrekenfileYaml, 'utf8');
+            console.log(`Wrekenfile written to ${outputPath}`);
+        }
+        catch (err) {
+            console.error('Failed to write output file:', err);
+            process.exit(1);
+        }
+    });
+}
+main();

package/dist/cli/cli-postman-to-wrekenfile.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/cli-postman-to-wrekenfile.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+"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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const postman_to_wrekenfile_1 = require("../postman-to-wrekenfile");
+function printUsage() {
+    console.log('Usage: npx ts-node src/cli-postman-to-wrekenfile.ts <postman_collection.json> <output_wrekenfile.yaml> [postman_environment.json]');
+    process.exit(1);
+}
+function main() {
+    return __awaiter(this, void 0, void 0, function* () {
+        const args = process.argv.slice(2);
+        if (args.length < 2) {
+            printUsage();
+        }
+        const [inputFile, outputFile, envFile] = args;
+        if (!fs_1.default.existsSync(inputFile)) {
+            console.error(`❌ Input file not found: ${inputFile}`);
+            process.exit(1);
+        }
+        let variables = {};
+        if (envFile) {
+            if (!fs_1.default.existsSync(envFile)) {
+                console.error(`❌ Environment file not found: ${envFile}`);
+                process.exit(1);
+            }
+            variables = (0, postman_to_wrekenfile_1.loadEnvironmentFile)(envFile);
+        }
+        try {
+            const postmanContent = fs_1.default.readFileSync(inputFile, 'utf8');
+            const postmanCollection = JSON.parse(postmanContent);
+            const wrekenfileYaml = (0, postman_to_wrekenfile_1.generateWrekenfile)(postmanCollection, variables);
+            fs_1.default.writeFileSync(outputFile, wrekenfileYaml);
+            console.log(`✅ Wrekenfile generated: ${outputFile}`);
+        }
+        catch (error) {
+            console.error(`❌ Error generating Wrekenfile: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}
+main();

package/dist/openapi-to-wreken.js

@@ -38,6 +38,7 @@ exports.generateWrekenfile = generateWrekenfile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const js_yaml_1 = require("js-yaml");
+const js_yaml_2 = require("js-yaml");
 const externalRefCache = {};
 function mapType(type, format) {
     if (format === 'uuid')
@@ -46,15 +47,32 @@ function mapType(type, format) {
         return 'TIMESTAMP';
     if (format === 'binary')
         return 'STRING'; // File uploads
-    const t = type === null || type === void 0 ? void 0 : type.toLowerCase();
-    if (t === 'string')
-        return 'STRING';
-    if (t === 'integer' || t === 'int')
-        return 'INT';
-    if (t === 'number')
-        return 'FLOAT';
-    if (t === 'boolean')
-        return 'BOOL';
+    if (typeof type === 'string') {
+        const t = type.toLowerCase();
+        if (t === 'string')
+            return 'STRING';
+        if (t === 'integer' || t === 'int')
+            return 'INT';
+        if (t === 'number')
+            return 'FLOAT';
+        if (t === 'boolean')
+            return 'BOOL';
+        return 'ANY';
+    }
+    // Handle array of types (OpenAPI allows type: ['string', 'null'])
+    if (Array.isArray(type) && type.length > 0 && typeof type[0] === 'string') {
+        const t = type[0].toLowerCase();
+        if (t === 'string')
+            return 'STRING';
+        if (t === 'integer' || t === 'int')
+            return 'INT';
+        if (t === 'number')
+            return 'FLOAT';
+        if (t === 'boolean')
+            return 'BOOL';
+        return 'ANY';
+    }
+    // Fallback for missing or unexpected type
     return 'ANY';
 }
 function generateDesc(op, method, path) {
@@ -89,26 +107,27 @@ function resolveRef(ref, spec, baseDir) {
         : externalRefCache[fullPath];
 }
 function getTypeFromSchema(schema, spec, baseDir) {
-    var _a, _b;
+    var _a;
+    if (!schema || typeof schema !== 'object') {
+        return 'ANY';
+    }
     if (schema.$ref) {
         const resolvedSchema = resolveRef(schema.$ref, spec, baseDir);
-        // Check if the resolved schema is a simple type
-        if (resolvedSchema.type && resolvedSchema.type !== 'object') {
+        if (resolvedSchema && resolvedSchema.type && resolvedSchema.type !== 'object') {
             return mapType(resolvedSchema.type, resolvedSchema.format);
         }
-        // It's a complex type, use STRUCT
         return `STRUCT(${schema.$ref.split('/').pop()})`;
     }
     if (schema.type === 'array') {
-        if ((_a = schema.items) === null || _a === void 0 ? void 0 : _a.$ref) {
+        if (schema.items && schema.items.$ref) {
             const resolvedItems = resolveRef(schema.items.$ref, spec, baseDir);
-            if (resolvedItems.type && resolvedItems.type !== 'object') {
+            if (resolvedItems && resolvedItems.type && resolvedItems.type !== 'object') {
                 return `[]${mapType(resolvedItems.type, resolvedItems.format)}`;
             }
             return `[]STRUCT(${schema.items.$ref.split('/').pop()})`;
         }
         else {
-            return `[]${mapType((_b = schema.items) === null || _b === void 0 ? void 0 : _b.type)}`;
+            return `[]${mapType((_a = schema.items) === null || _a === void 0 ? void 0 : _a.type)}`;
         }
     }
     if (schema.type && schema.type !== 'object') {
@@ -173,55 +192,55 @@ function extractStructs(spec, baseDir) {
     const schemas = ((_a = spec.components) === null || _a === void 0 ? void 0 : _a.schemas) || {};
     // Helper to recursively collect all referenced schemas, traversing all properties, arrays, and combiners
     function collectAllReferencedSchemas(schema, name) {
-        if (!name || structs[name])
+        if (!schema || typeof schema !== 'object' || !name || structs[name])
             return;
         const resolved = schema.$ref ? resolveRef(schema.$ref, spec, baseDir) : schema;
         const fields = parseSchema(name, resolved, spec, baseDir);
         structs[name] = fields;
         // Traverse all properties
-        if (resolved.type === 'object' && resolved.properties) {
+        if (resolved && resolved.type === 'object' && resolved.properties && typeof resolved.properties === 'object') {
             for (const [propName, prop] of Object.entries(resolved.properties)) {
-                if (prop.$ref) {
+                if (prop && typeof prop === 'object' && prop.$ref) {
                     const refName = prop.$ref.split('/').pop();
                     if (refName)
                         collectAllReferencedSchemas(resolveRef(prop.$ref, spec, baseDir), refName);
                 }
-                else if (prop.type === 'array' && prop.items) {
-                    if (prop.items.$ref) {
+                else if (prop && typeof prop === 'object' && prop.type === 'array' && prop.items) {
+                    if (prop.items && typeof prop.items === 'object' && prop.items.$ref) {
                         const refName = prop.items.$ref.split('/').pop();
                         if (refName)
                             collectAllReferencedSchemas(resolveRef(prop.items.$ref, spec, baseDir), refName);
                     }
-                    else if (prop.items.type === 'object' || prop.items.properties || prop.items.allOf || prop.items.oneOf || prop.items.anyOf) {
+                    else if (prop.items && typeof prop.items === 'object' && (prop.items.type === 'object' || prop.items.properties || prop.items.allOf || prop.items.oneOf || prop.items.anyOf)) {
                         collectAllReferencedSchemas(prop.items, name + '_' + propName + '_Item');
                     }
                 }
-                else if (prop.type === 'object' || prop.properties || prop.allOf || prop.oneOf || prop.anyOf) {
+                else if (prop && typeof prop === 'object' && (prop.type === 'object' || prop.properties || prop.allOf || prop.oneOf || prop.anyOf)) {
                     collectAllReferencedSchemas(prop, name + '_' + propName);
                 }
             }
         }
         // Traverse array items at root
-        if (resolved.type === 'array' && resolved.items) {
-            if (resolved.items.$ref) {
+        if (resolved && resolved.type === 'array' && resolved.items) {
+            if (resolved.items && typeof resolved.items === 'object' && resolved.items.$ref) {
                 const refName = resolved.items.$ref.split('/').pop();
                 if (refName)
                     collectAllReferencedSchemas(resolveRef(resolved.items.$ref, spec, baseDir), refName);
             }
-            else if (resolved.items.type === 'object' || resolved.items.properties || resolved.items.allOf || resolved.items.oneOf || resolved.items.anyOf) {
+            else if (resolved.items && typeof resolved.items === 'object' && (resolved.items.type === 'object' || resolved.items.properties || resolved.items.allOf || resolved.items.oneOf || resolved.items.anyOf)) {
                 collectAllReferencedSchemas(resolved.items, name + '_Item');
             }
         }
         // Traverse allOf/oneOf/anyOf
         for (const combiner of ['allOf', 'oneOf', 'anyOf']) {
-            if (Array.isArray(resolved[combiner])) {
+            if (resolved && Array.isArray(resolved[combiner])) {
                 for (const subSchema of resolved[combiner]) {
-                    if (subSchema.$ref) {
+                    if (subSchema && typeof subSchema === 'object' && subSchema.$ref) {
                         const refName = subSchema.$ref.split('/').pop();
                         if (refName)
                             collectAllReferencedSchemas(resolveRef(subSchema.$ref, spec, baseDir), refName);
                     }
-                    else {
+                    else if (subSchema && typeof subSchema === 'object') {
                         collectAllReferencedSchemas(subSchema, name + '_' + combiner);
                     }
                 }
@@ -232,7 +251,7 @@ function extractStructs(spec, baseDir) {
     for (const name in schemas) {
         collectAllReferencedSchemas(schemas[name], name);
         const schema = schemas[name];
-        if (schema.oneOf || schema.anyOf) {
+        if (schema && (schema.oneOf || schema.anyOf)) {
             structs[`${name}_Union`] = [{ name: 'value', type: 'ANY', required: 'FALSE' }];
         }
     }
@@ -243,13 +262,13 @@ function extractStructs(spec, baseDir) {
             // Extract request body schemas
             if ((_b = op.requestBody) === null || _b === void 0 ? void 0 : _b.content) {
                 for (const [contentType, content] of Object.entries(op.requestBody.content)) {
-                    if (content.schema) {
-                        if (content.schema.$ref) {
+                    if (content && content.schema) {
+                        if (content.schema && content.schema.$ref) {
                             const refName = content.schema.$ref.split('/').pop();
                             if (refName)
                                 collectAllReferencedSchemas(resolveRef(content.schema.$ref, spec, baseDir), refName);
                         }
-                        else {
+                        else if (content.schema && typeof content.schema === 'object') {
                             const requestStructName = generateStructName(operationId, method, pathStr, 'Request');
                             collectAllReferencedSchemas(content.schema, requestStructName);
                         }
@@ -259,15 +278,15 @@ function extractStructs(spec, baseDir) {
             // Extract response schemas
             if (op.responses) {
                 for (const [code, response] of Object.entries(op.responses)) {
-                    if (response.content) {
+                    if (response && response.content) {
                         for (const [contentType, content] of Object.entries(response.content)) {
-                            if (content.schema) {
-                                if (content.schema.$ref) {
+                            if (content && content.schema) {
+                                if (content.schema && content.schema.$ref) {
                                     const refName = content.schema.$ref.split('/').pop();
                                     if (refName)
                                         collectAllReferencedSchemas(resolveRef(content.schema.$ref, spec, baseDir), refName);
                                 }
-                                else {
+                                else if (content.schema && typeof content.schema === 'object') {
                                     const responseStructName = generateStructName(operationId, method, pathStr, `Response${code}`);
                                     collectAllReferencedSchemas(content.schema, responseStructName);
                                 }
@@ -399,13 +418,16 @@ function extractRequestBody(op, operationId, method, path, spec, baseDir) {
     if (contentType === 'application/json' && ((_a = requestBody.content[contentType]) === null || _a === void 0 ? void 0 : _a.schema)) {
         const bodySchema = requestBody.content[contentType].schema;
         let type;
-        if (bodySchema.$ref) {
+        if (bodySchema && bodySchema.$ref) {
             type = getTypeFromSchema(bodySchema, spec, baseDir);
         }
-        else {
+        else if (bodySchema) {
             const requestStructName = generateStructName(operationId, method, path, 'Request');
             type = `STRUCT(${requestStructName})`;
         }
+        else {
+            type = 'ANY';
+        }
         inputParams.push({
             name: 'body',
             type,
@@ -414,9 +436,9 @@ function extractRequestBody(op, operationId, method, path, spec, baseDir) {
     }
     else if (contentType === 'multipart/form-data' && ((_b = requestBody.content[contentType]) === null || _b === void 0 ? void 0 : _b.schema)) {
         const bodySchema = requestBody.content[contentType].schema;
-        if (bodySchema.properties) {
+        if (bodySchema && bodySchema.properties) {
             for (const [key, prop] of Object.entries(bodySchema.properties)) {
-                const type = prop.format === 'binary' ? 'FILE' : getTypeFromSchema(prop, spec, baseDir);
+                const type = prop && prop.format === 'binary' ? 'FILE' : getTypeFromSchema(prop, spec, baseDir);
                 const required = (bodySchema.required || []).includes(key) ? 'TRUE' : 'FALSE';
                 inputParams.push({
                     name: key,
@@ -541,6 +563,37 @@ function extractSecurityDefaults(spec) {
     }
     return defs;
 }
+function cleanYaml(yamlString) {
+    return yamlString
+        .replace(/\t/g, '  ')
+        .replace(/[\u00A0]/g, ' ')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+        .replace(/[ \t]+$/gm, '')
+        .replace(/\r\n/g, '\n');
+}
+function checkYamlForHiddenChars(yamlString) {
+    const lines = yamlString.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/\t/.test(line)) {
+            throw new Error(`YAML contains a TAB character at line ${i + 1}:\n${line}`);
+        }
+        if (/\u00A0/.test(line)) {
+            throw new Error(`YAML contains a non-breaking space (U+00A0) at line ${i + 1}:\n${line}`);
+        }
+        if (/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.test(line)) {
+            throw new Error(`YAML contains a non-printable character at line ${i + 1}:\n${line}`);
+        }
+    }
+}
+function validateYaml(yamlString) {
+    try {
+        (0, js_yaml_2.load)(yamlString);
+    }
+    catch (e) {
+        throw new Error('Generated YAML is invalid: ' + e.message);
+    }
+}
 function generateWrekenfile(spec, baseDir) {
     var _a, _b;
     if (!spec || typeof spec !== 'object') {
@@ -549,7 +602,7 @@ function generateWrekenfile(spec, baseDir) {
     if (!baseDir || typeof baseDir !== 'string') {
         throw new Error("Argument 'baseDir' is required and must be a string");
     }
-    return (0, js_yaml_1.dump)({
+    let yamlString = (0, js_yaml_1.dump)({
         VERSION: '1.2',
         INIT: {
             DEFAULTS: [
@@ -560,4 +613,8 @@ function generateWrekenfile(spec, baseDir) {
         INTERFACES: extractInterfaces(spec, baseDir),
         STRUCTS: extractStructs(spec, baseDir),
     });
+    yamlString = cleanYaml(yamlString);
+    checkYamlForHiddenChars(yamlString);
+    validateYaml(yamlString);
+    return yamlString;
 }

package/dist/openapi-to-wrekenfile.js

@@ -0,0 +1,10 @@
+"use strict";
+// Defensive fixes for OpenAPI v3 schema traversal
+// 1. Guard all property accesses ($ref, type, properties, items, allOf, oneOf, anyOf) with checks for existence and correct type
+// 2. Guard all calls to getTypeFromSchema or similar with checks for defined/object
+// 3. Apply these checks in all recursive struct extraction and interface extraction logic
+// Example for a recursive schema traversal:
+// if (schema && typeof schema === 'object' && schema.$ref) { ... }
+// if (prop && typeof prop === 'object' && prop.type === 'array' && prop.items) { ... }
+// ...
+// Please apply these patterns throughout the file, especially in struct extraction and interface extraction functions. 

package/dist/openapi-v2-to-wrekenfile.js

@@ -38,6 +38,7 @@ exports.generateWrekenfile = generateWrekenfile;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const js_yaml_1 = require("js-yaml");
+const js_yaml_2 = require("js-yaml");
 const externalRefCache = {};
 function mapType(type, format) {
     if (format === 'uuid')
@@ -46,15 +47,32 @@ function mapType(type, format) {
         return 'TIMESTAMP';
     if (format === 'binary')
         return 'STRING'; // File uploads
-    const t = type === null || type === void 0 ? void 0 : type.toLowerCase();
-    if (t === 'string')
-        return 'STRING';
-    if (t === 'integer' || t === 'int')
-        return 'INT';
-    if (t === 'number')
-        return 'FLOAT';
-    if (t === 'boolean')
-        return 'BOOL';
+    if (typeof type === 'string') {
+        const t = type.toLowerCase();
+        if (t === 'string')
+            return 'STRING';
+        if (t === 'integer' || t === 'int')
+            return 'INT';
+        if (t === 'number')
+            return 'FLOAT';
+        if (t === 'boolean')
+            return 'BOOL';
+        return 'ANY';
+    }
+    // Handle array of types (OpenAPI allows type: ['string', 'null'])
+    if (Array.isArray(type) && type.length > 0 && typeof type[0] === 'string') {
+        const t = type[0].toLowerCase();
+        if (t === 'string')
+            return 'STRING';
+        if (t === 'integer' || t === 'int')
+            return 'INT';
+        if (t === 'number')
+            return 'FLOAT';
+        if (t === 'boolean')
+            return 'BOOL';
+        return 'ANY';
+    }
+    // Fallback for missing or unexpected type
     return 'ANY';
 }
 function generateDesc(op, method, path) {
@@ -89,14 +107,16 @@ function resolveRef(ref, spec, baseDir) {
         : externalRefCache[fullPath];
 }
 function parseSchema(name, schema, spec, baseDir, depth = 0) {
-    var _a, _b, _c;
+    var _a, _b;
     if (depth > 3)
         return [];
-    if (schema.$ref)
+    if (schema && typeof schema === 'object' && schema.$ref) {
         return parseSchema(name, resolveRef(schema.$ref, spec, baseDir), spec, baseDir, depth + 1);
-    if (schema.allOf)
+    }
+    if (schema && typeof schema === 'object' && schema.allOf) {
         return schema.allOf.flatMap((s) => parseSchema(name, s, spec, baseDir, depth + 1));
-    if (schema.oneOf || schema.anyOf) {
+    }
+    if (schema && typeof schema === 'object' && (schema.oneOf || schema.anyOf)) {
         return [{
                 name: 'variant',
                 type: `STRUCT(${name}_Union)`,
@@ -104,32 +124,33 @@ function parseSchema(name, schema, spec, baseDir, depth = 0) {
             }];
     }
     // Handle primitive types - return empty array (no struct needed)
-    if (schema.type && schema.type !== 'object' && schema.type !== 'array') {
+    if (schema && typeof schema === 'object' && schema.type && schema.type !== 'object' && schema.type !== 'array') {
         return [];
     }
     // Handle empty objects (no properties) - return empty array
-    if (schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
+    if (schema && typeof schema === 'object' && schema.type === 'object' && (!schema.properties || Object.keys(schema.properties).length === 0)) {
         return [];
     }
     const fields = [];
-    if ((_a = schema.discriminator) === null || _a === void 0 ? void 0 : _a.propertyName) {
+    if (schema && typeof schema === 'object' && ((_a = schema.discriminator) === null || _a === void 0 ? void 0 : _a.propertyName)) {
         fields.push({
             name: schema.discriminator.propertyName,
             type: 'STRING',
             required: 'REQUIRED',
         });
     }
-    if (schema.type === 'object' && schema.properties) {
+    if (schema && typeof schema === 'object' && schema.type === 'object' && schema.properties) {
         for (const [key, prop] of Object.entries(schema.properties)) {
             let type = 'ANY';
-            if (prop.$ref)
+            if (prop && typeof prop === 'object' && prop.$ref) {
                 type = `STRUCT(${prop.$ref.split('/').pop()})`;
-            else if (prop.type === 'array') {
-                if ((_b = prop.items) === null || _b === void 0 ? void 0 : _b.$ref) {
+            }
+            else if (prop && typeof prop === 'object' && prop.type === 'array') {
+                if (prop && typeof prop === 'object' && prop.items && prop.items.$ref) {
                     type = `[]STRUCT(${prop.items.$ref.split('/').pop()})`;
                 }
-                else {
-                    type = `[]${mapType((_c = prop.items) === null || _c === void 0 ? void 0 : _c.type)}`;
+                else if (prop && typeof prop === 'object' && prop.items) {
+                    type = `[]${mapType((_b = prop.items) === null || _b === void 0 ? void 0 : _b.type)}`;
                 }
             }
             else {
@@ -162,7 +183,7 @@ function extractStructs(spec, baseDir) {
         const fields = parseSchema(name, definitions[name], spec, baseDir);
         // Always add the struct, even if empty
         structs[name] = fields;
-        if (definitions[name].oneOf || definitions[name].anyOf) {
+        if (definitions[name] && typeof definitions[name] === 'object' && (definitions[name].oneOf || definitions[name].anyOf)) {
             structs[`${name}_Union`] = [{ name: 'value', type: 'ANY', required: 'OPTIONAL' }];
         }
     }
@@ -173,7 +194,7 @@ function extractStructs(spec, baseDir) {
             // Extract request body schemas (OpenAPI v2 uses parameters with in: body)
             if (op.parameters) {
                 for (const param of op.parameters) {
-                    if (param.in === 'body' && param.schema && !param.schema.$ref) {
+                    if (param && typeof param === 'object' && param.in === 'body' && param.schema && !param.schema.$ref) {
                         // Inline schema - create a struct for it only if it has fields
                         const requestStructName = generateStructName(operationId, method, pathStr, 'Request');
                         const fields = parseSchema(requestStructName, param.schema, spec, baseDir);
@@ -186,7 +207,7 @@ function extractStructs(spec, baseDir) {
             // Extract response schemas (OpenAPI v2 has schema directly in response)
             if (op.responses) {
                 for (const [code, response] of Object.entries(op.responses)) {
-                    if (response.schema && !response.schema.$ref) {
+                    if (response && typeof response === 'object' && response.schema && !response.schema.$ref) {
                         // Inline schema - create a struct for it only if it has fields
                         const responseStructName = generateStructName(operationId, method, pathStr, `Response${code}`);
                         const fields = parseSchema(responseStructName, response.schema, spec, baseDir);
@@ -203,7 +224,7 @@ function extractStructs(spec, baseDir) {
 function getContentTypeAndBodyType(op) {
     var _a;
     // Check if there are formData parameters
-    const hasFormData = (_a = op.parameters) === null || _a === void 0 ? void 0 : _a.some((param) => param.in === 'formData');
+    const hasFormData = (_a = op.parameters) === null || _a === void 0 ? void 0 : _a.some((param) => param && typeof param === 'object' && param.in === 'formData');
     if (hasFormData) {
         return { contentType: 'multipart/form-data', bodyType: 'FORM' };
     }
@@ -259,7 +280,7 @@ function getHeadersForOperation(op, spec) {
     // Check if Authorization is used as a parameter but not defined in securityDefinitions
     if (op.parameters) {
         for (const param of op.parameters) {
-            if (param.in === 'header' && param.name === 'Authorization' && !headerMap.has('Authorization')) {
+            if (param && typeof param === 'object' && param.in === 'header' && param.name === 'Authorization' && !headerMap.has('Authorization')) {
                 headerMap.set('Authorization', 'bearer_token');
             }
         }
@@ -280,25 +301,25 @@ function extractParameters(op, spec) {
     if (op.parameters) {
         for (let param of op.parameters) {
             // Resolve parameter references
-            if (param.$ref) {
+            if (param && typeof param === 'object' && param.$ref) {
                 if (!spec.swaggerFile) {
                     throw new Error("spec.swaggerFile is undefined. Please provide a valid baseDir when calling generateWrekenfile, or ensure all refs are internal.");
                 }
                 param = resolveRef(param.$ref, spec, path.dirname(spec.swaggerFile));
             }
             // Skip body and formData parameters, they are handled in extractRequestBody
-            if (param.in === 'body' || param.in === 'formData') {
+            if (param && typeof param === 'object' && (param.in === 'body' || param.in === 'formData')) {
                 continue;
             }
-            const paramType = param.in || 'query';
-            const paramName = param.name;
-            const paramSchema = param.schema || {}; // Schema is sometimes at root of param
-            const paramRequired = param.required ? 'REQUIRED' : 'OPTIONAL';
+            const paramType = param && typeof param === 'object' ? param.in || 'query' : 'query';
+            const paramName = param && typeof param === 'object' ? param.name : '';
+            const paramSchema = param && typeof param === 'object' ? param.schema || {} : {}; // Schema is sometimes at root of param
+            const paramRequired = param && typeof param === 'object' ? param.required ? 'REQUIRED' : 'OPTIONAL' : 'OPTIONAL';
             let type = 'STRING';
-            if (param.type) {
+            if (param && typeof param === 'object' && param.type) {
                 type = mapType(param.type, param.format);
             }
-            else if (paramSchema.type) {
+            else if (paramSchema && typeof paramSchema === 'object' && paramSchema.type) {
                 type = mapType(paramSchema.type, paramSchema.format);
             }
             inputParams.push({
@@ -314,10 +335,10 @@ function extractParameters(op, spec) {
 function extractRequestBody(op, operationId, method, path) {
     var _a;
     const inputParams = [];
-    const bodyParam = (op.parameters || []).find((p) => p.in === 'body');
+    const bodyParam = (op.parameters || []).find((p) => p && typeof p === 'object' && p.in === 'body');
     if (bodyParam) {
         let type;
-        if ((_a = bodyParam.schema) === null || _a === void 0 ? void 0 : _a.$ref) {
+        if (bodyParam && typeof bodyParam === 'object' && ((_a = bodyParam.schema) === null || _a === void 0 ? void 0 : _a.$ref)) {
             type = `STRUCT(${bodyParam.schema.$ref.split('/').pop()})`;
         }
         else {
@@ -328,17 +349,17 @@ function extractRequestBody(op, operationId, method, path) {
         inputParams.push({
             name: 'body',
             type,
-            required: bodyParam.required ? 'REQUIRED' : 'OPTIONAL',
+            required: bodyParam && typeof bodyParam === 'object' ? bodyParam.required ? 'REQUIRED' : 'OPTIONAL' : 'OPTIONAL',
         });
     }
     // Handle formData for multipart/form-data
     if (op.parameters) {
         for (const param of op.parameters) {
-            if (param.in === 'formData') {
+            if (param && typeof param === 'object' && param.in === 'formData') {
                 inputParams.push({
-                    name: param.name,
-                    type: param.type === 'file' ? 'FILE' : mapType(param.type, param.format),
-                    required: param.required ? 'REQUIRED' : 'OPTIONAL',
+                    name: param && typeof param === 'object' ? param.name : '',
+                    type: param && typeof param === 'object' ? param.type === 'file' ? 'FILE' : mapType(param.type, param.format) : 'STRING',
+                    required: param && typeof param === 'object' ? param.required ? 'REQUIRED' : 'OPTIONAL' : 'OPTIONAL',
                 });
             }
         }
@@ -351,25 +372,25 @@ function extractResponses(op, operationId, method, path) {
     // Handle all response codes (success and error)
     for (const [code, response] of Object.entries(op.responses || {})) {
         let returnType = 'ANY';
-        if (response.schema) {
-            if (response.schema.$ref) {
+        if (response && typeof response === 'object' && response.schema) {
+            if (response && typeof response === 'object' && response.schema.$ref) {
                 returnType = `STRUCT(${response.schema.$ref.split('/').pop()})`;
             }
-            else if (response.schema.type === 'array') {
-                if ((_a = response.schema.items) === null || _a === void 0 ? void 0 : _a.$ref) {
+            else if (response && typeof response === 'object' && response.schema.type === 'array') {
+                if (response && typeof response === 'object' && ((_a = response.schema.items) === null || _a === void 0 ? void 0 : _a.$ref)) {
                     returnType = `[]STRUCT(${response.schema.items.$ref.split('/').pop()})`;
                 }
-                else {
+                else if (response && typeof response === 'object' && response.schema.items) {
                     returnType = `[]${mapType((_b = response.schema.items) === null || _b === void 0 ? void 0 : _b.type)}`;
                 }
             }
-            else if (response.schema.type === 'object') {
+            else if (response && typeof response === 'object' && response.schema.type === 'object') {
                 // Inline schema - use generated struct name
                 const responseStructName = generateStructName(operationId, method, path, `Response${code}`);
                 returnType = `STRUCT(${responseStructName})`;
             }
         }
-        else if (code === '204' || response.description === 'No Content') {
+        else if (code === '204' || response && typeof response === 'object' && response.description === 'No Content') {
             returnType = 'VOID';
         }
         returns.push({
@@ -396,7 +417,7 @@ function extractInterfaces(spec) {
             const alias = operationId;
             const endpoint = pathStr.includes('{') ? `\`${base}${pathStr}\`` : `${base}${pathStr}`;
             // Check if operation is hidden from docs
-            const isPrivate = op['x-hidden-from-docs'] === true;
+            const isPrivate = op && typeof op === 'object' && op['x-hidden-from-docs'] === true;
             const visibility = isPrivate ? 'PRIVATE' : 'PUBLIC';
             const { bodyType } = getContentTypeAndBodyType(op);
             const headers = getHeadersForOperation(op, spec);
@@ -426,23 +447,54 @@ function extractSecurityDefaults(spec) {
     const defs = [];
     const securityDefinitions = spec.securityDefinitions || {};
     for (const [name, scheme] of Object.entries(securityDefinitions)) {
-        if (scheme.type === 'basic') {
+        if (scheme && typeof scheme === 'object' && scheme.type === 'basic') {
             defs.push({ basic_auth: 'Basic <BASE64>' });
         }
-        else if (scheme.type === 'apiKey') {
-            if (scheme.in === 'header') {
+        else if (scheme && typeof scheme === 'object' && scheme.type === 'apiKey') {
+            if (scheme && typeof scheme === 'object' && scheme.in === 'header') {
                 defs.push({ [scheme.name.toLowerCase()]: `<${scheme.name.toUpperCase()}>` });
             }
-            else if (scheme.in === 'query') {
+            else if (scheme && typeof scheme === 'object' && scheme.in === 'query') {
                 defs.push({ [`query_${scheme.name.toLowerCase()}`]: `<${scheme.name.toUpperCase()}>` });
             }
         }
-        else if (scheme.type === 'oauth2') {
+        else if (scheme && typeof scheme === 'object' && scheme.type === 'oauth2') {
             defs.push({ bearer_token: 'BEARER <ACCESS_TOKEN>' });
         }
     }
     return defs;
 }
+function cleanYaml(yamlString) {
+    return yamlString
+        .replace(/\t/g, '  ')
+        .replace(/[\u00A0]/g, ' ')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+        .replace(/[ \t]+$/gm, '')
+        .replace(/\r\n/g, '\n');
+}
+function checkYamlForHiddenChars(yamlString) {
+    const lines = yamlString.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/\t/.test(line)) {
+            throw new Error(`YAML contains a TAB character at line ${i + 1}:\n${line}`);
+        }
+        if (/\u00A0/.test(line)) {
+            throw new Error(`YAML contains a non-breaking space (U+00A0) at line ${i + 1}:\n${line}`);
+        }
+        if (/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.test(line)) {
+            throw new Error(`YAML contains a non-printable character at line ${i + 1}:\n${line}`);
+        }
+    }
+}
+function validateYaml(yamlString) {
+    try {
+        (0, js_yaml_2.load)(yamlString);
+    }
+    catch (e) {
+        throw new Error('Generated YAML is invalid: ' + e.message);
+    }
+}
 function generateWrekenfile(spec, baseDir) {
     var _a;
     if (!spec || typeof spec !== 'object') {
@@ -453,7 +505,7 @@ function generateWrekenfile(spec, baseDir) {
     }
     // Add swaggerFile path to spec for ref resolution
     spec.swaggerFile = baseDir;
-    return (0, js_yaml_1.dump)({
+    let yamlString = (0, js_yaml_1.dump)({
         VERSION: '1.2',
         INIT: {
             DEFAULTS: [
@@ -464,4 +516,8 @@ function generateWrekenfile(spec, baseDir) {
         INTERFACES: extractInterfaces(spec),
         STRUCTS: extractStructs(spec, baseDir),
     }, { noArrayIndent: true });
+    yamlString = cleanYaml(yamlString);
+    checkYamlForHiddenChars(yamlString);
+    validateYaml(yamlString);
+    return yamlString;
 }

package/dist/postman-to-wrekenfile.js

@@ -43,6 +43,7 @@ exports.loadEnvironmentFile = loadEnvironmentFile;
 exports.extractCollectionVariables = extractCollectionVariables;
 exports.resolveVariables = resolveVariables;
 const fs = __importStar(require("fs"));
+const js_yaml_1 = require("js-yaml");
 function mapType(value) {
     if (typeof value === 'string') {
         // Check for common patterns
@@ -103,14 +104,24 @@ function extractFieldsFromObject(obj, depth = 0, prefix = '') {
     if (typeof obj !== 'object')
         return [];
     const fields = [];
+    const keyCount = {};
     for (const [key, value] of Object.entries(obj)) {
         let type = 'ANY';
         let required = 'OPTIONAL';
+        // Handle duplicate keys
+        let fieldName = key;
+        if (keyCount[key] === undefined) {
+            keyCount[key] = 1;
+        }
+        else {
+            keyCount[key] += 1;
+            fieldName = `${key} ${keyCount[key]}`;
+        }
         if (Array.isArray(value)) {
             if (value.length > 0) {
                 const firstItem = value[0];
                 if (typeof firstItem === 'object' && firstItem !== null) {
-                    type = `[]STRUCT(${prefix}${key}Item)`;
+                    type = `[]STRUCT(${prefix}${fieldName}Item)`;
                 }
                 else {
                     type = `[]${mapType(firstItem)}`;
@@ -121,13 +132,13 @@ function extractFieldsFromObject(obj, depth = 0, prefix = '') {
             }
         }
         else if (typeof value === 'object' && value !== null) {
-            type = `STRUCT(${prefix}${key})`;
+            type = `STRUCT(${prefix}${fieldName})`;
         }
         else {
             type = mapType(value);
         }
         fields.push({
-            name: key,
+            name: fieldName,
             type,
             required,
         });
@@ -175,6 +186,17 @@ function resolveVariables(value, variables) {
 }
 function extractStructs(collection, variables) {
     const structs = {};
+    const structNameCount = {};
+    function getUniqueStructName(name) {
+        if (structs[name] === undefined) {
+            structNameCount[name] = 1;
+            return name;
+        }
+        else {
+            structNameCount[name] = (structNameCount[name] || 1) + 1;
+            return `${name} ${structNameCount[name]}`;
+        }
+    }
     function processItem(item) {
         var _a;
         if (item.request) {
@@ -186,47 +208,41 @@ function extractStructs(collection, variables) {
             if (((_a = item.request.body) === null || _a === void 0 ? void 0 : _a.mode) === 'raw' && item.request.body.raw) {
                 const bodyData = parseJsonExample(item.request.body.raw);
                 if (bodyData) {
-                    const requestStructName = generateStructName(itemName, method, path, 'Request');
+                    let requestStructName = generateStructName(itemName, method, path, 'Request');
+                    requestStructName = getUniqueStructName(requestStructName);
                     const fields = extractFieldsFromObject(bodyData, 0, requestStructName);
-                    // Always add the struct, even if empty
                     structs[requestStructName] = fields.length > 0 ? fields : [];
-                    // Extract nested structs from request body
                     extractNestedStructs(bodyData, structs, requestStructName);
                 }
             }
             // Extract response structs from examples
             if (item.response) {
                 for (const response of item.response) {
-                    const responseStructName = generateStructName(itemName, method, path, `Response${response.code || '200'}`);
+                    let responseStructName = generateStructName(itemName, method, path, `Response${response.code || '200'}`);
+                    responseStructName = getUniqueStructName(responseStructName);
                     if (response.body) {
                         const responseData = parseJsonExample(response.body);
                         if (responseData) {
                             const fields = extractFieldsFromObject(responseData, 0, responseStructName);
-                            // Always add the struct, even if empty
                             structs[responseStructName] = fields.length > 0 ? fields : [];
-                            // Extract nested structs from response body
                             extractNestedStructs(responseData, structs, responseStructName);
                         }
                         else {
-                            // If body is not valid JSON or empty, create an empty struct
                             structs[responseStructName] = [];
                         }
                     }
                     else {
-                        // If no body at all, still create an empty struct
                         structs[responseStructName] = [];
                     }
                 }
             }
         }
-        // Recursively process nested items
         if (item.item) {
             for (const subItem of item.item) {
                 processItem(subItem);
             }
         }
     }
-    // Process all items in the collection
     for (const item of collection.item) {
         processItem(item);
     }
@@ -396,6 +412,17 @@ function extractResponses(item, itemName, method, path) {
 }
 function extractOperations(collection, variables) {
     const operations = [];
+    const operationNameCount = {};
+    function getUniqueOperationName(name) {
+        if (operationNameCount[name] === undefined) {
+            operationNameCount[name] = 1;
+            return name;
+        }
+        else {
+            operationNameCount[name] += 1;
+            return `${name} ${operationNameCount[name]}`;
+        }
+    }
     function processItem(item) {
         if (item.request) {
             const method = item.request.method || 'GET';
@@ -403,13 +430,13 @@ function extractOperations(collection, variables) {
             const path = extractPathFromUrl(url, variables);
             const itemName = item.name || 'unknown';
             // Generate operation ID
-            const operationId = itemName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+            let operationId = itemName.toLowerCase().replace(/[^a-z0-9]/g, '-');
+            operationId = getUniqueOperationName(operationId);
             const { contentType, bodyType } = getContentTypeAndBodyType(item.request);
             const headers = getHeadersForOperation(item.request, variables);
             const inputs = extractParameters(item.request, variables);
             const bodyInputs = extractRequestBody(item.request, itemName, method, path);
             const returns = extractResponses(item, itemName, method, path);
-            // Combine all inputs (avoid duplicates)
             const allInputs = [...inputs];
             if (bodyInputs.length > 0) {
                 allInputs.push(...bodyInputs);
@@ -430,20 +457,51 @@ function extractOperations(collection, variables) {
                 RETURNS: returns,
             });
         }
-        // Recursively process nested items
         if (item.item) {
             for (const subItem of item.item) {
                 processItem(subItem);
             }
         }
     }
-    // Process all items in the collection
     for (const item of collection.item) {
         processItem(item);
     }
     return operations;
 }
+function cleanYaml(yamlString) {
+    // Remove tabs, non-breaking spaces, and non-printable chars except standard whitespace and newlines
+    return yamlString
+        .replace(/\t/g, '  ')
+        .replace(/[\u00A0]/g, ' ')
+        .replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '')
+        .replace(/[ \t]+$/gm, '')
+        .replace(/\r\n/g, '\n');
+}
+function checkYamlForHiddenChars(yamlString) {
+    const lines = yamlString.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (/\t/.test(line)) {
+            throw new Error(`YAML contains a TAB character at line ${i + 1}:\n${line}`);
+        }
+        if (/\u00A0/.test(line)) {
+            throw new Error(`YAML contains a non-breaking space (U+00A0) at line ${i + 1}:\n${line}`);
+        }
+        if (/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/.test(line)) {
+            throw new Error(`YAML contains a non-printable character at line ${i + 1}:\n${line}`);
+        }
+    }
+}
+function validateYaml(yamlString) {
+    try {
+        (0, js_yaml_1.load)(yamlString);
+    }
+    catch (e) {
+        throw new Error('Generated YAML is invalid: ' + e.message);
+    }
+}
 function generateWrekenfile(collection, variables) {
+    var _a;
     if (!collection || typeof collection !== 'object') {
         throw new Error("Argument 'collection' is required and must be an object");
     }
@@ -453,7 +511,6 @@ function generateWrekenfile(collection, variables) {
     const structs = extractStructs(collection, variables);
     const operations = extractOperations(collection, variables);
     let wrekenfile = `VERSION: '1.2'\n`;
-    // Add INIT section with defaults from environment variables
     wrekenfile += `INIT:\n`;
     wrekenfile += `  DEFAULTS:\n`;
     if (Object.keys(variables).length === 0) {
@@ -461,7 +518,6 @@ function generateWrekenfile(collection, variables) {
     }
     else {
         for (const [key, value] of Object.entries(variables)) {
-            // Skip sensitive values like API keys and signatures
             const sensitiveKeys = ['api_key', 'api-key', 'x-api-key', 'signature', 'x-signature', 'authorization', 'token', 'password', 'secret'];
             const isSensitive = sensitiveKeys.some(sensitiveKey => key.toLowerCase().includes(sensitiveKey));
             if (isSensitive) {
@@ -472,7 +528,6 @@ function generateWrekenfile(collection, variables) {
             }
         }
     }
-    // Add INTERFACES section
     wrekenfile += `INTERFACES:\n`;
     for (const operation of operations) {
         wrekenfile += `  ${operation.name}:\n`;
@@ -490,11 +545,12 @@ function generateWrekenfile(collection, variables) {
             }
         }
         wrekenfile += `      BODYTYPE: ${operation.HTTP.BODYTYPE}\n`;
-        wrekenfile += `    INPUTS:\n`;
+        // INPUTS
         if (operation.INPUTS.length === 0) {
-            wrekenfile += `      []\n`;
+            wrekenfile += `    INPUTS: []\n`;
         }
         else {
+            wrekenfile += `    INPUTS:\n`;
             for (const input of operation.INPUTS) {
                 wrekenfile += `      - name: ${input.name}\n`;
                 wrekenfile += `        type: ${input.type}\n`;
@@ -504,6 +560,7 @@ function generateWrekenfile(collection, variables) {
                 }
             }
         }
+        // RETURNS
         wrekenfile += `    RETURNS:\n`;
         for (const ret of operation.RETURNS) {
             wrekenfile += `      - RETURNTYPE: ${ret.RETURNTYPE}\n`;
@@ -511,20 +568,33 @@ function generateWrekenfile(collection, variables) {
             wrekenfile += `        CODE: '${ret.CODE}'\n`;
         }
     }
-    // Add STRUCTS section
     wrekenfile += `STRUCTS:\n`;
     for (const [structName, fields] of Object.entries(structs)) {
-        wrekenfile += `  ${structName}:\n`;
         if (fields.length === 0) {
-            wrekenfile += `    []\n`;
+            wrekenfile += `  ${structName}: []\n`;
         }
         else {
+            wrekenfile += `  ${structName}:\n`;
             for (const field of fields) {
-                wrekenfile += `    - name: ${field.name}\n`;
-                wrekenfile += `      type: ${field.type}\n`;
-                wrekenfile += `      required: '${field.required}'\n`;
+                wrekenfile += '    - name: ' + field.name + '\n';
+                // Quote type if it contains non-alphanumeric characters (except underscore)
+                let typeValue = field.type;
+                if (/[^a-zA-Z0-9_]/.test(typeValue)) {
+                    typeValue = '"' + typeValue.replace(/"/g, '\"') + '"';
+                }
+                wrekenfile += '      type: ' + typeValue + '\n';
+                wrekenfile += "      required: '" + field.required + "'\n";
             }
         }
     }
+    // Debug print: show first 20 lines of STRUCTS block
+    const structsBlock = (_a = wrekenfile.split('STRUCTS:')[1]) === null || _a === void 0 ? void 0 : _a.split('\n').slice(0, 20).join('\n');
+    if (structsBlock) {
+        console.log('--- STRUCTS block preview ---');
+        console.log(structsBlock);
+    }
+    wrekenfile = cleanYaml(wrekenfile);
+    checkYamlForHiddenChars(wrekenfile);
+    validateYaml(wrekenfile);
     return wrekenfile;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wrekenfile-converter",
-  "version": "2.0.0",
+  "version": "2.0.3",
   "description": "Convert OpenAPI and Postman specs to Wrekenfile format with mini-chunking for vector DB storage",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",