create-yss-spec 2.1.6 → 2.1.8

package/template/.pi/skills/yss-db2mybatis/config/metadata.json

@@ -1,334 +0,0 @@
-{
-  "db_type": "mysql",
-  "database": "yss_metadata",
-  "schema": "yss_metadata",
-  "tables": [
-    {
-      "table_name": "dbs",
-      "table_comment": "dbs",
-      "primary_keys": [
-        "db_id"
-      ],
-      "columns": [
-        {
-          "name": "db_id",
-          "sql_type": "bigint",
-          "nullable": false,
-          "primary": true,
-          "auto_increment": false,
-          "comment": "id"
-        },
-        {
-          "name": "desc",
-          "sql_type": "varchar(4000)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "db_location",
-          "sql_type": "varchar(4000)",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "name",
-          "sql_type": "varchar(128)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "owner_name",
-          "sql_type": "varchar(128)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "owner_type",
-          "sql_type": "varchar(10)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "db_type",
-          "sql_type": "varchar(256)",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        }
-      ],
-      "indexes": [
-        {
-          "name": "PRIMARY",
-          "columns": [
-            "db_id"
-          ],
-          "unique": 1,
-          "primary": 1
-        }
-      ],
-      "foreign_keys": []
-    },
-    {
-      "table_name": "sds",
-      "table_comment": "sds",
-      "primary_keys": [],
-      "columns": [
-        {
-          "name": "sd_id",
-          "sql_type": "bigint",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "cd_id",
-          "sql_type": "bigint",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "input_format",
-          "sql_type": "varchar(4000)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "is_compressed",
-          "sql_type": "bit(1)",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "is_storedassubdirectories",
-          "sql_type": "bit(1)",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "location",
-          "sql_type": "varchar(4000)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "num_buckets",
-          "sql_type": "int",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "output_format",
-          "sql_type": "varchar(4000)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "serde_id",
-          "sql_type": "bigint",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        }
-      ],
-      "indexes": [],
-      "foreign_keys": []
-    },
-    {
-      "table_name": "tbl_lineage",
-      "table_comment": "tbl_lineage",
-      "primary_keys": [],
-      "columns": [
-        {
-          "name": "db_id",
-          "sql_type": "int",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "数据库id"
-        },
-        {
-          "name": "tbl_id",
-          "sql_type": "varchar(255)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "表id"
-        },
-        {
-          "name": "tbl_name",
-          "sql_type": "varchar(255)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "表名称"
-        },
-        {
-          "name": "up_tbl_id",
-          "sql_type": "varchar(255)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "上游id"
-        },
-        {
-          "name": "down_tbl_id",
-          "sql_type": "int",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "下游表id"
-        },
-        {
-          "name": "add_type",
-          "sql_type": "varchar(255)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "添加方式"
-        },
-        {
-          "name": "create_time",
-          "sql_type": "datetime",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "创建时间"
-        },
-        {
-          "name": "tbl_type",
-          "sql_type": "varchar(255)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": "表类型（mysql,hive）"
-        }
-      ],
-      "indexes": [],
-      "foreign_keys": []
-    },
-    {
-      "table_name": "tbls",
-      "table_comment": "tbls",
-      "primary_keys": [],
-      "columns": [
-        {
-          "name": "tbl_id",
-          "sql_type": "bigint",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "create_time",
-          "sql_type": "int",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "db_id",
-          "sql_type": "bigint",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "last_access_time",
-          "sql_type": "int",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "owner",
-          "sql_type": "varchar(767)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "owner_type",
-          "sql_type": "varchar(10)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "retention",
-          "sql_type": "int",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "sd_id",
-          "sql_type": "bigint",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "tbl_name",
-          "sql_type": "varchar(256)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "tbl_type",
-          "sql_type": "varchar(128)",
-          "nullable": true,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        },
-        {
-          "name": "is_rewrite_enabled",
-          "sql_type": "bit(1)",
-          "nullable": false,
-          "primary": false,
-          "auto_increment": false,
-          "comment": ""
-        }
-      ],
-      "indexes": [],
-      "foreign_keys": []
-    }
-  ]
-}

package/template/.pi/skills/yss-db2mybatis/config/temp_datasource.json

@@ -1,12 +0,0 @@
-{
-  "metadata_mysql": {
-    "db_type": "mysql",
-    "host": "<host>",
-    "port": 3306,
-    "user": "<user>",
-    "password": "<password>",
-    "database": "<database>",
-    "schema": null,
-    "service_name": null
-  }
-}

package/template/.pi/skills/yss-db2mybatis/references/datasource-config.example.json

@@ -1,46 +0,0 @@
-{
-  "datasources": {
-    "quality-mysql": {
-      "db_type": "mysql",
-      "host": "127.0.0.1",
-      "port": 3306,
-      "user": "root",
-      "password": "root",
-      "database": "yss_quality"
-    },
-    "quality-postgres": {
-      "db_type": "postgres",
-      "host": "127.0.0.1",
-      "port": 5432,
-      "user": "postgres",
-      "password": "postgres",
-      "database": "yss_quality",
-      "schema": "public"
-    },
-    "quality-oracle": {
-      "db_type": "oracle",
-      "host": "127.0.0.1",
-      "port": 1521,
-      "user": "quality",
-      "password": "quality",
-      "database": "ORCLPDB1"
-    },
-    "quality-opengauss": {
-      "db_type": "opengauss",
-      "host": "127.0.0.1",
-      "port": 5432,
-      "user": "opengauss",
-      "password": "password",
-      "database": "yss_quality",
-      "schema": "public"
-    },
-    "quality-oceanbase": {
-      "db_type": "oceanbase",
-      "host": "127.0.0.1",
-      "port": 2881,
-      "user": "root@mysql",
-      "password": "root",
-      "database": "yss_quality"
-    }
-  }
-}

