novalang 2.2.6

A modern programming language with Spring Boot-style application framework and automatic database table creation

NovaLang 🚀 - Programming Language with Spring Boot-Style API Templates

NovaLang is an experimental programming language with Spring Boot-style syntax and annotations. It focuses on rapid backend API development with familiar Java/Spring Boot patterns.

🎉 NEW in v2.2.5: Clean API Templates

• ✅ Clean API Templates: Minimal Spring Boot-style server foundation
• ✅ Spring Boot-Style Annotations: @Service, @RestController, @Entity support
• ✅ Simple Project Structure: ApplicationConfig + HealthController base
• ✅ IntelliJ Support: IDE recognition for .nova files
• ✅ CLI Tool: Project generation and basic tooling

🌟 Current Features

✅ What Actually Works

• Project Templates: Generate Spring Boot-style API projects
• CLI Tool: Create, build, and run NovaLang projects
• Annotation System: Database and REST annotations (@Entity, @Table, @Column, @RestController)
• SQL Schema Generation: Auto-generate CREATE TABLE statements from annotations
• Lexer: Tokenize NovaLang source code
• Basic Interpreter: Execute simple NovaLang programs

🚧 In Development

• Full Parser: Complete AST generation (partial implementation)
• Type System: Static type checking and inference
• Runtime: Variable scoping, function execution, class instantiation
• Database Connectivity: Actual connection to databases (currently only generates SQL)
• Multi-target Compilation: Compile to Java, TypeScript, Python

📋 Development Tools

• CLI Tool: Project lifecycle management (nova create, nova run)
• Lexer: Full tokenization with 400+ token types
• Annotation Processor: Parse and process database/REST annotations
• Template System: Generate clean API project structures

🚀 Quick Start

Installation

# Install NovaLang
pip install novalang

Create Your First API Project

# Create a new API project with clean Spring Boot-style template
nova create my-backend --template api

# Navigate to project
cd my-backend

# Run the application
cd ..
python interpreter.py my-backend/src/main.nova

Example NovaLang Code

// Clean Spring Boot-style API
@Configuration
class ApplicationConfig {
    function getDatabaseConfig() {
        return {
            host: "localhost",
            port: 3306,
            database: "my_db"
        }
    }
}

@RestController
class HealthController {
    @GetMapping("/health")
    function health() {
        return {
            status: "UP",
            timestamp: new Date()
        }
    }
}

// Database Entity Example
@DatabaseEntity
@Table(name: "users")
class User {
    @PrimaryKey
    @AutoIncrement
    @Column(name: "id", type: "BIGINT")
    let id: number = 0
    
    @Column(name: "name", type: "VARCHAR", length: 50)
    let name: string = ""
}
@Document(collection: "products")
class Product {
    @Id
    private id: String
    
    @Field("name")
    @Indexed
    private name: String
    
    @Field("tags")
    private tags: List<String>
}

Graph Databases

@Neo4j
@Node("Person")
class Person {
    @Id
    private id: String
    
    @Property("name")
    private name: String
    
    @Relationship(type: "KNOWS", direction: "OUTGOING")
    private friends: List<Person>
}

Time Series Databases

@InfluxDB
@Measurement("sensor_data")
class SensorReading {
    @Time
    private timestamp: Instant
    
    @Tag("sensor_id")
    private sensorId: String
    
    @Field("temperature")
    private temperature: Double
}

Vector Databases (AI/ML)

</code></pre>
<h3>What Gets Generated</h3>
<p>When you create an API project, NovaLang generates:</p>
<ul>
<li><strong>ApplicationConfig</strong>: Configuration management class</li>
<li><strong>HealthController</strong>: Basic health check endpoints</li>
<li><strong>Main Application</strong>: Spring Boot-style entry point</li>
<li><strong>Project Structure</strong>: src/, tests/, dist/ folders</li>
</ul>
<p><strong>Note</strong>: NovaLang currently generates SQL schemas but does <strong>not</strong> automatically create or connect to databases. You need to manually set up your database and execute the generated SQL.</p>
<h2>🏗️ Architecture</h2>
<p>NovaLang current architecture:</p>
<pre><code>NovaLang
├── Lexer: Tokenization with 400+ token types
├── Parser: AST generation (partial implementation)  
├── Interpreter: Execute basic .nova programs
├── Annotation Processor: Parse @Entity, @Table, @Column annotations
├── SQL Generator: Create TABLE statements from annotations
└── CLI: Project creation and template generation

📊 How It Works

1. Write NovaLang Code with Annotations

@DatabaseEntity
@Table(name: "products")
class Product {
    @PrimaryKey
    @Column(name: "id", type: "BIGINT")
    let id: number = 0
    
    @Column(name: "name", type: "VARCHAR", length: 100)
    let name: string = ""
}

2. Run Through Interpreter

python interpreter.py your_file.nova

3. Get Generated SQL

CREATE TABLE products (
    id BIGINT PRIMARY KEY,
    name VARCHAR(100)
);

4. Manually Create Database

You must manually:

• Install database (MySQL, PostgreSQL, etc.)
• Create the database
• Execute the generated SQL statements
• Parallel Processing: Concurrent database operations
• Memory Optimization: Zero-copy operations where possible

🧪 Testing

@Test
class UserServiceTest {
    @Mock
    private userRepository: UserRepository
    
    @InjectMocks  
    private userService: UserService
    
    @Test
    public testCreateUser() {
        // Given
        let user = User(email: "[e-mail]")
        
        // When
        let result = userService.createUser(user)
        
        // Then
        assert result.isSuccess()
        assert result.get().id != null
    }
}

📚 Documentation

• Language Reference: Complete language syntax
• Database Guide: Database integration examples
• API Documentation: Complete API reference
• Examples: Real-world examples and tutorials

🤝 Contributing

Contributions welcome! NovaLang is an experimental project under active development.

Development Roadmap

• Complete parser implementation
• Full type system with type checking
• Actual database connectivity (currently only generates SQL)
• Multi-target compilation (Java, TypeScript, Python)
• Runtime with proper scoping and execution
• Comprehensive test suite
• REPL/interactive mode
• Package manager
• Standard library

📄 License

NovaLang is released under the MIT License.

🎯 Project Status

NovaLang is an experimental programming language in early development:

• ✅ Working: Project templates, SQL generation, basic interpreter, CLI tool
• 🚧 In Progress: Full parser, type system, runtime execution
• 📋 Planned: Database connectivity, multi-target compilation, standard library

Current Use Case: Rapid API project scaffolding with Spring Boot-style patterns

---

Made with ❤️ by Martin Maboya

NovaLang - Experimental Spring Boot-Style Programming Language 🚀