Skip to main content

Features overview

Suggestions

We're taking any and all kinds of feature requests, suggestions and recommendations. Please direct them kindly to the github ticket or better yet discussion boards. Thank you!

Typegate

GraphQL API

Expose select functions in your graph through a GraphQL API. These root-functions will serve as the entry point to your graph for any incoming request. The typegraph model is a great fit for GraphQL semantics and this is the best supported way to consume typegraphs.

GraphQL Subscriptions

Get real-time data to clients.

REST API

You can expose select root functions through a simple REST API. This is handy to serve endpoints for clients that are not GraphQl capable, even though it hampers access to some typegraph features. Inputs will be sourced from either HTTP bodies or search parameters according to HTTP verb.

gRPC API

Support to expose the typegraph through a gRPC API.

Cron triggers

Execute functions at certain time intervals. Useful for cleanup jobs.

Rate-limiting

Rate-limit parts of your graph to minimize abuse. The limits can be configured granularly for each function and for custom time windows. Use custom request identifiers, in addition to ip addresses, to track limits counters.

CORS

Specify cross-origin request rules to control which domains can access your API from within a browser. Prevents abuse from websites trying to use your API without permission.

Single-node

The typegate can be run as a single node mode for simple deployments and using the filesystem as its artifact store. Useful for local development and testing.

Multi-node

Deploy multiple instances of the typegate to distribute loads across machines and scale horizontally. You'll only need a Redis compatible key-value cache, an S3 compatible object store, and your favorite load-balancer in front of the instances to get it going. This mode is recommended for production deployments even if only a single node is used.

Typegraph

Loading...

Scalar types

The primitive types integer, float, boolean, string and file. All data that flows through a typegraph reduces down to these types.

Type constraints

Declare types in your graph that are subset of primitives like string and integers by using regular expressions or min/max limits. Useful to validate incoming data even more and distribute invariants through your app.

Composite types

Support for struct, list, union, either and optional types. These allow you to represent types equivalent to most modern type systems.

Injections

Injections resolve part of your graph inline instead of from functions or provide defaults for incoming request data. This can be used to set static values or source them from the context, other parts of the graph...etc.

Functions

Nodes in your typegraph that represent data to be resolved after running some logic on a Runtime.

Function chaining

Compose functions together by feeding the output of one as the input of another. Encourages code reuse by allowing one to extract common middleware logic from each function, all within the typegraph layer.

`reduce`

reduce is useful to transform function input types so that only certain struct fields are used, discarding the others. Required fields can be hidden from the user and can instead be injected from the request's context or a static default. This is useful for remixing generated or core domain types to more targeted forms appropriate for a function.

`apply`

apply allows the flattening of deeply nested function input types to something friendlier. Injection can also be used to substitute required fields in the original type from another source.

Imports

Imports will allow graphs to include nodes from other API descriptions like GraphQL, OpenAPI, gRPC and database schemas. These APIs can then be consumed in a typesafe manner through the GraphQL and Http runtimes.

Secrets

First-class support for secrets to ease runtime substitution of sensetive values. API keys or dynamic values only discovrable after deployment, this is how you get them into your app.

Runtimes

Deno runtime

Write functions that execute pieces of TypeScript code on a Deno worker. Includes easy access to ESM and libraries through standard Deno features.

Loading...

Python runtime

Implement functions that execute python functions in code snippets or on disk modules.

from typegraph import typegraph, Policy, t, Graph
from typegraph.runtimes.deno import PythonRuntime

@typegraph() def example_python(g: Graph): public = Policy.public() python = PythonRuntime()

    g.expose(
        public,
        add=t.func(
            t.struct({"a": t.integer(), "b": t.integer()}),
            t.integer(),
            # we can provide the code inline using lambdas
            python.from_lambda(lambda x: x["a"] + x["b"]),
        ),
        sayHello=python.import_(
            t.struct({"name": t.string()}),
            t.string(),
            # point to pythoin a file on disc
            module="hello.py",
            name="say_hello"
        ),
    )

} 

S3 runtime

Store large blobs in S3 compatible object stores. This includes support for GraphQL file uploads and presigned URLs making working with images and large uploads a breeze.

Temporal runtime

Kick off and query Temporal workflows from a typegraph. Temporal is a durable execution engine that can be used to implement long-running, failure-resistant business processes.

Wasm runtime

Make functions that use WASM components to implement their logic. Write core-wasm or wasi 0.2 based wasm components in languages like Rust, Python and Javascript to power all your custom functions.

GraphQL runtime

