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

package/dist/core/types/standard-schema.d.mts

@@ -0,0 +1,64 @@
+//#region src/core/types/standard-schema.d.ts
+/**
+ * Standard Schema V1 type definition
+ * Implements the Standard Schema specification for runtime validation interop
+ * @see https://github.com/standard-schema/standard-schema
+ */
+/** 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/core/utils/directive-parser.d.mts

@@ -1,80 +1,29 @@
 //#region src/core/utils/directive-parser.d.ts
 /**
  * Directive parser utilities
- * AST-based parsing for GraphQL directive definitions
+ * AST-based parsing for GraphQL directive definitions using oxc-parser
  */
 interface ParsedDirective {
   name: string;
   locations: string[];
   args?: Record<string, {
     type: string;
-    defaultValue?: any;
+    defaultValue?: string | number | boolean | null;
   }>;
   description?: string;
   isRepeatable?: boolean;
 }
 /**
- * Clean AST-based directive parser using oxc-parser
+ * Parse directives from a TypeScript/JavaScript file
  */
-declare class DirectiveParser {
-  private oxc;
-  init(): Promise<void>;
-  /**
-   * Parse directives from a TypeScript/JavaScript file
-   */
-  parseDirectives(fileContent: string, filePath: string): Promise<ParsedDirective[]>;
-  /**
-   * Extract directive definitions from AST
-   */
-  private extractDirectiveDefinitions;
-  /**
-   * Traverse AST nodes recursively
-   */
-  private traverse;
-  /**
-   * Check if node is a defineDirective call
-   */
-  private isDefineDirectiveCall;
-  /**
-   * Extract directive configuration from defineDirective call
-   */
-  private extractDirectiveFromCall;
-  /**
-   * Extract directive properties from object expression
-   */
-  private extractDirectiveFromObject;
-  /**
-   * Extract string literal value
-   */
-  private extractStringLiteral;
-  /**
-   * Extract boolean literal value
-   */
-  private extractBooleanLiteral;
-  /**
-   * Extract array of strings
-   */
-  private extractStringArray;
-  /**
-   * Extract arguments object
-   */
-  private extractArgsObject;
-  /**
-   * Extract argument configuration
-   */
-  private extractArgConfig;
-  /**
-   * Extract literal value (string, number, boolean)
-   */
-  private extractLiteralValue;
-}
+declare function parseDirectivesFromFile(fileContent: string, filePath: string): ParsedDirective[];
 /**
  * Generate GraphQL directive schema from parsed directive
  */
 declare function generateDirectiveSchema(directive: ParsedDirective): string;
 /**
  * Directive file reference
- * Can be either { fullPath } or { specifier } (for GenImport compatibility)
+ * Accepts either { fullPath } or { specifier } form
  */
 type DirectiveFileRef = {
   fullPath: string;
@@ -82,13 +31,9 @@ type DirectiveFileRef = {
   specifier: string;
 };
 /**
- * Singleton instance for reuse
- */
-declare const directiveParser: DirectiveParser;
-/**
- * Generate GraphQL schema content from an array of parsed directives
- * Returns the schema string and optionally writes to buildDir/directives.graphql
+ * Generate GraphQL schema content from directive files
+ * Parses each file, extracts defineDirective calls, and produces SDL
  */
 declare function generateDirectiveSchemas(directives: DirectiveFileRef[], buildDir?: string): Promise<string | null>;
 //#endregion
-export { DirectiveFileRef, DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };
+export { DirectiveFileRef, ParsedDirective, generateDirectiveSchema, generateDirectiveSchemas, parseDirectivesFromFile };

package/dist/core/utils/directive-parser.mjs

@@ -1,170 +1,126 @@
+import { parseSync } from "oxc-parser";
 //#region src/core/utils/directive-parser.ts
 /**
-* Clean AST-based directive parser using oxc-parser
+* Directive parser utilities
+* AST-based parsing for GraphQL directive definitions using oxc-parser
 */
-var DirectiveParser = class {
-	oxc;
-	async init() {
-		if (!this.oxc) this.oxc = await import("oxc-parser");
-	}
-	/**
-	* Parse directives from a TypeScript/JavaScript file
-	*/
-	async parseDirectives(fileContent, filePath) {
-		await this.init();
-		try {
-			const result = this.oxc.parseSync(filePath, fileContent, {
-				lang: filePath.endsWith(".ts") ? "ts" : "js",
-				sourceType: "module",
-				astType: "ts"
-			});
-			if (result.errors.length > 0) return [];
-			return this.extractDirectiveDefinitions(result.program);
-		} catch {
-			return [];
-		}
-	}
-	/**
-	* Extract directive definitions from AST
-	*/
-	extractDirectiveDefinitions(program) {
-		const directives = [];
-		this.traverse(program, (node) => {
-			if (this.isDefineDirectiveCall(node)) {
-				const directive = this.extractDirectiveFromCall(node);
-				if (directive) directives.push(directive);
+function extractStringLiteral(node) {
+	if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+}
+function extractBooleanLiteral(node) {
+	if (node?.type === "Literal" && typeof node.value === "boolean") return node.value;
+}
+function extractLiteralValue(node) {
+	if (node?.type === "Literal") return node.value ?? void 0;
+}
+function extractStringArray(node) {
+	if (node?.type !== "ArrayExpression") return [];
+	return (node.elements || []).filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
+}
+function extractArgConfig(node) {
+	if (node?.type !== "ObjectExpression") return null;
+	let type = "String";
+	let defaultValue;
+	for (const prop of node.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		switch (prop.key.name) {
+			case "type": {
+				const typeValue = extractStringLiteral(prop.value);
+				if (typeValue) type = typeValue;
+				break;
 			}
-		});
-		return directives;
-	}
-	/**
-	* Traverse AST nodes recursively
-	*/
-	traverse(node, visitor) {
-		if (!node || typeof node !== "object") return;
-		visitor(node);
-		for (const key in node) {
-			const child = node[key];
-			if (Array.isArray(child)) child.forEach((item) => this.traverse(item, visitor));
-			else if (child && typeof child === "object") this.traverse(child, visitor);
+			case "defaultValue":
+				defaultValue = extractLiteralValue(prop.value);
+				break;
 		}
 	}
-	/**
-	* Check if node is a defineDirective call
-	*/
-	isDefineDirectiveCall(node) {
-		return node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "defineDirective" && node.arguments?.length > 0;
-	}
-	/**
-	* Extract directive configuration from defineDirective call
-	*/
-	extractDirectiveFromCall(node) {
-		const arg = node.arguments[0];
-		if (arg?.type !== "ObjectExpression") return null;
-		return this.extractDirectiveFromObject(arg);
+	return {
+		type,
+		...defaultValue !== void 0 && { defaultValue }
+	};
+}
+function extractArgsObject(node) {
+	if (node?.type !== "ObjectExpression") return {};
+	const args = {};
+	for (const prop of node.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		const argConfig = extractArgConfig(prop.value);
+		if (argConfig) args[prop.key.name] = argConfig;
 	}
-	/**
-	* Extract directive properties from object expression
-	*/
-	extractDirectiveFromObject(objNode) {
-		let name = "";
-		let locations = [];
-		let args = {};
-		let description;
-		let isRepeatable;
-		for (const prop of objNode.properties || []) {
-			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
-			switch (prop.key.name) {
-				case "name":
-					name = this.extractStringLiteral(prop.value) || "";
-					break;
-				case "locations":
-					locations = this.extractStringArray(prop.value);
-					break;
-				case "args":
-					args = this.extractArgsObject(prop.value);
-					break;
-				case "description":
-					description = this.extractStringLiteral(prop.value);
-					break;
-				case "isRepeatable":
-					isRepeatable = this.extractBooleanLiteral(prop.value);
-					break;
-			}
+	return args;
+}
+function extractDirectiveFromObject(objNode) {
+	let name = "";
+	let locations = [];
+	let args = {};
+	let description;
+	let isRepeatable;
+	for (const prop of objNode.properties || []) {
+		if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+		switch (prop.key.name) {
+			case "name":
+				name = extractStringLiteral(prop.value) || "";
+				break;
+			case "locations":
+				locations = extractStringArray(prop.value);
+				break;
+			case "args":
+				args = extractArgsObject(prop.value);
+				break;
+			case "description":
+				description = extractStringLiteral(prop.value);
+				break;
+			case "isRepeatable":
+				isRepeatable = extractBooleanLiteral(prop.value);
+				break;
 		}
-		return name && locations.length > 0 ? {
-			name,
-			locations,
-			args,
-			description,
-			isRepeatable
-		} : null;
-	}
-	/**
-	* Extract string literal value
-	*/
-	extractStringLiteral(node) {
-		if (node?.type === "Literal" && typeof node.value === "string") return node.value;
-	}
-	/**
-	* Extract boolean literal value
-	*/
-	extractBooleanLiteral(node) {
-		if (node?.type === "Literal" && typeof node.value === "boolean") return node.value;
-	}
-	/**
-	* Extract array of strings
-	*/
-	extractStringArray(node) {
-		if (node?.type !== "ArrayExpression") return [];
-		return (node.elements || []).filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
 	}
-	/**
-	* Extract arguments object
-	*/
-	extractArgsObject(node) {
-		if (node?.type !== "ObjectExpression") return {};
-		const args = {};
-		for (const prop of node.properties || []) {
-			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
-			const argName = prop.key.name;
-			const argConfig = this.extractArgConfig(prop.value);
-			if (argConfig) args[argName] = argConfig;
-		}
-		return args;
+	return name && locations.length > 0 ? {
+		name,
+		locations,
+		args,
+		description,
+		isRepeatable
+	} : null;
+}
+function traverse(node, visitor) {
+	if (!node || typeof node !== "object") return;
+	visitor(node);
+	for (const key in node) {
+		const child = node[key];
+		if (Array.isArray(child)) child.forEach((item) => traverse(item, visitor));
+		else if (child && typeof child === "object") traverse(child, visitor);
 	}
-	/**
-	* Extract argument configuration
-	*/
-	extractArgConfig(node) {
-		if (node?.type !== "ObjectExpression") return null;
-		let type = "String";
-		let defaultValue;
-		for (const prop of node.properties || []) {
-			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
-			switch (prop.key.name) {
-				case "type": {
-					const typeValue = this.extractStringLiteral(prop.value);
-					if (typeValue) type = typeValue;
-					break;
+}
+function isDefineDirectiveCall(node) {
+	return node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "defineDirective" && (node.arguments?.length ?? 0) > 0;
+}
+/**
+* Parse directives from a TypeScript/JavaScript file
+*/
+function parseDirectivesFromFile(fileContent, filePath) {
+	try {
+		const result = parseSync(filePath, fileContent, {
+			lang: filePath.endsWith(".ts") ? "ts" : "js",
+			sourceType: "module",
+			astType: "ts"
+		});
+		if (result.errors.length > 0) return [];
+		const directives = [];
+		traverse(result.program, (node) => {
+			if (isDefineDirectiveCall(node)) {
+				const arg = node.arguments[0];
+				if (arg?.type === "ObjectExpression") {
+					const directive = extractDirectiveFromObject(arg);
+					if (directive) directives.push(directive);
 				}
-				case "defaultValue":
-					defaultValue = this.extractLiteralValue(prop.value);
-					break;
 			}
-		}
-		return {
-			type,
-			...defaultValue !== void 0 && { defaultValue }
-		};
-	}
-	/**
-	* Extract literal value (string, number, boolean)
-	*/
-	extractLiteralValue(node) {
-		if (node?.type === "Literal") return node.value;
+		});
+		return directives;
+	} catch {
+		return [];
 	}
-};
+}
 /**
 * Generate GraphQL directive schema from parsed directive
 */
@@ -179,19 +135,12 @@ function generateDirectiveSchema(directive) {
 	const locations = directive.locations.join(" | ");
 	return `directive @${directive.name}${args} on ${locations}`;
 }
-/**
-* Get the file path from a directive reference
-*/
 function getFilePath(ref) {
 	return "fullPath" in ref ? ref.fullPath : ref.specifier;
 }
 /**
-* Singleton instance for reuse
-*/
-const directiveParser = new DirectiveParser();
-/**
-* Generate GraphQL schema content from an array of parsed directives
-* Returns the schema string and optionally writes to buildDir/directives.graphql
+* Generate GraphQL schema content from directive files
+* Parses each file, extracts defineDirective calls, and produces SDL
 */
 async function generateDirectiveSchemas(directives, buildDir) {
 	if (directives.length === 0) return null;
@@ -200,8 +149,7 @@ async function generateDirectiveSchemas(directives, buildDir) {
 	const allParsedDirectives = [];
 	for (const directive of directives) try {
 		const filePath = getFilePath(directive);
-		const content = fs.readFileSync(filePath, "utf-8");
-		const parsed = await directiveParser.parseDirectives(content, filePath);
+		const parsed = parseDirectivesFromFile(fs.readFileSync(filePath, "utf-8"), filePath);
 		allParsedDirectives.push(...parsed);
 	} catch {}
 	if (allParsedDirectives.length === 0) return null;
@@ -214,4 +162,4 @@ async function generateDirectiveSchemas(directives, buildDir) {
 	return schemaContent;
 }
 //#endregion
-export { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };
+export { generateDirectiveSchema, generateDirectiveSchemas, parseDirectivesFromFile };

package/dist/core/utils/file-io.d.mts

@@ -16,9 +16,5 @@ declare function writeFileIfChanged(path: string, content: string): boolean;
  * Ensure directory exists
  */
 declare function ensureDir(path: string): void;
-/**
- * Read file safely, returns undefined if file doesn't exist
- */
-declare function readFileSafe(path: string): string | undefined;
 //#endregion
-export { ensureDir, readFileSafe, writeFile, writeFileIfChanged };
+export { ensureDir, writeFile, writeFileIfChanged };

package/dist/core/utils/file-io.mjs

@@ -31,15 +31,5 @@ function writeFileIfChanged(path, content) {
 function ensureDir(path) {
 	mkdirSync(path, { recursive: true });
 }
-/**
-* Read file safely, returns undefined if file doesn't exist
-*/
-function readFileSafe(path) {
-	try {
-		return readFileSync(path, "utf-8");
-	} catch {
-		return;
-	}
-}
 //#endregion
-export { ensureDir, readFileSafe, writeFile, writeFileIfChanged };
+export { ensureDir, writeFile, writeFileIfChanged };

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

@@ -1,7 +1,8 @@
-import { DirectiveFileRef, DirectiveParser, ParsedDirective, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
+import { DirectiveFileRef, ParsedDirective, generateDirectiveSchema, generateDirectiveSchemas, parseDirectivesFromFile } from "./directive-parser.mjs";
 import { MaskErrorOptions, createDefaultMaskError } from "./errors.mjs";
-import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./file-io.mjs";
+import { ensureDir, writeFile, writeFileIfChanged } from "./file-io.mjs";
 import { getImportId, relativeWithDot } from "./imports.mjs";
-import { createLogger, createSilentLogger, defaultLogger } from "./logger.mjs";
+import { createLogger } from "./logger.mjs";
 import { OfetchTemplateOptions, generateOfetchTemplate } from "./ofetch-templates.mjs";
-export { DirectiveFileRef, DirectiveParser, MaskErrorOptions, OfetchTemplateOptions, ParsedDirective, createDefaultMaskError, createLogger, createSilentLogger, defaultLogger, directiveParser, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, readFileSafe, relativeWithDot, writeFile, writeFileIfChanged };
+import { capitalize } from "./string.mjs";
+export { DirectiveFileRef, MaskErrorOptions, OfetchTemplateOptions, ParsedDirective, capitalize, createDefaultMaskError, createLogger, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, parseDirectivesFromFile, relativeWithDot, writeFile, writeFileIfChanged };

package/dist/core/utils/index.mjs

@@ -1,7 +1,8 @@
-import { ensureDir, readFileSafe, writeFile, writeFileIfChanged } from "./file-io.mjs";
-import { createLogger, createSilentLogger, defaultLogger } from "./logger.mjs";
-import { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.mjs";
-import { createDefaultMaskError } from "./errors.mjs";
+import { ensureDir, writeFile, writeFileIfChanged } from "./file-io.mjs";
+import { capitalize } from "./string.mjs";
+import { createLogger } from "./logger.mjs";
 import { getImportId, relativeWithDot } from "./imports.mjs";
+import { generateDirectiveSchema, generateDirectiveSchemas, parseDirectivesFromFile } from "./directive-parser.mjs";
+import { createDefaultMaskError } from "./errors.mjs";
 import { generateOfetchTemplate } from "./ofetch-templates.mjs";
-export { DirectiveParser, createDefaultMaskError, createLogger, createSilentLogger, defaultLogger, directiveParser, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, readFileSafe, relativeWithDot, writeFile, writeFileIfChanged };
+export { capitalize, createDefaultMaskError, createLogger, ensureDir, generateDirectiveSchema, generateDirectiveSchemas, generateOfetchTemplate, getImportId, parseDirectivesFromFile, relativeWithDot, writeFile, writeFileIfChanged };

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

@@ -5,14 +5,5 @@ import { CoreLogger } from "../types/config.mjs";
  * Create a logger instance with the nitro-graphql tag
  */
 declare function createLogger(tag?: string): CoreLogger;
-/**
- * Default logger instance
- */
-declare const defaultLogger: CoreLogger;
-/**
- * Create a silent logger (no output)
- * Useful for testing or when logging should be suppressed
- */
-declare function createSilentLogger(): CoreLogger;
 //#endregion
-export { createLogger, createSilentLogger, defaultLogger };
+export { createLogger };

package/dist/core/utils/logger.mjs

@@ -14,23 +14,5 @@ function createLogger(tag = LOG_TAG) {
 		debug: (message, ...args) => logger.debug(message, ...args)
 	};
 }
-/**
-* Default logger instance
-*/
-const defaultLogger = createLogger();
-/**
-* Create a silent logger (no output)
-* Useful for testing or when logging should be suppressed
-*/
-function createSilentLogger() {
-	const noop = () => {};
-	return {
-		info: noop,
-		warn: noop,
-		error: noop,
-		success: noop,
-		debug: noop
-	};
-}
 //#endregion
-export { createLogger, createSilentLogger, defaultLogger };
+export { createLogger };

package/dist/core/utils/ofetch-templates.mjs

@@ -1,10 +1,9 @@
+import { capitalize } from "./string.mjs";
 //#region src/core/utils/ofetch-templates.ts
 /**
-* Capitalize first letter of a string
+* Shared ofetch template generation utilities
+* Used by both main client and external service code generation
 */
-function capitalize(str) {
-	return str.charAt(0).toUpperCase() + str.slice(1);
-}
 /**
 * Generate ofetch client template content
 *

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

@@ -1,5 +1,3 @@
-import { basename, dirname, join, resolve } from "pathe";
-
 //#region src/core/utils/runtime.d.ts
 /**
  * Cross-runtime compatibility layer
@@ -7,34 +5,18 @@ import { basename, dirname, join, resolve } from "pathe";
  * Provides runtime-agnostic file system and process utilities
  * that work across Node.js, Bun, and Deno.
  */
-/**
- * Read file contents asynchronously
- */
-declare function readFile(path: string): Promise<string>;
 /**
  * Read file contents synchronously
  */
 declare function readFileSync_(path: string): string;
-/**
- * Write file contents asynchronously
- */
-declare function writeFile(path: string, content: string): Promise<void>;
 /**
  * Write file contents synchronously
  */
 declare function writeFileSync_(path: string, content: string): void;
-/**
- * Check if file/directory exists asynchronously
- */
-declare function exists(path: string): Promise<boolean>;
 /**
  * Check if file/directory exists synchronously
  */
 declare function existsSync_(path: string): boolean;
-/**
- * Create directory recursively asynchronously
- */
-declare function mkdir(path: string): Promise<void>;
 /**
  * Create directory recursively synchronously
  */
@@ -59,16 +41,5 @@ declare function pathToFileURL(path: string): URL;
  * Works across Node.js, Bun, and Deno
  */
 declare function onSignal(signal: 'SIGINT' | 'SIGTERM', handler: () => void): void;
-/**
- * Read directory contents
- */
-declare function readdir(path: string): Promise<string[]>;
-/**
- * Get file/directory stats
- */
-declare function stat(path: string): Promise<{
-  isDirectory: () => boolean;
-  isFile: () => boolean;
-}>;
 //#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_ };