roaauto/docs/PLAN.md

Plan: ROA AUTO SaaS - Proiect Nou Separat

Context

Marius (ROMFAST SRL, Constanta) construieste un SaaS pentru service-uri auto mici si vulcanizari din Romania. Serverul initial e pe Proxmox la birou (nu VPS cloud), deci aplicatia trebuie sa functioneze si cand serverul e offline. Cand proiectul se autosustine financiar, se muta pe VPS cloud.

Exista un prototip in roa2web/roa-auto-mobile/ (Ionic Vue + SQLite server, single-tenant, fara auth) - folosit doar ca referinta conceptuala. Proiect nou de la zero, repository git separat.

---

Decizii Confirmate

Decizie	Valoare
Nume proiect	roaauto
Director	E:\proiecte\roaauto\
Git remote	gitea.romfast.ro:marius/roaauto
Domeniu	roaauto.romfast.ro
CSS framework	Tailwind CSS
Cod existent	De la zero (prototip doar referinta)
DB server	libSQL (fisier, in-process cu FastAPI)
DB browser	wa-sqlite (SQLite WASM)
Sync	Custom simplu (timestamp-based)
Offline	Da - reads + writes locale, sync cand e net

---

Arhitectura

[Browser]                                  [Server Proxmox / VPS]
┌─────────────────────┐                   ┌──────────────────────┐
│ Vue 3 PWA           │                   │ FastAPI              │
│ wa-sqlite (WASM)    │  ◄──── sync ────► │ libSQL (fisier)      │
│  └── OPFS storage   │                   │  └── roaauto.db      │
│  └── _sync_queue    │                   │                      │
│  └── ALL reads local│                   │ WeasyPrint (PDF)     │
│  └── writes instant │                   │ SMSAPI.ro (SMS)      │
│                     │                   │ JWT auth             │
│ Service Worker      │                   │                      │
│  └── app shell cache│                   │ Cloudflare Tunnel    │
└─────────────────────┘                   └──────────────────────┘

Cum functioneaza sync-ul

Initial sync (la login):

GET /api/sync/full?tables=orders,order_lines,vehicles,catalog_*
  → Server returneaza toate datele tenant-ului
  → Client INSERT-eaza in wa-sqlite local

Write (offline OK):

1. User creeaza comanda
2. INSERT in wa-sqlite local (instant, UUID generat client-side)
3. INSERT in _sync_queue (table, id, operation, data, timestamp)
4. Daca online: POST /api/sync/push → server valideaza → INSERT in libSQL
5. Daca offline: queue asteapta → sync la reconectare

Incremental sync (periodic, cand e online):

GET /api/sync/changes?since=2026-03-13T10:00:00
  → Server returneaza doar randurile modificate dupa timestamp
  → Client UPSERT in wa-sqlite local

Conflict resolution: Server wins (last-write-wins). Simplu, predictibil.

De ce libSQL pe server (nu PostgreSQL)

• Un fisier (roaauto.db) - nu un server/container separat
• In-process - FastAPI acceseaza direct, zero overhead retea
• Replication built-in - backup = copie fisier sau libSQL replication
• Schema identica cu wa-sqlite din browser (ambele SQLite)
• Resurse minime - perfect pentru Proxmox la birou
• Migrare la PostgreSQL cand cresc cerintele (change connection string + fix SQL specifics)

Limitari acceptate:

• Write concurrency: un writer la un moment dat (WAL mode). OK pentru <50 useri.
• ALTER TABLE limitat: Alembic batch operations rezolva asta.
• No RLS: izolare multi-tenant application-level (WHERE tenant_id = ?).

---

Tech Stack

Layer	Tehnologie	De ce
Backend	FastAPI + SQLAlchemy 2.0 + Alembic	Known territory
DB server	libSQL (via aiosqlite dialect)	Fisier, in-process, replication
DB browser	wa-sqlite (@journeyapps/wa-sqlite)	SQLite WASM, OPFS persistence
Sync	Custom (timestamp-based push/pull)	Simplu, fara dependente extra
Auth	python-jose + passlib (bcrypt)	JWT 30 zile, offline valid
PDF	WeasyPrint	Server-side, diacritice ROM OK
SMS	SMSAPI.ro	Provider romanesc, REST API
Frontend	Vue 3 + Tailwind CSS 4	Responsive, utility-first
State	Pinia + reactive SQL queries	Local-first
PWA	vite-plugin-pwa	App shell cache, install prompt
Build	Vite 6	Fast
Deploy	Docker (single container) + Dokploy + Cloudflare Tunnel	Self-hosted Proxmox
Git	Gitea (gitea.romfast.ro)	Self-hosted

