How to validate an email address with computed-types?

You need to create a custom validator using an external library like 'email-validator' or regex, as shown in the README's Email function example. This involves defining a function that throws on invalid input and optionally using .transform() for chaining.

computed-types vs zod: which should I use?

Computed Types excels in TypeScript integration and zero dependencies, ideal for custom validation logic. Zod offers more built-in validations and a larger ecosystem. Choose computed-types for tight type safety in pure TypeScript projects.

How to handle optional fields in computed-types?

Use the .optional() or .strictOptional() methods on validators, as demonstrated in schema examples like address: string.trim().optional(). This allows undefined or null values while maintaining type safety.

Does computed-types support async validation for API calls?

Yes, it automatically supports asynchronous validators by returning promises, as shown with the AvailableUsername example that fetches data from an API. The library handles promise resolution and type inference.

Is computed-types good for validating nested objects?

Yes, you can create nested schemas using the Schema function with objects and arrays, like in the UserSchema example with items array containing object validation. It supports deep validation and transformation.

How to create custom validators with computed-types?

Define a function that takes input and returns a value or throws an error, as shown with the Email validator. Use .transform() for chaining, and ensure optional arguments for optional types, per the README's custom type section.

Open-Awesome

computed_types

MITTypeScript

A strongly-typed runtime validation library for TypeScript that generates accurate interfaces and supports data transformation.

GitHub

359 stars13 forks0 contributors

What is computed_types?

Computed Types is a runtime validation library for TypeScript that allows developers to define schemas using function interfaces, which automatically generate accurate TypeScript types. It validates and transforms data at runtime while providing compile-time type safety, reducing duplication and catching errors early. The library supports both synchronous and asynchronous validation, along with data transformation and chaining of validators.

Target Audience

TypeScript developers who need runtime validation with strong type safety, especially those working on APIs, form validation, or data processing where schema validation is critical.

Value Proposition

Developers choose Computed Types for its seamless TypeScript integration, automatic interface generation, and zero-dependency design, offering a more type-safe and readable alternative to traditional validation libraries like Joi.

Overview

🦩 Joi like validations for TypeScript

Use Cases

Best For

Validating API request payloads with TypeScript interfaces
Building type-safe form validation schemas for frontend applications
Transforming and normalizing data during validation processes
Creating reusable validation chains with custom business logic
Ensuring runtime type safety in TypeScript projects without external dependencies
Handling asynchronous validation scenarios like username availability checks

Not Ideal For

Projects that require extensive, out-of-the-box validations like email or URL without custom code
Teams already heavily invested in other validation libraries like Zod or Joi with established ecosystems
Applications needing ultra-high-performance validation on massive datasets due to runtime overhead
Environments where developers prefer declarative schema definitions over function-based interfaces

Pros & Cons

Pros

Seamless TypeScript Integration

Automatically generates accurate TypeScript interfaces from validation schemas, eliminating duplication and catching errors at compile time, as shown in the UserSchema example.

Flexible Validator Chaining

Supports chaining multiple validators with helpers like .equals(), .test(), and .transform(), enabling complex type creation and data normalization in a single step.

Zero Dependencies

Lightweight and compact with no external dependencies, making it easy to integrate and bundle without bloat, as highlighted in the main features.

Asynchronous Support

Automatically detects and handles promises for async validation scenarios, such as checking username availability via API, without additional configuration.

Cons

Limited Built-in Validations

Requires custom validators for common checks like email validation, using external libraries or manual implementation, as demonstrated in the Email function example.

Steeper Learning Curve

Function-based interfaces and chaining methods can be less intuitive than declarative schemas, especially for developers new to this paradigm.

Smaller Ecosystem

Has fewer third-party plugins, integrations, and community resources compared to established alternatives like Joi or Zod, which may limit tooling support.

Open Source Alternative To

computed_types is an open-source alternative to the following products:

Joi

Joi is a powerful schema description language and data validator for JavaScript objects, commonly used in Node.js applications for input validation.

Frequently Asked Questions

Related Projects

croner

Trigger functions or evaluate cron expressions in JavaScript or TypeScript. No dependencies. Most features. Node. Deno. Bun. Browser.

Stars2,611

Forks75

Last commit4 days ago

fastest-validator

:zap: The fastest JS validator library for NodeJS

Stars1,464

Forks100

Last commit2 months ago

denon

👀 Monitor any changes in your Deno application and automatically restart.

Stars1,108

Forks43

Last commit2 years ago

evt

💧EventEmitter's typesafe replacement

Stars461

Forks8

Last commit1 year ago

Community-curated · Updated weekly · 100% open source

Found a gem we're missing?

Open-Awesome is built by the community, for the community. Submit a project, suggest an awesome list, or help improve the catalog on GitHub.

Submit a project Star on GitHub