nitro-graphql 2.0.0-beta.37 → 2.0.0-beta.38

package/dist/core/scanning/resolvers.mjs

@@ -0,0 +1,58 @@
+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
+*/
+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 { scanResolversCore };

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

@@ -0,0 +1,14 @@
+import { ScanContext, ScanResult } from "../types/scanning.mjs";
+
+//#region src/core/scanning/schemas.d.ts
+
+/**
+ * Scan for GraphQL schema files (.graphql) 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,64 @@
+import { GRAPHQL_GLOB_PATTERN } from "../constants.mjs";
+import { extractPaths, scanWithLayers } from "./common.mjs";
+import { relative } from "pathe";
+
+//#region src/core/scanning/schemas.ts
+/**
+* Scan for GraphQL schema files (.graphql) in server directory
+*/
+async function scanSchemasCore(ctx) {
+	const warnings = [];
+	const errors = [];
+	try {
+		const serverDirRelative = relative(ctx.rootDir, ctx.serverDir);
+		return {
+			items: extractPaths(await scanWithLayers(ctx, {
+				mainDir: ctx.rootDir,
+				mainSubDir: serverDirRelative,
+				layerDirs: ctx.layerServerDirs,
+				layerSubDir: "graphql",
+				pattern: 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 scanWithLayers(ctx, {
+				mainDir: ctx.rootDir,
+				mainSubDir: serverDirRelative,
+				layerDirs: ctx.layerServerDirs,
+				layerSubDir: "graphql",
+				pattern: "**/*.{graphql,gql}"
+			})),
+			warnings,
+			errors
+		};
+	} catch (error) {
+		errors.push(`GraphQL scanning error: ${error}`);
+		return {
+			items: [],
+			warnings,
+			errors
+		};
+	}
+}
+
+//#endregion
+export { scanGraphqlCore, scanSchemasCore };

package/dist/{utils/schema-builder.d.mts → core/schema/builder.d.mts}

@@ -1,7 +1,7 @@
 import { DirectiveDefinition } from "../types/define.mjs";
 import { GraphQLSchema } from "graphql";
 
-//#region src/utils/schema-builder.d.ts
+//#region src/core/schema/builder.d.ts
 
 /**
  * Schema definition from virtual module
@@ -44,5 +44,10 @@ interface CreateMergedSchemaOptions {
  * Supports Apollo Federation when enabled
  */
 declare function createMergedSchema(options: CreateMergedSchemaOptions): Promise<GraphQLSchema>;
+/**
+ * Build a GraphQL schema from file paths (CLI usage)
+ * Reads schema files, merges them, and builds an executable schema
+ */
+declare function buildGraphQLSchema(schemaPaths: string[]): Promise<GraphQLSchema | null>;
 //#endregion
-export { CreateMergedSchemaOptions, DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition, createMergedSchema };
+export { CreateMergedSchemaOptions, DirectiveWrapper, ModuleConfig, ResolverDefinition, SchemaDefinition, buildGraphQLSchema, createMergedSchema };

package/dist/{utils/schema-builder.mjs → core/schema/builder.mjs}

@@ -1,10 +1,11 @@
 import { loadFederationSupport, warnFederationUnavailable } from "./federation.mjs";
 import { consola as consola$1 } from "consola";
-import { parse } from "graphql";
+import { buildSchema, parse, print } from "graphql";
+import { readFileSync } from "node:fs";
 import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
 import { makeExecutableSchema } from "@graphql-tools/schema";
 
-//#region src/utils/schema-builder.ts
+//#region src/core/schema/builder.ts
 /**
 * Create a merged GraphQL schema from schemas, resolvers, and directives
 * Supports Apollo Federation when enabled
@@ -46,6 +47,24 @@ async function createMergedSchema(options) {
 		throw error;
 	}
 }
+/**
+* Build a GraphQL schema from file paths (CLI usage)
+* Reads schema files, merges them, and builds an executable schema
+*/
+async function buildGraphQLSchema(schemaPaths) {
+	if (schemaPaths.length === 0) return null;
+	try {
+		const mergedTypeDefs = mergeTypeDefs(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 { createMergedSchema };
+export { buildGraphQLSchema, createMergedSchema };

package/dist/{utils → core/schema}/federation.d.mts

@@ -1,14 +1,19 @@
 import { DocumentNode, GraphQLSchema } from "graphql";
 
-//#region src/utils/federation.d.ts
+//#region src/core/schema/federation.d.ts
 
 /**
- * Type for buildSubgraphSchema function from @apollo/subgraph
+ * Module type for buildSubgraphSchema
  */
-type BuildSubgraphSchemaFn = (options: {
+interface SubgraphModule {
   typeDefs: DocumentNode;
-  resolvers: Record<string, unknown>;
-}) => GraphQLSchema;
+  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.

package/dist/{utils → core/schema}/federation.mjs

@@ -1,7 +1,7 @@
 import { LOG_TAG } from "../constants.mjs";
 import { consola as consola$1 } from "consola";
 
-//#region src/utils/federation.ts
+//#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

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

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

package/dist/core/schema/index.mjs

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

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

@@ -0,0 +1,58 @@
+import { CoreConfig, CoreContext, CoreLogger } from "./config.mjs";
+import { ScanContext, ScanResult, ScannedResolver } from "./scanning.mjs";
+import "./index.mjs";
+
+//#region src/core/types/adapter.d.ts
+
+/**
+ * Framework adapter interface
+ * Adapters convert framework-specific types to core types
+ */
+interface FrameworkAdapter<TFramework = unknown> {
+  /** Adapter name for logging */
+  readonly name: string;
+  /** Create core config from framework instance */
+  createCoreConfig: (framework: TFramework) => CoreConfig;
+  /** Create core context from framework instance */
+  createCoreContext: (framework: TFramework) => CoreContext;
+  /** Create scan context from framework instance */
+  createScanContext: (framework: TFramework) => ScanContext;
+  /** Get framework logger adapted to CoreLogger interface */
+  getLogger: (framework: TFramework) => CoreLogger;
+}
+/**
+ * Scan adapter interface
+ * Provides high-level scanning operations using the framework adapter
+ */
+interface ScanAdapter<TFramework = unknown> {
+  /** Scan for GraphQL schema files */
+  scanSchemas: (framework: TFramework) => Promise<ScanResult<string>>;
+  /** Scan for GraphQL files (schemas + operations) */
+  scanGraphql: (framework: TFramework) => Promise<ScanResult<string>>;
+  /** Scan for resolver files */
+  scanResolvers: (framework: TFramework) => Promise<ScanResult<ScannedResolver>>;
+  /** Scan for directive files */
+  scanDirectives: (framework: TFramework) => Promise<ScanResult<ScannedResolver>>;
+  /** Scan for client documents */
+  scanDocuments: (framework: TFramework) => Promise<ScanResult<string>>;
+}
+/**
+ * Codegen adapter interface
+ * Provides high-level codegen operations using the framework adapter
+ */
+interface CodegenAdapter<TFramework = unknown> {
+  /** Generate server types */
+  generateServerTypes: (framework: TFramework, options?: {
+    silent?: boolean;
+  }) => Promise<void>;
+  /** Generate client types */
+  generateClientTypes: (framework: TFramework, options?: {
+    silent?: boolean;
+  }) => Promise<void>;
+}
+/**
+ * Combined full adapter interface
+ */
+interface FullFrameworkAdapter<TFramework = unknown> extends FrameworkAdapter<TFramework>, ScanAdapter<TFramework>, CodegenAdapter<TFramework> {}
+//#endregion
+export { CodegenAdapter, FrameworkAdapter, FullFrameworkAdapter, ScanAdapter };

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

@@ -0,0 +1,133 @@
+import { Source } from "@graphql-tools/utils";
+import { GraphQLSchema } from "graphql";
+
+//#region src/core/types/codegen.d.ts
+
+/**
+ * Scalar type mapping (can be string or input/output object)
+ */
+type ScalarType = string | {
+  input: string;
+  output: string;
+};
+/**
+ * Server codegen configuration
+ */
+interface ServerCodegenConfig {
+  scalars?: Record<string, ScalarType>;
+  defaultScalarType?: string;
+  defaultMapper?: string;
+  contextType?: string;
+  maybeValue?: string;
+  inputMaybeValue?: string;
+  declarationKind?: string;
+  enumsAsTypes?: boolean;
+  federation?: boolean;
+  [key: string]: unknown;
+}
+/**
+ * Client codegen configuration
+ */
+interface ClientCodegenConfig {
+  emitLegacyCommonJSImports?: boolean;
+  useTypeImports?: boolean;
+  enumsAsTypes?: boolean;
+  strictScalars?: boolean;
+  maybeValue?: string;
+  inputMaybeValue?: string;
+  documentMode?: string;
+  pureMagicComment?: boolean;
+  dedupeOperationSuffix?: boolean;
+  rawRequest?: boolean;
+  scalars?: Record<string, ScalarType>;
+  typedDocumentNode?: boolean;
+  [key: string]: unknown;
+}
+/**
+ * SDK codegen configuration
+ */
+interface SdkCodegenConfig extends ClientCodegenConfig {
+  [key: string]: unknown;
+}
+/**
+ * Input for server type generation
+ */
+interface ServerCodegenInput {
+  /** GraphQL framework name */
+  framework: string;
+  /** Parsed GraphQL schema */
+  schema: GraphQLSchema;
+  /** Server codegen configuration */
+  config?: ServerCodegenConfig;
+  /** Whether federation is enabled */
+  federationEnabled?: boolean;
+  /** Output filename (optional) */
+  outputPath?: string;
+}
+/**
+ * Result of server type generation
+ */
+interface ServerCodegenResult {
+  /** Generated TypeScript types content */
+  types: string;
+  /** Printed GraphQL schema */
+  schemaString: string;
+}
+/**
+ * Input for client type generation
+ */
+interface ClientCodegenInput {
+  /** Parsed GraphQL schema */
+  schema: GraphQLSchema;
+  /** Loaded GraphQL documents */
+  documents: Source[];
+  /** Client codegen configuration */
+  config?: ClientCodegenConfig;
+  /** SDK codegen configuration */
+  sdkConfig?: SdkCodegenConfig;
+  /** Output filename (optional) */
+  outputPath?: string;
+  /** Service name for external services */
+  serviceName?: string;
+  /** Virtual types import path */
+  virtualTypesPath?: string;
+  /** Generation options */
+  options?: {
+    silent?: boolean;
+    isInitial?: boolean;
+  };
+}
+/**
+ * Result of client type generation
+ */
+interface ClientCodegenResult {
+  /** Generated TypeScript types content */
+  types: string;
+  /** Generated SDK content */
+  sdk: string;
+}
+/**
+ * External service configuration for codegen
+ */
+interface ExternalServiceCodegenConfig {
+  name: string;
+  schema: string | string[];
+  endpoint: string;
+  headers?: Record<string, string> | (() => Record<string, string>);
+  documents?: string[];
+  downloadSchema?: boolean | 'once' | 'always' | 'manual';
+  downloadPath?: string;
+  codegen?: {
+    client?: ClientCodegenConfig;
+    clientSDK?: SdkCodegenConfig;
+  };
+}
+/**
+ * Schema loading options
+ */
+interface SchemaLoadOptions {
+  headers?: Record<string, string>;
+  loaders?: unknown[];
+}
+//#endregion
+export { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig, ScalarType, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult };

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

@@ -0,0 +1,212 @@
+import { GraphQLFramework } from "../constants.mjs";
+
+//#region src/core/types/config.d.ts
+
+/**
+ * Core logger interface
+ * Abstracts logging functionality for framework independence
+ */
+interface CoreLogger {
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  success: (message: string, ...args: unknown[]) => void;
+  debug: (message: string, ...args: unknown[]) => void;
+}
+/**
+ * GraphQL codegen configuration
+ */
+interface CoreCodegenConfig {
+  /** Server-side codegen options */
+  server?: Record<string, unknown>;
+  /** Client-side codegen options */
+  client?: Record<string, unknown>;
+  /** Client SDK codegen options */
+  clientSDK?: Record<string, unknown>;
+}
+/**
+ * Security configuration options
+ */
+interface CoreSecurityConfig {
+  /** Enable/disable GraphQL introspection */
+  introspection?: boolean;
+  /** Enable/disable GraphQL playground */
+  playground?: boolean;
+  /** Enable/disable error masking in responses */
+  maskErrors?: boolean;
+  /** Disable field suggestions in error messages */
+  disableSuggestions?: boolean;
+}
+/**
+ * External GraphQL service configuration
+ */
+interface CoreExternalService {
+  /** Unique service name */
+  name: string;
+  /** GraphQL schema URL or file path */
+  schema: string;
+  /** GraphQL endpoint URL */
+  endpoint: string;
+  /** Headers for schema introspection */
+  headers?: Record<string, string> | (() => Record<string, string>);
+  /** Document patterns for this service */
+  documents?: string[];
+  /** Service-specific path overrides */
+  paths?: {
+    sdk?: string;
+    types?: string;
+    ofetch?: string;
+  };
+}
+/**
+ * Apollo Federation configuration
+ */
+interface CoreFederationConfig {
+  /** Enable federation support */
+  enabled?: boolean;
+  /** Service name for federation */
+  serviceName?: string;
+}
+/**
+ * Path configuration with placeholders
+ */
+interface CorePathsConfig {
+  /** Server GraphQL directory (default: 'server/graphql') */
+  serverGraphql?: string;
+  /** Client GraphQL directory (default: 'app/graphql' or 'graphql') */
+  clientGraphql?: string;
+  /** Build directory (default: '.nitro' or '.nuxt') */
+  buildDir?: string;
+  /** Types output directory (default: '{buildDir}/types') */
+  typesDir?: string;
+}
+/**
+ * Scaffold file generation configuration
+ */
+interface CoreScaffoldConfig {
+  /** Master switch for all scaffold files */
+  enabled?: boolean;
+  /** Generate graphql.config.ts */
+  graphqlConfig?: boolean | string;
+  /** Generate server schema.ts */
+  serverSchema?: boolean | string;
+  /** Generate server config.ts */
+  serverConfig?: boolean | string;
+  /** Generate server context.d.ts */
+  serverContext?: boolean | string;
+}
+/**
+ * Type generation configuration
+ */
+interface CoreTypesConfig {
+  /** Master switch for type generation */
+  enabled?: boolean;
+  /** Server types output path */
+  server?: boolean | string;
+  /** Client types output path */
+  client?: boolean | string;
+  /** External service types output path */
+  external?: boolean | string;
+}
+/**
+ * SDK generation configuration
+ */
+interface CoreSdkConfig {
+  /** Master switch for SDK generation */
+  enabled?: boolean;
+  /** Main SDK output path */
+  main?: boolean | string;
+  /** External service SDK output path */
+  external?: boolean | string;
+}
+/**
+ * Client utilities configuration
+ */
+interface CoreClientUtilsConfig {
+  /** Master switch for client utilities */
+  enabled?: boolean;
+  /** Index file output path */
+  index?: boolean | string;
+  /** Ofetch client output path */
+  ofetch?: boolean | string;
+}
+/**
+ * Core GraphQL options
+ * Framework-agnostic GraphQL configuration
+ */
+interface CoreGraphQLOptions {
+  /** GraphQL framework to use */
+  framework?: GraphQLFramework;
+  /** GraphQL endpoint path */
+  endpoint?: string;
+  /** Codegen configuration */
+  codegen?: CoreCodegenConfig;
+  /** Security configuration */
+  security?: CoreSecurityConfig;
+  /** External GraphQL services */
+  externalServices?: CoreExternalService[];
+  /** Apollo Federation configuration */
+  federation?: CoreFederationConfig;
+  /** Path configuration */
+  paths?: CorePathsConfig;
+  /** Scaffold file configuration */
+  scaffold?: false | CoreScaffoldConfig;
+  /** Type generation configuration */
+  types?: false | CoreTypesConfig;
+  /** SDK generation configuration */
+  sdk?: false | CoreSdkConfig;
+  /** Client utilities configuration */
+  clientUtils?: false | CoreClientUtilsConfig;
+}
+/**
+ * Core configuration
+ * Main configuration interface that replaces Nitro-specific options
+ */
+interface CoreConfig {
+  /** Root directory of the project */
+  rootDir: string;
+  /** Build output directory */
+  buildDir: string;
+  /** Server GraphQL directory */
+  serverDir: string;
+  /** Client GraphQL directory */
+  clientDir: string;
+  /** Types output directory */
+  typesDir: string;
+  /** GraphQL framework to use */
+  framework: GraphQLFramework;
+  /** Whether running in Nuxt context */
+  isNuxt: boolean;
+  /** Whether running in development mode */
+  isDev: boolean;
+  /** GraphQL options */
+  graphqlOptions: CoreGraphQLOptions;
+  /** Logger instance */
+  logger: CoreLogger;
+  /** Patterns to ignore during scanning */
+  ignorePatterns: string[];
+  /** Layer server directories (Nuxt) */
+  layerServerDirs?: string[];
+  /** Layer app directories (Nuxt) */
+  layerAppDirs?: string[];
+}
+/**
+ * Core context for runtime operations
+ * Holds resolved configuration and state
+ */
+interface CoreContext {
+  /** Resolved configuration */
+  config: CoreConfig;
+  /** GraphQL build directory */
+  graphqlBuildDir: string;
+  /** Watch directories for file watching */
+  watchDirs: string[];
+  /** Relative directory paths */
+  dir: {
+    build: string;
+    client: string;
+    server: string;
+  };
+}
+//#endregion
+export { CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig };

package/dist/{types → core/types}/define.d.mts

@@ -1,12 +1,8 @@
 import { GraphQLSchema } from "graphql";
-import { ApolloServerOptions } from "@apollo/server";
-import { H3Event } from "nitro/h3";
-import { YogaServerOptions } from "graphql-yoga";
-import { NPMConfig } from "#graphql/server";
 
-//#region src/types/define.d.ts
+//#region src/core/types/define.d.ts
+
 type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
-type DefineServerConfig<T extends NPMConfig = NPMConfig> = T['framework'] extends 'graphql-yoga' ? Partial<YogaServerOptions<H3Event, Partial<H3Event>>> : T['framework'] extends 'apollo-server' ? Partial<ApolloServerOptions<H3Event>> : Partial<YogaServerOptions<H3Event, Partial<H3Event>>> | Partial<ApolloServerOptions<H3Event>>;
 type DirectiveLocationName = 'QUERY' | 'MUTATION' | 'SUBSCRIPTION' | 'FIELD' | 'FRAGMENT_DEFINITION' | 'FRAGMENT_SPREAD' | 'INLINE_FRAGMENT' | 'VARIABLE_DEFINITION' | 'SCHEMA' | 'SCALAR' | 'OBJECT' | 'FIELD_DEFINITION' | 'ARGUMENT_DEFINITION' | 'INTERFACE' | 'UNION' | 'ENUM' | 'ENUM_VALUE' | 'INPUT_OBJECT' | 'INPUT_FIELD_DEFINITION';
 type GraphQLScalarType = 'String' | 'Int' | 'Float' | 'Boolean' | 'ID' | 'JSON' | 'DateTime';
 type GraphQLBaseType = GraphQLScalarType | (string & {});
@@ -46,4 +42,4 @@ interface DefineDirectiveConfig {
   transformer?: (schema: GraphQLSchema) => GraphQLSchema;
 }
 //#endregion
-export { DefineDirectiveConfig, DefineServerConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType };
+export { DefineDirectiveConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType };

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

@@ -0,0 +1,5 @@
+import { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, ExternalServiceCodegenConfig, ScalarType, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult } from "./codegen.mjs";
+import { CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig } from "./config.mjs";
+import { DefineDirectiveConfig, DirectiveArgument, DirectiveDefinition, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType } from "./define.mjs";
+import { ResolverImport, ScanContext, ScanResult, ScannedFile, ScannedResolver } from "./scanning.mjs";
+export { ClientCodegenConfig, ClientCodegenInput, ClientCodegenResult, CoreClientUtilsConfig, CoreCodegenConfig, CoreConfig, CoreContext, CoreExternalService, CoreFederationConfig, CoreGraphQLOptions, CoreLogger, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig, DefineDirectiveConfig, DirectiveArgument, DirectiveDefinition, ExternalServiceCodegenConfig, Flatten, GraphQLArgumentType, GraphQLBaseType, GraphQLScalarType, ResolverImport, ScalarType, ScanContext, ScanResult, ScannedFile, ScannedResolver, SchemaLoadOptions, SdkCodegenConfig, ServerCodegenConfig, ServerCodegenInput, ServerCodegenResult };