@gct-paas/cli 0.0.1-dev.2 → 0.0.1-dev.20

package/dist/core/index.d.ts

@@ -1,7 +1,2 @@
-export * from './commitlint';
-export * from './eslint';
-export * from './prettier';
-export * from './rollup';
-export * from './stylelint';
-export * from './util';
-export * from './vite';
+export * from './handlebars';
+export * from './interface';

package/dist/core/interface/index.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/core/interface/index.d.ts

@@ -0,0 +1 @@
+export type IObject = Record<string | symbol, any>;

package/dist/index.cjs

@@ -0,0 +1,47 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _exportNames = {
+  bootstrap: true
+};
+exports.bootstrap = bootstrap;
+var _commander = require("commander");
+var _commands = require("./commands/index.cjs");
+var _utils = require("./utils/index.cjs");
+var _package = _interopRequireDefault(require("../package.json"));
+var _core = require("./core/index.cjs");
+Object.keys(_core).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
+  if (key in exports && exports[key] === _core[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _core[key];
+    }
+  });
+});
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+async function bootstrap() {
+  process.on("SIGINT", () => {
+    process.exit();
+  });
+  _commander.program.version(_package.default.version, "-v, --version", "\u67E5\u770B\u5F53\u524D\u7248\u672C").usage("<command> [options]").helpOption("-h, --help", "\u83B7\u53D6\u5E2E\u52A9\u4FE1\u606F").configureOutput({
+    // Visibly override write routines as example!
+    writeErr: str => process.stdout.write(`[ERR] ${str}`),
+    // Highlight errors in color.
+    outputError: (str, write) => write(`\x1B[31m${str}\x1B[0m`)
+  });
+  if ((0, _utils.localBinExists)()) {
+    const localCommandLoader = (0, _utils.loadLocalBinCommandLoader)();
+    localCommandLoader.load(_commander.program);
+  } else {
+    _commands.CommandLoader.load(_commander.program);
+  }
+  _commander.program.parse(process.argv);
+  if (!process.argv.slice(2).length) {
+    _commander.program.outputHelp();
+  }
+}

package/dist/interface/i-command/i-command.cjs

@@ -0,0 +1 @@
+"use strict";

package/dist/interface/i-command/i-command.d.ts

@@ -2,8 +2,6 @@ import { Command } from 'commander';
 /**
  * 命令项
  *
- * @author chitanda
- * @date 2021-12-18 15:12:13
  * @export
  * @interface ICommand
  */
@@ -11,16 +9,12 @@ export interface ICommand {
     /**
      * 加载命令
      *
-     * @author chitanda
-     * @date 2021-12-18 15:12:22
      * @param {Command} program
      */
     load(program: Command): void;
     /**
      * 执行行为
      *
-     * @author chitanda
-     * @date 2021-12-21 16:12:22
      * @param {...unknown[]} args
      * @return {*}  {(void | Promise<void>)}
      */

package/dist/interface/index.cjs

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _iCommand = require("./i-command/i-command.cjs");
+Object.keys(_iCommand).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _iCommand[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _iCommand[key];
+    }
+  });
+});

package/dist/utils/index.cjs

@@ -0,0 +1,18 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "loadLocalBinCommandLoader", {
+  enumerable: true,
+  get: function () {
+    return _localBinaries.loadLocalBinCommandLoader;
+  }
+});
+Object.defineProperty(exports, "localBinExists", {
+  enumerable: true,
+  get: function () {
+    return _localBinaries.localBinExists;
+  }
+});
+var _localBinaries = require("./local-binaries/local-binaries.cjs");

package/dist/utils/local-binaries/local-binaries.cjs

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.loadLocalBinCommandLoader = loadLocalBinCommandLoader;
+exports.localBinExists = localBinExists;
+var _path = require("path");
+var _fsExtra = _interopRequireDefault(require("fs-extra"));
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const localBinPathSegments = [process.cwd(), "node_modules", "@nestjs", "cli"];
+function localBinExists() {
+  return _fsExtra.default.existsSync((0, _path.join)(...localBinPathSegments));
+}
+function loadLocalBinCommandLoader() {
+  const path = _path.posix.join(...localBinPathSegments, "commands");
+  const commandsFile = require(path);
+  return commandsFile.CommandLoader;
+}

