nitro-graphql 2.0.0-beta.4 → 2.0.0-beta.41

package/dist/cli/commands/generate.mjs

@@ -0,0 +1,196 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { loadGraphQLDocuments } from "../../core/codegen/document-loader.mjs";
+import { generateClientTypesCore } from "../../core/codegen/client.mjs";
+import { generateResolverModule, generateRuntimeIndex, generateSchemaModule } from "../../core/codegen/runtime.mjs";
+import { generateServerTypesCore } from "../../core/codegen/server.mjs";
+import { scanDocumentsCore } from "../../core/scanning/documents.mjs";
+import { scanResolversCore } from "../../core/scanning/resolvers.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
+import { buildGraphQLSchema } from "../../core/schema/builder.mjs";
+import consola from "consola";
+import { dirname, join, relative } from "pathe";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+
+//#region src/cli/commands/generate.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Create ScanContext from CLI context
+*/
+function createScanContext(ctx) {
+	return {
+		rootDir: ctx.config.rootDir,
+		serverDir: ctx.config.serverDir,
+		clientDir: ctx.config.clientDir,
+		ignorePatterns: ctx.config.ignore,
+		isDev: false,
+		logger: {
+			info: (msg, ...args) => logger.info(msg, ...args),
+			warn: (msg, ...args) => logger.warn(msg, ...args),
+			error: (msg, ...args) => logger.error(msg, ...args),
+			success: (msg, ...args) => logger.success(msg, ...args),
+			debug: (msg, ...args) => logger.debug(msg, ...args)
+		},
+		layerServerDirs: [],
+		layerAppDirs: []
+	};
+}
+/**
+* Generate all types (server + client + optional runtime)
+*/
+async function generateAll(ctx, options = {}) {
+	await generateServer(ctx, options);
+	await generateClient(ctx, options);
+	if (options.runtime) await generateRuntimeFiles(ctx, options);
+	if (options.watch) await watchAndRegenerate(ctx, options);
+}
+/**
+* Generate server types
+*/
+async function generateServer(ctx, options = {}) {
+	const schemaResult = await scanSchemasCore(createScanContext(ctx));
+	if (schemaResult.errors.length > 0) for (const error of schemaResult.errors) logger.error(error);
+	if (schemaResult.items.length === 0) {
+		if (!options.silent) logger.info("No GraphQL schemas found in server directory");
+		return;
+	}
+	const schema = await buildGraphQLSchema(schemaResult.items);
+	if (!schema) {
+		logger.error("Failed to build GraphQL schema");
+		return;
+	}
+	const result = await generateServerTypesCore({
+		framework: ctx.config.framework,
+		schema,
+		config: ctx.config.codegen?.server,
+		federationEnabled: ctx.config.federation?.enabled
+	});
+	const schemaPath = join(ctx.config.buildDir, "schema.graphql");
+	mkdirSync(dirname(schemaPath), { recursive: true });
+	writeFileSync(schemaPath, result.schemaString, "utf-8");
+	const typesPath = join(ctx.config.typesDir, "nitro-graphql-server.d.ts");
+	mkdirSync(dirname(typesPath), { recursive: true });
+	writeFileSync(typesPath, result.types, "utf-8");
+	if (!options.silent) logger.success(`Generated server types: ${relative(ctx.config.rootDir, typesPath)}`);
+}
+/**
+* Generate client types
+*/
+async function generateClient(ctx, options = {}) {
+	const scanCtx = createScanContext(ctx);
+	const schemaPath = join(ctx.config.buildDir, "schema.graphql");
+	if (!existsSync(schemaPath)) {
+		if (!options.silent) logger.info("Server schema not found. Generate server types first.");
+		return;
+	}
+	const docsResult = await scanDocumentsCore(scanCtx, { externalServices: ctx.config.externalServices });
+	if (docsResult.errors.length > 0) for (const error of docsResult.errors) logger.error(error);
+	if (docsResult.items.length === 0) {
+		if (!options.silent) logger.info("No GraphQL documents found in client directory");
+		return;
+	}
+	const documents = await loadGraphQLDocuments(docsResult.items);
+	const { buildSchema } = await import("graphql");
+	const { readFileSync: readFileSync$1 } = await import("node:fs");
+	const result = await generateClientTypesCore({
+		schema: buildSchema(readFileSync$1(schemaPath, "utf-8")),
+		documents,
+		config: ctx.config.codegen?.client,
+		sdkConfig: ctx.config.codegen?.clientSDK,
+		options: { silent: options.silent }
+	});
+	if (result === false) {
+		if (!options.silent) logger.warn("Client type generation skipped");
+		return;
+	}
+	const typesPath = join(ctx.config.typesDir, "nitro-graphql-client.d.ts");
+	mkdirSync(dirname(typesPath), { recursive: true });
+	writeFileSync(typesPath, result.types, "utf-8");
+	const sdkPath = join(ctx.config.clientDir, "default", "sdk.ts");
+	mkdirSync(dirname(sdkPath), { recursive: true });
+	writeFileSync(sdkPath, result.sdk, "utf-8");
+	if (!options.silent) logger.success(`Generated client types: ${relative(ctx.config.rootDir, typesPath)}`);
+}
+/**
+* Generate runtime files (resolvers.ts, schema.ts, index.ts)
+*/
+async function generateRuntimeFiles(ctx, options = {}) {
+	const scanCtx = createScanContext(ctx);
+	const runtimeConfig = ctx.config.runtime;
+	const runtimeDir = typeof runtimeConfig === "object" && runtimeConfig.outDir ? join(ctx.config.rootDir, runtimeConfig.outDir) : join(ctx.config.buildDir, "runtime");
+	mkdirSync(runtimeDir, { recursive: true });
+	const include = typeof runtimeConfig === "object" && runtimeConfig.include ? runtimeConfig.include : {
+		resolvers: true,
+		schema: true,
+		index: true
+	};
+	if (include.resolvers !== false) {
+		const resolversResult = await scanResolversCore(scanCtx);
+		if (resolversResult.items.length > 0) {
+			const resolverCode = generateResolverModule(resolversResult.items, runtimeDir);
+			writeFileSync(join(runtimeDir, "resolvers.ts"), resolverCode, "utf-8");
+			if (!options.silent) logger.success(`Generated runtime: ${relative(ctx.config.rootDir, join(runtimeDir, "resolvers.ts"))}`);
+		} else if (!options.silent) logger.info("No resolvers found for runtime generation");
+	}
+	if (include.schema !== false) {
+		const schemaPath = join(ctx.config.buildDir, "schema.graphql");
+		if (existsSync(schemaPath)) {
+			const { readFileSync: readFileSync$1 } = await import("node:fs");
+			const schemaCode = generateSchemaModule(readFileSync$1(schemaPath, "utf-8"));
+			writeFileSync(join(runtimeDir, "schema.ts"), schemaCode, "utf-8");
+			if (!options.silent) logger.success(`Generated runtime: ${relative(ctx.config.rootDir, join(runtimeDir, "schema.ts"))}`);
+		} else if (!options.silent) logger.info("Schema not found for runtime generation. Run generate first.");
+	}
+	if (include.index !== false) {
+		const indexCode = generateRuntimeIndex();
+		writeFileSync(join(runtimeDir, "index.ts"), indexCode, "utf-8");
+		if (!options.silent) logger.success(`Generated runtime: ${relative(ctx.config.rootDir, join(runtimeDir, "index.ts"))}`);
+	}
+}
+/**
+* Watch mode - regenerate on file changes
+*/
+async function watchAndRegenerate(ctx, options = {}) {
+	const { watch } = await import("chokidar");
+	const watchDirs = [ctx.config.serverDir, ctx.config.clientDir];
+	const watcher = watch(watchDirs, {
+		ignoreInitial: true,
+		ignored: [
+			...ctx.config.ignore || [],
+			/node_modules/,
+			/\.git/
+		],
+		persistent: true
+	});
+	await new Promise((resolve$1) => {
+		watcher.on("ready", resolve$1);
+		watcher.on("error", (error) => logger.error("Watcher error:", error));
+	});
+	const relPath = (p) => relative(ctx.config.rootDir, p) || ".";
+	logger.info(`Watching: ${watchDirs.map(relPath).join(", ")}`);
+	let debounceTimer = null;
+	const debounceMs = ctx.config.watch?.debounce ?? 300;
+	watcher.on("all", (event, filePath) => {
+		if (!filePath.endsWith(".graphql") && !filePath.endsWith(".resolver.ts")) return;
+		if (debounceTimer) clearTimeout(debounceTimer);
+		debounceTimer = setTimeout(async () => {
+			try {
+				await generateAll(ctx, {
+					silent: options.silent ?? true,
+					watch: false
+				});
+				logger.success(`Types regenerated (${relPath(filePath)})`);
+			} catch (error) {
+				logger.error("Regeneration failed:", error);
+			}
+		}, debounceMs);
+	});
+	await new Promise((resolve$1) => {
+		process.on("SIGINT", () => {
+			watcher.close();
+			resolve$1();
+		});
+	});
+}
+
+//#endregion
+export { generateAll, generateClient, generateServer };

