What Standard Schema community packages would you like to see?

[MathurAditya724]

Standard Schema Community currently maintains:

• standard-json — Standard Schema → JSON Schema
• standard-openapi — Standard Schema → OpenAPI Schema

We’d love your input on what would make the Standard Schema ecosystem more useful.
What package, integration, adapter, tooling, example, or documentation project would you like to see added here?
When suggesting an idea, please include:

1. The problem or workflow it would solve
2. Which framework, runtime, or ecosystem it targets
3. Existing alternatives or related work, if any
4. Whether you’d be interested in helping design, build, or maintain it

A few directions we’re curious about:

• Framework integrations (Hono, Express, Fastify, tRPC, etc.)
• Client/API tooling generated from Standard Schema
• Testing, mocking, or fixture-generation utilities
• Documentation/examples for schema-library interoperability
• CLI, migration, or validation tooling

No idea is too small—practical pain points are especially useful. We’ll collect the feedback and turn the strongest proposals into scoped issues or repositories.

[ma3oudrjn]

I’d love to see a Standard Schema HTTP error/response adapter that provides a consistent way to turn validation results into framework-independent API errors.

1. Problem / workflow

Standard Schema makes validation portable, but the moment validation fails, applications still have to decide how to translate issues into an HTTP response.

In a backend API, I usually need to turn something like:

{
  issues: [
    { message: "Invalid email", path: ["email"] },
    { message: "Required", path: ["profile", "name"] }
  ]
}

into a predictable API error format.

Today this logic tends to be implemented separately in NestJS, Fastify, Express, Hono, routers, and application-specific error handlers.

There are also subtle interoperability problems around Issue.path and the runtime shape of issues. Different Standard Schema implementations can expose different path representations, and some implementations may return array-like error objects that are not safely serializable with JSON.stringify.

A small official package could normalize Standard Schema failures into a stable, JSON-safe representation and provide framework adapters.

For example:

const result = await schema["~standard"].validate(input);

if (result.issues) {
  throw new StandardHttpValidationError(result.issues);
}

and then:

{
  status: 400,
  code: "VALIDATION_ERROR",
  issues: [
    {
      path: ["email"],
      message: "Invalid email"
    }
  ]
}

The important part would be keeping the core representation framework-independent while providing optional adapters for HTTP frameworks.

2. Target ecosystem

Primarily:

• Node.js
• TypeScript
• REST APIs
• NestJS
• Fastify
• Express
• Hono

The core package should not depend on any framework.

3. Existing alternatives / related work

@standard-schema/utils already provides SchemaError and getDotPath, which is useful for generic validation handling.

There are also framework-specific implementations and integrations, such as React Hook Form's Standard Schema resolver, while projects like NestJS and TanStack Router have their own handling for validation issues.

What seems to be missing is a small, framework-agnostic layer focused specifically on the transport boundary:

Standard Schema validation result → safe, normalized API error

This could also define utilities for safely normalizing Issue.path without relying on JSON.stringify on vendor-specific issue objects.

4. Contribution

I’d be interested in helping design and build it.

I work mostly with TypeScript backend APIs and deal with request validation, DTOs, HTTP error handling, NestJS/Fastify, and API documentation, so this is a problem I could realistically help implement and test across multiple frameworks.

A good initial scope could be intentionally small:

• StandardHttpValidationError
• JSON-safe issue normalization
• consistent path normalization
• framework-neutral error response shape
• optional adapters for NestJS, Fastify, Express and Hono
• examples showing the same schema and error handling across different frameworks