@stonecrop/nuxt 0.7.3 → 0.7.5

package/src/cli/installers/grafserv.ts

@@ -0,0 +1,308 @@
+/**
+ * GraphQL server installer
+ * Installs @stonecrop/nuxt-grafserv and scaffolds server files
+ */
+
+import { existsSync } from 'node:fs'
+import { mkdir, writeFile, readFile } from 'node:fs/promises'
+import { join, dirname } from 'pathe'
+import { fileURLToPath } from 'node:url'
+import consola from 'consola'
+import { addDependencies } from '../utils/package'
+import { updateNuxtConfig } from '../utils/config'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export interface GrafservInstallerOptions {
+	cwd: string
+	schemaPath?: string
+	resolversPath?: string
+	endpoint?: string
+}
+
+/**
+ * Install the @stonecrop/nuxt-grafserv GraphQL server
+ */
+export async function installGrafserv(options: GrafservInstallerOptions): Promise<boolean> {
+	const {
+		cwd,
+		schemaPath = 'server/schema.graphql',
+		resolversPath = 'server/resolvers.ts',
+		endpoint = '/graphql/',
+	} = options
+
+	consola.start('Installing @stonecrop/nuxt-grafserv GraphQL server...')
+
+	try {
+		// Scaffold server files first
+		await scaffoldServerFiles(cwd)
+
+		// Add dependencies - use latest published versions
+		await addDependencies(cwd, {
+			'@stonecrop/nuxt-grafserv': 'latest',
+			'@stonecrop/graphql-middleware': 'latest',
+			graphql: '^16.11.0',
+			grafast: '^1.0.0-rc.4',
+		})
+
+		// Update nuxt.config.ts
+		const configUpdated = await updateNuxtConfig(cwd, {
+			import: "import type { ModuleOptions as GrafservOptions } from '@stonecrop/nuxt-grafserv'",
+			module: "'@stonecrop/nuxt-grafserv'",
+			moduleOptions: {
+				key: 'grafserv',
+				value: `{
+		// GraphQL schema and resolvers
+		schema: '${schemaPath}',
+		resolvers: '${resolversPath}',
+
+		// GraphQL endpoint
+		url: '${endpoint}',
+
+		// Enable GraphiQL in development
+		graphiql: true,
+
+		// Graphile preset with grafserv options
+		preset: {
+			grafserv: {
+				websockets: false,
+			},
+		},
+	} as GrafservOptions`,
+			},
+		})
+
+		if (!configUpdated) {
+			consola.warn('Could not automatically update nuxt.config.ts')
+			consola.info('Please add @stonecrop/nuxt-grafserv to your modules array manually')
+		}
+
+		consola.success('@stonecrop/nuxt-grafserv installed successfully')
+		return true
+	} catch (error) {
+		consola.error('Failed to install @stonecrop/nuxt-grafserv:', error)
+		return false
+	}
+}
+
+/**
+ * Scaffold the server directory with GraphQL files
+ */
+async function scaffoldServerFiles(cwd: string): Promise<void> {
+	const serverDir = join(cwd, 'server')
+
+	// Create server directory if it doesn't exist
+	if (!existsSync(serverDir)) {
+		await mkdir(serverDir, { recursive: true })
+		consola.info('Created server/ directory')
+	}
+
+	// Scaffold schema.graphql
+	const schemaPath = join(serverDir, 'schema.graphql')
+	if (!existsSync(schemaPath)) {
+		const schemaTemplate = await loadTemplate('schema.graphql')
+		await writeFile(schemaPath, schemaTemplate, 'utf-8')
+		consola.info('Created server/schema.graphql')
+	} else {
+		consola.info('server/schema.graphql already exists, skipping')
+	}
+
+	// Scaffold resolvers.ts
+	const resolversPath = join(serverDir, 'resolvers.ts')
+	if (!existsSync(resolversPath)) {
+		const resolversTemplate = await loadTemplate('resolvers.ts')
+		await writeFile(resolversPath, resolversTemplate, 'utf-8')
+		consola.info('Created server/resolvers.ts')
+	} else {
+		consola.info('server/resolvers.ts already exists, skipping')
+	}
+
+	// Scaffold plugins.ts
+	const pluginsPath = join(serverDir, 'plugins.ts')
+	if (!existsSync(pluginsPath)) {
+		const pluginsTemplate = await loadTemplate('plugins.ts')
+		await writeFile(pluginsPath, pluginsTemplate, 'utf-8')
+		consola.info('Created server/plugins.ts')
+	} else {
+		consola.info('server/plugins.ts already exists, skipping')
+	}
+}
+
+/**
+ * Load a template file
+ */
+async function loadTemplate(filename: string): Promise<string> {
+	// Try to load from templates directory
+	const templatePath = join(__dirname, '..', '..', '..', 'templates', filename)
+
+	if (existsSync(templatePath)) {
+		return readFile(templatePath, 'utf-8')
+	}
+
+	// Fallback to inline templates
+	return getInlineTemplate(filename)
+}
+
+/**
+ * Get inline template content as fallback
+ */
+function getInlineTemplate(filename: string): string {
+	const templates: Record<string, string> = {
+		'schema.graphql': `# Stonecrop GraphQL Schema
+# Add your type definitions here
+
+scalar JSON
+
+type Query {
+	"""
+	Health check endpoint
+	"""
+	healthCheck: HealthStatus!
+
+	"""
+	Get metadata for a doctype
+	"""
+	getMeta(doctype: String!): JSON
+}
+
+type Mutation {
+	"""
+	Execute a doctype action
+	"""
+	stonecropAction(doctype: String!, action: String!, args: JSON): ActionResult!
+}
+
+type HealthStatus {
+	status: String!
+	timestamp: String!
+}
+
+type ActionResult {
+	success: Boolean!
+	data: JSON
+	error: String
+}
+`,
+		'resolvers.ts': `/**
+ * GraphQL Resolvers
+ * Add your resolver implementations here
+ */
+
+export const resolvers = {
+	Query: {
+		healthCheck: () => ({
+			status: 'healthy',
+			timestamp: new Date().toISOString(),
+		}),
+
+		getMeta: (_: unknown, { doctype }: { doctype: string }) => {
+			// TODO: Implement doctype metadata lookup
+			console.log('getMeta called for:', doctype)
+			return null
+		},
+	},
+
+	Mutation: {
+		stonecropAction: async (
+			_: unknown,
+			{ doctype, action, args }: { doctype: string; action: string; args?: unknown }
+		) => {
+			// TODO: Implement action execution
+			console.log('stonecropAction called:', { doctype, action, args })
+			return {
+				success: true,
+				data: null,
+				error: null,
+			}
+		},
+	},
+}
+
+export default resolvers
+`,
+		'plugins.ts': `/**
+ * Grafserv Plugins
+ * Add custom middleware and hooks via Grafserv plugins
+ *
+ * @see https://grafast.org/grafserv/plugins
+ */
+
+import type { GraphileConfig } from 'graphile-config'
+
+/**
+ * Example: Request logging plugin
+ */
+const loggingPlugin: GraphileConfig.Plugin = {
+	name: 'request-logging',
+	version: '1.0.0',
+	grafserv: {
+		middleware: {
+			processGraphQLRequestBody: async (next, event) => {
+				const start = Date.now()
+				console.log('[GraphQL] Request started:', {
+					path: event.request.url,
+					method: event.request.method,
+				})
+
+				const result = await next()
+
+				const duration = Date.now() - start
+				console.log(\`[GraphQL] Request completed in \${duration}ms\`)
+
+				return result
+			},
+		},
+	},
+}
+
+/**
+ * Example: Authentication plugin
+ */
+const authPlugin: GraphileConfig.Plugin = {
+	name: 'authentication',
+	version: '1.0.0',
+	grafserv: {
+		middleware: {
+			processGraphQLRequestBody: async (next, event) => {
+				// Extract authentication from headers
+				const authHeader = event.request.headers.get('authorization')
+
+				if (authHeader?.startsWith('Bearer ')) {
+					const token = authHeader.slice(7)
+					// TODO: Validate token and set user context
+					console.log('[Auth] Token received:', token)
+				} else {
+					console.log('[Auth] Anonymous request')
+				}
+
+				return next()
+			},
+		},
+	},
+}
+
+/**
+ * Export all plugins
+ * Import these in your nuxt.config.ts:
+ *
+ * import plugins from './server/plugins'
+ *
+ * export default defineNuxtConfig({
+ *   grafserv: {
+ *     preset: {
+ *       plugins
+ *     }
+ *   }
+ * })
+ */
+export const plugins: GraphileConfig.Plugin[] = [
+	loggingPlugin,
+	// authPlugin, // Uncomment to enable authentication
+]
+
+export default plugins
+`,
+	}
+
+	return templates[filename] || ''
+}

