wormajs 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 alovajs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,49 @@
+# Worma - A modern OpenAPI code generator
+
+<p align="center">
+<img width="200px" src="https://alova.js.org/img/logo-text-vertical.svg" />
+</p>
+
+<p align="center"><b>Workflow-Streamlined next-generation request tools.<br />Extremely improve your API using efficiency and save brainpower Just one step</b></p>
+
+---
+
+## Usage
+
+This is a more modern openAPI generating solution for alova.js.
+
+Please to [worma documentation](https://alova.js.org/api/worma) for more details.
+
+## Join the community
+
+- [Follow us on X to get the latest updates](https://x.com/alovajs)
+
+- [Join the Discord](https://discord.gg/S47QGJgkVb)
+
+- [Join the WeChat group](https://alova.js.org/img/wechat_qrcode.jpg)
+
+## We need your support
+
+If you like alova, we are very grateful for giving us a star in the upper right corner, which is a recognition and encouragement for our work.
+
+## Welcome to contribute
+
+We are honored to receive active participation from developers around the world in Issues and Discussions.
+
+We hope to make alova a common project for everyone who is willing to participate, rather than the alova team. We encourage everyone to become a contributor to the alova community with an open and inclusive attitude. Even if you are a junior developer, as long as your ideas meet the development guidelines of alova, please participate generously.
+
+Effective contributions will win you a certain reputation in the Alova community. Before contributing, please be sure to read the [Contribution Guide](https://github.com/alovajs/alova/blob/main/CONTRIBUTING.md) in detail to ensure your contribution is effective.
+
+## Changelog
+
+[Link](https://github.com/alovajs/alova/releases)
+
+## Contributors
+
+<a href="https://github.com/alovajs/alova/graphs/contributors">
+<img src="https://contrib.rocks/image?repo=alovajs/alova&max=30&columns=10" />
+</a>
+
+## LICENSE
+
+[MIT](https://en.wikipedia.org/wiki/MIT_License)

package/dist/bin/actions.js

@@ -0,0 +1,245 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.actionInit = actionInit;
+exports.actionGen = actionGen;
+const node_path_1 = __importDefault(require("node:path"));
+const readline = __importStar(require("node:readline/promises"));
+const config_1 = require("../config");
+const constant_1 = require("../constant");
+const getAutoTemplateType_1 = __importDefault(require("../functions/getAutoTemplateType"));
+const generate_1 = __importDefault(require("../generate"));
+const helper_1 = require("../helper");
+const index_1 = require("../index");
+const utils_1 = require("../utils");
+const renderer_1 = require("./renderer");
+const theme_1 = require("./theme");
+// eslint-disable-next-line ts/no-require-imports, perfectionist/sort-imports
+const pkg = require('../../package.json');
+async function actionInit({ type, template, project }) {
+    const renderer = new renderer_1.InitRenderer(pkg.version);
+    // Resolve project path
+    const projectPath = project
+        ? (node_path_1.default.isAbsolute(project) ? project : node_path_1.default.resolve(process.cwd(), project))
+        : process.cwd();
+    // Auto-detect type if not specified
+    const isAutoDetected = !type;
+    const resolvedType = type || await (0, getAutoTemplateType_1.default)(projectPath);
+    // Determine config filename
+    const ext = resolvedType === constant_1.TemplateTypeEnum.TYPESCRIPT ? 'ts' : 'js';
+    const configFilename = `worma.config.${ext}`;
+    const outputPath = node_path_1.default.join(projectPath, configFilename);
+    const isTTY = process.stdout.isTTY;
+    // ── Phase 1: Pre-flight ──
+    renderer.printHeader();
+    renderer.printProjectInfo(projectPath, resolvedType, isAutoDetected);
+    // ── Overwrite check (BEFORE template selection) ──
+    if (await (0, utils_1.existsPromise)(outputPath)) {
+        if (isTTY) {
+            renderer.printSeparator();
+            const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+            const answer = await rl.question(`  ${theme_1.theme.warning('?')} ${configFilename} already exists. Overwrite? (y/N) `);
+            rl.close();
+            if (answer.toLowerCase() !== 'y') {
+                renderer.printSeparator();
+                renderer.printSkipped(outputPath);
+                return;
+            }
+        }
+        else {
+            // Non-TTY: silently skip
+            renderer.printSeparator();
+            renderer.printSkipped(outputPath);
+            return;
+        }
+    }
+    // ── Template selection ──
+    let resolvedTemplate = template;
+    if (!resolvedTemplate) {
+        if (isTTY) {
+            resolvedTemplate = await promptTemplate();
+        }
+        else {
+            // Non-TTY (tests / CI / pipe): default to alova
+            resolvedTemplate = constant_1.PresetTemplateName.ALOVA;
+        }
+    }
+    // Show final config info (template + output)
+    renderer.printConfigInfo(resolvedTemplate, outputPath);
+    renderer.printSeparator();
+    // ── Generate config file ──
+    try {
+        await (0, index_1.createConfig)({ type: resolvedType, template: resolvedTemplate, projectPath });
+        renderer.printSuccess();
+    }
+    catch (error) {
+        renderer.printFailure(`Configuration initialization failed: ${error.message}`);
+        process.exit(1);
+    }
+}
+/** Interactive template preset selection (TTY only). */
+async function promptTemplate() {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    console.log('');
+    console.log(`    ${theme_1.theme.label('Select template preset:')}`);
+    for (let i = 0; i < renderer_1.INIT_TEMPLATE_CHOICES.length; i++) {
+        const choice = renderer_1.INIT_TEMPLATE_CHOICES[i];
+        const marker = i === 0 ? `  ${theme_1.theme.dim('(default)')}` : '';
+        console.log(`      ${i + 1}. ${choice.name}${marker}`);
+    }
+    const answer = await rl.question(`    ${theme_1.theme.dim('▸')} `);
+    rl.close();
+    const num = Number(answer);
+    if (num >= 1 && num <= renderer_1.INIT_TEMPLATE_CHOICES.length) {
+        return renderer_1.INIT_TEMPLATE_CHOICES[num - 1].value;
+    }
+    // Default to first choice (alova) on invalid input
+    return renderer_1.INIT_TEMPLATE_CHOICES[0].value;
+}
+async function actionGen({ project, force, debug, }) {
+    if (debug) {
+        helper_1.logger.configure({ level: 'debug' });
+    }
+    // 1. Always use CWD as cache root — in monorepo this naturally unifies all sub-package caches;
+    //    in single-package this is a no-op since cacheRoot === projectPath.
+    (0, config_1.setGlobalConfig)({ cacheRoot: process.cwd() });
+    helper_1.logger.debug('Cache root:', process.cwd());
+    // 2. Resolve project directories
+    const projectDirs = project ? [project] : await (0, index_1.resolveWorkspaces)();
+    if (projectDirs.length === 0) {
+        console.error('No workspaces found.');
+        process.exit(1);
+    }
+    // 2. Collect project entries (dir, configPath, config, generators)
+    const projects = [];
+    for (const dir of projectDirs) {
+        let configPath;
+        try {
+            configPath = (await (0, utils_1.resolveConfigFile)(dir)) ?? undefined;
+        }
+        catch {
+            // config file not found — readConfig will throw a better error below
+        }
+        const config = await (0, index_1.readConfig)(dir);
+        const generators = config.generator;
+        if (!generators || generators.length === 0) {
+            console.log(`No generators configured for \`${dir}\`.`);
+            continue;
+        }
+        projects.push({ dir, configPath: configPath ?? dir, config, generators });
+    }
+    if (projects.length === 0)
+        return;
+    // 3. Branch routing
+    if (projects.length === 1) {
+        // Single project: existing MultiGeneratorRenderer path — 100% unchanged behaviour
+        const proj = projects[0];
+        await generateForProject(proj, force);
+    }
+    else {
+        // Multi-project: new MultiProjectRenderer + sequential execution
+        // Sequential execution avoids singleton config state clashes and ensures
+        // one project's failure doesn't affect others.
+        const projectInfos = projects.map(p => ({
+            dir: p.dir,
+            configPath: p.configPath,
+            generators: p.generators,
+        }));
+        const renderer = new renderer_1.MultiProjectRenderer(projectInfos, pkg.version);
+        const allResults = [];
+        for (let pi = 0; pi < projects.length; pi++) {
+            const proj = projects[pi];
+            try {
+                const results = await (0, generate_1.default)(proj.config, {
+                    force,
+                    projectPath: proj.dir,
+                    onProgress(event) {
+                        renderer.onProjectEvent(pi, event);
+                    },
+                });
+                allResults.push(results);
+            }
+            catch (error) {
+                // Mark all generators as failed for this project so the renderer
+                // can display the error properly.
+                const failResults = proj.generators.map((_, gi) => {
+                    renderer.onProjectEvent(pi, { index: gi, phase: 'failed', error: error.message || 'Unknown error' });
+                    return false;
+                });
+                allResults.push(failResults);
+            }
+        }
+        renderer.finalize(allResults);
+    }
+}
+async function generateForProject(entry, force) {
+    const { dir, configPath, config, generators } = entry;
+    // Initialize renderer — prints pre-flight (Phase 1), starts live-update (Phase 2)
+    const renderer = new renderer_1.MultiGeneratorRenderer(generators, pkg.version, configPath);
+    // Mark all generators active
+    for (let i = 0; i < generators.length; i++) {
+        renderer.setActive(i);
+    }
+    // Unified entry — generate() creates per-gen trackers internally
+    const results = await (0, generate_1.default)(config, {
+        force,
+        projectPath: dir,
+        onProgress(event) {
+            switch (event.phase) {
+                case 'active':
+                    renderer.setActive(event.index);
+                    break;
+                case 'progress':
+                    renderer.setProgress(event.index, event.progress, event.message);
+                    break;
+                case 'done':
+                    renderer.setDone(event.index, event.resolvedInput);
+                    break;
+                case 'skipped':
+                    renderer.setSkipped(event.index, event.resolvedInput);
+                    break;
+                case 'failed':
+                    renderer.setFailed(event.index, event.error);
+                    break;
+            }
+        },
+    });
+    // Finalize — Phase 3: stop live-update, show concise ✔/✖ summary
+    const failedCount = results.filter(r => !r).length;
+    renderer.finalize(failedCount);
+}

package/dist/bin/cli.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/* c8 ignore start */
+const commander_1 = require("commander");
+const constant_1 = require("../constant");
+const actions_1 = require("./actions");
+// eslint-disable-next-line ts/no-require-imports, perfectionist/sort-imports
+const pkg = require('../../package.json');
+const program = new commander_1.Command();
+program.name('worma').description('CLI to generate API from OpenAPI specs').version(pkg.version);
+program
+    .command('init')
+    .description('init a configuration file')
+    .addOption(new commander_1.Option('-t, --type <type>', 'type of configuration').choices([constant_1.TemplateTypeEnum.TYPESCRIPT, constant_1.ConfigTypeEnum.TS, constant_1.TemplateTypeEnum.COMMONJS, constant_1.TemplateTypeEnum.MODULE]))
+    .addOption(new commander_1.Option('-T, --template <template>', 'template preset to use').choices([constant_1.PresetTemplateName.ALOVA, constant_1.PresetTemplateName.AXIOS, constant_1.PresetTemplateName.FETCH, constant_1.PresetTemplateName.KY]))
+    .option('-p, --project <path>', 'project directory')
+    .action(actions_1.actionInit);
+program
+    .command('gen')
+    .description('generate API from OpenAPI specs')
+    .option('-f, --force', 'force generate api')
+    .option('-d, --debug', 'enable debug logging')
+    .option('-p, --project <path>', 'project directory (single project mode)')
+    .action(actions_1.actionGen);
+program.parse(process.argv);
+/* c8 ignore stop */

package/dist/bin/progressRenderer.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatProgressBar = formatProgressBar;
+exports.sortProgressEntries = sortProgressEntries;
+exports.renderProgressSnapshot = renderProgressSnapshot;
+exports.createProgressRenderer = createProgressRenderer;
+/**
+ * Render a single visual bar for a 0-100 progress value.
+ */
+function formatProgressBar(progress, width = 20) {
+    const safe = Math.max(0, Math.min(100, progress));
+    const filled = Math.round((safe / 100) * width);
+    return `${'█'.repeat(filled)}${'░'.repeat(width - filled)}`;
+}
+/**
+ * Sort progress entries so the core lifecycle line is shown first
+ * and plugin lines appear in stable alphabetical order.
+ */
+function sortProgressEntries(snapshot) {
+    return Object.values(snapshot).sort((a, b) => {
+        if (a.source === 'core')
+            return -1;
+        if (b.source === 'core')
+            return 1;
+        return a.source.localeCompare(b.source);
+    });
+}
+/**
+ * Render a multi-line snapshot suitable for use as `ora` spinner text.
+ * Each source is printed on its own row prefixed by its name.
+ */
+function renderProgressSnapshot(snapshot, options = {}) {
+    const { header, barWidth = 20 } = options;
+    const lines = sortProgressEntries(snapshot).map((entry) => {
+        const pct = `${entry.progress.toFixed(0).padStart(3)}%`;
+        const message = entry.message ? ` ${entry.message}` : '';
+        return `  [${entry.source}] ${formatProgressBar(entry.progress, barWidth)} ${pct}${message}`;
+    });
+    return header ? [header, ...lines].join('\n') : lines.join('\n');
+}
+/**
+ * Build a stateful renderer bound to a fixed header. Useful for CLI spinners
+ * where the header (e.g. project path) does not change between updates.
+ */
+function createProgressRenderer(header, options = {}) {
+    return (snapshot) => renderProgressSnapshot(snapshot, { ...options, header });
+}