Update docs.

Author: m0ver

en/SUMMARY.md

@@ -9,6 +9,7 @@
 * [Database Integration](database.md)
 * [Advanced Features](advanced-features.md)
 * [Best Practices](best-practices.md)
+* [What's New in 1.7.23](whats-new-1.7.23.md)
 
 ## API Reference
 * [Action API](api/action.md)

en/cli-applications.md

@@ -221,152 +221,31 @@ public String exportUsers() {
 
 ## Creating Custom Commands
 
-### POJO Generator Example
+### Built-in POJO Generator
 
-```java
-@Action(
-    value = "generate-pojo",
-    description = "Generate POJO class from database table",
-    options = {
-        @Argument(name = "table", description = "Database table name"),
-        @Argument(name = "package", description = "Java package name"),
-        @Argument(name = "output", description = "Output directory")
-    },
-    mode = Action.Mode.CLI
-)
-public String generatePojo() {
-    String table = getContext().getAttribute("--table");
-    String packageName = getContext().getAttribute("--package", "com.example.model");
-    String output = getContext().getAttribute("--output", "./src/main/java");
-    
-    if (table == null) {
-        return "Please provide a table name with --table";
-    }
-    
-    try {
-        Repository repository = Type.MySQL.createRepository();
-        repository.connect(getConfiguration());
-        
-        // Get table metadata
-        List<Row> columns = repository.query(
-            "SELECT COLUMN_NAME, DATA_TYPE, IS_NULLABLE " +
-            "FROM INFORMATION_SCHEMA.COLUMNS " +
-            "WHERE TABLE_NAME = ?", table);
-        
-        if (columns.isEmpty()) {
-            return "Table not found or has no columns: " + table;
-        }
-        
-        // Generate class name (convert snake_case to CamelCase)
-        String className = Arrays.stream(table.split("_"))
-            .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1).toLowerCase())
-            .collect(Collectors.joining());
-        
-        // Generate Java code
-        StringBuilder code = new StringBuilder();
-        code.append("package ").append(packageName).append(";\n\n");
-        code.append("public class ").append(className).append(" {\n\n");
-        
-        // Generate fields
-        for (Row column : columns) {
-            String columnName = column.getString("COLUMN_NAME");
-            String dataType = column.getString("DATA_TYPE");
-            String javaType = mapSqlTypeToJava(dataType);
-            String fieldName = toCamelCase(columnName);
-            
-            code.append("    private ").append(javaType).append(" ").append(fieldName).append(";\n");
-        }
-        
-        code.append("\n");
-        
-        // Generate getters and setters
-        for (Row column : columns) {
-            String columnName = column.getString("COLUMN_NAME");
-            String dataType = column.getString("DATA_TYPE");
-            String javaType = mapSqlTypeToJava(dataType);
-            String fieldName = toCamelCase(columnName);
-            String capitalizedFieldName = fieldName.substring(0, 1).toUpperCase() + fieldName.substring(1);
-            
-            // Getter
-            code.append("    public ").append(javaType).append(" get").append(capitalizedFieldName).append("() {\n");
-            code.append("        return ").append(fieldName).append(";\n");
-            code.append("    }\n\n");
-            
-            // Setter
-            code.append("    public void set").append(capitalizedFieldName).append("(").append(javaType).append(" ").append(fieldName).append(") {\n");
-            code.append("        this.").append(fieldName).append(" = ").append(fieldName).append(";\n");
-            code.append("    }\n\n");
-        }
-        
-        code.append("}");
-        
-        // Write to file
-        String packagePath = packageName.replace('.', '/');
-        Path outputPath = Paths.get(output, packagePath, className + ".java");
-        Files.createDirectories(outputPath.getParent());
-        Files.write(outputPath, code.toString().getBytes());
-        
-        return "Generated " + className + ".java in " + outputPath;
-    } catch (Exception e) {
-        return "Error generating POJO: " + e.getMessage();
-    }
-}
+Tinystruct includes a built-in `generate` command that creates POJO classes and XML mapping files directly from your database schema. It automatically detects Java types from column definitions and adds the required import statements — no manual import specification is needed.
 
-private String toCamelCase(String snakeCase) {
-    StringBuilder result = new StringBuilder();
-    boolean nextUpper = false;
-    
-    for (char c : snakeCase.toCharArray()) {
-        if (c == '_') {
-            nextUpper = true;
-        } else {
-            if (nextUpper) {
-                result.append(Character.toUpperCase(c));
-                nextUpper = false;
-            } else {
-                result.append(Character.toLowerCase(c));
-            }
-        }
-    }
-    
-    return result.toString();
-}
+```bash
+# Interactive mode — prompts for table names and output path
+bin/dispatcher generate
 
-private String mapSqlTypeToJava(String sqlType) {
-    switch (sqlType.toUpperCase()) {
-        case "VARCHAR":
-        case "CHAR":
-        case "TEXT":
-            return "String";
-        case "INT":
-        case "SMALLINT":
-        case "TINYINT":
-            return "Integer";
-        case "BIGINT":
-            return "Long";
-        case "DECIMAL":
-        case "NUMERIC":
-            return "BigDecimal";
-        case "FLOAT":
-            return "Float";
-        case "DOUBLE":
-            return "Double";
-        case "BOOLEAN":
-        case "BIT":
-            return "Boolean";
-        case "DATE":
-            return "LocalDate";
-        case "TIME":
-            return "LocalTime";
-        case "DATETIME":
-        case "TIMESTAMP":
-            return "LocalDateTime";
-        default:
-            return "Object";
-    }
-}
+# Non-interactive — specify tables directly
+bin/dispatcher generate --tables users
+
+# Multiple tables (semicolon-delimited)
+bin/dispatcher generate --tables "users;orders;products"
 ```
 
+The generator:
+- Supports **MySQL**, **MSSQL**, **SQLite**, and **H2** databases
+- **Automatically imports** `java.time.LocalDateTime`, `java.util.Date`, `java.sql.Timestamp`, and `java.sql.Time` based on column types
+- Generates both the **Java POJO** and the **XML mapping file**
+- Auto-detects the project's base package from your source tree
+- Singularizes table names for class names (e.g. `users` → `User`)
+
+For full details and generated code examples, see the [Database Integration — Built-in POJO Generator](database.md#built-in-pojo-generator) section.
+
+
 ## Best Practices
 
 1. **Provide Clear Help**: Always include descriptive help text for your commands.

en/database.md

@@ -576,6 +576,166 @@ In the tinystruct framework, there are distinct methods for different database o
 
 For clarity and precise control, it's recommended to use `append()` for inserts and `update()` for updates rather than relying on `save()`.
 
+## Built-in POJO Generator
+
+Tinystruct includes a built-in code generator that creates POJO classes and XML mapping files directly from your database schema. The generator supports **MySQL**, **MSSQL**, **SQLite**, and **H2** databases.
+
+### Running the Generator
+
+Use the `generate` CLI command to invoke the generator:
+
+```bash
+# Interactive mode — the generator will prompt for table names and output path
+bin/dispatcher generate
+
+# Non-interactive — specify tables directly
+bin/dispatcher generate --tables users
+
+# Multiple tables at once (semicolon-delimited)
+bin/dispatcher generate --tables "users;orders;products"
+```
+
+The interactive prompts will ask for:
+1. **Table name(s)** — semicolon-delimited (e.g. `users;orders`)
+2. **Base path** — where to place Java files (default: auto-detected from your project's package structure)
+
+### Automatic Package Imports
+
+The generator **automatically detects** the Java types required by your table columns and adds the correct import statements to the generated POJO. You do not need to specify any packages manually.
+
+The following type mappings are handled automatically:
+
+| SQL Column Type                        | Java Type         | Import                      |
+|----------------------------------------|-------------------|-----------------------------|
+| `DATETIME`, `TIMESTAMP`, `DATETIME2`   | `LocalDateTime`   | `java.time.LocalDateTime`   |
+| `DATE`                                 | `Date`            | `java.util.Date`            |
+| `TIMESTAMP` (explicit)                 | `Timestamp`       | `java.sql.Timestamp`        |
+| `TIME`                                 | `Time`            | `java.sql.Time`             |
+| `VARCHAR`, `CHAR`, `TEXT`              | `String`          | *(built-in)*                |
+| `INT`, `SMALLINT`, `TINYINT`           | `int`             | *(built-in)*                |
+| `BIGINT`                               | `long`            | *(built-in)*                |
+| `FLOAT`                                | `float`           | *(built-in)*                |
+| `DOUBLE`                               | `double`          | *(built-in)*                |
+| `BLOB`, `BINARY`, `VARBINARY`          | `byte[]`          | *(built-in)*                |
+
+### Generated Output
+
+For each table, the generator produces two files:
+
+1. **Java POJO** — e.g. `src/main/java/com/example/objects/User.java`
+2. **XML Mapping** — e.g. `src/main/resources/com/example/objects/User.map.xml`
+
+#### Example: Generated POJO
+
+For a table `users` with columns `id INT AUTO_INCREMENT`, `username VARCHAR(50)`, `email VARCHAR(100)`, `created_at DATETIME`:
+
+```java
+package com.example.objects;
+
+import java.io.Serializable;
+import java.time.LocalDateTime;
+import org.tinystruct.data.component.AbstractData;
+import org.tinystruct.data.component.Row;
+
+public class User extends AbstractData implements Serializable {
+    private static final long serialVersionUID = ...L;
+    private String username;
+    private String email;
+    private LocalDateTime createdAt;
+
+    public Integer getId() {
+        return Integer.parseInt(this.Id.toString());
+    }
+
+    public void setUsername(String username) {
+        this.username = this.setFieldAsString("username", username);
+    }
+
+    public String getUsername() {
+        return this.username;
+    }
+
+    public void setEmail(String email) {
+        this.email = this.setFieldAsString("email", email);
+    }
+
+    public String getEmail() {
+        return this.email;
+    }
+
+    public void setCreatedAt(LocalDateTime createdAt) {
+        this.createdAt = this.setFieldAsLocalDateTime("createdAt", createdAt);
+    }
+
+    public LocalDateTime getCreatedAt() {
+        return this.createdAt;
+    }
+
+    @Override
+    public void setData(Row row) {
+        if(row.getFieldInfo("id") != null)
+            this.setId(row.getFieldInfo("id").intValue());
+        if(row.getFieldInfo("username") != null)
+            this.setUsername(row.getFieldInfo("username").stringValue());
+        if(row.getFieldInfo("email") != null)
+            this.setEmail(row.getFieldInfo("email").stringValue());
+        if(row.getFieldInfo("created_at") != null)
+            this.setCreatedAt(row.getFieldInfo("created_at").localDateTimeValue());
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder buffer = new StringBuilder();
+        buffer.append("{");
+        buffer.append("\"Id\":" + this.getId());
+        buffer.append(",\"username\":\"" + this.getUsername() + "\"");
+        buffer.append(",\"email\":\"" + this.getEmail() + "\"");
+        buffer.append(",\"createdAt\":\"" + this.getCreatedAt() + "\"");
+        buffer.append("}");
+        return buffer.toString();
+    }
+}
+```
+
+#### Example: Generated XML Mapping
+
+```xml
+<?xml version="1.0" encoding="UTF-8"?>
+<mapping>
+    <class name="User" table="users">
+        <id name="Id" column="id" increment="true" generate="false" length="11" type="INT"/>
+        <property name="username" column="username" length="50" type="VARCHAR"/>
+        <property name="email" column="email" length="100" type="VARCHAR"/>
+        <property name="createdAt" column="created_at" length="0" type="DATETIME"/>
+    </class>
+</mapping>
+```
+
+### Using the Generated Code
+
+The generated classes extend `AbstractData`, so they integrate directly with tinystruct's ORM:
+
+```java
+// Create
+User user = new User();
+user.setUsername("john");
+user.setEmail("john@example.com");
+user.setCreatedAt(LocalDateTime.now());
+user.append();
+
+// Read
+User found = new User();
+found.setId(1);
+found.findOneById();
+
+// Update
+found.setEmail("newemail@example.com");
+found.update();
+
+// Delete
+found.delete();
+```
+
 ## Best Practices
 
 1. **Connection Management**: Always close your database connections when done.