@chihqiang/sql-quicktype 0.0.1 → 0.0.3

package/dist/index.mjs

@@ -1,699 +1,12 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/generator/TypeScriptGenerator.ts
-var TypeScriptGenerator_exports = {};
-__export(TypeScriptGenerator_exports, {
-  TypeScriptGenerator: () => TypeScriptGenerator
-});
-var TypeScriptGenerator;
-var init_TypeScriptGenerator = __esm({
-  "src/generator/TypeScriptGenerator.ts"() {
-    "use strict";
-    init_generator();
-    TypeScriptGenerator = class extends AGenerator {
-      constructor(options = { language: "typescript" }) {
-        super();
-        this.options = options;
-      }
-      /**
-       * 格式化字段名称（使用驼峰命名）
-       */
-      formatFieldName(name) {
-        return name.split("_").map((part, index) => {
-          if (index === 0) {
-            return part.toLowerCase();
-          }
-          return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-        }).join("");
-      }
-      /**
-       * 生成整个数据库模式的类型定义
-       */
-      generateDatabase(database) {
-        let result = `// Database: ${database.name}
-`;
-        result += `// Dialect: ${database.dialect}
-
-`;
-        for (const table of database.tables) {
-          result += this.generateTable(table);
-          result += "\n";
-        }
-        return result;
-      }
-      /**
-       * 生成单个表的类型定义
-       */
-      generateTable(table) {
-        let result = `// ${table.name} \u8868\u7ED3\u6784
-`;
-        result += `export interface ${this.formatTypeName(table.name)} {
-`;
-        for (const column of table.columns) {
-          result += this.generateColumn(column);
-        }
-        result += "}\n";
-        return result;
-      }
-      /**
-       * 生成列的类型定义
-       */
-      generateColumn(column) {
-        const fieldName = this.formatFieldName(column.name);
-        const typeName = this.mapSQLType(column.type, column.name);
-        const optional = column.nullable ? "?" : "";
-        let result = `	${fieldName}${optional}: ${typeName}`;
-        if (column.comment && this.options.generateComments !== false) {
-          result += `; // ${column.comment}`;
-        }
-        result += "\n";
-        return result;
-      }
-      /**
-       * 映射 SQL 类型到 TypeScript 类型
-       */
-      mapSQLType(type, columnName) {
-        switch (type.kind) {
-          case "int":
-          case "bigint":
-            return "number";
-          case "float":
-          case "decimal":
-            return "number";
-          case "varchar":
-          case "text":
-            return "string";
-          case "boolean":
-            return "boolean";
-          case "date":
-          case "datetime":
-            return "Date";
-          case "json":
-            return "unknown";
-          case "enum":
-            if (type.values && type.values.length > 0) {
-              const enumValues = type.values.map((v) => `'${v}'`).join(" | ");
-              if (columnName) {
-                const fieldName = this.formatFieldName(columnName);
-                return `${fieldName}: ${enumValues}`;
-              }
-              return enumValues;
-            }
-            return "string";
-          default:
-            return "string";
-        }
-      }
-    };
-  }
-});
-
-// src/generator/GolangGenerator.ts
-var GolangGenerator_exports = {};
-__export(GolangGenerator_exports, {
-  GolangGenerator: () => GolangGenerator
-});
-var GolangGenerator;
-var init_GolangGenerator = __esm({
-  "src/generator/GolangGenerator.ts"() {
-    "use strict";
-    init_generator();
-    GolangGenerator = class extends AGenerator {
-      constructor(options = { language: "go" }) {
-        super();
-        this.options = options;
-      }
-      /**
-       * 生成整个数据库模式的类型定义
-       */
-      generateDatabase(database) {
-        let result = `// Database: ${database.name}
-`;
-        result += `// Dialect: ${database.dialect}
-
-`;
-        if (this.options.namespace) {
-          result += `package ${this.options.namespace}
-
-`;
-        }
-        if (this.needsTimeImport(database)) {
-          result += `import "time"
-
-`;
-        }
-        for (const table of database.tables) {
-          result += this.generateTable(table);
-          result += "\n";
-        }
-        return result;
-      }
-      /**
-       * 生成单个表的类型定义
-       */
-      generateTable(table) {
-        let result = `// ${table.name} \u8868\u7ED3\u6784
-`;
-        result += `type ${this.formatTypeName(table.name)} struct {
-`;
-        for (const column of table.columns) {
-          result += this.generateColumn(column);
-        }
-        result += "}\n";
-        return result;
-      }
-      /**
-       * 生成列的类型定义
-       */
-      generateColumn(column) {
-        const fieldName = this.formatFieldName(column.name);
-        const typeName = this.mapSQLType(column.type);
-        const tag = this.generateGoTag(column);
-        let result = `	${fieldName} ${typeName} ${tag}`;
-        if (column.comment && this.options.generateComments !== false) {
-          result += ` // ${column.comment}`;
-        }
-        result += "\n";
-        return result;
-      }
-      /**
-       * 映射 SQL 类型到 Go 类型
-       */
-      mapSQLType(type) {
-        switch (type.kind) {
-          case "int":
-            return "int";
-          case "bigint":
-            return "int64";
-          case "float":
-            return "float64";
-          case "decimal":
-            return "float64";
-          case "varchar":
-          case "text":
-            return "string";
-          case "boolean":
-            return "bool";
-          case "date":
-          case "datetime":
-            return "time.Time";
-          case "json":
-            return "interface{}";
-          case "enum":
-            return "string";
-          default:
-            return "string";
-        }
-      }
-      /**
-       * 生成 Go 结构体标签
-       */
-      generateGoTag(column) {
-        const tags = [];
-        tags.push(`json:"${column.name}"`);
-        tags.push(`db:"${column.name}"`);
-        return `\`${tags.join(" ")}\``;
-      }
-    };
-  }
-});
-
-// src/generator/GormGenerator.ts
-var GormGenerator_exports = {};
-__export(GormGenerator_exports, {
-  GormGenerator: () => GormGenerator
-});
-var GormGenerator;
-var init_GormGenerator = __esm({
-  "src/generator/GormGenerator.ts"() {
-    "use strict";
-    init_generator();
-    GormGenerator = class extends AGenerator {
-      constructor(options = { language: "gorm" }) {
-        super();
-        this.options = options;
-      }
-      /**
-       * 生成整个数据库模式的类型定义
-       */
-      generateDatabase(database) {
-        let result = `// Database: ${database.name}
-`;
-        result += `// Dialect: ${database.dialect}
-
-`;
-        if (this.options.namespace) {
-          result += `package ${this.options.namespace}
-
-`;
-        }
-        if (this.needsTimeImport(database)) {
-          result += `import "time"
-
-`;
-        }
-        for (const table of database.tables) {
-          result += this.generateTable(table);
-          result += "\n";
-        }
-        return result;
-      }
-      /**
-       * 生成单个表的类型定义
-       */
-      generateTable(table) {
-        let result = `// ${table.name} \u8868\u7ED3\u6784
-`;
-        result += `type ${this.formatTypeName(table.name)} struct {
-`;
-        for (const column of table.columns) {
-          result += this.generateColumn(column);
-        }
-        result += "}\n";
-        return result;
-      }
-      /**
-       * 生成列的类型定义
-       */
-      generateColumn(column) {
-        const fieldName = this.formatFieldName(column.name);
-        const typeName = this.mapSQLType(column.type);
-        const tag = this.generateGormTag(column);
-        let result = `	${fieldName} ${typeName} ${tag}`;
-        if (column.comment && this.options.generateComments !== false) {
-          result += ` // ${column.comment}`;
-        }
-        result += "\n";
-        return result;
-      }
-      /**
-       * 映射 SQL 类型到 GORM 类型
-       */
-      mapSQLType(type) {
-        switch (type.kind) {
-          case "int":
-            return "int";
-          case "bigint":
-            return "int64";
-          case "float":
-            return "float64";
-          case "decimal":
-            return "float64";
-          case "varchar":
-          case "text":
-            return "string";
-          case "boolean":
-            return "bool";
-          case "date":
-          case "datetime":
-            return "time.Time";
-          case "json":
-            return "interface{}";
-          case "enum":
-            return "string";
-          default:
-            return "string";
-        }
-      }
-      /**
-       * 生成 GORM 结构体标签
-       */
-      generateGormTag(column) {
-        const tags = [];
-        tags.push(`column:${column.name}`);
-        let typeTag = "type:";
-        switch (column.type.kind) {
-          case "int":
-            typeTag += "int";
-            if (column.type.length) {
-              typeTag += `(${column.type.length})`;
-            }
-            break;
-          case "bigint":
-            typeTag += "bigint";
-            if (column.type.length) {
-              typeTag += `(${column.type.length})`;
-            }
-            break;
-          case "float":
-            typeTag += "float";
-            if (column.type.precision) {
-              typeTag += `(${column.type.precision}`;
-              if (column.type.scale) {
-                typeTag += `,${column.type.scale}`;
-              }
-              typeTag += ")";
-            }
-            break;
-          case "decimal":
-            typeTag += "decimal";
-            if (column.type.precision) {
-              typeTag += `(${column.type.precision}`;
-              if (column.type.scale) {
-                typeTag += `,${column.type.scale}`;
-              }
-              typeTag += ")";
-            }
-            break;
-          case "varchar":
-            typeTag += "varchar";
-            if (column.type.length) {
-              typeTag += `(${column.type.length})`;
-            }
-            break;
-          case "text":
-            typeTag += "text";
-            break;
-          case "boolean":
-            typeTag += "bool";
-            break;
-          case "date":
-            typeTag += "date";
-            break;
-          case "datetime":
-            typeTag += "datetime";
-            break;
-          case "json":
-            typeTag += "json";
-            break;
-          case "enum":
-            typeTag += "enum";
-            break;
-          default:
-            typeTag += "string";
-        }
-        tags.push(typeTag);
-        if (column.primaryKey) {
-          tags.push("primaryKey");
-        }
-        if (column.unique) {
-          tags.push("unique");
-        }
-        if (!column.nullable) {
-          tags.push("not null");
-        }
-        if (column.default) {
-          tags.push(`default:${column.default}`);
-        }
-        if (column.generated) {
-          tags.push("autoIncrement");
-        }
-        if (column.comment) {
-          tags.push(`comment:${column.comment}`);
-        }
-        return `\`gorm:"${tags.join(";")}" json:"${column.name}"\``;
-      }
-    };
-  }
-});
-
-// src/generator/XormGenerator.ts
-var XormGenerator_exports = {};
-__export(XormGenerator_exports, {
-  XormGenerator: () => XormGenerator
-});
-var XormGenerator;
-var init_XormGenerator = __esm({
-  "src/generator/XormGenerator.ts"() {
-    "use strict";
-    init_generator();
-    XormGenerator = class extends AGenerator {
-      constructor(options = { language: "xorm" }) {
-        super();
-        this.options = options;
-      }
-      /**
-       * 生成整个数据库模式的类型定义
-       */
-      generateDatabase(database) {
-        let result = `// Database: ${database.name}
-`;
-        result += `// Dialect: ${database.dialect}
-
-`;
-        if (this.options.namespace) {
-          result += `package ${this.options.namespace}
-
-`;
-        }
-        if (this.needsTimeImport(database)) {
-          result += `import "time"
-
-`;
-        }
-        for (const table of database.tables) {
-          result += this.generateTable(table);
-          result += "\n";
-        }
-        return result;
-      }
-      /**
-       * 生成单个表的类型定义
-       */
-      generateTable(table) {
-        let result = `// ${table.name} \u8868\u7ED3\u6784
-`;
-        result += `type ${this.formatTypeName(table.name)} struct {
-`;
-        for (const column of table.columns) {
-          result += this.generateColumn(column);
-        }
-        result += "}\n";
-        return result;
-      }
-      /**
-       * 生成列的类型定义
-       */
-      generateColumn(column) {
-        const fieldName = this.formatFieldName(column.name);
-        const typeName = this.mapSQLType(column.type);
-        const tag = this.generateXormTag(column);
-        let result = `	${fieldName} ${typeName} ${tag}`;
-        if (column.comment && this.options.generateComments !== false) {
-          result += ` // ${column.comment}`;
-        }
-        result += "\n";
-        return result;
-      }
-      /**
-       * 映射 SQL 类型到 XORM 类型
-       */
-      mapSQLType(type) {
-        switch (type.kind) {
-          case "int":
-            return "int";
-          case "bigint":
-            return "int64";
-          case "float":
-            return "float64";
-          case "decimal":
-            return "float64";
-          case "varchar":
-          case "text":
-            return "string";
-          case "boolean":
-            return "bool";
-          case "date":
-          case "datetime":
-            return "time.Time";
-          case "json":
-            return "interface{}";
-          case "enum":
-            return "string";
-          default:
-            return "string";
-        }
-      }
-      /**
-       * 生成 XORM 结构体标签
-       */
-      generateXormTag(column) {
-        const tags = [];
-        tags.push(`${column.name}`);
-        let typeTag = "";
-        switch (column.type.kind) {
-          case "int":
-            typeTag = "int";
-            if (column.type.length) {
-              typeTag += `(${column.type.length})`;
-            }
-            break;
-          case "bigint":
-            typeTag = "bigint";
-            if (column.type.length) {
-              typeTag += `(${column.type.length})`;
-            }
-            break;
-          case "float":
-            typeTag = "float";
-            if (column.type.precision) {
-              typeTag += `(${column.type.precision}`;
-              if (column.type.scale) {
-                typeTag += `,${column.type.scale}`;
-              }
-              typeTag += ")";
-            }
-            break;
-          case "decimal":
-            typeTag = "decimal";
-            if (column.type.precision) {
-              typeTag += `(${column.type.precision}`;
-              if (column.type.scale) {
-                typeTag += `,${column.type.scale}`;
-              }
-              typeTag += ")";
-            }
-            break;
-          case "varchar":
-            typeTag = "varchar";
-            if (column.type.length) {
-              typeTag += `(${column.type.length})`;
-            }
-            break;
-          case "text":
-            typeTag = "text";
-            break;
-          case "boolean":
-            typeTag = "bool";
-            break;
-          case "date":
-            typeTag = "date";
-            break;
-          case "datetime":
-            typeTag = "datetime";
-            break;
-          case "json":
-            typeTag = "json";
-            break;
-          case "enum":
-            typeTag = "enum";
-            break;
-          default:
-            typeTag = "string";
-        }
-        if (typeTag) {
-          tags.push(typeTag);
-        }
-        if (column.primaryKey) {
-          tags.push("pk");
-        }
-        if (column.unique) {
-          tags.push("unique");
-        }
-        if (!column.nullable) {
-          tags.push("notnull");
-        }
-        if (column.default) {
-          tags.push(`default(${column.default})`);
-        }
-        if (column.generated) {
-          tags.push("autoincr");
-        }
-        if (column.comment) {
-          tags.push(`comment(${column.comment})`);
-        }
-        return `\`xorm:"${tags.join(" ")}" json:"${column.name}"\``;
-      }
-    };
-  }
-});
-
-// src/generator/generator.ts
-var AGenerator, GeneratorFactory;
-var init_generator = __esm({
-  "src/generator/generator.ts"() {
-    "use strict";
-    AGenerator = class {
-      /**
-       * 格式化类型名称（如驼峰命名、帕斯卡命名等）
-       */
-      formatTypeName(name) {
-        return name.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
-      }
-      /**
-       * 格式化字段名称
-       */
-      formatFieldName(name) {
-        return name.split("_").map((part) => {
-          return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
-        }).join("");
-      }
-      /**
-       * 生成默认值
-       */
-      generateDefaultValue(column) {
-        if (!column.default) {
-          return "";
-        }
-        return column.default;
-      }
-      /**
-       * 检查是否需要导入 time 包
-       */
-      needsTimeImport(database) {
-        for (const table of database.tables) {
-          for (const column of table.columns) {
-            if (column.type.kind === "date" || column.type.kind === "datetime") {
-              return true;
-            }
-          }
-        }
-        return false;
-      }
-    };
-    GeneratorFactory = class {
-      /**
-       * 创建语言生成器实例
-       * @param language 目标语言
-       * @param options 生成器配置选项
-       * @returns 语言生成器实例
-       */
-      static async createGenerator(language, options = { language }) {
-        switch (language) {
-          case "typescript":
-            const { TypeScriptGenerator: TypeScriptGenerator2 } = await Promise.resolve().then(() => (init_TypeScriptGenerator(), TypeScriptGenerator_exports));
-            return new TypeScriptGenerator2(options);
-          case "go":
-            const { GolangGenerator: GolangGenerator2 } = await Promise.resolve().then(() => (init_GolangGenerator(), GolangGenerator_exports));
-            return new GolangGenerator2(options);
-          case "gorm":
-            const { GormGenerator: GormGenerator2 } = await Promise.resolve().then(() => (init_GormGenerator(), GormGenerator_exports));
-            return new GormGenerator2(options);
-          case "xorm":
-            const { XormGenerator: XormGenerator2 } = await Promise.resolve().then(() => (init_XormGenerator(), XormGenerator_exports));
-            return new XormGenerator2(options);
-          default:
-            throw new Error(`Unsupported language: ${language}`);
-        }
-      }
-    };
-  }
-});
-
 // src/sql-parser.ts
 import { Parser } from "node-sql-parser";