package/src/cli/installers/graphql-client.ts

@@ -0,0 +1,36 @@
+/**
+ * GraphQL client installer
+ * Installs @stonecrop/graphql-client for frontend GraphQL operations
+ */
+
+import consola from 'consola'
+import { addDependencies } from '../utils/package'
+
+export interface GraphqlClientInstallerOptions {
+	cwd: string
+}
+
+/**
+ * Install the @stonecrop/graphql-client package
+ */
+export async function installGraphqlClient(options: GraphqlClientInstallerOptions): Promise<boolean> {
+	const { cwd } = options
+
+	consola.start('Installing @stonecrop/graphql-client...')
+
+	try {
+		// Add dependencies - use latest published version
+		await addDependencies(cwd, {
+			'@stonecrop/graphql-client': 'latest',
+			graphql: '^16.11.0',
+			'graphql-request': '~6.0.0',
+		})
+
+		consola.success('@stonecrop/graphql-client installed successfully')
+		consola.info('Usage: import { createClient } from "@stonecrop/graphql-client"')
+		return true
+	} catch (error) {
+		consola.error('Failed to install @stonecrop/graphql-client:', error)
+		return false
+	}
+}

package/src/cli/installers/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Feature installers barrel export
+ */
+
+export { installFrontend, type FrontendInstallerOptions } from './frontend'
+export { installGrafserv, type GrafservInstallerOptions } from './grafserv'
+export { installGraphqlClient, type GraphqlClientInstallerOptions } from './graphql-client'
+export { installCasl, type CaslInstallerOptions } from './casl'
+export { installRockfoil, type RockfoilInstallerOptions } from './rockfoil'
+export { installDoctypes, type DoctypesInstallerOptions } from './doctypes'

