used zod codemod

server/private/lib/readConfigFile.ts

@@ -50,14 +50,14 @@ export const privateConfigSchema = z.object({
             host: z.string(),
             port: portSchema,
             password: z.string().optional(),
-            db: z.number().int().nonnegative().optional().default(0),
+            db: z.int().nonnegative().optional().default(0),
             replicas: z
                 .array(
                     z.object({
                         host: z.string(),
                         port: portSchema,
                         password: z.string().optional(),
-                        db: z.number().int().nonnegative().optional().default(0)
+                        db: z.int().nonnegative().optional().default(0)
                     })
                 )
                 .optional()
@@ -79,14 +79,14 @@ export const privateConfigSchema = z.object({
                 .default("http://gerbil:3004")
         })
         .optional()
-        .default({}),
+        .prefault({}),
     flags: z
         .object({
             enable_redis: z.boolean().optional().default(false),
             use_pangolin_dns: z.boolean().optional().default(false)
         })
         .optional()
-        .default({}),
+        .prefault({}),
     branding: z
         .object({
             app_name: z.string().optional(),

server/private/routers/auditLogs/queryAccessAuditLog.ts

@@ -30,13 +30,13 @@ export const queryAccessAuditLogsQuery = z.object({
     timeStart: z
         .string()
         .refine((val) => !isNaN(Date.parse(val)), {
-            message: "timeStart must be a valid ISO date string"
+            error: "timeStart must be a valid ISO date string"
         })
         .transform((val) => Math.floor(new Date(val).getTime() / 1000)),
     timeEnd: z
         .string()
         .refine((val) => !isNaN(Date.parse(val)), {
-            message: "timeEnd must be a valid ISO date string"
+            error: "timeEnd must be a valid ISO date string"
         })
         .transform((val) => Math.floor(new Date(val).getTime() / 1000))
         .optional()
@@ -51,7 +51,7 @@ export const queryAccessAuditLogsQuery = z.object({
         .string()
         .optional()
         .transform(Number)
-        .pipe(z.number().int().positive())
+        .pipe(z.int().positive())
         .optional(),
     actor: z.string().optional(),
     type: z.string().optional(),
@@ -61,13 +61,13 @@ export const queryAccessAuditLogsQuery = z.object({
         .optional()
         .default("1000")
         .transform(Number)
-        .pipe(z.number().int().positive()),
+        .pipe(z.int().positive()),
     offset: z
         .string()
         .optional()
         .default("0")
         .transform(Number)
-        .pipe(z.number().int().nonnegative())
+        .pipe(z.int().nonnegative())
 });
 
 export const queryAccessAuditLogsParams = z.object({

server/private/routers/auditLogs/queryActionAuditLog.ts

@@ -30,13 +30,13 @@ export const queryActionAuditLogsQuery = z.object({
     timeStart: z
         .string()
         .refine((val) => !isNaN(Date.parse(val)), {
-            message: "timeStart must be a valid ISO date string"
+            error: "timeStart must be a valid ISO date string"
         })
         .transform((val) => Math.floor(new Date(val).getTime() / 1000)),
     timeEnd: z
         .string()
         .refine((val) => !isNaN(Date.parse(val)), {
-            message: "timeEnd must be a valid ISO date string"
+            error: "timeEnd must be a valid ISO date string"
         })
         .transform((val) => Math.floor(new Date(val).getTime() / 1000))
         .optional()
@@ -50,13 +50,13 @@ export const queryActionAuditLogsQuery = z.object({
         .optional()
         .default("1000")
         .transform(Number)
-        .pipe(z.number().int().positive()),
+        .pipe(z.int().positive()),
     offset: z
         .string()
         .optional()
         .default("0")
         .transform(Number)
-        .pipe(z.number().int().nonnegative())
+        .pipe(z.int().nonnegative())
 });
 
 export const queryActionAuditLogsParams = z.object({

server/private/routers/auth/getSessionTransferToken.ts

@@ -28,7 +28,7 @@ import { response } from "@server/lib/response";
 import { encrypt } from "@server/lib/crypto";
 import config from "@server/lib/config";
 
-const paramsSchema = z.object({}).strict();
+const paramsSchema = z.strictObject({});
 
 export type GetSessionTransferTokenRenponse = {
     token: string;

server/private/routers/auth/quickStart.ts

@@ -62,10 +62,10 @@ import { isTargetValid } from "@server/lib/validators";
 import { listExitNodes } from "#private/lib/exitNodes";
 
 const bodySchema = z.object({
-    email: z.string().toLowerCase().email(),
+    email: z.email().toLowerCase(),
     ip: z.string().refine(isTargetValid),
     method: z.enum(["http", "https"]),
-    port: z.number().int().min(1).max(65535),
+    port: z.int().min(1).max(65535),
     pincode: z
         .string()
         .regex(/^\d{6}$/)

server/private/routers/billing/createCheckoutSession.ts

@@ -25,11 +25,9 @@ import stripe from "#private/lib/stripe";
 import { getLineItems, getStandardFeaturePriceSet } from "@server/lib/billing";
 import { getTierPriceSet, TierId } from "@server/lib/billing/tiers";
 
-const createCheckoutSessionSchema = z
-    .object({
+const createCheckoutSessionSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export async function createCheckoutSession(
     req: Request,

server/private/routers/billing/createPortalSession.ts

@@ -23,11 +23,9 @@ import config from "@server/lib/config";
 import { fromError } from "zod-validation-error";
 import stripe from "#private/lib/stripe";
 
-const createPortalSessionSchema = z
-    .object({
+const createPortalSessionSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export async function createPortalSession(
     req: Request,

server/private/routers/billing/getOrgSubscription.ts

@@ -33,11 +33,9 @@ import {
     SubscriptionItem
 } from "@server/db";
 
-const getOrgSchema = z
-    .object({
+const getOrgSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 registry.registerPath({
     method: "get",

server/private/routers/billing/getOrgUsage.ts

@@ -27,11 +27,9 @@ import { usageService } from "@server/lib/billing/usageService";
 import { FeatureId } from "@server/lib/billing";
 import { GetOrgUsageResponse } from "@server/routers/billing/types";
 
-const getOrgSchema = z
-    .object({
+const getOrgSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 registry.registerPath({
     method: "get",

server/private/routers/billing/internalGetOrgTier.ts

@@ -21,11 +21,9 @@ import { fromZodError } from "zod-validation-error";
 import { getOrgTierData } from "#private/lib/billing";
 import { GetOrgTierResponse } from "@server/routers/billing/types";
 
-const getOrgSchema = z
-    .object({
+const getOrgSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export async function getOrgTier(
     req: Request,

server/private/routers/certificates/getCertificate.ts

@@ -23,13 +23,11 @@ import { fromError } from "zod-validation-error";
 import { registry } from "@server/openApi";
 import { GetCertificateResponse } from "@server/routers/certificates/types";
 
-const getCertificateSchema = z
-    .object({
+const getCertificateSchema = z.strictObject({
         domainId: z.string(),
         domain: z.string().min(1).max(255),
         orgId: z.string()
-    })
-    .strict();
+    });
 
 async function query(domainId: string, domain: string) {
     const [domainRecord] = await db

server/private/routers/certificates/restartCertificate.ts

@@ -24,12 +24,10 @@ import stoi from "@server/lib/stoi";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
-const restartCertificateParamsSchema = z
-    .object({
-        certId: z.string().transform(stoi).pipe(z.number().int().positive()),
+const restartCertificateParamsSchema = z.strictObject({
+        certId: z.string().transform(stoi).pipe(z.int().positive()),
         orgId: z.string()
-    })
-    .strict();
+    });
 
 registry.registerPath({
     method: "post",
@@ -41,7 +39,7 @@ registry.registerPath({
             certId: z
                 .string()
                 .transform(stoi)
-                .pipe(z.number().int().positive()),
+                .pipe(z.int().positive()),
             orgId: z.string()
         })
     },

server/private/routers/domain/checkDomainNamespaceAvailability.ts

@@ -23,13 +23,11 @@ import { db, domainNamespaces, resources } from "@server/db";
 import { inArray } from "drizzle-orm";
 import { CheckDomainAvailabilityResponse } from "@server/routers/domain/types";
 
-const paramsSchema = z.object({}).strict();
+const paramsSchema = z.strictObject({});
 
-const querySchema = z
-    .object({
+const querySchema = z.strictObject({
         subdomain: z.string()
-    })
-    .strict();
+    });
 
 registry.registerPath({
     method: "get",

server/private/routers/domain/listDomainNamespaces.ts

@@ -23,24 +23,22 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
-const paramsSchema = z.object({}).strict();
+const paramsSchema = z.strictObject({});
 
-const querySchema = z
-    .object({
+const querySchema = z.strictObject({
         limit: z
             .string()
             .optional()
             .default("1000")
             .transform(Number)
-            .pipe(z.number().int().nonnegative()),
+            .pipe(z.int().nonnegative()),
         offset: z
             .string()
             .optional()
             .default("0")
             .transform(Number)
-            .pipe(z.number().int().nonnegative())
-    })
-    .strict();
+            .pipe(z.int().nonnegative())
+    });
 
 async function query(limit: number, offset: number) {
     const res = await db

server/private/routers/hybrid.ts

@@ -78,105 +78,78 @@ import { verifyResourceAccessToken } from "@server/auth/verifyResourceAccessToke
 import semver from "semver";
 
 // Zod schemas for request validation
-const getResourceByDomainParamsSchema = z
-    .object({
+const getResourceByDomainParamsSchema = z.strictObject({
         domain: z.string().min(1, "Domain is required")
-    })
-    .strict();
+    });
 
-const getUserSessionParamsSchema = z
-    .object({
+const getUserSessionParamsSchema = z.strictObject({
         userSessionId: z.string().min(1, "User session ID is required")
-    })
-    .strict();
+    });
 
-const getUserOrgRoleParamsSchema = z
-    .object({
+const getUserOrgRoleParamsSchema = z.strictObject({
         userId: z.string().min(1, "User ID is required"),
         orgId: z.string().min(1, "Organization ID is required")
-    })
-    .strict();
+    });
 
-const getRoleResourceAccessParamsSchema = z
-    .object({
+const getRoleResourceAccessParamsSchema = z.strictObject({
         roleId: z
             .string()
             .transform(Number)
             .pipe(
-                z.number().int().positive("Role ID must be a positive integer")
+                z.int().positive("Role ID must be a positive integer")
             ),
         resourceId: z
             .string()
             .transform(Number)
             .pipe(
-                z
-                    .number()
-                    .int()
+                z.int()
                     .positive("Resource ID must be a positive integer")
             )
-    })
-    .strict();
+    });
 
-const getUserResourceAccessParamsSchema = z
-    .object({
+const getUserResourceAccessParamsSchema = z.strictObject({
         userId: z.string().min(1, "User ID is required"),
         resourceId: z
             .string()
             .transform(Number)
             .pipe(
-                z
-                    .number()
-                    .int()
+                z.int()
                     .positive("Resource ID must be a positive integer")
             )
-    })
-    .strict();
+    });
 
-const getResourceRulesParamsSchema = z
-    .object({
+const getResourceRulesParamsSchema = z.strictObject({
         resourceId: z
             .string()
             .transform(Number)
             .pipe(
-                z
-                    .number()
-                    .int()
+                z.int()
                     .positive("Resource ID must be a positive integer")
             )
-    })
-    .strict();
+    });
 
-const validateResourceSessionTokenParamsSchema = z
-    .object({
+const validateResourceSessionTokenParamsSchema = z.strictObject({
         resourceId: z
             .string()
             .transform(Number)
             .pipe(
-                z
-                    .number()
-                    .int()
+                z.int()
                     .positive("Resource ID must be a positive integer")
             )
-    })
-    .strict();
+    });
 
-const validateResourceSessionTokenBodySchema = z
-    .object({
+const validateResourceSessionTokenBodySchema = z.strictObject({
         token: z.string().min(1, "Token is required")
-    })
-    .strict();
+    });
 
-const validateResourceAccessTokenBodySchema = z
-    .object({
+const validateResourceAccessTokenBodySchema = z.strictObject({
         accessTokenId: z.string().optional(),
         resourceId: z.number().optional(),
         accessToken: z.string()
-    })
-    .strict();
+    });
 
 // Certificates by domains query validation
-const getCertificatesByDomainsQuerySchema = z
-    .object({
+const getCertificatesByDomainsQuerySchema = z.strictObject({
         // Accept domains as string or array (domains or domains[])
         domains: z
             .union([z.array(z.string().min(1)), z.string().min(1)])
@@ -185,8 +158,7 @@ const getCertificatesByDomainsQuerySchema = z
         "domains[]": z
             .union([z.array(z.string().min(1)), z.string().min(1)])
             .optional()
-    })
-    .strict();
+    });
 
 // Type exports for request schemas
 export type GetResourceByDomainParams = z.infer<
@@ -591,11 +563,9 @@ hybridRouter.get(
     }
 );
 
-const getOrgLoginPageParamsSchema = z
-    .object({
+const getOrgLoginPageParamsSchema = z.strictObject({
         orgId: z.string().min(1)
-    })
-    .strict();
+    });
 
 hybridRouter.get(
     "/org/:orgId/login-page",
@@ -1217,7 +1187,7 @@ hybridRouter.post(
 );
 
 const geoIpLookupParamsSchema = z.object({
-    ip: z.string().ip()
+    ip: z.union([z.ipv4(), z.ipv6()])
 });
 hybridRouter.get(
     "/geoip/:ip",

server/private/routers/license/activateLicense.ts

@@ -20,11 +20,9 @@ import license from "#private/license/license";
 import { z } from "zod";
 import { fromError } from "zod-validation-error";
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         licenseKey: z.string().min(1).max(255)
-    })
-    .strict();
+    });
 
 export async function activateLicense(
     req: Request,

server/private/routers/license/deleteLicenseKey.ts

@@ -23,11 +23,9 @@ import { eq } from "drizzle-orm";
 import { licenseKey } from "@server/db";
 import license from "#private/license/license";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         licenseKey: z.string().min(1).max(255)
-    })
-    .strict();
+    });
 
 export async function deleteLicenseKey(
     req: Request,

server/private/routers/loginPage/createLoginPage.ts

@@ -35,18 +35,14 @@ import { TierId } from "@server/lib/billing/tiers";
 import { build } from "@server/build";
 import { CreateLoginPageResponse } from "@server/routers/loginPage/types";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         subdomain: z.string().nullable().optional(),
         domainId: z.string()
-    })
-    .strict();
+    });
 
 export type CreateLoginPageBody = z.infer<typeof bodySchema>;
 

server/private/routers/loginPage/getLoginPage.ts

@@ -22,11 +22,9 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { GetLoginPageResponse } from "@server/routers/loginPage/types";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 async function query(orgId: string) {
     const [res] = await db

server/private/routers/loginPage/updateLoginPage.ts

@@ -35,14 +35,12 @@ const paramsSchema = z
     })
     .strict();
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         subdomain: subdomainSchema.nullable().optional(),
         domainId: z.string().optional()
     })
-    .strict()
     .refine((data) => Object.keys(data).length > 0, {
-        message: "At least one field must be provided for update"
+        error: "At least one field must be provided for update"
     })
     .refine(
         (data) => {
@@ -51,7 +49,9 @@ const bodySchema = z
             }
             return true;
         },
-        { message: "Invalid subdomain" }
+        {
+            error: "Invalid subdomain"
+        }
     );
 
 export type UpdateLoginPageBody = z.infer<typeof bodySchema>;

server/private/routers/misc/sendSupportEmail.ts

@@ -22,12 +22,10 @@ import { sendEmail } from "@server/emails";
 import SupportEmail from "@server/emails/templates/SupportEmail";
 import config from "@server/lib/config";
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         body: z.string().min(1),
         subject: z.string().min(1).max(255)
-    })
-    .strict();
+    });
 
 export async function sendSupportEmail(
     req: Request,

server/private/routers/orgIdp/createOrgOidcIdp.ts

@@ -29,15 +29,14 @@ import { getOrgTierData } from "#private/lib/billing";
 import { TierId } from "@server/lib/billing/tiers";
 import { CreateOrgIdpResponse } from "@server/routers/orgIdp/types";
 
-const paramsSchema = z.object({ orgId: z.string().nonempty() }).strict();
+const paramsSchema = z.strictObject({ orgId: z.string().nonempty() });
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         name: z.string().nonempty(),
         clientId: z.string().nonempty(),
         clientSecret: z.string().nonempty(),
-        authUrl: z.string().url(),
-        tokenUrl: z.string().url(),
+        authUrl: z.url(),
+        tokenUrl: z.url(),
         identifierPath: z.string().nonempty(),
         emailPath: z.string().optional(),
         namePath: z.string().optional(),
@@ -45,8 +44,7 @@ const bodySchema = z
         autoProvision: z.boolean().optional(),
         variant: z.enum(["oidc", "google", "azure"]).optional().default("oidc"),
         roleMapping: z.string().optional()
-    })
-    .strict();
+    });
 
 // registry.registerPath({
 //     method: "put",

server/private/routers/orgIdp/listOrgIdps.ts

@@ -24,28 +24,24 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { ListOrgIdpsResponse } from "@server/routers/orgIdp/types";
 
-const querySchema = z
-    .object({
+const querySchema = z.strictObject({
         limit: z
             .string()
             .optional()
             .default("1000")
             .transform(Number)
-            .pipe(z.number().int().nonnegative()),
+            .pipe(z.int().nonnegative()),
         offset: z
             .string()
             .optional()
             .default("0")
             .transform(Number)
-            .pipe(z.number().int().nonnegative())
-    })
-    .strict();
+            .pipe(z.int().nonnegative())
+    });
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string().nonempty()
-    })
-    .strict();
+    });
 
 async function query(orgId: string, limit: number, offset: number) {
     const res = await db

server/private/routers/orgIdp/updateOrgOidcIdp.ts

@@ -35,8 +35,7 @@ const paramsSchema = z
     })
     .strict();
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         name: z.string().optional(),
         clientId: z.string().optional(),
         clientSecret: z.string().optional(),
@@ -48,8 +47,7 @@ const bodySchema = z
         scopes: z.string().optional(),
         autoProvision: z.boolean().optional(),
         roleMapping: z.string().optional()
-    })
-    .strict();
+    });
 
 export type UpdateOrgIdpResponse = {
     idpId: number;

server/private/routers/re-key/reGenerateClientSecret.ts

@@ -24,19 +24,15 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { hashPassword } from "@server/auth/password";
 
-const reGenerateSecretParamsSchema = z
-    .object({
-        clientId: z.string().transform(Number).pipe(z.number().int().positive())
-    })
-    .strict();
+const reGenerateSecretParamsSchema = z.strictObject({
+        clientId: z.string().transform(Number).pipe(z.int().positive())
+    });
 
-const reGenerateSecretBodySchema = z
-    .object({
+const reGenerateSecretBodySchema = z.strictObject({
         olmId: z.string().min(1).optional(),
         secret: z.string().min(1).optional(),
 
-    })
-    .strict();
+    });
 
 export type ReGenerateSecretBody = z.infer<typeof reGenerateSecretBodySchema>;
 

server/private/routers/re-key/reGenerateExitNodeSecret.ts

@@ -29,12 +29,10 @@ export const paramsSchema = z.object({
     orgId: z.string()
 });
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         remoteExitNodeId: z.string().length(15),
         secret: z.string().length(48)
-    })
-    .strict();
+    });
 
 
 registry.registerPath({

server/private/routers/re-key/reGenerateSiteSecret.ts

@@ -25,22 +25,18 @@ import { hashPassword } from "@server/auth/password";
 import { addPeer } from "@server/routers/gerbil/peers";
 
 
-const updateSiteParamsSchema = z
-    .object({
-        siteId: z.string().transform(Number).pipe(z.number().int().positive())
-    })
-    .strict();
+const updateSiteParamsSchema = z.strictObject({
+        siteId: z.string().transform(Number).pipe(z.int().positive())
+    });
 
-const updateSiteBodySchema = z
-    .object({
+const updateSiteBodySchema = z.strictObject({
         type: z.enum(["newt", "wireguard"]),
         newtId: z.string().min(1).max(255).optional(),
         newtSecret: z.string().min(1).max(255).optional(),
-        exitNodeId: z.number().int().positive().optional(),
+        exitNodeId: z.int().positive().optional(),
         pubKey: z.string().optional(),
         subnet: z.string().optional(),
-    })
-    .strict();
+    });
 
 registry.registerPath({
     method: "post",

server/private/routers/remoteExitNode/createRemoteExitNode.ts

@@ -35,12 +35,10 @@ export const paramsSchema = z.object({
     orgId: z.string()
 });
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         remoteExitNodeId: z.string().length(15),
         secret: z.string().length(48)
-    })
-    .strict();
+    });
 
 export type CreateRemoteExitNodeBody = z.infer<typeof bodySchema>;
 

server/private/routers/remoteExitNode/deleteRemoteExitNode.ts

@@ -24,12 +24,10 @@ import { fromError } from "zod-validation-error";
 import { usageService } from "@server/lib/billing/usageService";
 import { FeatureId } from "@server/lib/billing";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string().min(1),
         remoteExitNodeId: z.string().min(1)
-    })
-    .strict();
+    });
 
 export async function deleteRemoteExitNode(
     req: Request,

server/private/routers/remoteExitNode/getRemoteExitNode.ts

@@ -23,12 +23,10 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { GetRemoteExitNodeResponse } from "@server/routers/remoteExitNode/types";
 
-const getRemoteExitNodeSchema = z
-    .object({
+const getRemoteExitNodeSchema = z.strictObject({
         orgId: z.string().min(1),
         remoteExitNodeId: z.string().min(1)
-    })
-    .strict();
+    });
 
 async function query(remoteExitNodeId: string) {
     const [remoteExitNode] = await db

server/private/routers/remoteExitNode/listRemoteExitNodes.ts

@@ -23,11 +23,9 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { ListRemoteExitNodesResponse } from "@server/routers/remoteExitNode/types";
 
-const listRemoteExitNodesParamsSchema = z
-    .object({
+const listRemoteExitNodesParamsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 const listRemoteExitNodesSchema = z.object({
     limit: z
@@ -35,13 +33,13 @@ const listRemoteExitNodesSchema = z.object({
         .optional()
         .default("1000")
         .transform(Number)
-        .pipe(z.number().int().positive()),
+        .pipe(z.int().positive()),
     offset: z
         .string()
         .optional()
         .default("0")
         .transform(Number)
-        .pipe(z.number().int().nonnegative())
+        .pipe(z.int().nonnegative())
 });
 
 export function queryRemoteExitNodes(orgId: string) {

server/private/routers/remoteExitNode/pickRemoteExitNodeDefaults.ts

@@ -21,11 +21,9 @@ import { fromError } from "zod-validation-error";
 import { z } from "zod";
 import { PickRemoteExitNodeDefaultsResponse } from "@server/routers/remoteExitNode/types";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export async function pickRemoteExitNodeDefaults(
     req: Request,