baja-lite 1.0.4 → 1.0.5

package/src/boot.ts

@@ -0,0 +1,129 @@
+import { _GlobalSqlOption, GlobalSqlOption, _EventBus, _defOption, logger, _sqlCache, SqlCache, _dao, DBType, _primaryDB, SqliteRemote, _fs, _path, Mysql, Sqlite, _Hump, ColumnMode } from './sql';
+
+export const Boot = async function (options: GlobalSqlOption) {
+    globalThis[_GlobalSqlOption] = Object.assign({}, _defOption, options);
+    globalThis[_Hump] = globalThis[_GlobalSqlOption].columnMode === ColumnMode.HUMP;
+    if (options.sqlDir) {
+        globalThis[_path] = await import('path');
+        globalThis[_fs] = await import('fs');
+    }
+    logger.level = options.log ?? 'info';
+    globalThis[_sqlCache] = new SqlCache();
+    if (options.sqlMap || options.sqlDir) {
+        await globalThis[_sqlCache].init(options);
+    }
+    globalThis[_dao] = {
+        [DBType.Mongo]: {},
+        [DBType.Mysql]: {},
+        [DBType.Sqlite]: {},
+        [DBType.SqliteRemote]: {},
+        [DBType.Redis]: {}
+    };
+    if (options.Mysql) {
+        const { createPool } = await import('mysql2/promise');
+        if (options.Mysql['host']) {
+            globalThis[_dao][DBType.Mysql][_primaryDB] = new Mysql(createPool({
+                ...options.Mysql,
+                multipleStatements: true,
+                decimalNumbers: true,
+                supportBigNumbers: true
+            }));
+        } else {
+            let flag = false;
+            for (const [key, option] of Object.entries(options.Mysql)) {
+                const db = new Mysql(createPool({
+                    ...option,
+                    multipleStatements: true,
+                    decimalNumbers: true,
+                    supportBigNumbers: true
+                }));
+                if (flag === false) {
+                    globalThis[_dao][DBType.Mysql][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Mysql][key] = db;
+            }
+        }
+    }
+    if (options.Sqlite) {
+        const BetterSqlite3 = await import('better-sqlite3');
+        if (typeof options.Sqlite === 'string') {
+            globalThis[_dao][DBType.Sqlite][_primaryDB] = new Sqlite(new BetterSqlite3.default(options.Sqlite, { fileMustExist: false }));
+        } else {
+            let flag = false;
+            for (const [key, fileName] of Object.entries(options.Sqlite)) {
+                const db = new Sqlite(new BetterSqlite3.default(fileName, { fileMustExist: false }));
+                if (flag === false) {
+                    globalThis[_dao][DBType.Sqlite][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Sqlite][key] = db;
+            }
+        }
+    }
+    if (options.SqliteRemote) {
+        if (typeof options.SqliteRemote.db === 'string') {
+            await options.SqliteRemote.service.initDB(options.SqliteRemote.db);
+            globalThis[_dao][DBType.SqliteRemote][_primaryDB] = new SqliteRemote(options.SqliteRemote.service, options.SqliteRemote.db);
+        } else {
+            let flag = false;
+            for (const [key, fileName] of Object.entries(options.SqliteRemote.db)) {
+                await options.SqliteRemote.service.initDB(fileName);
+                const db = new SqliteRemote(options.SqliteRemote.service, fileName);
+                if (flag === false) {
+                    globalThis[_dao][DBType.SqliteRemote][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.SqliteRemote][key] = db;
+            }
+        }
+    }
+    if (options.Redis) {
+        const { Redis } = await import('ioredis');
+        if (options.Redis['host']) {
+            globalThis[_dao][DBType.Redis][_primaryDB] = new Redis(options.Redis);
+        } else {
+            let flag = false;
+            for (const [key, option] of Object.entries(options.Redis)) {
+                const db = new Redis(option);
+                if (flag === false) {
+                    globalThis[_dao][DBType.Redis][_primaryDB] = db;
+                    flag = true;
+                }
+                globalThis[_dao][DBType.Redis][key] = db;
+            }
+        }
+        const clients = Object.values(globalThis[_dao][DBType.Redis]) as any;
+        const Redlock = await import('redlock');
+        globalThis[_dao][DBType.RedisLock] = new Redlock.default(
+            clients,
+            {
+                // The expected clock drift; for more details see:
+                // http://redis.io/topics/distlock
+                driftFactor: 0.01, // multiplied by lock ttl to determine drift time
+
+                // The max number of times Redlock will attempt to lock a resource
+                // before erroring.
+                retryCount: 10,
+
+                // the time in ms between attempts
+                retryDelay: 200, // time in ms
+
+                // the max time in ms randomly added to retries
+                // to improve performance under high contention
+                // see https://www.awsarchitectureblog.com/2015/03/backoff.html
+                retryJitter: 200, // time in ms
+
+                // The minimum remaining time on a lock before an extension is automatically
+                // attempted with the `using` API.
+                automaticExtensionThreshold: 500, // time in ms
+            }
+        );
+        const { EventEmitter } = await import('events');
+        const event = new EventEmitter({ captureRejections: true });
+        event.on('error', error => {
+            logger.error('event-bus', error);
+        });
+        globalThis[_EventBus] = event;
+    }
+}

package/src/code.ts

@@ -1,2 +1,327 @@
 #!/usr/bin/env node
-console.log(__dirname);
+import path from 'path';
+import fs from 'fs';
+import { start } from 'repl';
+import { createPool } from 'mysql2/promise';
+import mustache from 'mustache';
+
+const lxMap = {
+    tinyint: "number",
+    smallint: "number",
+    mediumint: "number",
+    int: "number",
+    integer: "number",
+    bigint: "BigInt",
+    bit: "boolean",
+    double: "number",
+    real: "number",
+    float: "number",
+    decimal: "number",
+    numeric: "number",
+    char: "string",
+    varchar: "string",
+    date: "Date",
+    time: "string",
+    year: "string",
+    timestamp: "BigInt",
+    datetime: "Date",
+    tinyblob: "string",
+    blob: "string",
+    mediumblob: "string",
+    longblob: "string",
+    tinytext: "string",
+    text: "string",
+    mediumtext: "string",
+    longtext: "string",
+    enum: "string",
+    set: "string",
+    binary: "string",
+    varbinary: "string",
+    point: "Object",
+    linestring: "Object",
+    polygon: "Object",
+    geometry: "string",
+    multipoint: "Object",
+    multilinestring: "Object",
+    multipolygon: "Object",
+    geometrycollection: "Object"
+};
+let force = false;
+const basepath = path.join(__dirname, '..', '..', '..');
+const config = path.join(basepath, 'baja.code.json');
+const templatePath = path.join(basepath, 'code-template');
+console.log(`
+    **********************-----------
+    配置文件：
+    请在项目根目录添加文件:baja.code.json!配置如下:
+    {
+        "host": "",
+        "port": "",
+        "user": "",
+        "password": "",
+        "database": "",
+
+        "command": {
+			"entity": "src/{vueName}/{vueName}.entity.ts",
+			"controller": "src/{vueName}/{vueName}.controller.ts",
+			"service": "src/{vueName}/{vueName}.service.ts",
+			"sql": "src/sql/{vueName}.mu",
+			"module": "src/{vueName}/{vueName}.module.ts"
+		},
+        "commands": {
+            "s": ["entity", "controller", "service", "sql", "module"]
+        }
+        "commands": {
+            "s": ["entity", "controller", "service", "sql", "module"]
+        },
+        "output": "{ClassName}Module",
+    }
+    command是生成命令，这里声明命令同时定义文件生成路径:可用下面的变量替换.同时必须有同名模板.
+    路径是相对于项目根目录的
+    commands是组合命令,上面表示输入s，同时生成："entity", "controller", "service", "sql", "module"
+    output 是生成后打印出的内容
+    模板转义：<%& 变量 %>
+    **********************-----------
+    **********************-----------
+    **********************-----------
+    模板文件
+    请在项目根目录的code-template添加模板文件， 按照mustache(标签定义成了[ '<%', '%>' ])进行格式化,变量：
+        title,
+
+        tableName,
+        className,
+        ClassName,
+        vueName,
+        splitName,
+
+        columns: [
+            comment:
+            name: sku_id
+            Name: skuId
+            Field
+            Type
+        ], Field(类型string)，表示字段的注解, Type 表示JS类型
+        columnNames_join: 'sku_id, sku_name'
+        ColumnNames_join: 'sku_id skuId, sku_name skuName'
+
+        columns_no_id: [], 同columns，没有ID而已
+        columnNames_no_id: [],
+
+        ids: [], 参见 FieldOption,多一个参数Field，表示字段的注解, Type 表示JS类型
+        idNames: [], 主键字段数组
+        idNames_join: []
+
+        modelName: 模块名称，可能为空字符串
+        modelPath: 模块名称实际就影响访问路径，所以这里会直接拼好controller的模块访问路径，如果模块为空，则该属性就是空字符串,否则是 /模块名称/
+    -----
+    命令 table1,table2,table3:模块名称
+    table=. 表示扫描全库表
+    :模块名称 可以省略
+    -----
+    force: 切换是否覆盖
+`);
+
+
+try {
+    const outputs = new Set<string>();
+    const _configData = fs.readFileSync(config, { encoding: 'utf-8' }).toString();
+    const configData = JSON.parse(_configData) ;
+    const templates = Object.fromEntries(fs.readdirSync(templatePath).map(r => [path.basename(r, '.mu'), fs.readFileSync(path.join(templatePath, r), { encoding: 'utf-8' }).toString()]));
+    const pool = createPool({
+        host: configData.host,
+        port: configData.port,
+        user: configData.user,
+        password: configData.password,
+        database: configData.database
+    });
+    async function getTables(tableName: string) {
+        const conn = await pool.getConnection();
+        const params = [configData.database];
+        let sql = `
+        SELECT TABLE_NAME tableName, IFNULL(TABLE_COMMENT, TABLE_NAME) title FROM information_schema.TABLES
+        WHERE TABLE_SCHEMA= ? AND TABLE_TYPE = 'BASE TABLE'`;
+        if (tableName !== '.') {
+            sql += ` AND TABLE_NAME IN (?)`;
+            params.push(tableName.split(/,|\s/).map(r => r.trim()));
+        }
+        const [result] = await conn.query<any[]>(sql, params);
+        conn.release();
+        return result;
+    }
+    async function getColumns(tableName: string) {
+        const conn = await pool.getConnection();
+        const [result] = await conn.query<any[]>(`
+            SELECT
+                DATA_TYPE type,
+                COLUMN_NAME \`name\`,
+                IFNULL(IFNULL(CHARACTER_MAXIMUM_LENGTH,NUMERIC_PRECISION),DATETIME_PRECISION) \`length\`,
+                NUMERIC_SCALE scale,
+                COLUMN_DEFAULT def,
+                IF(COLUMN_KEY = 'PRI', 1, 0) id,
+                IF(IS_NULLABLE = 'NO', 1, 0) notNull,
+                COLUMN_COMMENT \`comment\`
+            FROM information_schema.COLUMNS WHERE TABLE_SCHEMA=? AND TABLE_NAME = ?;
+        `, [configData.database, tableName]);
+        const columns = result.map(r => {
+            if (r.id === 1) { r.id = true; }
+            else delete r.id;
+            if (r.notNull === 1) { r.notNull = true; }
+            else delete r.notNull;
+            r.comment = `* ${r.comment??''}(\`${tableName}.${r.name}\`)`;
+            const fields = new Array<string>(`type:SqlType.${r.type}`);
+            if (r.length !== null) { fields.push(`length:${r.length}`); }
+            if (r.scale !== null) { fields.push(`scale:${r.scale}`); }
+            if (r.def !== null) {
+                r.def ??= '';
+                if (isNaN(r.def) || r.def === '') {
+                    fields.push(`def:'${r.def}'`);
+                } else {
+                    fields.push(`def:${r.def}`);
+                }
+            }
+            if (r.id === true) { fields.push(`id:true`); }
+            if (r.notNull === true) { fields.push(`notNull:true`); }
+            r.Type = lxMap[r.type];
+            r.Field = `@Field({${fields.join(',')}})`;
+            r.Name = r.name.replace(/_(\w)/g, (a: string, b: string) => b.toUpperCase());
+            return r;
+        });
+        conn.release();
+        return columns;
+    }
+    async function excute(command: string, input: string, modelName: string) {
+        const tables = await getTables(input);
+        if (input !== '.') {
+            const checkTable = input.split(/,|\s/).map(r => r.trim())
+            if (checkTable.length !== tables.length) {
+                console.error(`[错误] 输入的表与数据库查询返回表不符，数据库返回${tables.length}个:${tables.map(i => i.tableName).join(',')}`);
+                return;
+            }
+        }
+        modelName ??= '';
+        const modelPath = modelName ? `/${modelName}/` : '';
+        for (const { tableName, title } of tables) {
+            const columns = await getColumns(tableName);
+            const className = tableName.replace(/_(\w)/g, (a: string, b: string) => b.toUpperCase());
+            const ClassName = className.replace(/\w/, (v: string) => v.toUpperCase());
+            const vueName = tableName.replace(/_/g, '-');
+            const splitName = tableName.replace(/_/g, '/');
+            const data = {
+                title,
+
+                tableName,
+                className,
+                ClassName,
+                vueName,
+                splitName,
+
+                columns,
+                columnNames: columns?.map(i => i.name),
+                columnNames_join: columns?.map(i => i.name).join(','),
+                ColumnNames_join: columns?.map(i => `${i.name} ${i.Name}`).join(','),
+
+                columns_no_id: columns?.filter(i => !i.id),
+                columnNames_no_id: columns?.filter(i => !i.id).map(i => i.name),
+                columnNames_no_id_join: columns?.filter(i => !i.id).map(i => i.name).join(','),
+
+                ids: columns?.filter(i => i.id),
+                idNames: columns?.filter(i => i.id).map(i => i.name),
+                idNames_join: columns?.filter(i => i.id).map(i => i.name).join(','),
+
+                modelName,
+                modelPath
+            };
+            const template = templates[command];
+            if (!template) {
+                console.error(`[错误] ${command} 未定义模板!`);
+                return;
+            }
+            const txt = mustache.render(template, data, {}, ['<%', '%>']);
+            const fileName = configData.command[command].replace(/{([a-zA-Z]+)}/g, (a: string, b: string) => data[b]);
+            const filePath = path.join(basepath, fileName);
+            const dirname = path.dirname(filePath);
+            try {
+                fs.statSync(dirname);
+            } catch (error) {
+                fs.mkdirSync(dirname);
+                console.info(`[生成] ${dirname}`);
+            }
+            try {
+                fs.statSync(filePath);
+                if (force === false) {
+                    console.warn(`[跳过] ${filePath}`);
+                    return;
+                } else {
+                    console.warn(`[覆盖] ${filePath}`);
+                }
+            } catch (error) {
+                console.info(`[生成] ${filePath}`);
+            }
+            if (configData.output) {
+                outputs.add(configData.output.replace(/{([a-zA-Z]+)}/g, (a: string, b: string) => data[b]));
+            }
+            fs.writeFileSync(path.join(basepath, fileName), txt);
+        }
+    }
+    const replServer = start();
+    function defineCommand(command: string, comands?: string[]) {
+        if (comands) {
+            console.log(`[组合]${command}>${comands.join(',')}注册成功`);
+        } else {
+            console.log(`[命令]${command}注册成功`);
+        }
+        if (comands) {
+            replServer.defineCommand(command, async input => {
+                outputs.clear();
+                const inputs = input.match(/([^:]+):{0,1}([a-zA-Z0-9]*)/);
+                if (inputs?.length !== 3) {
+                    return console.error(`[错误]命令格式应为: table1,table2[:模块名]`);
+                }
+                const [_, tables, modelName] = inputs;
+                for (const c of comands) {
+                    await excute(c, tables!, modelName ?? '');
+                }
+                console.info('执行完毕！下面打印生成的输出');
+                console.info(Array.from(outputs).join(','));
+            });
+        } else {
+            replServer.defineCommand(command, async input => {
+                outputs.clear();
+                const inputs = input.match(/([^:]+):{0,1}([a-zA-Z0-9]*)/);
+                if (inputs?.length !== 3) {
+                    return console.error(`[错误]命令格式应为: table1,table2[:模块名]`);
+                }
+                const [_, tables, modelName] = inputs;
+                await excute(command, tables!, modelName ?? '');
+                console.info('执行完毕！下面打印生成的输出');
+                console.info(Array.from(outputs).join(','));
+            });
+        }
+    }
+    replServer.defineCommand('force', () => {
+        force = !force;
+        console.log(force ? '覆盖生成' : '不覆盖生成!');
+    });
+    if (configData.command) {
+        for (const command of Object.keys(configData.command)) {
+            if (!templates[command]) {
+                console.error(`命令:${command}没有定义模板，该命令不会生效`);
+            } else {
+                defineCommand(command);
+            }
+        }
+    }
+    if (configData.commands) {
+        for (const [command, commands] of Object.entries(configData.commands)) {
+            const keys = commands as string[];
+            const error = keys.filter(k => !templates[k]).join(',');
+            if (error) {
+                console.error(`组合命令:${command}定义了${commands},但是${error}没有定义模板，该命令不会生效`);
+            } else {
+                defineCommand(command, keys);
+            }
+        }
+    }
+} catch (error) {
+    console.error(error);
+}