package/src/cli/installers/rockfoil.ts

@@ -0,0 +1,51 @@
+/**
+ * Rockfoil installer
+ * Installs @stonecrop/rockfoil PostGraphile middleware
+ */
+
+import consola from 'consola'
+
+import { updateNuxtConfig } from '../utils/config'
+import { addDependencies } from '../utils/package'
+import { addPluginToGrafservConfig } from '../utils/plugin'
+
+export interface RockfoilInstallerOptions {
+	cwd: string
+}
+
+/**
+ * Install the @stonecrop/rockfoil PostGraphile middleware
+ */
+export async function installRockfoil(options: RockfoilInstallerOptions): Promise<boolean> {
+	const { cwd } = options
+
+	consola.start('Installing @stonecrop/rockfoil PostGraphile middleware...')
+
+	try {
+		// Add dependencies - use latest published version
+		await addDependencies(cwd, {
+			'@stonecrop/rockfoil': 'latest',
+			postgraphile: '^5.0.0-rc.4',
+		})
+
+		// Add import to nuxt.config.ts
+		await updateNuxtConfig(cwd, {
+			import: "import { createPglRockfoilPlugin } from '@stonecrop/rockfoil'",
+		})
+
+		// Add plugin to grafserv preset configuration
+		const pluginAdded = await addPluginToGrafservConfig(cwd, 'createPglRockfoilPlugin({})')
+
+		if (pluginAdded) {
+			consola.success('@stonecrop/rockfoil installed and configured successfully')
+		} else {
+			consola.success('@stonecrop/rockfoil installed successfully')
+			consola.info('Add createPglRockfoilPlugin({}) to your grafserv preset plugins array manually')
+		}
+
+		return true
+	} catch (error) {
+		consola.error('Failed to install @stonecrop/rockfoil:', error)
+		return false
+	}
+}

package/src/cli/prompts.ts

