nitro-graphql 2.0.0-beta.72 → 2.0.0-beta.73

package/dist/core/utils/runtime.mjs

@@ -1,5 +1,4 @@
-import { basename, dirname, join, resolve } from "pathe";
-import { existsSync, mkdirSync, promises, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { pathToFileURL as pathToFileURL$1 } from "node:url";
 //#region src/core/utils/runtime.ts
 /**
@@ -10,53 +9,24 @@ import { pathToFileURL as pathToFileURL$1 } from "node:url";
 */
 const _globalThis = globalThis;
 /**
-* Read file contents asynchronously
-*/
-async function readFile(path) {
-	return promises.readFile(path, "utf-8");
-}
-/**
 * Read file contents synchronously
 */
 function readFileSync_(path) {
 	return readFileSync(path, "utf-8");
 }
 /**
-* Write file contents asynchronously
-*/
-async function writeFile(path, content) {
-	await promises.writeFile(path, content, "utf-8");
-}
-/**
 * Write file contents synchronously
 */
 function writeFileSync_(path, content) {
 	writeFileSync(path, content, "utf-8");
 }
 /**
-* Check if file/directory exists asynchronously
-*/
-async function exists(path) {
-	try {
-		await promises.access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-/**
 * Check if file/directory exists synchronously
 */
 function existsSync_(path) {
 	return existsSync(path);
 }
 /**
-* Create directory recursively asynchronously
-*/
-async function mkdir(path) {
-	await promises.mkdir(path, { recursive: true });
-}
-/**
 * Create directory recursively synchronously
 */
 function mkdirSync_(path) {
@@ -93,17 +63,5 @@ function onSignal(signal, handler) {
 	if (_globalThis.Deno) _globalThis.Deno.addSignalListener(signal, handler);
 	else process.on(signal, handler);
 }
-/**
-* Read directory contents
-*/
-async function readdir(path) {
-	return promises.readdir(path);
-}
-/**
-* Get file/directory stats
-*/
-async function stat(path) {
-	return promises.stat(path);
-}
 //#endregion
-export { basename, dirname, exists, existsSync_, exit, getCwd, join, mkdir, mkdirSync_, onSignal, pathToFileURL, readFile, readFileSync_, readdir, resolve, stat, writeFile, writeFileSync_ };
+export { existsSync_, exit, getCwd, mkdirSync_, onSignal, pathToFileURL, readFileSync_, writeFileSync_ };

package/dist/core/utils/string.d.mts

@@ -0,0 +1,10 @@
+//#region src/core/utils/string.d.ts
+/**
+ * Shared string utilities
+ */
+/**
+ * Capitalize the first character of a string (PascalCase first letter)
+ */
+declare function capitalize(str: string): string;
+//#endregion
+export { capitalize };

package/dist/core/utils/string.mjs

@@ -0,0 +1,12 @@
+//#region src/core/utils/string.ts
+/**
+* Shared string utilities
+*/
+/**
+* Capitalize the first character of a string (PascalCase first letter)
+*/
+function capitalize(str) {
+	return str.charAt(0).toUpperCase() + str.slice(1);
+}
+//#endregion
+export { capitalize };

package/dist/core/watcher/create-watcher.d.mts

@@ -0,0 +1,103 @@
+import { FSWatcher } from "chokidar";
+
+//#region src/core/watcher/create-watcher.d.ts
+/**
+ * Configuration for core watcher
+ */
+interface CoreWatcherConfig {
+  /** Directories to watch */
+  watchDirs: string[];
+  /** Server directory path (to classify changes) */
+  serverDir: string;
+  /** Debounce delay in ms (default: 150) */
+  debounceMs?: number;
+  /** Persistent watcher (default: true) */
+  persistent?: boolean;
+  /** Ignore initial scan (default: true) */
+  ignoreInitial?: boolean;
+  /** Use polling mode (default: false, but auto-enabled in CI/test environments) */
+  usePolling?: boolean;
+}
+/**
+ * Callbacks for watcher events
+ */
+interface CoreWatcherCallbacks {
+  /** Called when server files change (schemas, resolvers, directives) */
+  onServerChange: () => Promise<void>;
+  /** Called when client files change (documents only) */
+  onClientChange: () => Promise<void>;
+  /** Called when watcher is ready */
+  onReady?: () => void;
+  /** Called on watcher error */
+  onError?: (error: unknown) => void;
+}
+/**
+ * File type classification
+ */
+type FileType = 'graphql' | 'resolver' | 'directive' | null;
+/**
+ * Change type classification
+ */
+type ChangeType = 'server' | 'client' | null;
+/**
+ * Check if a file is a GraphQL-related file
+ */
+declare function getFileType(path: string): FileType;
+/**
+ * Check if a file should be watched
+ */
+declare function isWatchableFile(path: string): boolean;
+/**
+ * Classify a file change as server or client
+ */
+declare function classifyChange(path: string, serverDir: string): ChangeType;
+declare function createIgnoredFunction(): (path: string) => boolean;
+/**
+ * Check if a path should be skipped (generated files)
+ */
+declare function shouldSkipPath(path: string): boolean;
+/**
+ * Create a core file watcher
+ *
+ * This is the shared watcher used by both Nitro and CLI.
+ * Framework-specific actions are passed as callbacks.
+ *
+ * @example
+ * ```typescript
+ * // In Nitro
+ * const watcher = createCoreWatcher(
+ *   { watchDirs, serverDir: nitro.graphql.serverDir },
+ *   {
+ *     onServerChange: async () => {
+ *       await performGraphQLScan(nitro, { silent: true, isRescan: true })
+ *       await generateServerTypes(nitro, { silent: true })
+ *       await nitro.hooks.callHook('dev:reload')
+ *     },
+ *     onClientChange: async () => {
+ *       await generateClientTypes(nitro, { silent: true })
+ *     },
+ *   }
+ * )
+ *
+ * // In CLI
+ * const watcher = createCoreWatcher(
+ *   { watchDirs, serverDir: ctx.config.serverDir },
+ *   {
+ *     onServerChange: async () => {
+ *       await generateAll(ctx, { silent: true })
+ *       await reloadHandler()
+ *     },
+ *     onClientChange: async () => {
+ *       await generateClient(ctx, { silent: true })
+ *     },
+ *   }
+ * )
+ * ```
+ */
+declare function createCoreWatcher(config: CoreWatcherConfig, callbacks: CoreWatcherCallbacks): FSWatcher;
+/**
+ * Close a watcher safely
+ */
+declare function closeWatcher(watcher: FSWatcher): Promise<void>;
+//#endregion
+export { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/core/watcher/create-watcher.mjs

@@ -0,0 +1,143 @@
+import { DEFAULT_IGNORE_PATTERNS, DIRECTIVE_EXTENSIONS, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
+import { watch } from "chokidar";
+import { debounce } from "perfect-debounce";
+//#region src/core/watcher/create-watcher.ts
+const BACKSLASH_RE = /\\/g;
+/**
+* Check if a file is a GraphQL-related file
+*/
+function getFileType(path) {
+	if (GRAPHQL_EXTENSIONS.some((ext) => path.endsWith(ext))) return "graphql";
+	if (RESOLVER_EXTENSIONS.some((ext) => path.endsWith(ext))) return "resolver";
+	if (DIRECTIVE_EXTENSIONS.some((ext) => path.endsWith(ext))) return "directive";
+	return null;
+}
+/**
+* Check if a file should be watched
+*/
+function isWatchableFile(path) {
+	return getFileType(path) !== null;
+}
+/**
+* Classify a file change as server or client
+*/
+function classifyChange(path, serverDir) {
+	const fileType = getFileType(path);
+	if (!fileType) return null;
+	if (fileType === "resolver" || fileType === "directive") return "server";
+	if (fileType === "graphql") {
+		const normalizedPath = path.replace(BACKSLASH_RE, "/");
+		const normalizedServerDir = serverDir.replace(BACKSLASH_RE, "/");
+		if (normalizedPath.includes(normalizedServerDir)) return "server";
+		if (normalizedPath.includes("/server/graphql/") || normalizedPath.includes("\\server\\graphql\\")) return "server";
+		return "client";
+	}
+	return null;
+}
+/**
+* Create the ignored function for chokidar
+* Filters out non-GraphQL files and system directories
+*/
+const GLOB_STAR_RE = /\*\*/g;
+const SINGLE_STAR_RE = /\*/g;
+function createIgnoredFunction() {
+	const ignoredDirs = DEFAULT_IGNORE_PATTERNS.map((p) => p.replace(GLOB_STAR_RE, "").replace(SINGLE_STAR_RE, ""));
+	return (path) => {
+		if (ignoredDirs.some((dir) => path.includes(dir))) return true;
+		if (!(path.split("/").pop() || "").includes(".") || path.endsWith("/")) return false;
+		return !isWatchableFile(path);
+	};
+}
+/**
+* Check if a path should be skipped (generated files)
+*/
+function shouldSkipPath(path) {
+	return path.includes("/sdk.ts") || path.includes("/sdk.js") || path.endsWith("/config.ts");
+}
+/**
+* Create a core file watcher
+*
+* This is the shared watcher used by both Nitro and CLI.
+* Framework-specific actions are passed as callbacks.
+*
+* @example
+* ```typescript
+* // In Nitro
+* const watcher = createCoreWatcher(
+*   { watchDirs, serverDir: nitro.graphql.serverDir },
+*   {
+*     onServerChange: async () => {
+*       await performGraphQLScan(nitro, { silent: true, isRescan: true })
+*       await generateServerTypes(nitro, { silent: true })
+*       await nitro.hooks.callHook('dev:reload')
+*     },
+*     onClientChange: async () => {
+*       await generateClientTypes(nitro, { silent: true })
+*     },
+*   }
+* )
+*
+* // In CLI
+* const watcher = createCoreWatcher(
+*   { watchDirs, serverDir: ctx.config.serverDir },
+*   {
+*     onServerChange: async () => {
+*       await generateAll(ctx, { silent: true })
+*       await reloadHandler()
+*     },
+*     onClientChange: async () => {
+*       await generateClient(ctx, { silent: true })
+*     },
+*   }
+* )
+* ```
+*/
+function createCoreWatcher(config, callbacks) {
+	const { watchDirs, serverDir, debounceMs = 150, persistent = true, ignoreInitial = true, usePolling } = config;
+	const shouldUsePolling = usePolling ?? (process.env.CI === "true" || process.env.VITE_TEST === "true");
+	const watcher = watch(watchDirs, {
+		persistent,
+		ignoreInitial,
+		ignored: createIgnoredFunction(),
+		usePolling: shouldUsePolling,
+		interval: shouldUsePolling ? 100 : void 0,
+		awaitWriteFinish: shouldUsePolling ? {
+			stabilityThreshold: 100,
+			pollInterval: 50
+		} : false
+	});
+	const pending = {
+		server: false,
+		client: false
+	};
+	async function processChanges() {
+		const changes = { ...pending };
+		pending.server = pending.client = false;
+		try {
+			if (changes.server) await callbacks.onServerChange();
+			else if (changes.client) await callbacks.onClientChange();
+		} catch (error) {
+			callbacks.onError?.(error);
+		}
+	}
+	const debouncedProcess = debounce(processChanges, debounceMs);
+	watcher.on("all", (_, path) => {
+		if (shouldSkipPath(path)) return;
+		const changeType = classifyChange(path, serverDir);
+		if (!changeType) return;
+		if (changeType === "server") pending.server = true;
+		else pending.client = true;
+		debouncedProcess();
+	});
+	if (callbacks.onReady) watcher.on("ready", callbacks.onReady);
+	if (callbacks.onError) watcher.on("error", callbacks.onError);
+	return watcher;
+}
+/**
+* Close a watcher safely
+*/
+async function closeWatcher(watcher) {
+	await watcher.close();
+}
+//#endregion
+export { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

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

@@ -1,107 +1,2 @@
-import { FSWatcher } from "chokidar";
-
-//#region src/core/watcher/index.d.ts
-/**
- * Configuration for core watcher
- */
-interface CoreWatcherConfig {
-  /** Directories to watch */
-  watchDirs: string[];
-  /** Server directory path (to classify changes) */
-  serverDir: string;
-  /** Debounce delay in ms (default: 150) */
-  debounceMs?: number;
-  /** Persistent watcher (default: true) */
-  persistent?: boolean;
-  /** Ignore initial scan (default: true) */
-  ignoreInitial?: boolean;
-  /** Use polling mode (default: false, but auto-enabled in CI/test environments) */
-  usePolling?: boolean;
-}
-/**
- * Callbacks for watcher events
- */
-interface CoreWatcherCallbacks {
-  /** Called when server files change (schemas, resolvers, directives) */
-  onServerChange: () => Promise<void>;
-  /** Called when client files change (documents only) */
-  onClientChange: () => Promise<void>;
-  /** Called when watcher is ready */
-  onReady?: () => void;
-  /** Called on watcher error */
-  onError?: (error: unknown) => void;
-}
-/**
- * File type classification
- */
-type FileType = 'graphql' | 'resolver' | 'directive' | null;
-/**
- * Change type classification
- */
-type ChangeType = 'server' | 'client' | null;
-/**
- * Check if a file is a GraphQL-related file
- */
-declare function getFileType(path: string): FileType;
-/**
- * Check if a file should be watched
- */
-declare function isWatchableFile(path: string): boolean;
-/**
- * Classify a file change as server or client
- */
-declare function classifyChange(path: string, serverDir: string): ChangeType;
-/**
- * Create the ignored function for chokidar
- * Filters out non-GraphQL files and system directories
- */
-declare function createIgnoredFunction(): (path: string) => boolean;
-/**
- * Check if a path should be skipped (generated files)
- */
-declare function shouldSkipPath(path: string): boolean;
-/**
- * Create a core file watcher
- *
- * This is the shared watcher used by both Nitro and CLI.
- * Framework-specific actions are passed as callbacks.
- *
- * @example
- * ```typescript
- * // In Nitro
- * const watcher = createCoreWatcher(
- *   { watchDirs, serverDir: nitro.graphql.serverDir },
- *   {
- *     onServerChange: async () => {
- *       await performGraphQLScan(nitro, { silent: true, isRescan: true })
- *       await generateServerTypes(nitro, { silent: true })
- *       await nitro.hooks.callHook('dev:reload')
- *     },
- *     onClientChange: async () => {
- *       await generateClientTypes(nitro, { silent: true })
- *     },
- *   }
- * )
- *
- * // In CLI
- * const watcher = createCoreWatcher(
- *   { watchDirs, serverDir: ctx.config.serverDir },
- *   {
- *     onServerChange: async () => {
- *       await generateAll(ctx, { silent: true })
- *       await reloadHandler()
- *     },
- *     onClientChange: async () => {
- *       await generateClient(ctx, { silent: true })
- *     },
- *   }
- * )
- * ```
- */
-declare function createCoreWatcher(config: CoreWatcherConfig, callbacks: CoreWatcherCallbacks): FSWatcher;
-/**
- * Close a watcher safely
- */
-declare function closeWatcher(watcher: FSWatcher): Promise<void>;
-//#endregion
-export { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };
+import { ChangeType, CoreWatcherCallbacks, CoreWatcherConfig, FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath } from "./create-watcher.mjs";
+export { type ChangeType, type CoreWatcherCallbacks, type CoreWatcherConfig, type FileType, classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/core/watcher/index.mjs

@@ -1,140 +1,2 @@
-import { DIRECTIVE_EXTENSIONS, GRAPHQL_EXTENSIONS, RESOLVER_EXTENSIONS } from "../constants.mjs";
-import { watch } from "chokidar";
-import { debounce } from "perfect-debounce";
-//#region src/core/watcher/index.ts
-const BACKSLASH_RE = /\\/g;
-/**
-* Check if a file is a GraphQL-related file
-*/
-function getFileType(path) {
-	if (GRAPHQL_EXTENSIONS.some((ext) => path.endsWith(ext))) return "graphql";
-	if (RESOLVER_EXTENSIONS.some((ext) => path.endsWith(ext))) return "resolver";
-	if (DIRECTIVE_EXTENSIONS.some((ext) => path.endsWith(ext))) return "directive";
-	return null;
-}
-/**
-* Check if a file should be watched
-*/
-function isWatchableFile(path) {
-	return getFileType(path) !== null;
-}
-/**
-* Classify a file change as server or client
-*/
-function classifyChange(path, serverDir) {
-	const fileType = getFileType(path);
-	if (!fileType) return null;
-	if (fileType === "resolver" || fileType === "directive") return "server";
-	if (fileType === "graphql") {
-		const normalizedPath = path.replace(BACKSLASH_RE, "/");
-		const normalizedServerDir = serverDir.replace(BACKSLASH_RE, "/");
-		if (normalizedPath.includes(normalizedServerDir)) return "server";
-		if (normalizedPath.includes("/server/graphql/") || normalizedPath.includes("\\server\\graphql\\")) return "server";
-		return "client";
-	}
-	return null;
-}
-/**
-* Create the ignored function for chokidar
-* Filters out non-GraphQL files and system directories
-*/
-function createIgnoredFunction() {
-	return (path) => {
-		if (path.includes("/node_modules/") || path.includes("/.git/") || path.includes("/.output/") || path.includes("/.nitro/") || path.includes("/.nuxt/") || path.includes("/.graphql/") || path.includes("/dist/")) return true;
-		if (!(path.split("/").pop() || "").includes(".") || path.endsWith("/")) return false;
-		return !isWatchableFile(path);
-	};
-}
-/**
-* Check if a path should be skipped (generated files)
-*/
-function shouldSkipPath(path) {
-	return path.includes("/sdk.ts") || path.includes("/sdk.js") || path.endsWith("/config.ts");
-}
-/**
-* Create a core file watcher
-*
-* This is the shared watcher used by both Nitro and CLI.
-* Framework-specific actions are passed as callbacks.
-*
-* @example
-* ```typescript
-* // In Nitro
-* const watcher = createCoreWatcher(
-*   { watchDirs, serverDir: nitro.graphql.serverDir },
-*   {
-*     onServerChange: async () => {
-*       await performGraphQLScan(nitro, { silent: true, isRescan: true })
-*       await generateServerTypes(nitro, { silent: true })
-*       await nitro.hooks.callHook('dev:reload')
-*     },
-*     onClientChange: async () => {
-*       await generateClientTypes(nitro, { silent: true })
-*     },
-*   }
-* )
-*
-* // In CLI
-* const watcher = createCoreWatcher(
-*   { watchDirs, serverDir: ctx.config.serverDir },
-*   {
-*     onServerChange: async () => {
-*       await generateAll(ctx, { silent: true })
-*       await reloadHandler()
-*     },
-*     onClientChange: async () => {
-*       await generateClient(ctx, { silent: true })
-*     },
-*   }
-* )
-* ```
-*/
-function createCoreWatcher(config, callbacks) {
-	const { watchDirs, serverDir, debounceMs = 150, persistent = true, ignoreInitial = true, usePolling } = config;
-	const shouldUsePolling = usePolling ?? (process.env.CI === "true" || process.env.VITE_TEST === "true");
-	const watcher = watch(watchDirs, {
-		persistent,
-		ignoreInitial,
-		ignored: createIgnoredFunction(),
-		usePolling: shouldUsePolling,
-		interval: shouldUsePolling ? 100 : void 0,
-		awaitWriteFinish: shouldUsePolling ? {
-			stabilityThreshold: 100,
-			pollInterval: 50
-		} : false
-	});
-	const pending = {
-		server: false,
-		client: false
-	};
-	async function processChanges() {
-		const changes = { ...pending };
-		pending.server = pending.client = false;
-		try {
-			if (changes.server) await callbacks.onServerChange();
-			else if (changes.client) await callbacks.onClientChange();
-		} catch (error) {
-			callbacks.onError?.(error);
-		}
-	}
-	const debouncedProcess = debounce(processChanges, debounceMs);
-	watcher.on("all", (_, path) => {
-		if (shouldSkipPath(path)) return;
-		const changeType = classifyChange(path, serverDir);
-		if (!changeType) return;
-		if (changeType === "server") pending.server = true;
-		else pending.client = true;
-		debouncedProcess();
-	});
-	if (callbacks.onReady) watcher.on("ready", callbacks.onReady);
-	if (callbacks.onError) watcher.on("error", callbacks.onError);
-	return watcher;
-}
-/**
-* Close a watcher safely
-*/
-async function closeWatcher(watcher) {
-	await watcher.close();
-}
-//#endregion
+import { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath } from "./create-watcher.mjs";
 export { classifyChange, closeWatcher, createCoreWatcher, createIgnoredFunction, getFileType, isWatchableFile, shouldSkipPath };

package/dist/define.d.mts

@@ -1,5 +1,7 @@
-import { DefineDirectiveConfig, DefineServerConfig, DirectiveDefinition, Flatten, StandardSchemaV1 } from "./nitro/types.mjs";
-import { PubSubEngine, TypedPubSub, createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/index.mjs";
+import { DefineDirectiveConfig, DirectiveDefinition, Flatten } from "./core/types/define.mjs";
+import { StandardSchemaV1 } from "./core/types/standard-schema.mjs";
+import { DefineServerConfig } from "./nitro/types/define.mjs";
+import { PubSubEngine, TypedPubSub, createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/memory-pubsub.mjs";
 import { NPMConfig, Resolvers, ResolversTypes } from "#graphql/server";
 
 //#region src/define.d.ts

package/dist/define.mjs

@@ -1,4 +1,4 @@
-import { createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/index.mjs";
+import { createPubSub, mapAsyncIterator, withFilter } from "./core/pubsub/memory-pubsub.mjs";
 //#region src/define.ts
 /**
 * Define schema extensions programmatically for GraphQL types.
@@ -308,16 +308,17 @@ function defineDirective(config) {
 	const argsString = args ? `(${args})` : "";
 	const locations = config.locations.join(" | ");
 	const schemaDefinition = `directive @${config.name}${argsString} on ${locations}`;
-	Object.defineProperty(config, "__schema", {
+	const result = {
+		...config,
+		locations: [...config.locations]
+	};
+	Object.defineProperty(result, "__schema", {
 		value: schemaDefinition,
 		enumerable: false,
 		configurable: false,
 		writable: false
 	});
-	return {
-		...config,
-		locations: [...config.locations]
-	};
+	return result;
 }
 //#endregion
 export { createPubSub, defineDirective, defineField, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, mapAsyncIterator, withFilter };

package/dist/index.d.mts

@@ -1,6 +1,7 @@
-import { ExternalGraphQLService, NitroGraphQLOptions, SecurityConfig } from "./nitro/types.mjs";
+import { CoreSecurityConfig } from "./core/types/config.mjs";
+import { ExternalGraphQLService, NitroGraphQLOptions } from "./nitro/types/config.mjs";
 import { NitroAdapter } from "./nitro/adapter.mjs";
-import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/security.mjs";
 import { setupNitroGraphQL } from "./nitro/setup.mjs";
 import graphqlModule from "./nitro/index.mjs";
-export { type ExternalGraphQLService, NitroAdapter, type NitroGraphQLOptions, type SecurityConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };
+export { type ExternalGraphQLService, NitroAdapter, type NitroGraphQLOptions, type CoreSecurityConfig as SecurityConfig, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 import { NitroAdapter } from "./nitro/adapter.mjs";
-import { resolveSecurityConfig } from "./nitro/setup/logging.mjs";
+import { resolveSecurityConfig } from "./nitro/setup/security.mjs";
 import { setupNitroGraphQL } from "./nitro/setup.mjs";
 import graphqlModule from "./nitro/index.mjs";
 export { NitroAdapter, graphqlModule as default, resolveSecurityConfig, setupNitroGraphQL };