evaengine 1.0.14 → 3.0.0

package/README.md

@@ -22,6 +22,8 @@
 npm install evaengine
 ```
 
+本包源码为 TypeScript，npm 发布 `dist/` 编译产物并自带 `.d.ts` 类型声明（`@types/express`、`@types/lodash` 随 dependencies 自动安装，严格模式下类型开箱即用）；上述导入契约不受影响。
+
 可选脚手架：[EvaSkeleton.js](https://github.com/EvaEngine/EvaSkeleton.js)。
 
 ## 导入方式（重要）
@@ -130,6 +132,8 @@ await engine.runCLI();
 // node app.js user:create --name=Ada
 ```
 
+命令不存在或 `run()` 抛出异常时，进程以退出码 1 结束。
+
 ### 定时任务
 
 ```js
@@ -154,11 +158,6 @@ npx engine make:graphql
 npx engine tramp:dump-config
 ```
 
-配合 Spring Cloud Config（仅 bin）：
-
-- `SPRING_CONFIG_ENDPOINT`（设置后启用）
-- `SPRING_CONFIG_NAME`、`SPRING_CONFIG_PROFILES`、`SPRING_CONFIG_LABEL`
-
 ---
 
 ## 推荐项目结构
@@ -241,7 +240,6 @@ config.get(); // 完整对象
 | `CLI_NAME` | CLI 模式下 logger 标签 |
 | `MAX_REQUEST_DEBUG_BODY` | debug 中间件 body 限制 |
 | `SEQUELIZE_REPLICATION_CONFIG_KEY` | `db` 下 replication 配置的替代键名 |
-| `SPRING_CONFIG_*` | bin 远程配置（见上文） |
 
 ---
 
@@ -361,7 +359,15 @@ entities.init(); // 按 config.db 构建 Sequelize 并扫描目录
 
 const User = entities.get('user');
 const all = entities.getAll();
-await entities.getTransaction(async (t) => { /* … */ });
+
+const transaction = await entities.getTransaction();
+try {
+  await User.create({ name: 'Ada' }, { transaction });
+  await transaction.commit();
+} catch (error) {
+  await transaction.rollback();
+  throw error;
+}
 ```
 
 实体文件（经 `require` 加载的 CJS 或 ESM 工厂）：
@@ -441,4 +447,6 @@ npm run build
 npm test          # 部分测试需要本机 Redis 127.0.0.1:6379
 ```
 
+仓库源码为严格 TypeScript（仅可擦除语法），Node ≥24 原生直接运行 `src/**/*.ts`，日常开发无转译步骤；`npm run build` 用 tsc 编译发布产物 `dist/` 并生成声明文件。本地 CLI 可直接 `node src/bin.ts`，或先 build 后走 `./bin/engine`（shim → `dist/bin.js`）。
+
 发版：在 `main` 上由 semantic-release（Conventional Commits）执行——仅发布 npm，不创建 GitHub Release。维护者文档在 git 的 `docs/` 下，**npm 消费方无需阅读**。

package/bin/engine

@@ -1,32 +1,3 @@
 #!/usr/bin/env node
-import { EvaEngine, DI, exceptions, commands } from '../index.js';
-
-const engine = new EvaEngine({
-  projectRoot: process.cwd()
-}, 'cli');
-engine.registerCommands([commands]);
-
-const logger = DI.get('logger');
-try {
-  if (process.env.SPRING_CONFIG_ENDPOINT) {
-    await DI.get('config').resolveSpringConfig({
-      endpoint: process.env.SPRING_CONFIG_ENDPOINT,
-      name: process.env.SPRING_CONFIG_NAME || 'unknown-spring-config-name',
-      profiles: process.env.SPRING_CONFIG_PROFILES || process.env.NODE_ENV,
-      label: process.env.SPRING_CONFIG_LABEL || 'main'
-    });
-  }
-  await engine.runCLI();
-} catch (error) {
-  if (error instanceof exceptions.StandardException) {
-    logger.warn(error.getDetails());
-    logger.warn(error.message);
-  } else {
-    logger.error(error);
-  }
-} finally {
-  const redis = DI.get('redis');
-  if (redis.isConnected()) {
-    await redis.cleanup();
-  }
-}
+//Thin launcher: the CLI implementation lives in src/bin.ts and is compiled to dist
+import '../dist/bin.js';

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/bin.js

