create-warlock 3.0.15 → 3.0.17

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "create-warlock",
-    "version": "3.0.15",
+    "version": "3.0.17",
     "main": "./esm/index.js",
     "license": "MIT",
     "type": "module",

package/templates/warlock/package.json

@@ -30,11 +30,12 @@
         "@mongez/dotenv": "^1.1.9",
         "@mongez/config": "^1.0.26",
         "@mongez/supportive-is": "^2.0.4",
-        "@warlock.js/auth": "3.0.15",
-        "@warlock.js/cache": "3.0.15",
-        "@warlock.js/cascade": "3.0.15",
-        "@warlock.js/core": "3.0.15",
-        "@warlock.js/logger": "3.0.15",
+        "@warlock.js/auth": "3.0.17",
+        "@warlock.js/cache": "3.0.17",
+        "@warlock.js/cascade": "3.0.17",
+        "@warlock.js/core": "3.0.17",
+        "@warlock.js/logger": "3.0.17",
+        "@warlock.js/seal": "3.0.17",
         "@faker-js/faker": "^9.2.0",
         "dayjs": "^1.11.13"
     },

package/templates/warlock/src/app/users/controllers/auth/{activate-account.ts → activate-account.controller.ts}

@@ -1,8 +1,13 @@
 import type { Request, Response } from "@warlock.js/core";
 import { usersRepository } from "app/users/repositories/users.repository";
-
-export default async function activateAccount(
-  request: Request,
+import { loginUserService } from "app/users/services/login.service";
+import {
+  activateAccountSchema,
+  type ActivateAccountData,
+} from "app/users/validation/activate-account.validation";
+
+export default async function activateAccountController(
+  request: Request<ActivateAccountData>,
   response: Response,
 ) {
   const currentUser = request.user;
@@ -14,25 +19,15 @@ export default async function activateAccount(
     activatedAt: new Date(),
   });
 
-  const accessToken = await currentUser.generateAccessToken();
+  const loginData = await loginUserService(currentUser);
 
-  return response.success({
-    user: {
-      ...(await currentUser.toJSON()),
-      accessToken: accessToken,
-      userType: currentUser.userType,
-    },
-  });
+  return response.success(loginData);
 }
 
-activateAccount.validation = {
-  rules: {
-    code: ["required"],
-    email: ["required", "email"],
-  },
+activateAccountController.validation = {
+  schema: activateAccountSchema,
   validate: async (request: Request, response: Response) => {
     const user = await usersRepository.first({
-      isActive: false,
       email: request.input("email"),
       activationCode: request.int("code"),
     });
@@ -43,6 +38,12 @@ activateAccount.validation = {
       });
     }
 
+    if (user.isActive) {
+      return response.badRequest({
+        error: "User already activated",
+      });
+    }
+
     request.user = user;
   },
 };

package/templates/warlock/src/app/users/controllers/auth/admin-login.controller.ts

@@ -0,0 +1,39 @@
+import type { Request, Response } from "@warlock.js/core";
+import { User } from "app/users/models/user";
+import { loginUserService } from "app/users/services/login.service";
+import {
+  adminLoginSchema,
+  type AdminLoginData,
+} from "app/users/validation/admin-login.validation";
+
+export default async function adminLoginController(
+  request: Request<AdminLoginData>,
+  response: Response,
+) {
+  const user = request.user;
+
+  const loginData = await loginUserService(user);
+
+  return response.success(loginData);
+}
+
+adminLoginController.validation = {
+  schema: adminLoginSchema,
+  validate: async (request: Request, response: Response) => {
+    const user = await User.attempt(request.validated());
+
+    if (!user) {
+      return response.badRequest({
+        error: "Invalid credentials",
+      });
+    }
+
+    if (!user.get("isActive")) {
+      return response.badRequest({
+        error: "Your account is suspended!",
+      });
+    }
+
+    request.user = user;
+  },
+};

package/templates/warlock/src/app/users/controllers/auth/create-account.controller.ts

@@ -0,0 +1,25 @@
+import type { Request, RequestHandler, Response } from "@warlock.js/core";
+import { createAccountService } from "app/users/services/account.service";
+import { loginUserService } from "app/users/services/login.service";
+import {
+  createAccountSchema,
+  type CreateAccountData,
+} from "app/users/validation/create-account.validation";
+
+export const createAccountController: RequestHandler = async (
+  request: Request<CreateAccountData>,
+  response: Response,
+) => {
+  const user = await createAccountService(request.validated());
+
+  request.guest = request.user;
+  request.user = user;
+
+  return response.success({
+    user: await loginUserService(user),
+  });
+};
+
+createAccountController.validation = {
+  schema: createAccountSchema,
+};

