@bagelink/workspace 1.0.0

package/src/config.ts

@@ -0,0 +1,108 @@
+import type { WorkspaceConfig, WorkspaceEnvironment, WorkspaceOptions } from './types'
+import { existsSync } from 'node:fs'
+import { resolve, join } from 'node:path'
+import process from 'node:process'
+import { generateWorkspaceConfig } from './init'
+
+/**
+ * Load and resolve bgl.config.ts with cascading support
+ * Looks for config files from current directory up to workspace root
+ * If no config is found, prompts to create one interactively
+ */
+export async function resolveConfig(
+	mode: WorkspaceEnvironment = 'development',
+	options: WorkspaceOptions = {},
+): Promise<WorkspaceConfig> {
+	const root = options.root ?? process.cwd()
+	const configFile = options.configFile ?? 'bgl.config.ts'
+
+	// Try to load config from current directory
+	const localConfigPath = resolve(root, configFile)
+	const localConfig = await loadConfig(localConfigPath, mode)
+
+	if (localConfig) {
+		return localConfig
+	}
+
+	// Try parent directories (monorepo support)
+	let currentDir = root
+	const rootDir = resolve('/')
+
+	while (currentDir !== rootDir) {
+		const parentDir = resolve(currentDir, '..')
+		const parentConfigPath = join(parentDir, configFile)
+
+		if (existsSync(parentConfigPath)) {
+			const config = await loadConfig(parentConfigPath, mode)
+			if (config) {
+				return config
+			}
+		}
+
+		currentDir = parentDir
+	}
+
+	// No config found - generate one interactively
+	if (options.interactive !== false) {
+		await generateWorkspaceConfig(root, configFile)
+		// Try loading the newly created config
+		const newConfig = await loadConfig(localConfigPath, mode)
+		if (newConfig) {
+			return newConfig
+		}
+	}
+
+	throw new Error(`No bgl.config.ts found in ${root} or parent directories`)
+}
+
+/**
+ * Load config from a specific file path
+ */
+async function loadConfig(
+	configPath: string,
+	mode: WorkspaceEnvironment
+): Promise<WorkspaceConfig | null> {
+	if (!existsSync(configPath)) {
+		return null
+	}
+
+	try {
+		// Dynamic import to support ESM
+		const module = await import(`file://${configPath}`)
+
+		// Support both named export and default export
+		const configMap = module.default ?? module.configs ?? module.config
+
+		if (typeof configMap === 'function') {
+			return configMap(mode) as WorkspaceConfig
+		}
+
+		if (typeof configMap === 'object' && configMap !== null) {
+			// If it's a map of environments
+			const modeConfig = configMap[mode]
+			if (mode in configMap && modeConfig !== undefined && modeConfig !== null) {
+				return modeConfig as WorkspaceConfig
+			}
+			// If it's already a config object
+			return configMap as WorkspaceConfig
+		}
+
+		return null
+	} catch (error) {
+		console.warn(`Failed to load config from ${configPath}:`, error)
+		return null
+	}
+}
+
+/**
+ * Merge two configs, with the second one taking precedence
+ */
+export function mergeConfigs(
+	base: WorkspaceConfig,
+	override: Partial<WorkspaceConfig>
+): WorkspaceConfig {
+	return {
+		...base,
+		...override,
+	}
+}

package/src/index.ts

