Types Reference

TypeScript type definitions.

Core Types

Entity

interface Entity {
  name: string
  config: EntityConfig
}

EntityConfig

interface EntityConfig {
  fields: Record<string, FieldDef>
  rules?: Record<Operation, RuleDef[]>
  ownerField?: string
  timestamps?: boolean
  namespace?: string
  actions?: Record<string, EntityAction>
  validators?: EntityValidator[]
}

FieldDef

interface FieldDef {
  type: FieldType
  optional?: boolean
  unique?: boolean
  default?: any | (() => any)
  validation?: FieldValidation[]
  transforms?: FieldTransform[]
  security?: FieldSecurity
  access?: {
    read?: FieldAccessPolicy
    write?: FieldAccessPolicy
  }
  relation?: RelationDef
}

FieldType

type FieldType =
  | "string"
  | "text"
  | "int"
  | "float"
  | "boolean"
  | "datetime"
  | "json"

RelationDef

interface RelationDef {
  type: "belongsTo" | "hasMany" | "hasOne"
  entity: () => Entity | EntityBuilder
  foreignKey?: string
  onDelete?: "cascade" | "setNull" | "restrict"
  remote?: string
}

Operation

type Operation = "create" | "read" | "update" | "delete" | "list"

Rule Types

RuleDef

type RuleDef = BuiltInRule | RuleFn

BuiltInRule

type BuiltInRule = "everyone" | "authenticated" | "owner" | "admin"

RuleFn

type RuleFn = (ctx: RuleContext) => boolean | Promise<boolean>

RuleContext

interface RuleContext {
  user: User | null
  record: Record<string, unknown> | null
  operation: Operation
  driver: Driver
}

User Types

User

interface User {
  id: string
  email?: string
  role?: string
  [key: string]: unknown
}

Request/Response Types

NevrRequest

interface NevrRequest {
  method: string
  path: string
  headers: Record<string, string>
  query: Record<string, any>
  body: any
  params: Record<string, string>
}

NevrResponse

interface NevrResponse {
  status: number
  body: any
  headers?: Record<string, string>
}

Query Types

QueryOptions

interface QueryOptions {
  where?: Where
  select?: Record<string, boolean>
  include?: IncludeConfig
  orderBy?: Record<string, SortDirection>
  take?: number
  skip?: number
}

Where

interface Where {
  [field: string]: WhereValue | WhereOperator
}

interface WhereOperator {
  equals?: any
  not?: any
  in?: any[]
  notIn?: any[]
  lt?: number
  lte?: number
  gt?: number
  gte?: number
  contains?: string
  startsWith?: string
  endsWith?: string
}

Driver Types

Driver

interface Driver {
  findOne<T>(entity: string, where: Where): Promise<T | null>
  findMany<T>(entity: string, options?: QueryOptions): Promise<T[]>
  create<T>(entity: string, data: any): Promise<T>
  update<T>(entity: string, where: Where, data: any): Promise<T>
  delete(entity: string, where: Where): Promise<void>
  count(entity: string, where?: Where): Promise<number>
  transaction?<T>(fn: (tx: Driver) => Promise<T>): Promise<T>
}

Plugin Types

Plugin

interface Plugin {
  name: string
  version?: string
  description?: string
  entities?: Entity[]
  routes?: Route[] | ((nevr: NevrInstance) => Route[])
  middleware?: Middleware[] | ((nevr: NevrInstance) => Middleware[])
  hooks?: Hooks
  fields?: Record<string, FieldDef>
  context?: any | ((nevr: NevrInstance) => any)
  setup?: (nevr: NevrInstance) => void | Promise<void>
}

Route

interface Route {
  method: string
  path: string
  handler: (ctx: RouteContext) => Promise<any>
  middleware?: Middleware[]
}

Middleware

interface Middleware {
  name: string
  fn: MiddlewareFn
}

type MiddlewareFn = (
  ctx: MiddlewareContext,
  next: () => Promise<NevrResponse>
) => Promise<NevrResponse>

Hooks

interface Hooks {
  beforeCreate?: HookFn
  afterCreate?: HookFn
  beforeUpdate?: HookFn
  afterUpdate?: HookFn
  beforeDelete?: HookFn
  afterDelete?: HookFn
  onError?: (error: Error, ctx: HookContext) => void
}

Action Types

EntityAction

interface EntityAction {
  name: string
  method: string
  onResource: boolean
  rules: RuleDef[]
  input?: Record<string, FieldDef>
  handler?: (ctx: ActionContext) => Promise<any>
  workflow?: WorkflowConfig
  meta?: Record<string, any>
}

ActionContext

interface ActionContext<TInput = any> {
  input: TInput
  resourceId?: string
  user: User | null
  driver: Driver
  resolve: <T>(serviceId: string) => T
  entity: Entity
  raw: any
}

Workflow Types

WorkflowStep

interface WorkflowStep<TData, TResult> {
  name: string
  execute: (ctx: WorkflowContext<TData>) => Promise<TResult>
  compensate?: (ctx: WorkflowContext<TData>, result: TResult) => Promise<void>
}

WorkflowContext

interface WorkflowContext<TData> {
  input: any
  data: TData
  stepResults: Record<string, any>
  driver: Driver
  resolve: <T>(serviceId: string) => T
}

WorkflowConfig

interface WorkflowConfig {
  steps: WorkflowStep<any, any>[]
  useTransaction?: boolean
  timeout?: number
  initialData?: any
}

Service Types

ServiceFactory

type ServiceFactory<T> = (ctx: ServiceContext) => T | Promise<T>

ServiceOptions

interface ServiceOptions {
  lifecycle?: "singleton" | "transient" | "scoped"
  tags?: string[]
}

ServiceContext

interface ServiceContext {
  resolve: <T>(serviceId: string) => T
  resolveAsync: <T>(serviceId: string) => Promise<T>
  driver: Driver
}

Validation Types

EntityValidator

interface EntityValidator {
  fn: EntityValidatorFn
  message: string
  operations?: ("create" | "update")[]
  fields?: string[]
}

EntityValidatorFn

type EntityValidatorFn = (
  data: Record<string, unknown>,
  ctx?: EntityValidatorContext
) => boolean | Promise<boolean>

Access Policy Types

FieldAccessPolicy

type FieldAccessPolicy = FieldAccessPolicyRule | FieldAccessPolicyFn

FieldAccessPolicyRule

type FieldAccessPolicyRule =
  | "everyone"
  | "authenticated"
  | "owner"
  | "admin"
  | "none"

FieldAccessPolicyFn

type FieldAccessPolicyFn = (
  ctx: FieldAccessContext
) => boolean | Promise<boolean>

See Also

• Type Safety
• Type Inference