-var parserCache = /* @__PURE__ */ new Map();
-function getParser(dialect) {
-  if (!parserCache.has(dialect)) {
-    parserCache.set(dialect, new Parser());
-  }
-  return parserCache.get(dialect);
-}
 function parseSQL(sql, options = { dialect: "mysql" }) {
   if (!sql || typeof sql !== "string") {
     throw new Error("SQL string is required and must be a string");
   }
   try {
-    const parser = getParser(options.dialect);
-    const processedSql = sql.trim().replace(/\s+/g, " ").replace(/;\s*;/g, ";");
+    const parser = new Parser();
+    const processedSql = sql.trim().replace(/\s+/g, " ").replace(/;[\s;]*;/g, ";");
     const ast = parser.astify(processedSql, { database: options.dialect });
     if (!ast) {
       throw new Error("Failed to parse SQL: AST is null or undefined");
@@ -720,8 +33,8 @@ SQL length: ${sql.length} characters`
 var SQLParser = class {
   constructor(options = { dialect: "mysql" }) {
     /**
-     * 默认类型解析器
-     * 提供基本的 SQL 类型到 SQLType 的映射逻辑
+     * Default type resolver
+     * Provides basic SQL type to SQLType mapping logic
      */
     this.defaultTypeResolver = {
       resolve: (def) => {
@@ -802,7 +115,7 @@ var SQLParser = class {
                   if (v.value) {
                     value = v.value;
                   } else if (v.raw) {
-                    value = v.raw;
+                    value = String(v.raw);
                   } else {
                     value = String(v);
                   }
@@ -821,8 +134,8 @@ var SQLParser = class {
             };
             return emptyEnumType;
           /**
-           * 未识别类型默认降级为 text，避免解析失败
-           * 在严格模式下，遇到未识别的类型会抛出错误
+           * Unrecognized types fall back to text by default to avoid parse failure
+           * In strict mode, unrecognized types throw an error
            */
           default:
             if (this.options.strictMode) {
@@ -844,7 +157,7 @@ var SQLParser = class {
     this.parser = new Parser();
   }
   /**
-   * 遍历 AST，提取所有 CREATE TABLE
+   * Traverse AST, extract all CREATE TABLE statements
    */
   parseDatabase(ast, dbName = this.options.dbName || "db") {
     const db = {
@@ -857,22 +170,21 @@ var SQLParser = class {
         db.tables.push(this.parseTable(node));
       }
     }
-    db.tablesMap = {};
-    for (const table of db.tables) {
-      if (table.name) {
-        db.tablesMap[table.name] = table;
-      }
-    }
+    db.tablesMap = Object.fromEntries(
+      db.tables.filter((t) => t.name).map((t) => [t.name, t])
+    );
     return db;
   }
   /**
-   * 类型守卫：判断是否为 CREATE TABLE 语句
+   * Type guard: check if node is a CREATE TABLE statement
    */
   isCreateTable(node) {
-    return node.type === "create" && node.keyword === "table";
+    if (!node || typeof node !== "object") return false;
+    const n = node;
+    return n.type === "create" && n.keyword === "table";
   }
   /**
-   * 解析单表 AST -> TableSchema
+   * Parse single table AST -> TableSchema
    */
   parseTable(node) {
     var _a, _b, _c, _d;
@@ -916,9 +228,9 @@ var SQLParser = class {
     return table;
   }
   /**
-   * 解析列定义 AST -> ColumnSchema
+   * Parse column definition AST -> ColumnSchema
    *
-   * 注意：字段级 primary/unique 与表级定义会叠加
+   * Note: Field-level primary/unique and table-level definitions will overlap
    */
   parseColumn(def) {
     var _a, _b, _c;
@@ -932,18 +244,18 @@ var SQLParser = class {
     return {
       name: columnName,
       /**
-       * 抽象 SQL 类型映射
+       * Abstract SQL type mapping
        */
       type: this.mapSQLType(def.definition),
       /**
-       * node-sql-parser 中：
-       * nullable 是一个对象，当它存在且 type 是 "not null" 时，表示 NOT NULL
+       * In node-sql-parser:
+       * nullable is an object; when it exists and type is "not null", it means NOT NULL
        */
       nullable: !(def.nullable && def.nullable.type === "not null"),
       primaryKey: !!def.primary_key,
       unique: !!def.unique,
       /**
-       * 默认值需要序列化为 SQL 字符串
+       * Default value needs to be serialized as SQL string
        */
       default: def.default_val ? this.parseDefault(def.default_val) : void 0,
       comment: (_c = (_b = def.comment) == null ? void 0 : _b.value) == null ? void 0 : _c.value,
@@ -952,7 +264,7 @@ var SQLParser = class {
     };
   }
   /**
-   * 解析表级 PRIMARY KEY / UNIQUE / FOREIGN KEY
+   * Parse table-level PRIMARY KEY / UNIQUE / FOREIGN KEY
    */
   parseTableConstraint(def, table) {
     var _a, _b, _c, _d, _e, _f, _g, _h;
@@ -1004,7 +316,7 @@ var SQLParser = class {
     }
   }
   /**
-   * 解析普通索引
+   * Parse regular index
    */
   parseIndex(def, table) {
     var _a;
@@ -1018,7 +330,7 @@ var SQLParser = class {
     }
   }
   /**
-   * SQL AST 类型 -> SQLType（跨方言抽象）
+   * SQL AST type -> SQLType (cross-dialect abstraction)
    */
   mapSQLType(def) {
     const allResolvers = [
@@ -1035,139 +347,672 @@ var SQLParser = class {
     return textType;
   }
   /**
-   * 默认值 AST -> SQL 字符串
+   * Default value AST -> SQL string
    *
-   * 使用 sqlify 确保函数/表达式被正确序列化
+   * Uses sqlify to ensure functions/expressions are serialized correctly
    */
   parseDefault(def) {
-    var _a, _b, _c, _d, _e, _f, _g;
-    if (((_a = def.value) == null ? void 0 : _a.type) === "null" || def.value === null) {
+    var _a, _b;
+    const val = def.value;
+    if ((val == null ? void 0 : val.type) === "null" || val === null) {
       return null;
     }
     try {
-      return this.parser.sqlify(def.value);
-    } catch (error) {
-      if (((_b = def.value) == null ? void 0 : _b.type) === "function") {
-        if ((_e = (_d = (_c = def.value.name) == null ? void 0 : _c.name) == null ? void 0 : _d[0]) == null ? void 0 : _e.value) {
-          return def.value.name.name[0].value;
+      return this.parser.sqlify(val);
+    } catch (e) {
+      if ((val == null ? void 0 : val.type) === "function") {
+        const name = val.name;
+        const firstName = name == null ? void 0 : name.name;
+        if ((_a = firstName == null ? void 0 : firstName[0]) == null ? void 0 : _a.value) {
+          return String(firstName[0].value);
         }
       }
-      return String((_g = (_f = def.value) == null ? void 0 : _f.value) != null ? _g : def.value);
+      const inner = val;
+      return String((_b = inner == null ? void 0 : inner.value) != null ? _b : val);
     }
   }
 };
 
-// src/generator/index.ts
-init_generator();
-init_TypeScriptGenerator();
-init_GolangGenerator();
-init_GormGenerator();
-init_XormGenerator();
+// src/generator/base.ts
+var BaseGenerator = class {
+  constructor() {
+    this.needsTimeCache = null;
+  }
+  /**
+   * Format type name (e.g., PascalCase)
+   */
+  formatTypeName(name) {
+    return name.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+  }
+  /**
+   * Format field name
+   */
+  formatPascalCase(name) {
+    return name.split("_").map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase()).join("");
+  }
+  formatFieldName(name) {
+    return this.formatPascalCase(name);
+  }
+  /**
+   * Generate default value
+   */
+  generateDefaultValue(column) {
+    if (!column.default) {
+      return "";
+    }
+    return column.default;
+  }
+  needsTimeImport(database) {
+    if (this.needsTimeCache !== null) return this.needsTimeCache;
+    for (const table of database.tables) {
+      for (const column of table.columns) {
+        if (column.type.kind === "date" || column.type.kind === "datetime") {
+          this.needsTimeCache = true;
+          return true;
+        }
+      }
+    }
+    this.needsTimeCache = false;
+    return false;
+  }
+};
+var GeneratorFactory = class {
+  static register(language, constructor) {
+    this.registry[language] = constructor;
+  }
+  static createGenerator(language, options = { language }) {
+    const Generator = this.registry[language];
+    if (!Generator) {
+      throw new Error(`Unsupported language: ${language}`);
+    }
+    return new Generator(options);
+  }
+};
+GeneratorFactory.registry = {};
 
-// src/utils.ts
-init_generator();
-async function generateCode(sql, options) {
-  const dbSchema = parseSQL(sql, {
-    dialect: options.dialect || "mysql",
-    dbName: options.dbName || "my_database"
-  });
-  const generatorOptions = {
-    language: options.language,
-    namespace: options.namespace,
-    generateComments: true
-  };
-  const generator = await GeneratorFactory.createGenerator(
-    options.language,
-    generatorOptions
-  );
-  return generator.generateDatabase(dbSchema);
-}
+// src/generator/typescript-generator.ts
+var TypeScriptGenerator = class extends BaseGenerator {
+  constructor(options = { language: "typescript" }) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Format field name (camelCase)
+   */
+  formatFieldName(name) {
+    return name.split("_").map((part, index) => {
+      if (index === 0) {
+        return part.toLowerCase();
+      }
+      return part.charAt(0).toUpperCase() + part.slice(1).toLowerCase();
+    }).join("");
+  }
+  /**
+   * Generate type definitions for the entire database schema
+   */
+  generateDatabase(database) {
+    let result = `// Database: ${database.name}
+`;
+    result += `// Dialect: ${database.dialect}
 
-// src/reader/StringReader.ts
-var StringReader = class {
+`;
+    for (const table of database.tables) {
+      result += this.generateTable(table);
+      result += "\n";
+    }
+    return result;
+  }
+  /**
+   * Generate type definition for a single table
+   */
+  generateTable(table) {
+    let result = `// ${table.name} table structure
+`;
+    result += `export interface ${this.formatTypeName(table.name)} {
+`;
+    for (const column of table.columns) {
+      result += this.generateColumn(column);
+    }
+    result += "}\n";
+    return result;
+  }
   /**
-   * 构造函数
-   * @param sql SQL 字符串
+   * Generate column type definition
    */
-  constructor(sql) {
-    this.sql = sql;
+  generateColumn(column) {
+    const fieldName = this.formatFieldName(column.name);
+    const typeName = this.mapSQLType(column.type, column.name);
+    const optional = column.nullable ? "?" : "";
+    let result = `	${fieldName}${optional}: ${typeName}`;
+    if (column.comment && this.options.generateComments !== false) {
+      result += `; // ${column.comment}`;
+    }
+    result += "\n";
+    return result;
   }
   /**
-   * 读取 SQL 内容
-   * @returns Promise<string> SQL 内容
+   * Map SQL type to TypeScript type
    */
-  async read() {
-    return this.sql;
+  mapSQLType(type, columnName) {
+    switch (type.kind) {
+      case "int":
+      case "bigint":
+        return "number";
+      case "float":
+      case "decimal":
+        return "number";
+      case "varchar":
+      case "text":
+        return "string";
+      case "boolean":
+        return "boolean";
+      case "date":
+      case "datetime":
+        return "Date";
+      case "json":
+        return "unknown";
+      case "enum":
+        if (type.values && type.values.length > 0) {
+          const enumValues = type.values.map((v) => `'${v}'`).join(" | ");
+          if (columnName) {
+            const fieldName = this.formatFieldName(columnName);
+            return `${fieldName}: ${enumValues}`;
+          }
+          return enumValues;
+        }
+        return "string";
+      default:
+        return "string";
+    }
   }
 };
 
-// src/reader/FileReader.ts
-import * as fs from "fs/promises";
-var FileReader = class {
+// src/generator/go-generator.ts
+var GoGenerator = class extends BaseGenerator {
+  constructor(options = { language: "go" }) {
+    super();
+    this.options = options;
+  }
   /**
-   * 构造函数
-   * @param filePath SQL 文件路径
+   * Generate type definitions for the entire database schema
    */
-  constructor(filePath) {
-    this.filePath = filePath;
+  generateDatabase(database) {
+    let result = `// Database: ${database.name}
+`;
+    result += `// Dialect: ${database.dialect}
+
+`;
+    if (this.options.namespace) {
+      result += `package ${this.options.namespace}
+
+`;
+    }
+    if (this.needsTimeImport(database)) {
+      result += `import "time"
+
+`;
+    }
+    for (const table of database.tables) {
+      result += this.generateTable(table);
+      result += "\n";
+    }
+    return result;
   }
   /**
-   * 读取 SQL 内容
-   * @returns Promise<string> SQL 内容
-   * @throws Error 文件不存在或读取失败
+   * Generate type definition for a single table
    */
-  async read() {
-    try {
-      await fs.access(this.filePath);
-      const content = await fs.readFile(this.filePath, "utf-8");
-      console.log(`Reading SQL from file: ${this.filePath}`);
-      return content;
-    } catch (error) {
-      if (error instanceof Error) {
-        if (error.code === "ENOENT") {
-          throw new Error(`File not found: ${this.filePath}`);
-        }
-        throw new Error(`Failed to read file: ${error.message}`);
-      }
-      throw new Error("Unknown error reading file");
+  generateTable(table) {
+    let result = `// ${table.name} table structure
+`;
+    result += `type ${this.formatTypeName(table.name)} struct {
+`;
+    for (const column of table.columns) {
+      result += this.generateColumn(column);
+    }
+    result += "}\n";
+    return result;
+  }
+  /**
+   * Generate column type definition
+   */
+  generateColumn(column) {
+    const fieldName = this.formatFieldName(column.name);
+    const typeName = this.mapSQLType(column.type);
+    const tag = this.generateGoTag(column);
+    let result = `	${fieldName} ${typeName} ${tag}`;
+    if (column.comment && this.options.generateComments !== false) {
+      result += ` // ${column.comment}`;
+    }
+    result += "\n";
+    return result;
+  }
+  /**
+   * Map SQL type to Go type
+   */
+  mapSQLType(type) {
+    switch (type.kind) {
+      case "int":
+        return "int";
+      case "bigint":
+        return "int64";
+      case "float":
+        return "float64";
+      case "decimal":
+        return "float64";
+      case "varchar":
+      case "text":
+        return "string";
+      case "boolean":
+        return "bool";
+      case "date":
+      case "datetime":
+        return "time.Time";
+      case "json":
+        return "interface{}";
+      case "enum":
+        return "string";
+      default:
+        return "string";
     }
   }
+  /**
+   * Generate Go struct tags
+   */
+  generateGoTag(column) {
+    const tags = [];
+    tags.push(`json:"${column.name}"`);
+    tags.push(`db:"${column.name}"`);
+    return `\`${tags.join(" ")}\``;
+  }
 };
 
-// src/reader/ReaderFactory.ts
-var ReaderFactory = class {
+// src/generator/gorm-generator.ts
+var GormGenerator = class extends BaseGenerator {
+  constructor(options = { language: "gorm" }) {
+    super();
+    this.options = options;
+  }
   /**
-   * 创建 Reader 实例
-   * @param options 读取器选项
-   * @returns Reader 实例
-   * @throws Error 不支持的读取器类型
+   * Generate type definitions for the entire database schema
    */
-  static createReader(options) {
-    switch (options.type) {
-      case "string":
-        if (!options.source) {
-          throw new Error("Source is required for string reader");
-        }
-        return new StringReader(options.source);
-      case "file":
-        if (!options.source) {
-          throw new Error("Source is required for file reader");
-        }
-        return new FileReader(options.source);
+  generateDatabase(database) {
+    let result = `// Database: ${database.name}
+`;
+    result += `// Dialect: ${database.dialect}
+
+`;
+    if (this.options.namespace) {
+      result += `package ${this.options.namespace}
+
+`;
+    }
+    if (this.needsTimeImport(database)) {
+      result += `import "time"
+
+`;
+    }
+    for (const table of database.tables) {
+      result += this.generateTable(table);
+      result += "\n";
+    }
+    return result;
+  }
+  /**
+   * Generate type definition for a single table
+   */
+  generateTable(table) {
+    let result = `// ${table.name} table structure
+`;
+    result += `type ${this.formatTypeName(table.name)} struct {
+`;
+    for (const column of table.columns) {
+      result += this.generateColumn(column);
+    }
+    result += "}\n";
+    return result;
+  }
+  /**
+   * Generate column type definition
+   */
+  generateColumn(column) {
+    const fieldName = this.formatFieldName(column.name);
+    const typeName = this.mapSQLType(column.type);
+    const tag = this.generateGormTag(column);
+    let result = `	${fieldName} ${typeName} ${tag}`;
+    if (column.comment && this.options.generateComments !== false) {
+      result += ` // ${column.comment}`;
+    }
+    result += "\n";
+    return result;
+  }
+  /**
+   * Map SQL type to GORM type
+   */
+  mapSQLType(type) {
+    switch (type.kind) {
+      case "int":
+        return "int";
+      case "bigint":
+        return "int64";
+      case "float":
+        return "float64";
+      case "decimal":
+        return "float64";
+      case "varchar":
+      case "text":
+        return "string";
+      case "boolean":
+        return "bool";
+      case "date":
+      case "datetime":
+        return "time.Time";
+      case "json":
+        return "interface{}";
+      case "enum":
+        return "string";
+      default:
+        return "string";
+    }
+  }
+  /**
+   * Generate GORM struct tags
+   */
+  generateGormTag(column) {
+    const tags = [];
+    tags.push(`column:${column.name}`);
+    let typeTag = "type:";
+    switch (column.type.kind) {
+      case "int":
+        typeTag += "int";
+        if (column.type.length) {
+          typeTag += `(${column.type.length})`;
+        }
+        break;
+      case "bigint":
+        typeTag += "bigint";
+        if (column.type.length) {
+          typeTag += `(${column.type.length})`;
+        }
+        break;
+      case "float":
+        typeTag += "float";
+        if (column.type.precision) {
+          typeTag += `(${column.type.precision}`;
+          if (column.type.scale) {
+            typeTag += `,${column.type.scale}`;
+          }
+          typeTag += ")";
+        }
+        break;
+      case "decimal":
+        typeTag += "decimal";
+        if (column.type.precision) {
+          typeTag += `(${column.type.precision}`;
+          if (column.type.scale) {
+            typeTag += `,${column.type.scale}`;
+          }
+          typeTag += ")";
+        }
+        break;
+      case "varchar":
+        typeTag += "varchar";
+        if (column.type.length) {
+          typeTag += `(${column.type.length})`;
+        }
+        break;
+      case "text":
+        typeTag += "text";
+        break;
+      case "boolean":
+        typeTag += "bool";
+        break;
+      case "date":
+        typeTag += "date";
+        break;
+      case "datetime":
+        typeTag += "datetime";
+        break;
+      case "json":
+        typeTag += "json";
+        break;
+      case "enum":
+        typeTag += "enum";
+        break;
+      default:
+        typeTag += "string";
+    }
+    tags.push(typeTag);
+    if (column.primaryKey) {
+      tags.push("primaryKey");
+    }
+    if (column.unique) {
+      tags.push("unique");
+    }
+    if (!column.nullable) {
+      tags.push("not null");
+    }
+    if (column.default) {
+      tags.push(`default:${column.default}`);
+    }
+    if (column.generated) {
+      tags.push("autoIncrement");
+    }
+    if (column.comment) {
+      tags.push(`comment:${column.comment}`);
+    }
+    return `\`gorm:"${tags.join(";")}" json:"${column.name}"\``;
+  }
+};
+
+// src/generator/xorm-generator.ts
+var XormGenerator = class extends BaseGenerator {
+  constructor(options = { language: "xorm" }) {
+    super();
+    this.options = options;
+  }
+  /**
+   * Generate type definitions for the entire database schema
+   */
+  generateDatabase(database) {
+    let result = `// Database: ${database.name}
+`;
+    result += `// Dialect: ${database.dialect}
+
+`;
+    if (this.options.namespace) {
+      result += `package ${this.options.namespace}
+
+`;
+    }
+    if (this.needsTimeImport(database)) {
+      result += `import "time"
+
+`;
+    }
+    for (const table of database.tables) {
+      result += this.generateTable(table);
+      result += "\n";
+    }
+    return result;
+  }
+  /**
+   * Generate type definition for a single table
+   */
+  generateTable(table) {
+    let result = `// ${table.name} table structure
+`;
+    result += `type ${this.formatTypeName(table.name)} struct {
+`;
+    for (const column of table.columns) {
+      result += this.generateColumn(column);
+    }
+    result += "}\n";
+    return result;
+  }
+  /**
+   * Generate column type definition
+   */
+  generateColumn(column) {
+    const fieldName = this.formatFieldName(column.name);
+    const typeName = this.mapSQLType(column.type);
+    const tag = this.generateXormTag(column);
+    let result = `	${fieldName} ${typeName} ${tag}`;
+    if (column.comment && this.options.generateComments !== false) {
+      result += ` // ${column.comment}`;
+    }
+    result += "\n";
+    return result;
+  }
+  /**
+   * Map SQL type to XORM type
+   */
+  mapSQLType(type) {
+    switch (type.kind) {
+      case "int":
+        return "int";
+      case "bigint":
+        return "int64";
+      case "float":
+        return "float64";
+      case "decimal":
+        return "float64";
+      case "varchar":
+      case "text":
+        return "string";
+      case "boolean":
+        return "bool";
+      case "date":
+      case "datetime":
+        return "time.Time";
+      case "json":
+        return "interface{}";
+      case "enum":
+        return "string";
+      default:
+        return "string";
+    }
+  }
+  /**
+   * Generate XORM struct tags
+   */
+  generateXormTag(column) {
+    const tags = [];
+    tags.push(`${column.name}`);
+    let typeTag = "";
+    switch (column.type.kind) {
+      case "int":
+        typeTag = "int";
+        if (column.type.length) {
+          typeTag += `(${column.type.length})`;
+        }
+        break;
+      case "bigint":
+        typeTag = "bigint";
+        if (column.type.length) {
+          typeTag += `(${column.type.length})`;
+        }
+        break;
+      case "float":
+        typeTag = "float";
+        if (column.type.precision) {
+          typeTag += `(${column.type.precision}`;
+          if (column.type.scale) {
+            typeTag += `,${column.type.scale}`;
+          }
+          typeTag += ")";
+        }
+        break;
+      case "decimal":
+        typeTag = "decimal";
+        if (column.type.precision) {
+          typeTag += `(${column.type.precision}`;
+          if (column.type.scale) {
+            typeTag += `,${column.type.scale}`;
+          }
+          typeTag += ")";
+        }
+        break;
+      case "varchar":
+        typeTag = "varchar";
+        if (column.type.length) {
+          typeTag += `(${column.type.length})`;
+        }
+        break;
+      case "text":
+        typeTag = "text";
+        break;
+      case "boolean":
+        typeTag = "bool";
+        break;
+      case "date":
+        typeTag = "date";
+        break;
+      case "datetime":
+        typeTag = "datetime";
+        break;
+      case "json":
+        typeTag = "json";
+        break;
+      case "enum":
+        typeTag = "enum";
+        break;
       default:
-        throw new Error(`Unsupported reader type: ${options.type}`);
+        typeTag = "string";
+    }
+    if (typeTag) {
+      tags.push(typeTag);
+    }
+    if (column.primaryKey) {
+      tags.push("pk");
     }
+    if (column.unique) {
+      tags.push("unique");
+    }
+    if (!column.nullable) {
+      tags.push("notnull");
+    }
+    if (column.default) {
+      tags.push(`default(${column.default})`);
+    }
+    if (column.generated) {
+      tags.push("autoincr");
+    }
+    if (column.comment) {
+      tags.push(`comment(${column.comment})`);
+    }
+    return `\`xorm:"${tags.join(" ")}" json:"${column.name}"\``;
   }
 };
+
+// src/generator/index.ts
+GeneratorFactory.register("typescript", TypeScriptGenerator);
+GeneratorFactory.register("go", GoGenerator);
+GeneratorFactory.register("gorm", GormGenerator);
+GeneratorFactory.register("xorm", XormGenerator);
+
+// src/generate.ts
+function generateCode(sql, options) {
+  const dbSchema = parseSQL(sql, {
+    dialect: options.dialect || "mysql",
+    dbName: options.dbName || "my_database"
+  });
+  const generatorOptions = {
+    language: options.language,
+    namespace: options.namespace,
+    generateComments: true
+  };
+  const generator = GeneratorFactory.createGenerator(
+    options.language,
+    generatorOptions
+  );
+  return generator.generateDatabase(dbSchema);
+}
 export {
-  AGenerator,
-  FileReader,
+  BaseGenerator,
   GeneratorFactory,
-  GolangGenerator,
+  GoGenerator,
   GormGenerator,
-  ReaderFactory,
   SQLParser,
-  StringReader,
   TypeScriptGenerator,
   XormGenerator,
   generateCode,