@midwayjs/commander 4.0.0-beta.1

package/dist/configuration.d.ts

@@ -0,0 +1,3 @@
+export declare class CommanderConfiguration {
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,32 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommanderConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+let CommanderConfiguration = class CommanderConfiguration {
+};
+exports.CommanderConfiguration = CommanderConfiguration;
+exports.CommanderConfiguration = CommanderConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'commander',
+        importConfigs: [
+            {
+                default: {
+                    midwayLogger: {
+                        clients: {
+                            commanderLogger: {
+                                fileLogName: 'midway-commander.log',
+                            },
+                        },
+                    },
+                },
+            },
+        ],
+    })
+], CommanderConfiguration);
+//# sourceMappingURL=configuration.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,19 @@
+export declare const CLI_COMMAND_KEY = "commander:command";
+export declare const CLI_OPTION_KEY = "commander:option";
+export interface CliCommandOptions {
+    name: string;
+    arguments?: string;
+    description?: string;
+    argsDescription?: Record<string, string>;
+    aliases?: string[];
+}
+export interface CliOptionOptions {
+    flags: string;
+    description?: string;
+    defaultValue?: any;
+    required?: boolean;
+    name?: string;
+}
+export declare function Command(options: CliCommandOptions): ClassDecorator;
+export declare function Option(options: CliOptionOptions): MethodDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLI_OPTION_KEY = exports.CLI_COMMAND_KEY = void 0;
+exports.Command = Command;
+exports.Option = Option;
+const core_1 = require("@midwayjs/core");
+exports.CLI_COMMAND_KEY = 'commander:command';
+exports.CLI_OPTION_KEY = 'commander:option';
+function Command(options) {
+    return (target) => {
+        core_1.DecoratorManager.saveModule(exports.CLI_COMMAND_KEY, target);
+        core_1.MetadataManager.defineMetadata(exports.CLI_COMMAND_KEY, options, target);
+        (0, core_1.Scope)(core_1.ScopeEnum.Request)(target);
+    };
+}
+function Option(options) {
+    return (target, propertyKey, _descriptor) => {
+        void _descriptor;
+        core_1.MetadataManager.attachMetadata(exports.CLI_OPTION_KEY, {
+            propertyKey,
+            options,
+        }, target.constructor);
+    };
+}
+//# sourceMappingURL=decorator.js.map

package/dist/framework.d.ts

@@ -0,0 +1,25 @@
+import { BaseFramework, IMidwayBootstrapOptions } from '@midwayjs/core';
+import { ICommanderConfigurationOptions, IMidwayCommanderApplication, IMidwayContext } from './interface';
+import { Command } from 'commander';
+export declare class MidwayCommanderFramework extends BaseFramework<IMidwayCommanderApplication, IMidwayContext, ICommanderConfigurationOptions> {
+    app: IMidwayCommanderApplication;
+    protected frameworkLoggerName: string;
+    private program;
+    private isCommandsLoaded;
+    configure(_options: ICommanderConfigurationOptions): ICommanderConfigurationOptions;
+    applicationInitialize(_options: IMidwayBootstrapOptions): Promise<void>;
+    run(): Promise<void>;
+    /**
+     * 适用于测试或编程式触发命令的场景。
+     *
+     * 与 run() 不同，这里不会读取 process.argv，而是解析传入的 args，
+     * 从而避免测试环境（Jest/Node）对命令行参数的污染。
+     */
+    runCommand(...args: string[]): Promise<Command>;
+    private outputResult;
+    private outputChunk;
+    private isReadableLike;
+    private isAsyncIterableLike;
+    private loadCommands;
+}
+//# sourceMappingURL=framework.d.ts.map

package/dist/framework.js