package/dist/cli/commands/index.d.mts

@@ -0,0 +1,4 @@
+import { generateAll, generateClient, generateServer } from "./generate.mjs";
+import { init } from "./init.mjs";
+import { validate } from "./validate.mjs";
+export { generateAll, generateClient, generateServer, init, validate };

package/dist/cli/commands/index.mjs

@@ -0,0 +1,5 @@
+import { init } from "./init.mjs";
+import { generateAll, generateClient, generateServer } from "./generate.mjs";
+import { validate } from "./validate.mjs";
+
+export { generateAll, generateClient, generateServer, init, validate };

package/dist/cli/commands/init.d.mts

@@ -0,0 +1,46 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/init.d.ts
+
+/**
+ * Available templates from the examples directory
+ */
+declare const AVAILABLE_TEMPLATES: readonly [{
+  readonly name: "nitro";
+  readonly description: "Minimal Nitro + GraphQL starter";
+}, {
+  readonly name: "drizzle-orm";
+  readonly description: "Nitro + GraphQL + Drizzle ORM with PostgreSQL";
+}, {
+  readonly name: "vite";
+  readonly description: "Vite + Nitro GraphQL integration";
+}, {
+  readonly name: "vite-react";
+  readonly description: "Vite + React + Nitro GraphQL";
+}, {
+  readonly name: "vite-vue";
+  readonly description: "Vite + Vue + Nitro GraphQL";
+}, {
+  readonly name: "better-auth";
+  readonly description: "Nitro + GraphQL + Better Auth integration";
+}];
+type TemplateName = typeof AVAILABLE_TEMPLATES[number]['name'];
+/**
+ * List available templates
+ */
+declare function listTemplates(): void;
+/**
+ * Initialize project from template
+ */
+declare function initFromTemplate(projectName: string, templateName: string, options?: {
+  force?: boolean;
+  cwd?: string;
+}): Promise<void>;
+/**
+ * Initialize project structure (basic scaffolding)
+ */
+declare function init(ctx: CLIContext, options?: {
+  force?: boolean;
+}): Promise<void>;
+//#endregion
+export { AVAILABLE_TEMPLATES, TemplateName, init, initFromTemplate, listTemplates };

