nitro-graphql 2.0.0-beta.7 → 2.0.0-beta.70

package/dist/core/scanning/common.mjs

@@ -0,0 +1,59 @@
+import { GLOB_SCAN_PATTERN } from "../constants.mjs";
+import { join, relative } from "pathe";
+import { glob } from "tinyglobby";
+
+//#region src/core/scanning/common.ts
+const DEFAULT_IGNORE_PATTERNS = [
+	"**/node_modules/**",
+	"**/.git/**",
+	"**/.output/**",
+	"**/.nitro/**",
+	"**/.nuxt/**",
+	"**/.graphql/**"
+];
+/**
+* Scan a directory for files matching a glob pattern
+*/
+async function scanDirectory(ctx, baseDir, subDir, globPattern = GLOB_SCAN_PATTERN) {
+	return (await glob(join(subDir, globPattern), {
+		cwd: baseDir,
+		dot: true,
+		ignore: [...DEFAULT_IGNORE_PATTERNS, ...ctx.ignorePatterns],
+		absolute: true
+	}).catch((error) => {
+		if (error?.code === "ENOTDIR") {
+			ctx.logger.warn(`Ignoring \`${join(baseDir, subDir)}\`. It must be a directory.`);
+			return [];
+		}
+		throw error;
+	})).map((fullPath) => ({
+		fullPath,
+		path: relative(join(baseDir, subDir), fullPath)
+	})).sort((a, b) => a.path.localeCompare(b.path));
+}
+/**
+* Deduplicate files by fullPath
+*/
+function deduplicateFiles(files) {
+	const seenPaths = /* @__PURE__ */ new Set();
+	return files.filter((file) => {
+		if (seenPaths.has(file.fullPath)) return false;
+		seenPaths.add(file.fullPath);
+		return true;
+	});
+}
+/**
+* Filter files by extension
+*/
+function filterByExtension(files, extensions) {
+	return files.filter((file) => extensions.some((ext) => file.fullPath.endsWith(ext)));
+}
+/**
+* Extract file paths from scanned files
+*/
+function extractPaths(files) {
+	return files.map((f) => f.fullPath);
+}
+
+//#endregion
+export { deduplicateFiles, extractPaths, filterByExtension, scanDirectory };

package/dist/core/scanning/directives.d.mts

@@ -0,0 +1,13 @@
+import { ResolverImport, ScanContext, ScanResult, ScannedResolver } from "../types/scanning.mjs";
+
+//#region src/core/scanning/directives.d.ts
+/**
+ * Parse a defineDirective call and return the import info
+ */
+declare function parseDirectiveCall(calleeName: string, exportName: string, filePath: string): ResolverImport | null;
+/**
+ * Scan for directive files (.directive.ts/.js)
+ */
+declare function scanDirectivesCore(ctx: ScanContext): Promise<ScanResult<ScannedResolver>>;
+//#endregion
+export { parseDirectiveCall, scanDirectivesCore };

package/dist/core/scanning/directives.mjs

@@ -0,0 +1,29 @@
+import { DIRECTIVE_GLOB_PATTERN } from "../constants.mjs";
+import { scanWithAST } from "./ast-scanner.mjs";
+import { hash } from "ohash";
+
+//#region src/core/scanning/directives.ts
+/**
+* Parse a defineDirective call and return the import info
+*/
+function parseDirectiveCall(calleeName, exportName, filePath) {
+	if (calleeName !== "defineDirective") return null;
+	return {
+		name: exportName,
+		type: "directive",
+		as: `_${hash(exportName + filePath).replace(/-/g, "").slice(0, 6)}`
+	};
+}
+/**
+* Scan for directive files (.directive.ts/.js)
+*/
+function scanDirectivesCore(ctx) {
+	return scanWithAST(ctx, {
+		pattern: DIRECTIVE_GLOB_PATTERN,
+		parseCall: parseDirectiveCall,
+		emitWarnings: false
+	});
+}
+
+//#endregion
+export { parseDirectiveCall, scanDirectivesCore };