@@ -0,0 +1,99 @@
+import type {
+	WorkspaceConfig,
+	WorkspaceEnvironment,
+	WorkspaceOptions,
+	ProxyConfig,
+} from './types'
+import { resolveConfig, mergeConfigs } from './config'
+import { generateWorkspaceConfig, generateWorkspaceConfigSync } from './init'
+import {
+	generateNetlifyConfig,
+	generateNetlifyRedirect,
+	writeNetlifyConfig,
+	setBuildEnvVars,
+} from './netlify'
+import { createViteProxy, createCustomProxy } from './proxy'
+
+export type {
+	ProxyConfig,
+	WorkspaceConfig,
+	WorkspaceEnvironment,
+	WorkspaceOptions,
+}
+
+export {
+	createCustomProxy,
+	createViteProxy,
+	generateNetlifyConfig,
+	generateNetlifyRedirect,
+	generateWorkspaceConfig,
+	generateWorkspaceConfigSync,
+	mergeConfigs,
+	resolveConfig,
+	setBuildEnvVars,
+	writeNetlifyConfig,
+}
+
+/**
+ * Define workspace configuration
+ * Simple helper to get config from a config map
+ */
+export function defineWorkspace(
+	configs: Record<WorkspaceEnvironment, WorkspaceConfig>
+) {
+	return (mode: WorkspaceEnvironment = 'development'): WorkspaceConfig => {
+		return configs[mode] || configs.development
+	}
+}
+
+/**
+ * Create a workspace instance for managing project configuration
+ * Supports both single project and monorepo setups
+ */
+export function createWorkspace(options: WorkspaceOptions = {}) {
+	let cachedConfig: WorkspaceConfig | null = null
+
+	return {
+		/**
+		 * Get resolved config for the specified environment
+		 */
+		async getConfig(mode: WorkspaceEnvironment = 'development'): Promise<WorkspaceConfig> {
+			if (!cachedConfig) {
+				cachedConfig = await resolveConfig(mode, options)
+			}
+			return cachedConfig
+		},
+
+		/**
+		 * Create Vite proxy configuration
+		 */
+		createProxy(config: WorkspaceConfig): ProxyConfig {
+			return createViteProxy(config)
+		},
+
+		/**
+		 * Generate Netlify configuration file
+		 */
+		generateNetlify(
+			config: WorkspaceConfig,
+			outPath: string = './netlify.toml',
+			additionalConfig?: string
+		): void {
+			writeNetlifyConfig(config, outPath, additionalConfig)
+		},
+
+		/**
+		 * Set build environment variables
+		 */
+		setBuildEnv(config: WorkspaceConfig): void {
+			setBuildEnvVars(config)
+		},
+
+		/**
+		 * Clear cached configuration
+		 */
+		clearCache(): void {
+			cachedConfig = null
+		},
+	}
+}

package/src/init.ts