package/dist/cli/commands/init.mjs

@@ -0,0 +1,195 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import consola from "consola";
+import { basename, join, relative, resolve } from "pathe";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { downloadTemplate } from "giget";
+
+//#region src/cli/commands/init.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Available templates from the examples directory
+*/
+const AVAILABLE_TEMPLATES = [
+	{
+		name: "nitro",
+		description: "Minimal Nitro + GraphQL starter"
+	},
+	{
+		name: "drizzle-orm",
+		description: "Nitro + GraphQL + Drizzle ORM with PostgreSQL"
+	},
+	{
+		name: "vite",
+		description: "Vite + Nitro GraphQL integration"
+	},
+	{
+		name: "vite-react",
+		description: "Vite + React + Nitro GraphQL"
+	},
+	{
+		name: "vite-vue",
+		description: "Vite + Vue + Nitro GraphQL"
+	},
+	{
+		name: "better-auth",
+		description: "Nitro + GraphQL + Better Auth integration"
+	}
+];
+/**
+* Default GitHub template source
+*/
+const DEFAULT_TEMPLATE_REGISTRY = "github:productdevbook/nitro-graphql/examples";
+/**
+* List available templates
+*/
+function listTemplates() {
+	logger.info("Available templates:\n");
+	for (const template of AVAILABLE_TEMPLATES) console.log(`  ${template.name.padEnd(15)} - ${template.description}`);
+	console.log("\nUsage:");
+	console.log("  nitro-graphql init <project-name> --template <template-name>");
+	console.log("  nitro-graphql init my-app -t drizzle-orm");
+	console.log("\nCustom templates:");
+	console.log("  nitro-graphql init my-app -t gh:user/repo");
+	console.log("  nitro-graphql init my-app -t github:user/repo/subdir");
+}
+/**
+* Initialize project from template
+*/
+async function initFromTemplate(projectName, templateName, options = {}) {
+	const { force, cwd = process.cwd() } = options;
+	const targetDir = resolve(cwd, projectName);
+	if (existsSync(targetDir) && !force) {
+		logger.error(`Directory "${projectName}" already exists. Use --force to overwrite.`);
+		process.exit(1);
+	}
+	let templateSource;
+	if (templateName.includes(":") || templateName.includes("/")) templateSource = templateName;
+	else {
+		if (!AVAILABLE_TEMPLATES.find((t) => t.name === templateName)) {
+			logger.error(`Unknown template: "${templateName}"`);
+			logger.info("Use --list to see available templates");
+			process.exit(1);
+		}
+		templateSource = `${DEFAULT_TEMPLATE_REGISTRY}/${templateName}`;
+	}
+	logger.info(`Downloading template: ${templateName}`);
+	logger.debug(`Source: ${templateSource}`);
+	try {
+		const result = await downloadTemplate(templateSource, {
+			dir: targetDir,
+			force
+		});
+		logger.success(`Template downloaded to: ${result.dir}`);
+		const packageJsonPath = join(targetDir, "package.json");
+		if (existsSync(packageJsonPath)) try {
+			const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+			packageJson.name = basename(projectName).replace(/[^a-z0-9-]/gi, "-").replace(/^-+|-+$/g, "").toLowerCase() || "my-graphql-app";
+			writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}\n`, "utf-8");
+			logger.debug(`Updated package.json name to: ${packageJson.name}`);
+		} catch {
+			logger.warn("Could not update package.json name");
+		}
+		console.log("");
+		logger.info("Next steps:");
+		console.log(`  cd ${projectName}`);
+		console.log("  pnpm install");
+		console.log("  pnpm dev");
+		console.log("");
+	} catch (error) {
+		logger.error("Failed to download template:", error);
+		process.exit(1);
+	}
+}
+/**
+* Initialize project structure (basic scaffolding)
+*/
+async function init(ctx, options = {}) {
+	const { force } = options;
+	const dirs = [ctx.config.serverDir, ctx.config.clientDir];
+	for (const dir of dirs) if (!existsSync(dir)) {
+		mkdirSync(dir, { recursive: true });
+		logger.info(`Created directory: ${dir}`);
+	}
+	const configPath = join(ctx.config.rootDir, "nitro-graphql.config.ts");
+	if (force || !existsSync(configPath)) {
+		const relativeServerDir = relative(ctx.config.rootDir, ctx.config.serverDir) || "server/graphql";
+		const relativeClientDir = relative(ctx.config.rootDir, ctx.config.clientDir) || "graphql";
+		writeFileSync(configPath, `import { defineConfig } from 'nitro-graphql/cli'
+
+export default defineConfig({
+  framework: '${ctx.config.framework}',
+  serverDir: './${relativeServerDir}',
+  clientDir: './${relativeClientDir}',
+})
+`, "utf-8");
+		logger.success(`Created config file: ${configPath}`);
+	} else logger.info(`Config file already exists: ${configPath}`);
+	const tsconfigPath = join(ctx.config.rootDir, "tsconfig.json");
+	if (force || !existsSync(tsconfigPath)) {
+		const relativeBuildDir = relative(ctx.config.rootDir, ctx.config.buildDir) || ".graphql";
+		writeFileSync(tsconfigPath, `{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "paths": {
+      "#graphql/server": ["./${relativeBuildDir}/types/nitro-graphql-server.d.ts"],
+      "#graphql/client": ["./${relativeBuildDir}/types/nitro-graphql-client.d.ts"],
+      "#graphql/schema": ["./${relative(ctx.config.rootDir, ctx.config.serverDir) || "server/graphql"}/schema.ts"]
+    }
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["node_modules", "${relativeBuildDir}"]
+}
+`, "utf-8");
+		logger.success(`Created tsconfig.json: ${tsconfigPath}`);
+	} else logger.info(`tsconfig.json already exists: ${tsconfigPath}`);
+	const schemaPath = join(ctx.config.serverDir, "schema.graphql");
+	if (force || !existsSync(schemaPath)) {
+		writeFileSync(schemaPath, `# GraphQL Schema
+# Add your type definitions here
+
+type Query {
+  hello: String!
+}
+
+type Mutation {
+  # Add your mutations here
+  _empty: String
+}
+`, "utf-8");
+		logger.success(`Created example schema: ${schemaPath}`);
+	} else logger.info(`Schema file already exists: ${schemaPath}`);
+	const resolverPath = join(ctx.config.serverDir, "hello.resolver.ts");
+	if (force || !existsSync(resolverPath)) {
+		writeFileSync(resolverPath, `import { defineQuery } from 'nitro-graphql/define'
+
+export const helloQueries = defineQuery({
+  hello: () => 'Hello, world!',
+})
+`, "utf-8");
+		logger.success(`Created example resolver: ${resolverPath}`);
+	} else logger.info(`Resolver file already exists: ${resolverPath}`);
+	const queryPath = join(ctx.config.clientDir, "hello.graphql");
+	if (force || !existsSync(queryPath)) {
+		writeFileSync(queryPath, `query Hello {
+  hello
+}
+`, "utf-8");
+		logger.success(`Created example query: ${queryPath}`);
+	} else logger.info(`Query file already exists: ${queryPath}`);
+	logger.info("");
+	logger.info("Next steps:");
+	logger.info("  1. Run \"nitro-graphql generate\" to generate types");
+	logger.info("  2. Add more schemas to your server directory");
+	logger.info("  3. Add more queries/mutations to your client directory");
+}
+
+//#endregion
+export { AVAILABLE_TEMPLATES, init, initFromTemplate, listTemplates };

package/dist/cli/commands/validate.d.mts

@@ -0,0 +1,10 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/validate.d.ts
+
+/**
+ * Validate GraphQL schemas
+ */
+declare function validate(ctx: CLIContext): Promise<boolean>;
+//#endregion
+export { validate };

package/dist/cli/commands/validate.mjs

@@ -0,0 +1,69 @@
+import { LOG_TAG } from "../../core/constants.mjs";
+import { validateNoDuplicateTypes } from "../../core/codegen/validation.mjs";
+import { scanSchemasCore } from "../../core/scanning/schemas.mjs";
+import consola from "consola";
+import { existsSync, readFileSync } from "node:fs";
+
+//#region src/cli/commands/validate.ts
+const logger = consola.withTag(LOG_TAG);
+/**
+* Validate GraphQL schemas
+*/
+async function validate(ctx) {
+	const schemaResult = await scanSchemasCore({
+		rootDir: ctx.config.rootDir,
+		serverDir: ctx.config.serverDir,
+		clientDir: ctx.config.clientDir,
+		ignorePatterns: ctx.config.ignore,
+		isDev: false,
+		logger: {
+			info: (msg, ...args) => logger.info(msg, ...args),
+			warn: (msg, ...args) => logger.warn(msg, ...args),
+			error: (msg, ...args) => logger.error(msg, ...args),
+			success: (msg, ...args) => logger.success(msg, ...args),
+			debug: (msg, ...args) => logger.debug(msg, ...args)
+		},
+		layerServerDirs: [],
+		layerAppDirs: []
+	});
+	if (schemaResult.errors.length > 0) {
+		for (const error of schemaResult.errors) logger.error(error);
+		return false;
+	}
+	if (schemaResult.items.length === 0) {
+		logger.warn("No GraphQL schemas found to validate");
+		return true;
+	}
+	const schemaContents = [];
+	for (const schemaPath of schemaResult.items) {
+		if (!existsSync(schemaPath)) {
+			logger.error(`Schema file not found: ${schemaPath}`);
+			return false;
+		}
+		try {
+			const content = readFileSync(schemaPath, "utf-8");
+			schemaContents.push(content);
+		} catch (error) {
+			logger.error(`Failed to read schema file ${schemaPath}:`, error);
+			return false;
+		}
+	}
+	if (!validateNoDuplicateTypes(schemaResult.items, schemaContents)) {
+		logger.error("Schema validation failed");
+		return false;
+	}
+	try {
+		const { buildSchema, print } = await import("graphql");
+		const { mergeTypeDefs } = await import("@graphql-tools/merge");
+		const mergedTypeDefs = mergeTypeDefs(schemaContents);
+		buildSchema(typeof mergedTypeDefs === "string" ? mergedTypeDefs : print(mergedTypeDefs));
+		logger.info(`Validated ${schemaResult.items.length} schema file(s)`);
+		return true;
+	} catch (error) {
+		logger.error("Schema syntax error:", error);
+		return false;
+	}
+}
+
+//#endregion
+export { validate };

package/dist/cli/completions.d.mts

@@ -0,0 +1,7 @@
+import { ArgsDef, CommandDef } from "citty";
+
+//#region src/cli/completions.d.ts
+
+declare function initCompletions<T extends ArgsDef = ArgsDef>(command: CommandDef<T>): Promise<void>;
+//#endregion
+export { initCompletions };

package/dist/cli/completions.mjs

@@ -0,0 +1,34 @@
+import { AVAILABLE_TEMPLATES } from "./commands/init.mjs";
+
+//#region src/cli/completions.ts
+async function initCompletions(command) {
+	const { default: tab } = await import("@bomb.sh/tab/citty");
+	await tab(command, { subCommands: {
+		"init": { options: {
+			template: (complete) => {
+				for (const template of AVAILABLE_TEMPLATES) complete(template.name, template.description);
+				complete("gh:", "GitHub shorthand (gh:user/repo)");
+				complete("github:", "GitHub template (github:user/repo/path)");
+				complete("gitlab:", "GitLab template (gitlab:user/repo)");
+			},
+			cwd: (complete) => {
+				complete(".", "Current directory");
+			}
+		} },
+		"generate": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } },
+		"generate:server": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } },
+		"generate:client": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } },
+		"validate": { options: { cwd: (complete) => {
+			complete(".", "Current directory");
+		} } }
+	} });
+}
+
+//#endregion
+export { initCompletions };

package/dist/cli/config.d.mts

@@ -0,0 +1,75 @@
+import { GraphQLFramework } from "../core/constants.mjs";
+import { CoreClientUtilsConfig, CoreCodegenConfig, CoreExternalService, CoreFederationConfig, CorePathsConfig, CoreScaffoldConfig, CoreSdkConfig, CoreSecurityConfig, CoreTypesConfig } from "../core/types/config.mjs";
+import "../core/types/index.mjs";
+
+//#region src/cli/config.d.ts
+
+/**
+ * CLI configuration options
+ * Used when running nitro-graphql as a standalone CLI tool
+ */
+interface CLIConfig {
+  /** Root directory (defaults to current working directory) */
+  rootDir?: string;
+  /** Build output directory */
+  buildDir?: string;
+  /** Server GraphQL directory (defaults to 'server/graphql') */
+  serverDir?: string;
+  /** Client GraphQL directory (defaults to 'graphql') */
+  clientDir?: string;
+  /** Types output directory */
+  typesDir?: string;
+  /** GraphQL framework (defaults to 'graphql-yoga') */
+  framework?: GraphQLFramework;
+  /** Codegen configuration */
+  codegen?: CoreCodegenConfig;
+  /** Security configuration */
+  security?: CoreSecurityConfig;
+  /** External GraphQL services */
+  externalServices?: CoreExternalService[];
+  /** Apollo Federation configuration */
+  federation?: CoreFederationConfig;
+  /** Path configuration */
+  paths?: CorePathsConfig;
+  /** Scaffold file configuration */
+  scaffold?: false | CoreScaffoldConfig;
+  /** Type generation configuration */
+  types?: false | CoreTypesConfig;
+  /** SDK generation configuration */
+  sdk?: false | CoreSdkConfig;
+  /** Client utilities configuration */
+  clientUtils?: false | CoreClientUtilsConfig;
+  /** Patterns to ignore during scanning */
+  ignore?: string[];
+  /** Watch mode configuration */
+  watch?: {
+    /** Enable watch mode */
+    enabled?: boolean;
+    /** Debounce time in ms */
+    debounce?: number;
+  };
+  /**
+   * Runtime file generation
+   * Generates resolvers.ts, schema.ts for standalone server usage
+   */
+  runtime?: boolean | {
+    /** Output directory for runtime files (defaults to '{buildDir}/runtime') */
+    outDir?: string;
+    /** What to include in generation */
+    include?: {
+      resolvers?: boolean;
+      schema?: boolean;
+      index?: boolean;
+    };
+  };
+}
+/**
+ * Define CLI configuration with type safety
+ */
+declare function defineConfig(config: CLIConfig): CLIConfig;
+/**
+ * Default CLI configuration values
+ */
+declare const DEFAULT_CLI_CONFIG: CLIConfig;
+//#endregion
+export { CLIConfig, DEFAULT_CLI_CONFIG, defineConfig };

package/dist/cli/config.mjs

@@ -0,0 +1,20 @@
+//#region src/cli/config.ts
+/**
+* Define CLI configuration with type safety
+*/
+function defineConfig(config) {
+	return config;
+}
+/**
+* Default CLI configuration values
+*/
+const DEFAULT_CLI_CONFIG = {
+	framework: "graphql-yoga",
+	serverDir: "server/graphql",
+	clientDir: "graphql",
+	buildDir: ".graphql",
+	ignore: ["**/node_modules/**", "**/dist/**"]
+};
+
+//#endregion
+export { DEFAULT_CLI_CONFIG, defineConfig };