---

Structura Proiect

E:\proiecte\roaauto\
├── docker-compose.yml           # Backend (FastAPI + libSQL) + frontend build
├── docker-compose.dev.yml
├── Makefile                     # make dev, make migrate, make seed, make backup
├── .env.example
│
├── backend/
│   ├── Dockerfile
│   ├── requirements.txt
│   ├── alembic.ini
│   ├── alembic/versions/
│   ├── app/
│   │   ├── main.py              # FastAPI + lifespan
│   │   ├── config.py            # Settings din env
│   │   ├── deps.py              # get_db, get_current_user, get_tenant_id
│   │   │
│   │   ├── auth/
│   │   │   ├── router.py        # register, login, refresh
│   │   │   ├── service.py       # JWT 30 zile, bcrypt, trial logic
│   │   │   └── schemas.py
│   │   │
│   │   ├── sync/
│   │   │   ├── router.py        # GET /sync/full, GET /sync/changes, POST /sync/push
│   │   │   └── service.py       # Sync logic, conflict resolution
│   │   │
│   │   ├── tenants/             # settings, subscription
│   │   ├── users/               # invite, list, deactivate
│   │   ├── vehicles/            # CRUD
│   │   ├── orders/              # CRUD + workflow
│   │   │   ├── router.py
│   │   │   ├── service.py       # DRAFT->VALIDAT->FACTURAT, recalc totals
│   │   │   └── schemas.py
│   │   ├── invoices/            # create from order
│   │   ├── catalog/             # nomenclatures
│   │   ├── appointments/        # CRUD
│   │   ├── client_portal/       # GET /p/{token} (public, no auth)
│   │   ├── sms/                 # SMSAPI.ro
│   │   ├── pdf/
│   │   │   ├── service.py       # WeasyPrint
│   │   │   └── templates/       # deviz.html, factura.html
│   │   │
│   │   └── db/
│   │       ├── base.py          # SQLAlchemy Base, UUID mixin, TenantMixin
│   │       ├── session.py       # libSQL/aiosqlite engine + session
│   │       └── models/          # tenant, user, vehicle, order, etc.
│   │
│   ├── data/                    # libSQL database file(s)
│   │   └── .gitkeep
│   └── tests/
│
├── frontend/
│   ├── Dockerfile + nginx.conf
│   ├── package.json
│   ├── vite.config.js
│   ├── tailwind.config.js
│   ├── index.html
│   │
│   └── src/
│       ├── main.js              # Vue + Pinia + wa-sqlite init
│       ├── App.vue
│       │
│       ├── db/
│       │   ├── schema.js        # Tabele SQLite locale (mirror server)
│       │   ├── database.js      # wa-sqlite init + OPFS
│       │   ├── sync.js          # Sync engine (full sync, incremental, push queue)
│       │   └── queries.js       # Reactive query helper
│       │
│       ├── router/index.js
│       │
│       ├── stores/
│       │   ├── auth.js          # JWT, login/register, offline token validation
│       │   ├── orders.js        # SQL queries pe wa-sqlite local
│       │   ├── vehicles.js
│       │   ├── catalog.js
│       │   └── sync.js          # Sync status, last sync time
│       │
│       ├── composables/
│       │   ├── useAuth.js
│       │   ├── useBreakpoint.js
│       │   ├── useSqlQuery.js   # Reactive SQL query (re-run on table change)
│       │   └── useSync.js       # Online/offline status, trigger sync
│       │
│       ├── layouts/
│       │   ├── AppLayout.vue    # Sidebar desktop / bottom nav mobile
│       │   ├── AuthLayout.vue
│       │   └── ClientLayout.vue # Portal client (minimal)
│       │
│       ├── views/
│       │   ├── auth/            # Login, Register, InviteAccept
│       │   ├── dashboard/       # Today's orders, quick stats
│       │   ├── orders/          # List, Create, Detail, Invoice
│       │   ├── vehicles/        # List, Detail
│       │   ├── appointments/    # Calendar/list
│       │   ├── catalog/         # Tabbed: marci, norme, preturi
│       │   ├── settings/        # Profile, Users, Subscription
│       │   └── client/          # DevizView (public), AppointmentBook
│       │
│       ├── components/
│       │   ├── common/          # Button, Input, Modal, Table, StatusBadge, SyncIndicator
│       │   ├── orders/          # OrderCard, OperationForm, MaterialForm, OrderTotals
│       │   └── vehicles/        # VehiclePicker
│       │
│       └── assets/css/
│           └── main.css         # Tailwind imports
│
└── docs/
    ├── ARCHITECTURE.md
    └── CLAUDE.md                # Reguli pentru Claude Code in proiectul nou

