March 2023 Summaries

WunderGraph is an open-source testing framework for GraphQL APIs that allows developers to test their APIs locally and in Continuous Integration (CI) environments. The framework provides a type-safe way to write tests, using TypeScript models generated from the GraphQL schema. It supports various use cases such as testing simple monolithic GraphQL APIs, integrating with Apollo Federation, testing the Hasura GraphQL Engine, joining data across multiple APIs, and adding authentication to existing GraphQL APIs. WunderGraph's code-generation approach makes it easy to spot errors early thanks to the type system and TypeScript compiler. The framework is designed to be compatible with various testing frameworks and can run in parallel, making it suitable for CI environments.

The text discusses the challenges of embedding SQL into GraphQL without sacrificing type safety. It presents a solution that uses AST transformations to create a unified GraphQL API for various dependencies, including databases and OpenAPI definitions. The goal is to enable users to embed SQL queries into GraphQL without compromising type safety. The solution involves rewriting GraphQL operations at the gateway level, using AST transformations to adapt downstream GraphQL schemas to upstream Prisma Query Engine schemas. This allows for dynamic rewriting of GraphQL operations in a performant and maintainable way, making it possible to build an API Gateway that can handle complex use cases involving SQL queries embedded into GraphQL.

The article highlights ten GraphQL developer tools that can make building APIs easier. These tools range from schema visualization to full-stack development, testing, and documentation. The tools include GraphiQL, WunderGraph, GraphQL Voyager, SpectaQL, GraphQL Network Inspector, Postman, graphqurl, Prisma, GraphQL Faker, and GraphQL Inspector. Each tool is designed to simplify the development process, enhance productivity, and improve code quality for GraphQL developers. By using these tools, developers can streamline their workflow, reduce the complexity of GraphQL, and deliver high-quality APIs in less time.

As a software engineer, the author reflects on their journey and how they've grown in skills and knowledge. They acknowledge that being surrounded by talented colleagues can be intimidating and lead to feelings of inadequacy, as they compare themselves to their peers' abilities. However, the author argues that this comparison is natural and necessary for growth, but it's essential to focus on individual progress rather than comparing oneself to others. By looking at their own past performance and setting goals to improve, the author finds motivation and inspiration in their colleagues, recognizing that they are building upon each other's strengths. Ultimately, the author believes that being part of a team where learning and growth are encouraged is crucial for success.

We're hiring! We're looking for Golang (Go) Developers, DevOps Engineers and Solution Architects who want to help us shape the future of Microservices, distributed systems, and APIs. By working at WunderGraph, you'll have the opportunity to build the next generation of API and Microservices infrastructure. Our customer base ranges from small startups to well-known enterprises, allowing you to not just have an impact at scale, but also to build a network of industry professionals. We're all aware of the problem of keeping your API documentation in sync with the implementation of your API. There are multiple ways to solve this problem, but so far all of them take a lot of time and effort to maintain. In this article, we'll show you a new approach to API development that will make your life 10x easier. Just write your API in TypeScript and let the compiler do the work for you. Don't ever worry about writing OpenAPI specifications again. The existing approaches to solving this problem are the schema-first approach and the code-first approach, both of which have their drawbacks. The schema-first approach is tedious and has limitations with tooling, while the code-first approach requires annotations that can be cumbersome to use. Enter TypeScript First API Development, a new approach where you write TypeScript API handlers, and the compiler generates an OpenAPI specification for you. This approach eliminates the need to write specifications, annotate your code, or generate server stubs. You simply create a new project, create a new API handler, save it, and the compiler generates an OpenAPI specification. The generated specification can be used to test your API with curl or any other client, and you can deploy it to the cloud in under a minute. WunderGraph uses esbuild to transpile the file and dynamically load it into its fastify server as an endpoint, while using TypeScript's compiler to introspect the type of the input object and the return type of the handler. This approach is a great middle ground for cases where you want to move fast, iterate quickly, but still have a specification that you can share with your team and clients.

We're building a serverless CI/CD system with Podman, Firecracker, fly.io Machines, and temporal.io. Our custom CI system is called "The Builder," which uses Podman for rootless docker builds, fly.io for Firecracker VMs (Fly Machines), and temporal.io for reliable orchestration of the build process. We're using a queueing system to start build jobs, but we've integrated temporal.io to orchestrate the build workflow, including monitoring progress and reporting status back to users in real-time through GraphQL subscriptions. Our caching strategy uses native overlayfs to improve build times from 1:15m to 0:55m for initial builds and 30s to 13s for subsequent builds. The final solution allows us to provide our users with the best possible user experience, deploying their WunderGraphs in 13 seconds with seamless integration into our overall architecture.

This tutorial aims to make learning TypeScript easy and accessible by providing a practical guide to building a full-stack Todo App with NextJS, WunderGraph, and Prisma. The author argues that many developers are intimidated by TypeScript due to misconceptions about its complexity and difficulty. Instead, the author suggests that TypeScript is a tool to improve JavaScript code, not a replacement for it. The tutorial covers how to use TypeScript to eliminate ambiguity in code, take advantage of type inference, and ensure end-to-end typesafety. It also demonstrates how WunderGraph can simplify the process of building APIs with Prisma, providing a powerful stack for developers to build robust and maintainable applications.

The author, a technical founder, shares a personal story of struggling to build a business while being obsessed with technology. They realized that building a solution was not enough and needed to focus on marketing and understanding customer needs. The author developed a framework for technical founders to build a business, including finding a problem that can be marketed, building a go-to-market strategy before code, and letting customers vote with their wallets. They emphasize the importance of listening to customers, asking questions, and finding the root cause of problems, rather than just adding features. The author's journey highlights the need for technical founders to balance their passion for technology with the business side of things.