Pylon

Mit Pylon lässt sich eine GraphQL-API einfach und unkompliziert erstellen. Pylon ist ein Backend-Framework auf Basis von Hono und ermöglicht die Code-First-Entwicklung von GraphQL-APIs.

Das GraphQL-Schema wird in Echtzeit aus deinen TypeScript-Definitionen generiert, sodass du dich ganz auf deine Dienstlogik konzentrieren kannst. Dieser Ansatz beschleunigt die Entwicklung deutlich, verbessert die Typsicherheit und reduziert Fehler.

Inkompatible Änderungen im Code werden sofort in deiner API sichtbar, sodass du unmittelbar siehst, wie sie deren Funktionalität beeinflussen.

Weitere Informationen findest du auf der Website von Pylon.

Einen neuen Pylon-Dienst einrichten

Mit dem Befehl npm create pylon kannst du einen neuen Dienst erstellen. Er legt ein neues Pylon-Projekt mit einer grundlegenden Projektstruktur und Konfiguration an. Während der Einrichtung kannst du deine bevorzugte Laufzeitumgebung auswählen, zum Beispiel Bun, Node.js oder Cloudflare Workers.

Diese Anleitung verwendet die Bun-Laufzeitumgebung.

Ein neues Projekt erstellen

Führe folgenden Befehl aus, um ein neues Pylon-Projekt zu erstellen:

npm create pylon my-pylon@latest

Dies erstellt ein neues Verzeichnis namens my-pylon mit einer grundlegenden Pylon-Projektstruktur.

Projektstruktur

Pylon-Projekte sind wie folgt aufgebaut:

my-pylon/
├── .pylon/
├── src/
│   ├── index.ts
├── package.json
├── tsconfig.json

• .pylon/: Enthält den Produktionsbuild deines Projekts.
• src/: Enthält den Quellcode deines Projekts.
• src/index.ts: Der Einstiegspunkt deines Pylon-Dienstes.
• package.json: Die npm-Paketkonfigurationsdatei.
• tsconfig.json: Die TypeScript-Konfigurationsdatei.

Einfaches Beispiel

Hier ist ein Beispiel für einen einfachen Pylon-Dienst:

import { app } from '@getcronit/pylon'

export const graphql = {
  Query: {
    sum: (a: number, b: number) => a + b,
  },
  Mutation: {
    divide: (a: number, b: number) => a / b,
  },
}

export default app

Die API absichern

Pylon ist in ZITADEL integriert, eine cloudnative Lösung für Identitäts- und Zugriffsverwaltung, die sichere Authentifizierung und Autorisierung für deine APIs bereitstellt. Du kannst deine Pylon-API einfach absichern, indem du den Schritten in der ZITADEL-Dokumentation folgst.

Eine komplexere API erstellen

Mithilfe der Schemaerzeugung in Echtzeit kannst du mit Pylon komplexere APIs erstellen. Informationen zu unterstützten TypeScript-Typen und zur Definition deiner API findest du in der Pylon-Dokumentation.

Dieses Beispiel zeigt, wie du komplexe Typen und Dienste in Pylon definierst. Mit TypeScript-Klassen und -Methoden kannst du leistungsfähige APIs erstellen, die mit Datenbanken, externen Diensten und anderen Ressourcen interagieren.

import { app } from '@getcronit/pylon'

class Post {
  id: string
  title: string

  constructor(id: string, title: string) {
    this.id = id
    this.title = title
  }
}

class User {
  id: string
  name: string

  constructor(id: string, name: string) {
    this.id = id
    this.name = name
  }

  static async getById(id: string): Promise<User> {
    // Fetch user data from the database
    return new User(id, 'John Doe')
  }

  async posts(): Promise<Post[]> {
    // Fetch posts for this user from the database
    return [new Post('1', 'Hello, world!')]
  }

  async $createPost(title: string, content: string): Promise<Post> {
    // Create a new post for this user in the database
    return new Post('2', title)
  }
}

export const graphql = {
  Query: {
    user: User.getById,
  },
  Mutation: {
    createPost: (userId: string, title: string, content: string) => {
      const user = User.getById(userId)
      return user.$createPost(title, content)
    },
  },
}

export default app

Die API aufrufen

Die Pylon-API lässt sich mit jeder GraphQL-Clientbibliothek aufrufen. Für die Entwicklung empfehlen wir den Pylon Playground, eine webbasierte GraphQL-IDE, mit der du in Echtzeit mit deiner API interagieren kannst.

1. Starte den Pylon-Server, indem du im Projektverzeichnis bun run dev ausführst.
2. Öffne den Pylon Playground im Browser unter http://localhost:3000/graphql.
3. Schreibe deine GraphQL-Abfrage oder -Mutation im linken Bereich.

Auf den Hono-Kontext zugreifen

Mit der Funktion getContext kannst du überall in deinem Code auf den Hono-Kontext zugreifen. Sie gibt das aktuelle Kontextobjekt zurück, das Informationen über die Anfrage, die Antwort und andere kontextspezifische Daten enthält.

import { app, getContext } from '@getcronit/pylon'

export const graphql = {
  Query: {
    hello: () => {
      const context = getContext()
      return `Hello, ${context.req.headers.get('user-agent')}`
    },
  },
}

export default app

Weitere Informationen zum Hono-Kontextobjekt und seinen Eigenschaften findest du in der Hono-Dokumentation und der Pylon-Dokumentation.

Welche Rolle spielt Hono?

Pylon basiert auf Hono, einem leichtgewichtigen Webframework zur Erstellung von Webanwendungen und APIs. Hono stellt die Kernfunktionen für die Verarbeitung von HTTP-Anfragen und -Antworten bereit. Pylon erweitert diese Funktionen um die Entwicklung von GraphQL-APIs.

Zusätzlich zu GraphQL bietet Pylon Zugriff auf die zugrunde liegende Hono-Anwendungsinstanz, um eigene Routen und Middleware hinzuzufügen. So kannst du komplexere APIs und Dienste erstellen, die den gesamten Funktionsumfang von Hono nutzen.

import { app } from '@getcronit/pylon'

export const graphql = {
  Query: {
    sum: (a: number, b: number) => a + b,
  },
  Mutation: {
    divide: (a: number, b: number) => a / b,
  },
}

// Add a custom route to the Pylon app
app.get('/hello', (ctx, next) => {
  return new Response('Hello, world!')
})

Fazit

Pylon ist ein leistungsfähiges Webframework, das die Entwicklung von GraphQL-APIs vereinfacht. Es generiert Schemas in Echtzeit aus TypeScript-Typdefinitionen, verbessert damit die Typsicherheit und reduziert Fehler. Mit Pylon kannst du schnell sichere, skalierbare APIs erstellen, die deinen geschäftlichen Anforderungen entsprechen. Durch die Integration mit Hono kannst du alle Hono-Funktionen nutzen und dich gleichzeitig auf die Entwicklung von GraphQL-APIs konzentrieren.

Weitere Informationen zu Pylon findest du in der offiziellen Dokumentation.

Siehe auch

• Pylon
• Pylon-Dokumentation
• Hono-Dokumentation
• ZITADEL-Dokumentation