# know_anything_project

**Repository Path**: hany_code/know_anything_project

## Basic Information

- **Project Name**: know_anything_project
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 0
- **Created**: 2026-05-25
- **Last Updated**: 2026-05-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

# Framework Demo Collection

A comprehensive, standalone demo collection covering 17 frameworks across backend, frontend, and mobile development. Each demo implements core framework features with in-memory data, unit tests, Docker containerization, and documentation.

## Architecture Overview

```
Framework Demo Collection
├── Backend (8 frameworks)
│   ├── Python:  FastAPI, Flask, Django
│   ├── Go:      Gin, Echo, Fiber
│   └── Rust:    Actix-web, Axum, Rocket
├── Frontend (3 frameworks)
│   └── React, Vue, Angular
└── Mobile (3 frameworks)
    └── React Native, Flutter, Android (Kotlin)
```

## Table of Contents

- [Backend Demos](#backend-demos)
  - [Python](#python)
  - [Go](#go)
  - [Rust](#rust)
- [Frontend Demos](#frontend-demos)
- [Mobile Demos](#mobile-demos)
- [Quick Start](#quick-start)
- [Project Structure](#project-structure)

---

## Backend Demos

### Python

| Framework | Port | Path | Features | Tests |
|-----------|------|------|----------|-------|
| **FastAPI** | 8001 | `fastapi-demo/` | Path/Query params, Pydantic models, async CRUD, dependency injection, middleware, OpenAPI docs | 13 |
| **Flask** | 8002 | `flask-demo/` | Blueprint routing, Jinja2 templates, Flask-SQLAlchemy mock, session management, CORS | 23 |
| **Django** | 8003 | `django-demo/` | Django ORM mock, class-based views, URL routing, REST API, Django REST Framework | 18 |

### Go

| Framework | Port | Path | Features | Tests |
|-----------|------|------|----------|-------|
| **Gin** | 8004 | `gin-demo/` | Path/Query params, middleware, JSON validation, graceful shutdown, context propagation | 12 |
| **Echo** | 8005 | `echo-demo/` | Route groups, middleware, JSON binding, websocket, custom Binder, HDR middleware | 10 |
| **Fiber** | 8006 | `fiber-demo/` | Route params, Locals, JWT middleware, body parsing, CORS, limiter, helmet | 12 |

### Rust

| Framework | Port | Path | Features | Tests |
|-----------|------|------|----------|-------|
| **Actix-web** | 8007 | `actix-demo/` | State management, path extractors, JSON handling, middleware, CORS, JWT auth | 10 |
| **Axum** | 8008 | `axum-demo/` | State (Arc<Mutex<T>>), path/query/header extraction, middleware (CORS, auth), custom errors | 15 |
| **Rocket** | 8009 | `rocket-demo/` | Managed state, custom guards, fairings (logging, CORS), responder pattern, validators | 37 |

### Spring Ecosystem

| Framework | Ports | Path | Features | Tests |
|-----------|------|------|----------|-------|
| **Spring Boot** | 8080 | `springboot-demo/` | REST API, JPA mock, validation, actuator, profiles, exception handling | 10 |
| **Spring Cloud** | 8080-8888 | `springcloud-demo/` | Eureka registry, Config server, User/Order services, OpenFeign, Resilience4j circuit breaker, API Gateway | 22+ |

---

## Frontend Demos

| Framework | Path | Features | Tests |
|-----------|------|----------|-------|
| **React 19** | `react-demo/` | useState (Counter), useEffect (useFetch), Props, conditional rendering, list rendering (FlatList), forms, React Router 6, ErrorBoundary, context | 10 |
| **Vue 3** | `vue-demo/` | Composition API (ref/reactive/computed/watch), v-if/v-show/v-for/v-model, Props/Emit, lifecycle hooks, slots, Vue Router 4 | 5 |
| **Angular 19** | `angular-demo/` | Standalone components, signals, dependency injection, directives (ngIf/ngFor/ngClass), reactive forms, HTTP client simulation, lazy loading, custom pipes (truncate/exclamation) | 50+ |

---

## Mobile Demos

| Framework | Path | Features | Tests |
|-----------|------|----------|-------|
| **React Native** | `rn-demo/` | useState/useEffect, Props composition, Conditional rendering, FlatList, Form validation, Stack Navigator (3+ screens), StyleSheet flexbox | 10 |
| **Flutter** | `flutter-demo/` | StatefulWidget counter, StatelessWidget user card, Column/Row/Flex layouts, ListView.builder, Form with validation, Navigator 1.0 (3+ screens), SharedPreferences | 21 |
| **Android (Kotlin)** | `android-demo/` | Jetpack Compose, ViewModel + StateFlow, LazyColumn, Form validation, Navigation Compose, SharedPreferences, Hilt DI, Coroutines | 17 |

---

## Quick Start

### Build All Backend Demos (requires Docker)

```bash
# Build and start all backend services
docker-compose up --build

# Or run individual demos
cd fastapi-demo && docker build -t fastapi-demo . && docker run -p 8001:8000 fastapi-demo
```

### Run Backend Locally

**FastAPI:**
```bash
cd fastapi-demo && pip install -r requirements.txt && uvicorn app.main:app --reload --port 8000
```

**Flask:**
```bash
cd flask-demo && pip install -r requirements.txt && python -m flask run --port 5000
```

**Gin:**
```bash
cd gin-demo && go run cmd/server/main.go
```

**Actix-web:**
```bash
cd actix-demo && cargo run
```

### Run Frontend Demos

**React:**
```bash
cd react-demo && npm install && npm run dev
```

**Vue:**
```bash
cd vue-demo && npm install && npm run dev
```

**Angular:**
```bash
cd angular-demo && npm install && ng serve
```

### Run Mobile Demos

**React Native:**
```bash
cd rn-demo && npm install
# iOS
npx react-native run-ios
# Android
npx react-native run-android
```

**Flutter:**
```bash
cd flutter-demo && flutter pub get && flutter run
```

**Android (Kotlin):**
```bash
cd android-demo && ./gradlew assembleDebug
# APK: app/build/outputs/apk/debug/app-debug.apk
```

### Run Tests

```bash
# FastAPI
cd fastapi-demo && pytest

# Flask
cd flask-demo && pytest

# Gin
cd gin-demo && go test ./...

# Actix-web
cd actix-demo && cargo test

# React
cd react-demo && npm test

# Vue
cd vue-demo && npm test

# Angular
cd angular-demo && ng test

# Flutter
cd flutter-demo && flutter test

# Android
cd android-demo && ./gradlew test
```

---

## Project Structure

```
know_anything_project/
├── # Backend - Python
├── fastapi-demo/       FastAPI (Python async, Pydantic, OpenAPI)
├── flask-demo/          Flask (blueprints, Jinja2, SQLAlchemy mock)
├── django-demo/         Django (ORM mock, CBV, DRF)
│
├── # Backend - Go
├── gin-demo/            Gin (middleware, validation, graceful shutdown)
├── echo-demo/           Echo (route groups, websocket, HDR middleware)
├── fiber-demo/          Fiber (JWT, CORS, limiter, helmet)
│
├── # Backend - Rust
├── actix-demo/          Actix-web (async, actors, tokio)
├── axum-demo/           Axum (Tower ecosystem, typed routes)
├── rocket-demo/          Rocket (fairings, custom guards)
│
├── # Spring Ecosystem
├── springboot-demo/     Spring Boot (JPA mock, actuator, profiles)
├── springcloud-demo/    Spring Cloud (Eureka, Config, Feign, Resilience4j)
│
├── # Frontend
├── react-demo/           React 19 (hooks, Router 6, ErrorBoundary)
├── vue-demo/             Vue 3 (Composition API, Router 4)
├── angular-demo/         Angular 19 (signals, standalone, DI)
│
├── # Mobile
├── rn-demo/              React Native (hooks, navigation, flexbox)
├── flutter-demo/         Flutter (widgets, Navigator 1.0, SharedPreferences)
├── android-demo/         Android Kotlin (Compose, Hilt, Coroutines)
│
├── docker-compose.yml     All backend services
└── README.md              This file
```

---

## Key Design Decisions

- **In-memory data only** — no real databases or external API dependencies
- **Standalone demos** — each project is independent with its own `package.json`/`Cargo.toml`/`pubspec.yaml`/`build.gradle`
- **Docker for backends** — multi-stage builds for Rust/Go, `python:3.x-slim` for Python
- **Unit tests included** — every demo has test coverage (see table above)
- **No mobile APK build locally** — Android SDK not available in this environment; code is complete and ready to build with `gradlew assembleDebug`

---

## Notes

- Some demos skip local build/test runs due to unavailable toolchains (Docker Desktop, Node.js, Android SDK, Maven). Dockerfiles and build configs are written correctly and ready to use in a Docker-enabled Linux environment.
- Spring Cloud demo has its own internal `docker-compose.yml` in `springcloud-demo/` that wires all 5-6 microservice modules together.
- Rust demos use multi-stage Docker builds (`rust:latest` → `debian-slim`) for reproducible builds.