Joi Class Decorators

https://github.com/whefter/joi-class-decorators
Admin
Integrate Joi validation schema definitions directly into your type/DTO classes using convenient...
Tokens:8,503
Snippets:55
Trust Score:6.3
License:MIT
Update:10 months ago
Show doc for...
Tokens:
Raw
### Install joi-class-decorators

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Install the joi-class-decorators package using npm. This command adds the library as a dependency to your project.

```bash
npm install --save joi-class-decorators
```

--------------------------------

### Install Peer Dependencies for Joi 17/18

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Install the required peer dependencies, Joi and reflect-metadata, for your chosen Joi version. This ensures compatibility with the validation library.

```bash
npm install --save joi@^17 reflect-metadata@^0.1
# or
npm install --save joi@^18 reflect-metadata@^0.1
```

--------------------------------

### Example Usage of joi-class-decorators

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Demonstrates how to use joi-class-decorators to define validation schemas for a BookDto class. It shows property decorators for individual fields and class decorators for options, including validation groups for different operations.

```typescript
import { JoiSchema, JoiSchemaOptions, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
})
export class BookDto {
  @JoiSchema(Joi.string().required())
  @JoiSchema(['CREATE'], Joi.string().required())
  @JoiSchema(['UPDATE'], Joi.string().optional())
  name!: string;

  @JoiSchema(Joi.string().required())
  @JoiSchema(['CREATE'], Joi.string().required())
  @JoiSchema(['UPDATE'], Joi.string().optional())
  author!: string;

  @JoiSchema(Joi.number().optional())
  publicationYear?: number;
}

const schema = getClassSchema(BookDto);
Joi.assert(
  {
    name: 'Interesting Times',
    author: 'Terry Pratchett',
    publicationYear: 1994,
  },
  schema,
);

const updateSchema = getClassSchema(BookDto, { group: 'UPDATE' });
Joi.assert(
  {
    name: 'Interesting Times',
  },
  updateSchema,
);
```

--------------------------------

### Assigning Joi Schema for DEFAULT group with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Example of using `@JoiSchema(joiSchema)` to assign a specific Joi schema to a property for the `DEFAULT` group.

```typescript
class BookDto {
  @JoiSchema(Joi.string().optional())
  name?: string;
}
```

--------------------------------

### Configure Joi Validation Options with @JoiSchemaOptions in TypeScript

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

This snippet illustrates the use of the @JoiSchemaOptions decorator to configure Joi validation options at the class level. It controls behaviors like handling of unknown properties, stripping invalid values, and error reporting for the entire schema. Examples show both strict and lenient configurations, as well as group-specific options.

```typescript
import { JoiSchema, JoiSchemaOptions, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
  stripUnknown: false,
  abortEarly: false,
  presence: 'required',
})
class StrictConfigDto {
  @JoiSchema(Joi.string())
  name!: string;

  @JoiSchema(Joi.number())
  port!: number;
}

@JoiSchemaOptions({
  allowUnknown: true,
  stripUnknown: true,
  abortEarly: true,
})
class LenientConfigDto {
  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.number().default(8080))
  port?: number;
}

const strictSchema = getClassSchema(StrictConfigDto);
const lenientSchema = getClassSchema(LenientConfigDto);

// Strict validation - fails with unknown properties
const strictData = {
  name: 'myapp',
  port: 3000,
  extraField: 'not allowed',
};

const strictResult = strictSchema.validate(strictData);
console.log('Strict validation:', strictResult.error?.message);
// Error: "extraField" is not allowed

// Lenient validation - strips unknown properties
const lenientData = {
  name: 'myapp',
  extraField: 'will be stripped',
  anotherExtra: 'also stripped',
};

const lenientResult = lenientSchema.validate(lenientData);
console.log('Lenient validation:', lenientResult.error ? 'Failed' : 'Success');
console.log('Lenient value:', lenientResult.value);
// Success, extraField and anotherExtra are removed, port gets default value

// Group-specific options
@JoiSchemaOptions({
  allowUnknown: true,
})
@JoiSchemaOptions(['STRICT'], {
  allowUnknown: false,
})
class FlexibleDto {
  @JoiSchema(Joi.string().required())
  name!: string;
}

const defaultFlexSchema = getClassSchema(FlexibleDto);
const strictFlexSchema = getClassSchema(FlexibleDto, { group: 'STRICT' });

console.log('Default allows unknown:', defaultFlexSchema.validate({ name: 'test', extra: 'ok' }).error === null);
console.log('Strict rejects unknown:', strictFlexSchema.validate({ name: 'test', extra: 'fail' }).error !== null);

```