package/es/actions/gen-api/api-manage.d.ts

@@ -0,0 +1,36 @@
+import { IObject } from '../../core';
+/**
+ * api 管理
+ *
+ * @export
+ * @class EntityApiManage
+ */
+export declare class EntityApiManage {
+    readonly name: string;
+    readonly cache: Map<string, IObject>;
+    constructor(name: string);
+    /**
+     * 新增方法
+     *
+     * @param {string} method 方法名称
+     * @param {string} mode 请求方式
+     * @param {IObject} cfg 从 swagger 获取的配置
+     */
+    add(method: string, mode: string, cfg: IObject): void;
+}
+/**
+ * api 清单管理
+ *
+ * @export
+ * @class ApiManage
+ */
+export declare class ApiManage {
+    readonly cache: Map<string, EntityApiManage>;
+    /**
+     * 新增 api
+     *
+     * @param {string} pathStr 请求路径
+     * @param {IObject} cfg swagger 配置
+     */
+    add(pathStr: string, cfg: IObject): void;
+}

package/es/actions/gen-api/api-manage.mjs

@@ -0,0 +1,38 @@
+export class EntityApiManage {
+  constructor(name) {
+    this.name = name;
+  }
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * 新增方法
+   *
+   * @param {string} method 方法名称
+   * @param {string} mode 请求方式
+   * @param {IObject} cfg 从 swagger 获取的配置
+   */
+  add(method, mode, cfg) {
+    const tag = `${method}:${mode}`;
+    this.cache.set(tag, cfg);
+  }
+}
+export class ApiManage {
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * 新增 api
+   *
+   * @param {string} pathStr 请求路径
+   * @param {IObject} cfg swagger 配置
+   */
+  add(pathStr, cfg) {
+    const entityName = pathStr.split("/")[3];
+    const method = pathStr.split("/")[4];
+    if (!this.cache.has(entityName)) {
+      this.cache.set(entityName, new EntityApiManage(entityName));
+    }
+    const entity = this.cache.get(entityName);
+    const modes = Object.keys(cfg);
+    modes.forEach((mode) => {
+      entity.add(method, mode, cfg[mode]);
+    });
+  }
+}

package/es/actions/gen-api/gen-api.d.ts

@@ -0,0 +1,58 @@
+import { HandlebarsEngine, IObject } from '../../core';
+/**
+ * 基于 handlebars 模板编写生成 api
+ *
+ * @export
+ * @class GenApiAction
+ */
+export declare class GenApiAction {
+    private engine;
+    private modelManage;
+    private configs;
+    /**
+     * 生成 api
+     *
+     * @param {string} baseUrl swagger 服务地址
+     * @param {string} tag 要发布的 api 标识
+     * @param {string} template 模板目录
+     * @param {string} output 输出目录
+     * @param {boolean} clean 是否清理输出目录后再生成
+     */
+    run(baseUrl: string, tag: string, template: string, output: string, clean: boolean): Promise<void>;
+    /**
+     * 基于模型编译输出文件
+     *
+     * @protected
+     * @param {string} url
+     * @param {string} outPath
+     * @param {HandlebarsEngine} engine
+     * @returns {*}  {Promise<void>}
+     */
+    protected write(tag: string, url: string, outPath: string, engine: HandlebarsEngine): Promise<void>;
+    /**
+     * 注册所有的宏
+     *
+     * @protected
+     * @param {string} tempPath
+     * @param {HandlebarsEngine} engine
+     * @returns {*}  {Promise<void>}
+     */
+    protected registerMacros(tempPath: string, engine: HandlebarsEngine): Promise<void>;
+    /**
+     * 注册所有模板文件
+     *
+     * @protected
+     * @param {string} tempPath
+     * @param {HandlebarsEngine} engine
+     * @returns {*}  {Promise<void>}
+     */
+    protected registerTempFiles(tempPath: string, engine: HandlebarsEngine): Promise<void>;
+    /**
+     * 针对加载的配置进行处理
+     *
+     * @protected
+     * @param {IObject} model
+     * @returns {*}  {IObject}
+     */
+    protected transformModel(model: IObject): IObject;
+}

