used zod codemod

server/routers/domain/createOrgDomain.ts

@@ -15,20 +15,16 @@ import { isSecondLevelDomain, isValidDomain } from "@server/lib/validators";
 import { build } from "@server/build";
 import config from "@server/lib/config";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         type: z.enum(["ns", "cname", "wildcard"]),
         baseDomain: subdomainSchema,
         certResolver: z.string().optional().nullable(),
         preferWildcardCert: z.boolean().optional().nullable() // optional, only for wildcard
-    })
-    .strict();
+    });
 
 
 export type CreateDomainResponse = {

server/routers/domain/deleteOrgDomain.ts

@@ -10,12 +10,10 @@ import { and, eq } from "drizzle-orm";
 import { usageService } from "@server/lib/billing/usageService";
 import { FeatureId } from "@server/lib/billing";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         domainId: z.string(),
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export type DeleteAccountDomainResponse = {
     success: boolean;

server/routers/domain/getDNSRecords.ts

@@ -10,12 +10,10 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { getServerIp } from "@server/lib/serverIpService"; // your in-memory IP module
 
-const getDNSRecordsSchema = z
-    .object({
+const getDNSRecordsSchema = z.strictObject({
         domainId: z.string(),
         orgId: z.string()
-    })
-    .strict();
+    });
 
 async function query(domainId: string) {
     const records = await db

server/routers/domain/getDomain.ts

@@ -10,14 +10,12 @@ import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { domain } from "zod/v4/core/regexes";
 
-const getDomainSchema = z
-    .object({
+const getDomainSchema = z.strictObject({
         domainId: z
             .string()
             .optional(),
         orgId: z.string().optional()
-    })
-    .strict();
+    });
 
 async function query(domainId?: string, orgId?: string) {
     if (domainId) {

server/routers/domain/listDomains.ts

@@ -10,28 +10,24 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 
-const listDomainsParamsSchema = z
-    .object({
+const listDomainsParamsSchema = z.strictObject({
         orgId: z.string()
-    })
-    .strict();
+    });
 
-const listDomainsSchema = z
-    .object({
+const listDomainsSchema = 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 queryDomains(orgId: string, limit: number, offset: number) {
     const res = await db

server/routers/domain/restartOrgDomain.ts

@@ -8,12 +8,10 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { and, eq } from "drizzle-orm";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         domainId: z.string(),
         orgId: z.string()
-    })
-    .strict();
+    });
 
 export type RestartOrgDomainResponse = {
     success: boolean;

server/routers/domain/updateDomain.ts

@@ -9,19 +9,15 @@ import { fromError } from "zod-validation-error";
 import { eq, and } from "drizzle-orm";
 import { OpenAPITags, registry } from "@server/openApi";
 
-const paramsSchema = z
-    .object({
+const paramsSchema = z.strictObject({
         orgId: z.string(),
         domainId: z.string()
-    })
-    .strict();
+    });
 
-const bodySchema = z
-    .object({
+const bodySchema = z.strictObject({
         certResolver: z.string().optional().nullable(),
         preferWildcardCert: z.boolean().optional().nullable()
-    })
-    .strict();
+    });
 
 export type UpdateDomainResponse = {
     domainId: string;