---

Schema Database (identica server + browser)

Toate tabelele: id TEXT PRIMARY KEY (UUID v7 generat client-side), tenant_id TEXT NOT NULL, oracle_id INTEGER (NULL, mapare la Oracle ROAAUTO), updated_at TEXT (ISO timestamp pentru sync).

-- Tenants & Users
tenants (id, nume, cui, reg_com, adresa, telefon, email, iban, banca,
         plan, trial_expires_at, created_at, updated_at)

users (id, tenant_id, email, password_hash, nume, rol, activ,
       created_at, updated_at)

invites (id, tenant_id, email, rol, token, expires_at, accepted_at,
         created_by, created_at)

-- Nomenclatures
catalog_marci (id, tenant_id, denumire, activ)
catalog_modele (id, marca_id, denumire)
catalog_ansamble (id, tenant_id, denumire)
catalog_norme (id, tenant_id, cod, denumire, ore_normate, ansamblu_id)
catalog_preturi (id, tenant_id, denumire, pret, um)
catalog_tipuri_deviz (id, tenant_id, denumire)
catalog_tipuri_motoare (id, tenant_id, denumire)
mecanici (id, tenant_id, user_id, nume, prenume, activ)

-- Clients (nomenclator clienti cu date eFactura ANAF)
clients (id, tenant_id, tip_persoana, denumire, cod_fiscal, reg_com,
         adresa, judet, oras, cod_postal, tara, telefon, email,
         cont_iban, banca, observatii, activ, created_at, updated_at)

-- Core Business
vehicles (id, tenant_id, client_id, client_nume, client_telefon, client_email,
          client_cod_fiscal, client_adresa, nr_inmatriculare,
          marca_id, model_id, an_fabricatie, serie_sasiu,
          tip_motor_id, created_at, updated_at)

orders (id, tenant_id, nr_comanda, data_comanda, vehicle_id, client_id,
        tip_deviz_id, status, km_intrare, observatii,
        -- client snapshot (denormalized)
        client_nume, client_telefon, nr_auto, marca_denumire, model_denumire,
        -- totals
        total_manopera, total_materiale, total_general,
        -- client portal
        token_client,
        created_by, created_at, updated_at)

order_lines (id, order_id, tenant_id, tip, descriere,
             norma_id, ore, pret_ora,       -- manopera
             um, cantitate, pret_unitar,     -- material
             total, mecanic_id, ordine, created_at, updated_at)

invoices (id, tenant_id, order_id, client_id, nr_factura, serie_factura,
          data_factura, tip_document, modalitate_plata,
          client_nume, client_cod_fiscal, nr_auto,
          total_fara_tva, tva, total_general, created_at, updated_at)

appointments (id, tenant_id, vehicle_id, client_nume, client_telefon,
              data_ora, durata_minute, observatii, status, order_id,
              created_at, updated_at)

-- Sync (doar in browser, nu pe server)
_sync_queue (id, table_name, row_id, operation, data_json, created_at, synced_at)
_sync_state (table_name, last_sync_at)

---

Faze de Implementare

Faza 0: Setup Proiect (aceasta sesiune)

Livrabil: Director creat, plan salvat in proiect

1. Creeaza directorul E:\proiecte\roaauto\
2. Salveaza acest plan ca E:\proiecte\roaauto\docs\PLAN.md pentru referinte viitoare
3. STOP - nu continua cu implementarea

