Dart Frog | Blog

Dart Frog and GraphQL Basics

Sun, 22 Feb 2026 00:00:00 GMT

While Dart Frog doesn’t provide an “out of the box” way to implement a GraphQL schema, in this blog we’ll walk through how to build a GraphQL server powered by Dart Frog with just a few additional Dart packages.

Getting Started

To get started, simply create a dart frog server as you would normally would using the dart_frog create command.

Once you have a project, add two dependencies from pub.dev.

dart pub add graphql_schema2
dart pub add graphql_server2

The graphql_schema2 package will be used to create the schema and graphql_server2 will transform the schema into a server, or in our case, a route in our Dart Frog server.

Next, we need to create the schema. Consider this hypothetical API:

The Cool Games API is a GraphQL server that provides a way to query cool games for cool people to download.

Our example schema is composed of an entity called game, that has three fields, id, name, downloadLink.

We can model that entity with the following plain Dart class:

class Game {
  const Game({
    required this.id,
    required this.name,
    required this.downloadLink,
  });

  final int id;
  final String name;
  final String downloadLink;
}

We can then describe that model in a GraphQL schema:

GraphQLObjectType createGameSchema(
  RequestContext context,
) {
  final gameType = objectType(
    'game',
    fields: [
      field('id', graphQLInt, resolve: (obj, args) => (obj as Game).id),
      field(
        'name',
        graphQLString,
        resolve: (obj, args) => (obj as Game).name,
      ),
      field(
        'downloadLink',
        graphQLString,
        resolve: (obj, args) => (obj as Game).downloadLink,
      ),
    ],
  );
  return gameType;
}

Next, we need to create a full schema that includes the queries we will expose from our server.

Let’s write a repository that we can use to query games:

class GameRepository {
  Future<List<Game>> fetchGames() async => _games;

  Future<Game?> fetchGameById(int id) async {
    final result = _games.where((game) => game.id == id);
    if (result.isEmpty) return null;
    return result.first;
  }
}

const _games = [
  Game(
    id: 1,
    name: 'Mine Cat Digger',
    downloadLink: 'https://g4me.info/catdigger',
  ),
  Game(
    id: 2,
    name: 'Pixelado',
    downloadLink: 'https://g4me.info/pixelado',
  ),
];

The code to create the queries would look something like:

GraphQL createGraphQL(RequestContext context) {
  final gameSchema = createGameSchema(context);

  final schema = graphQLSchema(
    queryType: objectType(
      'Query',
      fields: [
        field(
          'games',
          listOf(gameSchema),
          resolve: (_, __) =>
            context.read<GameRepository>()
              .fetchGames(),
        ),
        field(
          'findGame',
          gameSchema,
          inputs: [
            GraphQLFieldInput('id', graphQLInt),
          ],
          resolve: (_, args) =>
            context.read<GameRepository>().fetchGameById(
              args['id'] as int,
            ),
        ),
      ],
    ),
  );

  return GraphQL(schema);
}

Finally, we need to expose this via a route. Let’s create a graphql.dart route in our server with the following code:

Future<Response> onRequest(RequestContext context) async {
  if (context.request.method != HttpMethod.post) {
    return Response(statusCode: 405);
  }

  final queryJson = await context.request.json();

  if (queryJson is! Map<String, dynamic> || !queryJson.containsKey('query')) {
    return Response(statusCode: 400, body: 'Missing "query" field in JSON.');
  }

  final query = queryJson['query'] as String;
  final variables = queryJson['variables'] as Map<String, dynamic>?;

  final graphQL = createGraphQL(context);
  final data = await graphQL.parseAndExecute(
    query,
    variableValues: variables ?? {},
  );

  return Response.json(body: {'data': data as Map<String, dynamic>});
}

And that’s all there is to it! You can now query your server for games using GraphQL:

$ curl http://localhost:8080/graphql \
  -H "Content-Type: application/json" \
  -X POST \
  -d '{ "query": " query AllGames() { games() { id name downloadLink } } "}'

The above query should produce the following response:

{
  "data": {
    "games": [
      {
        "id": "1",
        "name": "Mine Cat Digger",
        "downloadLink": "https://g4me.info/catdigger"
      },
      {
        "id": "2",
        "name": "Pixelado",
        "downloadLink": "https://g4me.info/pixelado"
      }
    ]
  }
}

Summary

In this blog we walked through how to set up the base schema and expose queries. To see a real working example, check out the full source and feel free to clone and run the example locally.

Fall 2025 Recap

Mon, 29 Sep 2025 00:00:00 GMT

We can’t believe it’s been two months since Dart Frog moved to a new organization!

Here’s a quick recap of what the team has been up to:

Migrated and redesigned the Dart Frog Website
Migrated the VSCode Extension
Released package:dart_frog_lint
Added support for Pub Workspaces
Contributed benchmarks to TechEmpower Framework Benchmarks
Created a new Discord Server
Published 14 package releases to pub.dev
Closed over 20 pull requests

🌐 Meet dart-frog.dev