Include external GraphQL APIs as part of your typegraph. This runtime provides functions that resolve the data by querying an external GraphQL API.

Http runtime

Include external Http APIs as part of your typegraph. Source the data for your graph using external HTTP requests.

Random runtime

Functions to generate random data based on your types. Useful for quickly throwing together an API and testing.

gRPC runtime

Include external gRPC APIs as part of your typegraph.

Prisma

Access a myriad of databases directly from your typegraph. Run queries, mange it's schema, the full orm featureset.

Loading...

Relational schemas

Use the types in your graph to declare and manage relational schemas to be used on your databse. This means support for primary keys, unique constraints, one-to-one, one-to-many, many-to-many relationships...etc.

CRUD queries

Easily generate functions for common create, update, read and delete queries. Includes nested filtering and aggregration paramters for efficent and targeted requests.

Raw queries

Drop down to raw SQL queries for cases not covered by the CRUD generators. Useful to access unique features native to your database or craft extra efficient queries.

PostgreSQL support

Support for PostgreSQL, a modern and established DBMS.

Beta databases

MySQL, MariaDB, AWS Aurora, AWS Aurora Serverless, Microsoft SQL Server, Azure SQL, MongoDB, CockroachDB.

Authentication

Policy-based access control

Policies are simple functions that take the request as input and return values to signal whether it's allowed/denied access. They can be attached to any function in the graph and are evaluated right before the request triggers one. They compose well and are the primary authorization primitive available to typegraphs.

Loading...

Basic authentication

Requests can authenticate themselves using Basic HTTP headers. Simple but useful for getting started or protecting admin only requests.

Loading...

JWT authentication

Json Web Tokens can be used to attach more authentication and context information to requests. The data in the tokens can then be used by policies to make authorization decisions.

Loading...

OAuth2 authorization

Use the Oauth2 scheme to implement social-sign in from common identity providers like Github, Meta and Google.

Loading...

Tooling

Meta CLI

Full-featured CLI to aid development and manage typegraph deployments on the typegate. Supports watch mode to aid rapid-iteration, including support for interactive database migration management. Bundles the typegate within it making the CLI all one needs to get started. (And a text editor, of course.)

❯ meta --help                                                                                    at 02:03:36
Declarative API development platform. Build backend components with WASM/Typescript/Python, no matter where and how your (legacy) systems are.

Usage: meta [OPTIONS] [COMMAND]

Commands: serialize Serialize the typegraphs defined in the specified python file(s) into JSON dev Push typegraph(s) with development mode features enabled deploy Push typegraph(s) to typegate undeploy Undeploy typegraph(s) from typegate gen Access metagen generators upgrade Upgrade completion Generate shell completion doctor Troubleshoot the installation new Create a new Metatype project typegate Access a minimal deno CLI help Print this message or the help of the given subcommand(s)

Options: --version -v, --verbose... Increase logging verbosity -q, --quiet... Decrease logging verbosity -C, --dir <DIR> [default: .] --config <CONFIG> path to the config file -h, --help Print help  

Metagen

Code generation suite that supports Rust, Python and Typescript. Generate types from your graph and other helper functions for authoring custom functions for the Wasm, Python and Deno runtimes respectively. Can be accessed through the CLI under the gen subcommand or through the different SDKs.

Meta LSP

Extension for your IDE to help authoring of typegraphs. Supports VSCode as of now.

Docker images

The typegate is primarily distributed as a docker image for deployment as a container. All the available configuration environment variables can be found here.

Helm charts

Helm charts are published to ease installation of a typegate deployment in your Kubernetes cluster.

 docker run --rm --pull always \ -p 7890:7890 \ -e TG_SECRET=$(openssl rand -base64 64 | tr -d '\n') \ -e TG_ADMIN_PASSWORD="password" \ ghcr.io/metatypedev/typegate:latest

SDKs

Typescript SDK

Use typescript to author typegraphs and access other SDK tooling. Supports Node and compatible runtimes like Deno and Bun.

Python SDK

Use Python to author typegraphs and access other SDK tooling.

Dart SDK

Use Dart to author typegraphs and access other SDK tooling.

Deployments

Programmatically upload your typegraphs to the typegate from within the SDK. Useful for writing tests or building on top of the Metatype platform.

Migrations

Programmaticaly manage necessary migrations returned by the Prisma runtime. Useful for writing tests or building on top of the Metatype platform.

Codegen

Access metagen through the SDK directly to generate type declarations and other helpful code. Useful for testing and to build custom workflows/tooling.