@@ -0,0 +1,153 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MidwayCommanderFramework = void 0;
+const core_1 = require("@midwayjs/core");
+const decorator_1 = require("./decorator");
+const commander_1 = require("commander");
+const stream_1 = require("stream");
+let MidwayCommanderFramework = class MidwayCommanderFramework extends core_1.BaseFramework {
+    frameworkLoggerName = 'commanderLogger';
+    program;
+    isCommandsLoaded = false;
+    configure(_options) {
+        void _options;
+        return this.configService.getConfiguration('commander');
+    }
+    async applicationInitialize(_options) {
+        void _options;
+        this.app = {};
+        this.program = new commander_1.Command();
+        this.program.exitOverride();
+    }
+    async run() {
+        this.loadCommands();
+        try {
+            await this.program.parseAsync(process.argv);
+        }
+        catch (error) {
+            void error;
+        }
+    }
+    /**
+     * 适用于测试或编程式触发命令的场景。
+     *
+     * 与 run() 不同，这里不会读取 process.argv，而是解析传入的 args，
+     * 从而避免测试环境（Jest/Node）对命令行参数的污染。
+     */
+    async runCommand(...args) {
+        this.loadCommands();
+        return this.program.parseAsync(args, { from: 'user' });
+    }
+    async outputResult(result) {
+        if (result == null) {
+            return;
+        }
+        if (Buffer.isBuffer(result)) {
+            process.stdout.write(result);
+            return;
+        }
+        if (typeof result === 'string') {
+            process.stdout.write(result);
+            return;
+        }
+        if (this.isReadableLike(result)) {
+            await new Promise((resolve, reject) => {
+                result.on('error', reject);
+                result.on('end', resolve);
+                result.pipe(process.stdout, { end: false });
+            });
+            return;
+        }
+        if (this.isAsyncIterableLike(result)) {
+            for await (const chunk of result) {
+                this.outputChunk(chunk);
+            }
+            return;
+        }
+        this.outputChunk(result);
+    }
+    outputChunk(chunk) {
+        if (chunk == null) {
+            return;
+        }
+        if (Buffer.isBuffer(chunk) || typeof chunk === 'string') {
+            process.stdout.write(chunk);
+            return;
+        }
+        process.stdout.write(JSON.stringify(chunk));
+    }
+    isReadableLike(value) {
+        return (value instanceof stream_1.Readable ||
+            (!!value &&
+                typeof value.pipe === 'function' &&
+                typeof value.on === 'function'));
+    }
+    isAsyncIterableLike(value) {
+        return (!!value && typeof value[Symbol.asyncIterator] === 'function');
+    }
+    loadCommands() {
+        if (this.isCommandsLoaded) {
+            return;
+        }
+        const modules = core_1.DecoratorManager.listModule(decorator_1.CLI_COMMAND_KEY);
+        for (const module of modules) {
+            const metadata = core_1.MetadataManager.getMetadata(decorator_1.CLI_COMMAND_KEY, module);
+            const cmd = this.program.command(metadata.name);
+            if (metadata.arguments) {
+                cmd.arguments(metadata.arguments);
+            }
+            if (metadata.description) {
+                cmd.description(metadata.description, metadata.argsDescription);
+            }
+            if (metadata.aliases) {
+                metadata.aliases.forEach(alias => cmd.alias(alias));
+            }
+            const optionMetadataList = core_1.MetadataManager.getMetadata(decorator_1.CLI_OPTION_KEY, module) || [];
+            for (const optMeta of optionMetadataList) {
+                const opt = optMeta.options;
+                let parser;
+                if (optMeta.propertyKey) {
+                    parser = module.prototype[optMeta.propertyKey];
+                }
+                if (opt.required) {
+                    if (parser) {
+                        cmd.requiredOption(opt.flags, opt.description, parser, opt.defaultValue);
+                    }
+                    else {
+                        cmd.requiredOption(opt.flags, opt.description, opt.defaultValue);
+                    }
+                }
+                else {
+                    if (parser) {
+                        cmd.option(opt.flags, opt.description, parser, opt.defaultValue);
+                    }
+                    else {
+                        cmd.option(opt.flags, opt.description, opt.defaultValue);
+                    }
+                }
+            }
+            cmd.action(async (...args) => {
+                const commandInstance = (await this.applicationContext.getAsync(module));
+                const commandObj = args[args.length - 1];
+                const actualArgs = args.slice(0, -2);
+                const actualOptions = commandObj.opts();
+                if (commandInstance.run) {
+                    const result = await commandInstance.run(actualArgs, actualOptions);
+                    await this.outputResult(result);
+                }
+            });
+        }
+        this.isCommandsLoaded = true;
+    }
+};
+exports.MidwayCommanderFramework = MidwayCommanderFramework;
+exports.MidwayCommanderFramework = MidwayCommanderFramework = __decorate([
+    (0, core_1.Framework)()
+], MidwayCommanderFramework);
+//# sourceMappingURL=framework.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './interface';
+export * from './decorator';
+export * from './response';
+export { MidwayCommanderFramework as Framework } from './framework';
+export { CommanderConfiguration as Configuration } from './configuration';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,25 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = exports.Framework = void 0;
+__exportStar(require("./interface"), exports);
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./response"), exports);
+var framework_1 = require("./framework");
+Object.defineProperty(exports, "Framework", { enumerable: true, get: function () { return framework_1.MidwayCommanderFramework; } });
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.CommanderConfiguration; } });
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,11 @@
+import { IConfigurationOptions, IMidwayApplication, IMidwayContext } from '@midwayjs/core';
+export { IMidwayContext } from '@midwayjs/core';
+export interface ICommanderConfigurationOptions extends IConfigurationOptions {
+}
+export type IMidwayCommanderApplication = IMidwayApplication<IMidwayContext>;
+export type Application = IMidwayCommanderApplication;
+export type Context = IMidwayContext;
+export interface CommandRunner {
+    run(passedParams: string[], options?: Record<string, any>): unknown | Promise<unknown>;
+}
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/dist/response.d.ts

