fix: adjust schema validation zod v4

Author: masb0ymas

src/app/database/schema/role.ts

@@ -4,7 +4,7 @@ import BaseSchema from '../entity/base'
 // Schema
 export const roleSchema = z.object({
   name: z
-    .string({ required_error: 'name is required' })
+    .string('name is required')
     .min(3, { message: 'name must be at least 3 characters long' })
     .max(255, { message: 'name must be at most 255 characters long' }),
 })

src/app/database/schema/session.ts

@@ -3,18 +3,16 @@ import BaseSchema from '../entity/base'
 
 // Schema
 export const sessionSchema = z.object({
-  user_id: z
-    .string({ required_error: 'user_id is required' })
-    .uuid({ message: 'user_id must be a valid UUID' }),
+  user_id: z.uuid({ message: 'user_id must be a valid UUID' }),
   token: z
-    .string({ required_error: 'token is required' })
-    .min(3, { message: 'token must be at least 3 characters long' }),
-  ip_address: z.string({ required_error: 'ip_address is required' }).nullable().optional(),
-  device: z.string({ required_error: 'device is required' }).nullable().optional(),
-  platform: z.string({ required_error: 'platform is required' }).nullable().optional(),
-  user_agent: z.string({ required_error: 'user_agent is required' }).nullable().optional(),
-  latitude: z.string({ required_error: 'latitude is required' }).nullable().optional(),
-  longitude: z.string({ required_error: 'longitude is required' }).nullable().optional(),
+    .string('token is required')
+    .min(3, { error: 'token must be at least 3 characters long' }),
+  ip_address: z.string('ip_address is required').nullable().optional(),
+  device: z.string('device is required').nullable().optional(),
+  platform: z.string('platform is required').nullable().optional(),
+  user_agent: z.string('user_agent is required').nullable().optional(),
+  latitude: z.string('latitude is required').nullable().optional(),
+  longitude: z.string('longitude is required').nullable().optional(),
 })
 
 // Type

src/app/database/schema/upload.ts

@@ -4,21 +4,19 @@ import BaseSchema from '../entity/base'
 // Schema
 export const uploadSchema = z.object({
   keyfile: z
-    .string({ required_error: 'keyfile is required' })
+    .string('keyfile is required')
     .min(3, { message: 'keyfile must be at least 3 characters long' }),
   filename: z
-    .string({ required_error: 'filename is required' })
+    .string('filename is required')
     .min(3, { message: 'filename must be at least 3 characters long' }),
   mimetype: z
-    .string({ required_error: 'mimetype is required' })
+    .string('mimetype is required')
     .min(3, { message: 'mimetype must be at least 3 characters long' }),
-  size: z
-    .number({ required_error: 'size is required' })
-    .min(1, { message: 'size must be at least 1' }),
+  size: z.number('size is required').min(1, { message: 'size must be at least 1' }),
   signed_url: z
-    .string({ required_error: 'signed_url is required' })
+    .string('signed_url is required')
     .min(3, { message: 'signed_url must be at least 3 characters long' }),
-  expiry_date_url: z.date({ required_error: 'expiry_date_url is required' }),
+  expiry_date_url: z.date('expiry_date_url is required'),
 })
 
 // Type

src/app/database/schema/user.ts

@@ -26,45 +26,22 @@ export const changePasswordSchema = passwordSchema
 
 export const userSchema = passwordSchema
   .extend({
-    fullname: z
-      .string({
-        required_error: 'fullname is required',
-        invalid_type_error: 'fullname must be a string',
-      })
-      .min(2, "fullname can't be empty"),
-    email: z
-      .string({
-        required_error: 'email is required',
-        invalid_type_error: 'email must be a string',
-      })
-      .email({ message: 'invalid email address' })
-      .min(2, "email can't be empty"),
+    fullname: z.string('fullname is required').min(2, "fullname can't be empty"),
+    email: z.email({ message: 'invalid email address' }).min(2, "email can't be empty"),
     phone: z.string().nullable(),
     token_verify: z.string().nullable(),
-    upload_id: z.string().uuid({ message: 'upload_id invalid uuid format' }).nullable(),
-    is_active: z.boolean({
-      required_error: 'is_active is required',
-      invalid_type_error: 'is_active must be a boolean',
-    }),
-    is_blocked: z.boolean({
-      required_error: 'is_blocked is required',
-      invalid_type_error: 'is_blocked must be a boolean',
-    }),
-    role_id: z
-      .string({
-        required_error: 'role id is required',
-        invalid_type_error: 'role id must be a string',
-      })
-      .uuid({ message: 'role id invalid uuid format' })
-      .min(2, `role id can't be empty`),
+    upload_id: z.uuid('upload_id invalid uuid format').nullable(),
+    is_active: z.boolean('is_active is required'),
+    is_blocked: z.boolean('is_blocked is required'),
+    role_id: z.uuid('role id invalid uuid format').min(2, `role id can't be empty`),
   })
   .refine((data) => data.new_password === data.confirm_new_password, {
     message: "passwords don't match",
     path: ['confirm_new_password'], // path of error
   })
 
 export const loginSchema = z.object({
-  email: z.string().email({ message: 'invalid email address' }).min(2, "email can't be empty"),
+  email: z.email('invalid email address').min(2, "email can't be empty"),
   password: z.string().min(2, "password can't be empty"),
   latitude: z.string().nullable(),
   longitude: z.string().nullable(),