@@ -0,0 +1,32 @@
+//The package entry only exports the core object, so the CLI imports its
+//building blocks directly (the legacy bin/engine named imports were broken)
+import EvaEngine from "./engine.js";
+import DI from "./di.js";
+import * as exceptions from "./exceptions/index.js";
+import * as commands from "./commands/index.js";
+const engine = new EvaEngine({
+    projectRoot: process.cwd()
+}, 'cli');
+engine.registerCommands([commands]);
+const logger = DI.get('logger');
+try {
+    await engine.runCLI();
+}
+catch (error) {
+    //用 exitCode 而非 process.exit，让 finally 里的 Redis 清理自然完成后进程才结束
+    process.exitCode = 1;
+    if (error instanceof exceptions.StandardException) {
+        logger.warn(error.getDetails());
+        logger.warn(error.message);
+    }
+    else {
+        logger.error(error);
+    }
+}
+finally {
+    const redis = DI.get('redis');
+    if (redis.isConnected()) {
+        await redis.cleanup();
+    }
+}
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,4EAA4E;AAC5E,OAAO,SAAS,MAAM,aAAa,CAAC;AACpC,OAAO,EAAE,MAAM,SAAS,CAAC;AACzB,OAAO,KAAK,UAAU,MAAM,uBAAuB,CAAC;AACpD,OAAO,KAAK,QAAQ,MAAM,qBAAqB,CAAC;AAEhD,MAAM,MAAM,GAAG,IAAI,SAAS,CAAC;IAC3B,WAAW,EAAE,OAAO,CAAC,GAAG,EAAE;CAC3B,EAAE,KAAK,CAAC,CAAC;AACV,MAAM,CAAC,gBAAgB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC;AAEpC,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;AAChC,IAAI,CAAC;IACH,MAAM,MAAM,CAAC,MAAM,EAAE,CAAC;AACxB,CAAC;AAAC,OAAO,KAAK,EAAE,CAAC;IACf,4DAA4D;IAC5D,OAAO,CAAC,QAAQ,GAAG,CAAC,CAAC;IACrB,IAAI,KAAK,YAAY,UAAU,CAAC,iBAAiB,EAAE,CAAC;QAClD,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,UAAU,EAAE,CAAC,CAAC;QAChC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;IAC7B,CAAC;SAAM,CAAC;QACN,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IACtB,CAAC;AACH,CAAC;QAAS,CAAC;IACT,MAAM,KAAK,GAAG,EAAE,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;IAC9B,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;QACxB,MAAM,KAAK,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;AACH,CAAC"}

package/{src/commands/index.js → dist/commands/index.d.ts}

@@ -1,12 +1,5 @@
 import Command from './interface.js';
 import { MakeEntity, MakeDbView, MakeGraphql } from './make_entity.js';
 import TrampConfig from './tramp.js';
-
 export default Command;
-
-export {
-  MakeEntity,
-  MakeDbView,
-  MakeGraphql,
-  TrampConfig
-};
+export { MakeEntity, MakeDbView, MakeGraphql, TrampConfig };

package/dist/commands/index.js

@@ -0,0 +1,6 @@
+import Command from "./interface.js";
+import { MakeEntity, MakeDbView, MakeGraphql } from "./make_entity.js";
+import TrampConfig from "./tramp.js";
+export default Command;
+export { MakeEntity, MakeDbView, MakeGraphql, TrampConfig };
+//# sourceMappingURL=index.js.map

package/dist/commands/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/commands/index.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AACvE,OAAO,WAAW,MAAM,YAAY,CAAC;AAErC,eAAe,OAAO,CAAC;AAEvB,OAAO,EACL,UAAU,EACV,UAAU,EACV,WAAW,EACX,WAAW,EACZ,CAAC"}

package/dist/commands/interface.d.ts

