SchemaLang

Output: Multiple Targets

// Generated Player class with drop-in methods
class Player {
private:
    int64_t id;
    std::string username;
    int32_t score;
    std::optional<double> winRate;
public:
    // Standard getters/setters
    int64_t getId() const;
    void setUsername(const std::string& value);
    
    // JSON serialization (from JSON generator)
    json toJSON();
    void fromJSON(json j);
    
    // SQLite operations (from SQLite generator)
    bool SQLiteInsert(sqlite3* db);
};

// Generated SQLiteDB class with query builders
class SQLiteDB {
public:
    // Query builder for Player table
    auto SelectPlayer() -> SQLiteQueryBuilder<Player>;
    
    // Create all tables with migrations
    void connect();
};

// Real-world usage in an HTTP server:
auto players = db->SelectPlayer()
    .WhereEquals("score", "1000")
    .OrderBy("username")
    .Exec<Player>();

for (const auto& player : players) {
    json response = player->toJSON();
    send_json_response(response);
}

CREATE TABLE IF NOT EXISTS Player (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    username VARCHAR(255) NOT NULL UNIQUE,
    score INT NOT NULL,
    winRate DOUBLE,
    INDEX idx_username (username)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "integer",
      "description": "Player ID"
    },
    "username": {
      "type": "string",
      "description": "Player username"
    },
    "score": {
      "type": "integer",
      "description": "Player score"
    },
    "winRate": {
      "type": "number",
      "description": "Win percentage"
    }
  },
  "required": ["id", "username", "score"]
}

HTTP Server Using Generated Code

// HTTP GET /api/characters endpoint
void HTTPSession::handle_get_characters() {
    // Get user from auth token
    auto user_id = validate_session_token(token);
    
    // Use generated query builder
    auto query = db_manager_->SelectCharacter()
        .WhereEquals("is_npc", "0")
        .WhereEquals("owner_user_id", 
                     std::to_string(user_id));
    
    // Execute and get results
    auto characters = query.Exec<CharacterSchema>();
    
    // Use generated JSON serialization
    json response = json::array();
    for (const auto& char_ptr : characters) {
        if (char_ptr) {
            response.push_back(char_ptr->toJSON());
        }
    }
    
    send_json_response(response);
}

// HTTP POST /api/characters endpoint
void HTTPSession::handle_create_character() {
    json body = json::parse(req_.body());
    
    // Create using generated class
    auto character = std::make_shared<CharacterSchema>();
    character->fromJSON(body);  // Generated method
    character->setOwner_user_id(user_id);
    
    // Insert using generated method
    if (character->SQLiteInsert(db_manager_->getDB())) {
        send_json_response(character->toJSON(), 
                          http::status::created);
    }
}