--------------------------------

### Using DEFAULT group with @JoiSchemaOptions and @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Demonstrates how the DEFAULT symbol is implicitly assigned to schemas and options when no group is specified. It shows equivalent class definitions using both implicit and explicit DEFAULT group assignments.

```typescript
import { DEFAULT } from 'joi-class-decorators';

@JoiSchemaOptions({
  allowUnknown: false,
})
class ImplicitDefaultGroupDto {
  @JoiSchema(Joi.string().required())
  name!: string;
}

@JoiSchemaOptions([DEFAULT], {
  allowUnknown: false,
})
class ExplicitDefaultGroupDto {
  @JoiSchema([DEFAULT], Joi.string().required())
  name!: string;
}
```

--------------------------------

### Retrieving Joi Schema with getClassSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Illustrates how to use the `getClassSchema` function (or its alias `getTypeSchema`) to obtain the Joi schema constructed from a given class type. This is useful for advanced scenarios like defining alternative schemas.

```typescript
class ThrillerDto {
  @JoiSchema(Joi.number().required())
  thrill!: number;
}

class RomanceDto {
  @JoiSchema(Joi.number().optional())
  romance?: number;
}

class AuthorDto {
  @JoiSchema(Joi.alternatives(getTypeSchema(ThrillerDto), getTypeSchema(RomanceDto)))
  booksRatings: ThrillerDto | RomanceDto;
}
```

--------------------------------

### Assigning Joi Schema for specific groups with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Demonstrates how to assign a Joi schema to a property for a specified set of groups using `@JoiSchema(groups[], joiSchema)`.

```typescript
class BookDto {
  @JoiSchema(['CREATE'], Joi.string().required())
  name!: string;
}
```

--------------------------------

### Construct Joi Schema from Decorated Class

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

The `getClassSchema` function generates a Joi validation schema from a decorated class constructor. It processes all decorators within the class hierarchy to create a complete Joi object schema. This schema can then be used with Joi's validation methods to validate data against the class's defined rules. Dependencies include 'joi-class-decorators' and 'joi'.

```typescript
import { JoiSchema, JoiSchemaOptions, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
})
class BookDto {
  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.string().required())
  author!: string;

  @JoiSchema(Joi.number().optional())
  publicationYear?: number;
}

// Get the schema for validation
const schema = getClassSchema(BookDto);

// Use the schema to validate data
const validData = {
  name: 'Interesting Times',
  author: 'Terry Pratchett',
  publicationYear: 1994,
};

try {
  const result = Joi.assert(validData, schema);
  console.log('Validation passed');
} catch (error) {
  console.error('Validation failed:', error.message);
}

// Invalid data example
const invalidData = {
  name: 'Book Without Author',
  extraField: 'not allowed',
};

try {
  Joi.assert(invalidData, schema);
} catch (error) {
  console.error('Validation failed:', error.message);
  // Error: "author" is required, "extraField" is not allowed
}
```

--------------------------------

### Apply Joi Schema Options to Class

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

The @JoiSchemaOptions decorator assigns Joi options to be passed to the .options() method of the fully constructed Joi schema for a class. It can be applied globally or to specific groups.

```typescript
import { JoiSchemaOptions, JoiSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
})
class BookDto {
  @JoiSchema(Joi.string().optional())
  name?: string;
}

@JoiSchemaOptions(['CREATE'], {
  allowUnknown: false,
})
class BookDtoWithGroup {
  @JoiSchema(['CREATE'], Joi.string().optional())
  name?: string;
}
```

--------------------------------

### Handle Class Inheritance with Joi Decorators

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Both @JoiSchema() and @JoiSchemaOptions() decorators correctly handle class inheritance, allowing for schemas to be built upon parent class definitions. Options are merged, with child class options taking precedence.

