DEV Community: Jop

I ran one API response through two JSON-to-Zod converters. One silently turned every field into z.string().

Jop — Wed, 24 Jun 2026 13:00:00 +0000

You have an API response. You want a Zod schema. So you paste the JSON into a JSON-to-Zod converter, copy the output, and ship it.

Here's the trap: a lot of those converters infer basic types only. Your email, your uuid, your url, your ISO timestamp — they all come out as z.string(). The schema compiles, the types look right, and your validator quietly accepts "not-an-email", "ftp://nope", and "2026-99-99" forever.

I wanted to see exactly how much gets lost, so I ran the same payload through two tools and diffed the output. Everything below is real, copy-pasteable output — nothing edited.

The input

A pretty ordinary user object:

{
  "id": "3f2a9c1e-5b7d-4e8a-9f1c-2d3e4f5a6b7c",
  "email": "ada@example.com",
  "website": "https://ada.dev",
  "age": 34,
  "rating": 4.7,
  "created_at": "2026-03-04T10:15:30Z",
  "is_active": true,
  "address": { "city": "Lyon", "zip": "69001" },
  "tags": ["early-adopter", "beta"]
}

Tool 1 — `json-to-zod` (npm)

const user = z.object({
  id: z.string(),
  email: z.string(),
  website: z.string(),
  age: z.number(),
  rating: z.number(),
  created_at: z.string(),
  is_active: z.boolean(),
  address: z.object({ city: z.string(), zip: z.string() }),
  tags: z.array(z.string()),
});

Structurally correct. But every meaningful field is a bare z.string() / z.number(). This schema will happily validate email: "lol" and created_at: "yesterday".

Tool 2 — TypeMorph

import { z } from "zod";

export const userAddressSchema = z.object({
  city: z.string(),
  zip: z.string().regex(/^[A-Z0-9][A-Z0-9\s\-]{1,8}[A-Z0-9]$/i),
});
export type UserAddress = z.infer<typeof userAddressSchema>;

export const userSchema = z.object({
  id: z.uuid(),
  email: z.email(),
  website: z.url(),
  age: z.number().int().min(0).max(150),
  rating: z.number().min(0).max(5),
  created_at: z.iso.datetime(),
  is_active: z.boolean(),
  address: userAddressSchema,
  tags: z.array(z.string()),
});
export type User = z.infer<typeof userSchema>;

The honest diff

Field	Value	`json-to-zod`	TypeMorph
`id`	a UUID	`z.string()`	`z.uuid()`
`email`	an email	`z.string()`	`z.email()`
`website`	a URL	`z.string()`	`z.url()`
`created_at`	ISO datetime	`z.string()`	`z.iso.datetime()`
`age`	`34`	`z.number()`	`z.number().int()…`

Two things worth being honest about:

The format detection is real and value-derived. z.uuid(), z.email(), z.url(), z.iso.datetime() come from looking at the actual values — they're facts, not guesses.
The numeric ranges and the zip regex are name-based guesses. age → .min(0).max(150), rating → .min(0).max(5) are inferred from field names, not values, so they can be wrong (a rating could be 0–10). TypeMorph lets you turn that "smart" layer off and keep only the facts. I'd rather it be upfront about which is which than pretend a guess is a fact.

Why this matters

A Zod schema's whole job is to reject bad data. z.string() where you meant z.email() is a validator that passes the exact inputs you wrote it to catch. You get the feeling of validation with none of the coverage — which is worse than no schema, because you stop checking.

When `json-to-zod` is still fine

It's a tiny, zero-dependency function you can call inside your own code. If you just want a rough scaffold and you'll add .email() / .uuid() / enums by hand, it does the job. It's also basically unmaintained at this point (last publish was years ago), so don't expect Zod v4 output or fixes.

Try the comparison yourself

npx typemorph-cli zod your-response.json --root User

CLI: npm i -g typemorph-cli
Web (paste JSON, get 40+ formats): https://typemorph.dev
Full honest comparison: https://typemorph.dev/alternatives/json-to-zod

I'm building TypeMorph in public — a JSON/OpenAPI → Zod/TypeScript/Go/Prisma converter that tries to detect what your data actually is instead of dumping everything to z.string(). Feedback (and "your inference got this wrong") very welcome.

How accurate are JSON Zod generators actually? I compared three on the same input

Jop — Sun, 21 Jun 2026 14:39:24 +0000

