shahzadahamad/Instant

This system is a full-stack social networking platform built with TypeScript, featuring a Node.js/Express backend and a Next.js frontend. It supports core social interactions including user authentication, profile management, posts, stories, and a real-time chat system with video calling capabilities. The platform also includes an admin dashboard for content moderation and user management, alongside a Stripe-integrated subscription service for monetization.

29 changes.

This period focused on establishing the core backend infrastructure, including database schemas, authentication systems, and API routes for a social networking application. It also introduced a dedicated admin dashboard and management interface, enabling administrators to control users, content, and platform metrics.

14 changes.

This period focused on implementing the backend application and infrastructure layers for key social features, including chat, stories, user search, and subscription management. The work established a consistent architectural pattern by introducing generic controller interfaces and explicit repository abstractions to support these new capabilities.

New controller classes have been introduced to expose story-related functionality via the API. The CreateStoryController enables users to upload and create new stories, handling file uploads and associated metadata. The GetStoriesController provides an endpoint to retrieve stories, specifically fetching content from followed users. These changes implement the backend logic required to support the user story feature.

Backend/src/infrastructure/controllers/user/story · high confidence

The application now supports creating and viewing user stories. The new CreateStory use case allows users to upload story content (including files) to AWS S3, persist the story data, and notify followers via WebSocket. The GetStories use case fetches stories from the current user and their followed users, filtering for content posted within the last 24 hours and returning structured data for both the user's own stories and those of their followings.

Backend/src/application/useCases/user/story · high confidence

Added two new use cases for the admin module: \AuthenticateAdmin\ and \HandleAdminRefreshToken\. The authentication use case allows admins to log in using either a username or email, validating credentials and returning an access token, a refresh token, and admin profile details. The refresh token use case enables the issuance of a new access token using a valid refresh token, or signals the need to clear cookies if the token is invalid or expired.

Backend/src/application/useCases/admin/authentication · high confidence

New controller endpoints have been added to the admin API to handle authentication flows. The login endpoint accepts a username or email and password, issuing an access token and setting an HTTP-only refresh token cookie. A logout endpoint clears this refresh token cookie, and a separate refresh token endpoint validates the existing cookie to issue a new access token or clear the cookie if the refresh token is invalid. These changes introduce the core administrative session management capabilities.

Backend/src/infrastructure/controllers/admin/authentication · high confidence

The application now includes a dedicated admin interface for managing platform content and users. This update adds a reusable sidebar and header for navigation, a dashboard displaying key metrics like revenue and active users, and detailed tables for managing posts and music libraries with features such as search, sorting, and pagination. Administrators can now add music with audio previews, toggle music listing status, and edit music metadata. The entry also establishes the underlying API client infrastructure with specific interceptors for admin authentication and token refresh, alongside a new sign-in form for admin access.

Frontend · high confidence

New controller files have been introduced in the backend infrastructure to expose administrative capabilities for managing music content. These endpoints allow administrators to create new music entries, edit existing ones, retrieve paginated and searchable music data, and toggle the listing status (list/unlist) of music tracks. The implementation follows a structured pattern using specific repository and use-case classes, standardized HTTP status codes, and centralized message constants.

Backend/src/infrastructure/controllers/admin/music · high confidence

New use cases have been introduced in the backend to allow administrators to create, edit, retrieve, and manage the visibility of music entries. The CreateMusic use case handles uploading audio and image files to AWS S3 and storing the metadata, while EditMusic allows updating the title and replacing the image file. GetMusicData provides paginated retrieval of music records with case-insensitive title search filtering. Additionally, ListAndUnlistMusicByAdmin enables administrators to toggle the public visibility status of existing music entries.

Backend/src/application/useCases/admin/music · high confidence

Administrators can now retrieve a paginated list of posts with optional text search. The new GetPostDataAdmin use case accepts page, limit, and search parameters, filtering posts by caption using a case-insensitive regex, and returns the matching posts along with total page and post counts.

Backend/src/application/useCases/admin/post · high confidence

