OABuilder & OACodeGen

Model Specification in OABuilder

OABuilder is a visual modeling environment used to define the application model. It captures domain structure, metadata, and runtime behavior, that includes:

• Entity definitions: objects, properties, links (1:1, 1:M, M:M), calculated fields
• Behavioral metadata: methods, validations, triggers, visibility/editability rules
• Infrastructure mapping: database schema, security rules, REST access, User Interface

The model is persisted in a structured format, and consumed by other generators and tools.

Intermediate Representation (IR) in OACodeGen

OACodeGen transforms the model into an Intermediate Representation (IR) that serves as a normalized, enriched view of the application model.

This process is similar to how modern compilers work: OACodeGen takes the high-level model (analogous to source code) and compiles it into a normalized, semantically rich IR. This IR is then used as the foundation for generating software artifacts.

• Normalizes inheritance, property resolution, and link navigation paths
• Encodes generation context: targets, language, structure, and file layout
• Tracks object dependencies, graph traversal rules, and feature usage

This IR decouples the domain model from any specific technology or output format, making it reusable for multiple generators.

OACodeGen as Meta Code Generator

OACodeGen is architected as a meta-generator: a system for creating and executing custom code generators based on the IR.

• Developers can define generators for specific layers, stacks, or targets
• Template engines use IR metadata to emit code, markup, schema, or docs
• Generators can be layered or composed, supporting reuse and modularity

This meta-generative approach enables organizations to define domain-specific output formats and enforce architectural patterns consistently across projects.

Generate Code for Any Framework

OACodeGen is a "code generator for code generators", that can transform your high-level OA Model into fully working software for any framework, backend, or frontend platform.

This enables seamless integration with your existing stack and allows you to explore new ones without rewriting your business logic. The OA Model becomes a true abstraction layer — portable, maintainable, and framework-agnostic.

There’s something uniquely powerful about designing a model in OABuilder and instantly seeing it come to life as working software — tailored to your chosen language or framework. With a single source of truth, you can watch your domain model generate and then run your model — all without writing repetitive boilerplate. It's software that is building itself, adapting to your stack while preserving the integrity of your design.

OABuilder’s current Code Generators

OABuilder includes a suite of built-in generators that consume the IR and output structured code across the stack:

• OAObjects: Model classes with full metadata support (identity, state, callbacks)
• Desktop UI: Java JFC/Swing based client or client-server UIs using OA-JFC library of components.
• OATemplate: A full template project that is used as an overlay and fill-out for code generation. It includes lifecycle logic, multi-user sync, services, and helper utilities.
• OpenAPI: Generates OpenAPI definitions and controllers from model metadata
• Web UI: HTML5 (SPA, SSR) UIs based on Bootstrap & OA-Web components
• Database Schema: DDL & DML scripts for creating and updating databases
• Spring Integration: Repositories, Controllers, and DAOs for Spring Boot apps
• Unit Tests: Model-level and service-level test code scaffolding
• Test Data Generator: Synthetic data creation based on model rules and object graph paths
• More to come: suport for other frameworks, languages and mobile

These generators target core OA runtime components such as:

• OAObject – base class for model entities
• Hub<OAObject> – observable, filterable object collections
• OADataSource – pluggable data access abstraction
• OA-JFC component set – UI components bound directly to object graph
• OA-Web component set – SPA/SSR/HTML5/Bootstrap components with binding and sync

This integration ensures that generated applications can operate as real-time object graphs — observing changes, resolving relationships, persisting state, and synchronizing across distributed environments.

The UI Code Generation IR

A noted capability of OACodeGen is its ability to generate full-featured, commercial-grade UIs directly from the model — without relying on manual layout tools or drag-and-drop builders.

The IR for UI generation is organized in a two-stage process:

• Stage 1 – Logical UI Blocks: Generates abstract layout components (forms, tables, panes) based on the model’s object structure, relationships, and metadata (e.g., visibility, required fields, constraints)
• Stage 2 – Target UI Translation: Transforms logical UI blocks into concrete UI code for the selected target platform — such as OA-JFC/Swing, OA-Web (HTML5/Bootstrap) — applying theme, layout, and component bindings

This approach allows UI generation to adapt easily across different platforms while ensuring that UI behavior and logic remain tightly coupled with the model. This is what allows OA to target any third party UI framework and component set. Examples include: React, Vue, Angular, Material UI, and others.

Full Project Adaptation Using OATemplate project files

OACodeGen can take a full generic application project — such as OATemplate — and adapt it to any modeled domain. OATemplate includes prebuilt code, services, components, and configuration files.

OACodeGen analyzes the model and uses the IR to dynamically insert, customize, and adjust the template project to align with the target domain. This includes renaming classes, injecting model-specific logic, and configuring sync, services, and UI bindings automatically.

This enables rapid application assembly by reusing and customizing proven, production-ready project structures.

Iterative Code Generation

OACodeGen is designed to support iterative development. As the model evolves, developers can rerun the code generators to regenerate application code layers without affecting custom modifications.

The generated code follows a modular pattern where base classes and generated files are separated from developer-authored logic. This separation allows repeated regeneration after model changes — ensuring model-to-code alignment while preserving any custom business logic or extensions.