> ## Documentation Index
> Fetch the complete documentation index at: https://www.orionjs.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Property Options

> Options available for schema properties

When defining properties in a schema, you can configure various options to specify validation rules, labels, and more.

## Basic Property Definition

The simplest way to define a property is to specify its type:

```typescript theme={null}
import {schemaWithName, InferSchemaType} from '@orion-js/schema'

export const ProductSchema = schemaWithName('ProductSchema', {
  _id: {type: String},
  name: {type: String},
  price: {type: Number}
})

export type ProductType = InferSchemaType<typeof ProductSchema>
```

In this example, Orionjs applies appropriate validation based on the specified types.

## Available Options

Each property in the schema can have the following options:

### `label`

A human-readable label for the field, useful for UI generation and error messages.

```typescript theme={null}
name: {
  type: String,
  label: 'Product Name'
}
```

### `description`

Provides a description for the field, which will be included in GraphQL schema generation.

```typescript theme={null}
price: {
  type: Number,
  label: 'Product Price',
  description: 'The price in USD before tax'
}
```

### `optional`

By default, all fields are required. Set `optional: true` to make a field optional.

```typescript theme={null}
description: {
  type: String,
  optional: true
}
```

### `private`

Fields marked as `private` will not be exposed in the GraphQL API.

```typescript theme={null}
internalNotes: {
  type: String,
  private: true
}
```

### `min` / `max`

These options provide validation constraints based on the field type:

* For `number`: Minimum and maximum numeric values
* For `string`: Minimum and maximum string length
* For `Date`: Minimum and maximum date

```typescript theme={null}
price: {
  type: Number,
  min: 0,
  max: 1000
},

name: {
  type: String,
  min: 3,
  max: 50
},

releaseDate: {
  type: Date,
  min: new Date('2023-01-01')
}
```

### `allowedValues`

Restricts the field to a set of allowed values.

```typescript theme={null}
size: {
  type: String,
  allowedValues: ['small', 'medium', 'large']
}
```

### `defaultValue`

Sets a default value for the field if none is provided.

```typescript theme={null}
status: {
  type: String,
  defaultValue: 'draft'
},

createdAt: {
  type: Date,
  defaultValue: () => new Date()
}
```

## Custom Validation

You can create custom validation logic using the `validate` option:

```typescript theme={null}
slug: {
  type: String,
  validate: (value) => {
    if (!/^[a-zA-Z0-9-]+$/.test(value)) {
      return 'slug-format-invalid'
    }
  }
}
```

The validate function:

* Receives the field value as its first parameter
* Should return an error message string if validation fails
* Should return nothing (undefined) if validation passes
* Can be an async function

## Custom Data Transformation

The `clean` option allows you to transform data before validation:

```typescript theme={null}
email: {
  type: String,
  clean: (value) => value.trim().toLowerCase()
}
```

The clean function:

* Receives the field value as its first parameter
* Should return the transformed value
* Can be an async function

## Working with Arrays

To define an array of values, use the array syntax in the type field:

```typescript theme={null}
tags: {
  type: [String]
},

categories: {
  type: [String],
  min: 1, // At least one item required
  maxLength: 10 // Maximum 10 items allowed
}
```

For arrays of complex types, you can reference other schemas:

```typescript theme={null}
import {schemaWithName, InferSchemaType} from '@orion-js/schema'
import {ProductVariantSchema} from './ProductVariantSchema'

export const ProductSchema = schemaWithName('ProductSchema', {
  // Other fields...
  
  variants: {
    type: [ProductVariantSchema]
  }
})

export type ProductType = InferSchemaType<typeof ProductSchema>
```

## Nested Schemas

You can nest schemas inside other schemas:

```typescript theme={null}
import {schemaWithName, InferSchemaType} from '@orion-js/schema'

export const AddressSchema = schemaWithName('AddressSchema', {
  street: {type: String},
  city: {type: String},
  zipCode: {type: String}
})

export type AddressType = InferSchemaType<typeof AddressSchema>

export const UserSchema = schemaWithName('UserSchema', {
  name: {type: String},
  email: {type: String},
  
  // Nested schema
  address: {type: AddressSchema}
})

export type UserType = InferSchemaType<typeof UserSchema>
```