feat(i18n): localize admin users backbone

src/schemas/user.schema.ts

@@ -1,38 +1,70 @@
 import { z } from "zod"
 
+import type { Dictionary } from "@/i18n/dictionaries"
+
+export type UserSchemaCopy = Dictionary["admin"]["users"]["schema"]
+
+export const defaultUserSchemaCopy: UserSchemaCopy = {
+  usernameRequired: "Username is required",
+  nameRequired: "Name is required",
+  emailInvalid: "Invalid email",
+  passwordMinLength: "Password must be at least 8 characters",
+  userIdRequired: "User id is required",
+}
+
 export const userRoleSchema = z.enum(["ADMIN", "MANAGER", "STAFF", "VIEWER"])
 
-const passwordSchema = z
-  .string()
-  .min(8, { error: "Password must be at least 8 characters" })
+function buildUserPasswordSchema(copy: UserSchemaCopy) {
+  return z.string().min(8, { error: copy.passwordMinLength })
+}
 
-export const createUserSchema = z.object({
-  username: z.string().trim().min(1, { error: "Username is required" }),
-  name: z.string().trim().min(1, { error: "Name is required" }),
-  email: z.email({ error: "Invalid email" }),
-  password: passwordSchema,
-  role: userRoleSchema,
-  isActive: z.boolean(),
-})
+export function buildCreateUserSchema(copy: UserSchemaCopy) {
+  return z.object({
+    username: z.string().trim().min(1, { error: copy.usernameRequired }),
+    name: z.string().trim().min(1, { error: copy.nameRequired }),
+    email: z.email({ error: copy.emailInvalid }),
+    password: buildUserPasswordSchema(copy),
+    role: userRoleSchema,
+    isActive: z.boolean(),
+  })
+}
 
-export const updateUserSchema = z.object({
-  id: z.string().min(1, { error: "User id is required" }),
-  username: z.string().trim().min(1, { error: "Username is required" }),
-  name: z.string().trim().min(1, { error: "Name is required" }),
-  email: z.email({ error: "Invalid email" }),
-  role: userRoleSchema,
-  isActive: z.boolean(),
-})
+export const createUserSchema = buildCreateUserSchema(defaultUserSchemaCopy)
 
-export const setUserActiveSchema = z.object({
-  id: z.string().min(1, { error: "User id is required" }),
-  isActive: z.boolean(),
-})
+export function buildUpdateUserSchema(copy: UserSchemaCopy) {
+  return z.object({
+    id: z.string().min(1, { error: copy.userIdRequired }),
+    username: z.string().trim().min(1, { error: copy.usernameRequired }),
+    name: z.string().trim().min(1, { error: copy.nameRequired }),
+    email: z.email({ error: copy.emailInvalid }),
+    role: userRoleSchema,
+    isActive: z.boolean(),
+  })
+}
 
-export const resetUserPasswordSchema = z.object({
-  id: z.string().min(1, { error: "User id is required" }),
-  password: passwordSchema,
-})
+export const updateUserSchema = buildUpdateUserSchema(defaultUserSchemaCopy)
+
+export function buildSetUserActiveSchema(copy: UserSchemaCopy) {
+  return z.object({
+    id: z.string().min(1, { error: copy.userIdRequired }),
+    isActive: z.boolean(),
+  })
+}
+
+export const setUserActiveSchema = buildSetUserActiveSchema(
+  defaultUserSchemaCopy,
+)
+
+export function buildResetUserPasswordSchema(copy: UserSchemaCopy) {
+  return z.object({
+    id: z.string().min(1, { error: copy.userIdRequired }),
+    password: buildUserPasswordSchema(copy),
+  })
+}
+
+export const resetUserPasswordSchema = buildResetUserPasswordSchema(
+  defaultUserSchemaCopy,
+)
 
 export type CreateUserFormType = z.infer<typeof createUserSchema>
 export type UpdateUserFormType = z.infer<typeof updateUserSchema>