nitro-graphql 0.0.11 → 0.0.13

package/dist/ecosystem/nuxt.d.ts

@@ -1,7 +1,7 @@
-import * as _nuxt_schema7 from "@nuxt/schema";
+import * as _nuxt_schema1 from "@nuxt/schema";
 
 //#region src/ecosystem/nuxt.d.ts
 interface ModuleOptions {}
-declare const _default: _nuxt_schema7.NuxtModule<ModuleOptions, ModuleOptions, false>;
+declare const _default: _nuxt_schema1.NuxtModule<ModuleOptions, ModuleOptions, false>;
 //#endregion
 export { ModuleOptions, _default as default };

package/dist/index.js

@@ -103,18 +103,21 @@ var src_default = defineNitroModule({
 			handler: join(runtime, "health"),
 			method: "get"
 		});
-		if (nitro.options.imports) nitro.options.imports.presets.push({
-			from: "nitro-graphql/utils/define",
-			imports: [
-				"defineResolver",
-				"defineMutation",
-				"defineQuery",
-				"defineSubscription",
-				"defineType",
-				"defineGraphQLConfig",
-				"defineSchema"
-			]
-		});
+		if (nitro.options.imports) {
+			nitro.options.imports.presets ??= [];
+			nitro.options.imports.presets.push({
+				from: "nitro-graphql/utils/define",
+				imports: [
+					"defineResolver",
+					"defineMutation",
+					"defineQuery",
+					"defineSubscription",
+					"defineType",
+					"defineGraphQLConfig",
+					"defineSchema"
+				]
+			});
+		}
 		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
 			const manualChunks = rollupConfig$1.output?.manualChunks;
 			const chunkFiles = rollupConfig$1.output?.chunkFileNames;

package/dist/routes/apollo-server.d.ts

@@ -1,6 +1,6 @@
-import * as h33 from "h3";
+import * as h32 from "h3";
 
 //#region src/routes/apollo-server.d.ts
-declare const _default: h33.EventHandler<h33.EventHandlerRequest, any>;
+declare const _default: h32.EventHandler<h32.EventHandlerRequest, any>;
 //#endregion
 export { _default as default };

package/dist/routes/graphql-yoga.d.ts

@@ -1,6 +1,6 @@
-import * as h31 from "h3";
+import * as h36 from "h3";
 
 //#region src/routes/graphql-yoga.d.ts
-declare const _default: h31.EventHandler<h31.EventHandlerRequest, Promise<Response>>;
+declare const _default: h36.EventHandler<h36.EventHandlerRequest, Promise<Response>>;
 //#endregion
 export { _default as default };

package/dist/routes/health.d.ts

@@ -1,7 +1,7 @@
-import * as h35 from "h3";
+import * as h34 from "h3";
 
 //#region src/routes/health.d.ts