```typescript
import { JoiSchemaOptions, JoiSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
})
class BookDto {
  @JoiSchema(Joi.string().required())
  name!: string;
}

@JoiSchemaOptions({
  allowUnknown: true,
})
class ExtendedBookDto extends BookDto {
  @JoiSchema(Joi.string().optional())
  author?: string;
}

// The resulting Joi schema for ExtendedBookDto would be equivalent to:
// Joi.object()
//   .keys({
//     name: Joi.string().required(),
//     author: Joi.string().optional(),
//   })
//   .options({
//     allowUnknown: true,
//   });
```

--------------------------------

### Assigning Array of Nested Object Schema for specific groups with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Shows how to assign a `Joi.array()` schema with nested items for specific groups using `@JoiSchema(groups[], [nestedType], customizeArraySchemaCallback?, customizeSchemaCallback?)`.

```typescript
class AuthorDto {
  @JoiSchema(
    ['UPDATE'],
    [BookDto],
    arraySchema => arraySchema.optional().default([]),
    schema => schema.optional(),
  )
  books!: BookDto[];
}
```

--------------------------------

### TypeScript Class Inheritance with Joi Validation

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

This snippet demonstrates class inheritance with joi-class-decorators. Parent classes define validation rules and options, which are inherited by child classes. Child properties can override parent properties, and class decorators like JoiSchemaCustomization can add further validation constraints.

```typescript
import { JoiSchema, JoiSchemaOptions, JoiSchemaCustomization, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
})
class BaseDto {
  @JoiSchema(Joi.string().uuid().required())
  id!: string;

  @JoiSchema(Joi.date().default(() => new Date()))
  createdAt!: Date;
}

@JoiSchemaOptions({
  stripUnknown: true,
})
class AuditableDto extends BaseDto {
  @JoiSchema(Joi.date().optional())
  updatedAt?: Date;

  @JoiSchema(Joi.string().optional())
  updatedBy?: string;
}

class UserDto extends AuditableDto {
  @JoiSchema(Joi.string().email().required())
  email!: string;

  @JoiSchema(Joi.string().min(8).required())
  password!: string;

  // Override parent's createdAt to make it optional
  @JoiSchema(Joi.date().optional())
  createdAt?: Date;
}

@JoiSchemaCustomization(schema => schema.and('firstName', 'lastName'))
class PersonDto extends BaseDto {
  @JoiSchema(Joi.string().optional())
  firstName?: string;

  @JoiSchema(Joi.string().optional())
  lastName?: string;

  @JoiSchema(Joi.number().min(0).max(120).optional())
  age?: number;
}

// Get schemas for each level
const baseSchema = getClassSchema(BaseDto);
const auditableSchema = getClassSchema(AuditableDto);
const userSchema = getClassSchema(UserDto);
const personSchema = getClassSchema(PersonDto);

// Base schema validation
console.log('Base keys:', Object.keys(baseSchema.describe().keys));
// ['id', 'createdAt']

// Auditable includes base fields plus its own
console.log('Auditable keys:', Object.keys(auditableSchema.describe().keys));
// ['id', 'createdAt', 'updatedAt', 'updatedBy']

// User includes all inherited fields
console.log('User keys:', Object.keys(userSchema.describe().keys));
// ['id', 'createdAt', 'updatedAt', 'updatedBy', 'email', 'password']

const validUser = {
  id: '123e4567-e89b-12d3-a456-426614174000',
  email: 'user@example.com',
  password: 'securePassword123',
};

console.log('User validation:', userSchema.validate(validUser).error ? 'Failed' : 'Success');
// Success, createdAt gets default value

// Person schema includes customization from parent
const validPerson = {
  id: '123e4567-e89b-12d3-a456-426614174000',
  firstName: 'John',
  lastName: 'Doe',
  age: 30,
};

console.log('Person validation:', personSchema.validate(validPerson).error ? 'Failed' : 'Success');
// Success

const invalidPerson = {
  id: '123e4567-e89b-12d3-a456-426614174000',
  firstName: 'John',
  age: 30,
};

console.log('Person invalid:', personSchema.validate(invalidPerson).error?.message);
// Error: firstName and lastName must be present together (due to .and())

```

--------------------------------

### Customize Constructed Schema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

The @JoiSchemaCustomization decorator accepts a function that is called with the fully constructed class schema. The return value of this function (which must be a schema) is used in subsequent steps, allowing for advanced schema modifications.

