Deep infers - Don´t give me correct types

[oscarthroedsson]

I have schemas for most of my stuff in the app.
→ Base
→ Create
→ Update

Examples:

export const UserProcessSchema = z.object({
  id: z.string(),
  userId: z.string(),
  user: userSchema.optional(),

  jobPostingId: z.string(),
  jobPosting: jobPostingSchema.nullable().optional(),

  status: UserProcessStatusEnums.default("not_started"),
  startedAt: z.string(),
  completedAt: z.string().nullable().optional(),

  processId: z.string().nullable().optional(),
  process: ProcessSchema.nullable().optional(),

  steps: z.array(UserProcessStepSchema).optional(),
});

export const UserProcessSchemaCreate = UserProcessSchema.omit({ id: true, steps: true, process: true }).extend({
  steps: z.array(UserProcessStepSchemaCreate).optional(),
  process: ProcessSchemaCreate.nullable().optional(),
  // JobPosting Create should be added
});
export const UserProcessSchemaUpdate = UserProcessSchema.partial().extend({
  jobPosting: jobPostingUpdateSchema,
  process: ProcessSchemaUpdate,
  steps: z.array(UserProcessStepSchemaUpdate).optional(),
});

I then use infer to provide me types:

export type IUserProcess = z.infer<typeof UserProcessSchema>;
export type IUserProcessCreate = z.infer<typeof UserProcessSchemaCreate>;
export type IUserProcessUpdate = z.infer<typeof UserProcessSchemaUpdate>;

But my types aren’t being typed correctly! I find this pretty weird, even if I don’t follow the intended structure.

Result of the types:

// IUserProcessCreate
type IUserProcessCreate = {
    userId: string;
    status: "not_started" | "started" | "waiting_for_reply" | "interview_booked" | "interview_completed" | "offer_received" | "rejected" | "hired" | "archived";
    startedAt: string;
    jobPostingId: string;
    completedAt: string | null | undefined;
    user: { ... 11 more } | undefined;
    jobPosting: { ... 21 more } | null | undefined;
    processId: string | null | undefined;
    steps: Record<string, unknown>[] | undefined;  👈🏼
    process: { ... 7 more } | null | undefined;
}

This is the schema I expect to see:

export const UserProcessStepSchema: ReturnType<typeof z.object> = z.object({
  id: z.string(),
  userProcessId: z.string(),
  stepId: z.string().optional(), // if user create one by them self, we won´t have a template

  isExecuted: z.boolean().default(false),
  executedAt: z.string().nullable().optional(),

  // Optional make it possible to query UserProcessStep with out including the actullay step
  step: ProcessStepSchema.optional(),
  comments: z.array(UserPipelineStepCommentSchema).default([]),

  // Do not include UserProcess here
  // Do not include Step
});

export const UserProcessStepSchemaCreate = UserProcessStepSchema.omit({
  id: true,
  userProcessId: true,
  stepId: true,
});

export const UserProcessStepSchemaUpdate = UserProcessStepSchema.partial()

Can someone help me understand how this is ment to be used?

[dosubot[bot]]

I'm a bot trained on Zod's codebase and issues.

When you see steps: Record<string, unknown>[] | undefined in your inferred type, it's usually because Zod's type inference falls back to a broad type if the nested schema isn't specific enough, or if the schema shape ends up with an index signature (like a catchall, loose mode, or merging in a record-type field) [docs]. This can happen if any part of your nested schema uses z.any(), z.unknown(), or if the schema is imported in a way that TypeScript can't resolve its shape precisely [source].

The .omit() and .extend() methods work by cloning the schema and updating its shape, so the inferred type should preserve nested schema types if everything is defined correctly [docs]. But if the element schema for your array (UserProcessStepSchemaCreate) is not specific, or if it's imported from another workspace and TypeScript can't resolve it, the type will degrade to Record<string, unknown> [source].

Checklist to debug:

• Make sure none of your schemas use z.any() or z.unknown() for fields you expect to be typed.
• Check for circular imports or workspace import issues—these can cause TypeScript to lose track of schema shapes.
• If you use .default() or .transform(), remember that z.infer gives you the output type, not the input type. Use z.input<typeof schema> for input types if needed [docs].
• If you're on Zod 3, consider upgrading to Zod 4, which improves type inference and workspace compatibility [source].
• Check your tsconfig.json for moduleResolution settings; using "node16" or "bundler" can affect type inference in monorepos [source].

If you still see the issue, please share a minimal, runnable reproduction (including the full definition of UserProcessStepSchemaCreate and any imported schemas). This will help pinpoint the problem.

Let me know if this helps or if you want to dig deeper! If your question is answered, feel free to close the issue.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}