@@ -0,0 +1,18 @@
+interface CommandArgv {
+    $0: string;
+    [key: string]: unknown;
+}
+export default class Command {
+    argv: CommandArgv;
+    options: Record<string, unknown> | null;
+    constructor(argv: CommandArgv);
+    getArgv(): CommandArgv;
+    setArgv(argv: CommandArgv): this;
+    setOptions(options: Record<string, unknown>): this;
+    getOptions(): Record<string, unknown>;
+    static getName(): string;
+    static getDescription(): string;
+    static getSpec(): object;
+    run(): void;
+}
+export {};

package/dist/commands/interface.js

@@ -0,0 +1,40 @@
+export default class Command {
+    argv;
+    options;
+    constructor(argv) {
+        this.argv = argv;
+        this.options = null;
+    }
+    getArgv() {
+        return this.argv;
+    }
+    setArgv(argv) {
+        this.argv = argv;
+        return this;
+    }
+    setOptions(options) {
+        this.options = options;
+        return this;
+    }
+    getOptions() {
+        const options = {};
+        Object.keys(this.argv).forEach((key) => {
+            if (key !== '$0' && ['string', 'number'].includes(typeof this.argv[key])) {
+                options[key] = this.argv[key];
+            }
+        });
+        return options;
+    }
+    static getName() {
+        return '';
+    }
+    static getDescription() {
+        return '';
+    }
+    static getSpec() {
+        return {};
+    }
+    run() {
+    }
+}
+//# sourceMappingURL=interface.js.map

package/dist/commands/interface.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"interface.js","sourceRoot":"","sources":["../../src/commands/interface.ts"],"names":[],"mappings":"AAKA,MAAM,CAAC,OAAO,OAAO,OAAO;IAC1B,IAAI,CAAc;IAClB,OAAO,CAAiC;IAExC,YAAY,IAAiB;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;IACtB,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,IAAI,CAAC;IACnB,CAAC;IAED,OAAO,CAAC,IAAiB;QACvB,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC;QACjB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU,CAAC,OAAgC;QACzC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;QACvB,OAAO,IAAI,CAAC;IACd,CAAC;IAED,UAAU;QACR,MAAM,OAAO,GAA4B,EAAE,CAAC;QAC5C,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,GAAG,EAAE,EAAE;YACrC,IAAI,GAAG,KAAK,IAAI,IAAI,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC;gBACzE,OAAO,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;YAChC,CAAC;QACH,CAAC,CAAC,CAAC;QACH,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,MAAM,CAAC,OAAO;QACZ,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,CAAC,cAAc;QACnB,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,MAAM,CAAC,OAAO;QACZ,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,GAAG;IACH,CAAC;CACF"}

package/dist/commands/make_entity.d.ts

@@ -0,0 +1,47 @@
+import Command from './interface.js';
+type SequelizeInstance = import('sequelize').Sequelize & {
+    QueryTypes: typeof import('sequelize').QueryTypes;
+};
+interface RawColumn {
+    Field: string;
+    Key: string;
+    Comment: unknown;
+    Collation: unknown;
+    Extra: string;
+    [key: string]: unknown;
+}
+interface GeneratedIndex {
+    name: string;
+    unique?: boolean;
+    fields?: string[];
+}
+export declare class MakeDbView extends Command {
+    static getName(): string;
+    static getDescription(): string;
+    static getSpec(): object;
+    getSql(tableName: string, attributes: Array<{
+        fieldName: string;
+    }>): string;
+    run(): Promise<void>;
+}
+export declare class MakeEntity extends Command {
+    static getName(): string;
+    static getDescription(): string;
+    static getSpec(): object;
+    static typeMapping(_type: string): string;
+    static typeAdditional(_type: string, sequlizeType: string, rawColumn: RawColumn): string;
+    static getIndexes(tableName: string, sequelize: SequelizeInstance): Promise<GeneratedIndex[]>;
+    run(): Promise<void>;
+}
+export declare class MakeGraphql extends Command {
+    static getName(): string;
+    static getDescription(): string;
+    static getSpec(): object;
+    static typeMapping(_type: string, _mappedTableName?: string): string;
+    getEnums(_type: string, columnName: string, tableName: string): {
+        name: string;
+        values: string[];
+    };
+    run(): Promise<void>;
+}
+export {};

package/dist/commands/make_entity.js

