A module-by-module explanation of responsibilities, typical data
flow and implementation boundaries. These descriptions reflect the
documented architecture; they are not runtime certification.
01
Domain boundaries and shared C++ types
The shared C++ library is the contract boundary between client
and server. The data model represents entities and
request/response DTOs; service interfaces make domain
operations explicit without forcing the Qt screen or a
database query to define the business model.
Why the split matters
A field or operation should have one clearly defined contract;
otherwise client and backend can disagree about what a request
means.
-
Model and transport changes should be reviewed together.
- Keep data-access details out of the desktop UI.
02
Authentication, relationships and visibility
A successful authentication step establishes a context for
subsequent requests; it does not grant unlimited access. The
server should combine the account, its role and the visibility
rules for the resource. Friend relationships affect
discoverability and profile access.
Example check
When a user opens a private profile, a successful login is not
enough: the server evaluates the target profile, viewer
relationship and visibility before returning fields.
- Validate every protected read or mutation.
03
Messaging and group membership
Message transmission combines an API-level action, a
membership rule, stored conversation records and rendering in
the Qt UI. Direct and group chats share messaging concepts but
differ in participant handling, invitations and member
changes.
State consistency
The same message may appear in multiple participants’ views.
Its database identity, reply relationship and reaction state
need consistent interpretation across API responses.
- Handle missing or deleted referenced messages safely.
- Re-check group membership for attachment access.
04
Feed, stories and short-form media
The publishing workflow has to serve several different
surfaces: an ordinary post, a saved item, a temporary story
and a reel. They can share author/media references while
keeping their own lifetime, ordering, visibility and
moderation semantics.
Publishing lifecycle
Creating a post, finding it in a personalized feed, reporting
it and moderating it are separate operations. Keeping them
separate simplifies both permissions and testing.
-
Consider visibility and expiration when retrieving stories.
05
Media, uploads and calls
The attachment classifier shown below maps filename extensions
to image, video, audio or generic file categories. Upload
endpoints also document chunked transport. WebSocket relay is
separately documented for calls and must not be confused with
persistent message attachment storage.
Upload boundary
File metadata is useful for presentation, but trusted
validation belongs to the backend. A failed upload should not
create an apparently valid attachment record.
-
Distinguish temporary upload state from committed media.
-
Relay sessions have different access rules from persistent
files.
06
Maps, route selection and personal utilities
The map design uses separation of concerns: marker collections
are refreshed through observer-style updates, while routing
algorithms are selected through a strategy interface. Personal
organisation tools add notes, reminders and alarms without
turning them into social posts.
Abstraction in practice
The view asks for route computation through a strategy
interface; it should not embed one search algorithm into
button event handlers. Marker refreshes are view updates, not
automatically a map service API.
- Separate algorithm choice from map rendering.
07
AI assistance and administrative review
An administrative review starts with reported material, not an
AI verdict. A classifier may support prioritisation, while an
administrator can inspect context, apply policy and record the
decision. These are separate stages in the documented design.
Human decision point
The AI service can produce a status or priority; a reviewer
applies the outcome using authenticated administrative
actions. Failure, pending review and rejection are not
interchangeable.
- Keep a traceable review state and reason.
-
Protect administrative endpoints independently of UI roles.
08
Deployment, trust boundaries and testing
Qt desktop pages call HTTP/JSON endpoints exposed by the C++
server. PostgreSQL provides persistence, while a Cloudflare
Tunnel appears in the deployment documentation. Tests are a
distinct project for contracts and representative
integrations.
Deployment boundary
Exposing the API through a tunnel changes connectivity, not
the trust model. Authentication and request validation are
still enforced inside the server, including download and relay
endpoints.
-
Use runtime secrets rather than committing credentials.
09
Security and production roadmap
The security roadmap explicitly names areas that require
production hardening. It must be read as work remaining or
needing verification, not as evidence that every listed
control is already deployed.
Risk register
Before a public release, security work should be closed with
evidence such as tests, configuration reviews and a targeted
abuse-case checklist—not just the presence of a roadmap
document.
-
Treat authentication bypass and unauthorized media reads as
release blockers.
-
Test validation of unexpected content and oversized uploads.
10
Verification matrix and release readiness
The architecture separates user-interface behaviour, domain
rules, persistence and media transport. A useful release gate
tests each boundary independently and then exercises
end-to-end flows; passing a single UI demonstration is not
enough to validate the system.
Release evidence
A demonstration shows that one supported scenario can work. A
release matrix also tests errors, unauthorized access, state
recovery and interfaces shared by client, server and Core.
- Test both successful and rejected API paths.
-
Run integration checks against a controlled test database.
OnConnect-Core: contracts and runtime responsibilities
The source tree contains IChatService, ChatService and repository interfaces. Their separation is more valuable to explain than another generic description of C++ or Qt.
01Interfaces and dependency injection
IChatService defines an abstraction for chat operations; ChatService is an implementation constructed with a chat repository and a date/time provider. This allows domain logic to be understood without coupling it directly to widgets.
02Desktop request boundary
Qt client widgets collect input and form requests; service and server-side authorization should determine which records or conversations a user may access.
03Media handling and transport
Attachment categorisation, media metadata and the WebSocket-based call relay are separate concerns from HTTP/JSON records. File extensions by themselves do not prove uploaded content is safe.
04Tests, deployment and audit trail
OnConnect-Tests is the stated place for shared-contract and representative integration checks. The documented security-hardening roadmap remains open and must be described as work requiring verification.
Qt Widgets client
→HTTP/JSON boundary
→C++ server services
→Repository layer
→PostgreSQL
The public-facing repository README currently contains only its title; this overview also uses source paths in OnConnect-Core and earlier project documentation.
Documentation: GitHub repository / project specification. The content describes documented behaviour or plans; deployment readiness is not inferred.