Introduction

The schema package in Orionjs provides a powerful type-safe way to define data structures in your application. Schemas serve two main purposes:

1. Define data structures: Schemas describe the structure, types, and validation rules for your data models.
2. Automatic integration: Schemas automatically integrate with GraphQL for API generation and MongoDB for document validation.

​

Schema Definition

The modern approach to define schemas in Orionjs uses the schemaWithName function to create type-safe data structures.

​

Basic Usage

import {schemaWithName, InferSchemaType} from '@orion-js/schema'
import {typedId} from '@orion-js/mongodb'

export const UserSchema = schemaWithName('UserSchema', {
  _id: {type: typedId('user')},
  name: {type: String, label: 'Full Name'},
  email: {type: String, optional: true},
  createdAt: {type: Date}
})

// You can infer the TypeScript type from your schema
export type UserType = InferSchemaType<typeof UserSchema>

The schemaWithName() function creates an Orionjs schema with a name, which is required for GraphQL integration. Each property is defined with its type and options.

​

Integration with GraphQL

Schemas defined with schemaWithName are automatically converted to GraphQL types when used in your API, saving you from writing redundant type definitions.

import {createQuery, Resolvers} from '@orion-js/graphql'
import {UserSchema} from '../schemas/UserSchema'

@Resolvers()
export class UserResolvers {
  @Query()
  getUser = createQuery({
    params: {
      userId: {type: typedId('user')}
    }
    returns: UserSchema,
    resolve: async (params) => {
      // Your implementation here
      return user // Returns object that matches UserSchema
    }
  })
}

When the above resolver is registered, Orionjs automatically:

• Creates a GraphQL type for UserSchema
• Sets up the appropriate field types based on your schema definition
• Handles type conversions between your application and GraphQL

​

Integration with MongoDB

When using schemas with MongoDB collections, Orionjs automatically validates documents before insertion or updates:

import {createCollection} from '@orion-js/mongodb'
import {UserSchema} from '../schemas/UserSchema'

const Users = createCollection({
  name: 'users',
  schema: UserSchema
})

// Document will be automatically validated against UserSchema before insertion
await Users.insertOne({
  name: 'John Doe',
  email: 'john@example.com',
  createdAt: new Date()
})

The validation ensures:

• All required fields are present
• Types match those defined in the schema
• Any custom validation rules are satisfied

​

Next Steps

Explore more about schemas:

• Schema Types - Learn about all available data types for schema fields
• Property Options - Learn about all available options for schema properties
• Schema Validation - Understand how validation works and how to create custom validators
• Advanced Schema Usage - Discover nested schemas, arrays, and schema inheritance
• Schema Serialization - Learn how schemas are serialized for client-side validation
• GraphQL Integration - Understand how schemas integrate with GraphQL