Cosmo

https://github.com/wundergraph/cosmo
Admin
WunderGraph Cosmo is a comprehensive Lifecycle API Management platform for Federated GraphQL,...
Tokens:92,570
Snippets:861
Trust Score:9.8
License:Apache-2.0
Update:9 months ago
Show doc for...
Tokens:
Raw
### Install and Run Admission Server (Bash)

Source: https://github.com/wundergraph/cosmo/blob/main/admission-server/README.md

Installs project dependencies using pnpm and starts the development server. After running, the server can be accessed at http://localhost:3009.

```bash
pnpm install
pnpm run dev
```

--------------------------------

### Start Cosmo Router with Bash Script

Source: https://github.com/wundergraph/cosmo/blob/main/examples/router-simple/README.md

This bash script installs dependencies, composes the federated schema, and starts the Cosmo Router locally. It's the primary command for setting up the example.

```bash
#!/bin/bash

# Install dependencies
npm install

# Compose the federated schema
# Assuming 'wgc' is in the PATH and configured for the project
wgc router compose

# Start the Cosmo Router
# Assuming 'wgc' is in the PATH and configured for the project
wgc router run

```

--------------------------------

### Start Cosmo Platform with Docker Compose

Source: https://github.com/wundergraph/cosmo/blob/main/examples/full-cosmo-docker/README.md

This snippet shows the shell command to initiate the Cosmo platform using Docker Compose. Ensure Docker and Docker Compose are installed and running.

```shell
./start.sh

```

--------------------------------

### Start pprof Heap Profiling

Source: https://github.com/wundergraph/cosmo/blob/main/router/docs/Profiling.md

Starts an HTTP server for the pprof profiling tool, allowing exploration of heap allocations. It requires a heap profile file (e.g., heap.out) and optionally accepts a host and port for the server. Useful commands within pprof include `web` (requires Graphviz), `top`, and `pdf`.

```bash
go tool pprof -http 127.0.0.1:6060 heap.out
```

--------------------------------

### Setup Controlplane Environment

Source: https://github.com/wundergraph/cosmo/blob/main/controlplane/README.md

Initializes the control plane by renaming the example environment file to '.env'. This step is crucial before configuring the application.

```bash
mv .env.example .env
```

--------------------------------

### Configure Custom Modules via YAML (YAML & Go)

Source: https://github.com/wundergraph/cosmo/blob/main/adr/custom-modules-v1.md

This example shows how to configure custom modules using a YAML file. The `config.yaml` demonstrates a `modules` section for custom configurations. The corresponding Go struct `MyModule` uses `yaml` tags to map configuration properties, including nested structures, allowing dynamic module setup at router startup.

```yaml
# config.yaml
modules:
  my_module:
    value: 42
```

```go
type MyModule struct {
	Value uint64 `yaml:"value"`

	Nested struct {
		Property string `yaml:"property"`
	} `yaml:"nested"`
}

func (m *MyModule) Provision(ctx *core.ModuleContext) error {
	// Access the custom value from the configuration
	m.Value
}

func (m *MyModule) Module() core.ModuleInfo {
	return core.ModuleInfo{
		Name: "myModule",
		New:  func() core.Module {
            return &MyModule{}
        },
	}
}
```

--------------------------------

### Implement Graph Server Start Hook in Go

Source: https://github.com/wundergraph/cosmo/blob/main/adr/custom-modules-v1.md

Allows custom logic to be executed just before the GraphQL server starts. Returning an error from this hook will prevent the server from starting. This is useful for pre-flight checks or initializations.

```go
type GraphServerStartHook interface {
    // OnGraphServerStart is called when the GraphQL server starts
    // Returning an error will result in the GraphQL server not starting
    OnGraphServerStart(ctx *core.GraphServerContext) error
}
```

--------------------------------

### Local Environment Variable Setup

Source: https://github.com/wundergraph/cosmo/blob/main/CONTRIBUTING.md

Commands to copy example environment variable files to their active counterparts for local development. This is essential for configuring services like the control plane, studio, and CLI.

```shell
# In the root directory (cosmo/)
# Copy controlplane environment file
cp controlplane/.env.example controlplane/.env

# Copy studio environment file
cp studio/.env.local.example studio/.env.local

# Copy cli environment file
cp cli/.env.example cli/.env
```

--------------------------------

### Make and Run Subgraph Startup Script

Source: https://github.com/wundergraph/cosmo/blob/main/cli/README.md

Makes the `start-subgraphs.sh` script executable and then runs it. This script is typically used in the Cosmo demo project to start the example subgraphs. The subgraphs will then be accessible at their respective GraphQL endpoints (e.g., http://localhost:4001/graphql).

```bash
chmod +x start-subgraphs.sh
./start-subgraphs.sh
```

--------------------------------

### Go: Initialize Custom Cosmo Router

Source: https://github.com/wundergraph/cosmo/blob/main/router/cmd/custom/README.md

The main.go file serves as the entrypoint for the custom router. It imports the default router commands and any custom modules, then starts the router process.

```go
package main

import (
	routercmd "github.com/wundergraph/cosmo/router/cmd"
	// Import your modules here
	_ "github.com/wundergraph/cosmo/router/cmd/custom/module"
)

func main() {
	routercmd.Main()
}
```

--------------------------------

### Rename Environment File for Local Setup

Source: https://github.com/wundergraph/cosmo/blob/main/studio/README.md

This command renames the example environment file to a local configuration file. Ensure you replace placeholder values in the `.env.local` file with your specific environment settings before running.

```bash
mv .env.local.example .env.local
```

--------------------------------

### Install Protographic CLI

Source: https://github.com/wundergraph/cosmo/blob/main/protographic/README.md

Installs the Protographic package globally using npm. This command is used to add the Protographic tool to your project's development dependencies.

```bash
npm install @wundergraph/protographic
```

--------------------------------

### Run Development Environment (Shell)

Source: https://github.com/wundergraph/cosmo/blob/main/router/README.md

This command starts the development environment for the Cosmo Router. It assumes a local setup with necessary prerequisites like Go 1.25 and environment variables configured via a .env file.

```shell
make dev
```

--------------------------------

### Benchmark WunderGraph Cosmo Router with k6 (Shell)

Source: https://github.com/wundergraph/cosmo/blob/main/router/docs/Profiling.md

Installs k6 using Homebrew and runs a benchmark test against the WunderGraph Cosmo router. This helps in understanding the router's performance under load by analyzing metrics like request duration, data transfer, and VUs. The output provides a detailed performance report.

```shell
brew install k6
k6 run bench.js
```

--------------------------------

### Access Admission Server Demo (Shell)

Source: https://github.com/wundergraph/cosmo/blob/main/admission-server/README.md

Opens the demo Admission Server in the browser. The demo server is available at https://demo-admission-server.fly.dev/.

```shell
open http://localhost:3009
```

--------------------------------

### Run WunderGraph Cosmo Router with pprof enabled (Go)

Source: https://github.com/wundergraph/cosmo/blob/main/router/docs/Profiling.md

Starts the WunderGraph Cosmo router with the pprof debugging endpoint enabled on a specified address. This allows for real-time performance monitoring and profiling. Ensure you have a local development environment set up before running.

```shell
go run cmd/router/main.go -pprof-addr=":6060"
```

--------------------------------

### Go Workspace Configuration Example

Source: https://github.com/wundergraph/cosmo/blob/main/CONTRIBUTING.md

An example of a `go.work` file used to manage Go module dependencies and specify workspace directories. This file is typically not committed to the repository.

```go
go 1.25

use (
	./demo
	./router
	./router-tests
)

// Here you can add custom replacements
```

--------------------------------

### Install Cosmo Router Plugin

Source: https://github.com/wundergraph/cosmo/blob/main/router-plugin/httpclient/README.md

This command installs the Cosmo Router Plugin package using the Go build tool. It is the first step required before using the HTTP client.

```bash
go get github.com/wundergraph/cosmo/router-plugin
```

--------------------------------

### Sample GraphQL Query for Employees

Source: https://github.com/wundergraph/cosmo/blob/main/examples/full-cosmo-docker/README.md

This is a sample GraphQL query to retrieve employee details, including their current mood, derived mood, availability, notes, and products. This query can be executed in the Studio Playground.

```graphql
query MyEmployees {
  employees {
    details {
      forename
    }
    currentMood
    derivedMood
    isAvailable
    notes
    products
  }
}

```

--------------------------------

### Example Go Plugin Main Entrypoint (Go)

Source: https://github.com/wundergraph/cosmo/blob/main/protographic/plugin_development.md

The main entry point for a Go-based WunderGraph Cosmo router plugin. It imports the necessary SDK and serves the plugin implementation.

```go
cosmo "github.com/wundergraph/cosmo/router-plugin"

package main

func main() {
	cosmo.Serve(&GRPCDataSourcePlugin{})
}
```

--------------------------------

### Example Feature Flag Response

Source: https://github.com/wundergraph/cosmo/blob/main/rfc/graph-feature-flags.md

Provides an example JSON response structure for the `__features` GraphQL query. This illustrates the data format clients can expect when querying available feature flags, including their names, associated subgraphs, and descriptions.

```json
{
  "__features": [
    {
      "name": "experimental",
      "subgraph": "products",
      "description": "Enables the experimental feature for the products Subgraph"
    }
  ]
}
```

--------------------------------

### Install wgc CLI using npx

Source: https://github.com/wundergraph/cosmo/blob/main/cli/README.md

Installs and runs the latest version of the WunderGraph Cosmo CLI (`wgc`) without global installation using npx. This command also requires Node.js v20 LTS or higher and is useful for trying out the CLI or for environments where global installations are not desired.

```bash
npx -y wgc@latest
```

--------------------------------

### Subscription Lifecycle Handler Example

Source: https://github.com/wundergraph/cosmo/blob/main/rfc/cosmo-streams-v1.md

Illustrates the subscription lifecycle with a focus on the `core.SubscriptionOnStartHandler` for early returns and custom authentication logic.

```text
Start subscription
    │
    └─▶ core.SubscriptionOnStartHandler (Early return, Custom Authentication Logic)
    │
    └─▶ "Subscription started"
```

--------------------------------

### SMTP Server Configuration Example

Source: https://github.com/wundergraph/cosmo/blob/main/helm/cosmo/README.md

Configuration options for setting up an SMTP server for sending emails. This includes enabling/disabling the server, specifying host, port, credentials, and TLS settings.

```yaml
controlplane.configuration.smtp: {"enabled":false,"host":"smtp.postmarkapp.com","password":"","port":587,"requireTls":true,"secure":true,"username":""}
```

--------------------------------

### Bash: Build Custom Router Executable

Source: https://github.com/wundergraph/cosmo/blob/main/router/cmd/custom/README.md

Compiles the custom router into a standalone executable binary named 'router'.

```bash
go build -o router ./cmd/custom/main.go
```

--------------------------------

### Bash: Build Custom Router Docker Image

Source: https://github.com/wundergraph/cosmo/blob/main/router/cmd/custom/README.md

Builds a Docker image for the custom router using the provided custom.Dockerfile, tagging it as 'router-custom:latest'.

```bash
docker build -f custom.Dockerfile -t router-custom:latest .
```

--------------------------------

### Enable Cosmo Seed Component using Helm

Source: https://github.com/wundergraph/cosmo/blob/main/helm/cosmo/DEV.md

Enables the seed component for initializing your organization and admin account. Ensure PostgreSQL and Keycloak are running before enabling. This is typically a one-time setup.

```shell
helm upgrade cosmo ./cosmo \
  --set global.seed.enabled=true
```

--------------------------------

### Bash: Run Custom Router

Source: https://github.com/wundergraph/cosmo/blob/main/router/cmd/custom/README.md

Command to execute the custom router locally. Ensure the .env file is configured before running.

```bash
go run ./cmd/custom/main.go
```

--------------------------------

### Publish Subgraph (Bash)

Source: https://github.com/wundergraph/cosmo/blob/main/admission-server/README.md

Publishes the 'employees' subgraph with its schema and assigns it to team A using labels. This is part of the process to set up a federated graph that uses the Admission Server.

```bash
wgc subgraph publish employees --schema ../demo/pkg/subgraphs/employees/subgraph/schema.graphqls --labels team=A
```

--------------------------------

### Get Application URL with NodePort Service

Source: https://github.com/wundergraph/cosmo/blob/main/helm/cosmo/charts/studio/templates/NOTES.txt

This snippet obtains the application URL for a Kubernetes service of type NodePort. It retrieves the allocated NodePort and Node IP using kubectl commands and then constructs the URL. Requires `kubectl` to be installed and configured.

```shell
{{- else if contains "NodePort" .Values.service.type }}
  export NODE_PORT=$(kubectl get --namespace {{ .Release.Namespace }} -o jsonpath="{.spec.ports[0].nodePort}" services {{ include "studio.fullname" . }})
  export NODE_IP=$(kubectl get nodes --namespace {{ .Release.Namespace }} -o jsonpath="{.items[0].status.addresses[0].address}")
  echo http://$NODE_IP:$NODE_PORT
{{- end }}
```

--------------------------------

### CLI Commands for Custom Module Workflow

Source: https://github.com/wundergraph/cosmo/blob/main/adr/custom-modules-v1.md

Provides examples of command-line interface (CLI) commands for managing custom modules. These commands cover scaffolding new modules, running tests for modules, and building the router with integrated custom modules.

```bash
wgc router new-module myModule --router v0.93.0 # Scaffold a new custom module and specify the router version
wgc router test # Run tests for all custom modules
wgc router build --image-tag myRouter # Build a custom module and package it into our official router image
```

--------------------------------

### Basic HTTP Client Usage in Go

Source: https://github.com/wundergraph/cosmo/blob/main/router-plugin/httpclient/README.md

Demonstrates the basic usage of the HTTP client, including creating a client instance with base URL and timeout, making a GET request, and unmarshalling a JSON response into a generic struct. It covers error handling and checking the success status of the response.

```go
package main

import (
	"context"
	"fmt"
	"time"

	"github.com/wundergraph/cosmo/router-plugin/httpclient"
)

func main() {
	// Create HTTP client with configuration options
	client := httpclient.New(
		httpclient.WithBaseURL("https://api.example.com"),
		httpclient.WithTimeout(10 * time.Second),
		httpclient.WithHeader("Accept", "application/json"),
	)

	// Create a context
	ctx := context.Background()

	// Make a GET request
	resp, err := client.Get(ctx, "/users/1")
	if err != nil {
		panic(err)
	}

	// Check if the request was successful
	if !resp.IsSuccess() {
		fmt.Printf("Request failed with status code: %d\n", resp.StatusCode)
		return
	}

	// Parse the response into a struct using generics
	type User struct {
		ID    int    `json:"id"`
		Name  string `json:"name"`
		Email string `json:"email"`
	}

	user, err := httpclient.UnmarshalTo[User](resp)
	if err != nil {
		panic(err)
	}

	fmt.Printf("User: %s (Email: %s)\n", user.Name, user.Email)
}
```

--------------------------------

### Configure Router with Signing Key (YAML)

Source: https://github.com/wundergraph/cosmo/blob/main/admission-server/README.md

Specifies the signing key for the router in the configuration file. This key must match the signing key used by the Admission Server to ensure valid configuration signatures.

```yaml
version: '1'

graph: 
  sign_key: 'sign_key'
```

--------------------------------

### Clone Cosmo Demo Project

Source: https://github.com/wundergraph/cosmo/blob/main/cli/README.md

Clones the official WunderGraph Cosmo demo project from GitHub. This project includes example subgraphs (`posts` and `users`) and a router configuration, serving as a starting point for learning and using Cosmo. After cloning, navigate into the project directory.

```bash
git clone https://github.com/wundergraph/cosmo-demo.git
cd cosmo-demo
```

--------------------------------

### Run Cosmo Router using Docker

Source: https://github.com/wundergraph/cosmo/blob/main/cli/README.md

Starts the WunderGraph Cosmo router using a Docker container. This command exposes the router on port 3002, mounts the generated `config.json` file for execution, and sets up necessary environment variables for development mode. It requires Docker to be installed and running.

```bash
docker run \
  --name cosmo-router \
  --rm \
  -p 3002:3002 \
  --add-host=host.docker.internal:host-gateway \
  --platform=linux/amd64 \
  -e pull=always \
  -e DEV_MODE=true \
  -e LISTEN_ADDR=0.0.0.0:3002 \
  -e EXECUTION_CONFIG_FILE_PATH="/config/config.json" \
  -v "$(pwd)/config.json:/config/config.json" \
  ghcr.io/wundergraph/cosmo/router:latest
```

--------------------------------

### Register a Custom Module in Go Router

Source: https://github.com/wundergraph/cosmo/blob/main/adr/custom-modules-v1.md

Demonstrates how to register a custom module within the main Go file of a router application. This involves calling the `RegisterModule` function with an instance of the module and potentially configuration options. The router then loads these modules at startup.

```go
func main() {
	core.RegisterModule(&MyModule{}, core.WithXyz("abc"))

    // Start the router
    routercmd.Main()
}
```

--------------------------------

### Install Cosmo Playground with npm

Source: https://github.com/wundergraph/cosmo/blob/main/playground/README.md

This command installs the Cosmo Playground package using npm. Ensure you have Node.js and npm installed.

```bash
npm install @wundergraph/playground
```

--------------------------------

### Enabling Feature Flags via Headers (Client)

Source: https://github.com/wundergraph/cosmo/blob/main/rfc/graph-feature-flags.md

Demonstrates how to enable feature flags for specific requests by setting the `X-WG-Feature-Flag` header. Multiple flags can be specified by separating them with a comma.

```text
X-WG-Feature-Flag: products.v2
X-WG-Feature-Flag: products.v2,employees.userAvatar
```

--------------------------------

### Implement Module Provision and Shutdown Hooks in Go

Source: https://github.com/wundergraph/cosmo/blob/main/adr/custom-modules-v1.md

Defines interfaces for managing the lifecycle of a module within the WunderGraph Cosmo system. The Provision hook is called during module setup, while Shutdown is called during tear down. It also includes a Module function to retrieve module information.

```go
type ModuleHooks interface {
	// Provision is called when the module is provisioned
	Provision(ctx *core.ModuleContext) error
	// Shutdown is called when the module is shutdown
	Shutdown() error
	// Module returns the module information and factory function
	Module() core.ModuleInfo
}
```

--------------------------------

### Install wgc CLI via npm

Source: https://github.com/wundergraph/cosmo/blob/main/cli/README.md

Installs the latest version of the WunderGraph Cosmo CLI (`wgc`) globally using npm. This command requires Node.js v20 LTS or higher. After installation, `wgc` will be available as a command in your terminal.

```bash
npm install -g wgc@latest
```

--------------------------------

### Start Infrastructure Containers (Make Target)

Source: https://github.com/wundergraph/cosmo/blob/main/CONTRIBUTING.md

A Make target to start the necessary infrastructure containers for the local demo environment.

```makefile
make infra-up
```

--------------------------------

### Start Debugging Containers (Make Target)

Source: https://github.com/wundergraph/cosmo/blob/main/CONTRIBUTING.md

A Make target to start additional containers, such as Prometheus, Jaeger, and Grafana, for debugging purposes, especially with the Cosmo Router.

```makefile
make infra-debug-up
```

--------------------------------

### Compose Modules Together in Go

Source: https://github.com/wundergraph/cosmo/blob/main/adr/custom-modules-v1.md

Enables composing modules by chaining them in the `Provision` method, allowing complex behavior through combinations. Submodules execute before the parent module. Data can be passed from parent to submodules via constructor arguments and shared using the request store.

```go
type MyModule struct{
	Value uint64 `yaml:"value"`
}

// Ensure that MyModule implements the RouterRequestHook interface
var _ RouterRequestHook = (*MyModule)(nil)

func (m *MyModule) Provision(ctx *core.ModuleContext) error {
	// Compose multiple modules together
	_ = ctx.RegisterModule(&ModuleB{
		value: m.Value,
	}, core.WithXyz("abc"))

	return nil
}

// ModuleB is a submodule of ModuleA

type ModuleB struct{
    value uint64
}

func (m *ModuleB) OnRouterRequest(req *core.RouterRequest, err error) error {
	// Access the parent module value
	m.value
	
	// Access the request store to share data between modules
	req.store.get("myData")

	return nil
}
```

--------------------------------

### Initialize a New Router Plugin (Bash)

Source: https://github.com/wundergraph/cosmo/blob/main/protographic/plugin_development.md

Scaffolds a new plugin directory structure for local development. This command creates the necessary files and directories for a Go-based plugin.

```bash
wgc router plugin init <directory>
```

--------------------------------

### Run CPU Profile Benchmark (Shell)

Source: https://github.com/wundergraph/cosmo/blob/main/router/internal/planningbenchmark/README.md

This command executes the CPU profiling for the planning benchmark using Taskfile. It assumes the Taskfile.yml has been configured and potentially modified. The output profile will be saved to a file named `<step>_cpu.out`.

```shell
task bench-cpu
```

--------------------------------

### S3 Storage URL Configuration Example

Source: https://github.com/wundergraph/cosmo/blob/main/helm/cosmo/README.md

Configuration example for S3 storage URL, which can be used for various services like CDN and control plane. It supports credentials within the URL and specific endpoint configurations.

```plaintext
cdn.configuration.s3StorageUrl: "http://minio:changeme@cosmo-minio:9000/cosmo"
controlplane.configuration.s3StorageUrl: "http://minio:changeme@cosmo-minio:9000/cosmo"
```

--------------------------------

### Example Federated Graph Query

Source: https://github.com/wundergraph/cosmo/blob/main/cli/README.md

An example GraphQL query to interact with the federated graph exposed by the Cosmo router. This query requests information about posts, including their IDs, content, and author details (ID and name). This demonstrates how to query data across multiple subgraphs managed by Cosmo.

```graphql
query {
  posts {
    id
    content
    author {
      id
      name
    }
  }
}
```

--------------------------------

### HTTP Client with Middleware in Go

Source: https://github.com/wundergraph/cosmo/blob/main/router-plugin/httpclient/README.md

Illustrates how to configure the HTTP client with custom middleware, such as authentication bearer tokens and user agents. It also shows how to add request-specific headers to individual requests.

```go
// Create a client with middleware
client := httpclient.New(
	httpclient.WithBaseURL("https://api.example.com"),
	httpclient.WithMiddleware(httpclient.AuthBearerMiddleware("your-token")),
	httpclient.WithMiddleware(httpclient.UserAgentMiddleware("MyApp/1.0")),
)

// Make a request with specific headers
resp, err := client.Get(ctx, "/users/1", 
	httpclient.WithRequestHeader("X-Request-ID", "12345"),
)
```

--------------------------------

### Access Application with ClusterIP Service

Source: https://github.com/wundergraph/cosmo/blob/main/helm/cosmo/charts/studio/templates/NOTES.txt

This snippet provides instructions for accessing an application with a Kubernetes service of type ClusterIP. It forwards a local port (8080) to the container port using `kubectl port-forward` and instructs the user to access the application via `http://127.0.0.1:8080`. Requires `kubectl`. The exact pod name and container port are dynamically determined.

```shell
{{- else if contains "ClusterIP" .Values.service.type }}
  export POD_NAME=$(kubectl get pods --namespace {{ .Release.Namespace }} -l "app.kubernetes.io/name={{ include "studio.name" . }},app.kubernetes.io/instance={{ .Release.Name }}" -o jsonpath="{.items[0].metadata.name}")
  export CONTAINER_PORT=$(kubectl get pod --namespace {{ .Release.Namespace }} $POD_NAME -o jsonpath="{.spec.containers[0].ports[0].containerPort}")
  echo "Visit http://127.0.0.1:8080 to use your application"
  kubectl --namespace {{ .Release.Namespace }} port-forward $POD_NAME 8080:$CONTAINER_PORT
{{- end }}
```

--------------------------------

### Copy Router Environment File

Source: https://github.com/wundergraph/cosmo/blob/main/CONTRIBUTING.md

Copies the example router environment file to a new file, allowing for local configuration of the router.

```shell
cp router/.env.example router/.env
```

--------------------------------

### Create Graph with Admission Webhook (Bash)

Source: https://github.com/wundergraph/cosmo/blob/main/admission-server/README.md

Creates a new federated graph named 'mygraph' and configures it to use the local Admission Server at http://localhost:3009 for validation. It also sets label matchers for teams A and B.

```bash
wgc federated-graph create mygraph -r http://127.0.0.1:3001/graphql --admission-webhook-url http://localhost:3009 --label-matcher=team=A,team=B
```

--------------------------------

### Bootstrap Cosmo Local Development

Source: https://github.com/wundergraph/cosmo/blob/main/CONTRIBUTING.md

Sequence of shell commands to set up the Cosmo repository, build libraries, start all services, and configure the local development environment.

```shell
# In the root directory (cosmo/)
# 1️⃣ Setup the repository, build libraries and start all services (Wait a few seconds until Keycloak is ready)
# You can check whether Keycloak is running by going to localhost:8080. It should show sign-in page
make

# 2️⃣ Run migrations and seed the database
make migrate && make seed

# 3️⃣ Start the control plane
make start-cp

# 4️⃣ Create the demo and copy the JWT printed at the bottom
make create-demo

# 5️⃣ Start the subgraphs
OTEL_AUTH_TOKEN=<jwt-token> make dc-subgraphs-demo

# 6️⃣ Put the JWT from the previous step into the router/.env as GRAPH_API_TOKEN and start the router
make start-router

# ✨ Finally, Start the studio (http://localhost:3000) and explore the Cosmo platform
make start-studio
```

--------------------------------

### Local graphql-go-tools Development (Go)

Source: https://github.com/wundergraph/cosmo/blob/main/router/README.md

This Go code snippet shows how to configure local development for the graphql-go-tools package. By uncommenting the 'replace' directive in go.mod, you can use a local version of the package, facilitating rapid iteration during development. Ensure the graphql-go-tools repository is in the parent directory.

```go
replace github.com/wundergraph/graphql-go-tools/v2 => ../../graphql-go-tools/v2
```
Tokens:
Raw