New controller classes have been added to the backend infrastructure to expose admin API routes for managing subscription plans. These endpoints allow administrators to create new subscriptions, edit existing ones, fetch subscription data with pagination and search capabilities, and toggle the active status of subscription lists.

Backend/src/infrastructure/controllers/admin/subscription · high confidence

Administrators can now create, edit, and toggle the visibility (list/unlist) of subscription plans, as well as retrieve a paginated and searchable list of all subscriptions. This change introduces the backend use-case logic for these operations, including validation for required fields like period and price, and supports filtering by search terms across period, price, and offer fields.

Backend/src/application/useCases/admin/subscription · high confidence

Administrators can now block or unblock users via a new use case that validates the action status and persists the change through the user repository. Additionally, a new endpoint allows admins to retrieve user data with support for pagination, configurable limits, and case-insensitive search across full name, username, email, and phone number fields.

Backend/src/application/useCases/admin/user · high confidence

The backend server has been initialized with a TypeScript-based structure, including configuration for ESLint linting, TypeScript compilation settings (targeting ES2020 with CommonJS modules), and custom type definitions for Express requests to support user authentication context.

Backend · high confidence

The backend application now initializes via a new \server.ts\ entry point that configures the Express server, HTTP server, and Socket.IO instance. This file wires up all API routes for user and admin functionalities (including auth, user management, music, posts, chat, subscriptions, search history, stories, and webhooks) using environment variables for path configuration. It also integrates middleware for CORS, cookies, JSON parsing, and Morgan logging, and establishes the database connection upon server startup.

Backend/src/presentation/settings · high confidence

This change introduces the foundational Mongoose models for the application's data layer, enabling core social networking capabilities. The new models include User and Admin for authentication and roles, Post and Story for content creation with filtering and privacy controls, and Comment for threaded discussions. It also adds support for social graph interactions via Friends and UserMoreData (tracking followers, followings, and watched posts), as well as real-time communication through Chat and Message models. Additional models support engagement (Like), notifications, search history, music integration, OTP verification, and payment processing via Stripe.

Backend/src/infrastructure/database · high confidence

This change introduces the complete set of Express route definitions for the user-facing API, organizing endpoints into dedicated modules for authentication, user profile management, social interactions (follows, friends, notifications), content operations (posts, comments, likes, archiving, reels, stories), chat, search history, music metadata, and subscription/webhook handling. These routes wire up the corresponding controllers and middleware (such as authentication and file upload), establishing the backend surface for user-facing features like registration, login, profile editing, post creation and management, social graph operations, messaging, and payment processing.

Backend/src/presentation/routes/user · high confidence

This change adds the backend application-layer logic for a new chat system, enabling users to create individual and group chats, send text and file messages (images, audio, video) via AWS S3, and share social media posts within conversations. The included use cases (CreateChat, SendMessage, FileMessage, SendShareMessage, GetChatList, etc.) handle member validation, message persistence, last-message updates, and real-time notification dispatch via SocketService, forming the core backend support for the chat feature.

Backend/src/application/useCases/user/chat · high confidence

The backend application layer now includes a full suite of use cases for handling user posts and engagement. This includes creating, editing, deleting, and archiving posts, as well as fetching posts for the user's profile, the explore page, and reels. It also introduces logic for liking and unliking posts and comments, replying to comments, and reporting posts. Privacy controls are enforced by filtering private account content based on follower status, and the system now supports real-time notifications via Socket.IO for actions like tagging, commenting, and liking.

Backend/src/application/useCases/user/post · high confidence

The application layer now defines and implements explicit repository interfaces for managing admin accounts, music, subscriptions, chats, comments, friends, likes, messages, notifications, OTPs, payments, posts, search history, stories, and extended user data. This change provides a structured data-access abstraction for these core features, replacing or supplementing previous direct database interactions with a consistent repository pattern.

Backend/src/application/repositories · high confidence

A new generic interface, IControllerHandler, has been added to the backend infrastructure. This interface defines a standard contract for controller logic by specifying a single handle method that accepts Express Request and Response objects and returns a Promise. This change establishes a consistent pattern for implementing controller handlers across the application.

