Quick Start

This guide introduces you to IOTA SDK’s core concepts and shows you how to build your first feature.

Core Concepts

Modules

IOTA SDK is organized into modules. Each module represents a business domain:

• Core - Users, authentication, roles
• Finance - Accounts, transactions, expenses
• Warehouse - Inventory, products, orders
• CRM - Customers, chats, relationships
• HRM - Employees, positions

Domain-Driven Design (DDD)

The SDK follows DDD principles with clear layer separation:

graph TD
    A[HTTP Request] --> B[Controller]
    B --> C[Service]
    C --> D[Domain Entity]
    D --> E[Repository]
    E --> F[(Database)]

Layer Responsibilities:

Multi-Tenancy

Every piece of data belongs to a tenant (organization). The SDK automatically:

• Isolates data between tenants
• Applies tenant filters to all queries
• Manages tenant-specific settings

Your First Module

Module Structure

A minimal module contains:

modules/mymodule/
├── component.go       # Component registration
├── links.go           # Navigation items
├── domain/            # Business entities
├── services/          # Business logic
├── presentation/      # Controllers & templates
└── permissions/       # RBAC constants

Module Registration

Components register themselves with the composition engine during startup:

1. Define the Component - Implement composition.Component
2. Build Declaratively - Add services with composition.Provide(...) and runtime slices with composition.Contribute...(...)
3. Compose Explicitly - Call engine.Register(yourComponent) and engine.Compile(...) for the capabilities your process needs

Key Registration Steps

When building a module, you’ll:

• Register Services - Business logic accessible through the composition container
• Register Controllers - HTTP handlers for routes
• Register Migrations - Database schema changes
• Register Permissions - RBAC for access control
• Register Navigation - Menu items for the UI

Understanding the Flow

Request Lifecycle

sequenceDiagram
    participant User
    participant Browser
    participant Controller
    participant Service
    participant Repository
    participant DB
    
    User->>Browser: Submit form
    Browser->>Controller: HTTP POST /resource
    Controller->>Controller: Validate DTO
    Controller->>Service: Call business method
    Service->>Domain: Create/Modify entity
    Service->>Repository: Persist changes
    Repository->>DB: Execute SQL
    DB-->>Repository: Return data
    Repository-->>Service: Return entity
    Service-->>Controller: Return result
    Controller-->>Browser: Redirect/Response

Data Flow

1. User interacts with UI (HTMX-enhanced forms)
2. Controller receives request, validates input
3. Service orchestrates business operations
4. Domain entities enforce business rules
5. Repository persists to database
6. Response returns to user (HTML or JSON)

Next Steps

Now that you understand the basics:

1. Review DBCTL Operations for policy-first DB workflows
2. Explore the Project Structure to see how the codebase is organized
3. Read about Architecture for deeper understanding of patterns
4. Review the Core Module to see a complete implementation

The SDK is designed to be intuitive once you understand the DDD layer separation. Every feature follows the same pattern, making it easy to extend and maintain.