Platformatic

Platformatic Gateway is an API gateway designed to aggregate and expose multiple services through a single API. It provides specialized support for:

• OpenAPI composition: Combining multiple OpenAPI specifications into a unified interface.
• GraphQL federation: Aggregating multiple GraphQL services into a single federated graph.

Watt is Platformatic's Node.js application server designed to centrally manage multiple Node.js applications. It provides a virtual mesh network and built-in integrations for:

• Logging: Fast logging via Pino.
• Monitoring: Integration with Prometheus.
• Observability: OpenTelemetry support.

Watt is compatible with popular web frameworks including Next.js, Astro, Express, and Fastify.

Watt provides several built-in capabilities for managing Node.js applications:

• Automatic multithreading: Optimizes resource allocation automatically via a single command.
• Comprehensive NFR management: Abstracts non-functional requirements (NFRs) such as logging, tracing, and resource allocation.
• Integrated OpenTelemetry tracing: Provides built-in OpenTelemetry support for real-time monitoring and performance insights.
• Unified logging with Pino: Uses Pino to ensure structured logging across all managed applications.

The @platformatic/runtime package allows you to start, control, and inspect Platformatic applications (including service, db, gateway, and runtime types) directly from Node.js code without using the CLI. This is ideal for writing tests, custom tooling, or embedding Platformatic within another application.

To use the API, you typically use create() to build a Runtime instance and then manage its lifecycle using methods like start() and close().

import { create } from '@platformatic/runtime'

const app = await create('path/to/platformatic.runtime.json')
const entrypointUrl = await app.start()

const res = await fetch(entrypointUrl)
console.log(await res.json())

await app.close()

Platformatic Runtime provides a unified environment to run multiple Platformatic microservices as a single monolithic deployment unit. This is ideal for streamlined development and monorepo management.

Key capabilities include:

• Programmatic start: Start the runtime within tests or other applications.
• Inter-application communication: Microservices can communicate via private message passing without binding to OS ports.
• Optimized execution: Running as a Runtime application enables specific compile and runtime optimizations for performance and resource management.

The Database Service provides several automated capabilities for rapid API development:

• Automatic API Generation: Generates complete REST/OpenAPI and GraphQL (including queries, mutations, and subscriptions) APIs from your schema.
• Interactive Documentation: Provides access to APIs via Scalar (for REST) and GraphiQL IDE (for GraphQL).
• Apollo Federation: Supports extending your API with federation.
• Type Safety: Automatically generates TypeScript definitions based on your SQL tables.
• Security: Supports JWT, Webhooks, HTTP Headers, and Role-Based Access Control (RBAC).
• Extensibility: Allows adding custom functionality via Fastify plugins or executing raw SQL queries.