used zod codemod

server/routers/auth/changePassword.ts

@@ -22,13 +22,11 @@ import { sendEmail } from "@server/emails";
 import ConfirmPasswordReset from "@server/emails/templates/NotifyResetPassword";
 import config from "@server/lib/config";
 
-export const changePasswordBody = z
-    .object({
+export const changePasswordBody = z.strictObject({
         oldPassword: z.string(),
         newPassword: passwordSchema,
         code: z.string().optional()
-    })
-    .strict();
+    });
 
 export type ChangePasswordBody = z.infer<typeof changePasswordBody>;
 

server/routers/auth/checkResourceSession.ts

@@ -7,10 +7,10 @@ import { response } from "@server/lib/response";
 import { validateResourceSessionToken } from "@server/auth/sessions/resource";
 import logger from "@server/logger";
 
-export const params = z.object({
+export const params = z.strictObject({
     token: z.string(),
-    resourceId: z.string().transform(Number).pipe(z.number().int().positive()),
-}).strict();
+    resourceId: z.string().transform(Number).pipe(z.int().positive()),
+});
 
 export type CheckResourceSessionParams = z.infer<typeof params>;
 

server/routers/auth/disable2fa.ts

@@ -16,12 +16,10 @@ import config from "@server/lib/config";
 import { unauthorized } from "@server/auth/unauthorizedResponse";
 import { UserType } from "@server/types/UserTypes";
 
-export const disable2faBody = z
-    .object({
+export const disable2faBody = z.strictObject({
         password: z.string(),
         code: z.string().optional()
-    })
-    .strict();
+    });
 
 export type Disable2faBody = z.infer<typeof disable2faBody>;
 

server/routers/auth/login.ts

@@ -20,14 +20,12 @@ import { verifySession } from "@server/auth/sessions/verifySession";
 import { UserType } from "@server/types/UserTypes";
 import { logAccessAudit } from "#dynamic/lib/logAccessAudit";
 
-export const loginBodySchema = z
-    .object({
-        email: z.string().toLowerCase().email(),
+export const loginBodySchema = z.strictObject({
+        email: z.email().toLowerCase(),
         password: z.string(),
         code: z.string().optional(),
         resourceGuid: z.string().optional()
-    })
-    .strict();
+    });
 
 export type LoginBody = z.infer<typeof loginBodySchema>;
 

server/routers/auth/requestPasswordReset.ts

@@ -17,11 +17,9 @@ import ResetPasswordCode from "@server/emails/templates/ResetPasswordCode";
 import { hashPassword } from "@server/auth/password";
 import { UserType } from "@server/types/UserTypes";
 
-export const requestPasswordResetBody = z
-    .object({
-        email: z.string().toLowerCase().email()
-    })
-    .strict();
+export const requestPasswordResetBody = z.strictObject({
+        email: z.email().toLowerCase()
+    });
 
 export type RequestPasswordResetBody = z.infer<typeof requestPasswordResetBody>;
 

server/routers/auth/requestTotpSecret.ts

@@ -16,12 +16,10 @@ import { UserType } from "@server/types/UserTypes";
 import { verifySession } from "@server/auth/sessions/verifySession";
 import config from "@server/lib/config";
 
-export const requestTotpSecretBody = z
-    .object({
+export const requestTotpSecretBody = z.strictObject({
         password: z.string(),
-        email: z.string().email().optional()
-    })
-    .strict();
+        email: z.email().optional()
+    });
 
 export type RequestTotpSecretBody = z.infer<typeof requestTotpSecretBody>;
 

server/routers/auth/resetPassword.ts

@@ -17,14 +17,12 @@ import ConfirmPasswordReset from "@server/emails/templates/NotifyResetPassword";
 import { sendEmail } from "@server/emails";
 import { passwordSchema } from "@server/auth/passwordSchema";
 