package/dist/core/scanning/documents.d.mts

@@ -0,0 +1,20 @@
+import { CoreExternalService } from "../types/config.mjs";
+import { ScanContext, ScanResult } from "../types/scanning.mjs";
+
+//#region src/core/scanning/documents.d.ts
+/**
+ * Options for scanning documents
+ */
+interface ScanDocumentsOptions {
+  /** External services to exclude from main scan */
+  externalServices?: CoreExternalService[];
+  /** Client directory relative path */
+  clientDirRelative?: string;
+}
+/**
+ * Scan for GraphQL client documents (.graphql, .gql) in client directory
+ * Excludes files from external service directories
+ */
+declare function scanDocumentsCore(ctx: ScanContext, options?: ScanDocumentsOptions): Promise<ScanResult<string>>;
+//#endregion
+export { ScanDocumentsOptions, scanDocumentsCore };

package/dist/core/scanning/documents.mjs

@@ -0,0 +1,37 @@
+import { GRAPHQL_GLOB_PATTERN } from "../constants.mjs";
+import { scanDirectory } from "./common.mjs";
+import { relative } from "pathe";
+
+//#region src/core/scanning/documents.ts
+/**
+* Scan for GraphQL client documents (.graphql, .gql) in client directory
+* Excludes files from external service directories
+*/
+async function scanDocumentsCore(ctx, options = {}) {
+	const warnings = [];
+	const errors = [];
+	try {
+		const clientDirRelative = options.clientDirRelative || relative(ctx.rootDir, ctx.clientDir);
+		const allFiles = await scanDirectory(ctx, ctx.rootDir, clientDirRelative, GRAPHQL_GLOB_PATTERN);
+		const externalPatterns = (options.externalServices || []).flatMap((service) => service.documents || []);
+		return {
+			items: allFiles.filter((f) => !f.path.startsWith("external/")).filter((f) => {
+				const relativePath = f.path;
+				for (const pattern of externalPatterns) if (pattern.replace(new RegExp(`^${clientDirRelative.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}/`), "").split("/")[0] === relativePath.split("/")[0]) return false;
+				return true;
+			}).map((f) => f.fullPath),
+			warnings,
+			errors
+		};
+	} catch (error) {
+		errors.push(`Document scanning error: ${error}`);
+		return {
+			items: [],
+			warnings,
+			errors
+		};
+	}
+}
+
+//#endregion
+export { scanDocumentsCore };

package/dist/core/scanning/index.d.mts

@@ -0,0 +1,7 @@
+import { ASTScanConfig, parseSingleFile, scanWithAST } from "./ast-scanner.mjs";
+import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./common.mjs";
+import { parseDirectiveCall, scanDirectivesCore } from "./directives.mjs";
+import { ScanDocumentsOptions, scanDocumentsCore } from "./documents.mjs";
+import { parseResolverCall, scanResolversCore } from "./resolvers.mjs";
+import { scanGraphqlCore, scanSchemasCore } from "./schemas.mjs";
+export { type ASTScanConfig, type ScanDocumentsOptions, deduplicateFiles, extractPaths, filterByExtension, parseDirectiveCall, parseResolverCall, parseSingleFile, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST };

package/dist/core/scanning/index.mjs

@@ -0,0 +1,8 @@
+import { deduplicateFiles, extractPaths, filterByExtension, scanDirectory } from "./common.mjs";
+import { parseSingleFile, scanWithAST } from "./ast-scanner.mjs";
+import { parseDirectiveCall, scanDirectivesCore } from "./directives.mjs";
+import { scanDocumentsCore } from "./documents.mjs";
+import { parseResolverCall, scanResolversCore } from "./resolvers.mjs";
+import { scanGraphqlCore, scanSchemasCore } from "./schemas.mjs";
+
+export { deduplicateFiles, extractPaths, filterByExtension, parseDirectiveCall, parseResolverCall, parseSingleFile, scanDirectivesCore, scanDirectory, scanDocumentsCore, scanGraphqlCore, scanResolversCore, scanSchemasCore, scanWithAST };