-declare const _default: h35.EventHandler<h35.EventHandlerRequest, Promise<{
+declare const _default: h34.EventHandler<h34.EventHandlerRequest, Promise<{
   status: string;
   message: string;
   timestamp: string;

package/dist/utils/apollo.d.ts

@@ -0,0 +1,17 @@
+import { ApolloServer, BaseContext, ContextFunction } from "@apollo/server";
+import { EventHandler, H3Event } from "h3";
+import { WithRequired } from "@apollo/utils.withrequired";
+import { Hooks } from "crossws";
+
+//#region src/utils/apollo.d.ts
+interface H3ContextFunctionArgument {
+  event: H3Event;
+}
+interface H3HandlerOptions<TContext extends BaseContext> {
+  context?: ContextFunction<[H3ContextFunctionArgument], TContext>;
+  websocket?: Partial<Hooks>;
+}
+declare function startServerAndCreateH3Handler(server: ApolloServer<BaseContext> | (() => ApolloServer<BaseContext>), options?: H3HandlerOptions<BaseContext>): EventHandler;
+declare function startServerAndCreateH3Handler<TContext extends BaseContext>(server: ApolloServer<TContext> | (() => ApolloServer<TContext>), options: WithRequired<H3HandlerOptions<TContext>, 'context'>): EventHandler;
+//#endregion
+export { H3ContextFunctionArgument, H3HandlerOptions, startServerAndCreateH3Handler };

package/dist/utils/client-codegen.d.ts

@@ -0,0 +1,23 @@
+import { CodegenClientConfig } from "../types/index.js";
+import { GraphQLSchema } from "graphql";
+import { Source } from "@graphql-tools/utils";
+import { LoadSchemaOptions, UnnormalizedTypeDefPointer } from "@graphql-tools/load";
+
+//#region src/utils/client-codegen.d.ts
+
+/**
+ * Type definition pointer for GraphQL schemas
+ */
+type GraphQLTypeDefPointer = UnnormalizedTypeDefPointer | UnnormalizedTypeDefPointer[];
+/**
+ * Options for loading GraphQL schemas
+ */
+type GraphQLLoadSchemaOptions = Partial<LoadSchemaOptions>;
+declare function graphQLLoadSchemaSync(schemaPointers: GraphQLTypeDefPointer, data?: GraphQLLoadSchemaOptions): Promise<GraphQLSchema | undefined>;
+declare function loadGraphQLDocuments(patterns: string | string[]): Promise<Source[]>;
+declare function generateClientTypes(schema: GraphQLSchema, docs: Source[], config?: CodegenClientConfig, outputPath?: string): Promise<false | {
+  types: string;
+  sdk: string;
+}>;
+//#endregion
+export { GraphQLLoadSchemaOptions, GraphQLTypeDefPointer, generateClientTypes, graphQLLoadSchemaSync, loadGraphQLDocuments };

package/dist/utils/client-codegen.js

@@ -8,7 +8,7 @@ import { plugin } from "@graphql-codegen/typescript";
 import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
 import { plugin as plugin$2 } from "@graphql-codegen/typescript-operations";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
-import { loadDocuments } from "@graphql-tools/load";
+import { loadDocuments, loadSchemaSync } from "@graphql-tools/load";
 
 //#region src/utils/client-codegen.ts
 function pluginContent(_schema, _documents, _config, _info) {
@@ -23,6 +23,21 @@ function pluginContent(_schema, _documents, _config, _info) {
 		content: ""
 	};
 }
+async function graphQLLoadSchemaSync(schemaPointers, data = {}) {
+	const pointers = Array.isArray(schemaPointers) ? schemaPointers : [schemaPointers];
+	const filteredPointers = [...pointers, "!**/vfs/**"];
+	let result;
+	try {
+		result = loadSchemaSync(filteredPointers, {
+			...data,
+			loaders: [new GraphQLFileLoader(), ...data.loaders || []]
+		});
+	} catch (e) {
+		if ((e.message || "").includes("Unable to find any GraphQL type definitions for the following pointers:")) consola$1.info("No server GraphQL files found. If you need server-side GraphQL, add .graphql files to your server directory.");
+		else throw e;
+	}
+	return result;
+}
 async function loadGraphQLDocuments(patterns) {
 	try {
 		const result = await loadDocuments(patterns, { loaders: [new GraphQLFileLoader()] });
@@ -118,4 +133,4 @@ async function generateClientTypes(schema, docs, config = {}, outputPath) {
 }
 
 //#endregion
-export { generateClientTypes, loadGraphQLDocuments };
+export { generateClientTypes, graphQLLoadSchemaSync, loadGraphQLDocuments };

package/dist/utils/define.d.ts

@@ -0,0 +1,20 @@
+import { ApolloServerOptions, BaseContext } from "@apollo/server";
+import { YogaServerOptions } from "graphql-yoga";
+import { ResolversTypes, StandardSchemaV1 } from "#graphql/server";
+import { GraphQLFramework, Resolvers } from "nitro-graphql";
+
+//#region src/utils/define.d.ts
+type Flatten<T> = T extends infer U ? { [K in keyof U]: U[K] } : never;
+declare function defineSchema<T extends Partial<Record<keyof ResolversTypes, StandardSchemaV1>>>(config: T): Flatten<T>;
+declare function defineResolver(resolvers: Resolvers): Resolvers;
+type ResolverQuery = Resolvers extends {
+  Query: infer Q;
+} ? Q : never;
+declare function defineQuery(resolvers?: Resolvers['Query']): Resolvers;
+declare function defineMutation(resolvers?: Resolvers['Mutation']): Resolvers;
+declare function defineSubscription(resolvers?: Resolvers['Subscription']): Resolvers;
+declare function defineType(resolvers: Resolvers): Resolvers;
+type DefineServerConfig = GraphQLFramework extends 'graphql-yoga' ? Partial<YogaServerOptions<any, any>> : GraphQLFramework extends 'apollo-server' ? Partial<ApolloServerOptions<BaseContext>> : Record<string, any>;
+declare function defineGraphQLConfig(config: Partial<DefineServerConfig>): Partial<DefineServerConfig>;
+//#endregion
+export { DefineServerConfig, ResolverQuery, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/define.js

@@ -0,0 +1,25 @@
+//#region src/utils/define.ts
+function defineSchema(config) {
+	return config;
+}
+function defineResolver(resolvers) {
+	return resolvers;
+}
+function defineQuery(resolvers = {}) {
+	return { Query: { ...resolvers } };
+}
+function defineMutation(resolvers = {}) {
+	return { Mutation: { ...resolvers } };
+}
+function defineSubscription(resolvers = {}) {
+	return { Subscription: { ...resolvers } };
+}
+function defineType(resolvers) {
+	return resolvers;
+}
+function defineGraphQLConfig(config) {
+	return config;
+}
+
+//#endregion
+export { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/utils/server-codegen.d.ts

@@ -0,0 +1,7 @@
+import { CodegenServerConfig } from "../types/index.js";
+import { GraphQLSchema } from "graphql";
+
+//#region src/utils/server-codegen.d.ts
+declare function generateTypes(schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
+//#endregion
+export { generateTypes };

package/dist/utils/server-type-generation.d.ts

@@ -0,0 +1,7 @@
+import { Nitro } from "nitropack";
+
+//#region src/utils/server-type-generation.d.ts
+declare function serverTypeGeneration(app: Nitro): Promise<void>;
+declare function clientTypeGeneration(app: Nitro, path: string): Promise<void>;
+//#endregion
+export { clientTypeGeneration, serverTypeGeneration };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "0.0.11",
+  "version": "0.0.13",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,