IvanZaycev0717/microservices-fastapi-vue-mongodb

This release establishes the foundational architecture for a microservices-based application, introducing core services for authentication, content, comments, and notifications. The backend features a new Admin Service with full CRUD capabilities for managing users, content, and comments, supported by gRPC and REST APIs. The frontend is now fully functional with theme and localization support, while the API Gateway integrates these services with caching and rate limiting. The release also includes comprehensive test coverage and infrastructure scripts for database initialization.

The backend admin service introduces new database access layers for managing content entities, including About, Certificates, Projects, Publications, and Tech. Each entity now has a corresponding CRUD class (e.g., AboutCRUD, ProjectsCRUD) that handles asynchronous MongoDB operations for creating, reading, updating, and deleting records. These changes enable the admin service to persist and retrieve structured data for these specific content types.

_backend/admin\_service/src/content\admin/crud · high confidence

Added new initialization scripts for MongoDB to automatically configure databases and users for the auth, content, and notification microservices. Each service now has a dedicated database (auth\_db, content\_db, notification\_db) with specific users and minimal readWrite privileges, alongside an admin user with dbAdmin rights. A README file documents the structure and security practices.

mongo-init-scripts · high confidence

A new SQL script (01-create-database.sql) has been added to the postgres-init-scripts directory. This script automatically creates the 'comments\_db' database if it does not already exist, ensuring safe initialization for the comments service and admin service. A README.md file was also added to document the purpose, structure, and security considerations of the initialization process.

postgres-init-scripts · high confidence

New SQL query files were added to the admin service to support comment administration. Specifically, clear\_table.sql provides a TRUNCATE operation to clear the comments table, and show\_all\_comments.sql provides a SELECT query to retrieve all comments, enabling the backend to manage and view user-generated content.

_backend/admin\_service/src/comments\admin/queries · high confidence

The admin service now includes a new \comments\_admin\ module that provides full CRUD (Create, Read, Update, Delete) operations for comments. This includes database models, a CRUD layer, API routes, and Pydantic schemas, enabling administrators to manage comment data directly.

_backend/admin\_service/src/comments\admin · high confidence

The admin service now includes a new notification subsystem, providing CRUD operations for managing email notifications. This includes Pydantic models for request and response validation, a CRUD layer for MongoDB interactions, and API routes to create, retrieve (by ID or email), and delete notifications. A background task is also introduced to handle the actual email sending process and update the notification status accordingly.

_backend/admin\_service/src/notification\admin · high confidence

Developers can now use the new Postman collection (Content\_Admin\_API.postman\_collection.json) and environment file (Content\_Admin\_Devs.postman\_environment.json) to interact with the Admin Service API. The collection includes pre-configured tests for authentication endpoints (register, login, refresh, logout) and user management, verifying response structures, headers, and security headers. The environment file provides default values for base URLs, user IDs, and tokens, facilitating local development and testing of the service's CRUD and auth endpoints.

_backend/admin\service · high confidence

New Pydantic models have been introduced in the admin service to support content management for About, Certificates, Projects, Publications, and Tech skills. These models define the data structures for creating, updating, and retrieving content, including multilingual support for About and Projects, and structured data for Tech skills organized by kingdoms.

_backend/admin\_service/src/content\admin/models · high confidence

The auth service now exposes a gRPC API for authentication and account management. The \AuthService\ includes RPCs for \Login\, \Register\, \Logout\, \RefreshToken\, \VerifyToken\, \ForgotPassword\, and \ResetPassword\. These are defined in \auth.proto\ and accompanied by the corresponding Python stubs (\auth\_pb2.py\, \auth\_pb2.pyi\, \auth\_pb2\_grpc.py\) that enable client and server implementations to interact with these endpoints.

_backend/auth\service/src/proto · high confidence

New Protocol Buffer definitions and generated Python/gRPC stubs have been added to the API gateway, introducing three new services: AuthService (handling login, register, logout, token refresh/verify, and password reset), CommentsService (supporting create, read, update, and delete operations for comments), and ContentService (providing endpoints for about, tech, projects, certificates, and publications). These changes establish the contract for these backend services, enabling the gateway to route and serialize/deserialize requests and responses for these specific domains.

_backend/api\gateway/src/protos · high confidence

