Unify/Readme.md

# Unify Developer Manual

### Build full applications with a single, unified codebase.

Unify is a full-stack application framework designed to remove the accidental complexity of modern web development. Instead of hand-wiring HTTP requests, state management, SQL queries, UI updates, permissions, and caching — Unify turns each **domain object** into a **live application object** that exists simultaneously on the server and client.

You write your application *once*.
Unify takes care of syncing it everywhere it needs to be.

---

## Why Unify?

Most web apps are assembled from disconnected technologies:
React + REST + ORM + SQL + State Manager + WebSockets + UI Framework + Access Control…

Each layer requires boilerplate to keep everything in sync:

* serialize → send → parse → update → re-render → validate permissions
* write SQL + write endpoints + write frontend state logic for the same entity

Unify eliminates these seams.

> **One class = data + logic + UI + permissions + real-time behavior**

The framework:

* turns your class into a database table (server)
* generates UI components from that class (client)
* syncs all changes via a structured WebSocket protocol
* applies permissions automatically based on user role
* integrates filtering, joins, pagination at the SQL level
* caches and updates only changed fields

You focus on the domain model.
Unify handles the rest.

---


### Why Unify Is AI-Optimized

Unify applications are self-describing graphs.
The object structure defines:

UI layout

Backend relationships

Permissions

Sync rules

Navigation

A human developer may lose track of where objects live in the graph.

But AI can:

infer full graph topology

find optimal traversal paths

safely modify relationships

rewrite UI interactions without breaking structure

This means Unify enables:

AI-generated UI actions

AI-guided refactoring

AI-assisted CRUD creation

Automated join discovery

Intelligent navigation handling



## What does development feel like?

Example: define a `News` class

```javascript
export default class news extends table {
    title = new text("Title");
    body  = new text("Message");
    price = new number("Price");

    permission() {
        this.allow(groups.visitor, "READ");
        this.allow(groups.admin, "WRITE");
    }
}
```

And a list view:

```javascript
export default class newsListTable extends gridView {
    header = new newsListTableHeader();
    body   = new newsListTableBody(newsListItem, new collection(news));
}
```

You don’t manually:

* write SQL queries
* define REST endpoints
* build WebSocket handlers
* implement CRUD actions
* code client state syncing
* generate UI markup

Unify does all of that from your object graph.

---

## Architecture: What’s inside

| Layer                  | Responsibility                             |
| ---------------------- | ------------------------------------------ |
| **Domain Objects**     | Single class shared by server + client     |
| **Render Collections** | Auto-loaded lists with pagination + search |
| **Table Controller**   | Database operations + joins                |
| **Socket Controller**  | Real-time communication layer              |
| **UI Runtime**         | Live elements, animations, events          |
| **Permission Engine**  | Automatic security per object/action       |

This creates a **Behavioral ORM**:

* objects contain their own server logic
* queries are automatically composed from UI actions
* users see only what they are permitted to interact with

---

## Why does this matter?

Modern software complexity isn’t caused by features — it’s caused by **glue code**.
For every feature, you implement it 3–6 times: backend models, database schema, API routes, frontend state, UI bindings…

Unify collapses those layers into **one source of truth**.

The result:

* drastically fewer bugs
* ultra-fast iteration cycles
* real-time UX without extra work
* secure-by-construction access rules
* smaller teams can ship full apps

---

## Current focus

The goal of this release is to give developers a working demonstration of:

* full-stack sync with no REST boilerplate
* real-time UI updates
* built-in permissions
* SQL searching / joining from the UI
* cross-platform dynamic UI rendering (Windows / Mac / Web)

The included **News Application** shows:

* search/filter with SQL operators (`LIKE`, `OR`, `>=`)
* item detail transitions + CRUD dialogs
* login + role-based access
* pagination
* dynamic view/layout behavior

---

## Who is Unify for?

✔ Full-stack developers
✔ Product developers who hate glue code
✔ Teams who want to ship faster
✔ Anyone who believes software should be simpler

---

## Status

Unify is actively developed and evolving.
Contributions, feedback, and architectural discussion are welcome.

> Help define the future of unified application development.

---

## Get started

The source includes:

* `unify_source/` – the core framework
* `unify_application/` – working reference application

Clone and run the app to see the architecture in motion:

```
git clone https://.../unify
cd unify_application
npm install
npm start
```

Documentation and complete API references are coming.