@resourge/schema
Advanced tools
[](LICENSE)
@resourge/schema package is a comprehensive schema validation package tailored for developers working with diverse data schemas in modern applications. Designed with simplicity and efficiency in mind, @resourge/schema provides a set of utilities to effortlessly validate data against predefined schemas, ensuring accuracy, consistency, and compliance with specified standards.
OnlyOnTouch to validate values "only on touch" (values that were changed between last and new validation).Install using Yarn:
yarn add @resourge/schema
or NPM:
npm install @resourge/schema --save
Benchmarks to compare with other schemas validators (the performance can variate slightly depending on the machine).
@resourge/schema old x 11,616,880 ops/sec ±3.03% (93 runs sampled)
@resourge/schema new x 4,492,524 ops/sec ±2.66% (92 runs sampled)
Fast Validator x 1,593,352 ops/sec ±1.83% (95 runs sampled)
joi x 200,949 ops/sec ±1.30% (94 runs sampled)
zod x 53,117 ops/sec ±2.82% (91 runs sampled)
Yup x 11,939 ops/sec ±0.50% (92 runs sampled)
HeavyBenchmark (done with an array with 10 000 items)
@resourge/schema old x 2,550 ops/sec ±2.17% (90 runs sampled)
@resourge/schema new x 1,363 ops/sec ±3.31% (93 runs sampled)
Fast Validator x 211 ops/sec ±0.78% (82 runs sampled)
joi x 28.60 ops/sec ±9.21% (52 runs sampled)
zod x 24.60 ops/sec ±4.28% (45 runs sampled)
Yup x 15.58 ops/sec ±6.81% (44 runs sampled)
Would you like to try?
git clone https://github.com/resourge/schema.git
cd schema
npm install
npm run bench
import { array, object, string } from '@resourge/schemas';
type User = {
name: string
age: number
hobbies: string[]
}
const user: User = {
name: 'Rimuru',
age: 39,
location: {
city: 'Tempest',
address: 'Tempest',
postalCode: '4000-000',
country: 'Tempest'
},
hobbies: [
'Read',
'Nothing'
]
}
const schema = object<User>({
name: string().min(5).required(),
age: number().min(18).required(),
hobbies: array(string()).min(1).required(),
}).compile();
const schemaErrors = schema.validate(user)
const isValidUser = schema.isValid(user)
object is used to define schemas for validating objects.
schemas: An object containing validation schemas for object properties.message (optional): A custom error message template for object validation failures.Once you have created a schema using the object function, you can chain various validation methods to define your validation rules. For example:
import { object, string, number } from '@resourge/schema';
const userSchema = object({
name: string().required("Name is required"),
age: number().min(18, "Age must be at least 18").max(100, "Age must be less than or equal to 100"),
email: string().email("Invalid email address")
})
.compile();
userSchema.validate({
name: "John Doe",
age: 25,
email: "john.doe@example.com"
});
In this example, the schema validates that the object:
string is used to define validation rules for string values. You can chain multiple validation methods to create complex validation logic.
message (optional)(string): Overrides the default error message for validation rules.Once you have created a schema using the string function, you can chain various validation methods to define your validation rules. For example:
import { string } from '@resourge/schema';
string()
.min(5, "Minimum length should be 5 characters")
.max(10, "Maximum length should be 10 characters")
.pattern(/[a-zA-Z]+/, "Should contain only alphabetic characters")
.compile();
In this example, the schema validates that the string:
number is used to define validation rules for numbers values. You can chain multiple validation methods to create complex validation logic.
message (optional)(string): Overrides the default error message for validation rules.Once you have created a schema using the number function, you can chain various validation methods to define your validation rules. For example:
import { string } from '@resourge/schema';
number()
.min(0, "Value should be greater than or equal to 0")
.max(100, "Value should be less than or equal to 100")
.integer("Value should be an integer")
.positive("Value should be positive")
.compile();
In this example, the schema validates that the number:
array is used to define validation rules for array's. You can chain multiple validation methods to create complex validation logic.
message (optional)(string): Overrides the default error message for validation rules.Once you have created a schema using the array function, you can chain various validation methods to define your validation rules. For example:
import { array } from '@resourge/schema';
// Create an array schema for validating arrays of objects
const arraySchema = array({
id: number().positive("ID must be a positive number"),
name: string().required("Name is required"),
email: string().email("Invalid email address")
}).compile();
// Example data to validate
const users = [
{ id: 1, name: "John Doe", email: "john@example.com" },
{ id: -2, name: "Alice", email: "alice@example" }, // Invalid email
{ id: 3, name: "Bob", email: "bob@example.com" }
];
// Validate the array of users
const validationResult = arraySchema.validate(users);
if (validationResult.isValid) {
console.log("All users are valid!");
} else {
console.log("Validation errors:");
console.log(validationResult.errors);
}
In this example, the schema validates:
date is used to define validation rules for dates. You can chain multiple validation methods to create complex validation logic.
message (optional)(string): Overrides the default error message for validation rules.Once you have created a schema using the date function, you can chain various validation methods to define your validation rules. For example:
import { date } from '@resourge/schema';
// Create a date schema for validating arrays of objects
const dateSchema = date()
.minDate(new Date("2024-01-01"), "Date must be after 2024-01-01")
.maxDate(new Date("2024-12-31"), "Date must be before 2024-12-31")
.compile();
// Example data to validate
const eventDate = new Date("2024-06-15");
// Validate the date
const validationResult = dateSchema.validate(eventDate);
if (validationResult.isValid) {
console.log("Event date is valid!");
} else {
console.log("Validation errors:");
console.log(validationResult.errors);
}
In this example, the schema validates:
boolean is used to define validation rules for dates. You can chain multiple validation methods to create complex validation logic.
message (optional)(string): Overrides the default error message for validation rules.Once you have created a schema using the boolean function, you can chain various validation methods to define your validation rules. For example:
import { boolean } from '@resourge/schema';
// Create a boolean schema for validating boolean values
const booleanSchema = boolean();
// Example data to validate
const isEnabled = true;
// Validate the boolean value
const validationResult = booleanSchema.validate(isEnabled);
if (validationResult.isValid) {
console.log("Boolean value is valid!");
} else {
console.log("Validation errors:");
console.log(validationResult.errors);
}
In this example, the schema validates:
compile is responsible for compiling the validation rules into executable code. The compiled code is then used to validate input data against the defined schema. (it's recommended to use in every schema. Otherwise isValid and validate will call it).
compile(config?: CompileConfig): this
config (optional): An object containing configuration options for compilation.
debug (optional): A boolean flag indicating whether to log the validation structure for debugging purposes. Default is false.defaultNullable (optional): A boolean flag indicating whether to make nullable default in the schemas. Default is undefined.defaultOptional (optional): A boolean flag indicating whether to make optional default in the schemas. Default is undefined.messages (optional): An object containing custom messages to be used during validation.onlyOnTouch (optional): A boolean flag indicating whether to make onlyOnTouch default in the schemas.import { object } from '@resourge/schema';
// Compile the schema with default configuration
object().compile();
// Compile the schema with custom configuration
object().compile({
debug: true,
defaultNullable: true,
messages: {
required: 'This field is required.',
notNullable: 'This field cannot be null.'
}
});
validate is responsible for validating input data against the compiled schema. It returns an array of errors if any validation errors are encountered.
validate(value: Input, onlyOnTouch?: OnlyOnTouch<Input>): SchemaError[] | Promise<SchemaError[]>
value: The input data to be validated against the schema.onlyOnTouch (optional): An array of keys that inform the schema if a value was touched. Works only with the onlyOnTouch feature of the schema.import { array, object, string } from '@resourge/schemas';
const schema = object({
username: string().required(),
age: number().min(20).required()
email: string().email().required()
}).compile();
const inputData = {
username: 'John',
age: 30,
email: 'john@example.com'
};
const errors = schema.validate(inputData);
if (errors.length > 0) {
console.log('Validation errors:', errors);
} else {
console.log('Validation successful');
}
@resourge/schema, by default, has default messages. This message can be changed globally.
const customMinMessage = 'Custom min message';
setupDefaultMessage({
//... rest of translations
string: {
min: () => customMinMessage
}
})
const schema = string()
.min(10)
.compile();
For comprehensive documentation and usage examples, visit the schema documentation.
Contributions to @resourge/schema are welcome! To contribute, please follow the contributing guidelines.
@resourge/schema is licensed under the MIT License.
For questions or support, please contact the maintainers:
FAQs
[](LICENSE)
The npm package @resourge/schema receives a total of 156 weekly downloads. As such, @resourge/schema popularity was classified as not popular.
We found that @resourge/schema demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 0 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
In this segment of the Risky Business podcast, Feross Aboukhadijeh and Patrick Gray discuss the challenges of tracking malware discovered in open source softare.
Research
Security News
A threat actor's playbook for exploiting the npm ecosystem was exposed on the dark web, detailing how to build a blockchain-powered botnet.
Security News
NVD’s backlog surpasses 20,000 CVEs as analysis slows and NIST announces new system updates to address ongoing delays.