```typescript
import { JoiSchema, JoiSchemaCustomization, JoiSchemaOptions } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaCustomization(schema => schema.or('label', 'description'))
class BookDto {
  @JoiSchema(Joi.string().required())
  label!: string;

  @JoiSchema(Joi.string().required())
  description!: string;
}

@JoiSchemaCustomization(['CREATE'], schema => schema.or('label', 'description'))
class BookDtoWithGroup {
  @JoiSchema(['CREATE'], Joi.string().required())
  label!: string;

  @JoiSchema(['CREATE'], Joi.string().required())
  description!: string;
}
```

--------------------------------

### Assigning Nested Object Schema for specific groups with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Shows how to assign a nested object schema for specific groups using `@JoiSchema(groups[], nestedType, customizeSchemaCallback?)`.

```typescript
class AuthorDto {
  @JoiSchema(['UPDATE'], BookDto, schema => schema.optional())
  firstBook?: BookDto;
}
```

--------------------------------

### Assigning Array of Nested Object Schema for DEFAULT group with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Demonstrates assigning a `Joi.array()` schema where each item is constructed from a nested type using `@JoiSchema([nestedType], customizeArraySchemaCallback?, customizeSchemaCallback?)` for the `DEFAULT` group. Callbacks allow customization of the array and its items.

```typescript
class AuthorDto {
  @JoiSchema([BookDto], arraySchema => arraySchema.required(), schema => schema.optional())
  books!: BookDto[];
}
```

--------------------------------

### Defining Object Schemas with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Shows the basic usage of the `@JoiSchema()` decorator to define a Joi object schema for a class. Properties decorated with `@JoiSchema` contribute to the final object schema.

```typescript
class BookDto {
  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.string().required())
  author!: string;

  @JoiSchema(Joi.number().optional())
  publicationYear?: number;
}
```

--------------------------------

### Customize Joi Schemas with @JoiSchemaCustomization (TypeScript)

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

The @JoiSchemaCustomization decorator allows for applying custom transformations to Joi schemas generated by joi-class-decorators. It is useful for implementing conditional validation, cross-field dependencies, and schema-level constraints. It takes a function that receives the generated schema and returns a modified one. Dependencies include 'joi-class-decorators' and 'joi'.

```typescript
import { JoiSchema, JoiSchemaCustomization, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaCustomization(schema =>
  schema.or('email', 'phone')
    .message('Either email or phone must be provided')
)
class ContactDto {
  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.string().email().optional())
  email?: string;

  @JoiSchema(Joi.string().pattern(/^\d{10}$/).optional())
  phone?: string;
}

@JoiSchemaCustomization(schema =>
  schema
    .when('.type', {
      is: 'premium',
      then: Joi.object().keys({
        maxUsers: Joi.number().min(10).required(),
        features: Joi.array().min(1).required(),
      }),
      otherwise: Joi.object().keys({
        maxUsers: Joi.number().max(5).default(5),
      }),
    })
)
class SubscriptionDto {
  @JoiSchema(Joi.string().valid('basic', 'premium').required())
  type!: string;

  @JoiSchema(Joi.number().optional())
  maxUsers?: number;

  @JoiSchema(Joi.array().items(Joi.string()).optional())
  features?: string[];
}

const contactSchema = getClassSchema(ContactDto);

// Valid: has email
console.log(contactSchema.validate({
  name: 'John Doe',
  email: 'john@example.com'
}).error);
// null

// Valid: has phone
console.log(contactSchema.validate({
  name: 'Jane Doe',
  phone: '1234567890'
}).error);
// null

// Invalid: missing both email and phone
console.log(contactSchema.validate({
  name: 'Invalid User'
}).error?.message);
// "Either email or phone must be provided"

const subscriptionSchema = getClassSchema(SubscriptionDto);

// Valid premium subscription
console.log(subscriptionSchema.validate({
  type: 'premium',
  maxUsers: 50,
  features: ['advanced-analytics', 'priority-support']
}).error);
// null

// Invalid premium subscription (maxUsers too low)
console.log(subscriptionSchema.validate({
  type: 'premium',
  maxUsers: 5,
  features: ['advanced-analytics']
}).error?.message);
// Validation error about maxUsers

// Valid basic subscription
console.log(subscriptionSchema.validate({
  type: 'basic'
}).error);
// null

```

--------------------------------

### Define Validation Groups for Class Schemas in TypeScript

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

This snippet demonstrates how to define different validation schemas for the same class based on context using the @JoiSchema decorator with group names. It allows a single DTO to handle scenarios like 'CREATE' and 'UPDATE' by applying specific validation rules and options for each group.

