@gct-paas/cli 0.0.1-dev.9 → 0.1.0

package/dist/core/index.d.ts

@@ -0,0 +1,2 @@
+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

@@ -11,7 +11,7 @@ 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");
+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;

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';

package/es/actions/index.mjs

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

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

@@ -0,0 +1,44 @@
+import { Command } from 'commander';
+import { ICommand } from '../../interface';
+export interface GenApiOptions {
+    /**
+     * 模板目录
+     *
+     * @author chitanda
+     * @date 2021-12-19 20:12:32
+     * @type {string}
+     */
+    template: string;
+    /**
+     * 模板输出目录
+     *
+     * @author chitanda
+     * @date 2021-12-19 20:12:37
+     * @type {string}
+     */
+    output: string;
+    /**
+     * 清理输出目录
+     *
+     * @author chitanda
+     * @date 2021-12-21 10:12:47
+     * @type {boolean}
+     */
+    clean: boolean;
+    /**
+     * swagger 地址
+     *
+     * @type {string}
+     */
+    url: string;
+    /**
+     * api标识
+     *
+     * @type {string}
+     */
+    tag: string;
+}
+export declare class GenApiCommand implements ICommand {
+    load(program: Command): void;
+    action(args: GenApiOptions): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+import { GenApiAction } from "../../actions/index.mjs";
+export class GenApiCommand {
+  load(program) {
+    program.command("gen-api").description("\u751F\u6210 api \u6587\u4EF6").option("--url <base-url>", "\u6307\u5B9Aapi\u83B7\u53D6\u7684swagger\u5730\u5740").option("-t --template <template>", "\u6307\u5B9A\u6A21\u677F\u76EE\u5F55").option("-o --output <output>", "\u6307\u5B9A\u8F93\u51FA\u76EE\u5F55").option("--tag <tag>", "\u6307\u5B9A\u5F53\u524D\u53D1\u5E03\u7684\u5206\u652F").option("--clean", "\u6E05\u7406\u8F93\u51FA\u76EE\u5F55").action(this.action.bind(this));
+  }
+  async action(args) {
+    await new GenApiAction().run(
+      args.url,
+      args.tag,
+      args.template,
+      args.output,
+      args.clean
+    );
+  }
+}

package/es/commands/index.mjs

@@ -1,6 +1,8 @@
 import { consola } from "consola";
+import { GenApiCommand } from "./gen-api/gen-api.mjs";
 export class CommandLoader {
   static load(program) {
+    new GenApiCommand().load(program);
     this.handleInvalidCommand(program);
   }
   static handleInvalidCommand(program) {

package/es/core/handlebars/constant/index.d.ts

@@ -0,0 +1,2 @@
+export declare const TEMP_EXTENSION = ".hbs";
+export declare const MACRO_FOLDER = "@macro";

package/es/core/handlebars/constant/index.mjs

@@ -0,0 +1,2 @@
+export const TEMP_EXTENSION = ".hbs";
+export const MACRO_FOLDER = "@macro";