[feature] Allow using external services in server side code

[Rigo-m]

Sometimes, masking queries to external services in the server is good for performance, especially when queries are really big (think cms graphql queries with lost of components/fragments).

Frontend code should be able to perform queries to server via sdk without passing huge queries.

Example:
Client code:

// frontend calls this fetch
$contentfulSDK.getPage('page-id')

Backend code

query { .... very long query to external service

Maybe this is already possible and I'm missing something

[productdevbook]

Hi! I understand what you're looking for now. This is actually a great feature request for selective server-side proxying of external GraphQL services.

What you want to achieve:

Frontend (simple call for complex operations):

// Simple, lightweight call for complex queries
const page = await $sdk.getComplexPage('page-id')

// But still direct access for simple queries  
const author = await $contentfulSDK.getAuthor('author-123')

Backend (handles only complex queries):

// Server proxies only the complex queries to external service
query GetComplexPage($id: String!) {
  page(id: $id) {
    title
    slug
    content
    sections {
      ... on HeroSection { title, image, cta }
      ... on TextSection { content, layout }
      // 50+ different fragment types
    }
    seo { title, description, keywords }
    metadata { publishDate, author, tags }
    relatedContent { ... complex nested queries }
  }
}

Benefits of selective proxy approach:

1. Developer Choice: You decide which queries need proxy, which can be direct
2. Performance: Only complex queries go through server, simple ones stay direct
3. Flexibility: Same external service can have both direct and proxy queries
4. Security: API tokens for sensitive operations stay server-side
5. Bundle Size: Only complex queries are removed from frontend bundle

Implementation Plan:

Selective Proxy System - Best of both worlds:

// nuxt.config.ts  
externalServices: [{
  name: 'contentful',
  schema: 'https://graphql.contentful.com/...',
  endpoint: 'https://graphql.contentful.com/...',
  documents: ['app/graphql/contentful/**/*.graphql'], // Direct queries
  proxyResolvers: 'server/graphql/contentful' // Proxy queries directory
}]

Usage after implementation:

// server/graphql/contentful/pages.proxy.resolver.ts - Complex operations only
export const getComplexPage = defineProxyQuery({
  service: 'contentful',
  resolver: async (_, { id }) => {
    return await executeExternalQuery('contentful', HUGE_COMPLEX_QUERY, { id })
  }
})

// app/graphql/contentful/authors.graphql - Simple direct queries
query GetAuthor($id: String!) {
  author(id: $id) { name, bio, avatar }
}

Frontend - Choose your approach per query:

// Complex query → goes through your server (proxy)
const page = await $sdk.getComplexPage({ id: 'page-123' })

// Simple query → direct to external service  
const author = await $contentfulSDK.getAuthor({ id: 'author-123' })

This gives you the flexibility to proxy only what you need while keeping simple operations direct. Does this selective approach match what you had in mind?

[Rigo-m]

Correct!
Only thing's missing (and I think it's the hardest part) is that responses from complex queries in the backend should be strongly typed as if they were done without proxying them