```typescript
import { JoiSchema, JoiSchemaOptions, getClassSchema, DEFAULT } from 'joi-class-decorators';
import * as Joi from 'joi';

@JoiSchemaOptions({
  allowUnknown: false,
})
@JoiSchemaOptions(['UPDATE'], {
  allowUnknown: false,
  stripUnknown: true,
})
class ArticleDto {
  // ID is forbidden on CREATE, optional on UPDATE, required by default
  @JoiSchema(Joi.string().uuid().required())
  @JoiSchema(['CREATE'], Joi.forbidden())
  @JoiSchema(['UPDATE'], Joi.string().uuid().optional())
  id?: string;

  // Title always required on CREATE, optional on UPDATE
  @JoiSchema(Joi.string().min(5).max(100).required())
  @JoiSchema(['UPDATE'], Joi.string().min(5).max(100).optional())
  title!: string;

  // Content required on CREATE, optional on UPDATE
  @JoiSchema(Joi.string().min(10).required())
  @JoiSchema(['UPDATE'], Joi.string().min(10).optional())
  content!: string;

  // Published date is optional on both, but with different defaults
  @JoiSchema(['CREATE'], Joi.date().default(() => new Date()))
  @JoiSchema(['UPDATE'], Joi.date().optional())
  publishedAt?: Date;
}

// Get schema for CREATE operation
const createSchema = getClassSchema(ArticleDto, { group: 'CREATE' });

const createData = {
  title: 'New Article',
  content: 'This is a new article with sufficient content.',
};

const createResult = createSchema.validate(createData);
console.log('Create validation:', createResult.error ? 'Failed' : 'Success');
console.log('Create value:', createResult.value);
// Success, publishedAt will be set to current date

// Get schema for UPDATE operation
const updateSchema = getClassSchema(ArticleDto, { group: 'UPDATE' });

const updateData = {
  id: '123e4567-e89b-12d3-a456-426614174000',
  title: 'Updated Title',
};

const updateResult = updateSchema.validate(updateData);
console.log('Update validation:', updateResult.error ? 'Failed' : 'Success');
console.log('Update value:', updateResult.value);
// Success, only provided fields are validated

// Get default schema (no group specified)
const defaultSchema = getClassSchema(ArticleDto);

const defaultData = {
  id: '123e4567-e89b-12d3-a456-426614174000',
  title: 'Article Title',
  content: 'Article content here',
};

const defaultResult = defaultSchema.validate(defaultData);
console.log('Default validation:', defaultResult.error ? 'Failed' : 'Success');

```

--------------------------------

### Assigning Nested Object Schema for DEFAULT group with @JoiSchema

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

Illustrates assigning a nested object schema constructed from another class using `@JoiSchema(nestedType)` for the `DEFAULT` group. An optional callback allows customization of the nested schema.

```typescript
class AuthorDto {
  @JoiSchema(BookDto, schema => schema.required())
  firstBook!: BookDto;
}
```

--------------------------------

### Extend Schema with Alternative Class

Source: https://github.com/whefter/joi-class-decorators/blob/master/README.md

The @JoiSchemaExtends decorator specifies an alternative class constructor to be used for schema construction. This is useful when the prototype chain differs from the decorated class, such as with OmitType from @nestjs/graphql.

```typescript
import { JoiSchema, JoiSchemaExtends } from 'joi-class-decorators';
import * as Joi from 'joi';

// Example with direct inheritance
class BookDto {
  @JoiSchema(Joi.string().required())
  name!: string;
}

class ThrillerDto extends BookDto {
  @JoiSchema(Joi.number().optional())
  thrill?: number;
}

// Example using @JoiSchemaExtends with OmitType
// Assume Book and InputType are defined elsewhere
// @InputType()
// @JoiSchemaExtends(Book)
// export class CreateBookInput extends OmitType(Book, ['id'], InputType) {
//   @JoiSchema(Joi.string())
//   @Field()
//   extraArg?: string;
// }
```

--------------------------------

### Define Property Validation Rules with @JoiSchema Decorator

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

The `@JoiSchema` decorator is used on class properties to define their validation rules. It accepts a Joi schema, and optionally, functions to customize array and item schemas for array properties. It supports direct Joi schemas, nested class types, and arrays of nested types. Dependencies include 'joi-class-decorators' and 'joi'.

