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: