@stonecrop/nuxt 0.7.3 → 0.7.5

package/src/cli/index.ts

@@ -0,0 +1,184 @@
+/**
+ * Stonecrop Nuxt CLI - Main Installer
+ *
+ * Orchestrates the installation of Stonecrop features into a Nuxt project.
+ */
+
+import consola from 'consola'
+import { detectFeatures, getInstalledSummary } from './detect'
+import { promptFeatures, type SelectedFeatures } from './prompts'
+import { installFrontend } from './installers/frontend'
+import { installGrafserv } from './installers/grafserv'
+import { installGraphqlClient } from './installers/graphql-client'
+import { installCasl } from './installers/casl'
+import { installRockfoil } from './installers/rockfoil'
+import { installDoctypes } from './installers/doctypes'
+import { getInstallCommand } from './utils/package'
+
+export interface InstallerOptions {
+	/** Working directory (defaults to current directory) */
+	cwd: string
+	/** Pre-selected features from CLI flags */
+	features?: Partial<SelectedFeatures>
+	/** Skip confirmation prompts */
+	skipConfirm?: boolean
+}
+
+/**
+ * Main installer entry point
+ */
+export async function runInstaller(options: InstallerOptions): Promise<void> {
+	const { cwd, features: preselectedFeatures = {}, skipConfirm = false } = options
+
+	consola.box('🌱 Stonecrop Nuxt Installer')
+	console.log()
+
+	// Detect existing setup
+	consola.start('Detecting existing setup...')
+	const detected = await detectFeatures(cwd)
+
+	if (!detected.isNuxtProject) {
+		consola.error('This does not appear to be a Nuxt project.')
+		consola.info('Please run this command in a directory with nuxt.config.ts and Nuxt in package.json.')
+		process.exit(1)
+	}
+
+	consola.success('Nuxt project detected')
+
+	// Show what's already installed
+	const installed = getInstalledSummary(detected)
+	if (installed.length > 0) {
+		console.log()
+		consola.info('Already installed:')
+		for (const item of installed) {
+			consola.info(`  ✓ ${item}`)
+		}
+	}
+
+	console.log()
+
+	// Prompt for features to install
+	const selectedFeatures = await promptFeatures({
+		preselected: preselectedFeatures,
+		detected,
+		skipConfirm,
+	})
+
+	if (!selectedFeatures) {
+		return
+	}
+
+	console.log()
+	consola.start('Installing selected features...')
+	console.log()
+
+	// Track installation results
+	const results: { feature: string; success: boolean }[] = []
+
+	// Install frontend module
+	if (selectedFeatures.frontend) {
+		const success = await installFrontend({ cwd })
+		results.push({ feature: '@stonecrop/nuxt', success })
+		console.log()
+	}
+
+	// Install GraphQL client
+	if (selectedFeatures.graphqlClient) {
+		const success = await installGraphqlClient({ cwd })
+		results.push({ feature: '@stonecrop/graphql-client', success })
+		console.log()
+	}
+
+	// Install GraphQL server
+	if (selectedFeatures.graphql) {
+		const success = await installGrafserv({ cwd })
+		results.push({ feature: '@stonecrop/nuxt-grafserv', success })
+		console.log()
+	}
+
+	// Install CASL middleware
+	if (selectedFeatures.casl) {
+		const success = await installCasl({ cwd })
+		results.push({ feature: '@stonecrop/casl-middleware', success })
+		console.log()
+	}
+
+	// Install Rockfoil middleware
+	if (selectedFeatures.rockfoil) {
+		const success = await installRockfoil({ cwd })
+		results.push({ feature: '@stonecrop/rockfoil', success })
+		console.log()
+	}
+
+	// Install sample doctypes
+	if (selectedFeatures.doctypes) {
+		const success = await installDoctypes({ cwd })
+		results.push({ feature: 'Sample doctypes', success })
+		console.log()
+	}
+
+	// Summary
+	const successCount = results.filter(r => r.success).length
+	const failCount = results.filter(r => !r.success).length
+
+	console.log()
+	if (failCount === 0) {
+		consola.success(`Successfully installed ${successCount} feature(s)`)
+	} else {
+		consola.warn(`Installed ${successCount} feature(s), ${failCount} failed`)
+		for (const result of results.filter(r => !r.success)) {
+			consola.error(`  ✗ ${result.feature}`)
+		}
+	}
+
+	// Next steps
+	console.log()
+	consola.box('Next Steps')
+	console.log()
+
+	const installCmd = getInstallCommand(cwd)
+	consola.info(`1. Install dependencies:`)
+	consola.info(`   ${installCmd}`)
+	console.log()
+
+	let stepNum = 2
+
+	if (selectedFeatures.graphql) {
+		consola.info(`${stepNum}. Update your GraphQL schema and resolvers:`)
+		consola.info(`   - server/schema.graphql`)
+		consola.info(`   - server/resolvers.ts`)
+		console.log()
+		stepNum++
+	}
+
+	if (selectedFeatures.rockfoil) {
+		consola.info(`${stepNum}. Configure Rockfoil:`)
+		consola.info(`   - Set DATABASE_URL environment variable`)
+		consola.info(`   - Configure the Rockfoil plugin options in nuxt.config.ts`)
+		console.log()
+		stepNum++
+	}
+
+	if (selectedFeatures.doctypes) {
+		consola.info(`${stepNum}. Customize your doctypes:`)
+		consola.info(`   - doctypes/Example.json`)
+		consola.info(`   - doctypes/example-table.json`)
+		console.log()
+		stepNum++
+	}
+
+	consola.info(`Start development server:`)
+	consola.info(`   pnpm dev`)
+	console.log()
+
+	if (selectedFeatures.graphql) {
+		consola.info(`Access GraphiQL:`)
+		consola.info(`   http://localhost:3000/graphql/`)
+		consola.info(`   (Make sure to restart your dev server if it's already running)`)
+		console.log()
+	}
+}
+
+// Re-export types for external use
+export type { SelectedFeatures } from './prompts'
+export type { DetectedFeatures } from './detect'

