@biuxiu/codegen 0.1.1

package/README.md

@@ -0,0 +1,11 @@
+# lua codegen
+
+### 使用lua+nodejs实现项目代码生成功能
+
+- 初始化项目
+  ```sh
+  # 安装依赖
+  pnpm i
+  # 初始化模板类型信息
+  pnpm template-init
+  ```

package/dist/code/nest.d.ts

@@ -0,0 +1,11 @@
+import { ApiServiceField, DtoField, EntityField } from '@/types';
+export declare class RenderNest {
+    #private;
+    constructor(name: string, path?: string);
+    remove(): void;
+    editAppModule(isDelete?: boolean): void;
+    genModule(): Promise<void>;
+    genApiService(apiService: ApiServiceField[]): Promise<void>;
+    genEntity(entity: EntityField[]): Promise<void>;
+    genDto(dto: DtoField[]): Promise<void>;
+}

package/dist/code/nest.js

@@ -0,0 +1,229 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var nest_exports = {};
+__export(nest_exports, {
+  RenderNest: () => RenderNest
+});
+module.exports = __toCommonJS(nest_exports);
+var import_render = __toESM(require("@/render"));
+var import_path = require("path");
+var import_util = require("@/util");
+var import_fs = require("fs");
+var import_dto = require("@/format/dto");
+var import_entity = require("@/format/entity");
+var import_api = require("@/format/api");
+var import_service = require("@/format/service");
+var import_config = require("@/config");
+var import_ts_morph = require("ts-morph");
+var import_shelljs = require("shelljs");
+const editFileQueue = [];
+let isRunning = false;
+const runEditTask = async () => {
+  if (!isRunning) {
+    isRunning = true;
+    while (editFileQueue.length > 0) {
+      const fn = editFileQueue.shift();
+      if (fn) await fn();
+    }
+    isRunning = false;
+  }
+};
+class RenderNest {
+  #moduleDir;
+  #name;
+  #path;
+  #formatPath(path) {
+    return path.split("/").filter((p) => p).join("/");
+  }
+  constructor(name, path) {
+    this.#path = path ? path.endsWith("/") ? `${this.#formatPath(path)}/${name}` : this.#formatPath(path) : name;
+    let basePath = "";
+    const apiDir = (0, import_config.getApiDir)();
+    if (this.#path.includes("/")) {
+      const pathArr = this.#path.split("/");
+      for (let i = 0; i < pathArr.length; i++) {
+        const curPath = pathArr[i];
+        if (i === 0) {
+          basePath = (0, import_path.join)(apiDir, curPath);
+        } else {
+          basePath = (0, import_path.join)(basePath, curPath);
+        }
+        if (!(0, import_fs.existsSync)(basePath)) {
+          (0, import_fs.mkdirSync)(basePath);
+        }
+      }
+    } else {
+      basePath = (0, import_path.join)(apiDir, this.#path);
+      if (!(0, import_fs.existsSync)(basePath)) {
+        (0, import_fs.mkdirSync)(basePath);
+      }
+    }
+    this.#name = name;
+    this.#moduleDir = basePath;
+  }
+  remove() {
+    if ((0, import_fs.existsSync)(this.#moduleDir)) {
+      (0, import_shelljs.exec)(`rm -rf ${this.#moduleDir}`);
+    }
+    this.editAppModule(true);
+  }
+  editAppModule(isDelete = false) {
+    editFileQueue.push(async () => {
+      const moudleName = `${this.#name[0].toUpperCase() + this.#name.slice(1)}Module`;
+      const appModuleFile = (0, import_path.join)((0, import_config.getApiDir)(), "app.module.ts");
+      if ((0, import_fs.existsSync)(appModuleFile)) {
+        const source = new import_ts_morph.Project().addSourceFileAtPath(appModuleFile);
+        const moduleImport = source.getImportDeclaration(
+          `./${this.#path}/${this.#name}.module`
+        );
+        const appModuleClass = source.getClassOrThrow("AppModule");
+        const importsArray = appModuleClass.getDecoratorOrThrow("Module").getArguments()[0].asKindOrThrow(import_ts_morph.SyntaxKind.ObjectLiteralExpression).getPropertyOrThrow("imports").getFirstChildByKindOrThrow(
+          import_ts_morph.SyntaxKind.ArrayLiteralExpression
+        );
+        const consumerStatement = appModuleClass.getMethodOrThrow("configure").getStatements()[0];
+        if (isDelete) {
+          if (moduleImport) {
+            moduleImport.remove();
+          }
+          importsArray.getElements().forEach((ele, index) => {
+            if (ele.getText() === moudleName) {
+              importsArray.removeElement(index);
+            }
+          });
+          const text = consumerStatement.getText();
+          if (text.includes(moudleName)) {
+            const newText = text.replace(
+              new RegExp(`,\\s*${moudleName}`),
+              ""
+            );
+            consumerStatement.replaceWithText(newText);
+          }
+        } else {
+          if (!moduleImport) {
+            source.addImportDeclaration({
+              namedImports: [moudleName],
+              moduleSpecifier: `./${this.#path}/${this.#name}.module`
+            });
+          }
+          let hasModule = false;
+          importsArray.getElements().forEach((ele) => {
+            if (ele.getText() === moudleName) {
+              hasModule = true;
+            }
+          });
+          if (!hasModule) {
+            importsArray.addElement(moudleName);
+          }
+          const text = consumerStatement.getText();
+          if (!text.includes(moudleName)) {
+            const newText = text.replace(
+              /\.forRoutes\(([^)]+)\)/,
+              `.forRoutes($1, ${moudleName})`
+            );
+            consumerStatement.replaceWithText(newText);
+          }
+        }
+        await source.save();
+        await (0, import_util.reFromatFile)(appModuleFile);
+      }
+    });
+    runEditTask();
+  }
+  async genModule() {
+    const modulePath = (0, import_path.join)(this.#moduleDir, `${this.#name}.module.ts`);
+    const moduleStr = await import_render.default.render("module", { name: this.#name });
+    (0, import_util.writeFormatFile)(modulePath, moduleStr);
+  }
+  async genApiService(apiService) {
+    const controllerPath = (0, import_path.join)(
+      this.#moduleDir,
+      `${this.#name}.controller.ts`
+    );
+    const servicePath = (0, import_path.join)(this.#moduleDir, `${this.#name}.service.ts`);
+    const [apiImport, apiContent] = new import_api.ApiFormat(
+      this.#name,
+      apiService
+    ).format();
+    import_render.default.render("controller", {
+      name: this.#name,
+      importInfo: apiImport,
+      content: apiContent
+    }).then((controllerStr) => {
+      (0, import_util.writeFormatFile)(controllerPath, controllerStr);
+    });
+    const [serviceImport, serviceContent] = new import_service.ServiceFormat(
+      this.#name,
+      apiService
+    ).format();
+    import_render.default.render("service", {
+      name: this.#name,
+      content: serviceContent,
+      importInfo: serviceImport
+    }).then((serviceStr) => {
+      (0, import_util.writeFormatFile)(servicePath, serviceStr);
+    });
+  }
+  async genEntity(entity) {
+    const entityDir = (0, import_path.join)(this.#moduleDir, "entities");
+    if (!(0, import_fs.existsSync)(entityDir)) {
+      (0, import_fs.mkdirSync)(entityDir);
+    }
+    const entityPath = (0, import_path.join)(entityDir, `${this.#name}.entity.ts`);
+    const [importInfo, content] = new import_entity.EntityFormat(entity).format();
+    const entityStr = await import_render.default.render("entity", {
+      name: this.#name,
+      importInfo,
+      content
+    });
+    (0, import_util.writeFormatFile)(entityPath, entityStr);
+  }
+  async genDto(dto) {
+    const dtoPath = (0, import_path.join)(this.#moduleDir, "dto");
+    if (!(0, import_fs.existsSync)(dtoPath)) {
+      (0, import_fs.mkdirSync)(dtoPath);
+    }
+    const createDtoPath = (0, import_path.join)(dtoPath, `create-${this.#name}.dto.ts`);
+    const updateDtoPath = (0, import_path.join)(dtoPath, `update-${this.#name}.dto.ts`);
+    const [importInfo, content] = new import_dto.DTOFromat(dto).format();
+    const createDtoStr = await import_render.default.render("create-dto", {
+      importInfo,
+      name: this.#name,
+      content
+    });
+    const updateDtoStr = await import_render.default.render("update-dto", {
+      name: this.#name
+    });
+    (0, import_util.writeFormatFile)(createDtoPath, createDtoStr);
+    (0, import_util.writeFormatFile)(updateDtoPath, updateDtoStr);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RenderNest
+});

package/dist/compile.d.ts

@@ -0,0 +1 @@
+export declare function compileToByte(filePath: string): Promise<ArrayBuffer>;

package/dist/compile.js

@@ -0,0 +1,58 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var compile_exports = {};
+__export(compile_exports, {
+  compileToByte: () => compileToByte
+});
+module.exports = __toCommonJS(compile_exports);
+var import_shelljs = require("shelljs");
+var import_path = require("path");
+var import_os = require("os");
+const getPathName = () => {
+  switch ((0, import_os.platform)()) {
+    case "win32":
+      return "win/luac.exe";
+    case "linux":
+      return "linux/luac";
+    case "darwin":
+      return "mac/luac";
+    default:
+      throw Error("\u4E0D\u652F\u6301\u7684\u64CD\u4F5C\u7CFB\u7EDF");
+  }
+};
+function compileToByte(filePath) {
+  const bin = (0, import_path.resolve)(__dirname, "../lua/bin", getPathName());
+  return new Promise((resolve2, reject) => {
+    (0, import_shelljs.exec)(
+      `${bin} -s -o - ${filePath}`,
+      { silent: true, encoding: "buffer" },
+      (code, out, err) => {
+        if (code === 0) {
+          resolve2(out);
+        } else {
+          reject(err.toString());
+        }
+      }
+    );
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  compileToByte
+});

package/dist/config.d.ts

@@ -0,0 +1,11 @@
+declare const CodegenConfig: {
+    webDir: string;
+    apiDir: string;
+    reverse: boolean;
+};
+export type ConfigType = Partial<typeof CodegenConfig>;
+export declare function setConfig(config: ConfigType): void;
+export declare const getWebDir: () => string;
+export declare const getApiDir: () => string;
+export declare const isReverse: () => boolean;
+export {};

package/dist/config.js

@@ -0,0 +1,53 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  getApiDir: () => getApiDir,
+  getWebDir: () => getWebDir,
+  isReverse: () => isReverse,
+  setConfig: () => setConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_path = require("path");
+const CodegenConfig = {
+  webDir: (0, import_path.resolve)(__dirname, ".."),
+  apiDir: (0, import_path.resolve)(__dirname, ".."),
+  reverse: false
+};
+function setConfig(config) {
+  if (config.webDir) {
+    CodegenConfig.webDir = config.webDir;
+  }
+  if (config.apiDir) {
+    CodegenConfig.apiDir = config.apiDir;
+  }
+  if (config.reverse !== void 0) {
+    CodegenConfig.reverse = config.reverse;
+  }
+}
+const getWebDir = () => CodegenConfig.webDir;
+const getApiDir = () => CodegenConfig.apiDir;
+const isReverse = () => CodegenConfig.reverse;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getApiDir,
+  getWebDir,
+  isReverse,
+  setConfig
+});

package/dist/format/api.d.ts

@@ -0,0 +1,8 @@
+import { ApiServiceField } from '@/types';
+import { BaseFormat } from './base';
+export declare class ApiFormat extends BaseFormat<ApiServiceField> {
+    #private;
+    constructor(moduleName: string, apiService: ApiServiceField[]);
+    protected formatOnceStep(): void;
+    protected formatEnd(): void;
+}

package/dist/format/api.js

@@ -0,0 +1,122 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var api_exports = {};
+__export(api_exports, {
+  ApiFormat: () => ApiFormat
+});
+module.exports = __toCommonJS(api_exports);
+var import_base = require("./base");
+class ApiFormat extends import_base.BaseFormat {
+  #hasInterceptor = false;
+  #moudleName;
+  #upperName;
+  #apiMap = {};
+  #importCommon = "Controller,";
+  constructor(moduleName, apiService) {
+    super(apiService);
+    this.#moudleName = moduleName;
+    this.#upperName = moduleName[0].toUpperCase() + moduleName.slice(1);
+  }
+  formatOnceStep() {
+    const { key, interceptor } = this.getCurSchema();
+    if (this.#apiMap[key]) {
+      return;
+    }
+    this.#apiMap[key] = true;
+    if (interceptor) {
+      this.#hasInterceptor = true;
+      this.content += "\n@UseInterceptors(ClassSerializerInterceptor)\n";
+    }
+    if (key === "get") {
+      this.content += `
+				@Get(':id')
+				findOne(@Param('id') id: string) {
+					return this.${this.#moudleName}Service.query(+id)
+				}
+`;
+    } else if (key === "all") {
+      this.content += `
+				@Get()
+				findAll(@Query() pageDto: PageDto) {
+					const { skip, take } = PageDto.setSkipTake(pageDto)
+					return this.${this.#moudleName}Service.table(skip, take, pageDto.search)
+				}
+`;
+    } else if (key === "delete") {
+      this.content += `
+				@Delete(':id')
+				remove(@Param('id') id: string) {
+					return this.${this.#moudleName}Service.delete(+id)
+				}
+`;
+    } else if (key === "update") {
+      this.content += `
+				@Patch(':id')
+				update(@Param('id') id: string, @Body() update${this.#upperName}Dto: Update${this.#upperName}Dto) {
+					return this.${this.#moudleName}Service.update(+id, update${this.#upperName}Dto)
+				}
+`;
+    } else if (key === "add") {
+      this.content += `
+				@Post()
+				create(@Body() create${this.#upperName}Dto: Create${this.#upperName}Dto) {
+					return this.${this.#moudleName}Service.create(create${this.#upperName}Dto)
+				}
+`;
+    }
+  }
+  formatEnd() {
+    if (this.#apiMap["get"]) {
+      this.#importCommon += "Get,";
+    }
+    if (this.#apiMap["delete"]) {
+      this.#importCommon += "Delete,";
+    }
+    if (this.#apiMap["all"]) {
+      this.#importCommon += "Query,";
+      this.importInfo += `import { PageDto } from '@api/common/dto/page.dto'
+`;
+    }
+    if (this.#apiMap["add"]) {
+      this.#importCommon += "Post,";
+      this.importInfo += `import { Create${this.#upperName}Dto } from './dto/create-${this.#moudleName}.dto'
+`;
+    }
+    if (this.#apiMap["update"]) {
+      this.#importCommon += "Patch,";
+      this.importInfo += `import { Update${this.#upperName}Dto } from './dto/update-${this.#moudleName}.dto'
+`;
+    }
+    if (this.#apiMap["get"] || this.#apiMap["delete"] || this.#apiMap["update"]) {
+      this.#importCommon += "Param,";
+    }
+    if (this.#apiMap["add"] || this.#apiMap["update"]) {
+      this.#importCommon += "Body,";
+    }
+    if (this.#hasInterceptor) {
+      this.#importCommon += "UseInterceptors,ClassSerializerInterceptor,";
+    }
+    this.importInfo += `import { ${this.#importCommon.slice(0, this.#importCommon.length - 1)} } from '@nestjs/common'
+`;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ApiFormat
+});

package/dist/format/base.d.ts

@@ -0,0 +1,10 @@
+export declare abstract class BaseFormat<T> {
+    #private;
+    protected importInfo: string;
+    protected content: string;
+    constructor(schemas: T[]);
+    protected getCurSchema(): T;
+    protected formatOnceStep(): void;
+    protected formatEnd(): void;
+    format(): string[];
+}

package/dist/format/base.js

@@ -0,0 +1,56 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var base_exports = {};
+__export(base_exports, {
+  BaseFormat: () => BaseFormat
+});
+module.exports = __toCommonJS(base_exports);
+class BaseFormat {
+  importInfo;
+  content;
+  #schemas;
+  #index = 0;
+  constructor(schemas) {
+    this.#schemas = schemas;
+    this.content = "";
+    this.importInfo = "";
+  }
+  #hasNext() {
+    return this.#schemas.length > this.#index;
+  }
+  getCurSchema() {
+    return this.#schemas[this.#index];
+  }
+  formatOnceStep() {
+  }
+  formatEnd() {
+  }
+  format() {
+    while (this.#hasNext()) {
+      this.formatOnceStep();
+      this.#index++;
+    }
+    this.formatEnd();
+    return [this.importInfo, this.content];
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseFormat
+});

package/dist/format/dto.d.ts

@@ -0,0 +1,8 @@
+import { DtoField } from '@/types';
+import { BaseFormat } from './base';
+export declare class DTOFromat extends BaseFormat<DtoField> {
+    #private;
+    constructor(dto: DtoField[]);
+    protected formatOnceStep(): void;
+    protected formatEnd(): void;
+}