Backend/src/infrastructure/controllers/interfaces · high confidence

Administrators can now fetch a paginated list of posts via a new controller endpoint. The implementation accepts query parameters for page number, search string, and limit, delegates to the existing GetPostDataAdmin use case, and returns the resulting post data or appropriate error responses.

Backend/src/infrastructure/controllers/admin/post · high confidence

This change introduces new controller classes in the admin infrastructure layer to expose API routes for fetching dashboard data and managing admin profiles. Specifically, it adds handlers for retrieving dashboard statistics (GetDashboardDataController), fetching current admin details (GetAdminDataController), updating admin profile information (EditAdminController), and changing admin passwords (EditAdminPasswordController). These controllers implement a generic IControllerHandler interface, utilize specific HTTP status codes and message constants, and delegate logic to corresponding application use cases, thereby enabling the frontend to interact with these new administrative capabilities.

Backend/src/infrastructure/controllers/admin/admin · high confidence

This change introduces a new set of Express router modules under \Backend/src/presentation/routes/admin\ that expose the backend endpoints for the admin interface. The routes cover admin authentication (login, logout, token refresh), admin profile management (view data, edit profile/password, dashboard data), music content management (create, get, edit, list/unlist), post retrieval, subscription plan management (create, edit, toggle list status), and user management (get user data, block/unblock). All content and user management routes are protected by the \adminAuthMiddleware\, ensuring that only authenticated administrators can access these functionalities.

Backend/src/presentation/routes/admin · high confidence

This change introduces four new application use cases for the admin module: GetDashboardData aggregates platform metrics (total revenue, active users, top followed users) from various repositories to power the admin dashboard; GetAdminData retrieves individual admin profile information; EditAdmin allows updating an admin's username, email, and profile picture (including S3 storage handling); and EditAdminPassword enables secure password changes by verifying the current password before hashing and storing the new one. These use cases centralize the business logic for admin profile management and dashboard data retrieval.

Backend/src/application/useCases/admin/admin · high confidence

Added two new controller implementations for the admin user management API: one to retrieve paginated and searchable user data (GetUserDataAdminController) and another to block or unblock specific users (BlockOrUnblockUserAdminController). These controllers implement the IControllerHandler interface, utilize specific HTTP status codes and message constants, and delegate to their respective application use cases.

Backend/src/infrastructure/controllers/admin/user · high confidence

This change introduces a set of new provider classes in the application layer to handle core backend services. Users benefit from a more robust authentication flow with dedicated providers for generating and verifying passwords (bcrypt), managing JWT access/refresh tokens, and creating secure OTPs. Media handling is enhanced with AWS S3 integration for file uploads and deletions, including automated content moderation via AWS Rekognition for images and videos, as well as Sharp-based image processing for circular profile pictures. Additionally, a new email service provider enables automated communications, including OTP verification emails, password reset links, and post-verification account confirmation messages.

Backend/src/application/providers · high confidence

The backend now includes dedicated middleware files to handle authentication for different contexts. The new \adminAuthMiddleware\ restricts access to requests where the user has the 'ADMIN' role, returning a 404 if the role is insufficient. The \authMiddleware\ validates standard user tokens and explicitly blocks access for users who are marked as blocked (\isBlock\), returning a 403 Forbidden status. Additionally, \socketAuthMiddleware\ enables authentication for Socket.IO connections by verifying access tokens from the handshake data, attaching the decoded user information to the socket instance for real-time features.

Backend/src/infrastructure/middlewares · high confidence

This change introduces a set of new application-layer use cases in the backend to support core user authentication flows. Users can now log in with username or email, register via OTP verification, authenticate via Google, and manage passwords through forgot-password and reset-password workflows. The implementation includes logic to block authenticated users, handle refresh tokens, and send verification emails, providing the backend foundation for the corresponding frontend features.

Backend/src/application/useCases/user/authentication · high confidence