@@ -0,0 +1,410 @@
+import groupBy from 'lodash/groupBy.js';
+import template from 'lodash/template.js';
+import Sequelize from 'sequelize';
+import fs from 'fs';
+import Command from "./interface.js";
+import DI from "../di.js";
+import Entities from "../entities/index.js";
+export class MakeDbView extends Command {
+    static getName() {
+        return 'make:dbview';
+    }
+    static getDescription() {
+        return 'Generate db views';
+    }
+    static getSpec() {
+        return {
+            entity_path: {
+                required: false,
+                description: 'Entity path'
+            },
+            dir: {
+                required: false,
+                description: 'Where view.sql to be generated'
+            }
+        };
+    }
+    getSql(tableName, attributes) {
+        const attrs = attributes.map((attr) => {
+            const { fieldName } = attr;
+            if (fieldName.endsWith('At')) {
+                return ` FROM_UNIXTIME(IF(${fieldName} > 0, ${fieldName}, NULL)) AS ${fieldName}`;
+            }
+            return ` \`${fieldName}\` AS \`${fieldName}\``;
+        });
+        return `DROP VIEW IF EXISTS view_${tableName};
+CREATE ALGORITHM=UNDEFINED SQL SECURITY DEFINER VIEW view_${tableName}
+    AS SELECT
+      ${attrs.join(',\n      ')}
+    FROM ${tableName};
+
+`;
+    }
+    async run() {
+        const logger = DI.get('logger');
+        const { dir, entity_path: entityPath = `${process.cwd()}/build/entities` } = this.getArgv();
+        const path = dir ? `${process.cwd()}/${dir}` : `${process.cwd()}/sql`;
+        const file = [path, 'views.sql'].join('/');
+        logger.info('Scan entity files under %s', entityPath);
+        const entities = new Entities(entityPath);
+        logger.info('Start generate db views to %s', file);
+        fs.mkdirSync(path, { recursive: true });
+        const models = Object.values(entities.getInstance().models);
+        const sql = [];
+        models.forEach((model) => {
+            //运行时 model.attributes 携带 fieldName、getTableName 为静态方法；sequelize 类型未完整声明
+            const entityModel = model;
+            logger.info(`Creating ${entityModel.getTableName()} view`);
+            sql.push(this.getSql(entityModel.getTableName(), Object.values(entityModel.attributes)));
+        });
+        fs.writeFileSync(file, sql.join(''));
+        logger.info('Views created');
+    }
+}
+export class MakeEntity extends Command {
+    static getName() {
+        return 'make:entity';
+    }
+    static getDescription() {
+        return 'Generate entities';
+    }
+    static getSpec() {
+        return {
+            timestamp: {
+                required: false,
+                description: 'Sequelize timestamp enabled'
+            },
+            dir: {
+                required: false,
+                description: 'Where entity files to be generated'
+            },
+            prefix: {
+                required: false,
+                description: 'Table prefix'
+            }
+        };
+    }
+    static typeMapping(_type) {
+        const type = _type.toLowerCase();
+        if (type === 'tinyint(1)' || type === 'boolean' || type === 'bit(1)') {
+            return 'DataTypes.BOOLEAN';
+        }
+        if (type.match(/^(smallint|mediumint|tinyint|int)/)) {
+            const length = type.match(/\(\d+\)/) || '';
+            return `DataTypes.INTEGER${length}`;
+        }
+        if (type.startsWith('bigint')) {
+            return 'DataTypes.BIGINT';
+        }
+        if (type.startsWith('enum')) {
+            return type.replace('enum', 'DataTypes.ENUM').replace(/,/g, ', ');
+        }
+        if (type.match(/^string|varchar|varying|nvarchar/)) {
+            const length = type.match(/\(\d+\)/) || '';
+            return length ? `DataTypes.STRING${length}` : 'DataTypes.STRING';
+        }
+        if (type.startsWith('char')) {
+            const length = type.match(/\(\d+\)/) || '';
+            return `DataTypes.CHAR${length}`;
+        }
+        if (type.match(/text|ntext$/)) {
+            return 'DataTypes.TEXT';
+        }
+        if (type.startsWith('year')) {
+            return 'DataTypes.INTEGER(4)';
+        }
+        if (type.startsWith('datetime')) {
+            return 'DataTypes.DATE';
+        }
+        if (type.startsWith('date')) {
+            return 'DataTypes.DATEONLY';
+        }
+        if (type.startsWith('time')) {
+            return 'DataTypes.TIME';
+        }
+        if (type.match(/^(float8|double precision)/)) {
+            return 'DataTypes.DOUBLE';
+        }
+        if (type.match(/^(float|float4)/)) {
+            return 'DataTypes.FLOAT';
+        }
+        if (type.startsWith('decimal')) {
+            const [, length, bits] = /\((\d+),(\d+)\)/g.exec(type) || [];
+            return length ? `DataTypes.DECIMAL(${length}, ${bits})` : 'DataTypes.DECIMAL';
+        }
+        if (type.match(/^uuid|uniqueidentifier/)) {
+            return 'DataTypes.UUIDV4';
+        }
+        if (type.startsWith('jsonb')) {
+            return 'DataTypes.JSONB';
+        }
+        if (type.startsWith('json')) {
+            return 'DataTypes.JSON';
+        }
+        if (type.startsWith('geometry')) {
+            return 'DataTypes.GEOMETRY';
+        }
+        return type;
+    }
+    static typeAdditional(_type, sequlizeType, rawColumn) {
+        const type = _type.toLowerCase();
+        let finalType = sequlizeType;
+        if (type.match(/unsigned/)) {
+            finalType += '.UNSIGNED';
+        }
+        if (type.match(/zerofill/)) {
+            finalType += '.ZEROFILL';
+        }
+        if (rawColumn.Collation === 'utf8_bin') {
+            finalType += '.BINARY';
+        }
+        return finalType;
+    }
+    static async getIndexes(tableName, sequelize) {
+        let rawIndexes = await sequelize.query(`SHOW INDEX FROM ${tableName}`, {
+            type: sequelize.QueryTypes.SELECT,
+            raw: true
+        });
+        if (!rawIndexes) {
+            return [];
+        }
+        rawIndexes = groupBy(rawIndexes, 'Key_name');
+        return Object.entries(rawIndexes).filter(([key]) => key !== 'PRIMARY').map(([name, columns]) => {
+            const index = columns[0].Non_unique !== 1 ? { name, unique: true } : { name };
+            index.fields = columns.map(c => c.Column_name);
+            return index;
+        });
+    }
+    async run() {
+        const config = DI.get('config').get();
+        const logger = DI.get('logger');
+        const sequelize = new Sequelize(config.db.database, null, null, Object.assign({}, config.sequelize, config.db, { logging: logger.getInstance().verbose }));
+        const query = sequelize.getQueryInterface();
+        let tables = await query.showAllTables();
+        const views = await sequelize.query(`SHOW FULL TABLES IN ${config.db.database} WHERE TABLE_TYPE LIKE 'VIEW'`, {
+            type: sequelize.QueryTypes.SELECT,
+            raw: true
+        });
+        if (views) {
+            const viewNames = views.map(v => Object.values(v)[0]);
+            tables = tables.filter(t => !viewNames.includes(t));
+        }
+        const { dir, timestamp = true, prefix } = this.getArgv();
+        if (prefix) {
+            tables = tables.filter(t => t.startsWith(prefix));
+        }
+        const path = dir ? `${process.cwd()}/${dir}` : `${process.cwd()}/src/entities`;
+        const schemaPath = `${path}/schemas`;
+        const entityTemplate = fs.readFileSync(`${import.meta.dirname}/../../template/entity.ejs`, 'utf8');
+        const schemaTemplate = fs.readFileSync(`${import.meta.dirname}/../../template/schema.ejs`, 'utf8');
+        fs.mkdirSync(path, { recursive: true });
+        fs.mkdirSync(schemaPath, { recursive: true });
+        logger.info('Start generate DB schemas to dir %s', path);
+        const tableHandler = async (table) => {
+            //describeTable 的 ColumnsDescription 与可回写形态不直接可比，运行时字段同源
+            const columns = (await query.describeTable(table));
+            const rawColumns = await sequelize.query(`SHOW FULL COLUMNS FROM ${table}`, {
+                type: sequelize.QueryTypes.SELECT,
+                raw: true
+            });
+            Object.values(rawColumns).forEach((rawColumn) => {
+                const columnName = rawColumn.Field;
+                columns[columnName].type = MakeEntity.typeAdditional(columns[columnName].type, MakeEntity.typeMapping(columns[columnName].type), rawColumn);
+                columns[columnName].unique = rawColumn.Key === 'UNI';
+                columns[columnName].comment = rawColumn.Comment;
+                columns[columnName].autoIncrement = rawColumn.Extra.startsWith('auto_increment') === true;
+            });
+            const indexes = await MakeEntity.getIndexes(table, sequelize);
+            const entityFile = `${path}/${table}.js`;
+            const schemaFile = `${schemaPath}/${table}.js`;
+            try {
+                fs.accessSync(entityFile);
+                logger.info('Entity file %s generate skipped, already exists by %s', table, entityFile);
+            }
+            catch {
+                fs.writeFileSync(entityFile, template(entityTemplate)({ table }));
+                logger.info('Entity file %s generated as %s', table, entityFile);
+            }
+            try {
+                fs.accessSync(schemaFile);
+                logger.info('Schema file %s generate override, already exists by %s', table, schemaFile);
+            }
+            catch {
+                logger.info('Schema file %s generated as %s', table, schemaFile);
+            }
+            //argv 值为 unknown；parseInt 对非字符串（如默认 true）按原语义得到 NaN
+            fs.writeFileSync(schemaFile, template(schemaTemplate)({
+                columns,
+                table,
+                indexes,
+                timestamp: parseInt(timestamp, 10) > 0
+            }));
+        };
+        //Skip sequelize migrate table
+        await Promise.all(Object.values(tables).filter(t => !['sequelizemeta', 'tramp_migrations'].includes(t)).map(tableHandler));
+        logger.info('All DB schemas generated');
+    }
+}
+export class MakeGraphql extends Command {
+    static getName() {
+        return 'make:graphql';
+    }
+    static getDescription() {
+        return 'Generate graphql schema';
+    }
+    static getSpec() {
+        return {
+            dir: {
+                required: false,
+                description: 'Where entity files to be generated'
+            },
+            prefix: {
+                required: false,
+                description: 'Table prefix'
+            },
+            mapping: {
+                required: false,
+                description: 'Mapping file path'
+            }
+        };
+    }
+    // 原调用传入 mappedTableName 但未使用（JS 实参多于形参），可选参数保持调用形态且不改变函数 length
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    static typeMapping(_type, _mappedTableName) {
+        const type = _type.toLowerCase();
+        if (type === 'tinyint(1)' || type === 'boolean' || type === 'bit(1)') {
+            return 'Boolean';
+        }
+        if (type.match(/^(smallint|mediumint|tinyint|int)/)) {
+            return 'Int';
+        }
+        if (type.startsWith('bigint')) {
+            return 'Int';
+        }
+        if (type.startsWith('enum')) {
+            return 'Enum';
+        }
+        if (type.match(/^string|varchar|varying|nvarchar/)) {
+            return 'String';
+        }
+        if (type.startsWith('char')) {
+            return 'String';
+        }
+        if (type.match(/text|ntext$/)) {
+            return 'String';
+        }
+        if (type.startsWith('year')) {
+            return 'Int';
+        }
+        if (type.startsWith('datetime')) {
+            return 'String';
+        }
+        if (type.startsWith('date')) {
+            return 'String';
+        }
+        if (type.startsWith('time')) {
+            return 'String';
+        }
+        if (type.match(/^(float8|double precision)/)) {
+            return 'Float';
+        }
+        if (type.match(/^(float|float4)/)) {
+            return 'Float';
+        }
+        if (type.startsWith('decimal')) {
+            return 'Float';
+        }
+        if (type.match(/^uuid|uniqueidentifier/)) {
+            return 'String';
+        }
+        if (type.startsWith('jsonb')) {
+            return 'JSON';
+        }
+        if (type.startsWith('json')) {
+            return 'JSON';
+        }
+        if (type.startsWith('geometry')) {
+            return 'String';
+        }
+        return type;
+    }
+    getEnums(_type, columnName, tableName) {
+        const type = _type.toLowerCase();
+        const values = type.slice(5, -1).split(',').map(v => v.slice(1, -1));
+        return {
+            name: `ENUM_${tableName}_${columnName}`,
+            values
+        };
+    }
+    async run() {
+        const config = DI.get('config').get();
+        const logger = DI.get('logger');
+        const sequelize = new Sequelize(config.db.database, null, null, Object.assign({}, config.sequelize, config.db, { logging: logger.getInstance().verbose }));
+        const query = sequelize.getQueryInterface();
+        let tables = await query.showAllTables();
+        const views = await sequelize.query(`SHOW FULL TABLES IN ${config.db.database} WHERE TABLE_TYPE LIKE 'VIEW'`, {
+            type: sequelize.QueryTypes.SELECT,
+            raw: true
+        });
+        if (views) {
+            const viewNames = views.map(v => Object.values(v)[0]);
+            tables = tables.filter(t => !viewNames.includes(t));
+        }
+        const { dir, prefix, mapping } = this.getArgv();
+        if (prefix) {
+            tables = tables.filter(t => t.startsWith(prefix));
+        }
+        const path = dir ? `${process.cwd()}/${dir}` : `${process.cwd()}/src/graphql`;
+        const schemaPath = `${path}/entities`;
+        const schemaTemplate = fs.readFileSync(`${import.meta.dirname}/../../template/graphql.ejs`, 'utf8');
+        const mappingFile = mapping ? `${process.cwd()}/${mapping}` : `${process.cwd()}/src/graphql/mapping.json`;
+        const mappingContent = JSON.parse(fs.readFileSync(mappingFile, 'utf8'));
+        const getMappedTableName = (tableName) => (mappingContent[tableName] ? mappingContent[tableName] : tableName);
+        fs.mkdirSync(path, { recursive: true });
+        fs.mkdirSync(schemaPath, { recursive: true });
+        logger.info('Start generate GraphQL schemas to dir %s', path);
+        const tableHandler = async (tableName) => {
+            const enums = [];
+            //describeTable 的 ColumnsDescription 与可回写形态不直接可比，运行时字段同源
+            const columns = (await query.describeTable(tableName));
+            const rawColumns = await sequelize.query(`SHOW FULL COLUMNS FROM ${tableName}`, {
+                type: sequelize.QueryTypes.SELECT,
+                raw: true
+            });
+            const mappedTableName = getMappedTableName(tableName);
+            Object.values(rawColumns).forEach((rawColumn) => {
+                const columnName = rawColumn.Field;
+                let type = MakeGraphql.typeMapping(columns[columnName].type, mappedTableName);
+                if (type === 'Enum') {
+                    const enumObj = this.getEnums(columns[columnName].type, columnName, mappedTableName);
+                    type = enumObj.name;
+                    enums.push(enumObj);
+                }
+                columns[columnName].type = type;
+                columns[columnName].unique = rawColumn.Key === 'UNI';
+                columns[columnName].comment = rawColumn.Comment;
+                columns[columnName].autoIncrement = rawColumn.Extra.startsWith('auto_increment') === true;
+            });
+            const indexes = await MakeEntity.getIndexes(tableName, sequelize);
+            const schemaFile = `${schemaPath}/${tableName}.graphqls`;
+            try {
+                fs.accessSync(schemaFile);
+                logger.info('Graphql schema file %s generate override, already exists by %s', tableName, schemaFile);
+            }
+            catch {
+                logger.info('Graphql schema file %s generated as %s', tableName, schemaFile);
+            }
+            fs.writeFileSync(schemaFile, template(schemaTemplate)({
+                tableName,
+                mappedTableName,
+                columns,
+                indexes,
+                enums
+            }));
+        };
+        //Skip sequelize migrate table
+        await Promise.all(Object.values(tables).filter(t => !['sequelizemeta', 'tramp_migrations'].includes(t)).map(tableHandler));
+        logger.info('All DB schemas generated');
+    }
+}
+//# sourceMappingURL=make_entity.js.map