package/dist/core/scanning/resolvers.d.mts

@@ -0,0 +1,14 @@
+import { ResolverImport, ScanContext, ScanResult, ScannedResolver } from "../types/scanning.mjs";
+
+//#region src/core/scanning/resolvers.d.ts
+/**
+ * Parse a define* function call and return the import info
+ * Exported for use by manifest loader
+ */
+declare function parseResolverCall(calleeName: string, exportName: string, filePath: string): ResolverImport | null;
+/**
+ * Scan for resolver files and parse their exports
+ */
+declare function scanResolversCore(ctx: ScanContext): Promise<ScanResult<ScannedResolver>>;
+//#endregion
+export { parseResolverCall, scanResolversCore };

package/dist/core/scanning/resolvers.mjs

@@ -0,0 +1,59 @@
+import { DEFINE_FUNCTIONS, RESOLVER_GLOB_PATTERN } from "../constants.mjs";
+import { scanWithAST } from "./ast-scanner.mjs";
+import { hash } from "ohash";
+
+//#region src/core/scanning/resolvers.ts
+/**
+* Parse a define* function call and return the import info
+* Exported for use by manifest loader
+*/
+function parseResolverCall(calleeName, exportName, filePath) {
+	const aliasHash = `_${hash(exportName + filePath).replace(/-/g, "").slice(0, 6)}`;
+	switch (calleeName) {
+		case "defineResolver": return {
+			name: exportName,
+			type: "resolver",
+			as: aliasHash
+		};
+		case "defineQuery": return {
+			name: exportName,
+			type: "query",
+			as: aliasHash
+		};
+		case "defineMutation": return {
+			name: exportName,
+			type: "mutation",
+			as: aliasHash
+		};
+		case "defineField": return {
+			name: exportName,
+			type: "type",
+			as: aliasHash
+		};
+		case "defineSubscription": return {
+			name: exportName,
+			type: "subscription",
+			as: aliasHash
+		};
+		case "defineDirective": return {
+			name: exportName,
+			type: "directive",
+			as: aliasHash
+		};
+		default: return null;
+	}
+}
+/**
+* Scan for resolver files and parse their exports
+*/
+function scanResolversCore(ctx) {
+	return scanWithAST(ctx, {
+		pattern: RESOLVER_GLOB_PATTERN,
+		parseCall: parseResolverCall,
+		emitWarnings: true,
+		validFunctions: DEFINE_FUNCTIONS
+	});
+}
+
+//#endregion
+export { parseResolverCall, scanResolversCore };

package/dist/core/scanning/schemas.d.mts

@@ -0,0 +1,13 @@
+import { ScanContext, ScanResult } from "../types/scanning.mjs";
+
+//#region src/core/scanning/schemas.d.ts
+/**
+ * Scan for GraphQL schema files (.graphql, .gql) in server directory
+ */
+declare function scanSchemasCore(ctx: ScanContext): Promise<ScanResult<string>>;
+/**
+ * Scan for GraphQL files (.graphql, .gql) in server directory
+ */
+declare function scanGraphqlCore(ctx: ScanContext): Promise<ScanResult<string>>;
+//#endregion
+export { scanGraphqlCore, scanSchemasCore };

package/dist/core/scanning/schemas.mjs