This change introduces a set of new HTTP controllers in the backend infrastructure to support chat functionality. Users can now create new chats (including group chats with optional file uploads), retrieve their chat list, and fetch detailed data for individual or single chats. Additionally, a dedicated endpoint allows sending file messages (such as images, audio, and video) within existing chats. These controllers implement a generic interface and delegate logic to application-layer use cases and repositories, establishing the REST API surface for chat operations.

Backend/src/infrastructure/controllers/user/chat · high confidence

Added two new controller endpoints to support the user music creation flow: one to retrieve music data based on a search query and another to fetch specific music details by ID. These controllers implement the standard IControllerHandler interface, utilize the MusicRepository for data access, and return standardized HTTP responses using defined status codes and message constants.

Backend/src/infrastructure/controllers/user/music · high confidence

The backend now exposes a comprehensive set of new API routes for managing user posts and engaging with content. Users can create, edit, delete, and archive posts, as well as view their own, liked, tagged, and archived post collections. The update introduces full interaction capabilities, including liking/unliking posts and comments, replying to comments, and reporting posts. Additionally, new endpoints allow users to fetch their post count, view posts from the explore page, and browse reels, with specific logic to handle privacy settings and exclude archived content where appropriate.

Backend/src/infrastructure/controllers/user/post · high confidence

The backend now exposes three new controller endpoints to support subscription workflows. Users can retrieve a list of available subscription plans via the new \GetSubscriptionListedDataController\, initiate a Stripe checkout session through \CreateCheckoutSessionStripe\, and the system now processes Stripe webhook events via \WebHookController\ to handle payment confirmations and trigger verification emails. These changes implement the infrastructure layer for the new subscription feature, wiring up the application use cases for plan retrieval, session creation, and payment event handling.

Backend/src/infrastructure/controllers/user/subscription · high confidence

Added two new application-layer use cases, GetCreatePostMusicData and GetCreatePostSelectedMusicData, to support the music functionality on both admin and user sides. GetCreatePostMusicData allows searching for listed music items by title and returns a paginated result (up to 10 items) along with the total count, while GetCreatePostSelectedMusicData retrieves a single music item by its ID. These changes enable the backend to fetch specific music data required for creating or managing posts, replacing previous generic or untyped implementations with structured, repository-backed queries.

Backend/src/application/useCases/user/music · high confidence

This change introduces a complete set of backend controllers for user authentication and account lifecycle management. Users can now register with OTP verification, log in with username/email or Google OAuth, manage password resets via email links, refresh access tokens, and securely log out. The implementation uses a consistent controller interface, standard HTTP status codes, and manages refresh tokens via HTTP-only cookies to support session persistence.

Backend/src/infrastructure/controllers/user/authentication · high confidence

The backend now exposes a comprehensive set of new API endpoints for user profile management and social networking. Users can now update their profile information (including private account status and profile pictures), search for other users by username, and retrieve detailed user data. The social graph is expanded with new capabilities to follow, unfollow, and remove users, as well as accept or delete friend requests. Additional endpoints provide user suggestions, track watched posts, and retrieve follower/following lists and notification counts.

Backend/src/infrastructure/controllers/user/user · high confidence

The application layer now includes a comprehensive set of new use cases for user profiles and social features. Users can now manage their online status, update profile details (including profile picture handling via AWS S3 and image processing), and search for other users. The system supports a full follow/unfollow workflow, including handling private account restrictions, sending and accepting follow requests, and retrieving follower/following lists with mutual friend data. Additionally, users can track watched posts, view notifications, and receive user suggestions based on mutual connections.

Backend/src/application/useCases/user/user · high confidence

The backend now exposes a set of new API endpoints for user search and search history management. Users can search for other users, view their own search history, add specific searches to their history, remove individual items from their history, or clear their entire search history. These changes are implemented via new controller classes (SearchController, SearchHistoryController, SearchHistoryAddController, RemoveController, and RemoveAllController) that wire up the corresponding application use cases and repositories.

Backend/src/infrastructure/controllers/user/search · high confidence