package/src/cli/installers/casl.ts

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

package/src/cli/installers/doctypes.ts

@@ -0,0 +1,206 @@
+/**
+ * Sample doctypes installer
+ * Scaffolds example doctype JSON 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'
+
+const __dirname = dirname(fileURLToPath(import.meta.url))
+
+export interface DoctypesInstallerOptions {
+	cwd: string
+}
+
+/**
+ * Install sample doctype files
+ */
+export async function installDoctypes(options: DoctypesInstallerOptions): Promise<boolean> {
+	const { cwd } = options
+
+	consola.start('Scaffolding sample doctypes...')
+
+	try {
+		const doctypesDir = join(cwd, 'doctypes')
+
+		// Create doctypes directory if it doesn't exist
+		if (!existsSync(doctypesDir)) {
+			await mkdir(doctypesDir, { recursive: true })
+			consola.info('Created doctypes/ directory')
+		}
+
+		// Scaffold Example.json (form doctype)
+		const examplePath = join(doctypesDir, 'Example.json')
+		if (!existsSync(examplePath)) {
+			const exampleTemplate = await loadTemplate('Example.json')
+			await writeFile(examplePath, exampleTemplate, 'utf-8')
+			consola.info('Created doctypes/Example.json')
+		} else {
+			consola.info('doctypes/Example.json already exists, skipping')
+		}
+
+		// Scaffold example-table.json (table doctype)
+		const tableExamplePath = join(doctypesDir, 'example-table.json')
+		if (!existsSync(tableExamplePath)) {
+			const tableTemplate = await loadTemplate('example-table.json')
+			await writeFile(tableExamplePath, tableTemplate, 'utf-8')
+			consola.info('Created doctypes/example-table.json')
+		} else {
+			consola.info('doctypes/example-table.json already exists, skipping')
+		}
+
+		consola.success('Sample doctypes created successfully')
+		return true
+	} catch (error) {
+		consola.error('Failed to scaffold doctypes:', error)
+		return false
+	}
+}
+
+/**
+ * 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> = {
+		'Example.json': JSON.stringify(
+			{
+				name: 'Example',
+				slug: 'example/:id',
+				tableName: 'examples',
+				fields: [
+					{
+						fieldname: 'id',
+						fieldtype: 'Data',
+						label: 'ID',
+						readOnly: true,
+					},
+					{
+						fieldname: 'title',
+						fieldtype: 'Data',
+						label: 'Title',
+						required: true,
+					},
+					{
+						fieldname: 'description',
+						fieldtype: 'Text',
+						label: 'Description',
+					},
+					{
+						fieldname: 'status',
+						fieldtype: 'Select',
+						label: 'Status',
+						options: ['Draft', 'Active', 'Archived'],
+						default: 'Draft',
+					},
+					{
+						fieldname: 'priority',
+						fieldtype: 'Select',
+						label: 'Priority',
+						options: ['Low', 'Medium', 'High'],
+						default: 'Medium',
+					},
+					{
+						fieldname: 'createdAt',
+						fieldtype: 'Datetime',
+						label: 'Created At',
+						readOnly: true,
+					},
+					{
+						fieldname: 'updatedAt',
+						fieldtype: 'Datetime',
+						label: 'Updated At',
+						readOnly: true,
+					},
+				],
+				workflow: {
+					states: ['Draft', 'Active', 'Archived'],
+					actions: {
+						activate: {
+							label: 'Activate',
+							handler: 'activate_example',
+							allowedStates: ['Draft'],
+							confirm: true,
+						},
+						archive: {
+							label: 'Archive',
+							handler: 'archive_example',
+							allowedStates: ['Active'],
+							confirm: true,
+						},
+					},
+				},
+			},
+			null,
+			'\t'
+		),
+		'example-table.json': JSON.stringify(
+			{
+				name: 'Example',
+				slug: 'example',
+				tableName: 'examples',
+				schema: [
+					{
+						component: 'ATable',
+						columns: [
+							{
+								name: 'id',
+								label: 'ID',
+								fieldtype: 'Data',
+								width: '8ch',
+							},
+							{
+								name: 'title',
+								label: 'Title',
+								fieldtype: 'Data',
+								width: '20ch',
+							},
+							{
+								name: 'status',
+								label: 'Status',
+								fieldtype: 'Data',
+								width: '10ch',
+							},
+							{
+								name: 'priority',
+								label: 'Priority',
+								fieldtype: 'Data',
+								width: '10ch',
+							},
+							{
+								name: 'createdAt',
+								label: 'Created',
+								fieldtype: 'Datetime',
+								width: '18ch',
+							},
+						],
+						config: {
+							view: 'list',
+						},
+					},
+				],
+			},
+			null,
+			'\t'
+		),
+	}
+
+	return templates[filename] || '{}'
+}

package/src/cli/installers/frontend.ts

@@ -0,0 +1,68 @@
+/**
+ * Frontend module installer
+ * Installs @stonecrop/nuxt and configures nuxt.config.ts
+ */
+
+import consola from 'consola'
+import { addDependencies } from '../utils/package'
+import { updateNuxtConfig } from '../utils/config'
+
+export interface FrontendInstallerOptions {
+	cwd: string
+}
+
+/**
+ * Install the @stonecrop/nuxt frontend module
+ */
+export async function installFrontend(options: FrontendInstallerOptions): Promise<boolean> {
+	const { cwd } = options
+
+	consola.start('Installing @stonecrop/nuxt frontend module...')
+
+	try {
+		// Add @stonecrop/nuxt and its required peer dependencies
+		// These packages are imported by the Nuxt module and need to be available at runtime
+		await addDependencies(cwd, {
+			'@stonecrop/nuxt': 'latest',
+			'@stonecrop/aform': 'latest',
+			'@stonecrop/atable': 'latest',
+			'@stonecrop/stonecrop': 'latest',
+			'@stonecrop/node-editor': 'latest',
+			'@stonecrop/schema': 'latest',
+			'@stonecrop/utilities': 'latest',
+			pinia: '^3.0.4',
+		})
+
+		// Update nuxt.config.ts with module and Nitro configuration
+		await updateNuxtConfig(cwd, {
+			module: "'@stonecrop/nuxt'",
+			moduleOptions: {
+				key: 'stonecrop',
+				value: `{
+		// Enable DocBuilder for visual schema editing
+		docbuilder: false,
+	}`,
+			},
+			// Add Nitro configuration to handle CSS imports in Stonecrop packages
+			// This is required because the packages use vite-plugin-lib-inject-css which adds
+			// CSS imports to the JavaScript bundles. Node.js ESM loader doesn't understand .css files,
+			// so we need Nitro to bundle these packages (allowing Vite to process the CSS)
+			nitroConfig: {
+				externalsInline: [
+					'@stonecrop/aform',
+					'@stonecrop/atable',
+					'@stonecrop/stonecrop',
+					'@stonecrop/node-editor',
+					'@stonecrop/utilities',
+				],
+			},
+		})
+
+		consola.success('@stonecrop/nuxt installed successfully')
+		consola.info('Added Nitro configuration for CSS handling')
+		return true
+	} catch (error) {
+		consola.error('Failed to install @stonecrop/nuxt:', error)
+		return false
+	}
+}