@@ -0,0 +1,52 @@
+import { GRAPHQL_GLOB_PATTERN } from "../constants.mjs";
+import { extractPaths, scanDirectory } from "./common.mjs";
+import { relative } from "pathe";
+
+//#region src/core/scanning/schemas.ts
+/**
+* Scan for GraphQL schema files (.graphql, .gql) in server directory
+*/
+async function scanSchemasCore(ctx) {
+	const warnings = [];
+	const errors = [];
+	try {
+		const serverDirRelative = relative(ctx.rootDir, ctx.serverDir);
+		return {
+			items: extractPaths(await scanDirectory(ctx, ctx.rootDir, serverDirRelative, GRAPHQL_GLOB_PATTERN)),
+			warnings,
+			errors
+		};
+	} catch (error) {
+		errors.push(`Schema scanning error: ${error}`);
+		return {
+			items: [],
+			warnings,
+			errors
+		};
+	}
+}
+/**
+* Scan for GraphQL files (.graphql, .gql) in server directory
+*/
+async function scanGraphqlCore(ctx) {
+	const warnings = [];
+	const errors = [];
+	try {
+		const serverDirRelative = relative(ctx.rootDir, ctx.serverDir);
+		return {
+			items: extractPaths(await scanDirectory(ctx, ctx.rootDir, serverDirRelative, "**/*.{graphql,gql}")),
+			warnings,
+			errors
+		};
+	} catch (error) {
+		errors.push(`GraphQL scanning error: ${error}`);
+		return {
+			items: [],
+			warnings,
+			errors
+		};
+	}
+}
+
+//#endregion
+export { scanGraphqlCore, scanSchemasCore };

package/dist/core/schema/builder.d.mts

@@ -0,0 +1,59 @@
+import { DirectiveDefinition } from "../types/define.mjs";
+import { GraphQLSchema, parse, subscribe, validate } from "graphql";
+
+//#region src/core/schema/builder.d.ts
+/**
+ * Schema definition from virtual module
+ */
+interface SchemaDefinition {
+  def: string;
+}
+/**
+ * Resolver definition from virtual module
+ */
+interface ResolverDefinition {
+  resolver: Record<string, unknown>;
+}
+/**
+ * Directive wrapper from virtual module
+ */
+interface DirectiveWrapper {
+  directive: DirectiveDefinition;
+}
+/**
+ * Module configuration for federation
+ */
+interface ModuleConfig {
+  federation?: {
+    enabled?: boolean;
+    serviceName?: string;
+  };
+}
+/**
+ * Options for creating a merged schema
+ */
+interface CreateMergedSchemaOptions {
+  schemas: SchemaDefinition[];
+  resolvers: ResolverDefinition[];
+  directives?: DirectiveWrapper[];
+  moduleConfig: ModuleConfig;
+}
+/**
+ * Create a merged GraphQL schema from schemas, resolvers, and directives
+ * Supports Apollo Federation when enabled
+ */
+declare function createMergedSchema(options: CreateMergedSchemaOptions): Promise<GraphQLSchema>;
+/**
+ * Base schema with empty Query and Mutation types.
+ * Required for 'extend type Query' syntax to work.
+ * Shared between CLI and Nitro.
+ */
+declare const BASE_SCHEMA = "type Query { _empty: String }\ntype Mutation { _empty: String }";
+/**
+ * Build a GraphQL schema from file paths (CLI usage)
+ * Reads schema files, merges them, and builds an executable schema
+ * Includes BASE_SCHEMA for extend type support
+ */
+declare function buildGraphQLSchema(schemaPaths: string[]): Promise<GraphQLSchema | null>;
+//#endregion
+export { BASE_SCHEMA, CreateMergedSchemaOptions, DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition, buildGraphQLSchema, createMergedSchema, parse, subscribe, validate };

package/dist/core/schema/builder.mjs