The backend now supports real-time communication features through a new Socket.IO service. Users can send and receive instant messages, initiate and end audio/video calls (with notifications sent to recipients), and share posts within chats. Additionally, the system broadcasts live updates for new posts, stories, and notifications, as well as user online/offline status changes, ensuring the frontend stays synchronized without polling.

Backend/src/infrastructure/service · high confidence

Users can now purchase subscription plans via Stripe checkout sessions and have their accounts automatically verified upon successful payment. This change introduces use cases to create Stripe checkout sessions, retrieve listed subscription plans, and process Stripe webhooks. When a payment succeeds, the system records the transaction, updates the user's verification status, and sends a confirmation email.

Backend/src/application/useCases/user/subscription · high confidence

The application now supports full user search and search history management. Users can search for other users, with results indicating whether the searcher is already following them. The system tracks search activity, allowing users to view their history (also showing follow status), add new searches to the history, remove individual entries, or clear the entire history.

Backend/src/application/useCases/user/search · high confidence

The backend now consolidates infrastructure setup into dedicated configuration modules within the \configs\ directory. This includes initialization for AWS S3 and Rekognition clients, MongoDB database connection, file upload handling via Multer, SMTP email service, rate limiting for API endpoints, and Stripe payment integration. Users benefit from a cleaner architecture where these external service connections are standardized and centrally managed, ensuring consistent behavior for file storage, notifications, security limits, and payment processing.

Backend/src/infrastructure/configs · high confidence

The backend's application layer now defines explicit TypeScript interfaces to structure data contracts across several features. New interfaces in \emailInterface.ts\ specify the payload shapes for OTP, password reset, and account verification emails. \fileTypes.ts\ defines the structure for uploaded image and audio files. \post.ts\ introduces detailed interfaces for post and story data, including moderation labels, custom filters, and complex MongoDB query types for admin search and subscription data, as well as user/friend relationship structures. Finally, \search.ts\ defines the shape for search history entries. These changes standardize how data is passed between the application logic and other layers.

Backend/src/application/interface · high confidence

The application now uses centralized constants for user-facing success, error, and info messages (messages.ts) and strongly-typed enums for HTTP status codes and user roles (enums.ts). This change replaces scattered string literals and magic numbers with a single source of truth, ensuring consistent messaging across the API and improving type safety for status handling.

Backend/src/infrastructure/constants · high confidence

The backend project now includes a new package-lock.json and updated package.json, adding dependencies for AWS Rekognition and S3, Stripe, Socket.IO, Morgan, and Multer (upgraded to 2.3.0), alongside development tools like ESLint and TypeScript. The frontend project has significantly expanded its dependency list, adding Material UI, NextUI, Radix UI components, Redux Toolkit, Stripe JS, Cropper.js, ZegoCloud for video calls, and various utility libraries, while also adding the vite-plugin-node-polyfills dev dependency.

(dependencies) · high confidence

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

• CAI 35 → 37 (+1.5)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 74 → 66 (-8.0)
• Architecture 44 → 57 (+13.6)
• Maturity 49 → 53 (+3.7)
• Readiness 18 → 19 (+1.0)
• Security 75 → 77 (+2.1)
• Accessibility 45 → 45 (+0.4)

