nitro-graphql 0.0.4 → 0.0.6

package/dist/rollup.js

@@ -0,0 +1,87 @@
+import { getImportId, scanGraphql } from "./utils/index.js";
+import { serverTypeGeneration } from "./utils/server-type-generation.js";
+import { readFile } from "node:fs/promises";
+import { parse } from "graphql";
+import { genImport } from "knitwork";
+
+//#region src/rollup.ts
+async function rollupConfig(app) {
+	virtualDefs(app);
+	virtualResolvers(app);
+	app.hooks.hook("rollup:before", (nitro, rollupConfig$1) => {
+		rollupConfig$1.plugins = rollupConfig$1.plugins || [];
+		const { include = /\.(graphql|gql)$/i, exclude, validate = false } = app.options.graphql?.loader || {};
+		if (Array.isArray(rollupConfig$1.plugins)) {
+			rollupConfig$1.plugins.push({
+				name: "nitro-graphql",
+				async load(id) {
+					if (exclude?.test?.(id)) return null;
+					if (!include.test(id)) return null;
+					try {
+						const content = await readFile(id, "utf-8");
+						if (validate) parse(content);
+						return `export default ${JSON.stringify(content)}`;
+					} catch (error) {
+						if (error.code === "ENOENT") return null;
+						this.error(`Failed to read GraphQL file ${id}: ${error.message}`);
+					}
+				}
+			});
+			rollupConfig$1.plugins.push({
+				name: "nitro-graphql-watcher",
+				async buildStart() {
+					const graphqlFiles = await scanGraphql(nitro);
+					for (const file of graphqlFiles) this.addWatchFile(file);
+					this.addWatchFile("server/graphql/");
+				}
+			});
+		}
+	});
+	app.hooks.hook("dev:reload", async () => {
+		await serverTypeGeneration(app);
+	});
+}
+function virtualDefs(app) {
+	const getDefs = () => {
+		const defs = [...app.scanDefs, ...app.options.graphql?.typedefs ?? []];
+		return defs;
+	};
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-internal-virtual/server-defs"] = () => {
+		const imports = getDefs();
+		const code = `
+${imports.map((handler) => `import ${getImportId(handler)} from '${handler}';`).join("\n")}
+
+export const defs = [
+${imports.map((h) => `{ def: ${getImportId(h)} }`).join(",\n")}
+];
+    `;
+		return code;
+	};
+}
+function virtualResolvers(app) {
+	const getResolvers = () => {
+		const resolvers = [...app.scanResolvers];
+		return resolvers;
+	};
+	app.options.virtual ??= {};
+	app.options.virtual["#nitro-internal-virtual/server-resolvers"] = () => {
+		const imports = getResolvers();
+		const importsContent = [...imports.map(({ specifier, imports: imports$1, options }) => {
+			return genImport(specifier, imports$1, options);
+		})];
+		const data = imports.map(({ imports: imports$1 }) => imports$1.map((i) => `{ resolver: ${i.as} }`).join(",\n")).filter(Boolean).join(",\n");
+		const content = [
+			"export const resolvers = [",
+			data,
+			"]",
+			""
+		];
+		content.unshift(...importsContent);
+		const code = content.join("\n");
+		return code;
+	};
+}
+
+//#endregion
+export { rollupConfig };

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

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

package/dist/routes/apollo-server.js

