used zod codemod

server/routers/site/createSite.ts

@@ -19,16 +19,13 @@ import { isIpInCidr } from "@server/lib/ip";
 import { verifyExitNodeOrgAccess } from "#dynamic/lib/exitNodes";
 import { build } from "@server/build";
 
-const createSiteParamsSchema = z
-    .object({
+const createSiteParamsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
-const createSiteSchema = z
-    .object({
+const createSiteSchema = z.strictObject({
         name: z.string().min(1).max(255),
-        exitNodeId: z.number().int().positive().optional(),
+        exitNodeId: z.int().positive().optional(),
         // subdomain: z
         //     .string()
         //     .min(1)
@@ -41,8 +38,7 @@ const createSiteSchema = z
         secret: z.string().optional(),
         address: z.string().optional(),
         type: z.enum(["newt", "wireguard", "local"])
-    })
-    .strict();
+    });
 // .refine((data) => {
 //     if (data.type === "local") {
 //         return !config.getRawConfig().flags?.disable_local_sites;

server/routers/site/deleteSite.ts

@@ -12,11 +12,9 @@ import { fromError } from "zod-validation-error";
 import { sendToClient } from "#dynamic/routers/ws";
 import { OpenAPITags, registry } from "@server/openApi";
 
-const deleteSiteSchema = z
-    .object({
-        siteId: z.string().transform(Number).pipe(z.number().int().positive())
-    })
-    .strict();
+const deleteSiteSchema = z.strictObject({
+        siteId: z.string().transform(Number).pipe(z.int().positive())
+    });
 
 registry.registerPath({
     method: "delete",

server/routers/site/getSite.ts

@@ -11,18 +11,16 @@ import stoi from "@server/lib/stoi";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
-const getSiteSchema = z
-    .object({
+const getSiteSchema = z.strictObject({
         siteId: z
             .string()
             .optional()
             .transform(stoi)
-            .pipe(z.number().int().positive().optional())
+            .pipe(z.int().positive().optional())
             .optional(),
         niceId: z.string().optional(),
         orgId: z.string().optional()
-    })
-    .strict();
+    });
 
 async function query(siteId?: number, niceId?: string, orgId?: string) {
     if (siteId) {

server/routers/site/listSiteRoles.ts

@@ -9,11 +9,9 @@ import createHttpError from "http-errors";
 import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 
-const listSiteRolesSchema = z
-    .object({
-        siteId: z.string().transform(Number).pipe(z.number().int().positive())
-    })
-    .strict();
+const listSiteRolesSchema = z.strictObject({
+        siteId: z.string().transform(Number).pipe(z.int().positive())
+    });
 
 export async function listSiteRoles(
     req: Request,

server/routers/site/listSites.ts

@@ -68,11 +68,9 @@ async function getLatestNewtVersion(): Promise<string | null> {
     }
 }
 
-const listSitesParamsSchema = z
-    .object({
+const listSitesParamsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 const listSitesSchema = z.object({
     limit: z
@@ -80,13 +78,13 @@ const listSitesSchema = 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())
 });
 
 function querySites(orgId: string, accessibleSiteIds: number[]) {

server/routers/site/pickSiteDefaults.ts

@@ -44,11 +44,9 @@ registry.registerPath({
     responses: {}
 });
 
-const pickSiteDefaultsSchema = z
-    .object({
+const pickSiteDefaultsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export async function pickSiteDefaults(
     req: Request,

server/routers/site/socketIntegration.ts

@@ -46,18 +46,14 @@ export interface Container {
     networks: Record<string, ContainerNetwork>;
 }
 
-const siteIdParamsSchema = z
-    .object({
-        siteId: z.string().transform(stoi).pipe(z.number().int().positive())
-    })
-    .strict();
+const siteIdParamsSchema = z.strictObject({
+        siteId: z.string().transform(stoi).pipe(z.int().positive())
+    });
 
-const DockerStatusSchema = z
-    .object({
+const DockerStatusSchema = z.strictObject({
         isAvailable: z.boolean(),
         socketPath: z.string().optional()
-    })
-    .strict();
+    });
 
 function validateSiteIdParams(params: any) {
     const parsedParams = siteIdParamsSchema.safeParse(params);

server/routers/site/updateSite.ts

@@ -11,14 +11,11 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { isValidCIDR } from "@server/lib/validators";
 
-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({
         name: z.string().min(1).max(255).optional(),
         niceId: z.string().min(1).max(255).optional(),
         dockerSocketEnabled: z.boolean().optional(),
@@ -37,9 +34,8 @@ const updateSiteBodySchema = z
         // megabytesIn: z.number().int().nonnegative().optional(),
         // megabytesOut: z.number().int().nonnegative().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"
     });
 
 registry.registerPath({