nitro-graphql 2.0.0-beta.37 → 2.0.0-beta.39

package/README.md

@@ -1,6 +1,6 @@
 <div align="center">
 
-<img src="./.docs/public/logo.svg" alt="Nitro GraphQL Logo" width="120" height="120">
+<img src="./.github/assets/logo.svg" alt="Nitro GraphQL Logo" width="120" height="120">
 
 # Nitro GraphQL
 
@@ -633,7 +633,7 @@ import { defineResolver, defineQuery, defineMutation, defineField, defineDirecti
 | `defineGraphQLConfig` | GraphQL server config | `defineGraphQLConfig({ maskedErrors: {...} })` |
 | `defineSchema` | Schema with Zod integration | `defineSchema({ Book: selectBookSchema })` |
 
-**Additional Utilities** from `nitro-graphql/utils`:
+**Additional Utilities** from `nitro-graphql/core`:
 - `createDefaultMaskError()` - Error handler for ZodError and HTTPError (use in `defineGraphQLConfig`)
 
 ### Type Generation

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

@@ -0,0 +1,26 @@
+import { CLIContext } from "../index.mjs";
+
+//#region src/cli/commands/generate.d.ts
+
+/**
+ * Generate all types (server + client + optional runtime)
+ */
+declare function generateAll(ctx: CLIContext, options?: {
+  silent?: boolean;
+  watch?: boolean;
+  runtime?: boolean;
+}): Promise<void>;
+/**
+ * Generate server types
+ */
+declare function generateServer(ctx: CLIContext, options?: {
+  silent?: boolean;
+}): Promise<void>;
+/**
+ * Generate client types
+ */
+declare function generateClient(ctx: CLIContext, options?: {
+  silent?: boolean;
+}): Promise<void>;
+//#endregion
+export { generateAll, generateClient, generateServer };

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,43 @@
+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: "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,191 @@
+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: "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 };