The API gateway now supports response caching via a new \CacheService\ backed by Redis, allowing endpoints to store and retrieve cached responses. A \rate\_limit\_decorator\ enforces rate limiting on endpoints using a distributed \TokenBucket\ algorithm stored in Redis. Additionally, a \KafkaConsumer\ listens for cache invalidation events to clear stale cache entries, ensuring data consistency. These changes introduce new dependencies on Redis and Kafka for the gateway's internal services.

_backend/api\gateway/src/services · high confidence

Introduces the Admin GUI frontend, a Quasar (Vue 3) single-page application that provides a complete administrative interface. The application supports authentication (login, logout, token refresh) and offers full CRUD operations for managing about cards, projects, certificates, publications, and comments. It includes specific UI components for each content type, a Dockerfile for containerized deployment, and configuration files (eslint, prettier, postcss) to support development and build processes.

_backend/admin\_service/admin\gui · high confidence

The admin service now includes a Dockerfile and entrypoint script that handle database migrations and initial data loading. The service connects to PostgreSQL and MongoDB, creates necessary databases and tables, and uploads initial data to MinIO. Configuration is managed through a Pydantic settings class that defines environment variables for database connections, Kafka topics, and service-specific settings.

_backend/admin\service/src · medium confidence

The API Gateway is initialized with core infrastructure and service integrations. Authentication is implemented via a gRPC client to an auth service, including token verification and comment ownership checks. The gateway also connects to a content service for retrieving projects, about pages, and publications, and to a comments service for managing user comments. Additionally, the gateway integrates with Redis for caching and rate limiting, and uses Kafka for cache invalidation.

_backend/api\gateway/src · high confidence

The frontend application is now fully initialized with a new App.vue root component that manages global state for dark/light theme switching and English/Russian language selection, persisting preferences in localStorage. The UI includes a responsive header, sidebar, and content scroll area, along with a suite of new components: AboutMeCard and AboutMeCarousel for displaying author information, an InteractiveMap with zoom/drag capabilities for visualizing tech skills, and a BreadcrumbsPanel for navigation. Additionally, the app supports user authentication flows (login, register, forgot/reset password), comment management (edit, delete, reply), and certificate galleries. All text is localized via new en.json and ru.json locale files, and global CSS variables define the light and dark theme palettes.

frontend/src · high confidence

The frontend application is now available, providing a complete single-page application with backend connectivity, authentication, and localization. The release includes production Dockerfiles for both development and production environments, along with necessary configuration files (nginx, .dockerignore, .editorconfig) and a public configuration script that defines API endpoints for the backend microservices.

frontend · high confidence

The repository was initialized with a comprehensive set of configuration files and documentation. A \.env.example\ file was added, defining environment variables for all microservices (Auth, Content, Comments, Notification, Admin) and infrastructure components (MongoDB, PostgreSQL, Redis, Kafka, MinIO, Elasticsearch). A \docker-compose.yml\ file was introduced to orchestrate the entire application stack, including frontend, API gateway, all backend services, and their associated databases and caches. Additionally, a \LICENCE\ file (MIT) and an updated \README.md\ with system design diagrams and setup instructions were added to the project root.

(repo-wide) · high confidence

The auth\_service directory is introduced with a complete implementation for user authentication, token management, and password reset functionality. The service exposes a gRPC API for login, registration, and token verification, backed by MongoDB and JWT. The addition includes a Dockerfile for containerization, a .dockerignore file, a Python script to generate gRPC stubs from proto files, and a linting script, establishing the operational and development environment for the service.

_backend/api\_gateway, backend/auth\service · high confidence

The auth service now implements a gRPC-based authentication flow supporting user login, registration, and password reset functionality. This change introduces async handling for user credentials via MongoDB (using an async client) and integrates with Apache Kafka (via aiokafka) to send password reset and success messages. The implementation includes new modules for JWT token processing, password hashing with bcrypt, and Kafka topic management, replacing the previous synchronous or different-library approach.

_backend/auth\service/src/services · high confidence