package/template/.pi/skills/yss-db2mybatis/references/project-convention.example.json

@@ -1,14 +0,0 @@
-{
-  "audit_columns": [
-    "created_by",
-    "created_date",
-    "last_modified_by",
-    "last_modified_date"
-  ],
-  "logic_delete_fields": [
-    "deleted",
-    "is_deleted"
-  ],
-  "pk_strategy": "error",
-  "page_method_name": "page"
-}

package/template/.pi/skills/yss-db2mybatis/references/type-mapping.json

@@ -1,31 +0,0 @@
-{
-  "bigint": "Long",
-  "int": "Integer",
-  "integer": "Integer",
-  "smallint": "Integer",
-  "tinyint": "Integer",
-  "number": "Long",
-  "numeric": "BigDecimal",
-  "decimal": "BigDecimal",
-  "float": "Float",
-  "double": "Double",
-  "real": "Float",
-  "varchar": "String",
-  "varchar2": "String",
-  "nvarchar2": "String",
-  "char": "String",
-  "nchar": "String",
-  "text": "String",
-  "clob": "String",
-  "nclob": "String",
-  "date": "LocalDateTime",
-  "datetime": "LocalDateTime",
-  "timestamp": "LocalDateTime",
-  "timestamp with time zone": "LocalDateTime",
-  "boolean": "Boolean",
-  "bool": "Boolean",
-  "bit": "Boolean",
-  "json": "String",
-  "jsonb": "String",
-  "uuid": "String"
-}

package/template/.pi/skills/yss-db2mybatis/scripts/db2mybatis.mjs