@@ -0,0 +1,39 @@
+import { startServerAndCreateH3Handler } from "../utils/apollo.js";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { defs } from "#nitro-internal-virtual/server-defs";
+import { resolvers } from "#nitro-internal-virtual/server-resolvers";
+import { ApolloServer } from "@apollo/server";
+import { ApolloServerPluginLandingPageLocalDefault } from "@apollo/server/plugin/landingPage/default";
+
+//#region src/routes/apollo-server.ts
+function createMergedSchema() {
+	try {
+		const mergedDefs = defs.map((schema) => schema.def).join("\n\n");
+		const typeDefs = mergeTypeDefs([mergedDefs]);
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		return {
+			typeDefs,
+			resolvers: mergedResolvers
+		};
+	} catch (error) {
+		console.error("Schema merge error:", error);
+		throw error;
+	}
+}
+let apolloServer;
+function createApolloServer() {
+	if (!apolloServer) {
+		const { typeDefs, resolvers: mergedResolvers } = createMergedSchema();
+		apolloServer = new ApolloServer({
+			typeDefs,
+			resolvers: mergedResolvers,
+			introspection: true,
+			plugins: [ApolloServerPluginLandingPageLocalDefault({ embed: true })]
+		});
+	}
+	return apolloServer;
+}
+var apollo_server_default = startServerAndCreateH3Handler(createApolloServer, { context: async (event) => ({ event }) });
+
+//#endregion
+export { apollo_server_default as default };

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

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

package/dist/routes/graphql-yoga.js