@@ -0,0 +1,15 @@
+import { IMidwayContext, ServerResponse, ServerStreamOptions } from '@midwayjs/core';
+import { Transform } from 'stream';
+export declare class CliStreamResponse<CTX extends IMidwayContext = IMidwayContext> extends Transform {
+    private readonly ctx;
+    private readonly options;
+    constructor(ctx: CTX, options?: ServerStreamOptions<CTX>);
+    _transform(chunk: any, encoding: any, callback: any): void;
+    send(data: unknown): void;
+    sendError(error: Error): void;
+}
+export declare class CliServerResponse<CTX extends IMidwayContext = IMidwayContext> extends ServerResponse<CTX> {
+    static STREAM_TPL: <CTX_1 extends IMidwayContext>(data: unknown, _ctx: CTX_1) => unknown;
+    stream(options?: ServerStreamOptions<CTX>): CliStreamResponse<any>;
+}
+//# sourceMappingURL=response.d.ts.map

package/dist/response.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CliServerResponse = exports.CliStreamResponse = void 0;
+const core_1 = require("@midwayjs/core");
+const stream_1 = require("stream");
+class CliStreamResponse extends stream_1.Transform {
+    ctx;
+    options;
+    constructor(ctx, options = {}) {
+        super({
+            objectMode: true,
+            ...options,
+        });
+        this.ctx = ctx;
+        this.options = options;
+    }
+    _transform(chunk, encoding, callback) {
+        try {
+            if (Buffer.isBuffer(chunk) || typeof chunk === 'string') {
+                this.push(chunk);
+            }
+            else {
+                this.push(JSON.stringify(chunk));
+            }
+            callback();
+        }
+        catch (err) {
+            this.ctx?.logger?.error?.(err);
+            this.end();
+            callback(err);
+        }
+    }
+    send(data) {
+        if (!this.writable) {
+            return;
+        }
+        const tpl = this.options.tpl ?? ((v) => v);
+        this.write(tpl(data, this.ctx));
+    }
+    sendError(error) {
+        this.ctx?.logger?.error?.(error);
+        this.end();
+    }
+}
+exports.CliStreamResponse = CliStreamResponse;
+class CliServerResponse extends core_1.ServerResponse {
+    static STREAM_TPL = (data, _ctx) => {
+        void _ctx;
+        return data;
+    };
+    stream(options = {}) {
+        return new CliStreamResponse(this.ctx, {
+            tpl: Object.getPrototypeOf(this).constructor.STREAM_TPL,
+            ...options,
+        });
+    }
+}
+exports.CliServerResponse = CliServerResponse;
+//# sourceMappingURL=response.js.map

package/index.d.ts

@@ -0,0 +1,9 @@
+import { CommanderConfigOptions } from './dist/index';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    commander?: Partial<CommanderConfigOptions>;
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@midwayjs/commander",
+  "version": "4.0.0-beta.1",
+  "description": "Midway Commander Framework",
+  "main": "dist/index.js",
+  "typings": "index.d.ts",
+  "keywords": [
+    "midway",
+    "component",
+    "commander"
+  ],
+  "author": "czy88840616 <czy88840616@gmail.com>",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand",
+    "cov": "node -r ts-node/register ../../node_modules/jest/bin/jest.js --runInBand --coverage --forceExit",
+    "ci": "npm run test",
+    "lint": "mwts check"
+  },
+  "dependencies": {
+    "@midwayjs/core": "workspace:^",
+    "commander": "14.0.2"
+  },
+  "devDependencies": {
+    "@midwayjs/mock": "workspace:^"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT"
+}