create-warlock 4.0.30 → 4.0.39

package/templates/warlock/src/app/auth/models/otp/otp.model.ts

@@ -1,35 +1,34 @@
-import { Model, type Casts, type Document } from "@warlock.js/cascade";
+import { Model, RegisterModel } from "@warlock.js/cascade";
+import { type Infer, v } from "@warlock.js/seal";
+import { globalColumnsSchema } from "app/shared/utils/global-columns-schema";
 
-export class OTP extends Model {
-  /**
-   * Collection name
-   */
-  public static collection = "otps";
+const otpSchema = globalColumnsSchema.extend({
+  code: v.string().required(),
+  type: v.string().required(),
+  target: v.string().required(),
+  channel: v.string().required(),
+  userId: v.number().required(),
+  userType: v.string().required(),
+  expiresAt: v.date().required(),
+  usedAt: v.date().optional(),
+  attempts: v.number().default(0),
+  maxAttempts: v.number().default(5),
+  metadata: v.record(v.any()).optional(),
+});
+
+type OTPSchema = Infer<typeof otpSchema>;
 
+@RegisterModel()
+export class OTP extends Model<OTPSchema> {
   /**
-   * Default value for model data
+   * Table name
    */
-  public defaultValue: Document = {
-    attempts: 0,
-    maxAttempts: 5,
-  };
+  public static table = "otps";
 
   /**
-   * Cast data types before saving
+   * Model schema
    */
-  protected casts: Casts = {
-    code: "string",
-    type: "string",
-    target: "string",
-    channel: "string",
-    userId: "number",
-    userType: "string",
-    expiresAt: "date",
-    usedAt: "date",
-    attempts: "number",
-    maxAttempts: "number",
-    metadata: "object",
-  };
+  public static schema = otpSchema;
 
   /**
    * Check if OTP is valid (not expired, not used, not max attempts)
@@ -59,17 +58,13 @@ export class OTP extends Model {
    * Mark OTP as used
    */
   public async markAsUsed(): Promise<this> {
-    return this.save({
-      usedAt: new Date(),
-    });
+    return this.set("usedAt", new Date()).save();
   }
 
   /**
    * Increment failed attempt
    */
   public async incrementAttempt(): Promise<this> {
-    return this.save({
-      attempts: this.get("attempts") + 1,
-    });
+    return this.set("attempts", this.get("attempts") + 1).save();
   }
 }

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

@@ -1,7 +1,7 @@
 import { v, type Infer, type Request } from "@warlock.js/core";
 
 export const loginSchema = v.object({
-  email: v.string().email().required(),
+  email: v.email().required(),
   password: v.string().required(),
 });
 

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

@@ -1,16 +1,21 @@
 import type { Auth } from "@warlock.js/auth";
 import { authService, type DeviceInfo, type TokenPair } from "@warlock.js/auth";
-import { User } from "app/users/models/user";
+import { User } from "app/users/models/user/user.model";
 
 export type LoginCredentials = {
   email: string;
   password: string;
 };
 
-export type LoginResult = {
-  user: Auth;
-  tokens: TokenPair;
-};
+export type LoginResult =
+  | {
+      user: Auth;
+      tokens: TokenPair;
+    }
+  | {
+      user: Auth;
+      accessToken: string;
+    };
 
 /**
  * Login with email and password

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

@@ -120,14 +120,6 @@ export async function verifyOtpService(
     });
   }
 
-  // Verify code matches
-  if (otp.get("code") !== code) {
-    await otp.incrementAttempt();
-    throw new ForbiddenError(t("auth.otpInvalid"), {
-      errorCode: AuthErrorCode.OTP_INVALID,
-    });
-  }
-
   // Mark as used
   await otp.markAsUsed();
 
@@ -164,11 +156,9 @@ export async function resendOtpService(
  * Cleanup expired OTPs
  */
 export async function cleanupExpiredOtpsService(): Promise<number> {
-  const expiredOtps = await OTP.aggregate().where("expiresAt", "<", new Date()).get();
+  const expiredOtps = await OTP.query().where("expiresAt", "<", new Date()).get();
 
-  for (const otp of expiredOtps) {
-    await otp.destroy();
-  }
+  await Promise.all(expiredOtps.map((otp) => otp.destroy()));
 
   return expiredOtps.length;
 }

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

@@ -25,7 +25,7 @@ export async function resetPasswordService(
   }
 
   // Update password
-  await user.save({ password: newPassword });
+  await user.set("password", newPassword).save();
 
   // Revoke all tokens (force re-login)
   // Or make it an option through user decision.

package/templates/warlock/src/app/posts/controllers/create-new-post.controller.ts

@@ -0,0 +1,20 @@
+import { type RequestHandler, v } from "@warlock.js/core";
+import { Post } from "../models/post/psot.model";
+
+export const createNewPostController: RequestHandler = async (request, response) => {
+  const post = await Post.create({
+    ...request.validated(),
+  });
+
+  return response.success({
+    post,
+  });
+};
+
+createNewPostController.validation = {
+  schema: v.object({
+    title: v.string().required(),
+    description: v.string(),
+    image: v.file().image().maxSize({ size: 2, unit: "MB" }).saveTo("posts"),
+  }),
+};

package/templates/warlock/src/app/posts/controllers/update-post.controller.ts

@@ -0,0 +1,24 @@
+import { type RequestHandler, v } from "@warlock.js/core";
+import { Post } from "../models/post/psot.model";
+
+export const updatePostController: RequestHandler = async (request, response) => {
+  const post = await Post.find(request.int("id"));
+
+  if (!post) {
+    return response.notFound();
+  }
+
+  await post.save({ merge: request.validated() });
+
+  return response.success({
+    post,
+  });
+};
+
+updatePostController.validation = {
+  schema: v.object({
+    title: v.string().required(),
+    description: v.string(),
+    image: v.file().image().maxSize({ size: 2, unit: "MB" }).saveTo("posts"),
+  }),
+};

package/templates/warlock/src/app/posts/models/post/psot.model.ts

@@ -0,0 +1,33 @@
+import { Model, RegisterModel } from "@warlock.js/cascade";
+import { defineResource, useComputedSlug } from "@warlock.js/core";
+import { type Infer, v } from "@warlock.js/seal";
+import { globalColumnsSchema } from "app/shared/utils/global-columns-schema";
+
+export const postSchema = globalColumnsSchema.extend({
+  title: v.string().required(),
+  description: v.string().required(),
+  slug: v.computed(useComputedSlug()),
+  image: v.string().required(),
+});
+
+export type PostSchema = Infer<typeof postSchema>;
+
+@RegisterModel()
+export class Post extends Model<PostSchema> {
+  public static table = "posts";
+
+  public static schema = postSchema;
+
+  public static resource = defineResource({
+    schema: {
+      id: "number",
+      slug: "string",
+      title: "string",
+      description: "string",
+      image: "storageUrl",
+      createdBy: "object",
+      updatedBy: "object",
+      isActive: "boolean",
+    },
+  });
+}

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

@@ -0,0 +1,11 @@
+import { router } from "@warlock.js/core";
+import { cloudUpload, guarded } from "app/utils/router";
+import { createNewPostController } from "./controllers/create-new-post.controller";
+import { updatePostController } from "./controllers/update-post.controller";
+
+guarded(() => {
+  cloudUpload(() => {
+    router.post("/posts", createNewPostController);
+  });
+  router.put("/posts/:id", updatePostController);
+});

package/templates/warlock/src/app/shared/utils/global-columns-schema.ts

@@ -0,0 +1,8 @@
+import { v } from "@warlock.js/seal";
+
+export const globalColumnsSchema = v.object({
+  createdBy: v.embed("User"),
+  updatedBy: v.embed("User"),
+  deletedBy: v.embed("User"),
+  isActive: v.boolean().default(true),
+});

package/templates/warlock/src/app/shared/utils/locales.ts

@@ -725,4 +725,8 @@ groupedTranslations("attributes", {
     en: "Name",
     ar: "الاسم",
   },
+  image: {
+    en: "Image",
+    ar: "الصورة",
+  },
 });