@@ -0,0 +1,118 @@
+import { writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * Generate bgl.config.ts file interactively
+ */
+export async function generateWorkspaceConfig(
+	root: string = process.cwd(),
+	configFile: string = 'bgl.config.ts',
+): Promise<void> {
+	console.log('\n🔧 No bgl.config.ts found. Let\'s create one!\n')
+
+	const response = await prompts([
+		{
+			type: 'text',
+			name: 'projectId',
+			message: 'What is your Bagel project ID?',
+			initial: 'my-project',
+			validate: (value: string) => value.length > 0 ? true : 'Project ID is required',
+		},
+		{
+			type: 'confirm',
+			name: 'useCustomHost',
+			message: 'Use custom production host?',
+			initial: false,
+		},
+		{
+			type: (prev: boolean) => (prev ? 'text' : null),
+			name: 'customHost',
+			message: 'Enter production host URL:',
+			initial: 'https://api.example.com',
+		},
+	])
+
+	// User cancelled
+	if (!response || !response.projectId) {
+		console.log('\n❌ Config generation cancelled.\n')
+		process.exit(1)
+	}
+
+	const productionHost = response.useCustomHost === true
+		? response.customHost as string
+		: `https://${response.projectId}.bagel.to`
+
+	const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	local: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`
+
+	const configPath = resolve(root, configFile)
+	writeFileSync(configPath, configContent, 'utf-8')
+
+	console.log(`\n✅ Created ${configFile}`)
+	console.log(`   Production host: ${productionHost}`)
+	console.log(`   Local dev host: http://localhost:8000\n`)
+	console.log('💡 You can edit this file to customize your configuration.\n')
+}
+
+/**
+ * Generate bgl.config.ts non-interactively
+ */
+export function generateWorkspaceConfigSync(
+	projectId: string,
+	root: string = process.cwd(),
+	configFile: string = 'bgl.config.ts',
+	customHost?: string,
+): void {
+	const productionHost = customHost ?? `https://${projectId}.bagel.to`
+
+	const configContent = `import { defineWorkspace } from '@bagelink/workspace'
+import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
+
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+	local: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+	production: {
+		host: '${productionHost}',
+		proxy: '/api',
+		openapi_url: '${productionHost}/openapi.json',
+	},
+}
+
+export default defineWorkspace(configs)
+`
+
+	const configPath = resolve(root, configFile)
+	writeFileSync(configPath, configContent, 'utf-8')
+	console.log(`✅ Created ${configPath}`)
+}

package/src/netlify.ts

@@ -0,0 +1,62 @@
+import type { WorkspaceConfig } from './types'
+import { writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+
+/**
+ * Generate netlify.toml redirect configuration
+ */
+export function generateNetlifyRedirect(config: WorkspaceConfig): string {
+	const redirect = `[[redirects]]
+  from = "${config.proxy}/*"
+  to = "${config.host}/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+`
+
+	return redirect
+}
+
+/**
+ * Generate complete netlify.toml file
+ */
+export function generateNetlifyConfig(
+	config: WorkspaceConfig,
+	additionalConfig?: string,
+): string {
+	const redirect = generateNetlifyRedirect(config)
+
+	if (additionalConfig !== undefined && additionalConfig !== '') {
+		return `${redirect}\n${additionalConfig}`
+	}
+
+	return redirect
+}
+
+/**
+ * Write netlify.toml file to disk
+ */
+export function writeNetlifyConfig(
+	config: WorkspaceConfig,
+	outPath: string = './netlify.toml',
+	additionalConfig?: string
+): void {
+	const content = generateNetlifyConfig(config, additionalConfig)
+	const resolvedPath = resolve(outPath)
+
+	writeFileSync(resolvedPath, content, 'utf-8')
+	console.log(`✓ Generated netlify.toml at ${resolvedPath}`)
+}
+
+/**
+ * Set environment variables for build process
+ */
+export function setBuildEnvVars(config: WorkspaceConfig): void {
+	process.env.BGL_PROXY_PATH = config.proxy
+	process.env.BGL_API_HOST = config.host
+
+	if (config.openapi_url !== undefined && config.openapi_url !== '') {
+		process.env.BGL_OPENAPI_URL = config.openapi_url
+	}
+}

package/src/proxy.ts

@@ -0,0 +1,57 @@
+import type { WorkspaceConfig, ProxyConfig } from './types'
+
+/**
+ * Create Vite proxy configuration from WorkspaceConfig
+ */
+export function createViteProxy(config: WorkspaceConfig): ProxyConfig {
+	const proxy: ProxyConfig = {}
+
+	// Main API proxy
+	if (config.proxy && config.host) {
+		proxy[config.proxy] = {
+			target: config.host,
+			changeOrigin: true,
+			rewrite: (path: string) => path.replace(new RegExp(`^${config.proxy}`), ''),
+			secure: true,
+		}
+	}
+
+	// Files endpoint proxy (direct, no rewrite)
+	if (config.host) {
+		proxy['/files'] = {
+			target: config.host,
+			changeOrigin: true,
+			secure: true,
+		}
+	}
+
+	return proxy
+}
+
+/**
+ * Create custom proxy configuration
+ */
+export function createCustomProxy(
+	paths: string[],
+	target: string,
+	options: {
+		changeOrigin?: boolean
+		rewrite?: boolean
+		secure?: boolean
+	} = {}
+): ProxyConfig {
+	const proxy: ProxyConfig = {}
+
+	for (const path of paths) {
+		proxy[path] = {
+			target,
+			changeOrigin: options.changeOrigin ?? true,
+			secure: options.secure ?? true,
+			...(options.rewrite === true && {
+				rewrite: (p: string) => p.replace(new RegExp(`^${path}`), ''),
+			}),
+		}
+	}
+
+	return proxy
+}

package/src/types.ts

@@ -0,0 +1,49 @@
+export type WorkspaceEnvironment = 'local' | 'development' | 'production'
+
+export interface WorkspaceConfig {
+	/**
+	 * The host URL of the backend API server
+	 * @example 'http://localhost:8000' | 'https://project.bagel.to'
+	 */
+	host: string
+
+	/**
+	 * The proxy path to use for API requests
+	 * @default '/api'
+	 */
+	proxy: string
+
+	/**
+	 * Optional OpenAPI specification URL for SDK generation
+	 */
+	openapi_url?: string
+}
+
+export interface WorkspaceOptions {
+	/**
+	 * Root directory of the workspace
+	 * @default process.cwd()
+	 */
+	root?: string
+
+	/**
+	 * Path to the config file relative to root
+	 * @default 'bgl.config.ts'
+	 */
+	configFile?: string
+
+	/**
+	 * Enable interactive config generation if no config is found
+	 * @default true
+	 */
+	interactive?: boolean
+}
+
+export interface ProxyConfig {
+	[path: string]: {
+		target: string
+		changeOrigin: boolean
+		rewrite?: (path: string) => string
+		secure: boolean
+	}
+}

package/templates/netlify.toml.template

@@ -0,0 +1,6 @@
+[[redirects]]
+  from = "{{BGL_PROXY_PATH}}/*"
+  to = "{{BGL_API_HOST}}/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}