I've been relying on JSON→Zod generators to scaffold schemas from API responses,
and kept wondering — how much do they actually infer vs just dumping z.string()?
So I ran three tools on the same payload to find out.

Input (same for all):

{ "status": "active", "email": "a@b.com", "id": "a1b2c3d4-…",
  "joined": "2026-01-01T00:00:00Z", "age": 30, "website": "https://a.com" }

json-to-zod

z.object({
  status: z.string(), email: z.string(), id: z.string(),
  joined: z.string(), age: z.number(), website: z.string(),
})

Zero format detection. Technically correct, validates nothing.

quicktype (-l typescript-zod)

z.object({
  status: z.string(), email: z.string(), id: z.string(),
  joined: z.coerce.date(), // caught the date
  age: z.number(), website: z.string(),
})

1 out of 6. Better, but stops there.

TypeMorph (disclosure: side project I built — take with salt)

z.object({
  status: z.enum(["active", "pending", "closed"]),
  email: z.email(),
  id: z.uuid(),
  joined: z.iso.datetime(),
  age: z.number().int().min(0).max(150),
  website: z.url(),
})

The interesting design questions this raised for me:

Enums from a single sample → you get z.enum(["active"]) which rejects valid future values. You need multiple samples aggregated before enums are safe. Worth it?
Name-based heuristics (age → .int().min(0).max(150)) — useful shortcut or too opinionated?
Open-vocab fields like currency or country should stay z.string() even if they look like enums

Is anyone doing something smarter here? Curious what approach others take
when generating schemas from real API data.

Why I stopped copy-pasting JSON into online converters and built TypeMorph

Jop — Sun, 14 Jun 2026 11:20:42 +0000

Why I stopped copy-pasting JSON into online converters and built TypeMorph

Every developer has done it. You grab a JSON response from an API, paste it into some random online tool, and get a TypeScript interface back. Fast, convenient — and potentially a huge security mistake.

I did this for years before I realized what I was actually doing: sending production API responses, internal data models, and sometimes customer data to servers I knew nothing about.