package/templates/warlock/src/app/uploads/controllers/fetch-uploaded-file.controller.ts

@@ -0,0 +1,32 @@
+import { fileExistsAsync } from "@mongez/fs";
+import { CACHE_FOR } from "@warlock.js/cache";
+import { Image, type RequestHandler, storage, v } from "@warlock.js/core";
+
+export const fetchUploadedFileController: RequestHandler = async (request, response) => {
+  const absolutePath = storage.root(request.input("*"));
+
+  const { w: width, h: height } = request.validated();
+
+  if (!(await fileExistsAsync(absolutePath))) {
+    return response.notFound();
+  }
+
+  if (width || height) {
+    const image = new Image(absolutePath);
+    image.resize({
+      width,
+      height,
+    });
+
+    return response.sendImage(image, CACHE_FOR.ONE_DAY);
+  }
+
+  return response.sendFile(absolutePath, CACHE_FOR.ONE_YEAR);
+};
+
+fetchUploadedFileController.validation = {
+  schema: v.object({
+    w: v.numeric().min(1),
+    h: v.numeric().min(1),
+  }),
+};

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

@@ -0,0 +1,4 @@
+import { router } from "@warlock.js/core";
+import { fetchUploadedFileController } from "./controllers/fetch-uploaded-file.controller";
+
+router.get("/uploads/*", fetchUploadedFileController);

