wrekenfile-converter 2.0.6 → 2.1.0

package/dist/v2/cli/cli-openapi-v2-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_v2_to_wrekenfile_1 = require("../openapi-v2-to-wrekenfile");
+function printUsage() {
+    console.log(`Usage: npx ts-node src/cli/rest/cli-openapi-v2-to-wrekenfile.ts --input <swagger.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 swaggerSpec;
+        try {
+            const raw = fs.readFileSync(inputPath, 'utf8');
+            if (inputPath.endsWith('.json')) {
+                swaggerSpec = JSON.parse(raw);
+            }
+            else {
+                swaggerSpec = (0, js_yaml_1.load)(raw);
+            }
+        }
+        catch (err) {
+            console.error('Failed to load Swagger/OpenAPI v2 file:', err);
+            process.exit(1);
+        }
+        let wrekenfileYaml;
+        try {
+            wrekenfileYaml = (0, openapi_v2_to_wrekenfile_1.generateWrekenfile)(swaggerSpec, baseDir);
+        }
+        catch (err) {
+            console.error('Failed to generate Wrekenfile:', err);
+            process.exit(1);
+        }
+        try {
+            fs.writeFileSync(outputPath, wrekenfileYaml, 'utf8');
+            console.log(`✅ Wrekenfile v2.0.1 written to ${outputPath}`);
+        }
+        catch (err) {
+            console.error('Failed to write output file:', err);
+            process.exit(1);
+        }
+    });
+}
+main();

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

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

package/dist/v2/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/rest/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 v2.0.1 generated: ${outputFile}`);
+        }
+        catch (error) {
+            console.error(`❌ Error generating Wrekenfile: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}
+main();

package/dist/v2/index.d.ts

@@ -0,0 +1,4 @@
+export { generateWrekenfile } from './openapi-to-wreken';
+export { generateWrekenfile as generateWrekenfileV2 } from './openapi-v2-to-wrekenfile';
+export { generateWrekenfile as generateWrekenfileFromPostman, extractStructs, extractOperations, mapType, parseJsonExample, extractFieldsFromObject, loadEnvironmentFile, extractCollectionVariables, resolveVariables } from './postman-to-wrekenfile';
+export { generateMiniWrekenfiles, saveMiniWrekenfiles, MiniWrekenfile } from './mini-wrekenfile-generator';

package/dist/v2/index.js

@@ -0,0 +1,25 @@
+"use strict";
+// v2 entry point - Wrekenfile spec version 2.1.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.saveMiniWrekenfiles = exports.generateMiniWrekenfiles = exports.resolveVariables = exports.extractCollectionVariables = exports.loadEnvironmentFile = exports.extractFieldsFromObject = exports.parseJsonExample = exports.mapType = exports.extractOperations = exports.extractStructs = exports.generateWrekenfileFromPostman = exports.generateWrekenfileV2 = exports.generateWrekenfile = void 0;
+// Export OpenAPI v3 converter
+var openapi_to_wreken_1 = require("./openapi-to-wreken");
+Object.defineProperty(exports, "generateWrekenfile", { enumerable: true, get: function () { return openapi_to_wreken_1.generateWrekenfile; } });
+// Export OpenAPI v2 (Swagger) converter
+var openapi_v2_to_wrekenfile_1 = require("./openapi-v2-to-wrekenfile");
+Object.defineProperty(exports, "generateWrekenfileV2", { enumerable: true, get: function () { return openapi_v2_to_wrekenfile_1.generateWrekenfile; } });
+// Export Postman converter
+var postman_to_wrekenfile_1 = require("./postman-to-wrekenfile");
+Object.defineProperty(exports, "generateWrekenfileFromPostman", { enumerable: true, get: function () { return postman_to_wrekenfile_1.generateWrekenfile; } });
+Object.defineProperty(exports, "extractStructs", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractStructs; } });
+Object.defineProperty(exports, "extractOperations", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractOperations; } });
+Object.defineProperty(exports, "mapType", { enumerable: true, get: function () { return postman_to_wrekenfile_1.mapType; } });
+Object.defineProperty(exports, "parseJsonExample", { enumerable: true, get: function () { return postman_to_wrekenfile_1.parseJsonExample; } });
+Object.defineProperty(exports, "extractFieldsFromObject", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractFieldsFromObject; } });
+Object.defineProperty(exports, "loadEnvironmentFile", { enumerable: true, get: function () { return postman_to_wrekenfile_1.loadEnvironmentFile; } });
+Object.defineProperty(exports, "extractCollectionVariables", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractCollectionVariables; } });
+Object.defineProperty(exports, "resolveVariables", { enumerable: true, get: function () { return postman_to_wrekenfile_1.resolveVariables; } });
+// Export mini Wrekenfile generator
+var mini_wrekenfile_generator_1 = require("./mini-wrekenfile-generator");
+Object.defineProperty(exports, "generateMiniWrekenfiles", { enumerable: true, get: function () { return mini_wrekenfile_generator_1.generateMiniWrekenfiles; } });
+Object.defineProperty(exports, "saveMiniWrekenfiles", { enumerable: true, get: function () { return mini_wrekenfile_generator_1.saveMiniWrekenfiles; } });

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

@@ -0,0 +1,13 @@
+export interface MiniWrekenfile {
+    content: string;
+    metadata: {
+        endpoint?: string;
+        interface?: string;
+        source?: string;
+        methods: string[];
+        structs: string[];
+        filename: string;
+    };
+}
+export declare function generateMiniWrekenfiles(wrekenfileContent: string): MiniWrekenfile[];
+export declare function saveMiniWrekenfiles(miniWrekenfiles: MiniWrekenfile[], outputDir?: string): void;

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

@@ -0,0 +1,289 @@
+"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.generateMiniWrekenfiles = generateMiniWrekenfiles;
+exports.saveMiniWrekenfiles = saveMiniWrekenfiles;
+const yaml = __importStar(require("js-yaml"));
+const fs = __importStar(require("fs"));
+const constants_1 = require("./utils/constants");
+function generateMiniWrekenfiles(wrekenfileContent) {
+    if (!wrekenfileContent || typeof wrekenfileContent !== 'string') {
+        throw new Error("Argument 'wrekenfileContent' is required and must be a string");
+    }
+    const data = yaml.load(wrekenfileContent);
+    if (!data.METHODS) {
+        throw new Error('No METHODS section found in Wrekenfile');
+    }
+    const methodGroups = groupMethods(data.METHODS);
+    const miniWrekenfiles = [];
+    for (const [groupKey, groupInfo] of Object.entries(methodGroups)) {
+        miniWrekenfiles.push(createMiniWrekenfile(data, groupKey, groupInfo));
+    }
+    return miniWrekenfiles;
+}
+const BACKTICK = '`';
+const SLASH = '/';
+function normalizeEndpoint(endpoint) {
+    endpoint = endpoint.trim();
+    if (endpoint.startsWith(BACKTICK) && endpoint.endsWith(BACKTICK)) {
+        endpoint = endpoint.slice(1, -1).trim();
+    }
+    if (endpoint.startsWith(SLASH)) {
+        endpoint = endpoint.substring(1);
+    }
+    return endpoint;
+}
+function groupMethods(methods) {
+    var _a, _b;
+    const groups = {};
+    for (const [methodName, methodData] of Object.entries(methods)) {
+        if ((_a = methodData.HTTP) === null || _a === void 0 ? void 0 : _a.ENDPOINT) {
+            const endpoint = normalizeEndpoint(methodData.HTTP.ENDPOINT);
+            const groupKey = `${constants_1.GROUP_PREFIX_HTTP}${endpoint}`;
+            if (!groups[groupKey]) {
+                groups[groupKey] = {
+                    methods: {},
+                    type: 'http',
+                    endpoint: endpoint
+                };
+            }
+            groups[groupKey].methods[methodName] = methodData;
+        }
+        else if ((_b = methodData.INTERFACE) === null || _b === void 0 ? void 0 : _b.NAME) {
+            const interfaceName = methodData.INTERFACE.NAME;
+            const source = methodData.SOURCE;
+            const groupKey = source ? `${constants_1.GROUP_PREFIX_SDK}${source}:${interfaceName}` : `${constants_1.GROUP_PREFIX_SDK}${interfaceName}`;
+            if (!groups[groupKey]) {
+                groups[groupKey] = {
+                    methods: {},
+                    type: 'sdk',
+                    interface: interfaceName,
+                    source: source
+                };
+            }
+            groups[groupKey].methods[methodName] = methodData;
+        }
+        else if (methodData.SOURCE) {
+            // SDK methods with SOURCE but no INTERFACE.NAME - group by SOURCE
+            const source = methodData.SOURCE;
+            const groupKey = `${constants_1.GROUP_PREFIX_SDK}${source}`;
+            if (!groups[groupKey]) {
+                groups[groupKey] = {
+                    methods: {},
+                    type: 'sdk',
+                    source: source
+                };
+            }
+            groups[groupKey].methods[methodName] = methodData;
+        }
+        else {
+            const groupKey = `${constants_1.GROUP_PREFIX_OTHER}${methodName}`;
+            groups[groupKey] = {
+                methods: { [methodName]: methodData },
+                type: 'other'
+            };
+        }
+    }
+    return groups;
+}
+function createMiniWrekenfile(data, groupKey, groupInfo) {
+    var _a;
+    const { methods, type, endpoint, interface: interfaceName, source } = groupInfo;
+    const requiredStructs = collectRequiredStructs(methods, data.STRUCTS || {});
+    const miniData = {
+        VERSION: data.VERSION,
+        METHODS: methods,
+    };
+    if (type === 'sdk' && source && ((_a = data.SOURCES) === null || _a === void 0 ? void 0 : _a[source])) {
+        miniData.SOURCES = { [source]: data.SOURCES[source] };
+    }
+    if (data.DEFAULTS && Object.keys(data.DEFAULTS).length > 0) {
+        miniData.DEFAULTS = data.DEFAULTS;
+    }
+    if (Object.keys(requiredStructs).length > 0) {
+        miniData.STRUCTS = requiredStructs;
+    }
+    const content = yaml.dump(miniData, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true
+    });
+    const methodList = Object.values(methods).map((method) => {
+        var _a, _b;
+        return ((_a = method.HTTP) === null || _a === void 0 ? void 0 : _a.METHOD) || ((_b = method.INTERFACE) === null || _b === void 0 ? void 0 : _b.NAME) || Object.keys(methods)[0];
+    }).filter(Boolean);
+    const metadata = {
+        methods: methodList,
+        structs: Object.keys(requiredStructs),
+        filename: generateFilename(groupKey, type, endpoint, interfaceName, source)
+    };
+    if (endpoint)
+        metadata.endpoint = `/${endpoint}`;
+    if (interfaceName)
+        metadata.interface = interfaceName;
+    if (source)
+        metadata.source = source;
+    return { content, metadata };
+}
+function extractTypeFromInput(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value && typeof value === 'object' && 'TYPE' in value)
+        return value.TYPE;
+    return null;
+}
+function collectStructRefsFromType(type, structRefs) {
+    const structNames = extractAllStructNames(type);
+    for (const structName of structNames) {
+        if (structName)
+            structRefs.add(structName);
+    }
+}
+function collectRequiredStructs(methods, allStructs) {
+    var _a, _b;
+    const requiredStructs = {};
+    const processedStructs = new Set();
+    const structRefs = new Set();
+    for (const methodData of Object.values(methods)) {
+        if (methodData.INPUTS) {
+            for (const input of methodData.INPUTS) {
+                for (const value of Object.values(input)) {
+                    const type = extractTypeFromInput(value);
+                    if (type)
+                        collectStructRefsFromType(type, structRefs);
+                }
+            }
+        }
+        if (methodData.RETURNS) {
+            for (const ret of methodData.RETURNS) {
+                if (ret.RETURNTYPE)
+                    collectStructRefsFromType(ret.RETURNTYPE, structRefs);
+            }
+        }
+        if (methodData.ERRORS) {
+            for (const error of methodData.ERRORS) {
+                if (error.TYPE)
+                    collectStructRefsFromType(error.TYPE, structRefs);
+            }
+        }
+        if ((_b = (_a = methodData.ASYNC) === null || _a === void 0 ? void 0 : _a.RESULT) === null || _b === void 0 ? void 0 : _b.TYPE) {
+            collectStructRefsFromType(methodData.ASYNC.RESULT.TYPE, structRefs);
+        }
+    }
+    for (const structName of structRefs) {
+        collectStructRecursively(structName, allStructs, requiredStructs, processedStructs);
+    }
+    return requiredStructs;
+}
+function collectStructRecursively(structName, allStructs, requiredStructs, processedStructs) {
+    if (processedStructs.has(structName) || !allStructs[structName]) {
+        return;
+    }
+    processedStructs.add(structName);
+    requiredStructs[structName] = allStructs[structName];
+    const structFields = allStructs[structName];
+    if (Array.isArray(structFields)) {
+        for (const field of structFields) {
+            if (field.type) {
+                const nestedStructNames = extractAllStructNames(field.type);
+                for (const nestedStructName of nestedStructNames) {
+                    if (nestedStructName) {
+                        collectStructRecursively(nestedStructName, allStructs, requiredStructs, processedStructs);
+                    }
+                }
+            }
+        }
+    }
+}
+const STRUCT_REGEX = /^STRUCT\(([^)]+)\)/;
+const ARRAY_STRUCT_REGEX = /^\[\]STRUCT\(([^)]+)\)/;
+const MAP_STRUCT_REGEX = /map\[[^\]]+\]STRUCT\(([^)]+)\)/;
+function extractAllStructNames(typeString) {
+    const matches = [];
+    const match1 = typeString.match(STRUCT_REGEX);
+    const match2 = typeString.match(ARRAY_STRUCT_REGEX);
+    const match3 = typeString.match(MAP_STRUCT_REGEX);
+    if (match1)
+        matches.push(match1[1]);
+    if (match2)
+        matches.push(match2[1]);
+    if (match3)
+        matches.push(match3[1]);
+    return matches;
+}
+function sanitizeFilename(name) {
+    return name
+        .replace(constants_1.FILENAME_LEADING_SLASHES, '')
+        .replace(constants_1.FILENAME_TRAILING_SLASHES, '')
+        .replace(constants_1.FILENAME_INVALID_CHARS, '-')
+        .replace(constants_1.FILENAME_MULTIPLE_HYPHENS, '-')
+        .replace(constants_1.FILENAME_LEADING_TRAILING_HYPHENS, '');
+}
+function generateFilename(groupKey, type, endpoint, interfaceName, source) {
+    let cleanName;
+    if (type === 'http' && endpoint) {
+        cleanName = sanitizeFilename(endpoint);
+    }
+    else if (type === 'sdk') {
+        if (interfaceName) {
+            cleanName = sanitizeFilename(interfaceName);
+            if (source) {
+                const cleanSource = sanitizeFilename(source);
+                cleanName = `${cleanSource}-${cleanName}`;
+            }
+        }
+        else if (source) {
+            // SDK methods grouped by SOURCE only (no interface name)
+            cleanName = sanitizeFilename(source);
+        }
+        else {
+            // Fallback: use method name from groupKey
+            cleanName = sanitizeFilename(groupKey.replace(constants_1.GROUP_PREFIX_SDK, ''));
+        }
+    }
+    else {
+        cleanName = sanitizeFilename(groupKey.replace(constants_1.GROUP_PREFIX_OTHER, ''));
+    }
+    return `${constants_1.MINI_FILENAME_PREFIX}${cleanName}${constants_1.YAML_EXTENSION}`;
+}
+function saveMiniWrekenfiles(miniWrekenfiles, outputDir = constants_1.DEFAULT_MINI_OUTPUT_DIR) {
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    for (const miniFile of miniWrekenfiles) {
+        const filePath = `${outputDir}/${miniFile.metadata.filename}`;
+        fs.writeFileSync(filePath, miniFile.content);
+    }
+}

package/dist/v2/openapi-to-wreken.d.ts

@@ -0,0 +1,2 @@
+declare function generateWrekenfile(spec: any, baseDir: string): string;
+export { generateWrekenfile };