Wesley

"Things are only impossible until they're not." -- Jean-Luc Picard

Wesley is a domain-free GraphQL-to-IR transformation toolchain.

Wesley extracts the structure described by GraphQL SDL, lowers that structure into deterministic JSON IR, and provides hooks for you to give it semantics in your own extensions.

There is no graph. Only structure and what you make of it.

GraphQL SDL -> deterministic Wesley IR -> your domain via extensions

Wesley is deliberately domain-empty. It claims no ownership over runtime law, scheduler semantics, persistence models, replication behavior, storage engines, transport protocols, or substrate truth. Those concerns belong to extension modules, sibling repos, or consuming applications.

Wesley owns the GraphQL-to-IR transformation. Extensions own meaning.

Stability

Wesley is pre-1.0 software. APIs, CLI commands, generated artifacts, metadata schemas, and extension boundaries can still change between 0.x releases.

Use Wesley when you want deterministic build-time structure extraction and are comfortable pinning versions. Treat generated artifacts and extension contracts as release-scoped until the project declares a stable 1.0 surface.

Quick Start

After the signed v0.2.0 tag publishes, install the native CLI:

cargo install wesley-cli --version 0.2.0
wesley --help

From a source checkout:

cargo run --bin wesley -- --help
cargo xtask preflight

Lower GraphQL SDL into Wesley L1 IR:

cargo run --bin wesley -- schema lower \
  --schema test/fixtures/ir-parity/small-schema.graphql \
  --json

Generate target-neutral Rust or TypeScript projections:

cargo run --bin wesley -- emit rust \
  --schema test/fixtures/weslaw/contract-bundle-shape.graphql \
  --out generated/model.rs \
  --metadata-out generated/model.metadata.json

cargo run --bin wesley -- emit typescript \
  --schema test/fixtures/weslaw/contract-bundle-shape.graphql \
  --out generated/types.ts \
  --metadata-out generated/types.metadata.json

Run the local release-quality gate before opening a PR:

cargo xtask preflight

Validate a project manifest when a repo wants config-driven schema selection:

cargo run --bin wesley -- config validate --config wesley.config.json --json
cargo run --bin wesley -- config changed-schemas \
  --config wesley.config.json \
  --changed test/fixtures/examples/ecommerce.graphql \
  --json

The retained pnpm workspace supports docs, Holmes assurance tooling, and workspace checks. Use Node >=22.12.0 with pnpm 9.15.9 when working from this checkout.

What Wesley Owns

Wesley owns domain-free compiler facts:

• GraphQL SDL parsing and normalization
• deterministic L1 IR and schema hashes
• schema diffs and root operation catalogs
• operation selection and directive-argument extraction
• Rust and TypeScript model and operation bindings
• TypeScript and Rust LE-binary codec projections
• weslaw/v1 authoring, hashing, diffing, rebinding, and coverage metadata
• release and assurance checks around those generic compiler contracts

Wesley preserves directives as inspectable structure. It does not decide what those directives mean for a database, runtime, product, graph rewrite system, transport, scheduler, or application. Extension owners do that work.

The detailed ownership rule lives in Domain-Empty Core Boundary.

External Module Examples

A single schema can be compiled by many extensions simultaneously. Each extension consumes Wesley IR independently and emits its own artifacts.

Module family	External owner	Responsibility
Postgres	wesley-postgres	SQL schemas, migrations, indexes, pgTAP, CRUD helpers
Validation	external target/module	Runtime and static validation rules
TypeScript	Wesley emitter or external target	Type contracts and client bindings
Codec	Wesley emitter or external target	Binary and runtime codecs
Echo	Echo-owned integration	Runtime law, footprints, observation semantics
Continuum	Continuum-owned module/repo	Deferred protocol generation

What's New in v0.2.0

Wesley 0.2.0 is the domain-free project-manifest platform release. It adds the JSON/YAML wesley.project-manifest/v1 surface, native wesley config commands, manifest-driven schema selection for HOLMES CI, descriptor-only extension fixture modules, and a comprehensive docs/topics/ operator map. The release keeps the boundary explicit: Wesley extracts structure from GraphQL, and extensions assign meaning.

For complete history, read CHANGELOG.md.

Reference Map

• Docs entrance
• Topics
• Guide
• Architecture
• Wesley North Star
• SDL, Shape, And Law
• End To End
• Entrypoints
• CLI reference
• Project manifest
• Directive truth table
• Module authoring
• Technical teardown
• Release policy
• Contributing
• Support
• Security

Anti-Goals

Wesley is not:

• a runtime
• a scheduler
• a database
• a replication engine
• a GraphQL server replacement
• a universal protocol
• a transport framework
• a venue for domain-specific product semantics

Keeping Wesley narrow is what lets extensions own rich semantics without turning the compiler into hidden platform ideology.

Support

Use SUPPORT.md for questions, issue routing, security reporting, and release-support expectations.