exp-node-server 1.1.7 → 2.0.0

package/templates/prisma/src/app/modules/account/account.swagger.ts

@@ -1,186 +1,277 @@
 export const accountSwaggerDocs = {
-  "/api/auth/sign-up": {
+  '/api/auth/sign-up': {
     post: {
-      tags: ["account"],
-      summary: "Create  new account",
-      description: "",
+      tags: ['auth'],
+      summary: 'Create  new account',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              email: "user@gmail.com",
-              password: "password",
-              fullName: "User",
+              email: 'user@gmail.com',
+              password: 'password',
+              fullName: 'User',
             }),
           },
         },
       },
       responses: {
-        201: { description: "account created successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'account created successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/sign-in": {
+  '/api/auth/sign-in': {
     post: {
-      tags: ["account"],
-      summary: "Sign In your account",
-      description: "",
+      tags: ['auth'],
+      summary: 'Sign In your account',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              email: "user@gmail.com",
-              password: "password",
+              email: 'user@gmail.com',
+              password: 'password',
             }),
           },
         },
       },
       responses: {
-        201: { description: "User signed in successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'User signed in successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/verify-otp": {
+  '/api/auth/verify-otp': {
     put: {
-      tags: ["account"],
-      summary: "Verify OTP",
-      description: "",
+      tags: ['auth'],
+      summary: 'Verify OTP',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              email: "user@gmail.com",
-              otp: "654321",
+              email: 'user@gmail.com',
+              otp: '654321',
             }),
           },
         },
       },
       responses: {
-        201: { description: "OTP verification successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'OTP verification successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/verify-link": {
+  '/api/auth/verify-link': {
     put: {
-      tags: ["account"],
-      summary: "Verify Link",
-      description: "",
+      tags: ['auth'],
+      summary: 'Verify Link',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              token: "dsakfjasdkj",
+              token: 'dsakfjasdkj',
             }),
           },
         },
       },
       responses: {
-        201: { description: "Token verification successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'Token verification successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/me": {
+  '/api/auth/me': {
     get: {
-      tags: ["account"],
-      summary: "Get me account",
-      description: "",
+      tags: ['auth'],
+      summary: 'Get me account',
+      description: '',
       responses: {
-        200: { description: "account fetched successfully" },
-        401: { description: "unauthorized" },
+        200: { description: 'account fetched successfully' },
+        401: { description: 'unauthorized' },
       },
     },
   },
-  "/api/auth/change-password": {
+  '/api/auth/change-password': {
     put: {
-      tags: ["account"],
-      summary: "Change Password",
-      description: "",
+      tags: ['auth'],
+      summary: 'Change Password',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              oldPassword: "123456",
-              newPassword: "654321",
+              oldPassword: '123456',
+              newPassword: '654321',
             }),
           },
         },
       },
       responses: {
-        201: { description: "Passwrod change successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'Passwrod change successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/resend-otp": {
+  '/api/auth/resend-otp': {
     put: {
-      tags: ["account"],
-      summary: "Resend OTP",
-      description: "",
+      tags: ['auth'],
+      summary: 'Resend OTP',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              email: "user@gmail.com",
+              email: 'user@gmail.com',
             }),
           },
         },
       },
       responses: {
-        201: { description: "OTP resend successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'OTP resend successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/forget-password": {
+  '/api/auth/forget-password': {
     put: {
-      tags: ["account"],
-      summary: "Forget Password",
-      description: "",
+      tags: ['auth'],
+      summary: 'Forget Password',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              email: "user@gmail.com",
+              email: 'user@gmail.com',
             }),
           },
         },
       },
       responses: {
-        201: { description: "Forget password successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'Forget password successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },
-  "/api/auth/reset-password": {
+  '/api/auth/reset-password': {
     put: {
-      tags: ["account"],
-      summary: "Reset Password",
-      description: "",
+      tags: ['auth'],
+      summary: 'Reset Password',
+      description: '',
       requestBody: {
         required: true,
         content: {
-          "application/json": {
+          'application/json': {
             example: JSON.stringify({
-              token: "dkfjadskfds",
-              newPass: "newpass",
+              token: 'dkfjadskfds',
+              newPass: 'newpass',
             }),
           },
         },
       },
       responses: {
-        201: { description: "Password reset successfully" },
-        500: { description: "Validation error or internal server error" },
+        201: { description: 'Password reset successfully' },
+        500: { description: 'Validation error or internal server error' },
+      },
+    },
+  },
+  '/api/auth/refresh-token': {
+    post: {
+      tags: ['auth'],
+      summary: 'Get a new access token (and a rotated refresh token)',
+      description:
+        'Browsers send the `refresh_token` cookie automatically; other clients send it in the body. ' +
+        'Every call returns a new refresh token and invalidates the old one. Reusing an old ' +
+        'refresh token ends the whole session.',
+      requestBody: {
+        required: false,
+        content: {
+          'application/json': {
+            example: JSON.stringify({ refreshToken: 'only-for-non-browser-clients' }),
+          },
+        },
+      },
+      responses: {
+        200: { description: '{ accessToken, refreshToken }, both also set as httpOnly cookies' },
+        401: { description: 'Missing, invalid, expired or reused refresh token' },
+      },
+    },
+  },
+  '/api/auth/sign-out': {
+    post: {
+      tags: ['auth'],
+      summary: 'Sign out this device (revokes its refresh token, clears the cookies)',
+      responses: { 200: { description: 'Signed out' } },
+    },
+  },
+  '/api/auth/sign-out-all': {
+    post: {
+      tags: ['auth'],
+      summary: 'Sign out from all devices (revokes every access token)',
+      responses: {
+        200: { description: 'Signed out everywhere' },
+        401: { description: 'unauthorized' },
+      },
+    },
+  },
+  '/api/auth/social/providers': {
+    get: {
+      tags: ['social auth'],
+      summary: 'List the enabled social login providers',
+      responses: { 200: { description: 'Providers, with the URL that starts each login' } },
+    },
+  },
+  '/api/auth/social/{provider}': {
+    get: {
+      tags: ['social auth'],
+      summary: 'Start a social login (open in the browser, not via fetch)',
+      description:
+        "Link to it from the front-end: <a href='/api/auth/social/google?returnTo=/dashboard'>Login with Google</a>. " +
+        'After the provider, the browser is redirected to SOCIAL_REDIRECT_URL with `?code=` (and `returnTo`) on success, ' +
+        'or `?error=` (access_denied, invalid_state, email_unverified, account_disabled, social_login_failed).',
+      parameters: [
+        {
+          name: 'provider',
+          in: 'path',
+          required: true,
+          schema: {
+            type: 'string',
+            enum: ['google', 'facebook', 'github', 'twitter', 'linkedin', 'discord'],
+          },
+        },
+        {
+          name: 'returnTo',
+          in: 'query',
+          required: false,
+          schema: { type: 'string', example: '/dashboard' },
+          description: 'Path on the front-end to come back to. Only same-site paths are kept.',
+        },
+      ],
+      responses: { 302: { description: 'Redirect to the provider' } },
+    },
+  },
+  '/api/auth/social/exchange': {
+    post: {
+      tags: ['social auth'],
+      summary: 'Trade the single-use code from the social login redirect for an access token',
+      requestBody: {
+        required: true,
+        content: {
+          'application/json': { example: JSON.stringify({ code: 'code-from-redirect' }) },
+        },
+      },
+      responses: {
+        200: { description: 'Logged in (token in body and httpOnly cookie)' },
+        401: { description: 'Invalid, expired or already used code' },
       },
     },
   },

package/templates/prisma/src/app/modules/account/account.validation.ts

@@ -1,41 +1,63 @@
-import z from "zod";
+import z from 'zod';
+
+const email = z.email('A valid email is required.').transform((e) => e.toLowerCase());
+const password = z
+  .string('Password is required.')
+  .min(8, 'Password must be at least 8 characters.')
+  .max(72, 'Password must be at most 72 characters.'); // bcrypt ignores bytes past 72
 
 const sign_up = z.object({
-  email: z.string("Email is required."),
-  password: z.string("Password is required."),
-  fullName: z.string("Full name is required."),
+  email,
+  password,
+  fullName: z.string('Full name is required.').trim().min(1).max(100),
 });
 
-const sing_in = z.object({
-  email: z.string("Email is required."),
-  password: z.string("Password is required."),
+const sign_in = z.object({
+  email,
+  password: z.string('Password is required.').max(72),
 });
 
 const change_password = z.object({
-  oldPassword: z.string("Old Password is requied"),
-  newPassword: z.string("New Password is required"),
+  oldPassword: z.string('Old Password is required').max(72),
+  newPassword: password,
 });
 
 const verify_otp = z.object({
-  email: z.string("Email is requied"),
-  otp: z.string("OTP is required"),
+  email,
+  otp: z.string('OTP is required').regex(/^\d{6}$/, 'OTP must be 6 digits'),
 });
+
+const token = z.string('Token is required').min(1).max(2048);
+
 const verify_link = z.object({
-  token: z.string("Token is required "),
+  token,
 });
-const resend_otp = z.object({
-  email: z.string("Email is requied"),
+
+const email_only = z.object({
+  email,
 });
+
 const reset_pass = z.object({
-  token: z.string("Token is required"),
-  newPass: z.string("Password is required"),
+  token,
+  newPass: password,
 });
+
+// optional: browsers send the refresh token as a cookie instead
+const refresh_token = z.object({ refreshToken: z.string().min(1).max(256).optional() }).optional();
+
+const social_exchange = z.object({
+  code: z.string('Code is required').min(1).max(256),
+});
+
 export const account_validation = {
   sign_up,
-  sing_in,
+  sign_in,
   change_password,
   verify_otp,
-  resend_otp,
+  resend_otp: email_only,
+  forget_password: email_only,
   verify_link,
-  reset_pass
+  reset_pass,
+  social_exchange,
+  refresh_token,
 };

package/templates/prisma/src/app/modules/profile/profile.controller.ts

@@ -1,13 +1,13 @@
-import catchAsync from "../../utils/catch_async";
-import manageResponse from "../../utils/manage_response";
-import { profile_service } from "./profile.service";
+import catchAsync from '../../utils/catch_async.js';
+import manageResponse from '../../utils/manage_response.js';
+import { profile_service } from './profile.service.js';
 
 const update_profile = catchAsync(async (req, res) => {
   const result = await profile_service.update_profile_into_db(req);
   manageResponse(res, {
     success: true,
     statusCode: 200,
-    message: "profile updated successfully.",
+    message: 'profile updated successfully.',
     data: result,
   });
 });

package/templates/prisma/src/app/modules/profile/profile.route.ts

@@ -1,19 +1,25 @@
-import { Router } from "express";
-import RequestValidator from "../../middlewares/request_validator";
-import { profile_controller } from "./profile.controller";
-import { profile_validations } from "./profile.validation";
-import auth from "../../middlewares/auth";
-import uploader from "../../middlewares/uploader";
+import { Router } from 'express';
+import auth from '../../middlewares/auth.js';
+import RequestValidator from '../../middlewares/request_validator.js';
+import uploader from '../../middlewares/uploader.js';
+import { AppError } from '../../utils/app_error.js';
+import { profile_controller } from './profile.controller.js';
+import { profile_validations } from './profile.validation.js';
 
 const router = Router();
 
 router.patch(
-  "/",
-  auth("USER"),
-  uploader.single("file"),
-  (req, res, next) => {
-    req.body = JSON.parse(req?.body?.data);
-    next();
+  '/',
+  auth(),
+  uploader.single('file'),
+  // multipart forms send the JSON fields as a `data` string
+  (req, _res, next) => {
+    try {
+      req.body = req.body?.data ? JSON.parse(req.body.data) : {};
+      next();
+    } catch {
+      next(new AppError('`data` must be valid JSON', 400));
+    }
   },
   RequestValidator(profile_validations.update_profile),
   profile_controller.update_profile,

package/templates/prisma/src/app/modules/profile/profile.service.ts

@@ -1,24 +1,17 @@
-import { Request } from "express";
-import uploadCloud from "../../utils/cloudinary";
-import { prisma } from "../../lib/prisma";
-import { JwtPayloadType } from "../../utils/JWT";
+import { Request } from 'express';
+import { prisma } from '../../lib/prisma.js';
+import uploadCloud from '../../utils/cloudinary.js';
 
 const update_profile_into_db = async (req: Request) => {
-  const user = req?.user as JwtPayloadType;
-  const payload = req?.body;
-  const file = req?.file;
-  // check file and upload to cloud
-  if (file) {
-    const cloudRes = await uploadCloud(file);
-    payload.profilePhoto = cloudRes?.secure_url;
-  }
-  const result = await prisma.profile.update({
-    where: {
-      accountId: user.accountId as string,
-    },
-    data: payload,
+  const payload: { fullName?: string } = req.body;
+
+  // validation already ran (see profile.route.ts), so only valid requests upload
+  const profilePhoto = req.file ? (await uploadCloud(req.file, 'profiles')).secure_url : undefined;
+
+  return prisma.profile.update({
+    where: { accountId: req.user!.accountId },
+    data: { fullName: payload.fullName, profilePhoto },
   });
-  return result;
 };
 
 export const profile_service = {

package/templates/prisma/src/app/modules/profile/profile.swagger.ts

@@ -1,24 +1,24 @@
 export const profileSwaggerDocs = {
-  "/api/profile": {
+  '/api/profile': {
     patch: {
-      tags: ["profile"],
-      summary: "Update profile",
+      tags: ['profile'],
+      summary: 'Update profile',
       requestBody: {
         required: true,
         content: {
-          "multipart/form-data": {
+          'multipart/form-data': {
             schema: {
-              type: "object",
+              type: 'object',
               properties: {
                 data: {
-                  type: "object",
+                  type: 'object',
                   properties: {
-                    fullName: { type: "string" },
+                    fullName: { type: 'string' },
                   },
                 },
                 file: {
-                  type: "string",
-                  format: "binary",
+                  type: 'string',
+                  format: 'binary',
                 },
               },
             },
@@ -26,8 +26,8 @@ export const profileSwaggerDocs = {
         },
       },
       responses: {
-        200: { description: "profile updated successfully" },
-        500: { description: "Validation error or internal server error" },
+        200: { description: 'profile updated successfully' },
+        500: { description: 'Validation error or internal server error' },
       },
     },
   },

package/templates/prisma/src/app/modules/profile/profile.validation.ts

@@ -1,6 +1,6 @@
-import { z } from "zod";
+import { z } from 'zod';
 const update_profile = z.object({
-  fullName: z.string().optional(),
+  fullName: z.string().trim().min(1).max(100).optional(),
 });
 
 export const profile_validations = {