```typescript
import { JoiSchema, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

class AddressDto {
  @JoiSchema(Joi.string().required())
  street!: string;

  @JoiSchema(Joi.string().required())
  city!: string;

  @JoiSchema(Joi.string().pattern(/^\d{5}$/))
  zipCode!: string;
}

class PersonDto {
  // Simple Joi schema
  @JoiSchema(Joi.string().min(2).max(50).required())
  name!: string;

  // Nested object with customization
  @JoiSchema(AddressDto, schema => schema.required())
  address!: AddressDto;

  // Array of nested objects with array and item customization
  @JoiSchema(
    [AddressDto],
    arraySchema => arraySchema.min(1).max(3),
    itemSchema => itemSchema.optional()
  )
  previousAddresses!: AddressDto[];

  // Optional field with default
  @JoiSchema(Joi.number().min(0).max(120).default(0))
  age?: number;
}

const schema = getClassSchema(PersonDto);

const validPerson = {
  name: 'John Doe',
  address: {
    street: '123 Main St',
    city: 'Springfield',
    zipCode: '12345',
  },
  previousAddresses: [
    {
      street: '456 Oak Ave',
      city: 'Shelbyville',
      zipCode: '67890',
    },
  ],
  age: 30,
};

const { error, value } = schema.validate(validPerson);
console.log('Validation result:', error ? error.message : 'Success');
console.log('Validated value:', value);
```

--------------------------------

### Extend Schemas with @JoiSchemaExtends (TypeScript)

Source: https://context7.com/whefter/joi-class-decorators/llms.txt

The @JoiSchemaExtends decorator is used to specify an alternative parent class for Joi schema construction. This is essential when the actual prototype chain of a class differs from its logical inheritance, a common scenario with utility types like OmitType or PickType. It ensures that properties from the specified parent class are included in the generated schema. Dependencies include 'joi-class-decorators' and 'joi'.

```typescript
import { JoiSchema, JoiSchemaExtends, getClassSchema } from 'joi-class-decorators';
import * as Joi from 'joi';

class BaseEntityDto {
  @JoiSchema(Joi.string().uuid().required())
  id!: string;

  @JoiSchema(Joi.date().required())
  createdAt!: Date;

  @JoiSchema(Joi.date().required())
  updatedAt!: Date;
}

// Normal inheritance works as expected
class ProductDto extends BaseEntityDto {
  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.number().positive().required())
  price!: number;
}

// Simulating a case where prototype chain is broken
// (e.g., using NestJS OmitType or other transformations)
class ManuallyExtendedProduct {
  // Properties from BaseEntityDto need to be manually defined
  id!: string;
  createdAt!: Date;
  updatedAt!: Date;

  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.number().positive().required())
  price!: number;
}

// Without @JoiSchemaExtends, schema only includes name and price
const manualSchemaWithoutExtends = getClassSchema(ManuallyExtendedProduct);
console.log('Without extends - keys:', Object.keys(manualSchemaWithoutExtends.describe().keys));
// ['name', 'price']

// Using @JoiSchemaExtends to explicitly set parent class
@JoiSchemaExtends(BaseEntityDto)
class ProperlyExtendedProduct {
  id!: string;
  createdAt!: Date;
  updatedAt!: Date;

  @JoiSchema(Joi.string().required())
  name!: string;

  @JoiSchema(Joi.number().positive().required())
  price!: number;
}

const extendedSchema = getClassSchema(ProperlyExtendedProduct);
console.log('With extends - keys:', Object.keys(extendedSchema.describe().keys));
// ['id', 'createdAt', 'updatedAt', 'name', 'price']

// Validate with inherited fields
const validProduct = {
  id: '123e4567-e89b-12d3-a456-426614174000',
  createdAt: new Date(),
  updatedAt: new Date(),
  name: 'Laptop',
  price: 999.99,
};

const result = extendedSchema.validate(validProduct);
console.log('Validation:', result.error ? result.error.message : 'Success');
// Success

// Missing inherited field
const invalidProduct = {
  name: 'Laptop',
  price: 999.99,
};

const invalidResult = extendedSchema.validate(invalidProduct);
console.log('Invalid:', invalidResult.error?.message);
// Error: "id" is required

```
Tokens:
Raw