create-warlock 4.0.139 → 4.0.141

package/package.json

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

package/templates/warlock/package.json

@@ -23,13 +23,13 @@
         "@mongez/reinforcements": "^2.3.17",
         "@mongez/localization": "^3.2.1",
         "@mongez/supportive-is": "^2.0.4",
-        "@warlock.js/auth": "4.0.139",
-        "@warlock.js/cache": "4.0.139",
-        "@warlock.js/cascade": "4.0.139",
-        "@warlock.js/scheduler": "4.0.139",
-        "@warlock.js/core": "4.0.139",
-        "@warlock.js/logger": "4.0.139",
-        "@warlock.js/seal": "4.0.139",
+        "@warlock.js/auth": "4.0.141",
+        "@warlock.js/cache": "4.0.141",
+        "@warlock.js/cascade": "4.0.141",
+        "@warlock.js/scheduler": "4.0.141",
+        "@warlock.js/core": "4.0.141",
+        "@warlock.js/logger": "4.0.141",
+        "@warlock.js/seal": "4.0.141",
         "dayjs": "^1.11.19",
         "mongodb": "^7.0.0"
     },

package/templates/warlock/src/app/auth/controllers/forgot-password.controller.ts

@@ -5,52 +5,29 @@ import {
   type RequestHandler,
   type Response,
 } from "@warlock.js/core";
-import { usersRepository } from "app/users/repositories/users.repository";
-import { createOtpService } from "../services/otp.service";
+import { forgotPasswordService } from "../services/forgot-password.service";
 
 /**
  * Forgot password controller
  * POST /auth/forgot-password
  */