package/es/actions/gen-api/gen-api.mjs

@@ -0,0 +1,164 @@
+import path from "path";
+import fse from "fs-extra";
+import * as rm from "rimraf";
+import glob from "fast-glob";
+import log from "consola";
+import got from "got";
+import { HandlebarsEngine, MACRO_FOLDER } from "../../core/index.mjs";
+import { ModelManage } from "./model-manage.mjs";
+export class GenApiAction {
+  // private baseUrl = 'http://paas.paasdev.gct-paas.com';
+  engine = new HandlebarsEngine();
+  modelManage = new ModelManage();
+  configs = {
+    platform: "/gct-platform/v2/api-docs?group=%E7%AE%A1%E7%90%86%E5%B9%B3%E5%8F%B0API",
+    apaas: "/gct-apaas/v2/api-docs?group=apaas%E5%B9%B3%E5%8F%B0API"
+  };
+  /**
+   * 生成 api
+   *
+   * @param {string} baseUrl swagger 服务地址
+   * @param {string} tag 要发布的 api 标识
+   * @param {string} template 模板目录
+   * @param {string} output 输出目录
+   * @param {boolean} clean 是否清理输出目录后再生成
+   */
+  async run(baseUrl, tag, template, output, clean) {
+    const cwd = process.cwd();
+    const tempPath = path.resolve(cwd, template);
+    const outPath = path.resolve(cwd, output);
+    if (clean === true && fse.existsSync(outPath)) {
+      rm.sync(outPath);
+    }
+    await this.registerMacros(tempPath, this.engine);
+    await this.registerTempFiles(tempPath, this.engine);
+    await this.write(
+      tag,
+      path.join(baseUrl, this.configs[tag]),
+      outPath,
+      this.engine
+    );
+  }
+  /**
+   * 基于模型编译输出文件
+   *
+   * @protected
+   * @param {string} url
+   * @param {string} outPath
+   * @param {HandlebarsEngine} engine
+   * @returns {*}  {Promise<void>}
+   */
+  async write(tag, url, outPath, engine) {
+    const cfg = await got(url).json();
+    const model = this.transformModel(cfg);
+    this.modelManage.init(tag, model);
+    const all = [];
+    engine.temps.forEach((template, key) => {
+      if (key === "") {
+        return;
+      }
+      const outFilePath = path.join(outPath, key);
+      const tags = engine.parseContextTags(key);
+      if (tags.length === 0) {
+        log.info(`\u751F\u6210\u6587\u4EF6\uFF1A${outFilePath}`);
+        all.push(
+          fse.outputFile(
+            outFilePath,
+            engine.render(template, {
+              entities: Array.from(this.modelManage.entities.values()),
+              definitions: model.definitions
+            }),
+            "utf-8"
+          )
+        );
+      } else {
+        if (tags.includes("api")) {
+          this.modelManage.entities.forEach((model2) => {
+            const filePath = engine.render(outFilePath, model2);
+            log.info(`\u751F\u6210\u6587\u4EF6\uFF1A${filePath}`);
+            all.push(
+              fse.outputFile(filePath, engine.render(template, model2), "utf-8")
+            );
+          });
+        }
+      }
+    });
+    await Promise.all(all);
+  }
+  /**
+   * 注册所有的宏
+   *
+   * @protected
+   * @param {string} tempPath
+   * @param {HandlebarsEngine} engine
+   * @returns {*}  {Promise<void>}
+   */
+  async registerMacros(tempPath, engine) {
+    const macroFiles = glob.sync(path.join(MACRO_FOLDER, "**/*.hbs"), {
+      cwd: tempPath,
+      dot: true,
+      absolute: true
+    });
+    if (macroFiles.length > 0) {
+      await Promise.all(
+        macroFiles.map((macroFilePath) => {
+          return new Promise((resolve) => {
+            fse.readFile(macroFilePath, "utf-8").then((file) => {
+              const key = path.relative(tempPath, macroFilePath);
+              log.info(`\u6CE8\u518C\u5B8F\uFF1A${key}`);
+              engine.registerMacro(key, file);
+              resolve();
+            });
+          });
+        })
+      );
+    }
+  }
+  /**
+   * 注册所有模板文件
+   *
+   * @protected
+   * @param {string} tempPath
+   * @param {HandlebarsEngine} engine
+   * @returns {*}  {Promise<void>}
+   */
+  async registerTempFiles(tempPath, engine) {
+    const tempFiles = glob.sync("**/*.hbs", {
+      cwd: tempPath,
+      dot: true,
+      absolute: true,
+      ignore: [path.join(MACRO_FOLDER, "**/*.hbs")]
+    });
+    if (tempFiles.length > 0) {
+      await Promise.all(
+        tempFiles.map((tempFilePath) => {
+          return new Promise((resolve) => {
+            fse.readFile(tempFilePath, "utf-8").then((file) => {
+              const key = path.relative(tempPath, tempFilePath);
+              log.info(`\u6CE8\u518C\u6A21\u677F\uFF1A${key}`);
+              engine.registerTemp(key, file);
+              resolve();
+            });
+          });
+        })
+      );
+    }
+  }
+  /**
+   * 针对加载的配置进行处理
+   *
+   * @protected
+   * @param {IObject} model
+   * @returns {*}  {IObject}
+   */
+  transformModel(model) {
+    const keys = Object.keys(model.definitions);
+    keys.forEach((key) => {
+      const item = model.definitions[key];
+      if (item.properties) {
+        item.propertySize = Object.keys(item.properties).length;
+      }
+    });
+    return model;
+  }
+}