The auth service now includes a new data access layer and data models to support authentication operations. The \crud/auth.py\ file introduces an \AuthCRUD\ class that handles user creation, retrieval by email or ID, login timestamp updates, and password hash updates against a MongoDB users collection. Additionally, \crud/token.py\ provides a \TokenCRUD\ class for managing refresh tokens, including creation, retrieval, marking as used, and invalidation. The \models/schemas.py\ file defines Pydantic schemas for user data (\UserDB\, \UserResponse\), request payloads (\CreateUserRequest\, \LoginRequest\, \RefreshTokenRequest\, \ForgotPasswordRequest\, \ResetPasswordRequest\), and response structures (\TokenData\, \TokenPayload\, \ForgotPasswordResponse\, \ResetPasswordResponse\), establishing the internal data contracts for the authentication microservice.

_backend/auth\_service/src/crud, backend/auth\service/src/models · high confidence

Added a new authentication service (auth\_admin) that provides full CRUD operations for user management and token handling. The service includes database models for users and tokens, CRUD repositories for MongoDB, and API routes for user registration, login, and retrieval. It also manages refresh tokens, allowing users to obtain new access tokens. The implementation uses Pydantic for data validation and FastAPI for routing, with dependencies for database access and user authentication.

_backend/admin\_service/src/auth\admin · high confidence

Add new service modules to the admin service, including asynchronous Kafka producers (base, cache invalidation, logging, and topic management) using aiokafka, MinIO storage management, image and PDF processing, MongoDB and PostgreSQL connection managers, JWT token handling, email sending, and webhook notifications. These services provide the core functionality for the admin service to manage content, handle caching, and communicate with other microservices.

_backend/admin\service/src/services · high confidence

The backend/notification\_service directory now contains a new microservice built on FastAPI and aiokafka. It listens for password reset and success events from Kafka, stores notification records in MongoDB, and sends styled HTML emails via SMTP. The service exposes /health and / endpoints, uses structured JSON logging, and manages lifecycle events for database and Kafka connections.

_backend/notification\service · high confidence

The backend/comments\_service area now contains a fully functional gRPC service for managing hierarchical comments stored in PostgreSQL. This includes the proto definitions, generated Python gRPC code, a CRUD layer using SQLAlchemy 2.0, Pydantic schemas for validation, and the main entry point that starts the gRPC server on port 50054. The service supports creating, retrieving (by ID, project, or author), updating, and deleting comments, with support for parent-child comment relationships.

_backend/comments\service · high confidence

A new Content Service has been added to the backend, exposing a gRPC API for retrieving about information, technology stacks, projects, certificates, and publications. The service connects to MongoDB to fetch and structure this content, supporting language-specific translations and sorting. It includes a Dockerfile for containerization, a .dockerignore file, and a README with usage instructions. The implementation uses Pydantic for data models, Pydantic-Settings for configuration, and includes a health check endpoint for the gRPC server.

_backend/content\service · high confidence

The API gateway now exposes new endpoints for user authentication (login, register, verify, etc.), comment management (listing, filtering by user or project), and content retrieval (about, tech stack, projects, certificates). These endpoints integrate with gRPC microservices, implement rate limiting and Redis caching for content endpoints, and handle authentication state via HTTP-only cookies.

_backend/api\gateway/src/api/v1/endpoints · high confidence

The admin service now exposes full CRUD (Create, Read, Update, Delete) REST APIs for managing content about, certificates, projects, publications, and technical skills. Each resource is served via dedicated FastAPI routers (e.g., /about, /certificates, /projects, /publications, /technologies) that integrate with MongoDB for data persistence and MinIO for file storage. The implementation includes image processing (resizing, format conversion to WebP), PDF-to-image conversion for certificates, and dependency injection for database connections and logging.

_backend/admin\_service/src/content\admin/routes · high confidence

The auth service now uses a custom JSON logger that outputs structured logs (timestamp, service, level, message, module, function, line) to stdout, replacing any previous logging mechanism. Additionally, the service exposes a gRPC health check endpoint that verifies database connectivity, returning SERVING or NOT\_SERVING status. The service also initializes Kafka producers and ensures required topics exist at startup.

_backend/auth\service/src · high confidence

The admin service now includes Alembic migration scripts to manage the comments table schema. The initial migration (e8b30e350263) alters the 'comments' table to allow the 'parent\_comment\_id' column to be nullable. A subsequent migration (08aa32224a8f) modifies the foreign key constraint on 'parent\_comment\_id' to enable cascade deletion, ensuring that child comments are automatically removed when their parent is deleted.

_backend/admin\service/src/alembic · high confidence

Added comprehensive test coverage for admin service CRUD operations; Added unit tests for the auth service database layer.