-export const resetPasswordBody = z
-    .object({
-        email: z.string().toLowerCase().email(),
+export const resetPasswordBody = z.strictObject({
+        email: z.email().toLowerCase(),
         token: z.string(), // reset secret code
         newPassword: passwordSchema,
         code: z.string().optional() // 2fa code
-    })
-    .strict();
+    });
 
 export type ResetPasswordBody = z.infer<typeof resetPasswordBody>;
 

server/routers/auth/securityKey.ts

@@ -99,28 +99,28 @@ async function clearChallenge(sessionId: string) {
     await db.delete(webauthnChallenge).where(eq(webauthnChallenge.sessionId, sessionId));
 }
 
-export const registerSecurityKeyBody = z.object({
+export const registerSecurityKeyBody = z.strictObject({
     name: z.string().min(1),
     password: z.string().min(1),
     code: z.string().optional()
-}).strict();
+});
 
-export const verifyRegistrationBody = z.object({
+export const verifyRegistrationBody = z.strictObject({
     credential: z.any()
-}).strict();
+});
 
-export const startAuthenticationBody = z.object({
-    email: z.string().email().optional()
-}).strict();
+export const startAuthenticationBody = z.strictObject({
+    email: z.email().optional()
+});
 
-export const verifyAuthenticationBody = z.object({
+export const verifyAuthenticationBody = z.strictObject({
     credential: z.any()
-}).strict();
+});
 
-export const deleteSecurityKeyBody = z.object({
+export const deleteSecurityKeyBody = z.strictObject({
     password: z.string().min(1),
     code: z.string().optional()
-}).strict();
+});
 
 export async function startRegistration(
     req: Request,

server/routers/auth/setServerAdmin.ts

@@ -14,7 +14,7 @@ import { UserType } from "@server/types/UserTypes";
 import moment from "moment";
 
 export const bodySchema = z.object({
-    email: z.string().toLowerCase().email(),
+    email: z.email().toLowerCase(),
     password: passwordSchema,
     setupToken: z.string().min(1, "Setup token is required")
 });

server/routers/auth/signup.ts

@@ -26,7 +26,7 @@ import { build } from "@server/build";
 import resend, { AudienceIds, moveEmailToAudience } from "#dynamic/lib/resend";
 
 export const signupBodySchema = z.object({
-    email: z.string().toLowerCase().email(),
+    email: z.email().toLowerCase(),
     password: passwordSchema,
     inviteToken: z.string().optional(),
     inviteId: z.string().optional(),

server/routers/auth/validateSetupToken.ts

@@ -8,11 +8,9 @@ import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 
-const validateSetupTokenSchema = z
-    .object({
+const validateSetupTokenSchema = z.strictObject({
         token: z.string().min(1, "Token is required")
-    })
-    .strict();
+    });
 
 export type ValidateSetupTokenResponse = {
     valid: boolean;

server/routers/auth/verifyEmail.ts

@@ -13,11 +13,9 @@ import logger from "@server/logger";
 import { freeLimitSet, limitsService } from "@server/lib/billing";
 import { build } from "@server/build";
 
-export const verifyEmailBody = z
-    .object({
+export const verifyEmailBody = z.strictObject({
         code: z.string()
-    })
-    .strict();
+    });
 
 export type VerifyEmailBody = z.infer<typeof verifyEmailBody>;
 

server/routers/auth/verifyTotp.ts

@@ -18,13 +18,11 @@ import { generateBackupCodes } from "@server/lib/totp";
 import { verifySession } from "@server/auth/sessions/verifySession";
 import { unauthorized } from "@server/auth/unauthorizedResponse";
 
-export const verifyTotpBody = z
-    .object({
-        email: z.string().email().optional(),
+export const verifyTotpBody = z.strictObject({
+        email: z.email().optional(),
         password: z.string().optional(),
         code: z.string()
-    })
-    .strict();
+    });
 
 export type VerifyTotpBody = z.infer<typeof verifyTotpBody>;