One of the first things we worked on was migrating the official website and documentation to an independent domain. The site is now powered by Starlight and includes a refreshed design, full text search, updated documentation, a new blog with an RSS Feed, and more!

📦 New Package: `dart_frog_lint`

While updating documentation and examples, we realized we could provide a much better developer experience configuring lint rules.

We released the dart_frog_lint package to standardize lint rules across all Dart Frog projects.

New projects created via dart_frog create now ship with dart_frog_lint automatically.

Existing projects can add dart_frog_lint by following these steps:

Install dart_frog_lint as a dev dependency

dart pub add --dev dart_frog_lint

Use the recommended rules in the analysis_options.yaml

include: package:dart_frog_lint/recommended.yaml

With over 8,400 downloads in the last 30 days, it’s awesome to see the impact dart_frog_lint is having already within the community!

🎯 Pub Workspaces Support

A highly-anticipated feature was adding support for pub workspaces. Since Dart 3.6.0, pub supports organizing repositories into a workspace using a single shared resolution for all packages. Using workspaces for large repositories reduces the amount of memory required for analysis, hence improving performance.

As of Dart Frog CLI v1.2.9, Dart Frog fully supports pub workspaces! Dart Frog workspaces is already being used in production at Shorebird to serve millions of patches all over the world. If your team is using pub workspaces with Dart Frog, let us know — we’d love to hear about your experience!

🏎️ New Benchmarks

As part of burning down a variety of longstanding issues, we added basic performance benchmarks to TechEmpower Framework Benchmarks for both Shelf and Dart Frog. This is just the first many benchmarks we plan to add in order to both measure and improve the performance of Dart Frog servers.

🧑‍💻 Updated VSCode Extension

As part of the migration to a new GitHub organization, we also had to migrate the Dart Frog VSCode extension. Since the VSCode marketplace does not support transferring an existing extension to a different publisher, we have published a new Dart Frog VSCode Extension. We are working on deprecating the old extension in order to provide a smooth, seamless transition so stay tuned for additional updates over the coming days.

💬 Dedicated Discord Server

Finally, Dart Frog now has an official Discord Server! You can join the community, get support from the team, show off you work and more! We’re currently at 99 active members so join us and help us continue to grow the community!

👀 What’s Next

While we’ve gotten a lot done over the last two months, there’s still much to look forward to!

Next, we’ll focus on burning down the existing backlog of issues which includes tackling some highly requested features such as:

If there’s anything you feel is missing or can be improved, please let us know.

None of this would be possible without the community so thanks everyone for the support and we’ll see you in the next update! ✌️

The Future of Dart Frog

Fri, 01 Aug 2025 00:00:00 GMT

We’re very grateful for how far Dart Frog has come while under the VeryGoodOpenSource organization and incredibly thankful to Very Good Ventures for investing in Dart Frog and taking it from idea to reality.

After many discussions with Very Good Ventures, Dart Frog maintainers, and the community at large, Dart Frog has moved to a new GitHub organization! We feel confident that this move will empower the community to take Dart Frog to the next level.

As Dart Frog moves to an independent organization, we’re opening the doors for a broader range of developers to get involved and help shape the project’s direction. Rest assured that the dart_frog ecosystem isn’t going anywhere — teams can confidently continue building their backends without any interruptions or migrations.

About the organization

The organization will consist of the same group of core maintainers who have worked on Dart Frog since its inception in April 2022: Alejandro Santiago, Erick Zanardo, Felix Angelov, Jochum van der Ploeg, Marcos Sevilla, and Renan Araujo.

This group may change over time based on contributions, availability, and other factors. We plan to take inspiration from other successful open source organizations like Flame that provide a nice blueprint to follow.

What’s the impact?

The good news is we’ve worked really hard to make sure nothing changes for you as a developer! You can continue to use the same dart_frog package and ecosystem. We aim to release more frequently so stay tuned for new features, bug fixes, and more.

What’s next?

Speaking of what’s next, here’s a high level overview of what we have planned for the rest of the year. We (the core maintainers) will be meeting in the near future to do a more in-depth planning session and will update the public roadmap as part of that meeting. Some of the work we have planned includes:

Maintenance
- Publish a new release to distribute all existing bug fixes
- Automate releasing to pub.dev and the VSCode marketplace
- Triage and burn down the existing backlog of issues
- Review and burn down open pull requests
Features
- Add support for Dart workspaces
- Add Dart API client generation
- Add Dart API documentation generation
- Prioritize and begin work on new features identified during our planning
Ecosystem
- Formally meet for the first time and do a planning session
- Invest in growing and moderating the new Dart Frog Discord Server
- Establish a larger social presence & plan events for the community

How can you help?

💬 Come join the community on Discord.
🙋 Open an issue if you encounter a bug or would like a new feature added.
👀 Stay tuned for more updates in the near future including new feature releases, documentation improvements, community events, and more!

Thanks for all your support 💙

We’re more excited than ever for the future of Dart Frog 🎯 🐸