@@ -0,0 +1,204 @@
+/**
+ * Interactive prompts for feature selection
+ */
+
+import prompts from 'prompts'
+import consola from 'consola'
+import type { DetectedFeatures } from './detect'
+
+export interface SelectedFeatures {
+	frontend: boolean
+	graphql: boolean
+	graphqlClient: boolean
+	casl: boolean
+	rockfoil: boolean
+	doctypes: boolean
+}
+
+export interface PromptOptions {
+	/** Pre-selected features from CLI flags */
+	preselected?: Partial<SelectedFeatures>
+	/** Already detected features in the project */
+	detected?: DetectedFeatures
+	/** Skip confirmation prompts */
+	skipConfirm?: boolean
+}
+
+/**
+ * Prompt the user to select which features to install
+ */
+export async function promptFeatures(options: PromptOptions = {}): Promise<SelectedFeatures | null> {
+	const { preselected = {}, detected, skipConfirm } = options
+
+	// If any features are pre-selected via flags, use those
+	const hasPreselected = Object.values(preselected).some(Boolean)
+	if (hasPreselected) {
+		return {
+			frontend: preselected.frontend ?? false,
+			graphql: preselected.graphql ?? false,
+			graphqlClient: preselected.graphqlClient ?? false,
+			casl: preselected.casl ?? false,
+			rockfoil: preselected.rockfoil ?? false,
+			doctypes: preselected.doctypes ?? false,
+		}
+	}
+
+	// Build choices based on what's already installed
+	const choices = [
+		{
+			title: '@stonecrop/nuxt - Frontend module',
+			value: 'frontend',
+			description: 'Schema-driven UI components and routing',
+			disabled: detected?.hasFrontend,
+			selected: !detected?.hasFrontend,
+		},
+		{
+			title: '@stonecrop/graphql-client - GraphQL client',
+			value: 'graphqlClient',
+			description: 'GraphQL client with Stonecrop integration',
+			disabled: detected?.hasGraphqlClient,
+			selected: false,
+		},
+		{
+			title: '@stonecrop/nuxt-grafserv - GraphQL server',
+			value: 'graphql',
+			description: 'Grafserv-based GraphQL API with middleware support',
+			disabled: detected?.hasGraphql,
+			selected: false,
+		},
+		{
+			title: '@stonecrop/casl-middleware - Authorization',
+			value: 'casl',
+			description: 'CASL-based permission system for GraphQL',
+			disabled: detected?.hasCasl,
+			selected: false,
+		},
+		{
+			title: '@stonecrop/rockfoil - PostGraphile middleware',
+			value: 'rockfoil',
+			description: 'PostGraphile integration for database-driven GraphQL',
+			disabled: detected?.hasRockfoil,
+			selected: false,
+		},
+		{
+			title: 'Sample doctypes',
+			value: 'doctypes',
+			description: 'Example doctype JSON files to get started',
+			disabled: detected?.hasDoctypes,
+			selected: false,
+		},
+	]
+
+	// Filter out disabled choices for the hint
+	const availableCount = choices.filter(c => !c.disabled).length
+	if (availableCount === 0) {
+		consola.info('All Stonecrop features are already installed!')
+		return null
+	}
+
+	// Show what's already installed
+	if (detected) {
+		const installed = choices.filter(c => c.disabled)
+		if (installed.length > 0) {
+			consola.info('Already installed:')
+			for (const item of installed) {
+				consola.info(`  ✓ ${item.title}`)
+			}
+			console.log()
+		}
+	}
+
+	const response = await prompts(
+		{
+			type: 'multiselect',
+			name: 'features',
+			message: 'Select features to install',
+			choices: choices.filter(c => !c.disabled),
+			hint: '- Space to select. Return to submit',
+			instructions: false,
+		},
+		{
+			onCancel: () => {
+				consola.info('Installation cancelled')
+				process.exit(0)
+			},
+		}
+	)
+
+	if (!response.features || response.features.length === 0) {
+		consola.info('No features selected')
+		return null
+	}
+
+	const selected: SelectedFeatures = {
+		frontend: response.features.includes('frontend'),
+		graphql: response.features.includes('graphql'),
+		graphqlClient: response.features.includes('graphqlClient'),
+		casl: response.features.includes('casl'),
+		rockfoil: response.features.includes('rockfoil'),
+		doctypes: response.features.includes('doctypes'),
+	}
+
+	// Confirm selection
+	if (!skipConfirm) {
+		console.log()
+		consola.info('Selected features:')
+		if (selected.frontend) consola.info('  • @stonecrop/nuxt')
+		if (selected.graphqlClient) consola.info('  • @stonecrop/graphql-client')
+		if (selected.graphql) consola.info('  • @stonecrop/nuxt-grafserv')
+		if (selected.casl) consola.info('  • @stonecrop/casl-middleware')
+		if (selected.rockfoil) consola.info('  • @stonecrop/rockfoil')
+		if (selected.doctypes) consola.info('  • Sample doctypes')
+		console.log()
+
+		const confirm = await prompts({
+			type: 'confirm',
+			name: 'proceed',
+			message: 'Proceed with installation?',
+			initial: true,
+		})
+
+		if (!confirm.proceed) {
+			consola.info('Installation cancelled')
+			return null
+		}
+	}
+
+	return selected
+}
+
+/**
+ * Prompt for GraphQL server configuration
+ */
+export async function promptGraphqlConfig(): Promise<{
+	schemaPath: string
+	resolversPath: string
+	endpoint: string
+} | null> {
+	const response = await prompts([
+		{
+			type: 'text',
+			name: 'schemaPath',
+			message: 'GraphQL schema path',
+			initial: './server/schema.graphql',
+		},
+		{
+			type: 'text',
+			name: 'resolversPath',
+			message: 'Resolvers file path',
+			initial: './server/resolvers.ts',
+		},
+		{
+			type: 'text',
+			name: 'endpoint',
+			message: 'GraphQL endpoint URL',
+			initial: '/graphql/',
+		},
+	])
+
+	if (!response.schemaPath) {
+		return null
+	}
+
+	return response
+}