package/templates/warlock/src/app/users/controllers/auth/login.controller.ts

@@ -0,0 +1,32 @@
+import {
+  type Request,
+  type RequestHandler,
+  type Response,
+} from "@warlock.js/core";
+import { User } from "app/users/models/user";
+import { loginUserService } from "app/users/services/login.service";
+import {
+  loginSchema,
+  type LoginData,
+} from "app/users/validation/login.validation";
+
+export const loginController: RequestHandler = async (
+  request: Request<LoginData>,
+  response: Response,
+) => {
+  const user = await User.attempt(request.validated());
+
+  if (!user) {
+    return response.badRequest({
+      error: "Invalid credentials",
+    });
+  }
+
+  const loginData = await loginUserService(user);
+
+  return response.success(loginData);
+};
+
+loginController.validation = {
+  schema: loginSchema,
+};

package/templates/warlock/src/app/users/routes.ts

@@ -5,23 +5,23 @@ import {
   guardedGuest,
   guardedGuestAdmin,
 } from "app/utils/router";
-import activateAccount from "./controllers/auth/activate-account";
-import adminLogin from "./controllers/auth/admin-login";
-import forgetPassword from "./controllers/auth/forget-password";
-import { loginRequest } from "./controllers/auth/login.request";
-import logout from "./controllers/auth/logout";
-import { registerRequest } from "./controllers/auth/register.request";
-import resendActivationCode from "./controllers/auth/resend-activation-code";
-import resetPassword from "./controllers/auth/reset-password";
-import verifyForgetPasswordCode from "./controllers/auth/verify-forget-password-code";
-import changePassword from "./controllers/profile/change-password";
-import myProfile from "./controllers/profile/my-profile";
-import updateProfile from "./controllers/profile/update-profile";
-import { restfulUsers } from "./controllers/restful-users";
+import activateAccountController from "./controllers/auth/activate-account.controller";
+import adminLoginController from "./controllers/auth/admin-login.controller";
+import { createAccountController } from "./controllers/auth/create-account.controller";
+import forgetPassword from "./controllers/auth/forget-password.controller";
+import { loginController } from "./controllers/auth/login.controller";
+import logout from "./controllers/auth/logout.controller";
+import resendActivationCode from "./controllers/auth/resend-activation-code.controller";
+import resetPassword from "./controllers/auth/reset-password.controller";
+import verifyForgetPasswordCode from "./controllers/auth/verify-forget-password-code.controller";
+import changePassword from "./controllers/profile/change-password.controller";
+import myProfile from "./controllers/profile/my-profile.controller";
+import updateProfile from "./controllers/profile/update-profile.controller";
+import { restfulUsers } from "./controllers/users.restful";
 
 // admin auth
 guardedGuestAdmin(() => {
-  router.post("/login", adminLogin);
+  router.post("/login", adminLoginController);
   router.post("/forget-password", forgetPassword);
   router.post("/reset-password", resetPassword);
 });