package/es/actions/gen-api/model-manage.d.ts

@@ -0,0 +1,124 @@
+import { IObject } from '../../core';
+/**
+ * 实体方法模型
+ *
+ * @export
+ * @interface IMethodModel
+ */
+export interface IMethodModel {
+    /**
+     * 方法名称
+     *
+     * @type {string}
+     */
+    name: string;
+    /**
+     * 请求方式
+     *
+     * @type {string}
+     */
+    mode: string;
+    /**
+     * 方法模型
+     *
+     * @type {IObject}
+     */
+    model: IObject;
+    /**
+     * 请求实体
+     *
+     * @type {IObject}
+     */
+    requestEntity?: IObject;
+    /**
+     * 响应实体
+     *
+     * @type {IObject}
+     */
+    responseEntity?: IObject;
+    /**
+     * 查询参数
+     *
+     * @type {IObject[]}
+     */
+    queries: IObject[];
+}
+/**
+ * 实体模型
+ *
+ * @export
+ * @interface IEntityModel
+ */
+export interface IEntityModel {
+    /**
+     * 实体名称
+     *
+     * @type {string}
+     */
+    entityName: string;
+    /**
+     * 平台标识 apaas, platform
+     *
+     * @type {string}
+     */
+    tag: string;
+    /**
+     * 实体名称(同name)
+     *
+     * @type {string}
+     */
+    api: string;
+    /**
+     * 实体模型
+     *
+     * @type {IObject}
+     */
+    model: IObject;
+    /**
+     * 实体方法模型
+     *
+     * @type {IMethodModel[]}
+     */
+    methods: IMethodModel[];
+    /**
+     * 实体引用实体名称集合
+     *
+     * @type {string[]}
+     */
+    entityRefs: string[];
+}
+/**
+ * 模型管理
+ *
+ * @export
+ * @class ModelManage
+ */
+export declare class ModelManage {
+    /**
+     * 所有实体模型
+     *
+     * @type {Map<string, IEntityModel>}
+     */
+    readonly entities: Map<string, IEntityModel>;
+    /**
+     * 所有用到的实体定义
+     *
+     * @type {Map<string, IObject>}
+     */
+    readonly definitions: Map<string, IObject>;
+    /**
+     * 目前接口中的基础数据类型
+     *
+     * @protected
+     */
+    protected basicDataType: string[];
+    init(tag: string, cfg: IObject): void;
+    /**
+     * 获取接口的引用对象
+     *
+     * @protected
+     * @param {IObject} data
+     * @returns {*}  {string}
+     */
+    protected getOriginRef(data: IObject): string;
+}