Faza 1: Fundatie + Auth + Sync (Saptamana 1-2)

Livrabil: Register/Login, wa-sqlite local, sync functional

Backend:

1. git init la E:\proiecte\roaauto\, remote pe Gitea
2. FastAPI skeleton: main.py, config.py, deps.py
3. libSQL setup: session.py cu aiosqlite
4. Alembic init + prima migrare: tenants, users, invites
5. Auth: POST /auth/register (creeaza tenant + owner), POST /auth/login (JWT 30 zile)
6. Sync endpoints: GET /sync/full, GET /sync/changes?since=, POST /sync/push
7. JWT middleware: get_current_user, get_tenant_id

Frontend: 8. Vue 3 + Vite + Tailwind + Pinia scaffold 9. wa-sqlite setup: database.js (init WASM + OPFS), schema.js (create tables) 10. Sync engine: sync.js (full sync, incremental sync, push queue) 11. Router cu auth guards 12. Pages: Login, Register 13. App layout responsive (sidebar desktop, bottom nav mobile) 14. Sync status indicator (online/offline/syncing)

Verificare: Register → login → full sync → datele apar in wa-sqlite local → offline: app functioneaza → reconectare: sync push

Faza 2: Business Logic Core (Saptamana 3-4)

Livrabil: Creare comanda cu operatii/materiale, workflow complet

1. Models + migrations: vehicles, orders, order_lines, catalog_*, mecanici
2. Seed data (Alembic): 24 marci, 11 ansamble, 6 tipuri deviz, 5 tipuri motoare, 3 preturi
3. OrderService: CRUD + workflow DRAFT→VALIDAT→FACTURAT + recalc totals
4. wa-sqlite schema update (mirror noile tabele)
5. Frontend: Dashboard (comenzi azi, stats)
6. Frontend: Orders list (query local SQLite, filtrare, search)
7. Frontend: Order create (vehicle picker, operatii, materiale, totals live)
8. Frontend: Order detail (view/edit, status actions)
9. Frontend: Catalog management (tabbed)
10. Frontend: Vehicle picker (search-as-you-type pe SQLite local)

Verificare: Creare comanda offline → operatii + materiale → totals corecte → reconectare → sync → comanda pe server

Faza 3: Facturare + PDF (Saptamana 5)

Livrabil: Deviz/factura PDF

1. Model invoices, InvoiceService (VALIDAT→FACTURAT, TVA 19%)
2. WeasyPrint templates HTML/CSS (deviz.html, factura.html cu diacritice)
3. Endpoint GET /api/orders/{id}/pdf/deviz
4. Frontend: Invoice page, PDF download/share

Verificare: DRAFT → operatii → VALIDAT → factura → PDF cu diacritice corecte

Faza 4: Portal Client + SMS (Saptamana 6)

Livrabil: Client primeste SMS, vede deviz, accepta/refuza

1. GET /api/p/{token} (public, no auth) → deviz data
2. POST /api/p/{token}/accept, /reject
3. SMSAPI.ro integration
4. Frontend: DevizViewPage (public, mobile-first)
5. Frontend: "Trimite deviz" button (SMS + WhatsApp link)
6. Model appointments + CRUD + client booking

Verificare: Comanda → trimite SMS → client link → accepta → status updated

Faza 5: Management Angajati + Settings (Saptamana 7)

Livrabil: Owner invita angajati, role-based access

1. Invite system (email link 48h)
2. User management (list, deactivate, roles)
3. Settings: profil service
4. Role-based UI (mecanic vede doar comenzile lui)

Faza 6: Deployment (Saptamana 8)

Livrabil: roaauto.romfast.ro live

1. Dockerfile (FastAPI + libSQL, single container)
2. Frontend Dockerfile (nginx)
3. docker-compose.yml
4. Dokploy pe Proxmox + Cloudflare Tunnel
5. Trial expiry middleware
6. Backup strategy (libSQL replication / cron cp)

Faza 7: Polish + PWA (Saptamana 9-10)

Livrabil: Production-ready, instalabil

1. PWA: service worker, install prompt, icons
2. Sync indicator UI (online/offline/syncing/error)
3. Error handling, toasts, loading states
4. Responsive testing (phone, tablet, desktop)
5. Reports: sumar lunar, export CSV

