nitro-graphql 0.0.1

package/dist/client-watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-watcher.js","names":["nitro: Nitro","options: NitroGraphQLYogaOptions","options: NitroGraphQLOptions"],"sources":["../src/client-watcher.ts"],"sourcesContent":["import type { Nitro } from 'nitropack/types'\nimport type { NitroGraphQLOptions } from './types'\nimport { mkdir, writeFile } from 'node:fs/promises'\nimport { mergeTypeDefs } from '@graphql-tools/merge'\nimport { makeExecutableSchema } from '@graphql-tools/schema'\nimport { consola } from 'consola'\nimport { join } from 'pathe'\n// import { generateClientTypes } from './client-codegen' // Conditionally imported to prevent bundling\nimport { scanGraphQLFiles } from './scanner'\nimport { debounce } from './utils'\n\nconst logger = consola.withTag('graphql')\n\nasync function regenerateClientTypes(nitro: Nitro, options: NitroGraphQLYogaOptions) {\n  try {\n    if (!options.client?.enabled)\n      return\n\n    // Regenerating client types silently\n\n    // Get the server schema\n    const scanResult = await scanGraphQLFiles(nitro)\n    if (scanResult.typeDefs.length === 0) {\n      logger.warn('⚠️  No server schema found for client type generation')\n      return\n    }\n\n    const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs)\n    const schema = makeExecutableSchema({\n      typeDefs: mergedTypeDefs,\n      resolvers: {},\n    })\n\n    // Client GraphQL file patterns\n    const clientPatterns = options.client.watchPatterns || [\n      join(nitro.options.srcDir, '**/*.graphql'),\n      join(nitro.options.srcDir, '**/*.gql'),\n      // Exclude server GraphQL files\n      `!${join(nitro.options.srcDir, 'graphql/**/*')}`,\n    ]\n\n    // Generate client types using dynamic import\n    const { generateClientTypes } = await import('./client-codegen')\n    const generatedTypes = await generateClientTypes(\n      schema,\n      clientPatterns,\n      options.client.config,\n      options.client.outputPath,\n    )\n\n    if (generatedTypes) {\n      const outputPath = options.client.outputPath\n        || join(nitro.options.buildDir, 'types', 'graphql-client.generated.ts')\n\n      const typesDir = join(nitro.options.buildDir, 'types')\n      await mkdir(typesDir, { recursive: true })\n      await writeFile(outputPath, generatedTypes)\n\n      logger.success('✨ Client types updated')\n    }\n  }\n  catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error)\n    logger.error('❌ Client type generation failed:', errorMessage)\n  }\n}\n\nexport async function setupClientWatcher(nitro: Nitro, options: NitroGraphQLOptions) {\n  if (!options.client?.enabled) {\n    logger.info('🚫 Client type generation disabled')\n    return\n  }\n\n  // Setting up client file watcher\n\n  // Client GraphQL patterns\n  const clientPatterns = options.client.watchPatterns || [\n    join(nitro.options.srcDir, '**/*.graphql'),\n    join(nitro.options.srcDir, '**/*.gql'),\n  ]\n\n  const generateClientTypesDebounced = debounce(async () => {\n    await regenerateClientTypes(nitro, options)\n  }, 300)\n\n  const { watch } = await import('chokidar')\n  const { globby } = await import('globby')\n\n  // Find existing client GraphQL files\n  const existingClientFiles = await globby(clientPatterns, {\n    absolute: true,\n    ignore: [join(nitro.options.srcDir, 'graphql/**/*')], // Exclude server files\n  })\n\n  // Client file watching setup complete\n\n  const watchPatterns = existingClientFiles.length > 0 ? existingClientFiles : clientPatterns\n\n  const watcher = watch(watchPatterns, {\n    persistent: true,\n    ignoreInitial: true,\n    ignored: /(^|[/\\\\])\\../,\n    followSymlinks: false,\n    depth: 10,\n    usePolling: true,\n    interval: 1000,\n    binaryInterval: 1000,\n  })\n\n  watcher.on('change', (_path) => {\n    generateClientTypesDebounced()\n  })\n\n  watcher.on('add', (_path) => {\n    generateClientTypesDebounced()\n  })\n\n  watcher.on('unlink', (_path) => {\n    generateClientTypesDebounced()\n  })\n\n  watcher.on('error', (error) => {\n    const errorMessage = error instanceof Error ? error.message : String(error)\n    logger.error('❌ Client watcher error:', errorMessage)\n  })\n\n  nitro.hooks.hook('close', () => {\n    logger.info('🔒 Closing client watcher')\n    watcher.close()\n  })\n\n  // Generate initial types\n  await generateClientTypesDebounced()\n\n  logger.success('✅ Client watcher ready')\n}\n"],"mappings":";;;;;;;;;AAWA,MAAM,SAAS,QAAQ,QAAQ,UAAU;AAEzC,eAAe,sBAAsBA,OAAcC,SAAkC;AACnF,KAAI;AACF,OAAK,QAAQ,QAAQ,QACnB;EAKF,MAAM,aAAa,MAAM,iBAAiB,MAAM;AAChD,MAAI,WAAW,SAAS,WAAW,GAAG;AACpC,UAAO,KAAK,wDAAwD;AACpE;EACD;EAED,MAAM,iBAAiB,cAAc,WAAW,SAAS;EACzD,MAAM,SAAS,qBAAqB;GAClC,UAAU;GACV,WAAW,CAAE;EACd,EAAC;EAGF,MAAM,iBAAiB,QAAQ,OAAO,iBAAiB;GACrD,KAAK,MAAM,QAAQ,QAAQ,eAAe;GAC1C,KAAK,MAAM,QAAQ,QAAQ,WAAW;GAEtC,CAAC,CAAC,EAAE,KAAK,MAAM,QAAQ,QAAQ,eAAe,EAAE;EACjD;EAGD,MAAM,EAAE,qBAAqB,GAAG,MAAM,OAAO;EAC7C,MAAM,iBAAiB,MAAM,oBAC3B,QACA,gBACA,QAAQ,OAAO,QACf,QAAQ,OAAO,WAChB;AAED,MAAI,gBAAgB;GAClB,MAAM,aAAa,QAAQ,OAAO,cAC7B,KAAK,MAAM,QAAQ,UAAU,SAAS,8BAA8B;GAEzE,MAAM,WAAW,KAAK,MAAM,QAAQ,UAAU,QAAQ;AACtD,SAAM,MAAM,UAAU,EAAE,WAAW,KAAM,EAAC;AAC1C,SAAM,UAAU,YAAY,eAAe;AAE3C,UAAO,QAAQ,yBAAyB;EACzC;CACF,SACM,OAAO;EACZ,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO,MAAM,oCAAoC,aAAa;CAC/D;AACF;AAED,eAAsB,mBAAmBD,OAAcE,SAA8B;AACnF,MAAK,QAAQ,QAAQ,SAAS;AAC5B,SAAO,KAAK,qCAAqC;AACjD;CACD;CAKD,MAAM,iBAAiB,QAAQ,OAAO,iBAAiB,CACrD,KAAK,MAAM,QAAQ,QAAQ,eAAe,EAC1C,KAAK,MAAM,QAAQ,QAAQ,WAAW,AACvC;CAED,MAAM,+BAA+B,SAAS,YAAY;AACxD,QAAM,sBAAsB,OAAO,QAAQ;CAC5C,GAAE,IAAI;CAEP,MAAM,EAAE,OAAO,GAAG,MAAM,OAAO;CAC/B,MAAM,EAAE,QAAQ,GAAG,MAAM,OAAO;CAGhC,MAAM,sBAAsB,MAAM,OAAO,gBAAgB;EACvD,UAAU;EACV,QAAQ,CAAC,KAAK,MAAM,QAAQ,QAAQ,eAAe,AAAC;CACrD,EAAC;CAIF,MAAM,gBAAgB,oBAAoB,SAAS,IAAI,sBAAsB;CAE7E,MAAM,UAAU,MAAM,eAAe;EACnC,YAAY;EACZ,eAAe;EACf,SAAS;EACT,gBAAgB;EAChB,OAAO;EACP,YAAY;EACZ,UAAU;EACV,gBAAgB;CACjB,EAAC;AAEF,SAAQ,GAAG,UAAU,CAAC,UAAU;AAC9B,gCAA8B;CAC/B,EAAC;AAEF,SAAQ,GAAG,OAAO,CAAC,UAAU;AAC3B,gCAA8B;CAC/B,EAAC;AAEF,SAAQ,GAAG,UAAU,CAAC,UAAU;AAC9B,gCAA8B;CAC/B,EAAC;AAEF,SAAQ,GAAG,SAAS,CAAC,UAAU;EAC7B,MAAM,eAAe,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM;AAC3E,SAAO,MAAM,2BAA2B,aAAa;CACtD,EAAC;AAEF,OAAM,MAAM,KAAK,SAAS,MAAM;AAC9B,SAAO,KAAK,4BAA4B;AACxC,UAAQ,OAAO;CAChB,EAAC;AAGF,OAAM,8BAA8B;AAEpC,QAAO,QAAQ,yBAAyB;AACzC"}