@@ -0,0 +1,78 @@
+import { loadFederationSupport, warnFederationUnavailable } from "./federation.mjs";
+import { consola as consola$1 } from "consola";
+import { buildSchema, parse, parse as parse$1, print, subscribe, validate } from "graphql";
+import { readFileSync } from "node:fs";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+
+//#region src/core/schema/builder.ts
+/**
+* Create a merged GraphQL schema from schemas, resolvers, and directives
+* Supports Apollo Federation when enabled
+*/
+async function createMergedSchema(options) {
+	const { schemas, resolvers, directives, moduleConfig } = options;
+	try {
+		const typeDefs = mergeTypeDefs([schemas.map((schema) => schema.def).join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		const federationEnabled = moduleConfig.federation?.enabled;
+		let schema;
+		if (federationEnabled) {
+			const buildSubgraph = await loadFederationSupport();
+			if (buildSubgraph) schema = buildSubgraph({
+				typeDefs: typeof typeDefs === "string" ? parse$1(typeDefs) : typeDefs,
+				resolvers: mergedResolvers
+			});
+			else {
+				warnFederationUnavailable();
+				schema = makeExecutableSchema({
+					typeDefs,
+					resolvers: mergedResolvers
+				});
+			}
+		} else schema = makeExecutableSchema({
+			typeDefs,
+			resolvers: mergedResolvers
+		});
+		if (directives && directives.length > 0) {
+			for (const { directive } of directives) if (directive.transformer) schema = directive.transformer(schema);
+		}
+		return schema;
+	} catch (error) {
+		consola$1.error("Schema merge error:", error);
+		throw error;
+	}
+}
+/**
+* Base schema with empty Query and Mutation types.
+* Required for 'extend type Query' syntax to work.
+* Shared between CLI and Nitro.
+*/
+const BASE_SCHEMA = `type Query { _empty: String }
+type Mutation { _empty: String }`;
+/**
+* Build a GraphQL schema from file paths (CLI usage)
+* Reads schema files, merges them, and builds an executable schema
+* Includes BASE_SCHEMA for extend type support
+*/
+async function buildGraphQLSchema(schemaPaths) {
+	if (schemaPaths.length === 0) return null;
+	try {
+		const mergedTypeDefs = mergeTypeDefs([BASE_SCHEMA, ...schemaPaths.map((path) => readFileSync(path, "utf-8"))], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+		return buildSchema(typeof mergedTypeDefs === "string" ? mergedTypeDefs : print(mergedTypeDefs));
+	} catch (error) {
+		consola$1.error("Failed to build GraphQL schema:", error);
+		return null;
+	}
+}
+
+//#endregion
+export { BASE_SCHEMA, buildGraphQLSchema, createMergedSchema, parse, subscribe, validate };

package/dist/core/schema/federation.d.mts

@@ -0,0 +1,33 @@
+import { DocumentNode, GraphQLSchema } from "graphql";
+
+//#region src/core/schema/federation.d.ts
+/**
+ * Module type for buildSubgraphSchema
+ */
+interface SubgraphModule {
+  typeDefs: DocumentNode;
+  resolvers?: Record<string, unknown>;
+}
+/**
+ * Type for buildSubgraphSchema function from @apollo/subgraph
+ * Accepts either an array of modules or a single options object
+ */
+type BuildSubgraphSchemaFn = (modulesOrOptions: SubgraphModule[] | SubgraphModule) => GraphQLSchema;
+/**
+ * Dynamically load @apollo/subgraph for federation support.
+ * Returns the buildSubgraphSchema function if available, or false if the package is not installed.
+ * Result is cached for subsequent calls.
+ */
+declare function loadFederationSupport(): Promise<BuildSubgraphSchemaFn | false>;
+/**
+ * Log a warning when federation is enabled but @apollo/subgraph is not available.
+ * Uses consola logger instead of console.warn for consistent logging.
+ */
+declare function warnFederationUnavailable(): void;
+/**
+ * Reset the federation support cache.
+ * Useful for testing or when the module needs to be reloaded.
+ */
+declare function resetFederationCache(): void;
+//#endregion
+export { loadFederationSupport, resetFederationCache, warnFederationUnavailable };

package/dist/core/schema/federation.mjs

@@ -0,0 +1,40 @@
+import { LOG_TAG } from "../constants.mjs";
+import { consola as consola$1 } from "consola";
+
+//#region src/core/schema/federation.ts
+const logger = consola$1.withTag(LOG_TAG);
+/**
+* Cached result: function if available, false if not available, null if not checked yet
+*/
+let buildSubgraphSchemaCache = null;
+/**
+* Dynamically load @apollo/subgraph for federation support.
+* Returns the buildSubgraphSchema function if available, or false if the package is not installed.
+* Result is cached for subsequent calls.
+*/
+async function loadFederationSupport() {
+	if (buildSubgraphSchemaCache !== null) return buildSubgraphSchemaCache;
+	try {
+		buildSubgraphSchemaCache = (await import("@apollo/subgraph")).buildSubgraphSchema;
+	} catch {
+		buildSubgraphSchemaCache = false;
+	}
+	return buildSubgraphSchemaCache;
+}
+/**
+* Log a warning when federation is enabled but @apollo/subgraph is not available.
+* Uses consola logger instead of console.warn for consistent logging.
+*/
+function warnFederationUnavailable() {
+	logger.warn("Federation enabled but @apollo/subgraph not available, falling back to regular schema");
+}
+/**
+* Reset the federation support cache.
+* Useful for testing or when the module needs to be reloaded.
+*/
+function resetFederationCache() {
+	buildSubgraphSchemaCache = null;
+}
+
+//#endregion
+export { loadFederationSupport, resetFederationCache, warnFederationUnavailable };

package/dist/core/schema/index.d.mts

@@ -0,0 +1,3 @@
+import { BASE_SCHEMA, CreateMergedSchemaOptions, DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition, buildGraphQLSchema, createMergedSchema, parse, subscribe, validate } from "./builder.mjs";
+import { loadFederationSupport, resetFederationCache, warnFederationUnavailable } from "./federation.mjs";
+export { BASE_SCHEMA, CreateMergedSchemaOptions, DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition, buildGraphQLSchema, createMergedSchema, loadFederationSupport, parse, resetFederationCache, subscribe, validate, warnFederationUnavailable };

package/dist/core/schema/index.mjs

@@ -0,0 +1,4 @@
+import { loadFederationSupport, resetFederationCache, warnFederationUnavailable } from "./federation.mjs";
+import { BASE_SCHEMA, buildGraphQLSchema, createMergedSchema, parse, subscribe, validate } from "./builder.mjs";
+
+export { BASE_SCHEMA, buildGraphQLSchema, createMergedSchema, loadFederationSupport, parse, resetFederationCache, subscribe, validate, warnFederationUnavailable };

package/dist/core/server/index.d.mts

@@ -0,0 +1,4 @@
+import { CoreServerInstance, CoreServerOptions, ServerFactory } from "./types.mjs";
+import { APOLLO_SANDBOX_CDN, createSandboxResponse, fetchSandboxScript } from "./sandbox.mjs";
+import { BASE_SCHEMA, apolloSandboxHtml, createYogaServer } from "./yoga.mjs";
+export { APOLLO_SANDBOX_CDN, type CoreServerInstance, type CoreServerOptions, type ServerFactory, BASE_SCHEMA as YOGA_BASE_SCHEMA, apolloSandboxHtml, createSandboxResponse, createYogaServer, fetchSandboxScript };

package/dist/core/server/index.mjs

@@ -0,0 +1,4 @@
+import { APOLLO_SANDBOX_CDN, createSandboxResponse, fetchSandboxScript } from "./sandbox.mjs";
+import { BASE_SCHEMA, apolloSandboxHtml, createYogaServer } from "./yoga.mjs";
+
+export { APOLLO_SANDBOX_CDN, BASE_SCHEMA as YOGA_BASE_SCHEMA, apolloSandboxHtml, createSandboxResponse, createYogaServer, fetchSandboxScript };

package/dist/core/server/sandbox.d.mts

@@ -0,0 +1,18 @@
+//#region src/core/server/sandbox.d.ts
+/**
+ * Core Sandbox Script Handler
+ *
+ * Proxies Apollo Sandbox script from CDN with caching.
+ * Used by both CLI and Nitro.
+ */
+declare const APOLLO_SANDBOX_CDN = "https://embeddable-sandbox.cdn.apollographql.com/_latest/embeddable-sandbox.umd.production.min.js";
+/**
+ * Fetch and cache the Apollo Sandbox script
+ */
+declare function fetchSandboxScript(): Promise<string>;
+/**
+ * Create a Response with the sandbox script
+ */
+declare function createSandboxResponse(): Promise<Response>;
+//#endregion
+export { APOLLO_SANDBOX_CDN, createSandboxResponse, fetchSandboxScript };

package/dist/core/server/sandbox.mjs

@@ -0,0 +1,39 @@
+//#region src/core/server/sandbox.ts
+/**
+* Core Sandbox Script Handler
+*
+* Proxies Apollo Sandbox script from CDN with caching.
+* Used by both CLI and Nitro.
+*/
+const APOLLO_SANDBOX_CDN = "https://embeddable-sandbox.cdn.apollographql.com/_latest/embeddable-sandbox.umd.production.min.js";
+let cachedScript = null;
+/**
+* Fetch and cache the Apollo Sandbox script
+*/
+async function fetchSandboxScript() {
+	if (cachedScript) return cachedScript;
+	const response = await fetch(APOLLO_SANDBOX_CDN);
+	if (!response.ok) throw new Error(`Failed to fetch Apollo Sandbox script: ${response.status}`);
+	cachedScript = await response.text();
+	return cachedScript;
+}
+/**
+* Create a Response with the sandbox script
+*/
+async function createSandboxResponse() {
+	try {
+		const script = await fetchSandboxScript();
+		return new Response(script, { headers: {
+			"content-type": "text/javascript; charset=utf-8",
+			"cache-control": "public, max-age=2592000, immutable"
+		} });
+	} catch (error) {
+		return new Response(`// Error loading Apollo Sandbox: ${error}`, {
+			status: 500,
+			headers: { "content-type": "text/javascript; charset=utf-8" }
+		});
+	}
+}
+
+//#endregion
+export { APOLLO_SANDBOX_CDN, createSandboxResponse, fetchSandboxScript };

package/dist/core/server/types.d.mts

@@ -0,0 +1,54 @@
+import { DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition } from "../schema/builder.mjs";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/server/types.d.ts
+/**
+ * Security configuration for GraphQL server
+ */
+interface CoreSecurityConfig {
+  /** Enable GraphQL introspection (default: true in dev, false in prod) */
+  introspection?: boolean;
+  /** Enable GraphQL playground/sandbox (default: true in dev, false in prod) */
+  playground?: boolean;
+  /** Mask error messages in responses (default: false in dev, true in prod) */
+  maskErrors?: boolean;
+  /** Disable field suggestions in error messages */
+  disableSuggestions?: boolean;
+}
+/**
+ * Options for creating a GraphQL server instance
+ */
+interface CoreServerOptions {
+  /** Schema definitions (GraphQL SDL strings) */
+  schemas: SchemaDefinition[];
+  /** Resolver definitions */
+  resolvers: ResolverDefinition[];
+  /** Directive definitions (optional) */
+  directives?: DirectiveWrapper[];
+  /** Module configuration (federation, etc.) */
+  moduleConfig: ModuleConfig;
+  /** GraphQL endpoint path (default: /api/graphql) */
+  endpoint?: string;
+  /** Security configuration */
+  security?: CoreSecurityConfig;
+  /** User's imported GraphQL config (from defineGraphQLConfig) */
+  importedConfig?: Record<string, unknown>;
+}
+/**
+ * GraphQL server instance returned by server factories
+ */
+interface CoreServerInstance {
+  /**
+   * Handle a request using the web standard fetch API
+   * Compatible with srvx, Bun, Deno, and Node.js
+   */
+  fetch: (request: Request, context?: Record<string, unknown>) => Promise<Response>;
+  /** The compiled GraphQL schema */
+  schema: GraphQLSchema;
+}
+/**
+ * Factory function type for creating GraphQL servers
+ */
+type ServerFactory = (options: CoreServerOptions) => Promise<CoreServerInstance>;
+//#endregion
+export { CoreSecurityConfig, CoreServerInstance, CoreServerOptions, ServerFactory };