Faza 8: Nomenclator Clienti (Clients)

Livrabil: CRUD clienti cu date eFactura ANAF, legatura 1:N cu vehicule

1. Model clients + migrare Alembic (backend)
2. client_id FK pe vehicles, orders, invoices
3. CRUD endpoints: GET/POST /api/clients, GET/PUT/DELETE /api/clients/{id}
4. wa-sqlite schema update (tabel clients, FK-uri)
5. Frontend: pagina Clienti (list, create, edit, delete)
6. Frontend: selector client in VehiclePicker si OrderCreate
7. Sync: adauga clients in SYNCABLE_TABLES
8. Playwright E2E tests (desktop + mobile)

Faza 9: Edit/Delete/Devalidare Comenzi

Livrabil: Gestionare completa comenzi - edit, stergere, devalidare

1. PUT /api/orders/{id} - edit header comanda (doar in DRAFT)
2. DELETE /api/orders/{id} - stergere comanda (orice nefacturat)
3. POST /api/orders/{id}/devalidate - VALIDAT → DRAFT
4. DELETE /api/invoices/{id} - stergere factura (permite stergere comanda FACTURAT)
5. Frontend: butoane edit/delete/devalidare pe OrderDetail
6. Confirmare stergere cu modal
7. Playwright E2E tests

Faza 10: Integrare Nomenclator Clienti

Livrabil: Clienti integrati in flux comenzi si facturi

1. Auto-populare date client pe comanda din nomenclator
2. Selectie client existent sau creare client nou la vehicul
3. Validare date client complete la facturare (CUI, adresa)
4. PDF factura cu date client din nomenclator

Faza 11: Bon Fiscal (tip_document)

Livrabil: Suport dual FACTURA + BON_FISCAL pe invoices

1. tip_document pe invoices: FACTURA (B2B, eFactura) sau BON_FISCAL (B2C, casa de marcat)
2. Factura: necesita date client complete (CUI, adresa)
3. Bon fiscal: format simplificat, fara date client obligatorii
4. UI: selectie tip document la facturare
5. PDF template diferentiat pentru bon fiscal

---

Referinta din Prototip (doar consultare)

Ce	Fisier	Ce portam conceptual
Workflow	roa-auto-mobile/backend/services/order_service.py	State machine, _recalc_totals
Seed data	roa-auto-mobile/backend/seed.py	24 marci, ansamble, tipuri
PDF layout	roa-auto-mobile/src/services/pdf.js	Format coloane, header, totals
UI flow	roa-auto-mobile/src/views/OrderCreatePage.vue	Flow creare comanda
Vehicle search	roa-auto-mobile/src/components/VehiclePicker.vue	Search pattern

---

Compatibilitate ROAAUTO Oracle

SaaS-ul trebuie sa fie compatibil cu ROAAUTO VFP9+Oracle. Clientii care cresc pot migra la sistemul complet ROAAUTO cu Oracle. Coloanele SaaS mapeaza 1:1 la tabelele Oracle MARIUSM_AUTO.dev_*.

Mapare tabele SaaS → Oracle ROAAUTO

SaaS (libSQL)	Oracle (MARIUSM_AUTO)	Note
orders	dev_ordl	+tenant_id, +token_client, UUID vs Integer PK
order_lines (tip=manopera)	dev_oper	SaaS unifica oper+materiale in order_lines
order_lines (tip=material)	dev_estimari_produse	Acelasi tabel, filtrat pe tip
vehicles	dev_masiniclienti	Renamed, aceleasi coloane client+vehicul
clients	nom_parteneri + adrese_parteneri	Adrese simplificate flat
clients.tip_persoana	nom_parteneri.tip_persoana	PF/PJ
clients.cod_fiscal	nom_parteneri.cod_fiscal	CUI sau CNP
catalog_marci	dev_nom_marci	+tenant_id
catalog_modele	dev_nom_masini	Identic
catalog_ansamble	dev_nom_ansamble	+tenant_id
catalog_norme	dev_nom_norme	+tenant_id
catalog_preturi	dev_nom_preturi	+tenant_id
catalog_tipuri_deviz	dev_tip_deviz	+tenant_id
catalog_tipuri_motoare	dev_tipuri_motoare	+tenant_id
mecanici	dev_mecanici	+tenant_id, +user_id
invoices	facturi (local)	Identic structural
invoices.tip_document	vanzari.tip_factura	FACTURA/BON_FISCAL
invoices.client_id	vanzari.id_part	FK la client
orders.client_id	(denormalizat)	Referinta directa la client
vehicles.client_id	(implicit in dev_masiniclienti)	1:N client → vehicule
tenants	-	Doar SaaS (nu exista in Oracle)
users	-	Doar SaaS
appointments	-	Doar SaaS (feature nou)

