@bagelink/workspace 1.8.0 → 1.8.5

package/src/lint.ts

@@ -0,0 +1,323 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * List of redundant lint config files that can be safely removed
+ * after setting up the new lint configuration
+ */
+const REDUNDANT_FILES = [
+	// Old ESLint configs
+	'.eslintrc',
+	'.eslintrc.json',
+	'.eslintrc.js',
+	'.eslintrc.cjs',
+	'.eslintrc.yaml',
+	'.eslintrc.yml',
+	// Oxlint
+	'oxlint.json',
+	// Old Prettier configs (we create .prettierrc)
+	'prettier.config.js',
+	'prettier.config.cjs',
+	'prettier.config.mjs',
+	'.prettierrc.json',
+	'.prettierrc.yaml',
+	'.prettierrc.yml',
+	'.prettierrc.js',
+	'.prettierrc.cjs',
+	'.prettierrc.mjs',
+	'.prettierrc.toml',
+]
+
+/**
+ * Set up linting in a project
+ */
+export async function setupLint(
+	root: string = process.cwd(),
+	isWorkspace: boolean = false,
+): Promise<void> {
+	console.log('\n🔍 Setting up linting...\n')
+
+	const response = await prompts([
+		{
+			type: 'multiselect',
+			name: 'configs',
+			message: 'Select configurations to set up:',
+			choices: [
+				{ title: 'ESLint', value: 'eslint', selected: true },
+				{ title: 'Prettier', value: 'prettier', selected: true },
+				{ title: 'EditorConfig', value: 'editorconfig', selected: true },
+				{ title: 'Git Hooks', value: 'githooks', selected: false },
+			],
+		},
+		{
+			type: 'confirm',
+			name: 'cleanRedundant',
+			message: 'Clean up redundant lint config files?',
+			initial: true,
+		},
+		{
+			type: 'confirm',
+			name: 'installDeps',
+			message: 'Install dependencies?',
+			initial: true,
+		},
+	])
+
+	if (!response || !response.configs) {
+		console.log('\n❌ Setup cancelled.\n')
+		process.exit(1)
+	}
+
+	const { configs, cleanRedundant, installDeps } = response
+
+	// Clean up redundant files first
+	if (cleanRedundant) {
+		await cleanRedundantFiles(root)
+	}
+
+	// Create config files
+	if (configs.includes('eslint')) {
+		createEslintConfig(root, isWorkspace)
+	}
+
+	if (configs.includes('prettier')) {
+		createPrettierConfig(root)
+	}
+
+	if (configs.includes('editorconfig')) {
+		createEditorConfig(root)
+	}
+
+	if (configs.includes('githooks')) {
+		createGitHooks(root)
+	}
+
+	// Update package.json
+	updatePackageJsonLint(root, configs)
+
+	if (installDeps) {
+		console.log('\n📦 Installing dependencies...')
+		console.log('Run: bun add -D @bagelink/lint-config eslint prettier typescript')
+	}
+
+	console.log('\n✅ Linting setup complete!')
+	console.log('\nAvailable commands:')
+	console.log('  bun run lint       - Run linter')
+	console.log('  bun run lint:fix   - Fix linting issues')
+	console.log('  bun run format     - Format code with Prettier')
+	console.log('')
+}
+
+/**
+ * Create ESLint config
+ */
+function createEslintConfig(root: string, isWorkspace: boolean): void {
+	const configPath = resolve(root, 'eslint.config.js')
+
+	const config = isWorkspace
+		? `import { defineConfig } from '@bagelink/lint-config/eslint'
+
+export default defineConfig({
+	// Workspace-level ESLint config
+	ignores: ['**/dist/**', '**/node_modules/**', '**/.bun-cache/**'],
+})
+`
+		: `import vue3Config from '@bagelink/lint-config/eslint/vue3'
+
+export default vue3Config
+`
+
+	writeFileSync(configPath, config)
+	console.log('✅ Created eslint.config.js')
+}
+
+/**
+ * Create Prettier config
+ */
+function createPrettierConfig(root: string): void {
+	const configPath = resolve(root, '.prettierrc')
+
+	const config = {
+		semi: false,
+		singleQuote: true,
+		tabWidth: 2,
+		useTabs: true,
+		trailingComma: 'all',
+		printWidth: 100,
+		arrowParens: 'avoid',
+	}
+
+	writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`)
+	console.log('✅ Created .prettierrc')
+
+	// .prettierignore
+	const ignorePath = resolve(root, '.prettierignore')
+	const ignore = `dist
+node_modules
+.bun-cache
+*.min.js
+*.min.css
+`
+
+	writeFileSync(ignorePath, ignore)
+	console.log('✅ Created .prettierignore')
+}
+
+/**
+ * Create EditorConfig
+ */
+function createEditorConfig(root: string): void {
+	const configPath = resolve(root, '.editorconfig')
+
+	const config = `root = true
+
+[*]
+charset = utf-8
+indent_style = tab
+indent_size = 2
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+
+[*.md]
+trim_trailing_whitespace = false
+
+[*.{json,yml,yaml}]
+indent_style = space
+indent_size = 2
+`
+
+	writeFileSync(configPath, config)
+	console.log('✅ Created .editorconfig')
+}
+
+/**
+ * Create Git Hooks
+ */
+function createGitHooks(root: string): void {
+	const packageJsonPath = resolve(root, 'package.json')
+
+	if (!existsSync(packageJsonPath)) {
+		console.warn('⚠️  No package.json found, skipping git hooks')
+		return
+	}
+
+	// .lintstagedrc
+	const lintStagedConfig = {
+		'*.{js,jsx,ts,tsx,vue}': ['eslint --fix'],
+		'*.{json,md,yml,yaml}': ['prettier --write'],
+	}
+
+	writeFileSync(
+		resolve(root, '.lintstagedrc'),
+		`${JSON.stringify(lintStagedConfig, null, 2)}\n`,
+	)
+
+	console.log('✅ Created .lintstagedrc')
+	console.log('ℹ️  Add simple-git-hooks and lint-staged to devDependencies')
+	console.log('   Then run: npx simple-git-hooks')
+}
+
+/**
+ * Clean up redundant lint configuration files
+ */
+async function cleanRedundantFiles(root: string): Promise<void> {
+	const foundFiles: string[] = []
+
+	// Check which redundant files exist
+	for (const file of REDUNDANT_FILES) {
+		const filePath = resolve(root, file)
+		if (existsSync(filePath)) {
+			foundFiles.push(file)
+		}
+	}
+
+	if (foundFiles.length === 0) {
+		console.log('✨ No redundant files found')
+		return
+	}
+
+	console.log('\n📋 Found redundant files:')
+	foundFiles.forEach((file) => { console.log(`   - ${file}`) })
+
+	const confirmResponse = await prompts({
+		type: 'confirm',
+		name: 'confirm',
+		message: `Delete ${foundFiles.length} redundant file${foundFiles.length > 1 ? 's' : ''}?`,
+		initial: true,
+	})
+
+	if (!confirmResponse.confirm) {
+		console.log('⏭️  Skipped cleaning redundant files')
+		return
+	}
+
+	// Delete confirmed files
+	let deleted = 0
+	for (const file of foundFiles) {
+		try {
+			unlinkSync(resolve(root, file))
+			console.log(`🗑️  Deleted ${file}`)
+			deleted++
+		}
+		catch (error) {
+			console.error(`❌ Failed to delete ${file}:`, error)
+		}
+	}
+
+	console.log(`✅ Cleaned up ${deleted} file${deleted > 1 ? 's' : ''}`)
+}
+
+/**
+ * Update package.json with lint scripts
+ */
+function updatePackageJsonLint(root: string, configs: string[]): void {
+	const packageJsonPath = resolve(root, 'package.json')
+
+	if (!existsSync(packageJsonPath)) {
+		console.warn('⚠️  No package.json found')
+		return
+	}
+
+	try {
+		const packageJson = JSON.parse(
+			readFileSync(packageJsonPath, 'utf-8'),
+		)
+
+		if (!packageJson.scripts) {
+			packageJson.scripts = {}
+		}
+
+		// Add lint scripts
+		if (configs.includes('eslint')) {
+			if (!packageJson.scripts.lint) {
+				packageJson.scripts.lint = 'eslint .'
+			}
+			if (!packageJson.scripts['lint:fix']) {
+				packageJson.scripts['lint:fix'] = 'eslint . --fix'
+			}
+		}
+
+		// Add format scripts
+		if (configs.includes('prettier')) {
+			if (!packageJson.scripts.format) {
+				packageJson.scripts.format = 'prettier --write .'
+			}
+			if (!packageJson.scripts['format:check']) {
+				packageJson.scripts['format:check'] = 'prettier --check .'
+			}
+		}
+
+		writeFileSync(
+			packageJsonPath,
+			`${JSON.stringify(packageJson, null, 2)}\n`,
+		)
+
+		console.log('✅ Updated package.json with lint scripts')
+	}
+	catch (error) {
+		console.error('❌ Failed to update package.json:', error)
+	}
+}

package/src/netlify.ts

@@ -5,9 +5,13 @@ import process from 'node:process'
 
 /**
  * Generate netlify.toml redirect configuration
+ * Uses environment variables for flexibility across environments
  */
 export function generateNetlifyRedirect(config: WorkspaceConfig): string {
-	const redirect = `[[redirects]]
+	const redirect = `# API Proxy Configuration
+# Environment variables are set in Netlify UI or netlify.toml [build.environment] section
+
+[[redirects]]
   from = "${config.proxy}/*"
   to = "${config.host}/:splat"
   status = 200
@@ -18,13 +22,49 @@ export function generateNetlifyRedirect(config: WorkspaceConfig): string {
 	return redirect
 }
 
+/**
+ * Generate netlify.toml with environment variable template
+ * Provides a standard config that can be reused across projects
+ */
+export function generateNetlifyConfigTemplate(): string {
+	return `# Standard Netlify configuration for Bagelink projects
+# Uses environment variables for proxy configuration
+
+[build.environment]
+  # Set these in Netlify UI or override here
+  # BGL_PROXY_PATH = "/api"
+  # BGL_API_HOST = "https://your-project.bagel.to"
+
+[[redirects]]
+  # Proxy API requests to backend
+  # Uses BGL_PROXY_PATH and BGL_API_HOST from environment
+  from = "/api/*"
+  to = "https://your-project.bagel.to/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+
+# Example: Multiple API backends
+# [[redirects]]
+#   from = "/api/v2/*"
+#   to = "https://api-v2.example.com/:splat"
+#   status = 200
+#   force = true
+`
+}
+
 /**
  * Generate complete netlify.toml file
  */
 export function generateNetlifyConfig(
 	config: WorkspaceConfig,
 	additionalConfig?: string,
+	useTemplate: boolean = false,
 ): string {
+	if (useTemplate) {
+		return generateNetlifyConfigTemplate()
+	}
+
 	const redirect = generateNetlifyRedirect(config)
 
 	if (additionalConfig !== undefined && additionalConfig !== '') {
@@ -40,13 +80,24 @@ export function generateNetlifyConfig(
 export function writeNetlifyConfig(
 	config: WorkspaceConfig,
 	outPath: string = './netlify.toml',
-	additionalConfig?: string
+	additionalConfig?: string,
+	useTemplate: boolean = false,
 ): void {
-	const content = generateNetlifyConfig(config, additionalConfig)
+	const content = generateNetlifyConfig(config, additionalConfig, useTemplate)
 	const resolvedPath = resolve(outPath)
 
 	writeFileSync(resolvedPath, content, 'utf-8')
 	console.log(`✓ Generated netlify.toml at ${resolvedPath}`)
+
+	if (!useTemplate) {
+		console.log('\n💡 Tip: For environment-based config, set these in Netlify UI:')
+		console.log(`   BGL_PROXY_PATH = "${config.proxy}"`)
+		console.log(`   BGL_API_HOST = "${config.host}"`)
+		if (config.openapi_url) {
+			console.log(`   BGL_OPENAPI_URL = "${config.openapi_url}"`)
+		}
+		console.log('')
+	}
 }
 
 /**

package/src/proxy.ts

@@ -1,3 +1,4 @@
+import type { IncomingMessage, ServerResponse, ClientRequest } from 'node:http'
 import type { WorkspaceConfig, ProxyConfig } from './types'
 
 /**
@@ -12,7 +13,22 @@ export function createViteProxy(config: WorkspaceConfig): ProxyConfig {
 			target: config.host,
 			changeOrigin: true,
 			rewrite: (path: string) => path.replace(new RegExp(`^${config.proxy}`), ''),
-			secure: true,
+			secure: false,
+			ws: true,
+			followRedirects: true,
+			autoRewrite: true,
+			protocolRewrite: 'http',
+			configure: (proxy: any, _options: any) => {
+				proxy.on('proxyReq', (proxyReq: ClientRequest, req: IncomingMessage, _res: ServerResponse) => {
+					// Ensure proper headers are forwarded
+					if (req.headers.origin) {
+						proxyReq.setHeader('origin', config.host)
+					}
+				})
+				proxy.on('error', (err: Error, _req: IncomingMessage, _res: ServerResponse) => {
+					console.log('proxy error', err)
+				})
+			},
 		}
 	}
 
@@ -21,7 +37,9 @@ export function createViteProxy(config: WorkspaceConfig): ProxyConfig {
 		proxy['/files'] = {
 			target: config.host,
 			changeOrigin: true,
-			secure: true,
+			secure: false,
+			ws: true,
+			followRedirects: true,
 		}
 	}
 
@@ -38,6 +56,7 @@ export function createCustomProxy(
 		changeOrigin?: boolean
 		rewrite?: boolean
 		secure?: boolean
+		ws?: boolean
 	} = {}
 ): ProxyConfig {
 	const proxy: ProxyConfig = {}
@@ -46,7 +65,8 @@ export function createCustomProxy(
 		proxy[path] = {
 			target,
 			changeOrigin: options.changeOrigin ?? true,
-			secure: options.secure ?? true,
+			secure: options.secure ?? false,
+			ws: options.ws ?? true,
 			...(options.rewrite === true && {
 				rewrite: (p: string) => p.replace(new RegExp(`^${path}`), ''),
 			}),

package/src/sdk.ts

@@ -0,0 +1,196 @@
+import type { WorkspaceConfig } from './types'
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * Generate SDK from OpenAPI spec
+ */
+export async function generateSDK(
+	root: string = process.cwd(),
+): Promise<void> {
+	console.log('\n🔧 Generating SDK from OpenAPI...\n')
+
+	// Try to load config
+	let config: WorkspaceConfig | null = null
+	let openApiUrl: string | undefined
+
+	try {
+		const configPath = resolve(root, 'bgl.config.ts')
+		if (existsSync(configPath)) {
+			const module = await import(`file://${configPath}`)
+			const workspace = module.default
+			if (typeof workspace === 'function') {
+				config = workspace('development')
+				if (config?.openapi_url) {
+					openApiUrl = config.openapi_url
+				}
+			}
+		}
+	}
+	catch {
+		// Ignore config load errors
+	}
+
+	// Prompt for missing info
+	const response = await prompts([
+		{
+			type: openApiUrl !== undefined ? null : 'text',
+			name: 'openApiUrl',
+			message: 'OpenAPI spec URL:',
+			initial: openApiUrl ?? 'http://localhost:8000/openapi.json',
+		},
+		{
+			type: 'text',
+			name: 'outputDir',
+			message: 'Output directory:',
+			initial: './src/api',
+		},
+		{
+			type: 'confirm',
+			name: 'splitFiles',
+			message: 'Split into organized files?',
+			initial: true,
+		},
+	])
+
+	if (!response) {
+		console.log('\n❌ SDK generation cancelled.\n')
+		process.exit(1)
+	}
+
+	const finalUrl = openApiUrl ?? response.openApiUrl
+	const { outputDir, splitFiles } = response
+
+	console.log(`\n📡 Fetching OpenAPI spec from: ${finalUrl}`)
+	console.log(`📁 Output directory: ${outputDir}\n`)
+
+	try {
+		// Dynamic import of @bagelink/sdk
+		const { openAPI } = await import('@bagelink/sdk')
+		const { readFileSync } = await import('node:fs')
+		const { dirname, join } = await import('node:path')
+		const { fileURLToPath } = await import('node:url')
+
+		const { types, code } = await openAPI(finalUrl, '/api')
+
+		const outputPath = resolve(root, outputDir)
+		if (!existsSync(outputPath)) {
+			mkdirSync(outputPath, { recursive: true })
+		}
+
+		// Write types
+		const typesPath = resolve(outputPath, 'types.d.ts')
+		writeFileSync(typesPath, types)
+		console.log('✅ Generated types.d.ts')
+
+		// Write API client
+		const apiPath = resolve(outputPath, 'api.ts')
+		writeFileSync(apiPath, code)
+		console.log('✅ Generated api.ts')
+
+		// Copy streamClient.ts from @bagelink/sdk
+		try {
+			const sdkModule = await import('@bagelink/sdk')
+			const sdkPath = fileURLToPath(import.meta.resolve('@bagelink/sdk'))
+			const sdkDir = dirname(sdkPath)
+			const streamClientSource = join(sdkDir, 'openAPITools', 'streamClient.ts')
+
+			if (existsSync(streamClientSource)) {
+				const streamClientCode = readFileSync(streamClientSource, 'utf-8')
+				const streamClientPath = resolve(outputPath, 'streamClient.ts')
+				writeFileSync(streamClientPath, streamClientCode)
+				console.log('✅ Generated streamClient.ts')
+			}
+		} catch (e) {
+			// Stream client is optional, don't fail if not found
+			console.log('ℹ️  streamClient.ts not found (optional)')
+		}
+
+		// Write index
+		const indexPath = resolve(outputPath, 'index.ts')
+		writeFileSync(
+			indexPath,
+			'export * from \'./api\'\nexport * from \'./types.d\'\n',
+		)
+		console.log('✅ Generated index.ts')
+
+		if (splitFiles) {
+			console.log('\n🔀 Splitting into organized files...')
+			console.log('ℹ️  File splitting requires @bagelink/sdk bin scripts')
+			console.log('    Keeping monolithic structure for now')
+			// Note: File splitting requires unpublished bin scripts
+			// Users can manually run: bunx bagelink generate
+		}
+
+		console.log('\n✅ SDK generated successfully!')
+		console.log(`\nImport it in your code:`)
+		console.log(`  import { api } from '${outputDir.replace('./src/', './')}'`)
+		console.log('')
+	}
+	catch (error: unknown) {
+		console.error('\n❌ Failed to generate SDK:')
+		if (error instanceof Error) {
+			console.error(error.message)
+		}
+		else {
+			console.error(error)
+		}
+		console.log('\nMake sure:')
+		console.log('  1. @bagelink/sdk is installed: bun add -D @bagelink/sdk')
+		console.log('  2. OpenAPI URL is accessible')
+		console.log('  3. API server is running (if using localhost)')
+		process.exit(1)
+	}
+}
+
+/**
+ * Generate SDK for all projects in workspace
+ */
+export async function generateSDKForWorkspace(root: string = process.cwd()): Promise<void> {
+	console.log('\n🏢 Generating SDK for workspace projects...\n')
+
+	// Find all projects
+	const fs = await import('node:fs')
+	const items = fs.readdirSync(root, { withFileTypes: true })
+	const projects = items
+		.filter(
+			item => item.isDirectory()
+				&& item.name !== 'node_modules'
+				&& item.name !== 'shared'
+				&& item.name !== '.git'
+				&& !item.name.startsWith('.'),
+		)
+		.map(item => item.name)
+
+	if (projects.length === 0) {
+		console.log('No projects found in workspace')
+		return
+	}
+
+	const response = await prompts({
+		type: 'multiselect',
+		name: 'selectedProjects',
+		message: 'Select projects to generate SDK for:',
+		choices: projects.map(p => ({ title: p, value: p, selected: true })),
+	})
+
+	if (!response || !response.selectedProjects || response.selectedProjects.length === 0) {
+		console.log('\n❌ No projects selected.\n')
+		return
+	}
+
+	for (const project of response.selectedProjects) {
+		console.log(`\n📦 Generating SDK for: ${project}`)
+		const projectPath = resolve(root, project)
+		try {
+			await generateSDK(projectPath)
+		}
+		catch {
+			console.error(`Failed to generate SDK for ${project}`)
+		}
+	}
+
+	console.log('\n✅ All SDKs generated!')
+}

package/src/types.ts

@@ -45,5 +45,10 @@ export interface ProxyConfig {
 		changeOrigin: boolean
 		rewrite?: (path: string) => string
 		secure: boolean
+		ws?: boolean
+		followRedirects?: boolean
+		autoRewrite?: boolean
+		protocolRewrite?: string
+		configure?: (proxy: any, options: any) => void
 	}
 }