So I built TypeMorph (https://typemorph.dev) — a schema conversion tool that runs 100% in your browser. No servers. No uploads. Your data never leaves your machine.

The problem with online converters

Most "free" online converters are not actually free. You're paying with your data.

When you paste a JSON payload into a third-party tool:

That payload hits their servers
It may be logged, stored, or analyzed
If it contains PII or proprietary business logic, you just leaked it

For personal projects this might be fine. But for a startup or enterprise team? One slip and you've violated your own data handling policies.

What TypeMorph does differently

TypeMorph uses a single AST pipeline that runs entirely in your browser:

JSON / YAML / OpenAPI / JSON Schema
└─► inferSchema() → Schema AST
└─► generators → 160+ output formats

Everything is client-side. There is no backend. The conversion happens in your tab and stays there.

160+ output formats

TypeMorph doesn't just do TypeScript. Paste one JSON object and get:

Validation schemas: Zod, Yup, Valibot, ArkType, Joi
Languages: Go, Rust, Python (Pydantic), Java, Kotlin, Swift, C#, Dart
Databases: Prisma, Drizzle, Kysely, MySQL, PostgreSQL, MongoDB
API: OpenAPI, Postman, Protobuf, GraphQL
Frontend: React Props, Vue Props, Pinia, Redux Slice

And it's not dumb code generation. The Zod generator applies semantic validators automatically:

// Input JSON: { "email": "user@example.com", "age": 28, "score": 94 }

// TypeMorph output:
export const rootSchema = z.object({
email: z.string().email(), // detected from field name
age: z.number().int().min(0).max(150), // semantic range
score: z.number().min(0).max(100), // semantic range
});

Schema Quality Score

TypeMorph grades your schema A–F and tells you why:

Fields typed as any
Missing format constraints (uuid, email, datetime…)
Mixed naming conventions (camelCase vs snake_case)
Overly deep nesting

It's like a linter for your data model.

Breaking Change Detector

Paste two versions of a schema and TypeMorph tells you exactly what broke:

0% compatible · 7 breaking · 1 info

❌ id REMOVED — Required field 'id' was removed
❌ name REMOVED — Required field 'name' was removed
⚠️ user_id ADDED — New required field. Existing payloads will be invalid

This alone has saved me from shipping breaking API changes more than once.

VS Code Extension

Last week I shipped a VS Code extension so you don't even need to open a browser.

Ctrl+Shift+T on any JSON file → pick a format → output appears in a side panel.

Install it from the VS Code Marketplace (https://marketplace.visualstudio.com/items?itemName=TypeMorph.typemorph-vscode).

CLI for CI pipelines

npm install -g typemorph-cli

typemorph zod schema.json # convert to Zod
typemorph quality schema.json # schema quality score
typemorph diff v1.json v2.json # breaking change detection

Try it

Web: https://typemorph.dev
VS Code: Marketplace (https://marketplace.visualstudio.com/items?itemName=TypeMorph.typemorph-vscode)
CLI: npm install -g typemorph-cli

If you've ever pasted company data into a random online tool and immediately felt uneasy about it — TypeMorph is for you.

What output formats do you wish existed? Drop them in the comments.

ents.

Why ChatGPT sucks at generating Types (and how I fixed it)

Jop — Sat, 30 May 2026 14:00:00 +0000

Have you ever pasted a JSON payload into ChatGPT and asked it to generate a TypeScript interface or Go struct?

Usually, it works. But sometimes, it decides to be "helpful" and changes your user_id to UserId, or completely forgets an optional field. In a production CI/CD pipeline, this kind of AI hallucination is a nightmare.

I got tired of this, so I built TypeFlow: A developer tool that converts JSON, SQL, or YAML into 16+ languages instantly. But the real secret isn't just AI—it's a Hybrid Architecture.

The Problem: AI is smart, but unpredictable

When dealing with Data Transfer Objects (DTOs), schemas, and type definitions, you need 100% deterministic output. If an AI "guesses" a type wrong, your app crashes.

Legacy tools like QuickType are fully deterministic but feel outdated and struggle with broken syntax. Modern devs just use AI, but sacrifice reliability.

The Solution: The Hybrid "TypeFlow" Engine

I wanted the absolute reliability of a compiler, mixed with the "magic" of an LLM. Here is how I built the TypeFlow engine:

1. The Core: Pure AST Parsing (Zero AI)

When you paste JSON or SQL into TypeFlow, it doesn't go to an LLM. Instead, I wrote a custom parser that reads the input and builds a Unified Abstract Syntax Tree (AST) entirely in the browser.
From that single AST, the engine deterministically generates 16 different outputs (TypeScript, Python Pydantic, Go Structs, Rust, Swift, etc.) in 0.01 seconds.
Result: Zero hallucinations. 100% reliable types.

2. The Magic: AI for Semantics and Healing

If the core is pure logic, where does the AI come in? I used the Gemini API for the things logic can't do easily:

Schema Healing: If you paste broken JSON (missing commas, trailing brackets), the AI intercepts it, heals the syntax instantly, and passes it to the AST parser.
Semantic Zod Validation: AST parsers just see string. I added an AI feature that reads the context of your data and infers semantic rules, automatically generating z.string().email() or z.string().uuid() for Zod validation.
Mermaid ER Diagrams: The AI reads the AST structure and generates beautiful Mermaid database relationship diagrams in real-time.

The Tech Stack

Frontend: Next.js 14 (App Router) + TailwindCSS
Editor: Monaco Editor (VS Code engine in the browser)
AI: Gemini 2.5 Flash (Using Server-Sent Events alt=sse for real-time code streaming)
Hosting: Cloudflare Pages (Blazing fast global edge delivery)

Try it out!

I just launched the beta version. It's completely free to use right now.
Check it out here: TypeFlow.pro

Let me know what you think! Have you experienced AI hallucinations breaking your code before? Drop a comment below!👇

DEV Community: Jop

I ran one API response through two JSON-to-Zod converters. One silently turned every field into z.string().

The input

Tool 1 — json-to-zod (npm)

Tool 2 — TypeMorph

The honest diff

Why this matters

When json-to-zod is still fine

Try the comparison yourself

How accurate are JSON Zod generators actually? I compared three on the same input

Why I stopped copy-pasting JSON into online converters and built TypeMorph

Why ChatGPT sucks at generating Types (and how I fixed it)

The Problem: AI is smart, but unpredictable

The Solution: The Hybrid "TypeFlow" Engine

1. The Core: Pure AST Parsing (Zero AI)

2. The Magic: AI for Semantics and Healing

The Tech Stack

Try it out!

Tool 1 — `json-to-zod` (npm)

When `json-to-zod` is still fine