• Boundary-crossing change coupling: CreatePostFormSubmit.tsx ↔ postSlice.ts (Frontend/src/components/create-post/CreatePostFormSubmit.tsx)
• Change coupling: App.tsx ↔ Image.tsx (Frontend/src/App.tsx)
• Change coupling: App.tsx ↔ SignInForm.tsx (Frontend/src/App.tsx)
• Change coupling: CreatePostBody.tsx ↔ CreatePostFormSubmit.tsx (Frontend/src/components/create-post/CreatePostBody.tsx)
• Change coupling: MusicDetialsTable.tsx ↔ UserDetialsTable.tsx (Frontend/src/components/admin/music/MusicDetialsTable.tsx)
• Change coupling: OtpForm.tsx ↔ SignInForm.tsx (Frontend/src/components/authentication/OtpForm.tsx)
• Change coupling: OtpForm.tsx ↔ SignUpForm.tsx (Frontend/src/components/authentication/OtpForm.tsx)
• Change coupling: Sidebar.tsx ↔ EditProfileForm.tsx (Frontend/src/components/common/Sidebar.tsx)
• Change coupling: SignInForm.tsx ↔ SignUpForm.tsx (Frontend/src/components/authentication/SignInForm.tsx)
• Critical CVE: [GHSA redacted] (Backend/package-lock.json)
• Critical CVE: [GHSA redacted] (Frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (Frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (Frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (Backend/package-lock.json)
• Critical CVE: [GHSA redacted] (Backend/package-lock.json)
• Critical CVE: [GHSA redacted] (Backend/package-lock.json)
• Critical CVE: [GHSA redacted] (Frontend/package-lock.json)
• Critical CVE: [GHSA redacted] (Frontend/package-lock.json)
• Dependency hygiene not measured — dependency manifest found but not parsed for hygiene
• Dormant codebase
• …and 43 more

• AddMusicForm.AddMusicForm (cognitive 41) (Frontend/src/components/admin/music/AddMusicForm.tsx)
• AddMusicForm.AddMusicForm (cyclomatic 31) (Frontend/src/components/admin/music/AddMusicForm.tsx)
• AdminProfileDetials.AdminProfileDetails (cognitive 34) (Frontend/src/components/admin/profile/AdminProfileDetials.tsx)
• AdminProfileDetials.AdminProfileDetails (cyclomatic 28) (Frontend/src/components/admin/profile/AdminProfileDetials.tsx)
• AudioRecoding.AudioRecorder (cyclomatic 17) (Frontend/src/components/chats/AudioRecoding.tsx)
• CallModal.CallModal (cognitive 34) (Frontend/src/components/calls/CallModal.tsx)
• CallModal.CallModal (cyclomatic 23) (Frontend/src/components/calls/CallModal.tsx)
• Change coupling clique: App.tsx, SignInForm.tsx, SignUpForm.tsx (Frontend/src/App.tsx)
• ChangePost.ChangePost (cognitive 35) (Frontend/src/components/create-post/ChangePost.tsx)
• ChangePost.ChangePost (cyclomatic 34) (Frontend/src/components/create-post/ChangePost.tsx)
• ChatDetials.ChatDetials (cognitive 66) (Frontend/src/components/chats/ChatDetials.tsx)
• ChatDetials.ChatDetials (cyclomatic 61) (Frontend/src/components/chats/ChatDetials.tsx)
• ChatInbox.ChatsInbox (cognitive 116) (Frontend/src/components/chats/ChatInbox.tsx)
• ChatInbox.ChatsInbox (cyclomatic 66) (Frontend/src/components/chats/ChatInbox.tsx)
• ClassTooLong: PostModal (Frontend/src/components/common/PostViewModal/PostModal.tsx)
• CreatePostBody.CreatePostBody (cognitive 40) (Frontend/src/components/create-post/CreatePostBody.tsx)
• CreatePostBody.CreatePostBody (cyclomatic 45) (Frontend/src/components/create-post/CreatePostBody.tsx)
• CreatePostFilters.CreatePostFilters (cyclomatic 29) (Frontend/src/components/create-post/CreatePostFilters.tsx)
• CreatePostFormSubmit.CreatePostFormSubmit (cognitive 39) (Frontend/src/components/create-post/CreatePostFormSubmit.tsx)
• CreatePostFormSubmit.CreatePostFormSubmit (cyclomatic 26) (Frontend/src/components/create-post/CreatePostFormSubmit.tsx)
• …and 240 more

• 2 commits — 2 feature/other, 0 fixes

• (repo) — 1 commit
• Backend/package-lock.json — 1 commit

• change: Merge pull request #1 from shahzadahamad/dependabot/npm_and_yarn/Backend/multer-2.3.0
• change: chore(deps): bump multer from 1.4.5-lts.1 to 2.3.0 in /Backend

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

shahzadahamad/Instant 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.