Framework Overview

Oidis is a full-stack TypeScript framework for building enterprise web applications. It runs on Node.js with MongoDB on the backend and Bootstrap 5 in the browser, giving you a single language and a consistent set of patterns from database to UI.

What Makes Oidis Different

Unlike frameworks that focus on either the frontend or backend, Oidis covers the entire stack with a unified architecture:

• Single language — TypeScript everywhere, with shared models and utilities between frontend and backend
• Built-in RPC — The LiveContentProtocol (LCP) handles frontend-to-backend communication automatically via @Extern decorators
• Decorator-driven — Define models with @Entity/@Property, expose APIs with @Extern/@Route, map URLs with @Resolver
• MVC with conventions — The Page-Panel-Controller pattern provides a clear structure for every UI feature
• Enterprise-ready — Authentication, authorization, audit logging, Docker CI/CD, and soft-delete are built in

Concepts ahead

This overview introduces key concepts like BaseModel, @Entity, @Extern, and JSONP configuration. Each is covered in depth later — see Models, Decorators, and JSONP System.

Architecture at a Glance

Every Oidis application follows the same structure:

source/typescript/Io/Oidis/YourProject/
├── Models/                  # Backend models (@Entity + BaseModel<T>)
├── Utils/                   # Backend services (AuthManager, business logic)
├── HttpProcessor/Resolvers/ # Backend route handlers
├── Connectors/              # Backend external integrations
├── Gui/
│   ├── Models/              # Frontend models (mirrors of backend)
│   ├── Pages/               # Page layouts (tabs configuration)
│   ├── Panels/              # Panel views (HTML + component refs)
│   ├── Controllers/         # Panel controllers (business logic)
│   ├── Connectors/          # Frontend RPC connectors
│   ├── Stores/              # Singleton state stores
│   └── UserControls/        # Reusable UI components
├── Loader.ts                # Backend bootstrap
└── Gui/Loader.ts            # Frontend bootstrap

The root namespace contains backend code (Node.js). The Gui/ subdirectory contains frontend code (browser). Each side has its own Loader.ts entry point.

The Request Lifecycle

Here's what happens when a user interacts with an Oidis application:

1. Browser — User clicks a button bound via EventsBinding.SingleClick()
2. Frontend Connector — Controller calls connector.DoSomething(data) which internally uses asyncInvoke()
3. LCP Transport — Request travels over HTTP/WebSocket to /liveContent/
4. Backend Resolution — LiveContentResolver finds the @Extern method via reflection
5. Authorization — AuthManager.IsAuthorizedFor() checks the method permission before the method runs
6. Execution — Backend method runs (DB queries, business logic, external APIs)
7. Response — Result serialized and sent back to the frontend connector
8. UI Update — Controller updates panel components (tables, forms, toasts)

Technology Stack

Layer	Technology
Language	TypeScript (ES2022, NodeNext modules)
Backend Runtime	Node.js
Database	MongoDB (via Mongoose, abstracted by BaseModel)
Frontend UI	Bootstrap 5.3, custom SCSS themes
Build System	Oidis Builder (custom toolchain)
Package Format	JSONP configuration (package.conf.jsonp)
CI/CD	Docker containers, encrypted deployment
Version Control	Git (GitLab), conventional branching

Who Is This For

This documentation is written for TypeScript developers joining an Oidis project or evaluating the framework. You should be comfortable with:

• TypeScript classes, decorators, and async/await
• Basic Node.js and npm concepts
• HTML/CSS fundamentals (Bootstrap knowledge is a plus)
• MongoDB basics (documents, collections, queries)

You don't need prior experience with Oidis — that's what these docs are for.

How to Read These Docs

Getting started — new to Oidis, read in order:

1. Installation Guide — Set up your environment
2. Architecture Overview — Understand the big picture
3. Page-Panel-Controller — Learn the MVC pattern
4. Models Overview — Understand the data layer

Building features — hands-on development:

• GUI — Panels, data binding, tables, dialogs, user controls
• Decorators — @Entity, @Extern, @Route, @Resolver, @Partial
• Utilities — LogIt, StringUtils, ObjectValidator, JsonUtils, Convert, and more

Hub GUI:

• Hub GUI — Dashboard, SSO, tools menu, connectors, extension points

Build & deploy:

• Oidis Builder — CLI, tasks, configuration, build process, deployment
• Configuration — JSONP system, commons config, solutions

Standards & tooling:

• Conventions — Naming, formatting, file headers, JSDoc
• Guides — IDE setup, coding standards, version control, Claude Code integration

Advanced topics:

• Advanced — Docker & CI, testing, E2E Playwright, ForceCompile, Bootstrap theming

Getting Help

• Oidis Website: oidis.io — Project homepage
• GitLab: gitlab.com/oidis — Source code and issue tracking
• Contact: info@oidis.io — Questions and contributions

---

Claude Code Integration

If you use Claude Code for development, configure your project with a CLAUDE.md file and point it to your local clone of this wiki. See the Claude Code Integration guide for setup instructions and best practices.

---

See also: Architecture Overview | GUI Overview | Utilities Overview | Builder Overview