Coloane compatibile (pastreaza aceleasi nume)

Coloanele business raman identice cu Oracle pentru migrare usoara:

• nr_comanda, data_comanda, status, km_intrare, observatii
• client_nume, client_telefon, client_cod_fiscal, nr_auto
• marca_denumire, model_denumire
• total_manopera, total_materiale, total_general
• denumire, ore, pret_ora, cantitate, pret_unitar, total
• nr_inmatriculare, serie_sasiu, an_fabricatie
• cod, ore_normate, pret, um
• nr_factura, serie_factura, data_factura, modalitate_plata
• tva, total_fara_tva

Coloane adaugate fata de Oracle (doar in SaaS)

• id TEXT (UUID v7) - in loc de id INTEGER (Oracle sequence)
• tenant_id TEXT - izolare multi-tenant
• oracle_id INTEGER - mapare la ID-ul Oracle, NULL pana la migrare
• token_client TEXT - portal client (feature SaaS)
• updated_at TEXT - timestamp sync
• created_at TEXT - audit

Script migrare SaaS → Oracle (Phase viitoare)

# Migrare: export din libSQL SaaS → import in Oracle ROAAUTO
# 1. Map UUID → Integer (Oracle sequences)
# 2. Split order_lines → dev_oper (manopera) + dev_estimari_produse (material)
# 3. Rename tables: vehicles → dev_masiniclienti, orders → dev_ordl
# 4. Drop columns: tenant_id, token_client, oracle_id
# 5. Import nomenclatures shared (global marci etc)

---

Sistem Tier-uri si Business Model

Free Forever (0 RON/luna)

• 100% local - wa-sqlite in browser, ZERO cost server per user
• Toate features-urile de baza: comenzi, operatii, materiale, vehicule, nomenclator
• PDF generation client-side (jsPDF) - deviz + factura
• Web Share API - share PDF via WhatsApp/email
• Backup/restore manual - export DB ca fisier JSON/SQLite pe telefon, restore din fisier
• Un singur device (datele in browser-ul respectiv)
• Nu necesita cont pe server - app-ul se incarca ca PWA, functioneaza standalone
• Limite soft: ~50 comenzi/luna (nu blocheaza, doar sugereaza upgrade gratios)
• NU: sync cloud, client portal, SMS, multi-device, backup automat

Basic (49 RON/luna - de stabilit)

• Tot ce e in Free +
• Cloud sync (libSQL server) - datele salvate in cloud, backup automat
• Multi-device - lucreaza de pe telefon SI calculator
• Client portal - link unic pentru client sa vada devizul
• WhatsApp link - generare link deviz pentru WhatsApp (gratuit)
• 1 user

Pro (99 RON/luna - de stabilit)

• Tot ce e in Basic +
• SMS deviz - trimite SMS cu link via SMSAPI.ro
• Multi-user - pana la 3 useri (owner + 2 angajati)
• Programari - modul appointments
• Rapoarte - sumar lunar, export CSV
• Priority support

Cum functioneaza tehnic

Free tier (zero server cost):

1. User acceseaza roaauto.romfast.ro
2. PWA se incarca si se instaleaza (service worker cache)
3. wa-sqlite se initializeaza cu schema goala
4. User lucreaza 100% local - fara cont, fara server
5. Datele raman DOAR in browser (OPFS)
6. Daca sterge browser data → pierde tot (avertizare clara)

Upgrade Free → Basic:

1. User da click "Creeaza cont" (POST /auth/register)
2. Se creeaza tenant + user pe server
3. Full sync: datele locale se uploadeaza pe server (POST /sync/push)
4. De acum: sync bidirectional activ
5. Datele safe pe server + backup

