@stonecrop/nuxt 0.7.3 → 0.7.5

package/src/cli/utils/config.ts

@@ -0,0 +1,260 @@
+/**
+ * Utilities for manipulating nuxt.config.ts
+ */
+
+import { readFile, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join } from 'pathe'
+import consola from 'consola'
+
+export interface NuxtConfigUpdate {
+	/** Module to add to the modules array */
+	module?: string
+	/** Module options to add (key in defineNuxtConfig) */
+	moduleOptions?: {
+		key: string
+		value: string
+	}
+	/** Import to add at the top of the file */
+	import?: string
+	/** Nitro configuration to add */
+	nitroConfig?: {
+		externalsInline?: string[]
+	}
+}
+
+/**
+ * Check if a module is already configured in nuxt.config.ts
+ */
+export async function hasModule(cwd: string, moduleName: string): Promise<boolean> {
+	const configPath = findNuxtConfig(cwd)
+	if (!configPath) return false
+
+	const content = await readFile(configPath, 'utf-8')
+
+	// Check for module in modules array
+	const modulePatterns = [
+		new RegExp(`['"\`]${escapeRegex(moduleName)}['"\`]`),
+		new RegExp(`from\\s+['"\`]${escapeRegex(moduleName)}['"\`]`),
+	]
+
+	return modulePatterns.some(pattern => pattern.test(content))
+}
+
+/**
+ * Find the nuxt.config file in the project
+ */
+export function findNuxtConfig(cwd: string): string | null {
+	const candidates = ['nuxt.config.ts', 'nuxt.config.js', 'nuxt.config.mjs']
+
+	for (const candidate of candidates) {
+		const fullPath = join(cwd, candidate)
+		if (existsSync(fullPath)) {
+			return fullPath
+		}
+	}
+
+	return null
+}
+
+/**
+ * Update nuxt.config.ts with new module configuration
+ *
+ * This uses string manipulation rather than AST parsing for simplicity
+ * and to preserve formatting/comments as much as possible.
+ */
+export async function updateNuxtConfig(cwd: string, updates: NuxtConfigUpdate): Promise<boolean> {
+	const configPath = findNuxtConfig(cwd)
+	if (!configPath) {
+		consola.error('Could not find nuxt.config.ts in', cwd)
+		return false
+	}
+
+	let content = await readFile(configPath, 'utf-8')
+	let modified = false
+
+	// Add import if specified
+	if (updates.import) {
+		if (!content.includes(updates.import)) {
+			// Find the first import or the start of the file
+			const importMatch = content.match(/^import\s+/m)
+			if (importMatch && importMatch.index !== undefined) {
+				// Add after existing imports
+				const lastImportMatch = content.match(/^import\s.*$/gm)
+				if (lastImportMatch && lastImportMatch.length > 0) {
+					const lastImport = lastImportMatch[lastImportMatch.length - 1]
+					if (lastImport) {
+						const lastImportIndex = content.lastIndexOf(lastImport)
+						const insertIndex = lastImportIndex + lastImport.length
+						content = content.slice(0, insertIndex) + '\n' + updates.import + content.slice(insertIndex)
+					}
+				}
+			} else {
+				// Add at the start of the file
+				content = updates.import + '\n\n' + content
+			}
+			modified = true
+		}
+	}
+
+	// Add module to modules array
+	if (updates.module) {
+		const moduleEntry = updates.module
+
+		// Find the modules array
+		const modulesMatch = content.match(/modules\s*:\s*\[/)
+		if (modulesMatch && modulesMatch.index !== undefined) {
+			// Find the closing bracket
+			const startIndex = modulesMatch.index + modulesMatch[0].length
+			const closingIndex = findMatchingBracket(content, startIndex - 1)
+
+			if (closingIndex !== -1) {
+				// Check if module is already present in the modules array (not just anywhere in the file)
+				const arrayContent = content.slice(startIndex, closingIndex)
+				const moduleAlreadyExists = arrayContent.includes(moduleEntry)
+
+				if (!moduleAlreadyExists) {
+					// Check if array is empty
+					const separator = arrayContent.trim().length > 0 ? ', ' : ''
+
+					content = content.slice(0, closingIndex) + separator + moduleEntry + content.slice(closingIndex)
+					modified = true
+				}
+			}
+		} else {
+			// modules array doesn't exist, we need to add it
+			const defineNuxtConfigMatch = content.match(/defineNuxtConfig\s*\(\s*\{/)
+			if (defineNuxtConfigMatch && defineNuxtConfigMatch.index !== undefined) {
+				const insertIndex = defineNuxtConfigMatch.index + defineNuxtConfigMatch[0].length
+				content = content.slice(0, insertIndex) + `\n\tmodules: [${moduleEntry}],` + content.slice(insertIndex)
+				modified = true
+			}
+		}
+	}
+
+	// Add module options
+	if (updates.moduleOptions) {
+		const { key, value } = updates.moduleOptions
+
+		// Check if the key already exists
+		const keyPattern = new RegExp(`${escapeRegex(key)}\\s*:`)
+		if (!keyPattern.test(content)) {
+			// Find defineNuxtConfig and add the option
+			const defineNuxtConfigMatch = content.match(/defineNuxtConfig\s*\(\s*\{/)
+			if (defineNuxtConfigMatch && defineNuxtConfigMatch.index !== undefined) {
+				// Find a good place to insert (after modules if it exists, otherwise at the start)
+				const modulesEndMatch = content.match(/modules\s*:\s*\[[^\]]*\]\s*,?/)
+				if (modulesEndMatch && modulesEndMatch.index !== undefined) {
+					const insertIndex = modulesEndMatch.index + modulesEndMatch[0].length
+					content = content.slice(0, insertIndex) + `\n\n\t${key}: ${value},` + content.slice(insertIndex)
+				} else {
+					const insertIndex = defineNuxtConfigMatch.index + defineNuxtConfigMatch[0].length
+					content = content.slice(0, insertIndex) + `\n\t${key}: ${value},` + content.slice(insertIndex)
+				}
+				modified = true
+			}
+		}
+	}
+
+	// Add Nitro configuration
+	if (updates.nitroConfig) {
+		// Check if nitro config already exists
+		const nitroMatch = content.match(/nitro\s*:\s*\{/)
+
+		if (updates.nitroConfig.externalsInline) {
+			const packagesStr = updates.nitroConfig.externalsInline.map(pkg => `'${pkg}'`).join(', ')
+
+			if (nitroMatch && nitroMatch.index !== undefined) {
+				// Nitro config exists, check if externals.inline exists
+				const externalsMatch = content.match(/externals\s*:\s*\{/)
+
+				if (externalsMatch && externalsMatch.index !== undefined && externalsMatch.index > nitroMatch.index) {
+					// Check if inline array exists
+					const inlineMatch = content.match(/inline\s*:\s*\[/)
+
+					if (inlineMatch && inlineMatch.index !== undefined && inlineMatch.index > externalsMatch.index) {
+						// inline array exists, add packages if not present
+						const startIndex = inlineMatch.index + inlineMatch[0].length
+						const closingIndex = findMatchingBracket(content, startIndex - 1)
+
+						if (closingIndex !== -1) {
+							const arrayContent = content.slice(startIndex, closingIndex).trim()
+							const separator = arrayContent.length > 0 ? ', ' : ''
+							content = content.slice(0, closingIndex) + separator + packagesStr + content.slice(closingIndex)
+							modified = true
+						}
+					} else {
+						// externals exists but no inline, add it
+						const startIndex = externalsMatch.index + externalsMatch[0].length
+						content = content.slice(0, startIndex) + `\n\t\t\tinline: [${packagesStr}],` + content.slice(startIndex)
+						modified = true
+					}
+				} else {
+					// nitro exists but no externals, add it
+					const startIndex = nitroMatch.index + nitroMatch[0].length
+					content =
+						content.slice(0, startIndex) +
+						`\n\t\texternals: {\n\t\t\tinline: [${packagesStr}],\n\t\t},` +
+						content.slice(startIndex)
+					modified = true
+				}
+			} else {
+				// No nitro config, add everything - insert after modules array
+				const defineNuxtConfigMatch = content.match(/defineNuxtConfig\s*\(\s*\{/)
+				if (defineNuxtConfigMatch && defineNuxtConfigMatch.index !== undefined) {
+					// Try to find modules array to insert after it
+					const modulesEndMatch = content.match(/modules\s*:\s*\[[^\]]*\]\s*,?/)
+					if (modulesEndMatch && modulesEndMatch.index !== undefined) {
+						const insertIndex = modulesEndMatch.index + modulesEndMatch[0].length
+						content =
+							content.slice(0, insertIndex) +
+							`\n\n\t// Nitro configuration for Stonecrop CSS handling\n\tnitro: {\n\t\texternals: {\n\t\t\tinline: [${packagesStr}],\n\t\t},\n\t},` +
+							content.slice(insertIndex)
+					} else {
+						// No modules, add at the start of config
+						const insertIndex = defineNuxtConfigMatch.index + defineNuxtConfigMatch[0].length
+						content =
+							content.slice(0, insertIndex) +
+							`\n\t// Nitro configuration for Stonecrop CSS handling\n\tnitro: {\n\t\texternals: {\n\t\t\tinline: [${packagesStr}],\n\t\t},\n\t},` +
+							content.slice(insertIndex)
+					}
+					modified = true
+				}
+			}
+		}
+	}
+
+	if (modified) {
+		await writeFile(configPath, content, 'utf-8')
+		consola.success(`Updated ${configPath}`)
+	}
+
+	return modified
+}
+
+/**
+ * Find the matching closing bracket
+ */
+function findMatchingBracket(content: string, openIndex: number): number {
+	const openChar = content[openIndex]
+	const closeChar = openChar === '[' ? ']' : openChar === '{' ? '}' : ')'
+
+	let depth = 1
+	let i = openIndex + 1
+
+	while (i < content.length && depth > 0) {
+		const char = content[i]
+		if (char === openChar) depth++
+		else if (char === closeChar) depth--
+		i++
+	}
+
+	return depth === 0 ? i - 1 : -1
+}
+
+/**
+ * Escape special regex characters
+ */
+function escapeRegex(str: string): string {
+	return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}

package/src/cli/utils/index.ts

@@ -0,0 +1,15 @@
+/**
+ * CLI utilities barrel export
+ */
+
+export { hasModule, findNuxtConfig, updateNuxtConfig, type NuxtConfigUpdate } from './config'
+
+export {
+	readPackageJson,
+	writePackageJson,
+	hasPackage,
+	addDependencies,
+	detectPackageManager,
+	getInstallCommand,
+	type PackageJson,
+} from './package'

package/src/cli/utils/package.ts

@@ -0,0 +1,128 @@
+/**
+ * Utilities for manipulating package.json
+ */
+
+import { readFile, writeFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import { join } from 'pathe'
+import consola from 'consola'
+
+export interface PackageJson {
+	name?: string
+	version?: string
+	dependencies?: Record<string, string>
+	devDependencies?: Record<string, string>
+	[key: string]: unknown
+}
+
+/**
+ * Read package.json from the project
+ */
+export async function readPackageJson(cwd: string): Promise<PackageJson | null> {
+	const packagePath = join(cwd, 'package.json')
+
+	if (!existsSync(packagePath)) {
+		return null
+	}
+
+	const content = await readFile(packagePath, 'utf-8')
+	return JSON.parse(content)
+}
+
+/**
+ * Write package.json to the project
+ */
+export async function writePackageJson(cwd: string, pkg: PackageJson): Promise<void> {
+	const packagePath = join(cwd, 'package.json')
+	await writeFile(packagePath, JSON.stringify(pkg, null, '\t') + '\n', 'utf-8')
+}
+
+/**
+ * Check if a package is installed (in dependencies or devDependencies)
+ */
+export async function hasPackage(cwd: string, packageName: string): Promise<boolean> {
+	const pkg = await readPackageJson(cwd)
+	if (!pkg) return false
+
+	return !!(pkg.dependencies?.[packageName] || pkg.devDependencies?.[packageName])
+}
+
+/**
+ * Add dependencies to package.json
+ */
+export async function addDependencies(
+	cwd: string,
+	dependencies: Record<string, string>,
+	options: { dev?: boolean } = {}
+): Promise<boolean> {
+	const pkg = await readPackageJson(cwd)
+	if (!pkg) {
+		consola.error('Could not find package.json in', cwd)
+		return false
+	}
+
+	const key = options.dev ? 'devDependencies' : 'dependencies'
+	pkg[key] = pkg[key] || {}
+
+	let modified = false
+	for (const [name, version] of Object.entries(dependencies)) {
+		if (!pkg[key]![name]) {
+			pkg[key]![name] = version
+			modified = true
+			consola.info(`Adding ${name}@${version} to ${key}`)
+		}
+	}
+
+	if (modified) {
+		// Sort dependencies alphabetically
+		pkg[key] = sortObject(pkg[key] as Record<string, string>)
+		await writePackageJson(cwd, pkg)
+	}
+
+	return modified
+}
+
+/**
+ * Get the package manager used in the project
+ */
+export function detectPackageManager(cwd: string): 'npm' | 'yarn' | 'pnpm' | 'bun' {
+	if (existsSync(join(cwd, 'bun.lockb')) || existsSync(join(cwd, 'bun.lock'))) {
+		return 'bun'
+	}
+	if (existsSync(join(cwd, 'pnpm-lock.yaml'))) {
+		return 'pnpm'
+	}
+	if (existsSync(join(cwd, 'yarn.lock'))) {
+		return 'yarn'
+	}
+	return 'npm'
+}
+
+/**
+ * Get the install command for the detected package manager
+ */
+export function getInstallCommand(cwd: string): string {
+	const pm = detectPackageManager(cwd)
+	switch (pm) {
+		case 'bun':
+			return 'bun install'
+		case 'pnpm':
+			return 'pnpm install'
+		case 'yarn':
+			return 'yarn'
+		default:
+			return 'npm install'
+	}
+}
+
+/**
+ * Sort an object's keys alphabetically
+ */
+function sortObject(obj: Record<string, string>): Record<string, string> {
+	return Object.keys(obj)
+		.sort()
+		.reduce((acc, key) => {
+			acc[key] = obj[key]
+			return acc
+		}, {} as Record<string, string>)
+}

package/src/cli/utils/plugin.ts

@@ -0,0 +1,107 @@
+/**
+ * Utilities for managing Grafserv plugin configuration in nuxt.config.ts
+ */
+
+import { readFile, writeFile } from 'node:fs/promises'
+import consola from 'consola'
+
+import { findNuxtConfig } from './config'
+
+/**
+ * Add a plugin to the grafserv preset plugins array in nuxt.config.ts
+ *
+ * @param cwd - Current working directory
+ * @param pluginCode - The plugin code to add (e.g., "pglCaslPlugin" or "createPglRockfoilPlugin({})")
+ * @returns true if successfully added, false otherwise
+ */
+export async function addPluginToGrafservConfig(cwd: string, pluginCode: string): Promise<boolean> {
+	const configPath = findNuxtConfig(cwd)
+	if (!configPath) {
+		consola.error('Could not find nuxt.config.ts')
+		return false
+	}
+
+	let content = await readFile(configPath, 'utf-8')
+
+	// Check if plugin is already configured
+	if (content.includes(pluginCode)) {
+		consola.info('Plugin already configured in nuxt.config.ts')
+		return true
+	}
+
+	// Find grafserv configuration
+	const grafservMatch = content.match(/grafserv\s*:\s*\{/)
+	if (!grafservMatch || grafservMatch.index === undefined) {
+		consola.warn('Could not find grafserv configuration in nuxt.config.ts')
+		return false
+	}
+
+	// Check if preset exists within grafserv config
+	const grafservStart = grafservMatch.index
+	const presetMatch = content.slice(grafservStart).match(/preset\s*:\s*\{/)
+
+	if (presetMatch && presetMatch.index !== undefined) {
+		const presetStart = grafservStart + presetMatch.index
+		// Check if plugins array exists within preset
+		const pluginsMatch = content.slice(presetStart).match(/plugins\s*:\s*\[/)
+
+		if (pluginsMatch && pluginsMatch.index !== undefined) {
+			// Plugins array exists, add to it
+			const pluginsStart = presetStart + pluginsMatch.index + pluginsMatch[0].length
+			const closingBracket = findMatchingBracket(content, pluginsStart - 1)
+
+			if (closingBracket !== -1) {
+				const arrayContent = content.slice(pluginsStart, closingBracket).trim()
+				const separator = arrayContent.length > 0 ? ', ' : ''
+
+				content = content.slice(0, closingBracket) + separator + pluginCode + content.slice(closingBracket)
+
+				await writeFile(configPath, content, 'utf-8')
+				consola.success('Added plugin to grafserv.preset.plugins array')
+				return true
+			}
+		} else {
+			// preset exists but no plugins array, add it
+			const presetContentStart = presetStart + presetMatch[0].length
+			content =
+				content.slice(0, presetContentStart) + `\n\t\t\tplugins: [${pluginCode}],` + content.slice(presetContentStart)
+
+			await writeFile(configPath, content, 'utf-8')
+			consola.success('Added plugins array to grafserv.preset configuration')
+			return true
+		}
+	} else {
+		// grafserv exists but no preset, add preset with plugins
+		const grafservContentStart = grafservStart + grafservMatch[0].length
+		content =
+			content.slice(0, grafservContentStart) +
+			`\n\t\tpreset: {\n\t\t\tplugins: [${pluginCode}],\n\t\t},` +
+			content.slice(grafservContentStart)
+
+		await writeFile(configPath, content, 'utf-8')
+		consola.success('Added preset.plugins configuration to grafserv')
+		return true
+	}
+
+	return false
+}
+
+/**
+ * Find the matching closing bracket
+ */
+function findMatchingBracket(content: string, openIndex: number): number {
+	const openChar = content[openIndex]
+	const closeChar = openChar === '[' ? ']' : openChar === '{' ? '}' : ')'
+
+	let depth = 1
+	let i = openIndex + 1
+
+	while (i < content.length && depth > 0) {
+		const char = content[i]
+		if (char === openChar) depth++
+		else if (char === closeChar) depth--
+		i++
+	}
+
+	return depth === 0 ? i - 1 : -1
+}

package/templates/Example.json

@@ -0,0 +1,85 @@
+{
+	"name": "Example",
+	"slug": "example/:id",
+	"tableName": "examples",
+	"fields": [
+		{
+			"fieldname": "id",
+			"fieldtype": "Data",
+			"label": "ID",
+			"readOnly": true
+		},
+		{
+			"fieldname": "title",
+			"fieldtype": "Data",
+			"label": "Title",
+			"required": true,
+			"width": "30ch"
+		},
+		{
+			"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": "assignee",
+			"fieldtype": "Link",
+			"label": "Assignee",
+			"options": "User"
+		},
+		{
+			"fieldname": "dueDate",
+			"fieldtype": "Date",
+			"label": "Due Date"
+		},
+		{
+			"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
+			},
+			"reopen": {
+				"label": "Reopen",
+				"handler": "reopen_example",
+				"allowedStates": ["Archived"],
+				"confirm": false
+			}
+		}
+	}
+}

package/templates/example-table.json

@@ -0,0 +1,60 @@
+{
+	"name": "Example",
+	"slug": "example",
+	"tableName": "examples",
+	"listDoctype": "Example",
+	"schema": [
+		{
+			"component": "ATable",
+			"columns": [
+				{
+					"name": "id",
+					"label": "ID",
+					"fieldtype": "Data",
+					"width": "8ch"
+				},
+				{
+					"name": "title",
+					"label": "Title",
+					"fieldtype": "Data",
+					"width": "25ch"
+				},
+				{
+					"name": "status",
+					"label": "Status",
+					"fieldtype": "Data",
+					"width": "10ch"
+				},
+				{
+					"name": "priority",
+					"label": "Priority",
+					"fieldtype": "Data",
+					"width": "10ch"
+				},
+				{
+					"name": "assignee",
+					"label": "Assignee",
+					"fieldtype": "Data",
+					"width": "15ch"
+				},
+				{
+					"name": "dueDate",
+					"label": "Due Date",
+					"fieldtype": "Date",
+					"width": "12ch"
+				},
+				{
+					"name": "createdAt",
+					"label": "Created",
+					"fieldtype": "Datetime",
+					"width": "18ch"
+				}
+			],
+			"config": {
+				"view": "list",
+				"sortable": true,
+				"filterable": true
+			}
+		}
+	]
+}