@@ -33,9 +33,9 @@ guardedAdmin(() => {
 
 // user auth
 guardedGuest(() => {
-  router.post("/login", loginRequest);
-  router.post("/register", registerRequest);
-  router.post("/register/verify", activateAccount);
+  router.post("/login", loginController);
+  router.post("/register", createAccountController);
+  router.post("/register/verify", activateAccountController);
   router.post("/resend-activation-code", resendActivationCode);
   router.post("/forget-password", forgetPassword);
   router.post("/forget-password/verify-code", verifyForgetPasswordCode);

package/templates/warlock/src/app/users/services/account.service.ts

@@ -0,0 +1,16 @@
+import { Random } from "@mongez/reinforcements";
+import type { User } from "app/users/models/user";
+import usersRepository from "app/users/repositories/users-repository";
+
+/**
+ * Create a new user account
+ */
+export async function createAccountService(
+  profileData: Record<string, any>,
+): Promise<User> {
+  return await usersRepository.create({
+    isCustomer: true,
+    ...profileData,
+    activationCode: Random.int(100000, 999999),
+  });
+}

package/templates/warlock/src/app/users/services/login.service.ts

@@ -0,0 +1,18 @@
+import type { User } from "app/users/models/user";
+
+/**
+ * Login user and return user data with access token
+ */
+export async function loginUserService(user: User): Promise<{
+  user: any;
+  accessToken: string;
+  userType: string;
+}> {
+  const accessToken = await user.generateAccessToken();
+  
+  return {
+    user: await user.toJSON(),
+    accessToken: accessToken,
+    userType: user.userType,
+  };
+}

package/templates/warlock/src/app/users/validation/activate-account.validation.ts

@@ -0,0 +1,8 @@
+import { v, type Infer } from "@warlock.js/core";
+
+export const activateAccountSchema = v.object({
+  email: v.string().email().required(),
+  code: v.string().required(),
+});
+
+export type ActivateAccountData = Infer<typeof activateAccountSchema>;

package/templates/warlock/src/app/users/validation/admin-login.validation.ts

@@ -0,0 +1,8 @@
+import { v, type Infer } from "@warlock.js/core";
+
+export const adminLoginSchema = v.object({
+  email: v.string().email().required(),
+  password: v.string().required(),
+});
+
+export type AdminLoginData = Infer<typeof adminLoginSchema>;

package/templates/warlock/src/app/users/validation/create-account.validation.ts

@@ -0,0 +1,10 @@
+import { v, type Infer } from "@warlock.js/core";
+
+export const createAccountSchema = v.object({
+  name: v.string().minLength(2).required(),
+  email: v.string().email().required(),
+  password: v.string().minLength(8).required().strongPassword(),
+  confirmPassword: v.string().minLength(8).required().saveAs("password"),
+});
+
+export type CreateAccountData = Infer<typeof createAccountSchema>;

package/templates/warlock/src/app/users/validation/login.validation.ts

@@ -0,0 +1,8 @@
+import { v, type Infer } from "@warlock.js/core";
+
+export const loginSchema = v.object({
+  email: v.string().email().required(),
+  password: v.string().required(),
+});
+
+export type LoginData = Infer<typeof loginSchema>;

package/templates/warlock/src/app/users/controllers/auth/admin-login.ts

@@ -1,40 +0,0 @@
-import type { Request, Response } from "@warlock.js/core";
-import { User } from "app/users/models/user";
-
-export default async function adminLogin(request: Request, response: Response) {
-  const user = request.user;
-
-  const auth = await user.generateAccessToken();
-
-  return response.success({
-    user: {
-      ...(await user.toJSON()),
-      accessToken: auth,
-      userType: user.userType,
-    },
-  });
-}
-
-adminLogin.validation = {
-  rules: {
-    password: ["required"],
-    email: ["required", "email"],
-  },
-  validate: async (request: Request, response: Response) => {
-    const user = await User.attempt(request.only(["email", "password"]));
-
-    if (!user) {
-      return response.badRequest({
-        error: "Invalid credentials",
-      });
-    }
-
-    if (!user.get("isActive")) {
-      return response.badRequest({
-        error: "Your account is suspended!",
-      });
-    }
-
-    request.user = user;
-  },
-};

package/templates/warlock/src/app/users/controllers/auth/login.request.ts

@@ -1,28 +0,0 @@
-import {
-  type Request,
-  type RequestHandler,
-  type Response,
-} from "@warlock.js/core";
-import { User } from "app/users/models/user";
-
-export const loginRequest: RequestHandler = async (
-  request: Request,
-  response: Response,
-) => {
-  const user = await User.attempt(request.only(["email", "password"]));
-
-  if (!user) {
-    return response.badRequest({
-      message: "Invalid credentials",
-    });
-  }
-
-  // generate a JWT token for the logged-in user
-  const token = await user.generateAccessToken();
-
-  return response.success({
-    message: "User logged in successfully",
-    user,
-    accessToken: token,
-  });
-};

package/templates/warlock/src/app/users/controllers/auth/register.request.ts

@@ -1,24 +0,0 @@
-import { Random } from "@mongez/reinforcements";
-import type { RequestHandler } from "@warlock.js/core";
-import { v, type Request, type Response } from "@warlock.js/core";
-import { User } from "app/users/models/user";
-
-export const registerRequest: RequestHandler = async (
-  request: Request,
-  response: Response,
-) => {
-  User.create({
-    ...request.validated(),
-    activationCode: Random.int(100000, 999999),
-  });
-
-  return response.success();
-};
-
-registerRequest.validation = {
-  schema: v.object({
-    name: v.string().minLength(2).required(),
-    email: v.string().email().required().unique(User),
-    password: v.string().minLength(8).required(),
-  }),
-};