@@ -1,145 +0,0 @@
-#!/usr/bin/env node
-/**
- * Offline-first database metadata and YSS MyBatis scaffold generator.
- * Node >=22 is required.  Live database drivers are deliberately resolved only
- * from YSS_DB2MYBATIS_DRIVER_ROOT (or the caller's cwd); this tool never installs
- * packages or modifies the driver directory.
- */
-import fs from 'node:fs';
-import path from 'node:path';
-import os from 'node:os';
-import readline from 'node:readline/promises';
-import { stdin as input, stdout as output } from 'node:process';
-import { createRequire } from 'node:module';
-
-const AUDIT_COLUMNS = new Set(['created_by', 'created_date', 'last_modified_by', 'last_modified_date']);
-const LOGIC_DELETE_FIELDS = ['deleted', 'is_deleted'];
-const JAVA_IMPORTS = { BigDecimal: 'import java.math.BigDecimal;', LocalDateTime: 'import java.time.LocalDateTime;', LocalDate: 'import java.time.LocalDate;', LocalTime: 'import java.time.LocalTime;' };
-
-class SkillError extends Error {}
-const readText = (file) => fs.readFileSync(file, 'utf8');
-const writeText = (file, text) => { fs.mkdirSync(path.dirname(file), { recursive: true }); fs.writeFileSync(file, text, 'utf8'); };
-const loadJson = (file) => JSON.parse(readText(file));
-const pascal = (value) => String(value || '').split(/[_\-\s]+/).filter(Boolean).map((x) => x[0].toUpperCase() + x.slice(1).toLowerCase()).join('');
-const camel = (value) => { const x = pascal(value); return x ? x[0].toLowerCase() + x.slice(1) : x; };
-const upperFirst = (value) => value ? value[0].toUpperCase() + value.slice(1) : value;
-const lowerFirst = (value) => value ? value[0].toLowerCase() + value.slice(1) : value;
-const normalizeSqlType = (value) => String(value || '').trim().toLowerCase().replace(/\(.*\)/, '').replace(/\s+/g, ' ');
-const stripSqlType = (value) => normalizeSqlType(value).split(' ')[0] || '';
-const replaceTemplate = (text, values) => text.replace(/\$\{([^}]+)\}/g, (all, key) => Object.hasOwn(values, key) ? String(values[key]) : all);
-const normalizeTables = (value) => value ? value.split(',').map((x) => x.trim()).filter(Boolean) : null;
-const unquoteIdentifier = (value) => { let x = String(value).trim(); if ((x.startsWith('`') && x.endsWith('`')) || (x.startsWith('"') && x.endsWith('"'))) x = x.slice(1, -1); return x.includes('.') ? x.split('.').at(-1) : x; };
-const defaultPath = (root, relative) => path.resolve(root, relative);
-
-function filterTables(tables, include, exclude) {
-  const inc = include ? new RegExp(include) : null; const exc = exclude ? new RegExp(exclude) : null;
-  return tables.filter((table) => (!inc || inc.test(table.table_name)) && (!exc || !exc.test(table.table_name)));
-}
-function splitTopLevel(text, delimiter = ',') {
-  const values = []; let buffer = ''; let depth = 0; let quote = '';
-  for (let i = 0; i < text.length; i += 1) { const ch = text[i];
-    if (quote) { buffer += ch; if (ch === quote && text[i - 1] !== '\\') quote = ''; continue; }
-    if (["'", '"', '`'].includes(ch)) { quote = ch; buffer += ch; }
-    else if (ch === '(') { depth += 1; buffer += ch; }
-    else if (ch === ')') { depth = Math.max(0, depth - 1); buffer += ch; }
-    else if (ch === delimiter && depth === 0) { if (buffer.trim()) values.push(buffer.trim()); buffer = ''; }
-    else buffer += ch;
-  }
-  if (buffer.trim()) values.push(buffer.trim()); return values;
-}
-function parseSqlType(definition) {
-  let end = definition.length; const lower = definition.toLowerCase();
-  for (const pattern of [/\bnot\s+null\b/i, /\bnull\b/i, /\bdefault\b/i, /\bcomment\b/i, /\bprimary\s+key\b/i, /\bauto_increment\b/i, /\bgenerated\b/i, /\bunique\b/i, /\breferences\b/i, /\bconstraint\b/i, /\bcheck\b/i]) { const match = lower.match(pattern); if (match?.index !== undefined) end = Math.min(end, match.index); }
-  return definition.slice(0, end).trim();
-}
-function parseDdlTable(statement) {
-  const found = statement.match(/create\s+table\s+(?:if\s+not\s+exists\s+)?([`".\w]+)/i);
-  if (!found) throw new SkillError('DDL 解析失败：未识别 CREATE TABLE 语句');
-  const tableName = unquoteIdentifier(found[1]); const left = statement.indexOf('(', found.index + found[0].length);
-  if (left < 0) throw new SkillError(`DDL 解析失败：表 ${tableName} 缺少字段定义`);
-  let depth = 1; let quote = ''; let right = -1;
-  for (let i = left + 1; i < statement.length; i += 1) { const ch = statement[i]; if (quote) { if (ch === quote && statement[i - 1] !== '\\') quote = ''; } else if (["'", '"', '`'].includes(ch)) quote = ch; else if (ch === '(') depth += 1; else if (ch === ')' && --depth === 0) { right = i; break; } }
-  if (right < 0) throw new SkillError(`DDL 解析失败：表 ${tableName} 字段括号未闭合`);
-  const comment = statement.slice(right + 1).match(/comment\s*=\s*'([^']*)'/i)?.[1] || '';
-  const columns = []; const primaryKeys = [];
-  for (const raw of splitTopLevel(statement.slice(left + 1, right))) { const item = raw.trim().replace(/,+$/, ''); const lower = item.toLowerCase(); if (!item) continue;
-    if (lower.startsWith('primary key') || (lower.includes('constraint') && lower.includes('primary key'))) { const pkMatch = item.match(/\((.*?)\)/is); if (pkMatch) primaryKeys.push(...splitTopLevel(pkMatch[1]).map(unquoteIdentifier)); continue; }
-    if (/^(key|index|unique key|unique index|constraint|foreign key)\b/i.test(lower)) continue;
-    const colMatch = item.match(/^\s*([`".\w]+)\s+(.+)$/is); if (!colMatch) continue;
-    const name = unquoteIdentifier(colMatch[1]); const definition = colMatch[2].trim(); const inlinePk = /\bprimary\s+key\b/i.test(definition);
-    columns.push({ name, sql_type: parseSqlType(definition), nullable: !/\bnot\s+null\b/i.test(definition), primary: inlinePk, auto_increment: /\bauto_increment\b|\bidentity\b/i.test(definition), comment: definition.match(/comment\s+'([^']*)'/i)?.[1] || '' });
-    if (inlinePk && !primaryKeys.includes(name)) primaryKeys.push(name);
-  }
-  const pkSet = new Set(primaryKeys); for (const column of columns) if (pkSet.has(column.name)) { column.primary = true; column.nullable = false; }
-  return { table_name: tableName, table_comment: comment || tableName, primary_keys: primaryKeys, columns, indexes: [], foreign_keys: [] };
-}
-function metadataFromDdl(text, dbType = 'mysql', database = 'ddl', schema = null) {
-  const matches = [...text.matchAll(/\bcreate\s+table\b/ig)]; const tables = matches.map((match, index) => parseDdlTable(text.slice(match.index, matches[index + 1]?.index).trim()));
-  return { db_type: dbType, database, schema: schema || database, tables };
-}
-function readDdl(args) { if (args['ddl-file'] && args['ddl-sql']) throw new SkillError('不能同时使用 --ddl-file 和 --ddl-sql'); if (args['ddl-file']) return readText(args['ddl-file']); if (args['ddl-sql']) return args['ddl-sql']; throw new SkillError('请提供 --ddl-file 或 --ddl-sql'); }
-function javaType(type, mapping) { const normalized = normalizeSqlType(type); return mapping[normalized] || mapping[stripSqlType(type)] || 'String'; }
-function inferDomain(table, prefix) { return pascal(prefix && table.startsWith(prefix) ? table.slice(prefix.length) : table); }
-
-function parseArgs(argv) {
-  const [command, ...tokens] = argv; if (!command || command === '--help' || command === '-h') return { command: 'help', args: {} };
-  const args = {}; for (let i = 0; i < tokens.length; i += 1) { const token = tokens[i]; if (!token.startsWith('--')) throw new SkillError(`未知参数: ${token}`); const key = token.slice(2); if (['dry-run', 'overwrite', 'verbose', 'keep-audit-columns'].includes(key)) args[key] = true; else { if (tokens[i + 1] === undefined || tokens[i + 1].startsWith('--')) throw new SkillError(`参数 --${key} 需要值`); args[key] = tokens[++i]; } }
-  return { command, args };
-}
-const CONNECTION_OPTIONS = ['datasource-config', 'datasource-name', 'db-type', 'host', 'port', 'user', 'password', 'database', 'schema', 'tables', 'include-tables-regex', 'exclude-tables-regex'];
-const SCAFFOLD_OPTIONS = ['skill-root', 'base-package', 'domain-segment', 'domain-java-root', 'infra-java-root', 'table-prefix', 'po-template', 'domain-model-template', 'repository-template', 'domain-gateway-template', 'gateway-impl-template', 'convertor-template', 'type-mapping', 'convention-file', 'pk-strategy', 'keep-audit-columns', 'overwrite', 'dry-run', 'verbose', 'ddl-file', 'ddl-sql'];
-const COMMAND_OPTIONS = {
-  init: ['skill-root'],
-  extract: [...CONNECTION_OPTIONS, 'output'],
-  ddl2metadata: ['ddl-file', 'ddl-sql', 'db-type', 'database', 'schema', 'output'],
-  scaffold: [...CONNECTION_OPTIONS, 'metadata-file', ...SCAFFOLD_OPTIONS],
-  validate: ['datasource-config', ...SCAFFOLD_OPTIONS],
-};
-function validateOptionNames(command, args) {
-  if (!COMMAND_OPTIONS[command]) throw new SkillError(`不支持的命令: ${command}`);
-  const allowed = new Set(COMMAND_OPTIONS[command]);
-  for (const name of Object.keys(args)) if (!allowed.has(name)) throw new SkillError(`未知参数: --${name}`);
-}
-function requireArgs(args, names) { for (const name of names) if (args[name] === undefined || args[name] === '') throw new SkillError(`缺少 --${name}`); }
-function help() { console.log(`usage: node scripts/db2mybatis.mjs <init|extract|ddl2metadata|scaffold|validate> [options]\n\ncommands:\n  init          交互式配置向导\n  extract       提取数据库元数据\n  ddl2metadata  根据 DDL 文本生成 metadata.json\n  scaffold      根据元数据生成代码\n  validate      校验配置和模板`); }
-
-function mergeDatasource(args) { if (!args['datasource-config']) return args; const config = loadJson(args['datasource-config']); if (!args['datasource-name']) throw new SkillError('使用 --datasource-config 时必须传 --datasource-name'); const source = (config.datasources || {})[args['datasource-name']] || config[args['datasource-name']]; if (!source) throw new SkillError(`datasource 未找到: ${args['datasource-name']}`); for (const key of ['db-type', 'host', 'port', 'user', 'password', 'database', 'schema']) { const inputKey = key.replace('-', '_'); if ((args[key] === undefined || args[key] === '') && source[inputKey] !== undefined && source[inputKey] !== '') args[key] = source[inputKey]; } return args; }
-function requireConnection(args) { if (!args['db-type']) throw new SkillError('缺少 --db-type'); const missing = ['host', 'port', 'user', 'password', 'database'].filter((key) => !args[key]); if (missing.length) throw new SkillError(`缺少连接参数: ${missing.join(', ')}`); }
-function driver(name, dbType) { const root = process.env.YSS_DB2MYBATIS_DRIVER_ROOT || process.cwd(); try { return createRequire(path.join(path.resolve(root), 'package.json'))(name); } catch (error) { throw new SkillError(`${dbType} 需要 Node 驱动 ${name}；请在 YSS_DB2MYBATIS_DRIVER_ROOT（未设置时为当前工作目录）提供该依赖。本工具不会自动安装依赖。`); } }
-const mysqlQuery = async (connection, sql, values = []) => { const [rows] = await connection.execute(sql, values); return rows; };
-async function mysqlMetadata(args, dbType = 'mysql') {
-  const mysql = driver('mysql2/promise', dbType); let connection;
-  try { connection = await mysql.createConnection({ host: args.host, port: Number(args.port), user: args.user, password: args.password, database: args.database, charset: 'utf8mb4' }); const wanted = normalizeTables(args.tables); const tableRows = await mysqlQuery(connection, `SELECT TABLE_NAME, TABLE_COMMENT FROM information_schema.tables WHERE table_schema=? AND table_type='BASE TABLE'${wanted ? ` AND table_name IN (${wanted.map(() => '?').join(',')})` : ''} ORDER BY table_name`, [args.database, ...(wanted || [])]); const tables = [];
-    for (const row of tableRows) { const tableName = row.TABLE_NAME; const cols = await mysqlQuery(connection, `SELECT COLUMN_NAME, DATA_TYPE, COLUMN_TYPE, IS_NULLABLE, COLUMN_KEY, EXTRA, COLUMN_COMMENT FROM information_schema.columns WHERE table_schema=? AND table_name=? ORDER BY ORDINAL_POSITION`, [args.database, tableName]); const indexRows = await mysqlQuery(connection, `SELECT INDEX_NAME AS index_name, COLUMN_NAME AS column_name, NON_UNIQUE = 0 AS is_unique, INDEX_NAME = 'PRIMARY' AS is_primary FROM information_schema.STATISTICS WHERE TABLE_SCHEMA=? AND TABLE_NAME=? ORDER BY INDEX_NAME, SEQ_IN_INDEX`, [args.database, tableName]); const fkRows = await mysqlQuery(connection, `SELECT CONSTRAINT_NAME AS fk_name, COLUMN_NAME AS column_name, REFERENCED_TABLE_NAME AS referenced_table, REFERENCED_COLUMN_NAME AS referenced_column FROM information_schema.KEY_COLUMN_USAGE WHERE TABLE_SCHEMA=? AND TABLE_NAME=? AND REFERENCED_TABLE_NAME IS NOT NULL ORDER BY CONSTRAINT_NAME, ORDINAL_POSITION`, [args.database, tableName]); const indexes = groupRows(indexRows, 'index_name', (x) => ({ name: x.index_name, columns: [], unique: Boolean(x.is_unique), primary: Boolean(x.is_primary) }), (result, x) => result.columns.push(x.column_name)); const foreignKeys = groupRows(fkRows, 'fk_name', (x) => ({ name: x.fk_name, columns: [], referenced_table: x.referenced_table, referenced_columns: [] }), (result, x) => { result.columns.push(x.column_name); result.referenced_columns.push(x.referenced_column); }); const columns = cols.map((col) => ({ name: col.COLUMN_NAME, sql_type: col.COLUMN_TYPE || col.DATA_TYPE, nullable: col.IS_NULLABLE === 'YES', primary: col.COLUMN_KEY === 'PRI', auto_increment: String(col.EXTRA || '').toLowerCase().includes('auto_increment'), comment: col.COLUMN_COMMENT || '' })); tables.push({ table_name: tableName, table_comment: row.TABLE_COMMENT || tableName, primary_keys: columns.filter((x) => x.primary).map((x) => x.name), columns, indexes, foreign_keys: foreignKeys }); }
-    return { db_type: dbType, database: args.database, schema: args.database, tables };
-  } finally { if (connection) await connection.end(); }
-}
-function groupRows(rows, key, factory, add) { const map = new Map(); for (const row of rows) { const value = row[key]; if (!map.has(value)) map.set(value, factory(row)); add(map.get(value), row); } return [...map.values()]; }
-async function postgresMetadata(args, dbType = 'postgres') {
-  const pg = driver('pg', dbType); const schema = args.schema || 'public'; const client = new pg.Client({ host: args.host, port: Number(args.port), user: args.user, password: args.password, database: args.database }); await client.connect(); try { const wanted = normalizeTables(args.tables); const tableResult = await client.query(`SELECT t.table_name, pgd.description AS table_comment FROM information_schema.tables t LEFT JOIN pg_catalog.pg_statio_all_tables st ON st.schemaname=t.table_schema AND st.relname=t.table_name LEFT JOIN pg_catalog.pg_description pgd ON pgd.objoid=st.relid AND pgd.objsubid=0 WHERE t.table_schema=$1 AND t.table_type='BASE TABLE'${wanted ? ' AND t.table_name = ANY($2)' : ''} ORDER BY t.table_name`, wanted ? [schema, wanted] : [schema]); const tables = [];
-    for (const tableRow of tableResult.rows) { const tableName = tableRow.table_name; const cols = (await client.query(`SELECT c.column_name,c.data_type,c.udt_name,c.is_nullable,pgd.description AS column_comment FROM information_schema.columns c LEFT JOIN pg_catalog.pg_statio_all_tables st ON st.schemaname=c.table_schema AND st.relname=c.table_name LEFT JOIN pg_catalog.pg_description pgd ON pgd.objoid=st.relid AND pgd.objsubid=c.ordinal_position WHERE c.table_schema=$1 AND c.table_name=$2 ORDER BY c.ordinal_position`, [schema, tableName])).rows; const pks = (await client.query(`SELECT kcu.column_name FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name=kcu.constraint_name AND tc.table_schema=kcu.table_schema AND tc.table_name=kcu.table_name WHERE tc.table_schema=$1 AND tc.table_name=$2 AND tc.constraint_type='PRIMARY KEY' ORDER BY kcu.ordinal_position`, [schema, tableName])).rows.map((x) => x.column_name); const indexRows = (await client.query(`SELECT ic.relname AS index_name,a.attname AS column_name,idx.indisunique AS is_unique,idx.indisprimary AS is_primary FROM pg_index idx JOIN pg_class ic ON idx.indexrelid=ic.oid JOIN pg_class t ON idx.indrelid=t.oid JOIN pg_namespace n ON t.relnamespace=n.oid JOIN pg_attribute a ON a.attrelid=t.oid AND a.attnum=ANY(idx.indkey) WHERE n.nspname=$1 AND t.relname=$2 ORDER BY ic.relname,a.attnum`, [schema, tableName])).rows; const fkRows = (await client.query(`SELECT tc.constraint_name AS fk_name,kcu.column_name AS column_name,ccu.table_name AS referenced_table,ccu.column_name AS referenced_column FROM information_schema.table_constraints tc JOIN information_schema.key_column_usage kcu ON tc.constraint_name=kcu.constraint_name JOIN information_schema.constraint_column_usage ccu ON ccu.constraint_name=tc.constraint_name WHERE tc.table_schema=$1 AND tc.table_name=$2 AND tc.constraint_type='FOREIGN KEY' ORDER BY tc.constraint_name,kcu.ordinal_position`, [schema, tableName])).rows; const pkSet = new Set(pks); tables.push({ table_name: tableName, table_comment: tableRow.table_comment || tableName, primary_keys: pks, columns: cols.map((x) => ({ name: x.column_name, sql_type: x.udt_name || x.data_type, nullable: x.is_nullable === 'YES', primary: pkSet.has(x.column_name), auto_increment: ['serial', 'bigserial'].includes(x.udt_name), comment: x.column_comment || '' })), indexes: groupRows(indexRows, 'index_name', (x) => ({ name: x.index_name, columns: [], unique: x.is_unique, primary: x.is_primary }), (x, row) => x.columns.push(row.column_name)), foreign_keys: groupRows(fkRows, 'fk_name', (x) => ({ name: x.fk_name, columns: [], referenced_table: x.referenced_table, referenced_columns: [] }), (x, row) => { x.columns.push(row.column_name); x.referenced_columns.push(row.referenced_column); }) }); }
-    return { db_type: dbType, database: args.database, schema, tables };
-  } finally { await client.end(); }
-}
-async function oracleMetadata(args) {
-  const oracle = driver('oracledb', 'oracle'); const connection = await oracle.getConnection({ user: args.user, password: args.password, connectString: `${args.host}:${Number(args.port)}/${args.database}` }); try { const wanted = normalizeTables(args.tables); const binds = {}; const queryNames = wanted?.map((x, i) => { binds[`t${i}`] = x.toUpperCase(); return `:t${i}`; }); const tableRows = (await connection.execute(`SELECT table_name FROM user_tables${queryNames ? ` WHERE table_name IN (${queryNames.join(',')})` : ''} ORDER BY table_name`, binds)).rows; const tables = [];
-    for (const row of tableRows) { const tableName = row[0]; const run = async (sql) => (await connection.execute(sql, { table_name: tableName })).rows; const colRows = await run(`SELECT utc.column_name,utc.data_type,utc.data_precision,utc.data_scale,utc.nullable,ucc.comments FROM user_tab_columns utc LEFT JOIN user_col_comments ucc ON utc.table_name=ucc.table_name AND utc.column_name=ucc.column_name WHERE utc.table_name=:table_name ORDER BY utc.column_id`); const pks = (await run(`SELECT cols.column_name FROM user_constraints cons JOIN user_cons_columns cols ON cons.constraint_name=cols.constraint_name WHERE cons.constraint_type='P' AND cons.table_name=:table_name ORDER BY cols.position`)).map((x) => x[0].toLowerCase()); const identity = new Set((await run(`SELECT column_name FROM user_tab_identity_cols WHERE table_name=:table_name`)).map((x) => x[0].toLowerCase())); const indexRows = await run(`SELECT ui.index_name,uic.column_name,ui.uniqueness='UNIQUE' AS is_unique,ui.index_name IN (SELECT uc.constraint_name FROM user_constraints uc WHERE uc.table_name=:table_name AND uc.constraint_type='P') AS is_primary FROM user_indexes ui JOIN user_ind_columns uic ON ui.index_name=uic.index_name WHERE ui.table_name=:table_name ORDER BY ui.index_name,uic.column_position`); const fkRows = await run(`SELECT uc.constraint_name,ucc.column_name,ruc.table_name,rucc.column_name FROM user_constraints uc JOIN user_cons_columns ucc ON uc.constraint_name=ucc.constraint_name JOIN user_constraints ruc ON uc.r_constraint_name=ruc.constraint_name JOIN user_cons_columns rucc ON ruc.constraint_name=rucc.constraint_name AND ucc.position=rucc.position WHERE uc.table_name=:table_name AND uc.constraint_type='R' ORDER BY uc.constraint_name,ucc.position`); const tableComment = (await run(`SELECT comments FROM user_tab_comments WHERE table_name=:table_name`))[0]?.[0] || tableName.toLowerCase(); const pkSet = new Set(pks); const typeFor = (x) => { const type = String(x[1] || '').toLowerCase(); if (type !== 'number') return type; return Number(x[3]) > 0 ? 'numeric' : Number(x[2]) <= 9 ? 'integer' : 'bigint'; }; tables.push({ table_name: tableName.toLowerCase(), table_comment: tableComment, primary_keys: pks, columns: colRows.map((x) => { const name = x[0].toLowerCase(); return { name, sql_type: typeFor(x), nullable: x[4] === 'Y', primary: pkSet.has(name), auto_increment: identity.has(name), comment: x[5] || '' }; }), indexes: groupRows(indexRows.map((x) => ({ index_name: x[0].toLowerCase(), column_name: x[1].toLowerCase(), is_unique: x[2], is_primary: x[3] })), 'index_name', (x) => ({ name: x.index_name, columns: [], unique: x.is_unique, primary: x.is_primary }), (x, row2) => x.columns.push(row2.column_name)), foreign_keys: groupRows(fkRows.map((x) => ({ fk_name: x[0].toLowerCase(), column_name: x[1].toLowerCase(), referenced_table: x[2].toLowerCase(), referenced_column: x[3].toLowerCase() })), 'fk_name', (x) => ({ name: x.fk_name, columns: [], referenced_table: x.referenced_table, referenced_columns: [] }), (x, row2) => { x.columns.push(row2.column_name); x.referenced_columns.push(row2.referenced_column); }) }); }
-    return { db_type: 'oracle', database: args.database, schema: args.user, tables };
-  } finally { await connection.close(); }
-}
-async function extract(args) { mergeDatasource(args); requireConnection(args); let metadata; try { if (['mysql', 'oceanbase'].includes(args['db-type'])) metadata = await mysqlMetadata(args, args['db-type']); else if (['postgres', 'opengauss'].includes(args['db-type'])) metadata = await postgresMetadata(args, args['db-type']); else if (args['db-type'] === 'oracle') metadata = await oracleMetadata(args); else throw new SkillError(`不支持的 db_type: ${args['db-type']}`); } catch (error) { if (error instanceof SkillError) throw error; throw new SkillError(`数据库连接失败: ${error.message}\n\n排查建议：\n  1. 检查数据库服务是否启动\n  2. 检查主机地址和端口是否正确\n  3. 检查用户名和密码是否正确\n  4. 检查数据库名是否正确\n  5. 检查网络连接是否正常\n`); }
-  const original = metadata.tables; metadata.tables = filterTables(original, args['include-tables-regex'], args['exclude-tables-regex']); if (!metadata.tables.length && original.length) throw new SkillError(`没有匹配到表。可用表：${original.map((x) => x.table_name).join(', ')}`); return metadata; }
-
-function normaliseScaffold(args) { const root = args['skill-root']; for (const [name, target] of Object.entries({ 'type-mapping': 'references/type-mapping.json', 'po-template': 'assets/po.java.template', 'domain-model-template': 'assets/domain_model.java.template', 'repository-template': 'assets/repository.java.template', 'domain-gateway-template': 'assets/domain_gateway.java.template', 'gateway-impl-template': 'assets/gateway_impl.java.template', 'convertor-template': 'assets/convertor.java.template' })) if (!args[name]) args[name] = defaultPath(root, target); const convention = { audit_columns: [...AUDIT_COLUMNS], logic_delete_fields: [...LOGIC_DELETE_FIELDS], pk_strategy: args['pk-strategy'] || 'error', page_method_name: 'page' }; if (args['convention-file']) Object.assign(convention, loadJson(args['convention-file'])); if (args['keep-audit-columns']) convention.audit_columns = []; args._convention = convention; }
-function validateTemplates(args) { const expected = { [args['po-template']]: ['${domain_name}', '${fields_block}', '${table_name}'], [args['domain-model-template']]: ['${domain_name}'], [args['repository-template']]: ['${domain_name}'], [args['domain-gateway-template']]: ['${domain_name}', '${pk_java_type}'], [args['gateway-impl-template']]: ['${domain_name}', '${repository_field_name}'], [args['convertor-template']]: ['${domain_name}'] }; for (const [file, tokens] of Object.entries(expected)) for (const token of tokens) if (!readText(file).includes(token)) throw new SkillError(`模板 ${file} 缺少占位符 ${token}`); }
-function buildFields(columns, mapping, skipped, forPo) { const lines = []; const usable = []; for (const column of columns) { if (skipped.has(column.name)) continue; usable.push(column); const field = camel(column.name); if (column.comment) lines.push(`/** ${column.comment} */`); if (forPo) lines.push(column.primary ? `@TableId(value = "${column.name}", type = IdType.${column.auto_increment ? 'AUTO' : 'ASSIGN_ID'})` : `    @TableField("${column.name}")`); lines.push(`    private ${javaType(column.sql_type, mapping)} ${field};`, ''); } while (lines.at(-1) === '') lines.pop(); return [lines.join('\n'), usable]; }
-function pickPrimary(table, columns, strategy) { const keys = table.primary_keys || []; if (keys.length > 1 && strategy === 'error') throw new SkillError(`表 ${table.table_name} 为联合主键 ${JSON.stringify(keys)}，当前 pk_strategy=error。可改用 --pk-strategy first`); if (keys.length) { const hit = columns.find((x) => x.name === keys[0]); if (hit) return hit; } return columns.find((x) => x.primary) || columns.find((x) => x.name === 'id') || { name: 'id', sql_type: 'bigint', primary: true, auto_increment: false }; }
-function importsFor(columns, mapping) { return [...new Set(columns.map((x) => JAVA_IMPORTS[javaType(x.sql_type, mapping)]).filter(Boolean))].sort().join('\n'); }
-function filePaths(args, domain) { const base = args['base-package'].replaceAll('.', '/'); const segment = args['domain-segment'] || domain.toLowerCase(); const domainRoot = path.join(args['domain-java-root'], base, 'domain', segment); const infra = path.join(args['infra-java-root'], base, 'repository'); return { domain_model: path.join(domainRoot, 'model', `${domain}.java`), domain_gateway: path.join(domainRoot, 'gateway', `${domain}Gateway.java`), po: path.join(infra, 'entity', `${domain}PO.java`), repo: path.join(infra, `${domain}Repository.java`), gateway_impl: path.join(infra, 'gateway', 'impl', `${domain}GatewayImpl.java`), convertor: path.join(infra, 'convertor', `${domain}Convertor.java`) }; }
-function writeJava(file, content, args) { if (fs.existsSync(file) && !args.overwrite) throw new SkillError(`文件已存在: ${file}. 如需覆盖请添加 --overwrite`); if (!args['dry-run']) writeText(file, `${content.trim()}\n`); }
-function generateTable(table, args, mapping) { const convention = args._convention; const domain = inferDomain(table.table_name, args['table-prefix'] || 't_'); const segment = args['domain-segment']; const modelPkg = `${args['base-package']}.domain.${segment || domain.toLowerCase()}.model`; const gatewayPkg = `${args['base-package']}.domain.${segment || domain.toLowerCase()}.gateway`; const [poFields, poColumns] = buildFields(table.columns || [], mapping, new Set(convention.audit_columns || []), true); const [domainFields, domainColumns] = buildFields(table.columns || [], mapping, new Set(convention.audit_columns || []), false); const primary = pickPrimary(table, domainColumns, convention.pk_strategy || 'error'); const pkName = camel(primary.name); const values = { base_package: args['base-package'], gateway_pkg: gatewayPkg, model_pkg: modelPkg, domain_segment: segment, table_name: table.table_name, table_comment: String(table.table_comment || table.table_name).replaceAll('*/', ''), domain_name: domain, fields_block: poFields, extra_imports: importsFor(poColumns, mapping), pk_java_type: javaType(primary.sql_type, mapping), pk_field_name: pkName, pk_getter: `get${upperFirst(pkName)}`, repository_field_name: `${lowerFirst(domain)}Repository`, method_add: `add${domain}`, method_update: `update${domain}`, method_delete: `delete${domain}`, method_get: `get${domain}ById`, method_page: `page${domain}`, logic_delete_condition: '' }; const logical = (convention.logic_delete_fields || []).find((x) => domainColumns.some((col) => col.name === x)); if (logical) values.logic_delete_condition = `        wrapper.eq(${domain}PO::get${upperFirst(camel(logical))}, 0);`; const templates = { domain_model: args['domain-model-template'], domain_gateway: args['domain-gateway-template'], po: args['po-template'], repo: args['repository-template'], gateway_impl: args['gateway-impl-template'], convertor: args['convertor-template'] }; const paths = filePaths(args, domain); const outputValues = { ...values, fields_block: domainFields, extra_imports: importsFor(domainColumns, mapping) }; const generated = []; for (const [kind, file] of Object.entries(paths)) { const templateValues = kind === 'domain_model' ? outputValues : values; writeJava(file, replaceTemplate(readText(templates[kind]), templateValues), args); generated.push(file); } return generated; }
-
-async function runInit(args) { requireArgs(args, ['skill-root']); const rl = readline.createInterface({ input, output }); const ask = async (label, fallback) => (await rl.question(`${label}${fallback ? ` [${fallback}]` : ''}: `)).trim() || fallback || ''; try { console.log('='.repeat(60) + '\n  yss-db2mybatis 配置向导\n' + '='.repeat(60)); const dbType = await ask('数据库类型（mysql/postgres/oracle）', 'postgres'); if (!['mysql', 'postgres', 'oracle'].includes(dbType)) throw new SkillError('数据库类型必须是 mysql、postgres 或 oracle'); const host = await ask('数据库主机地址', 'localhost'); const port = await ask('数据库端口', ({ mysql: '3306', postgres: '5432', oracle: '1521' })[dbType]); const user = await ask('数据库用户名', 'dmz'); const password = await ask('数据库密码', 'dmz'); const database = await ask('数据库名', 'yss_metadata'); const schema = dbType === 'postgres' ? await ask('Schema 名称', 'public') : null; const datasourceName = await ask('数据源名称', 'my-datasource'); const basePackage = await ask('基础包名', 'com.yss.metadata'); const segment = await ask('领域分段名', 'metadata'); const confirm = (await ask('确认生成配置文件? (y/n)', 'y')).toLowerCase(); if (!['y', 'yes', ''].includes(confirm)) { console.log('已取消'); return; } const file = path.join(os.tmpdir(), 'yss-db2mybatis', 'datasource-config.json'); const source = { db_type: dbType, host, port: Number(port), user, password, database }; if (schema) source.schema = schema; writeText(file, `${JSON.stringify({ datasources: { [datasourceName]: source } }, null, 2)}\n`); const metadata = path.join(os.tmpdir(), 'yss-db2mybatis', 'metadata.json'); console.log(`\n✅ 数据源配置文件已生成: ${file}\n\n1. 提取元数据:\n   node ${args['skill-root']}/scripts/db2mybatis.mjs extract \\\n     --datasource-config ${file} \\\n     --datasource-name ${datasourceName} \\\n     --include-tables-regex '.*' \\\n     --output ${metadata}\n\n2. 生成代码:\n   node ${args['skill-root']}/scripts/db2mybatis.mjs scaffold \\\n     --skill-root ${args['skill-root']} \\\n     --metadata-file ${metadata} \\\n     --base-package ${basePackage} \\\n     --domain-segment ${segment} \\\n     --domain-java-root ./domain \\\n     --infra-java-root ./infrastructure \\\n     --dry-run`); } finally { rl.close(); } }
-async function main() { let parsed; try { parsed = parseArgs(process.argv.slice(2)); if (parsed.command === 'help') return help(); const { command, args } = parsed; validateOptionNames(command, args); if (command === 'init') return runInit(args); if (command === 'ddl2metadata') { requireArgs(args, ['output']); const metadata = metadataFromDdl(readDdl(args), args['db-type'] || 'mysql', args.database || 'ddl', args.schema); if (!metadata.tables.length) throw new SkillError('DDL 中未识别到 CREATE TABLE'); writeText(args.output, `${JSON.stringify(metadata, null, 2)}\n`); console.log(`metadata written: ${args.output}\ntables: ${metadata.tables.length}`); return; } if (command === 'extract') { requireArgs(args, ['output']); const metadata = await extract(args); writeText(args.output, `${JSON.stringify(metadata, null, 2)}\n`); console.log(`metadata written: ${args.output}\ntables: ${metadata.tables.length}`); return; } if (!['scaffold', 'validate'].includes(command)) throw new SkillError(`不支持的命令: ${command}`); requireArgs(args, ['skill-root', 'base-package', 'domain-segment', 'domain-java-root', 'infra-java-root']); normaliseScaffold(args); validateTemplates(args); if (command === 'validate') { const checks = []; if (args['datasource-config']) { const config = loadJson(args['datasource-config']); if (!config.datasources || typeof config.datasources !== 'object' || Array.isArray(config.datasources)) throw new SkillError('datasource 配置文件缺少 datasources 对象'); checks.push('datasource-config'); } if (args['convention-file']) { const convention = loadJson(args['convention-file']); if (!convention || typeof convention !== 'object' || Array.isArray(convention)) throw new SkillError('convention 文件必须为 JSON 对象'); checks.push('convention-file'); } console.log(`validate passed\nchecks: ${[...checks, 'templates'].join(', ')}`); return; } let metadata; if (args['metadata-file']) { metadata = loadJson(args['metadata-file']); } else if (args['ddl-file'] || args['ddl-sql']) { metadata = metadataFromDdl(readDdl(args), args['db-type'] || 'mysql', args.database || 'ddl', args.schema); } else metadata = await extract(args); const tables = filterTables(metadata.tables || [], args['include-tables-regex'], args['exclude-tables-regex']); if (!tables.length) throw new SkillError('没有匹配到可生成的表'); const mapping = loadJson(args['type-mapping']); const files = tables.flatMap((table) => generateTable(table, args, mapping)); for (const file of files) console.log(`${args['dry-run'] ? 'planned' : 'generated'}: ${file}`); console.log(`done. file count: ${files.length}`); } catch (error) { console.error(`error: ${error.message}`); process.exitCode = 2; } }
-
-await main();