package/templates/warlock/src/app/users/controllers/create-new-user.controller.ts

@@ -0,0 +1,28 @@
+import { v, type RequestHandler } from "@warlock.js/core";
+import { User } from "../models/user";
+
+export const createNewUserController: RequestHandler = async (request, response) => {
+  const file = request.file("image")!;
+
+  const output = await file.save("images");
+
+  const user = await User.create({
+    ...request.validated(["name", "email", "password"]),
+    image: output.path,
+    imageMetadata: await file.metadata(),
+  });
+
+  return response.success({
+    message: "File uploaded successfully",
+    user,
+  });
+};
+
+createNewUserController.validation = {
+  schema: v.object({
+    name: v.string().required(),
+    email: v.email().required().unique(User),
+    password: v.string().min(6),
+    image: v.file().image().required().maxSize({ unit: "MB", size: 1.5 }),
+  }),
+};

package/templates/warlock/src/app/users/controllers/get-users.controller.ts

@@ -1,9 +1,14 @@
 import { type Request, type RequestHandler, type Response } from "@warlock.js/core";
-import { getUsersService } from "../services/get-users.service";
+import { usersRepository } from "../repositories/users.repository";
 
 export const getUsersController: RequestHandler = async (request: Request, response: Response) => {
+  const users = await usersRepository.listCached({
+    ...request.all(),
+    simpleSelect: true,
+  });
+
   return response.success({
-    users: await getUsersService(),
+    users,
   });
 };
 

package/templates/warlock/src/app/users/events/inject-created-by-user.into-model.event.ts

@@ -0,0 +1,32 @@
+import { Model } from "@warlock.js/cascade";
+import { useCurrentUser } from "@warlock.js/core";
+
+const globalEvents = Model.globalEvents();
+
+const saveSubscription = globalEvents.onSaving(async (model, { isInsert }) => {
+  const user = useCurrentUser();
+
+  if (!user) return;
+
+  if (isInsert) {
+    if (model.schemaHas("createdBy")) {
+      model.set("createdBy", user);
+    }
+  }
+
+  if (model.schemaHas("updatedBy")) {
+    model.set("updatedBy", user);
+  }
+});
+
+const deleteSubscription = globalEvents.onDeleting(async (model) => {
+  const user = useCurrentUser();
+
+  if (!user) return;
+
+  if (model.schemaHas("deletedBy")) {
+    model.set("deletedBy", user);
+  }
+});
+
+export const cleanup = [saveSubscription, deleteSubscription];

package/templates/warlock/src/app/users/events/sync.ts