-export const forgotPassword: RequestHandler = async (
+export const forgotPasswordController: RequestHandler = async (
   request: Request,
   response: Response,
 ) => {
   const { email } = request.validated();
 
-  // Find user by email (silent fail for security)
-  const user = await usersRepository.first({ email });
+  await forgotPasswordService(email);
 
-  if (!user) {
-    // Silent success - don't reveal if email exists
-    return response.success({
-      message: t("auth.otpSent"),
-    });
-  }
-
-  // Create OTP
-  const otp = await createOtpService({
-    target: email,
-    channel: "email",
-    type: "password-reset",
-    userId: user.id,
-    userType: user.userType,
-  });
-
-  // TODO: Send email with OTP code
-  // await sendPasswordResetEmail(user, otp.get("code"));
-  console.log(`[DEV] Password reset OTP for ${email}: ${otp.get("code")}`);
-
-  // Always return success for security (don't reveal if email exists)
   return response.success({
     message: t("auth.otpSent"),
   });
 };
 
-forgotPassword.description = "Request password reset";
+forgotPasswordController.description = "Request password reset";
 
-forgotPassword.validation = {
+forgotPasswordController.validation = {
   schema: v.object({
-    email: v.string().email().required(),
+    email: v.email().required(),
   }),
 };

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

@@ -1,13 +1,13 @@
-import { t, type RequestHandler, type Response } from "@warlock.js/core";
+import { type RequestHandler, type Response } from "@warlock.js/core";
 import { type LoginRequest } from "../requests/login.request";
+import { loginSchema } from "../schema/login.schema";
 import { loginService } from "../services/auth.service";
-import { loginSchema } from "../validation/login.schema";
 
 /**
  * Login controller
  * POST /auth/login
  */
-export const login: RequestHandler = async (
+export const loginController: RequestHandler = async (
   request: LoginRequest,
   response: Response,
 ) => {
@@ -16,17 +16,11 @@ export const login: RequestHandler = async (
     ip: request.ip,
   });
 
-  if (!result) {
-    return response.unauthorized({
-      error: t("auth.invalidCredentials"),
-    });
-  }
-
   return response.success(result);
 };
 
-login.description = "User Login";
+loginController.description = "User Login";
 
-login.validation = {
+loginController.validation = {
   schema: loginSchema,
 };

package/templates/warlock/src/app/auth/controllers/logout-all.controller.ts

@@ -10,7 +10,7 @@ import { logoutAllService } from "../services/auth.service";
  * Logout from all devices controller
  * POST /auth/logout-all
  */
-export const logoutAll: RequestHandler = async (
+export const logoutAllController: RequestHandler = async (
   request: Request,
   response: Response,
 ) => {
@@ -21,4 +21,4 @@ export const logoutAll: RequestHandler = async (
   });
 };
 
-logoutAll.description = "Logout from all devices";
+logoutAllController.description = "Logout from all devices";

package/templates/warlock/src/app/auth/controllers/logout.controller.ts

@@ -10,7 +10,7 @@ import { logoutService } from "../services/auth.service";
  * Logout controller
  * POST /auth/logout
  */
-export const logout: RequestHandler = async (
+export const logoutController: RequestHandler = async (
   request: Request,
   response: Response,
 ) => {
@@ -21,4 +21,4 @@ export const logout: RequestHandler = async (
   });
 };
 
-logout.description = "User Logout";
+logoutController.description = "User Logout";

package/templates/warlock/src/app/auth/controllers/me.controller.ts

@@ -8,7 +8,7 @@ import {
  * Get current user controller
  * GET /auth/me
  */
-export const me: RequestHandler = async (
+export const meController: RequestHandler = async (
   request: Request,
   response: Response,
 ) => {
@@ -17,4 +17,4 @@ export const me: RequestHandler = async (
   });
 };
 
-me.description = "Get Current User";
+meController.description = "Get Current User";

package/templates/warlock/src/app/auth/controllers/refresh-token.controller.ts

@@ -1,5 +1,4 @@
 import {
-  t,
   v,
   type Request,
   type RequestHandler,
@@ -11,7 +10,7 @@ import { refreshTokensService } from "../services/auth.service";
  * Refresh token controller
  * POST /auth/refresh-token
  */
-export const refreshToken: RequestHandler = async (
+export const refreshTokenController: RequestHandler = async (
   request: Request,
   response: Response,
 ) => {
@@ -22,18 +21,12 @@ export const refreshToken: RequestHandler = async (
     ip: request.ip,
   });
 
-  if (!result) {
-    return response.unauthorized({
-      error: t("auth.invalidRefreshToken"),
-    });
-  }
-
   return response.success(result);
 };
 
-refreshToken.description = "Refresh Access Token";
+refreshTokenController.description = "Refresh Access Token";
 
-refreshToken.validation = {
+refreshTokenController.validation = {
   schema: v.object({
     refreshToken: v.string().required(),
   }),

package/templates/warlock/src/app/auth/controllers/reset-password.controller.ts

@@ -1,7 +1,7 @@
 import { t, type Response } from "@warlock.js/core";
 import { type ResetPasswordRequest } from "../requests/reset-password.request";
+import { resetPasswordSchema } from "../schema/reset-password.schema";
 import { resetPasswordService } from "../services/reset-password.service";
-import { resetPasswordSchema } from "../validation/reset-password.schema";
 
 /**
  * Reset password controller
@@ -10,9 +10,7 @@ export const resetPasswordController = async (
   request: ResetPasswordRequest,
   response: Response,
 ) => {
-  const { email, code, newPassword } = request.validated();
-
-  await resetPasswordService(email, code, newPassword);
+  await resetPasswordService(request.validated());
 
   return response.success({
     message: t("auth.passwordResetSuccess"),

package/templates/warlock/src/app/auth/main.ts

@@ -1,16 +1,11 @@
 import { authService } from "@warlock.js/auth";
-import { onceConnected } from "@warlock.js/cascade";
 import { scheduler } from "app/shared/services/scheduler.service";
 import { cleanupExpiredOtpsService } from "./services/otp.service";
 
-onceConnected(() => {
-  // Cleanup expired OTPs every hour
-  scheduler
-    .newJob("cleanup-expired-otps", cleanupExpiredOtpsService)
-    .everyHour();
+// Cleanup expired OTPs every hour
+scheduler.newJob("cleanup-expired-otps", cleanupExpiredOtpsService).everyHour();
 
-  // Cleanup expired refresh tokens every hour
-  scheduler
-    .newJob("cleanup-expired-tokens", () => authService.cleanupExpiredTokens())
-    .everyHour();
-});
+// Cleanup expired refresh tokens every hour
+scheduler
+  .newJob("cleanup-expired-tokens", () => authService.cleanupExpiredTokens())
+  .everyHour();

package/templates/warlock/src/app/auth/requests/guarded.request.ts

@@ -1,6 +1,7 @@
 import type { Request } from "@warlock.js/core";
 import type { User } from "app/users/models/user";
 
-export type GuardedRequest<RequestPayload = unknown> = Request<RequestPayload> & {
-  user: User;
-};
+export type GuardedRequest<RequestPayload = unknown> =
+  Request<RequestPayload> & {
+    user: User;
+  };

package/templates/warlock/src/app/auth/requests/login.request.ts

@@ -1,4 +1,4 @@
 import type { Request } from "@warlock.js/core";
-import { type LoginSchema } from "../validation/login.schema";
+import { type LoginSchema } from "../schema/login.schema";
 
 export type LoginRequest = Request<LoginSchema>;

package/templates/warlock/src/app/auth/requests/reset-password.request.ts

@@ -1,4 +1,4 @@
 import type { Request } from "@warlock.js/core";
-import { type ResetPasswordSchema } from "../validation/reset-password.schema";
+import { type ResetPasswordSchema } from "../schema/reset-password.schema";
 
 export type ResetPasswordRequest = Request<ResetPasswordSchema>;

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

@@ -1,22 +1,22 @@
 import { router } from "@warlock.js/core";
 import { guarded } from "app/shared/utils/router";
-import { forgotPassword } from "./controllers/forgot-password.controller";
-import { login } from "./controllers/login.controller";
-import { logoutAll } from "./controllers/logout-all.controller";
-import { logout } from "./controllers/logout.controller";
-import { me } from "./controllers/me.controller";
-import { refreshToken } from "./controllers/refresh-token.controller";
+import { forgotPasswordController } from "./controllers/forgot-password.controller";
+import { loginController } from "./controllers/login.controller";
+import { logoutAllController } from "./controllers/logout-all.controller";
+import { logoutController } from "./controllers/logout.controller";
+import { meController } from "./controllers/me.controller";
+import { refreshTokenController } from "./controllers/refresh-token.controller";
 import { resetPasswordController } from "./controllers/reset-password.controller";
 
 // Auth routes
 router.prefix("/auth", () => {
-  router.post("/login", login);
-  router.post("/refresh-token", refreshToken);
-  router.post("/forgot-password", forgotPassword);
+  router.post("/login", loginController);
+  router.post("/refresh-token", refreshTokenController);
+  router.post("/forgot-password", forgotPasswordController);
   router.post("/reset-password", resetPasswordController);
   guarded(() => {
-    router.post("/logout", logout);
-    router.post("/logout-all", logoutAll);
-    router.get("/me", me);
+    router.post("/logout", logoutController);
+    router.post("/logout-all", logoutAllController);
+    router.get("/me", meController);
   });
 });

package/templates/warlock/src/app/auth/services/auth.service.ts

@@ -1,5 +1,6 @@
-import type { Auth } from "@warlock.js/auth";
+import type { AccessTokenOutput, Auth } from "@warlock.js/auth";
 import { authService, type DeviceInfo, type TokenPair } from "@warlock.js/auth";
+import { t, UnAuthorizedError } from "@warlock.js/core";
 import { User } from "app/users/models/user/user.model";
 
 export type LoginCredentials = {
@@ -9,12 +10,13 @@ export type LoginCredentials = {
 
 export type LoginResult =
   | {
-      user: Auth;
+      user: User;
       tokens: TokenPair;
     }
+  | null
   | {
-      user: Auth;
-      accessToken: string;
+      user: User;
+      accessToken: AccessTokenOutput;
     };
 
 /**
@@ -23,8 +25,14 @@ export type LoginResult =
 export async function loginService(
   credentials: LoginCredentials,
   deviceInfo?: DeviceInfo,
-): Promise<LoginResult | null> {
-  return authService.login(User, credentials, deviceInfo);
+): Promise<LoginResult> {
+  const result = await authService.login(User, credentials, deviceInfo);
+
+  if (!result) {
+    throw new UnAuthorizedError(t("auth.invalidCredentials"));
+  }
+
+  return result;
 }
 
 /**
@@ -47,6 +55,12 @@ export async function logoutAllService(user: Auth): Promise<void> {
 export async function refreshTokensService(
   refreshToken: string,
   deviceInfo?: DeviceInfo,
-): Promise<TokenPair | null> {
-  return authService.refreshTokens(refreshToken, deviceInfo);
+): Promise<TokenPair> {
+  const result = await authService.refreshTokens(refreshToken, deviceInfo);
+
+  if (!result) {
+    throw new UnAuthorizedError(t("auth.invalidRefreshToken"));
+  }
+
+  return result;
 }

package/templates/warlock/src/app/auth/services/forgot-password.service.ts

@@ -0,0 +1,30 @@
+import { getFirstUserService } from "app/users/services/list-users.service";
+import { createOtpService } from "./otp.service";
+
+/**
+ * Example Usage:
+ * await forgotPasswordService("user@example.com");
+ */
+
+/**
+ * Handle forgot password request
+ *
+ * @param email - User email address
+ * @returns Promise<void>
+ */
+export async function forgotPasswordService(email: string): Promise<void> {
+  // Find user by email (silent fail for security)
+  const user = await getFirstUserService({ email });
+
+  // Create OTP
+  const otp = await createOtpService({
+    target: email,
+    channel: "email",
+    type: "password-reset",
+    userId: user.id,
+    userType: user.userType,
+  });
+
+  // TODO: Send email with OTP code using a mail service
+  // await sendPasswordResetEmail(user, otp.get("code"));
+}

package/templates/warlock/src/app/auth/services/otp.service.ts

@@ -23,7 +23,7 @@ export type CreateOTPOptions = {
   target: string;
   channel: OTPChannel;
   type: OTPType;
-  userId?: number;
+  userId?: number | string;
   userType?: string;
   expiresIn?: Duration;
   length?: number;

package/templates/warlock/src/app/auth/services/reset-password.service.ts

@@ -4,14 +4,20 @@ import { User } from "app/users/models/user";
 import { AuthErrorCode } from "../utils/auth-error-code";
 import { verifyOtpService } from "./otp.service";
 
+type ResetPasswordOptions = {
+  email: string;
+  code: string;
+  newPassword: string;
+};
+
 /**
  * Reset user password using OTP verification
  */
 export async function resetPasswordService(
-  email: string,
-  code: string,
-  newPassword: string,
+  options: ResetPasswordOptions,
 ): Promise<User> {
+  const { email, code, newPassword } = options;
+
   // Verify OTP
   const otp = await verifyOtpService(code, email, "password-reset");
 

package/templates/warlock/src/app/users/controllers/{get-users.controller.ts → list-users.controller.ts}

@@ -5,13 +5,12 @@ import {
 } from "@warlock.js/core";
 import { usersRepository } from "../repositories/users.repository";
 
-export const getUsersController: RequestHandler = async (
+export const listUsersController: RequestHandler = async (
   request: Request,
   response: Response,
 ) => {
   const users = await usersRepository.listCached({
     ...request.all(),
-    simpleSelect: true,
   });
 
   return response.success({
@@ -19,4 +18,4 @@ export const getUsersController: RequestHandler = async (
   });
 };
 
-getUsersController.description = "Get Users Controller";
+listUsersController.description = "List Users Controller";

package/templates/warlock/src/app/users/models/user/user.model.ts

@@ -1,32 +1,14 @@
 import { Auth } from "@warlock.js/auth";
-import { hasMany, RegisterModel } from "@warlock.js/cascade";
-import {
-  defineResource,
-  uploadedFileMetadataSchema,
-  useHashedPassword,
-} from "@warlock.js/core";
+import { RegisterModel } from "@warlock.js/cascade";
+import { useHashedPassword } from "@warlock.js/core";
 import { type Infer, v } from "@warlock.js/seal";
-import { type Post } from "app/posts/models/post/post.model";
 import { globalColumnsSchema } from "app/shared/utils/global-columns-schema";
-
-const UserResource = defineResource({
-  schema: {
-    id: "number",
-    name: "string",
-    email: "string",
-    image: "storageUrl",
-    createdAt: "date",
-    updatedAt: "date",
-    isActive: "boolean",
-    type: () => "user",
-  },
-});
+import { UserResource } from "app/users/resources/user.resource";
 
 export const userSchema = globalColumnsSchema.extend({
-  name: v.string().required().trim(),
-  email: v.email().requiredIfEmpty("id").unique("User"),
+  name: v.string().required(),
+  email: v.email().requiredIfEmpty("id"),
   image: v.string(),
-  imageMetadata: uploadedFileMetadataSchema,
   password: v
     .string()
     .min(6)
@@ -48,12 +30,6 @@ export class User extends Auth<UserSchema> {
    */
   public static schema = userSchema;
 
-  public static relations = {
-    posts: hasMany("Post", { foreignKey: "authorId" }),
-  };
-
-  public posts?: Post[];
-
   /**
    * Embed fields when saving in another model
    */

package/templates/warlock/src/app/users/repositories/users.repository.ts

@@ -2,22 +2,22 @@ import type { FilterRules, RepositoryOptions } from "@warlock.js/core";
 import { RepositoryManager } from "@warlock.js/core";
 import { User } from "../models/user";
 
-class UsersRepository extends RepositoryManager<User> {
-  public source = User;
+export type UserFilter = {
+  email?: string;
+  name?: string;
+  id?: string;
+};
+
+export type UsersListOptions = RepositoryOptions & UserFilter;
 
-  public simpleSelectColumns: string[] = ["id", "name", "createdAt"];
+class UsersRepository extends RepositoryManager<User, UserFilter> {
+  public source = User;
 
   public filterBy: FilterRules = {
-    id: "int",
+    id: "=",
     name: "like",
     email: "=",
   };
-
-  public defaultOptions: RepositoryOptions = {
-    orderBy: {
-      createdAt: "desc",
-    },
-  };
 }
 
 export const usersRepository = new UsersRepository();

package/templates/warlock/src/app/users/resources/user.resource.ts

@@ -0,0 +1,14 @@
+import { defineResource } from "@warlock.js/core";
+
+export const UserResource = defineResource({
+  schema: {
+    id: "number",
+    name: "string",
+    email: "string",
+    image: "storageUrl",
+    createdAt: "date",
+    updatedAt: "date",
+    isActive: "boolean",
+    type: () => "user",
+  },
+});

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

@@ -1,8 +1,11 @@
 import { router } from "@warlock.js/core";
 import { guarded } from "app/shared/utils/router";
 import { createNewUserController } from "./controllers/create-new-user.controller";
-import { getUsersController } from "./controllers/get-users.controller";
+import { listUsersController } from "./controllers/list-users.controller";
 
 guarded(() => {
-  router.route("/users").get(getUsersController).post(createNewUserController);
+  router
+    .route("/users")
+    .list(listUsersController)
+    .post(createNewUserController);
 });

package/templates/warlock/src/app/users/services/list-users.service.ts

@@ -1,7 +1,17 @@
+import { ResourceNotFoundError } from "@warlock.js/core";
+import type { UsersListOptions } from "../repositories/users.repository";
 import { usersRepository } from "../repositories/users.repository";
 
-export async function listUsersService() {
-  return usersRepository.allActiveCached({
-    select: ["id", "name", "email", "isActive", "age"],
-  });
+export async function listUsersService(filters: UsersListOptions = {}) {
+  return usersRepository.listActiveCached(filters);
+}
+
+export async function getFirstUserService(filters: UsersListOptions = {}) {
+  const user = await usersRepository.firstActiveCached(filters);
+
+  if (!user) {
+    throw new ResourceNotFoundError("No user found");
+  }
+
+  return user;
 }

package/templates/warlock/src/config/repository.ts

@@ -0,0 +1,11 @@
+import type { RepositoryConfigurations } from "@warlock.js/core";
+
+export default {
+  isActiveColumn: "status",
+  isActiveValue: "active",
+  defaultOptions: {
+    orderBy: {
+      created_at: "desc",
+    },
+  },
+} as RepositoryConfigurations;