The admin service's frontend (admin\_gui) now includes a package.json and package-lock.json, establishing a Quasar/Vue.js 3 application with dependencies like axios, pinia, and quasar. On the backend, the admin service's Python environment is initialized with a pyproject.toml and poetry.lock, introducing libraries such as fastapi, pymongo, aiokafka, and bcrypt, while the api\_gateway and auth\_service lockfiles confirm the adoption of aiokafka 0.12.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 37 → 40 (+2.9)
• Rubric changed (rubric-2026.08.18 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 59 → 46 (-13.4)
• Architecture 88 → 95 (+7.3)
• Maturity 55 → 59 (+3.6)
• Readiness 17 → 24 (+6.9)
• Security 49 → 62 (+13.2)
• Domain Modelling 100 → 100 (+0.0)
• Accessibility 49 → 48 (-0.7)

• Change coupling: about.py ↔ tech.py (backend/admin_service/src/content_admin/crud/about.py)
• Change coupling: certificates.py ↔ main.py (backend/admin_service/src/content_admin/crud/certificates.py)
• Change coupling: certificates.py ↔ projects.py (backend/admin_service/src/content_admin/crud/certificates.py)
• Change coupling: certificates.py ↔ publications.py (backend/admin_service/src/content_admin/crud/certificates.py)
• Change coupling: certificates.py ↔ settings.py (backend/admin_service/src/content_admin/crud/certificates.py)
• Change coupling: main.py ↔ image_processor.py (backend/admin_service/src/main.py)
• Change coupling: projects.py ↔ main.py (backend/admin_service/src/content_admin/crud/projects.py)
• Change coupling: projects.py ↔ main.py (backend/admin_service/src/content_admin/routes/projects.py)
• Change coupling: projects.py ↔ publications.py (backend/admin_service/src/content_admin/crud/projects.py)
• Change coupling: tech.py ↔ main.py (backend/admin_service/src/content_admin/crud/tech.py)
• Coverage not included — suite not readable by the collector
• Critical CVE: [GHSA redacted] (frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (backend/admin_service/src/poetry.lock)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Duplicated block (10 lines × 2) (backend/admin_service/src/comments_admin/routes/comments.py)
• Duplicated block (10 lines × 2) (backend/admin_service/src/content_admin/models/projects.py)
• Duplicated block (10 lines × 2) (backend/api_gateway/src/grpc_clients/comments_client.py)
• Duplicated block (10 lines × 3) (backend/api_gateway/src/api/v1/endpoints/auth.py)
• Duplicated block (11 lines × 3) (backend/api_gateway/src/api/v1/dependencies.py)
• …and 87 more

• Change coupling: about.py ↔ main.py (backend/admin_service/src/content_admin/crud/about.py)
• Change coupling: about.py ↔ main.py (backend/admin_service/src/content_admin/routes/about.py)
• Coverage not measured — JavaScript/TypeScript suite
• Critical CVE: [GHSA redacted] (frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (backend/admin_service/src/poetry.lock)
• Critical CVE: [GHSA redacted] (backend/api_gateway/poetry.lock)
• Critical CVE: [GHSA redacted] (frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (backend/admin_service/src/poetry.lock)
• Dependency hygiene PARTLY measured — Python dependencies read, no exact pin to grade for currency
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (10 lines × 2) (backend/api_gateway/src/grpc_clients/comments_client.py)
• Duplicated block (103 lines × 4) (backend/auth_service/src/logger.py)
• Duplicated block (10–11 lines × 2) (backend/api_gateway/src/api/v1/endpoints/comments.py)
• Duplicated block (11–12 lines × 2) (backend/admin_service/src/comments_admin/routes/comments.py)
• Duplicated block (11–13 lines × 3) (backend/api_gateway/src/api/v1/dependencies.py)
• Duplicated block (11–15 lines × 13) (backend/api_gateway/src/api/v1/endpoints/auth.py)
• Duplicated block (12 lines × 3) (backend/admin_service/src/content_admin/crud/certificates.py)
• Duplicated block (13 lines × 2) (backend/admin_service/src/auth_admin/crud/token.py)
• Duplicated block (13 lines × 2) (backend/admin_service/src/auth_admin/crud/token.py)
• …and 568 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

IvanZaycev0717/microservices-fastapi-vue-mongodb was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.