@biuxiu/codegen 0.2.12 → 0.2.14

package/dist/code/nest.d.ts

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

package/dist/code/nest.js

@@ -1,6 +1,6 @@
 import xiu from "../render";
 import { join } from "path";
-import { reFromatFile, writeFormatFile } from "../util";
+import { writeFormatFile } from "../util";
 import { existsSync, mkdirSync, statSync } from "fs";
 import { DTOFromat } from "../format/dto";
 import { EntityFormat } from "../format/entity";
@@ -44,15 +44,14 @@ class RenderNest {
         await unlink(filePath);
       }
     }
-    rmdir(path);
+    await rmdir(path);
   }
-  remove() {
+  async remove() {
     if (existsSync(this.#moduleDir)) {
-      this.#deleteDir(this.#moduleDir);
+      await this.#deleteDir(this.#moduleDir);
     }
-    this.editAppModule(true);
   }
-  editAppModule(isDelete = false) {
+  async editAppModule(isDelete = false) {
     if (!isDelete) {
       let basePath = "";
       const apiDir = getApiDir();
@@ -131,16 +130,15 @@ class RenderNest {
             consumerStatement.replaceWithText(newText);
           }
         }
-        await source.save();
-        await reFromatFile(appModuleFile);
+        await writeFormatFile(appModuleFile, source.getFullText());
       }
     });
-    runEditTask();
+    await runEditTask();
   }
   async genModule() {
     const modulePath = join(this.#moduleDir, `${this.#name}.module.ts`);
     const moduleStr = await xiu.render("module", { name: this.#name });
-    writeFormatFile(modulePath, moduleStr);
+    await writeFormatFile(modulePath, moduleStr);
   }
   async genApiService(apiService) {
     const controllerPath = join(
@@ -152,24 +150,26 @@ class RenderNest {
       this.#name,
       apiService
     ).format();
-    xiu.render("controller", {
-      name: this.#name,
-      importInfo: apiImport,
-      content: apiContent
-    }).then((controllerStr) => {
-      writeFormatFile(controllerPath, controllerStr);
-    });
     const [serviceImport, serviceContent] = new ServiceFormat(
       this.#name,
       apiService
     ).format();
-    xiu.render("service", {
-      name: this.#name,
-      content: serviceContent,
-      importInfo: serviceImport
-    }).then((serviceStr) => {
-      writeFormatFile(servicePath, serviceStr);
-    });
+    const [controllerStr, serviceStr] = await Promise.all([
+      xiu.render("controller", {
+        name: this.#name,
+        importInfo: apiImport,
+        content: apiContent
+      }),
+      xiu.render("service", {
+        name: this.#name,
+        content: serviceContent,
+        importInfo: serviceImport
+      })
+    ]);
+    await Promise.all([
+      writeFormatFile(controllerPath, controllerStr),
+      writeFormatFile(servicePath, serviceStr)
+    ]);
   }
   async genEntity(entity) {
     const entityDir = join(this.#moduleDir, "entities");
@@ -183,7 +183,7 @@ class RenderNest {
       importInfo,
       content
     });
-    writeFormatFile(entityPath, entityStr);
+    await writeFormatFile(entityPath, entityStr);
   }
   async genDto(dto) {
     const dtoPath = join(this.#moduleDir, "dto");
@@ -193,16 +193,14 @@ class RenderNest {
     const createDtoPath = join(dtoPath, `create-${this.#name}.dto.ts`);
     const updateDtoPath = join(dtoPath, `update-${this.#name}.dto.ts`);
     const [importInfo, content] = new DTOFromat(dto).format();
-    const createDtoStr = await xiu.render("create-dto", {
-      importInfo,
-      name: this.#name,
-      content
-    });
-    const updateDtoStr = await xiu.render("update-dto", {
-      name: this.#name
-    });
-    writeFormatFile(createDtoPath, createDtoStr);
-    writeFormatFile(updateDtoPath, updateDtoStr);
+    const [createDtoStr, updateDtoStr] = await Promise.all([
+      xiu.render("create-dto", { importInfo, name: this.#name, content }),
+      xiu.render("update-dto", { name: this.#name })
+    ]);
+    await Promise.all([
+      writeFormatFile(createDtoPath, createDtoStr),
+      writeFormatFile(updateDtoPath, updateDtoStr)
+    ]);
   }
 }
 export {

package/dist/code/vue.d.ts

@@ -0,0 +1,11 @@
+import { ApiServiceField, FieldSchema, ModuleConfig, ModuleRoute } from '@/types';
+export declare class RenderVue {
+    #private;
+    constructor(name: string, path?: string);
+    editDir(isDelete?: boolean): Promise<void>;
+    setDatabase(route: ModuleRoute, isDelete?: boolean): Promise<undefined>;
+    genRoute(route: ModuleRoute): Promise<void>;
+    genVueTable({ name, comment }: ModuleConfig, fields: FieldSchema[]): Promise<void>;
+    genVueForm(config: ModuleConfig, fields: FieldSchema[]): Promise<void>;
+    genTsFile(fields: FieldSchema[], api: ApiServiceField[]): Promise<void>;
+}

package/dist/code/vue.js

@@ -0,0 +1,176 @@
+import { getSqliteFile, getWebDir } from "@/config";
+import xiu from "@/render";
+import { writeFormatFile } from "@/util";
+import { existsSync, mkdirSync, statSync } from "fs";
+import { readdir, rmdir, unlink } from "fs/promises";
+import { join } from "path";
+import Database from "better-sqlite3";
+class RenderVue {
+  #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;
+    const webDir = getWebDir();
+    this.#name = name;
+    this.#moduleDir = join(webDir, this.#path);
+  }
+  async #deleteDir(path) {
+    const files = await readdir(path);
+    for (let i = 0; i < files.length; i++) {
+      const filePath = join(path, files[i]);
+      if (statSync(filePath).isDirectory()) {
+        await this.#deleteDir(filePath);
+      } else {
+        await unlink(filePath);
+      }
+    }
+    await rmdir(path);
+  }
+  async editDir(isDelete = false) {
+    if (isDelete) {
+      if (existsSync(this.#moduleDir)) {
+        await this.#deleteDir(this.#moduleDir);
+      }
+    } else {
+      let basePath = "";
+      const apiDir = getWebDir();
+      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 = join(apiDir, curPath);
+          } else {
+            basePath = join(basePath, curPath);
+          }
+          if (!existsSync(basePath)) {
+            mkdirSync(basePath);
+          }
+        }
+      } else {
+        basePath = join(apiDir, this.#path);
+        if (!existsSync(basePath)) {
+          mkdirSync(basePath);
+        }
+      }
+    }
+  }
+  #findIdByKey(key, select) {
+    const result = select.get(key);
+    return result ? result.id : void 0;
+  }
+  async setDatabase(route, isDelete = false) {
+    const sqliteFile = getSqliteFile();
+    if (!existsSync(sqliteFile)) {
+      return;
+    }
+    const db = new Database(sqliteFile);
+    const selectStmt = db.prepare(
+      `SELECT id FROM w_permission WHERE key = ?`
+    );
+    const insertStmt = db.prepare(
+      `INSERT INTO w_permission (title, key, description, pid) VALUES (@title, @key, @description, @pid)`
+    );
+    const deleteStmt = db.prepare(`DELETE FROM w_permission WHERE key = ?`);
+    const hasPremissionTbl = db.prepare(
+      `SELECT name FROM sqlite_master WHERE type='table' AND name=?`
+    ).get("w_permission");
+    if (!hasPremissionTbl) {
+      return Promise.reject("\u6743\u9650\u8868\u4E0D\u5B58\u5728");
+    }
+    const pathList = route.path.split("/").filter((p) => p);
+    const prefixKey = pathList.length > 1 ? "#" + pathList[0].replaceAll("-", "_") : "";
+    let pid = null;
+    if (prefixKey) {
+      const id = this.#findIdByKey(prefixKey, selectStmt);
+      if (!id) return Promise.reject(`\u7236\u7EA7\u6743\u9650${prefixKey}\u4E0D\u5B58\u5728`);
+      pid = id;
+    }
+    const key = "#" + pathList.join("_").replaceAll("-", "_");
+    let fn;
+    if (isDelete) {
+      const list = ["@add", "@update", "@delete"].map((k) => key + k);
+      fn = db.transaction(() => {
+        for (const k of list) {
+          deleteStmt.run(k);
+        }
+        deleteStmt.run(key);
+      });
+    } else {
+      const keyId = this.#findIdByKey(key, selectStmt);
+      if (keyId) return Promise.reject(`\u5F53\u524D\u6743\u9650${key}\u5DF2\u5B58\u5728`);
+      const list = [
+        { k: "@add", title: "\u6DFB\u52A0" },
+        { k: "@update", title: "\u4FEE\u6539" },
+        { k: "@delete", title: "\u5220\u9664" }
+      ].map(({ k, title }) => ({
+        title: title + route.title,
+        key: key + k,
+        description: title + route.title + "\u4FE1\u606F"
+      }));
+      fn = db.transaction(() => {
+        const { lastInsertRowid } = insertStmt.run({
+          key,
+          title: route.title,
+          description: `${route.title}\u9875\u9762\u67E5\u770B`,
+          pid
+        });
+        for (const item of list) {
+          insertStmt.run({ ...item, pid: lastInsertRowid });
+        }
+      });
+    }
+    try {
+      fn();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+  async genRoute(route) {
+    const filePath = join(this.#moduleDir, "meta.json");
+    const source = await xiu.render("route-mata", route);
+    await writeFormatFile(filePath, source, "json");
+  }
+  async genVueTable({ name, comment }, fields) {
+    const filePath = join(this.#moduleDir, "index.vue");
+    const source = await xiu.render("index-vue", {
+      name,
+      comment,
+      fields
+    });
+    await writeFormatFile(filePath, source, "vue");
+  }
+  async genVueForm(config, fields) {
+    const filePath = join(this.#moduleDir, "form.vue");
+    const source = await xiu.render("form-vue", {
+      name: config.name,
+      comment: config.comment,
+      fields: fields.map((f) => ({
+        ...f,
+        isNumber: f.type === "number",
+        isString: f.type === "string"
+      }))
+    });
+    await writeFormatFile(filePath, source, "vue");
+  }
+  async genTsFile(fields, api) {
+    const apiMathods = api.map((a) => a.key);
+    const filePath = join(this.#moduleDir, "fetch-type.ts");
+    const source = await xiu.render("fetch-type", {
+      name: this.#name,
+      filedList: fields,
+      add: apiMathods.includes("add"),
+      delete: apiMathods.includes("delete"),
+      all: apiMathods.includes("all"),
+      update: apiMathods.includes("update")
+    });
+    await writeFormatFile(filePath, source);
+  }
+}
+export {
+  RenderVue
+};

package/dist/config.d.ts

@@ -1,6 +1,7 @@
 declare const CodegenConfig: {
     webDir: string;
     apiDir: string;
+    sqliteFile: string;
     reverse: boolean;
 };
 export type ConfigType = Omit<Partial<typeof CodegenConfig>, 'reverse'>;
@@ -8,5 +9,6 @@ export declare function setConfig(config: ConfigType): void;
 export declare const setReverse: (reverse: boolean) => boolean;
 export declare const getWebDir: () => string;
 export declare const getApiDir: () => string;
+export declare const getSqliteFile: () => string;
 export declare const isReverse: () => boolean;
 export {};

package/dist/config.js

@@ -2,6 +2,7 @@ import { resolve } from "path";
 const CodegenConfig = {
   webDir: resolve(__dirname, ".."),
   apiDir: resolve(__dirname, ".."),
+  sqliteFile: resolve(__dirname, "..", "admin.db"),
   reverse: false
 };
 function setConfig(config) {
@@ -11,13 +12,18 @@ function setConfig(config) {
   if (config.apiDir) {
     CodegenConfig.apiDir = config.apiDir;
   }
+  if (config.sqliteFile) {
+    CodegenConfig.sqliteFile = config.sqliteFile;
+  }
 }
 const setReverse = (reverse) => CodegenConfig.reverse = reverse;
 const getWebDir = () => CodegenConfig.webDir;
 const getApiDir = () => CodegenConfig.apiDir;
+const getSqliteFile = () => CodegenConfig.sqliteFile;
 const isReverse = () => CodegenConfig.reverse;
 export {
   getApiDir,
+  getSqliteFile,
   getWebDir,
   isReverse,
   setConfig,

package/dist/format/api.js

@@ -1,6 +1,7 @@
 import { BaseFormat } from "./base";
 class ApiFormat extends BaseFormat {
   #hasInterceptor = false;
+  #isNoAuth = false;
   #moudleName;
   #upperName;
   #apiMap = {};
@@ -11,7 +12,7 @@ class ApiFormat extends BaseFormat {
     this.#upperName = moduleName[0].toUpperCase() + moduleName.slice(1);
   }
   formatOnceStep() {
-    const { key, interceptor } = this.getCurSchema();
+    const { key, interceptor, noAuth } = this.getCurSchema();
     if (this.#apiMap[key]) {
       return;
     }
@@ -20,6 +21,10 @@ class ApiFormat extends BaseFormat {
       this.#hasInterceptor = true;
       this.content += "\n@UseInterceptors(ClassSerializerInterceptor)\n";
     }
+    if (noAuth) {
+      this.#isNoAuth = true;
+      this.content += "\n@NoAuthToken()\n";
+    }
     if (key === "get") {
       this.content += `
 				@Get(':id')
@@ -86,6 +91,10 @@ class ApiFormat extends BaseFormat {
     if (this.#apiMap["add"] || this.#apiMap["update"]) {
       this.#importCommon += "Body,";
     }
+    if (this.#isNoAuth) {
+      this.importInfo += `import { NoAuthToken } from '@api/common/utils/passport'
+`;
+    }
     if (this.#hasInterceptor) {
       this.#importCommon += "UseInterceptors,ClassSerializerInterceptor,";
     }

package/dist/gen-type.js

@@ -3,14 +3,14 @@ import { writeFormatFile } from "./util";
 import { existsSync, mkdirSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
 const genLuaTypes = async (path) => {
-  const types = ["base", "nest", "vue"];
+  const types = ["api", "base", "dto", "orm"];
   const vscodePath = join(path, ".vscode");
   if (!existsSync(vscodePath)) {
     mkdirSync(vscodePath);
   }
   const moveList = types.map((t) => ({
     writePath: join(vscodePath, `${t}-type.lua`),
-    readPath: resolve(__dirname, `../sources/${t}-type.txt`)
+    readPath: resolve(__dirname, `../sources/${t}-type.lua`)
   }));
   moveList.forEach((m) => {
     if (!existsSync(m.writePath)) {
@@ -27,7 +27,7 @@ const genLuaTypes = async (path) => {
       settionObj["Lua.workspace.library"] = types.map(
         (t) => `.vscode/${t}-type.lua`
       );
-      writeFormatFile(settingPath, JSON.stringify(settionObj), true);
+      writeFormatFile(settingPath, JSON.stringify(settionObj), "json");
     }
   } else {
     writeFormatFile(
@@ -35,7 +35,7 @@ const genLuaTypes = async (path) => {
       JSON.stringify({
         "Lua.workspace.library": types.map((t) => `.vscode/${t}-type.lua`)
       }),
-      true
+      "json"
     );
   }
 };

package/dist/index.d.ts

@@ -1,5 +1,7 @@
-import { genLuaTypes } from './gen-type';
 import { ConfigType } from './config';
-declare const startGen: (filePath: string, config?: ConfigType) => Promise<undefined>;
-declare const startRemove: (filePath: string, config?: ConfigType) => Promise<undefined>;
-export { startGen, startRemove, genLuaTypes };
+declare const _default: {
+    startGen: (filePath: string, config?: ConfigType | undefined) => Promise<undefined>;
+    startRemove: (filePath: string, config?: ConfigType | undefined) => Promise<undefined>;
+    genLuaTypes: (path: string) => Promise<void>;
+};
+export default _default;

package/dist/index.js

@@ -2,29 +2,30 @@ import { compileToByte } from "./compile";
 import { existsSync } from "fs";
 import { genLuaTypes } from "./gen-type";
 import { setConfig, setReverse } from "./config";
-async function startRun(filePath, isDelete, config) {
-  if (config) setConfig(config);
-  setReverse(isDelete);
-  if (existsSync(filePath)) {
-    try {
-      const data = await compileToByte(filePath);
-      const { run } = await import("./lua_codegen");
+import { runTask } from "./task";
+function startRun(isDelete) {
+  return async function(filePath, config) {
+    if (config) setConfig(config);
+    setReverse(isDelete);
+    if (existsSync(filePath)) {
+      try {
+        const data = await compileToByte(filePath);
+        const { run } = await import("./lua_codegen");
 			run(new Uint8Array(data), filePath);
-    } catch (error) {
-      return Promise.reject(error);
+        await runTask();
+      } catch (error) {
+        return Promise.reject(error);
+      }
+    } else {
+      return Promise.reject(`${filePath}\u6587\u4EF6\u5B58\u5728`);
     }
-  } else {
-    return Promise.reject(`${filePath}\u6587\u4EF6\u5B58\u5728`);
-  }
+  };
 }
-const startGen = (filePath, config) => {
-  return startRun(filePath, false, config);
-};
-const startRemove = (filePath, config) => {
-  return startRun(filePath, true, config);
+var src_default = {
+  startGen: startRun(false),
+  startRemove: startRun(true),
+  genLuaTypes
 };
 export {
-  genLuaTypes,
-  startGen,
-  startRemove
+  src_default as default
 };

package/dist/libs/nest-lib.d.ts

@@ -1,5 +1,5 @@
 import { ApiServiceField, DtoField, EntityField } from '../types';
-export declare function renderNestCode(entity: EntityField[], dto: DtoField[], apiService: ApiServiceField[], config: {
+export declare function renderNestCode(config: {
     name: string;
     path?: string;
-}): void;
+}, entity: EntityField[], dto: DtoField[], apiService: ApiServiceField[]): void;

package/dist/libs/nest-lib.js

@@ -1,16 +1,22 @@
+import { setTask } from "../task";
 import { RenderNest } from "../code/nest";
 import { isReverse } from "../config";
-function renderNestCode(entity, dto, apiService, config) {
-  const api = new RenderNest(config.name, config.path);
-  if (isReverse()) {
-    api.remove();
-    return;
-  }
-  api.editAppModule();
-  api.genModule();
-  api.genDto(dto);
-  api.genEntity(entity);
-  api.genApiService(apiService);
+function renderNestCode(config, entity, dto, apiService) {
+  setTask(async () => {
+    const api = new RenderNest(config.name, config.path);
+    if (isReverse()) {
+      await Promise.all([api.remove(), api.editAppModule(true)]);
+    } else {
+      await Promise.all([
+        api.editAppModule(),
+        api.genModule(),
+        api.genDto(dto),
+        api.genEntity(entity),
+        api.genApiService(apiService)
+      ]);
+    }
+    console.log("lib end>>>");
+  });
 }
 export {
   renderNestCode

package/dist/libs.d.ts

@@ -0,0 +1,9 @@
+import { ApiServiceField, DtoField, EntityField, FieldSchema, ModuleConfig, ModuleRoute } from './types';
+export declare function renderNestCode(config: {
+    name: string;
+    path?: string;
+}, entity: EntityField[], dto: DtoField[], apiService: ApiServiceField[]): void;
+type FieldTuple = [string, FieldSchema['type'], string];
+export declare function renderVueCode(config: ModuleConfig, route: ModuleRoute, fieldList: FieldTuple[], api: ApiServiceField[]): void;
+export declare function printToNode(info: any): void;
+export {};

package/dist/libs.js

@@ -0,0 +1,51 @@
+import { setTask } from "./task";
+import { RenderNest } from "./code/nest";
+import { isReverse } from "./config";
+import { RenderVue } from "./code/vue";
+function renderNestCode(config, entity, dto, apiService) {
+  setTask(async () => {
+    const nest = new RenderNest(config.name, config.path);
+    if (isReverse()) {
+      await Promise.all([nest.remove(), nest.editAppModule(true)]);
+    } else {
+      await nest.editAppModule();
+      await Promise.all([
+        nest.genModule(),
+        nest.genDto(dto),
+        nest.genEntity(entity),
+        nest.genApiService(apiService)
+      ]);
+    }
+  });
+}
+function renderVueCode(config, route, fieldList, api) {
+  setTask(async () => {
+    const fields = fieldList.map(([key, type, comment]) => ({
+      key,
+      type,
+      comment
+    }));
+    const vue = new RenderVue(config.name, config.path);
+    if (isReverse()) {
+      vue.editDir(true);
+      vue.setDatabase(route, true);
+    } else {
+      await vue.editDir();
+      await Promise.all([
+        vue.setDatabase(route),
+        vue.genTsFile(fields, api),
+        vue.genRoute(route),
+        vue.genVueForm(config, fields),
+        vue.genVueTable(config, fields)
+      ]);
+    }
+  });
+}
+function printToNode(info) {
+  console.log(info);
+}
+export {
+  printToNode,
+  renderNestCode,
+  renderVueCode
+};

package/dist/lua_codegen_bg.js

@@ -1,6 +1,4 @@
-import { printToNode } from './libs';
-import { renderNestCode } from './libs/nest-lib';
-import { genWebCode } from './libs/vue-lib';
+import { printToNode, renderNestCode, renderVueCode } from './libs';
 
 let wasm;
 export function __wbg_set_wasm(val) {
@@ -146,12 +144,12 @@ export function __wbindgen_object_drop_ref(arg0) {
     takeObject(arg0);
 };
 
-export function __wbg_renderNestCode_ba91730cbcd316b3(arg0, arg1, arg2, arg3) {
+export function __wbg_renderNestCode_786f8dedd18b6a00(arg0, arg1, arg2, arg3) {
     renderNestCode(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
 };
 
-export function __wbg_genWebCode_2826bcda9a2b9845(arg0, arg1, arg2) {
-    genWebCode(getStringFromWasm0(arg0, arg1), getObject(arg2));
+export function __wbg_renderVueCode_cd8438a75c2a320e(arg0, arg1, arg2, arg3) {
+    renderVueCode(getObject(arg0), getObject(arg1), getObject(arg2), getObject(arg3));
 };
 
 export function __wbg_printToNode_f8646f4da26c5023(arg0) {

package/dist/render.js

@@ -2,10 +2,7 @@ import { XiuTemplate } from "@biuxiu/template";
 import { resolve } from "path";
 const basePath = resolve(__dirname, "..");
 const xiu = new XiuTemplate(basePath);
-xiu.install(() => ({
-  name: "up",
-  fn: (val) => val[0].toUpperCase() + val.slice(1)
-}));
+xiu.install(["up", (val) => val[0].toUpperCase() + val.slice(1)]);
 var render_default = xiu;
 export {
   render_default as default

package/dist/task.d.ts

@@ -0,0 +1,6 @@
+type TaskFn = {
+    (): Promise<void>;
+};
+export declare function setTask(fn: TaskFn): void;
+export declare function runTask(): Promise<void[]>;
+export {};

package/dist/task.js

@@ -0,0 +1,16 @@
+const TaskQueue = [];
+function setTask(fn) {
+  TaskQueue.push(fn);
+}
+function runTask() {
+  const currentTask = [];
+  for (let i = 0; i < TaskQueue.length; i++) {
+    const fn = TaskQueue[i];
+    currentTask.push(fn);
+  }
+  return Promise.all(currentTask.map((f) => f()));
+}
+export {
+  runTask,
+  setTask
+};

package/dist/types.d.ts

@@ -1,7 +1,18 @@
-type FieldSchema = {
+export type FieldSchema = {
     key: string;
+    comment: string;
     type: 'string' | 'number' | 'bool';
 };
+export interface ModuleConfig {
+    name: string;
+    comment: string;
+    path?: string;
+}
+export interface ModuleRoute {
+    path: string;
+    icon: string;
+    title: string;
+}
 export type DtoField = FieldSchema & {
     isOptional?: boolean;
     limit?: {
@@ -15,7 +26,6 @@ export type DtoField = FieldSchema & {
 };
 export type EntityField = FieldSchema & {
     isExclude?: true;
-    comment?: string;
     length?: number;
     nullable?: true;
     name?: string;
@@ -24,5 +34,5 @@ export type EntityField = FieldSchema & {
 export type ApiServiceField = {
     key: 'get' | 'all' | 'delete' | 'update' | 'add';
     interceptor?: true;
+    noAuth?: true;
 };
-export {};

package/dist/util.d.ts

@@ -1,2 +1,2 @@
-export declare const reFromatFile: (filePath: string) => Promise<void>;
-export declare const writeFormatFile: (filePath: string, content: string, isJson?: boolean) => Promise<void>;
+import { BuiltInParserName, LiteralUnion } from 'prettier';
+export declare const writeFormatFile: (filePath: string, content: string, parser?: LiteralUnion<BuiltInParserName>) => Promise<undefined>;

package/dist/util.js

@@ -1,23 +1,22 @@
-import { readFile, writeFile } from "fs/promises";
-import { format, resolveConfig, resolveConfigFile } from "prettier";
-const reFromatFile = async (filePath) => {
-  const content = await readFile(filePath, "utf-8");
-  await writeFormatFile(filePath, content);
-};
-const writeFormatFile = async (filePath, content, isJson = false) => {
+import { writeFile } from "fs/promises";
+import {
+  format,
+  resolveConfig,
+  resolveConfigFile
+} from "prettier";
+const writeFormatFile = async (filePath, content, parser = "typescript") => {
   try {
     const file = await resolveConfigFile(filePath);
     const config = file ? await resolveConfig(file) : {};
     const formatText = await format(content, {
       ...config,
-      parser: isJson ? "json" : "typescript"
+      parser
     });
     await writeFile(filePath, formatText);
   } catch (error) {
-    console.log(error);
+    return Promise.reject(error);
   }
 };
 export {
-  reFromatFile,
   writeFormatFile
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@biuxiu/codegen",
-	"version": "0.2.12",
+	"version": "0.2.14",
 	"description": "代码生成工具",
 	"main": "dist/index.js",
 	"scripts": {
@@ -19,6 +19,7 @@
 	"license": "ISC",
 	"devDependencies": {
 		"@biuxiu/publish": "^1.2.11",
+		"@types/better-sqlite3": "^7.6.11",
 		"@types/node": "^20.14.2",
 		"@types/shelljs": "^0.8.15",
 		"esbuild": "^0.21.5",
@@ -28,8 +29,8 @@
 		"typescript": "^5.4.5"
 	},
 	"dependencies": {
-		"@biuxiu/template": "^1.2.3",
-		"module-alias": "^2.2.3",
+		"@biuxiu/template": "^1.5.2",
+		"better-sqlite3": "^11.1.2",
 		"prettier": "^3.3.2",
 		"ts-morph": "^22.0.0"
 	}