package/dist/codegen-DWJuLowd.d.ts

@@ -0,0 +1,16 @@
+import { GraphQLSchema } from "graphql";
+
+//#region src/codegen.d.ts
+interface CodegenServerConfig {
+  contextType?: string;
+  scalars?: Record<string, any>;
+  defaultMapper?: string;
+  mapperTypeSuffix?: string;
+  [key: string]: any;
+}
+declare function generateTypes(schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
+//# sourceMappingURL=codegen.d.ts.map
+
+//#endregion
+export { CodegenServerConfig, generateTypes };
+//# sourceMappingURL=codegen-DWJuLowd.d.ts.map

package/dist/codegen-DWJuLowd.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-DWJuLowd.d.ts","names":[],"sources":["../src/codegen.ts"],"sourcesContent":[],"mappings":";;;UAeiB,mBAAA;;EAAA,OAAA,CAAA,EAEL,MAFK,CAAA,MAAmB,EAAA,GAAA,CAAA;EAqBd,aAAA,CAAA,EAAa,MAAA;EAAA,gBAAA,CAAA,EAAA,MAAA;EAAA,CAAA,GACzB,EAAA,MAAA,CAAA,EAAA,GAAA;;AAEW,iBAHC,aAAA,CAGD,MAAA,EAFX,aAEW,EAAA,MAAA,CAAA,EADX,mBACW,EAAA,UAAA,CAAA,EAAA,MAAA,CAAA,EAAA,OAAA,CAAA,MAAA,CAAA;AAAA"}

package/dist/codegen-Dbw6gEZt.js

@@ -0,0 +1,110 @@
+import { codegen } from "@graphql-codegen/core";
+import * as typescriptPlugin from "@graphql-codegen/typescript";
+import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { defu } from "defu";
+import { parse } from "graphql";
+import { CurrencyResolver, DateTimeResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
+
+//#region src/codegen.ts
+function pluginContent(_schema, _documents, _config, _info) {
+	return {
+		prepend: [
+			"// THIS FILE IS GENERATED, DO NOT EDIT!",
+			"/* eslint-disable eslint-comments/no-unlimited-disable */",
+			"/* tslint:disable */",
+			"/* eslint-disable */",
+			"/* prettier-ignore */"
+		],
+		content: ""
+	};
+}
+async function generateTypes(schema, config = {}, outputPath) {
+	const defaultConfig = {
+		scalars: {
+			Boolean: {
+				input: "boolean",
+				output: "boolean"
+			},
+			DateTime: DateTimeResolver.extensions.codegenScalarType,
+			DateTimeISO: DateTimeResolver.extensions.codegenScalarType,
+			UUID: UUIDResolver.extensions.codegenScalarType,
+			JSON: JSONResolver.extensions.codegenScalarType,
+			JSONObject: JSONResolver.extensions.codegenScalarType,
+			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
+			Currency: CurrencyResolver.extensions.codegenScalarType,
+			File: {
+				input: "File",
+				output: "File"
+			},
+			Cursor: {
+				input: "number",
+				output: "number"
+			}
+		},
+		defaultScalarType: "unknown",
+		defaultMapper: `ResolverReturnType<{T}>`,
+		contextType: "./context#GraphQLContext",
+		maybeValue: "T | null | undefined",
+		inputMaybeValue: "T | undefined",
+		enumsAsTypes: true,
+		useTypeImports: true,
+		strictScalars: true,
+		emitLegacyCommonJSImports: false
+	};
+	const mergedConfig = defu(config, defaultConfig);
+	const output = await codegen({
+		filename: outputPath || "types.generated.ts",
+		schema: parse(printSchemaWithDirectives(schema)),
+		documents: [],
+		config: mergedConfig,
+		plugins: [
+			{ imports: {} },
+			{ pluginContent: {} },
+			{ typescript: {} },
+			{ typescriptResolvers: {} }
+		],
+		pluginMap: {
+			pluginContent: { plugin: pluginContent },
+			imports: { plugin: () => ({
+				prepend: [`type Primitive =
+    | null
+    | undefined
+    | string
+    | number
+    | boolean
+    | symbol
+    | bigint;
+
+type BuiltIns = Primitive | void | Date | RegExp;
+
+type ResolverReturnType<T> = T extends BuiltIns
+    ? T
+    : T extends (...args: any[]) => unknown
+    ? T | undefined
+    : T extends object
+    ? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+        ? ItemType[] extends T // Test for arrays (non-tuples) specifically
+            ? Array<ResolverReturnType<ItemType>>
+            : ResolverReturnTypeObject<T> // Tuples behave properly
+        : ResolverReturnTypeObject<T>
+    : unknown;
+
+type ResolverReturnTypeObject<T extends object> = {
+  [K in keyof T]: ResolverReturnType<T[K]>
+};`, ""],
+				content: ""
+			}) },
+			typescript: typescriptPlugin,
+			typescriptResolvers: typescriptResolversPlugin
+		}
+	}).catch((e) => {
+		console.warn("[nitro-graphql] Code generation error:", e);
+		return "";
+	});
+	return output;
+}
+
+//#endregion
+export { generateTypes };
+//# sourceMappingURL=codegen-Dbw6gEZt.js.map

package/dist/codegen-Dbw6gEZt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen-Dbw6gEZt.js","names":["_schema: any","_documents: any","_config: any","_info: any","schema: GraphQLSchema","config: CodegenServerConfig","outputPath?: string","defaultConfig: CodegenServerConfig","e: any"],"sources":["../src/codegen.ts"],"sourcesContent":["import type { GraphQLSchema } from 'graphql'\nimport { codegen } from '@graphql-codegen/core'\nimport * as typescriptPlugin from '@graphql-codegen/typescript'\nimport * as typescriptResolversPlugin from '@graphql-codegen/typescript-resolvers'\nimport { printSchemaWithDirectives } from '@graphql-tools/utils'\nimport { defu } from 'defu'\nimport { parse } from 'graphql'\nimport {\n  CurrencyResolver,\n  DateTimeResolver,\n  JSONResolver,\n  NonEmptyStringResolver,\n  UUIDResolver,\n} from 'graphql-scalars'\n\nexport interface CodegenServerConfig {\n  contextType?: string\n  scalars?: Record<string, any>\n  defaultMapper?: string\n  mapperTypeSuffix?: string\n  [key: string]: any\n}\n\nfunction pluginContent(_schema: any, _documents: any, _config: any, _info: any) {\n  return {\n    prepend: [\n      '// THIS FILE IS GENERATED, DO NOT EDIT!',\n      '/* eslint-disable eslint-comments/no-unlimited-disable */',\n      '/* tslint:disable */',\n      '/* eslint-disable */',\n      '/* prettier-ignore */',\n    ],\n    content: '',\n  }\n}\n\nexport async function generateTypes(\n  schema: GraphQLSchema,\n  config: CodegenServerConfig = {},\n  outputPath?: string,\n) {\n  const defaultConfig: CodegenServerConfig = {\n    scalars: {\n      Boolean: {\n        input: 'boolean',\n        output: 'boolean',\n      },\n      DateTime: DateTimeResolver.extensions.codegenScalarType as any,\n      DateTimeISO: DateTimeResolver.extensions.codegenScalarType as any,\n      UUID: UUIDResolver.extensions.codegenScalarType as any,\n      JSON: JSONResolver.extensions.codegenScalarType as any,\n      JSONObject: JSONResolver.extensions.codegenScalarType as any,\n      NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType as any,\n      Currency: CurrencyResolver.extensions.codegenScalarType as any,\n      File: {\n        input: 'File',\n        output: 'File',\n      },\n      Cursor: {\n        input: 'number',\n        output: 'number',\n      },\n    },\n    defaultScalarType: 'unknown',\n    defaultMapper: `ResolverReturnType<{T}>`,\n    contextType: './context#GraphQLContext',\n    maybeValue: 'T | null | undefined',\n    inputMaybeValue: 'T | undefined',\n    enumsAsTypes: true,\n    useTypeImports: true,\n    strictScalars: true,\n    emitLegacyCommonJSImports: false,\n  }\n\n  const mergedConfig = defu(config, defaultConfig)\n\n  const output = await codegen({\n    filename: outputPath || 'types.generated.ts',\n    schema: parse(printSchemaWithDirectives(schema)),\n    documents: [],\n    config: mergedConfig,\n    plugins: [\n      { imports: {} },\n      { pluginContent: {} },\n      { typescript: {} },\n      { typescriptResolvers: {} },\n    ],\n    pluginMap: {\n      pluginContent: {\n        plugin: pluginContent,\n      },\n      imports: {\n        plugin: () => ({\n          prepend: [\n            `type Primitive =\n    | null\n    | undefined\n    | string\n    | number\n    | boolean\n    | symbol\n    | bigint;\n\ntype BuiltIns = Primitive | void | Date | RegExp;\n\ntype ResolverReturnType<T> = T extends BuiltIns\n    ? T\n    : T extends (...args: any[]) => unknown\n    ? T | undefined\n    : T extends object\n    ? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156\n        ? ItemType[] extends T // Test for arrays (non-tuples) specifically\n            ? Array<ResolverReturnType<ItemType>>\n            : ResolverReturnTypeObject<T> // Tuples behave properly\n        : ResolverReturnTypeObject<T>\n    : unknown;\n\ntype ResolverReturnTypeObject<T extends object> = {\n  [K in keyof T]: ResolverReturnType<T[K]>\n};`,\n            '',\n          ],\n          content: '',\n        }),\n      },\n      typescript: typescriptPlugin,\n      typescriptResolvers: typescriptResolversPlugin,\n    },\n  }).catch((e: any) => {\n    console.warn('[nitro-graphql] Code generation error:', e)\n    return ''\n  })\n\n  return output\n}\n"],"mappings":";;;;;;;;;AAuBA,SAAS,cAAcA,SAAcC,YAAiBC,SAAcC,OAAY;AAC9E,QAAO;EACL,SAAS;GACP;GACA;GACA;GACA;GACA;EACD;EACD,SAAS;CACV;AACF;AAED,eAAsB,cACpBC,QACAC,SAA8B,CAAE,GAChCC,YACA;CACA,MAAMC,gBAAqC;EACzC,SAAS;GACP,SAAS;IACP,OAAO;IACP,QAAQ;GACT;GACD,UAAU,iBAAiB,WAAW;GACtC,aAAa,iBAAiB,WAAW;GACzC,MAAM,aAAa,WAAW;GAC9B,MAAM,aAAa,WAAW;GAC9B,YAAY,aAAa,WAAW;GACpC,gBAAgB,uBAAuB,WAAW;GAClD,UAAU,iBAAiB,WAAW;GACtC,MAAM;IACJ,OAAO;IACP,QAAQ;GACT;GACD,QAAQ;IACN,OAAO;IACP,QAAQ;GACT;EACF;EACD,mBAAmB;EACnB,eAAe,CAAC,uBAAuB,CAAC;EACxC,aAAa;EACb,YAAY;EACZ,iBAAiB;EACjB,cAAc;EACd,gBAAgB;EAChB,eAAe;EACf,2BAA2B;CAC5B;CAED,MAAM,eAAe,KAAK,QAAQ,cAAc;CAEhD,MAAM,SAAS,MAAM,QAAQ;EAC3B,UAAU,cAAc;EACxB,QAAQ,MAAM,0BAA0B,OAAO,CAAC;EAChD,WAAW,CAAE;EACb,QAAQ;EACR,SAAS;GACP,EAAE,SAAS,CAAE,EAAE;GACf,EAAE,eAAe,CAAE,EAAE;GACrB,EAAE,YAAY,CAAE,EAAE;GAClB,EAAE,qBAAqB,CAAE,EAAE;EAC5B;EACD,WAAW;GACT,eAAe,EACb,QAAQ,cACT;GACD,SAAS,EACP,QAAQ,OAAO;IACb,SAAS,CACP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;EAyBX,CAAC,EACS,EACD;IACD,SAAS;GACV,GACF;GACD,YAAY;GACZ,qBAAqB;EACtB;CACF,EAAC,CAAC,MAAM,CAACC,MAAW;AACnB,UAAQ,KAAK,0CAA0C,EAAE;AACzD,SAAO;CACR,EAAC;AAEF,QAAO;AACR"}

package/dist/codegen.d.ts

@@ -0,0 +1,2 @@
+import { CodegenServerConfig, generateTypes } from "./codegen-DWJuLowd.js";
+export { CodegenServerConfig, generateTypes };

package/dist/codegen.js

@@ -0,0 +1,3 @@
+import { generateTypes } from "./codegen-Dbw6gEZt.js";
+
+export { generateTypes };

package/dist/context-BgqNJFCT.d.ts

@@ -0,0 +1,13 @@
+import { YogaInitialContext } from "graphql-yoga";
+import { H3Event } from "h3";
+
+//#region src/context.d.ts
+interface GraphQLContext extends YogaInitialContext {
+  event: H3Event;
+  storage: any;
+}
+//# sourceMappingURL=context.d.ts.map
+
+//#endregion
+export { GraphQLContext };
+//# sourceMappingURL=context-BgqNJFCT.d.ts.map

package/dist/context-BgqNJFCT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-BgqNJFCT.d.ts","names":[],"sources":["../src/context.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,cAAA,SAAuB;SAC/B;EADQ,OAAA,EAAA,GAAA"}

package/dist/context.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLContext } from "./context-BgqNJFCT.js";
+export { GraphQLContext };

package/dist/context.js

@@ -0,0 +1 @@
+import "./context-CZdhkJYD.js";

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { CodegenClientConfig, GraphQLSchemaConfig, NitroGraphQLOptions, Resolvers } from "./types-D_NqyCcy.js";
+import { CodegenServerConfig, generateTypes } from "./codegen-DWJuLowd.js";
+import { GraphQLContext } from "./context-BgqNJFCT.js";
+import { createResolver, defineGraphQLResolver, defineYogaConfig } from "./utils-BuYDOLIi.js";
+import * as nitropack0 from "nitropack";
+
+//#region src/index.d.ts
+declare const _default: nitropack0.NitroModule;
+//#endregion
+export { CodegenClientConfig, CodegenServerConfig, GraphQLContext, GraphQLSchemaConfig, NitroGraphQLOptions, Resolvers, createResolver, _default as default, defineGraphQLResolver, defineYogaConfig, generateTypes };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,424 @@
+import { scanGraphQLFiles } from "./scanner-BdcKEPQk.js";
+import { createResolver, defineGraphQLResolver, defineYogaConfig } from "./utils-87_22aIA.js";
+import { generateTypes } from "./codegen-Dbw6gEZt.js";
+import "./context-CZdhkJYD.js";
+import { mkdir, writeFile } from "node:fs/promises";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+import { makeExecutableSchema } from "@graphql-tools/schema";
+import { consola } from "consola";
+import { join } from "pathe";
+import { defineNitroModule } from "nitropack/kit";
+
+//#region src/index.ts
+const logger = consola.withTag("graphql");
+var src_default = defineNitroModule({
+	name: "nitro:graphql-yoga",
+	async setup(nitro) {
+		const options = {
+			endpoint: "/api/graphql",
+			playground: true,
+			cors: false,
+			cacheHeaders: {
+				enabled: true,
+				maxAge: 604800
+			},
+			client: {
+				enabled: false,
+				outputPath: void 0,
+				watchPatterns: void 0,
+				config: {
+					documentMode: "string",
+					emitLegacyCommonJSImports: false,
+					useTypeImports: true,
+					enumsAsTypes: true
+				}
+			},
+			...nitro.options.graphqlYoga,
+			...nitro.options.runtimeConfig?.graphqlYoga
+		};
+		const graphqlPath = join(nitro.options.srcDir, "graphql");
+		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig) => {
+			rollupConfig.external = rollupConfig.external || [];
+			const codegenExternals = [
+				"@graphql-codegen/core",
+				"@graphql-codegen/typescript",
+				"@graphql-codegen/typescript-resolvers",
+				"@graphql-codegen/typescript-operations",
+				"@graphql-codegen/typescript-generic-sdk",
+				"@graphql-tools/graphql-file-loader",
+				"@graphql-tools/load"
+			];
+			if (Array.isArray(rollupConfig.external)) rollupConfig.external.push(...codegenExternals);
+			else if (typeof rollupConfig.external === "function") {
+				const originalExternal = rollupConfig.external;
+				rollupConfig.external = (id, parent, isResolved) => {
+					if (codegenExternals.some((external) => id.includes(external))) return true;
+					return originalExternal(id, parent, isResolved);
+				};
+			}
+			const originalChunkFileNames = rollupConfig.output.chunkFileNames;
+			rollupConfig.output.chunkFileNames = (chunk) => {
+				const allIds = chunk.moduleIds || [];
+				const hasGraphQLResolverFile = allIds.some((id) => id.includes(graphqlPath) && !id.includes("node_modules") && !id.includes("#nitro-graphql") && (id.endsWith(".ts") || id.endsWith(".js") || id.endsWith(".mjs")));
+				if (hasGraphQLResolverFile) return `chunks/graphql/[name].mjs`;
+				if (typeof originalChunkFileNames === "function") return originalChunkFileNames(chunk);
+				return originalChunkFileNames || "chunks/_/[name].mjs";
+			};
+		});
+		nitro.options.virtual ??= {};
+		nitro.options.virtual["#nitro-graphql/context"] = () => `
+export type { GraphQLContext } from 'nitro-graphql/context'
+`;
+		const scanResult = await scanGraphQLFiles(nitro);
+		if (scanResult.resolvers.length > 0) logger.success(`Found ${scanResult.resolvers.length} resolvers`);
+		if (scanResult.typeDefs.length > 0) {
+			const mergedTypeDefs = mergeTypeDefs(scanResult.typeDefs);
+			const schema = makeExecutableSchema({
+				typeDefs: mergedTypeDefs,
+				resolvers: {}
+			});
+			const { generateTypes: generateTypes$1 } = await new Function("return import(\"nitro-graphql/codegen\")")();
+			const generatedTypes = await generateTypes$1(schema);
+			const outputPath = join(nitro.options.buildDir, "types", "graphql-types.generated.ts");
+			const typesDir = join(nitro.options.buildDir, "types");
+			await mkdir(typesDir, { recursive: true });
+			await writeFile(outputPath, generatedTypes);
+			const graphqlDtsPath = join(typesDir, "graphql.d.ts");
+			const graphqlDtsContent = `// Auto-generated by nitro-graphql
+import type { Resolvers as Test } from './graphql-types.generated'
+
+declare module 'nitro-graphql' {
+  interface Resolvers extends Test {}
+}
+`;
+			await writeFile(graphqlDtsPath, graphqlDtsContent);
+			logger.success("Types generated");
+		} else {
+			const typesDir = join(nitro.options.buildDir, "types");
+			await mkdir(typesDir, { recursive: true });
+			const minimalTypes = `// Generated by nitro-graphql (no schema found)
+export type Resolvers = any
+`;
+			const outputPath = join(typesDir, "graphql-types.generated.ts");
+			await writeFile(outputPath, minimalTypes);
+			const graphqlDtsPath = join(typesDir, "graphql.d.ts");
+			const graphqlDtsContent = `// Auto-generated by nitro-graphql
+import type { Resolvers as Test } from './graphql-types.generated'
+
+declare module 'nitro-graphql' {
+  interface Resolvers extends Test {}
+}
+`;
+			await writeFile(graphqlDtsPath, graphqlDtsContent);
+			logger.info("Created minimal types (no schema found)");
+		}
+		if (nitro.options.dev) {
+			const setupGraphQLWatcher = (await new Function("return import(\"nitro-graphql/watcher\")")()).setupGraphQLWatcher;
+			const setupClientWatcher = (await new Function("return import(\"nitro-graphql/client-watcher\")")()).setupClientWatcher;
+			await setupGraphQLWatcher(nitro);
+			await setupClientWatcher(nitro, options);
+		}
+		nitro.options.handlers = nitro.options.handlers || [];
+		const endpoint = options.endpoint || "/api/graphql";
+		nitro.options.handlers.push({
+			route: endpoint,
+			handler: "#nitro-graphql/handler",
+			method: "get"
+		});
+		nitro.options.handlers.push({
+			route: endpoint,
+			handler: "#nitro-graphql/handler",
+			method: "post"
+		});
+		nitro.options.handlers.push({
+			route: endpoint,
+			handler: "#nitro-graphql/handler",
+			method: "options"
+		});
+		nitro.options.handlers.push({
+			route: `${endpoint}/health`,
+			handler: "#nitro-graphql/health",
+			method: "get"
+		});
+		nitro.options.virtual["#nitro-graphql/handler"] = () => `
+import { createYoga } from 'graphql-yoga'
+import { defineEventHandler, readRawBody, setHeader, setResponseStatus } from 'h3'
+import { useStorage } from 'nitro/runtime'
+import { makeExecutableSchema } from '@graphql-tools/schema'
+import { mergeTypeDefs, mergeResolvers } from '@graphql-tools/merge'
+import { join } from 'pathe'
+// Types are generated at build time to .nitro/graphql-types.generated.ts
+
+// GraphQL Context type is injected via context module
+
+// Create resolver helper
+globalThis.createResolver = function(resolvers) {
+  return resolvers
+}
+
+// Dynamic schema loading function
+async function loadTypeDefs() {
+  const schemaPath = join('${nitro.options.srcDir}', 'graphql', '**', '*.graphql')
+  const { loadFilesSync } = await import('@graphql-tools/load-files')
+  return loadFilesSync(schemaPath, {
+    recursive: true,
+  })
+}
+
+// Load resolvers using dynamic imports (Nitro handles the bundling)
+const resolverImports = [
+${scanResult.resolvers.map((resolver) => `  () => import('${resolver.path}')`).join(",\n")}
+]
+
+// Async function to load resolvers
+async function loadResolvers() {
+  let resolvers = {}
+  try {
+    if (resolverImports.length > 0) {
+      const resolverModules = []
+      
+      for (let i = 0; i < resolverImports.length; i++) {
+        try {
+          const resolverModule = await resolverImports[i]()
+          const resolver = resolverModule.default || resolverModule
+          
+          if (resolver) {
+            resolverModules.push(resolver)
+          }
+        } catch (error) {
+          console.warn('[graphql] Failed to load resolver:', i, error.message)
+        }
+      }
+      
+      if (resolverModules.length > 0) {
+        resolvers = mergeResolvers(resolverModules)
+      } else {
+        console.warn('[graphql] No resolvers could be loaded')
+        resolvers = { Query: {}, Mutation: {} }
+      }
+    } else {
+      console.warn('[graphql] No resolvers found')
+      resolvers = { Query: {}, Mutation: {} }
+    }
+  } catch (error) {
+    console.warn('[graphql] Error loading resolvers:', error.message)
+    resolvers = { Query: {}, Mutation: {} }
+  }
+  return resolvers
+}
+
+// Apollo Sandbox HTML with 1 week cache
+const apolloSandboxHtml = \`<!DOCTYPE html>
+<html lang="en">
+<body style="margin: 0; overflow-x: hidden; overflow-y: hidden">
+<div id="sandbox" style="height:100vh; width:100vw;"></div>
+<script src="https://embeddable-sandbox.cdn.apollographql.com/02e2da0fccbe0240ef03d2396d6c98559bab5b06/embeddable-sandbox.umd.production.min.js"><\/script>
+<script>
+new window.EmbeddedSandbox({
+  target: "#sandbox",
+  initialEndpoint: window.location.href,
+  hideCookieToggle: false,
+  initialState: {
+    includeCookies: true
+  }
+});
+<\/script>
+</body>
+</html>\`
+
+// Set cache headers for Apollo Sandbox HTML (1 week = 604800 seconds)
+function setApolloSandboxCacheHeaders(event) {
+  setHeader(event, 'Cache-Control', 'public, max-age=604800, s-maxage=604800')
+  setHeader(event, 'Expires', new Date(Date.now() + 604800000).toUTCString())
+  setHeader(event, 'ETag', \`"apollo-sandbox-\${Date.now()}"\`)
+}
+
+// Lazy initialization
+let yoga = null
+let initPromise = null
+
+async function getYoga() {
+  // In development mode, always reload schema for hot updates
+  const isDev = ${nitro.options.dev}
+  if (yoga && !isDev) return yoga
+  
+  if (!initPromise || isDev) {
+    // Reset yoga instance in development mode
+    if (isDev) {
+      yoga = null
+    }
+    
+    initPromise = (async () => {
+      // Load custom yoga config first (separate from resolvers)
+      let customYogaConfig = {}
+      ${scanResult.yogaConfigPath ? `
+      try {
+        const yogaConfigModule = await import('${scanResult.yogaConfigPath}')
+        customYogaConfig = yogaConfigModule.default || yogaConfigModule
+      } catch (error) {
+        console.warn('[graphql] Failed to load yoga config:', error.message)
+      }` : ""}
+
+      const resolvers = await loadResolvers()
+      const typeDefs = await loadTypeDefs()
+      
+      // Merge schema and resolvers (without yoga config interfering)
+      const schema = makeExecutableSchema({
+        typeDefs: mergeTypeDefs(typeDefs),
+        resolvers,
+      })
+
+      // Default yoga configuration
+      const defaultYogaConfig = {
+        schema,
+        context: async ({ request }) => {
+          const event = request.$$event
+          return {
+            event,
+            request,
+            storage: useStorage(),
+          }
+        },
+        graphqlEndpoint: '${endpoint}',
+        graphiql: ${options.playground !== false},
+        renderGraphiQL: () => apolloSandboxHtml,
+        landingPage: false,
+        cors: ${JSON.stringify(options.cors || false)},
+      }
+
+      // Clean up custom config (remove properties that could be mistaken for GraphQL resolvers)
+      const cleanCustomConfig = { ...customYogaConfig }
+      
+      // Remove empty arrays and functions that GraphQL Tools might confuse with resolvers
+      if (Array.isArray(cleanCustomConfig.plugins) && cleanCustomConfig.plugins.length === 0) {
+        delete cleanCustomConfig.plugins
+      }
+      
+      // Remove these yoga-specific configs from resolver merging
+      const yogaOnlyConfigs = ['context', 'plugins', 'maskedErrors', 'graphiql', 'cors']
+      const cleanResolverConfig = { ...cleanCustomConfig }
+      yogaOnlyConfigs.forEach(key => {
+        delete cleanResolverConfig[key]
+      })
+
+      // Merge custom config with defaults
+      const yogaConfig = {
+        ...defaultYogaConfig,
+        ...cleanCustomConfig,
+        // Always override schema and endpoint from default config
+        schema,
+        graphqlEndpoint: '${endpoint}',
+      }
+
+      yoga = createYoga(yogaConfig)
+      
+      return yoga
+    })()
+  }
+  
+  return initPromise
+}
+
+export default defineEventHandler(async (event) => {
+  const { req } = event.node
+  const host = req.headers.host || 'localhost'
+  const protocol = 'http'
+  const url = new URL(req.url || '/', protocol + '://' + host)
+  
+  // Attach event to request for context
+  req.$$event = event
+  
+  const yogaInstance = await getYoga()
+  const response = await yogaInstance.fetch(url.toString(), {
+    method: req.method || 'GET',
+    headers: req.headers,
+    body: req.method !== 'GET' && req.method !== 'HEAD' ? await readRawBody(event) : undefined,
+  }, {
+    event,
+  })
+  
+  // Set response headers
+  response.headers.forEach((value, key) => {
+    setHeader(event, key, value)
+  })
+  
+  // Set status code
+  setResponseStatus(event, response.status)
+  
+  // Return response body
+  if (response.body) {
+    const contentType = response.headers.get('content-type')
+    if (contentType?.includes('text/html')) {
+      // Set cache headers for Apollo Sandbox HTML
+      setApolloSandboxCacheHeaders(event)
+      return await response.text()
+    }
+    if (contentType?.includes('application/json')) {
+      return await response.text()
+    }
+    return response.body
+  }
+  
+  return null
+})
+`;
+		nitro.options.virtual["#nitro-graphql/health"] = () => `
+import { defineEventHandler, setResponseStatus } from 'h3'
+
+export default defineEventHandler(async (event) => {
+  try {
+    const response = await $fetch('${endpoint}', {
+      method: 'POST',
+      body: {
+        query: 'query Health { __typename }',
+        operationName: 'Health',
+      },
+      headers: {
+        'Content-Type': 'application/json',
+        'Accept': 'application/json',
+      },
+    })
+    
+    if (response && typeof response === 'object' && 'data' in response) {
+      return {
+        status: 'healthy',
+        message: 'GraphQL server is running',
+        timestamp: new Date().toISOString(),
+      }
+    }
+    
+    throw new Error('Invalid response from GraphQL server')
+  } catch (error) {
+    setResponseStatus(event, 503)
+    return {
+      status: 'unhealthy',
+      message: error.message || 'GraphQL server is not responding',
+      timestamp: new Date().toISOString(),
+    }
+  }
+})
+`;
+		if (nitro.options.imports) nitro.options.imports.presets.push({
+			from: "nitro-graphql",
+			imports: [
+				"createResolver",
+				"defineGraphQLResolver",
+				"defineGraphQLSchema",
+				"defineGraphQLResolvers",
+				"defineYogaConfig",
+				"gql"
+			]
+		});
+		nitro.options.typescript ??= {};
+		nitro.options.typescript.tsConfig ??= {};
+		nitro.options.typescript.tsConfig.compilerOptions ??= {};
+		nitro.options.typescript.tsConfig.compilerOptions.paths ??= {};
+		nitro.options.typescript.tsConfig.compilerOptions.paths["#build/graphql-types.generated"] = [join(nitro.options.buildDir, "types", "graphql-types.generated.ts")];
+		nitro.options.typescript.tsConfig.include = nitro.options.typescript.tsConfig.include || [];
+		nitro.options.typescript.tsConfig.include.push(join(nitro.options.buildDir, "types", "graphql-types.generated.ts"), join(nitro.options.buildDir, "types", "graphql.d.ts"));
+	}
+});
+
+//#endregion
+export { createResolver, src_default as default, defineGraphQLResolver, defineYogaConfig, generateTypes };
+//# sourceMappingURL=index.js.map