@@ -0,0 +1,5 @@
+import { modelSync } from "@warlock.js/cascade";
+import { Post } from "app/posts/models/post/psot.model";
+import { User } from "../models/user";
+
+modelSync.sync(User, Post, "createdBy");

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

@@ -0,0 +1,5 @@
+import { onceConnected } from "@warlock.js/cascade";
+
+onceConnected(async () => {
+  // TODO: Review cloud storage deleteDirectory not working as expected
+});

package/templates/warlock/src/app/users/models/user/migrations/11-12-2025_23-58-03-user.migration.ts

@@ -1,14 +1,14 @@
-import { migrationOffice, type Blueprint } from "@warlock.js/cascade";
+import { Migration } from "@warlock.js/cascade";
 import { User } from "../user.model";
 
-export default migrationOffice.register({
-  name: "userMigration",
-  createdAt: "11-12-2025_23-58-03",
-  blueprint: User.blueprint(),
-  up: (blueprint: Blueprint) => {
-    blueprint.unique("id");
-  },
-  down: (blueprint: Blueprint) => {
-    blueprint.dropUniqueIndex("id");
-  },
-});
+export default class UsersMigration extends Migration.for(User) {
+  public up() {
+    this.int("id").unique().autoIncrement();
+    this.unique("email");
+  }
+
+  public down() {
+    this.dropIndex("id");
+    this.dropUnique("email");
+  }
+}

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

@@ -1,46 +1,73 @@
 import { Auth } from "@warlock.js/auth";
-import { type Casts, type Document, type ModelSync } from "@warlock.js/cascade";
+import { RegisterModel } from "@warlock.js/cascade";
+import { defineResource, uploadedFileMetadataSchema, useHashedPassword } from "@warlock.js/core";
+import { type Infer, v } from "@warlock.js/seal";
+import { globalColumnsSchema } from "app/shared/utils/global-columns-schema";
 