@@ -0,0 +1,56 @@
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { defs } from "#nitro-internal-virtual/server-defs";
+import { resolvers } from "#nitro-internal-virtual/server-resolvers";
+import { defineEventHandler, toWebRequest } from "h3";
+import { createSchema, createYoga } from "graphql-yoga";
+
+//#region src/routes/graphql-yoga.ts
+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>`;
+function createMergedSchema() {
+	try {
+		const mergedDefs = defs.map((schema) => schema.def).join("\n\n");
+		const typeDefs = mergeTypeDefs([mergedDefs]);
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		return createSchema({
+			typeDefs,
+			resolvers: mergedResolvers
+		});
+	} catch (error) {
+		console.error("Schema merge error:", error);
+		throw error;
+	}
+}
+let yoga;
+var graphql_yoga_default = defineEventHandler(async (event) => {
+	if (!yoga) {
+		const schema = createMergedSchema();
+		yoga = createYoga({
+			schema,
+			graphqlEndpoint: "/api/graphql",
+			landingPage: false,
+			renderGraphiQL: () => apolloSandboxHtml
+		});
+	}
+	const request = toWebRequest(event);
+	const response = await yoga.handleRequest(request, event);
+	return new Response(response.body, response);
+});
+
+//#endregion
+export { graphql_yoga_default as default };

package/dist/routes/health.d.ts

@@ -0,0 +1,10 @@
+import * as h36 from "h3";
+
+//#region src/routes/health.d.ts
+declare const _default: h36.EventHandler<h36.EventHandlerRequest, Promise<{
+  status: string;
+  message: string;
+  timestamp: string;
+}>>;
+//#endregion
+export { _default as default };

package/dist/routes/health.js

@@ -0,0 +1,44 @@
+import { defineEventHandler, setResponseStatus } from "h3";
+import { useRuntimeConfig } from "nitropack/runtime";
+
+//#region src/routes/health.ts
+var health_default = defineEventHandler(async (event) => {
+	const runtime = useRuntimeConfig();
+	if (!runtime.graphql || !runtime.graphql.endpoint?.graphql) {
+		setResponseStatus(event, 404);
+		return {
+			status: "error",
+			message: "GraphQL health check endpoint is not configured",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+	try {
+		const response = await $fetch(runtime.graphql.endpoint?.graphql, {
+			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: (/* @__PURE__ */ new Date()).toISOString()
+		};
+		throw new Error("Invalid response from GraphQL server");
+	} catch (error) {
+		setResponseStatus(event, 503);
+		return {
+			status: "unhealthy",
+			message: error instanceof Error ? error.message : "GraphQL server is not responding",
+			timestamp: (/* @__PURE__ */ new Date()).toISOString()
+		};
+	}
+});
+
+//#endregion
+export { health_default as default };

package/dist/types/index.d.ts

@@ -0,0 +1,67 @@
+import { StandardSchemaV1 } from "./standard-schema.js";
+import { ESMCodeGenOptions } from "knitwork";
+import { IResolvers } from "@graphql-tools/utils";
+import { TypeScriptPluginConfig } from "@graphql-codegen/typescript";
+import { TypeScriptDocumentsPluginConfig } from "@graphql-codegen/typescript-operations";
+import { TypeScriptResolversPluginConfig } from "@graphql-codegen/typescript-resolvers";
+
+//#region src/types/index.d.ts
+type CodegenServerConfig = TypeScriptPluginConfig & TypeScriptResolversPluginConfig;
+interface IESMImport {
+  name: string;
+  as?: string;
+  type: 'resolver' | 'query' | 'mutation' | 'type' | 'subscription';
+}
+interface GenImport {
+  specifier: string;
+  imports: IESMImport[];
+  options?: ESMCodeGenOptions;
+}
+declare module 'nitropack/types' {
+  interface Nitro {
+    scanDefs: string[];
+    scanResolvers: GenImport[];
+    graphql: {
+      buildDir: string;
+      watchDirs: string[];
+      clientDir: string;
+      serverDir: string;
+    };
+  }
+}
+declare module 'nitropack' {
+  interface NitroOptions {
+    graphql?: NitroGraphQLOptions;
+  }
+  interface NitroRuntimeConfig {
+    graphql?: NitroGraphQLOptions;
+  }
+  interface NitroConfig {
+    graphql?: NitroGraphQLOptions;
+  }
+}
+interface CodegenClientConfig extends TypeScriptPluginConfig, TypeScriptDocumentsPluginConfig {
+  endpoint?: string;
+  documentMode?: 'string' | 'graphQLTag' | 'documentNode' | 'documentNodeImportFragments' | 'external';
+}
+interface NitroGraphQLOptions {
+  framework: 'graphql-yoga' | 'apollo-server';
+  endpoint?: {
+    graphql?: string;
+    healthCheck?: string;
+  };
+  playground?: boolean;
+  typedefs?: string[];
+  resolvers?: Array<IResolvers<any, any>>;
+  loader?: {
+    include?: RegExp;
+    exclude?: RegExp;
+    validate?: boolean;
+  };
+  codegen?: {
+    server?: CodegenServerConfig;
+    client?: CodegenClientConfig;
+  };
+}
+//#endregion
+export { CodegenClientConfig, CodegenServerConfig, GenImport, NitroGraphQLOptions };

package/dist/types/standard-schema.d.ts

@@ -0,0 +1,59 @@
+//#region src/types/standard-schema.d.ts
+/** The Standard Schema interface. */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+  /** The Standard Schema properties. */
+  readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+  /** The Standard Schema properties interface. */
+  export interface Props<Input = unknown, Output = Input> {
+    /** The version number of the standard. */
+    readonly version: 1;
+    /** The vendor name of the schema library. */
+    readonly vendor: string;
+    /** Validates unknown input values. */
+    readonly validate: (value: unknown) => Result<Output> | Promise<Result<Output>>;
+    /** Inferred types associated with the schema. */
+    readonly types?: Types<Input, Output> | undefined;
+  }
+  /** The result interface of the validate function. */
+  export type Result<Output> = SuccessResult<Output> | FailureResult;
+  /** The result interface if validation succeeds. */
+  export interface SuccessResult<Output> {
+    /** The typed output value. */
+    readonly value: Output;
+    /** The non-existent issues. */
+    readonly issues?: undefined;
+  }
+  /** The result interface if validation fails. */
+  export interface FailureResult {
+    /** The issues of failed validation. */
+    readonly issues: ReadonlyArray<Issue>;
+  }
+  /** The issue interface of the failure output. */
+  export interface Issue {
+    /** The error message of the issue. */
+    readonly message: string;
+    /** The path of the issue, if any. */
+    readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+  }
+  /** The path segment interface of the issue. */
+  export interface PathSegment {
+    /** The key representing a path segment. */
+    readonly key: PropertyKey;
+  }
+  /** The Standard Schema types interface. */
+  export interface Types<Input = unknown, Output = Input> {
+    /** The input type of the schema. */
+    readonly input: Input;
+    /** The output type of the schema. */
+    readonly output: Output;
+  }
+  /** Infers the input type of a Standard Schema. */
+  export type InferInput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['input'];
+  /** Infers the output type of a Standard Schema. */
+  export type InferOutput<Schema extends StandardSchemaV1> = NonNullable<Schema['~standard']['types']>['output'];
+  export {};
+}
+//#endregion
+export { StandardSchemaV1 };

package/dist/utils/apollo.js

@@ -0,0 +1,62 @@
+import { HeaderMap } from "@apollo/server";
+import { eventHandler, getHeaders, isMethod, readBody, setHeaders } from "h3";
+
+//#region src/utils/apollo.ts
+function startServerAndCreateH3Handler(server, options) {
+	const apolloServer = typeof server === "function" ? server() : server;
+	apolloServer.startInBackgroundHandlingStartupErrorsByLoggingAndFailingAllRequests();
+	const defaultContext = () => Promise.resolve({});
+	const contextFunction = options?.context ?? defaultContext;
+	return eventHandler({
+		handler: async (event) => {
+			if (isMethod(event, "OPTIONS")) return null;
+			try {
+				const graphqlRequest = await toGraphqlRequest(event);
+				const { body, headers, status } = await apolloServer.executeHTTPGraphQLRequest({
+					httpGraphQLRequest: graphqlRequest,
+					context: () => contextFunction({ event })
+				});
+				if (body.kind === "chunked") throw new Error("Incremental delivery not implemented");
+				setHeaders(event, Object.fromEntries(headers));
+				event.res.statusCode = status || 200;
+				return body.string;
+			} catch (error) {
+				if (error instanceof SyntaxError) {
+					event.res.statusCode = 400;
+					return error.message;
+				} else throw error;
+			}
+		},
+		websocket: options?.websocket
+	});
+}
+async function toGraphqlRequest(event) {
+	return {
+		method: event.req.method || "POST",
+		headers: normalizeHeaders(getHeaders(event)),
+		search: normalizeQueryString(event.req.url),
+		body: await normalizeBody(event)
+	};
+}
+function normalizeHeaders(headers) {
+	const headerMap = new HeaderMap();
+	for (const [key, value] of Object.entries(headers)) if (Array.isArray(value)) headerMap.set(key, value.join(","));
+	else if (value) headerMap.set(key, value);
+	return headerMap;
+}
+function normalizeQueryString(url) {
+	if (!url) return "";
+	return url.split("?")[1] || "";
+}
+async function normalizeBody(event) {
+	const PayloadMethods = [
+		"PATCH",
+		"POST",
+		"PUT",
+		"DELETE"
+	];
+	if (isMethod(event, PayloadMethods)) return await readBody(event);
+}
+
+//#endregion
+export { startServerAndCreateH3Handler };

package/dist/{client-codegen.js → utils/client-codegen.js}

@@ -1,15 +1,16 @@
-import { consola } from "consola";
+import { preset } from "../node_modules/.pnpm/@graphql-codegen_import-types-preset@3.0.1_graphql@16.11.0/node_modules/@graphql-codegen/import-types-preset/esm/index.js";
+import { defu as defu$1 } from "defu";
+import { parse } from "graphql";
+import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { consola as consola$1 } from "consola";
 import { codegen } from "@graphql-codegen/core";
 import { plugin } from "@graphql-codegen/typescript";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import { defu } from "defu";
-import { parse } from "graphql";
 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";
 
-//#region src/client-codegen.ts
+//#region src/utils/client-codegen.ts
 function pluginContent(_schema, _documents, _config, _info) {
 	return {
 		prepend: [
@@ -31,13 +32,12 @@ async function loadGraphQLDocuments(patterns) {
 		else throw e;
 	}
 }
-async function generateClientTypes(schema, patterns, config = {}, outputPath) {
-	const docs = await loadGraphQLDocuments(patterns);
+async function generateClientTypes(schema, docs, config = {}, outputPath) {
 	if (docs.length === 0) {
-		consola.info("[graphql] No client GraphQL files found. Skipping client type generation.");
-		return "";
+		consola$1.info("[graphql] No client GraphQL files found. Skipping client type generation.");
+		return false;
 	}
-	consola.info(`[graphql] Found ${docs.length} client GraphQL documents`);
+	consola$1.info(`[graphql] Found ${docs.length} client GraphQL documents`);
 	const defaultConfig = {
 		documentMode: "string",
 		emitLegacyCommonJSImports: false,
@@ -54,7 +54,7 @@ async function generateClientTypes(schema, patterns, config = {}, outputPath) {
 			Currency: "string"
 		}
 	};
-	const mergedConfig = defu(config, defaultConfig);
+	const mergedConfig = defu$1(config, defaultConfig);
 	try {
 		const output = await codegen({
 			filename: outputPath || "client-types.generated.ts",
@@ -64,22 +64,58 @@ async function generateClientTypes(schema, patterns, config = {}, outputPath) {
 			plugins: [
 				{ pluginContent: {} },
 				{ typescript: {} },
+				{ typescriptOperations: {} }
+			],
+			pluginMap: {
+				pluginContent: { plugin: pluginContent },
+				typescript: { plugin },
+				typescriptOperations: { plugin: plugin$2 }
+			}
+		});
+		const sdkOutput = await preset.buildGeneratesSection({
+			baseOutputDir: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...docs],
+			config: {
+				documentMode: "string",
+				pureMagicComment: true,
+				strictScalars: true,
+				scalars: {
+					DateTime: "Date",
+					JSON: "any",
+					UUID: "string",
+					NonEmptyString: "string",
+					Currency: "string"
+				},
+				useTypeImports: true
+			},
+			presetConfig: { typesPath: "#graphql/client" },
+			plugins: [
+				{ pluginContent: {} },
 				{ typescriptOperations: {} },
 				{ typescriptGenericSdk: { rawRequest: false } }
 			],
 			pluginMap: {
 				pluginContent: { plugin: pluginContent },
-				typescript: { plugin },
 				typescriptOperations: { plugin: plugin$2 },
 				typescriptGenericSdk: { plugin: plugin$1 }
 			}
 		});
-		return output;
+		const results = await Promise.all(sdkOutput.map(async (config$1) => {
+			return {
+				file: config$1.filename,
+				content: await codegen(config$1)
+			};
+		}));
+		return {
+			types: output,
+			sdk: results[0]?.content || ""
+		};
 	} catch (error) {
-		consola.warn("[graphql] Client type generation failed:", error);
-		return "";
+		consola$1.warn("[graphql] Client type generation failed:", error);
+		return false;
 	}
 }
 
 //#endregion
-export { generateClientTypes };
+export { generateClientTypes, loadGraphQLDocuments };

package/dist/utils/define.d.ts

@@ -0,0 +1,17 @@
+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;
+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 { 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/index.d.ts

@@ -0,0 +1,15 @@
+import { GenImport } from "../types/index.js";
+import { Nitro } from "nitropack";
+
+//#region src/utils/index.d.ts
+declare const GLOB_SCAN_PATTERN = "**/*.{graphql,gql,js,mjs,cjs,ts,mts,cts,tsx,jsx}";
+declare function getImportId(p: string, lazy?: boolean): string;
+declare function relativeWithDot(from: string, to: string): string;
+declare function scanGraphql(nitro: Nitro): Promise<string[]>;
+declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
+declare function scanDirectives(nitro: Nitro): Promise<string[]>;
+declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
+declare function scanDefs(nitro: Nitro): Promise<string[]>;
+declare function unique(arr: any[]): any[];
+//#endregion
+export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDefs, scanDirectives, scanGraphql, scanResolvers, scanTypeDefs, unique };