Downgrade Basic → Free:

1. Subscription expirat sau anulat
2. Sync se opreste (server refuza sync requests)
3. Datele locale raman in browser (functioneaza ca inainte)
4. Datele pe server se pastreaza 90 zile (re-upgrade posibil)
5. Dupa 90 zile: datele server se sterg

Trial flow:

1. Register → 30 zile trial Basic gratuit
2. Sync activ, toate features-urile Basic
3. La expirare: downgrade automat la Free
4. Datele locale raman, sync se opreste
5. "Upgrade" button prominent

Backup manual (Free tier)

Export: wa-sqlite → JSON blob → download ca fisier "roaauto-backup-2026-03-13.json"
  - Buton "Salveaza backup" in Settings
  - Foloseste File System Access API sau download fallback
  - Include: toate tabelele, settings, metadata

Restore: fisier JSON → parse → INSERT in wa-sqlite
  - Buton "Restaureaza din backup" in Settings
  - Confirmare: "Asta va inlocui datele curente. Continui?"
  - Validare: verifica schema version, integritate date

UX important: La fiecare 7 zile fara backup, reminder subtil (banner, nu modal): "Ultima salvare: acum 12 zile. Salveaza un backup pe telefon."

Limite soft + sugestii gratioase (stil Revolut)

Filosofie: Nu blocam NICIODATA. Doar sugeram, pozitiv, la momentul potrivit.

Limite soft Free:

• ~50 comenzi/luna (numar orientativ, nu hard limit)
• Fara limita pe vehicule/nomenclator

Cum arata sugestiile (non-intrusive, pozitive):

Moment	Tip	Mesaj (exemplu)
Comanda #20	Banner mic, dismissable	"Ai creat 20 de comenzi luna asta. Stiai ca poti sincroniza datele pe mai multe dispozitive?"
Comanda #40	Card in dashboard	"Afacerea ta creste! Cu planul Basic ai backup automat si poti trimite devize direct clientilor."
Comanda #50	Bottom sheet (o singura data)	"Ai atins 50 de comenzi. Felicitari! Activeaza planul Basic pentru sync, backup automat si portal client. Continui gratuit, fara restrictii."
Share PDF manual	Tooltip subtil	"Poti trimite devizul direct pe WhatsApp clientului cu un click. Vezi planul Basic."
Dupa 3 luni activ	Card in dashboard	"Folosesti ROA AUTO de 3 luni. Multumim! Protejeaza-ti datele cu backup automat in cloud."

Reguli:

• Fiecare sugestie apare MAX o data (dismiss = nu mai apare niciodata)
• Niciodata popup/modal blocant
• Ton pozitiv: "Felicitari", "Afacerea ta creste", "Stiai ca..."
• Buton "Nu, multumim" vizibil si respectat
• Nu afiseaza mai mult de 1 sugestie pe zi
• Dupa dismiss: minimum 7 zile pana la urmatoarea sugestie

Logica in cod

// Frontend: check tier before feature
const tier = authStore.tier // 'free', 'basic', 'pro' (din JWT sau local)

// Sync: doar paid
if (tier !== 'free') {
  await syncEngine.start() // start bidirectional sync
}

// Client portal: doar basic+
if (tier === 'free') {
  showUpgradeModal('client_portal')
} else {
  generateClientLink(order.token_client)
}

// SMS: doar pro
if (tier !== 'pro') {
  showUpgradeModal('sms')
}

# Backend: middleware tier check
@app.middleware("http")
async def check_subscription(request, call_next):
    if request.url.path.startswith("/api/sync"):
        tenant = await get_tenant(request)
        if tenant.plan == "free" or tenant.is_expired():
            return JSONResponse(status_code=402, content={"detail": "Upgrade required"})
    return await call_next(request)

---

Migrare viitoare la PostgreSQL

Cand proiectul creste si se muta pe VPS cloud:

1. Schimba aiosqlite → asyncpg in session.py
2. Adapteaza Alembic migrations (remove batch operations)
3. Adauga PostgreSQL RLS pentru izolare tenant
4. Optional: adauga PowerSync pentru sync automat (inlocuieste custom sync)
5. Schema e compatibila - aceleasi tabele, aceleasi coloane