-export class User extends Auth {
+const UserResource = defineResource({
+  schema: {
+    id: "number",
+    name: "string",
+    email: "string",
+    image: "storageUrl",
+    createdAt: "date",
+    updatedAt: "date",
+    isActive: "boolean",
+    type: () => "user",
+  },
+});
+
+export const userSchema = globalColumnsSchema.extend({
+  name: v.string().required().trim(),
+  email: v.email().requiredIfEmpty("id"),
+  image: v.string(),
+  imageMetadata: uploadedFileMetadataSchema,
+  password: v.string().min(6).requiredIfEmpty("id").addTransformer(useHashedPassword()),
+});
+
+export type UserSchema = Infer<typeof userSchema>;
+
+@RegisterModel()
+export class User extends Auth<UserSchema> {
   /**
    * Collection name
    */
-  public static collection = "users";
+  public static table = "users";
 
   /**
-   * List of models to sync with
-   * To sync with a single embedded document use: [User.sync("city")],
-   * this will update the city sub-document to all users when city model is updated.
-   * To sync with multiple embedded documents use: [Post.syncMany("keywords")],
-   * This will update the keywords sub-document to all posts when keywords model is updated.
+   * Model Schema
    */
-  public syncWith: ModelSync[] = [];
+  public static schema = userSchema;
 
   /**
-   * Default value for model data
-   * Works only when creating new records
+   * Embed fields when saving in another model
    */
-  public defaultValue: Document = {};
+  public static embed = ["id", "name"];
 
   /**
-   * User type
+   * Resource to be used when converting the model to JSON
    */
-  public userType = "user";
+  public static resource = UserResource;
 
   /**
-   * Cast data types before saving documents into database
+   * User type identifier
    */
-  protected casts: Casts = {
-    name: "string",
-    age: "number",
-    email: "string",
-    isActive: "boolean",
-  };
+  public get userType(): string {
+    return "user";
+  }
 
-  /**
-   * Define what columns should be used when model document is embedded in another document.
-   * Make sure to set only the needed columns to reduce the document size.
-   * This is useful for better performance when fetching data from database.
-   */
-  public embedded = ["id", "name"];
+  static {
+    // Local scopes
+    this.addScope("active", (query) => {
+      query.where("isActive", true);
+    });
+
+    this.addScope("admins", (query) => {
+      query.where("role", "admin");
+    });
+
+    this.addScope("verified", (query) => {
+      query.where("emailVerified", true);
+    });
+  }
 }

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

@@ -1,27 +1,23 @@
-import { RepositoryManager, type FilterByOptions, type RepositoryOptions } from "@warlock.js/core";
-import { User } from "./../models/user";
+import type { FilterRules, RepositoryOptions } from "@warlock.js/core";
+import { RepositoryManager } from "@warlock.js/core";
+import { User } from "../models/user";
 
-export class UsersRepository extends RepositoryManager<User> {
-  /**
-   * {@inheritDoc}
-   */
-  public model = User;
+class UsersRepository extends RepositoryManager<User> {
+  public source = User;
 
-  /**
-   * Simple columns selections
-   * Set the columns that need to be selected when passing 'simple' option with 'true'
-   */
-  public simpleSelectColumns = ["id"];
+  public simpleSelectColumns: string[] = ["id", "name", "createdAt"];
 
-  /**
-   * List default options
-   */
-  protected defaultOptions: RepositoryOptions = this.withDefaultOptions({});
+  public filterBy: FilterRules = {
+    id: "int",
+    name: "like",
+    email: "=",
+  };
 
-  /**
-   * Filter By options
-   */
-  protected filterBy: FilterByOptions = this.withDefaultFilters({});
+  public defaultOptions: RepositoryOptions = {
+    orderBy: {
+      createdAt: "desc",
+    },
+  };
 }
 
 export const usersRepository = new UsersRepository();

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

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

package/templates/warlock/src/app/users/seeds/users.seed.ts

@@ -0,0 +1,21 @@
+import { Random } from "@mongez/reinforcements";
+import { seeder } from "@warlock.js/core";
+import { User } from "../models/user";
+
+export default seeder({
+  name: "Seed Users",
+  once: true,
+  run: async () => {
+    for (let i = 0; i < 10; i++) {
+      await User.create({
+        name: `User ${Random.int()}`,
+        email: `user${Random.int()}@gmail.com`,
+        password: `password-${Random.int()}`,
+      });
+    }
+
+    return {
+      recordsCreated: 10,
+    };
+  },
+});

package/templates/warlock/src/app/utils/cloud-upload.middleware.ts

@@ -0,0 +1,14 @@
+import { type Request, type Response, storage, storageDriverContext } from "@warlock.js/core";
+
+export async function cloudUploadMiddleware(request: Request, _response: Response) {
+  if (request.path !== "/posts") return;
+
+  // Example 1: Set driver with tenant-specific prefix
+  storageDriverContext.setDriver(storage.getDriver("r2"), {
+    prefix: `tenant`,
+    metadata: { tenantId: request.user?.id },
+  });
+
+  // Example 2: Or just set prefix for same driver
+  // storageDriverContext.setPrefix(`tenant-${request.user?.id}`);
+}

package/templates/warlock/src/app/utils/router.ts

@@ -1,5 +1,6 @@
 import { authMiddleware } from "@warlock.js/auth";
 import { router } from "@warlock.js/core";
+import { cloudUploadMiddleware } from "./cloud-upload.middleware";
 
 export function publicRoutes(callback: () => void) {
   router.group(
@@ -23,7 +24,16 @@ export function guardedAdmin(callback: () => void) {
 export function guarded(callback: () => void) {
   router.group(
     {
-      middleware: [authMiddleware()],
+      middleware: [authMiddleware("user")],
+    },
+    callback,
+  );
+}
+
+export function cloudUpload(callback: () => void) {
+  router.group(
+    {
+      middleware: [authMiddleware("user"), cloudUploadMiddleware],
     },
     callback,
   );

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

@@ -11,6 +11,8 @@ const authConfigurations: AuthConfigurations = {
     expiresIn: NO_EXPIRATION,
     refresh: {
       expiresIn: "7d",
+      enabled: false,
+      secret: env("JWT_REFRESH_SECRET"),
     },
   },
 };