package/es/actions/gen-api/model-manage.mjs

@@ -0,0 +1,126 @@
+import { ApiManage } from "./api-manage.mjs";
+export class ModelManage {
+  /**
+   * 所有实体模型
+   *
+   * @type {Map<string, IEntityModel>}
+   */
+  entities = /* @__PURE__ */ new Map();
+  /**
+   * 所有用到的实体定义
+   *
+   * @type {Map<string, IObject>}
+   */
+  definitions = /* @__PURE__ */ new Map();
+  /**
+   * 目前接口中的基础数据类型
+   *
+   * @protected
+   */
+  basicDataType = [
+    "any",
+    "number",
+    "string",
+    "null",
+    "boolean",
+    "Void",
+    "object"
+  ];
+  init(tag, cfg) {
+    const apiManage = new ApiManage();
+    const paths = Object.keys(cfg.paths).filter((pathStr) => {
+      return !pathStr.startsWith("/external") || pathStr === "/external/api/tenant/info/byPortOrDomain";
+    });
+    paths.forEach((pathStr) => {
+      const pathCfg = cfg.paths[pathStr];
+      apiManage.add(pathStr, pathCfg);
+    });
+    const entityNames = apiManage.cache.keys();
+    for (const entityName of entityNames) {
+      const entitySet = /* @__PURE__ */ new Set();
+      const entityManage = apiManage.cache.get(entityName);
+      const methods = [];
+      const tags = entityManage.cache.keys();
+      for (const tag2 of tags) {
+        const [methodName, mode] = tag2.split(":");
+        const config = entityManage.cache.get(tag2);
+        let requestEntity = void 0;
+        const param = config.parameters.find((param2) => {
+          if (param2.in === "body") {
+            return param2;
+          }
+        });
+        if (param && param.schema) {
+          const refKey = this.getOriginRef(param.schema);
+          requestEntity = cfg.definitions[refKey];
+          if (requestEntity && Object.keys(requestEntity).length > 0) {
+            this.definitions.set(refKey, requestEntity);
+            entitySet.add(refKey);
+          }
+        }
+        let responseEntity = void 0;
+        if (config.responses["200"].schema) {
+          const refKey = this.getOriginRef(config.responses["200"].schema);
+          responseEntity = cfg.definitions[refKey];
+          if (responseEntity && Object.keys(responseEntity).length > 0) {
+            this.definitions.set(refKey, responseEntity);
+            entitySet.add(refKey);
+          }
+        }
+        const queries = config.parameters.filter(
+          (param2) => {
+            if (param2.in === "query") {
+              return param2;
+            }
+          }
+        );
+        if (methodName === "{id}") {
+          queries.push({
+            name: "id",
+            in: "query",
+            description: "\u6570\u636E\u4E3B\u952E",
+            required: true,
+            type: "string"
+          });
+        }
+        methods.push({
+          name: methodName !== "undefined" ? methodName : "",
+          mode,
+          model: config,
+          requestEntity,
+          responseEntity,
+          queries
+        });
+      }
+      this.entities.set(entityName, {
+        tag,
+        entityName,
+        api: entityName,
+        model: cfg.definitions[entityName],
+        methods,
+        entityRefs: Array.from(entitySet.values()).filter((item) => {
+          return this.basicDataType.findIndex((type) => {
+            return item.indexOf(`\xAB${type}\xBB`) !== -1;
+          }) === -1 && !this.basicDataType.includes(item);
+        })
+      });
+    }
+  }
+  /**
+   * 获取接口的引用对象
+   *
+   * @protected
+   * @param {IObject} data
+   * @returns {*}  {string}
+   */
+  getOriginRef(data) {
+    const { $ref, originalRef, type } = data;
+    if (type) return type;
+    if (originalRef) return originalRef;
+    if ($ref) {
+      const _refs_ = $ref.split("/");
+      return _refs_[_refs_.length - 1];
+    }
+    return "any";
+  }
+}

package/es/actions/index.d.ts

@@ -0,0 +1 @@
+export { GenApiAction } from './gen-api/gen-api';