Schema

Your project's schema defines your:

• Flags, i.e. their names and types

• Input types for targeting logic, e.g. User, Organization, Environment

• Event types, e.g. SignUpEvent, PurchaseEvent, etc, with payload fields, e.g. revenueAmount

You can build your schema visually in the Schema view or write it in GraphQL. For example, the following schema defines:

• A Boolean feature flag called showNewEditor

• Input types called User and Organization to use in flag targeting logic

• An event type called PurchaseEvent that contains the context in its payload

• A Void event trigger flag called purchase which we can use to log the PurchaseEvent

type Source {
  root(context: Context!): Root!
}

input Context {
  environment: Environment!
  user: User!
  organization: Organization!
}

enum Environment { development, test, production }

input User {
  id: String!
  name: String!
  email: String!
}

input Organization {
  id: String!
  name: String!
  plan: Plan!
}

enum Plan { free, pro, enterprise }

input PurchaseEvent @event  {
  context: Context!
}

type Root {
  showNewEditor: Boolean!
  purchase: Void!
}

Complex input types

You can define arbitrarily complex types for your inputs. For example, the User input type can have a field with a list of roles:

input User {
  id: String!
  name: String!
  email: String!
  roles: [Role!]!
}

enum Role { viewer, editor, admin }

Complex flag types

In addition to simple Boolean feature flags, you can have flags with String, Int and Float types, and custom enum, object and list types. For example, you can define the following flags on the Root type:

type Root {
  showNewEditor: Boolean!
  purchase: Void!
  navBarPosition: Position!
  maxTeamMembers: Int!
  callToActionText: String!
  onboardingGuides: [OnboardingGuide!]!
}

enum Position { LEFT, RIGHT, TOP, BOTTOM }

type OnboardingGuide {
  id: String!
  title: String!
  bodyMarkdown: String!
  checklist: [String!]!
  difficultyLevel: DifficultyLevel!
  expectedDurationSeconds: Int!
}

enum DifficultyLevel { BEGINNER, INTERMEDIATE, ADVANCED }

Flag-specific targeting attributes

Instead of adding new input types and targeting attributes to the top-level Context, you can add them directly to specific flags.

This is useful if a targeting attribute is only relevant to a specific flag, as it avoids polluting the top-level scope with it, and ensures it can't be accidentally used in the targeting logic of other flags.

It also lets you pass different attribute values to a flag in the same browser session. So you can have flags that depend on the session state like user input, selected options, the current view, etc.

For example, you can define a priceId flag that depends on the provided usageAmount:

type Root {
  priceId(usageAmount: Int!): String!
}

Flag lifecycle

You can manage flag lifecycle by marking flags as deprecated in your schema from the Hypertune UI or in GraphQL with the @deprecated directive.

Schema migrations

To make large changes to your schema, e.g. sweeping refactors, you can use Git-style branches and pull requests to easily migrate your schema.