@bagelink/workspace 1.10.6 → 1.10.9

package/README.md

@@ -57,10 +57,15 @@ Create `bgl.config.ts`:
 import { defineWorkspace } from '@bagelink/workspace'
 import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
 
+/**
+ * Define your workspace environments
+ * You can add as many custom environments as needed (e.g., 'staging', 'preview')
+ * Use --mode flag to switch: bgl dev --mode <env_name>
+ */
 const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
   localhost: {
     host: 'http://localhost:8000',
-    proxy: '/api',
+    proxy: '/api', // Optional: remove to skip proxy setup
     openapi_url: 'http://localhost:8000/openapi.json',
   },
   development: {
@@ -72,6 +77,11 @@ const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
     host: 'https://project.bagel.to',
     proxy: '/api',
   },
+  // Add your own custom environments
+  staging: {
+    host: 'https://staging.project.bagel.to',
+    proxy: '/api',
+  },
 }
 
 export default defineWorkspace(configs)
@@ -79,7 +89,66 @@ export default defineWorkspace(configs)
 
 ## Usage
 
-### 1. Configure Vite (`vite.config.ts`)
+### 1. Add Type Definitions
+
+Add to your project's `env.d.ts`:
+
+```typescript
+/// <reference types="@bagelink/workspace/env" />
+```
+
+This provides TypeScript types for injected environment variables.
+
+### 2. Configure Vite (`vite.config.ts`)
+
+**Recommended: Use the Vite plugin (keeps your config clean and standard)**
+
+```typescript
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
+import workspace from './bgl.config'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    bagelink({ workspace }),
+  ],
+})
+```
+
+The plugin automatically:
+- Configures proxy based on `bgl.config.ts`
+- Sets up `@` alias pointing to `./src`
+- Sets up `@shared` alias (in monorepos)
+- Keeps your vite.config.ts clean and extensible
+
+**Advanced: Custom options**
+
+```typescript
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
+import { fileURLToPath } from 'node:url'
+import workspace from './bgl.config'
+
+export default defineConfig({
+  plugins: [
+    vue(),
+    bagelink({
+      workspace,
+      config: {
+        sharedPath: '../packages/shared',
+        additionalAliases: {
+          '@utils': fileURLToPath(new URL('./src/utils', import.meta.url))
+        }
+      }
+    }),
+  ],
+})
+```
+
+**Legacy: Manual proxy setup**
 
 ```typescript
 import { defineConfig } from 'vite'
@@ -98,19 +167,104 @@ export default defineConfig(({ mode }) => {
 })
 ```
 
-### 2. Add scripts to `package.json`
+### 3. Use Configuration in Your App
+
+**Access config at runtime with `useWorkspace()`:**
+
+```typescript
+import { useWorkspace, getApiUrl } from '@bagelink/workspace'
+
+// In your app setup
+const { baseURL, proxy, host, mode } = useWorkspace()
+const auth = createAuth({ baseURL }) // Uses proxy if available, otherwise host
+
+// Or get full API URL
+const apiUrl = getApiUrl() // 'https://project.bagel.to/api'
+```
+
+**Vue component example:**
+
+```vue
+<script setup lang="ts">
+import { useWorkspace } from '@bagelink/workspace'
+import { createAuth } from '@bagelink/auth'
+
+const { baseURL, proxy, host, mode } = useWorkspace()
+const auth = createAuth({ baseURL }) // Uses proxy if available, otherwise host
+
+console.log('API Host:', host)
+console.log('Environment:', mode)
+</script>
+```
+
+**Access raw environment variables:**
+
+```typescript
+// These are injected at build time by the bagelink plugin
+const proxy = import.meta.env.VITE_BGL_PROXY        // '/api'
+const host = import.meta.env.VITE_BGL_HOST          // 'https://project.bagel.to'
+const openapi = import.meta.env.VITE_BGL_OPENAPI_URL // optional
+```
+
+### 4. Add scripts to `package.json`
 
 ```json
 {
   "scripts": {
     "dev": "vite",
     "dev:local": "vite --mode localhost",
-    "build": "vite build"
+    "dev:staging": "vite --mode staging",
+    "build": "vite build",
+    "build:staging": "vite build --mode staging"
   }
 }
 ```
 
-### 3. Generate Netlify Config
+### 5. Custom Environments
+
+You can define as many custom environments as you need. The environment name is completely flexible:
+
+```typescript
+const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
+  localhost: {
+    host: 'http://localhost:8000',
+    proxy: '/api',
+  },
+  development: {
+    host: 'https://dev.project.bagel.to',
+    proxy: '/api',
+  },
+  staging: {
+    host: 'https://staging.project.bagel.to',
+    proxy: '/api',
+  },
+  preview: {
+    host: 'https://preview.project.bagel.to',
+    // No proxy - will use host directly
+  },
+  production: {
+    host: 'https://project.bagel.to',
+    proxy: '/api',
+  },
+}
+```
+
+Use the `--mode` flag to switch environments:
+
+```bash
+# Development
+bgl dev --mode development
+
+# Staging
+bgl dev --mode staging
+
+# Production build
+bgl build --mode production
+```
+
+**Note:** The `proxy` field is optional. If omitted, no proxy will be configured for that environment, and `baseURL` from `useWorkspace()` will return the `host` value instead.
+
+### 6. Generate Netlify Config
 
 ```typescript
 import { writeNetlifyConfig } from '@bagelink/workspace'
@@ -409,7 +563,42 @@ Show CLI help.
 
 ## API
 
-### `defineWorkspace(configs)`
+### Runtime Functions
+
+#### `useWorkspace()`
+
+Get workspace configuration at runtime. Config is injected as environment variables during build.
+
+```typescript
+import { useWorkspace } from '@bagelink/workspace'
+
+const { baseURL, proxy, host, openapiUrl, mode } = useWorkspace()
+```
+
+**Returns:**
+```typescript
+interface RuntimeWorkspaceConfig {
+  baseURL: string        // proxy if available, otherwise host
+  proxy?: string         // '/api' (optional)
+  host: string           // 'https://project.bagel.to'
+  openapiUrl?: string    // optional
+  mode: string           // current environment (e.g., 'localhost', 'development', 'staging')
+}
+```
+
+#### `getApiUrl()`
+
+Get the full API URL by combining host and proxy.
+
+```typescript
+import { getApiUrl } from '@bagelink/workspace'
+
+const apiUrl = getApiUrl() // 'https://project.bagel.to/api'
+```
+
+### Configuration Functions
+
+#### `defineWorkspace(configs)`
 
 Define workspace configuration for all environments.
 
@@ -448,21 +637,37 @@ const proxy = workspace.createProxy(config)
 workspace.generateNetlify(config, './netlify.toml')
 ```
 
-### `createViteProxy(config)`
+### Build-Time Functions
+
+These are available from `@bagelink/workspace/vite`:
+
+#### `createViteProxy(config)`
 
 Generate Vite proxy configuration.
 
-### `writeNetlifyConfig(config, outPath?, additionalConfig?)`
+```typescript
+import { createViteProxy } from '@bagelink/workspace/vite'
+```
+
+#### `writeNetlifyConfig(config, outPath?, additionalConfig?)`
 
 Generate and write netlify.toml file.
 
-### `setBuildEnvVars(config)`
+```typescript
+import { writeNetlifyConfig } from '@bagelink/workspace/vite'
+```
+
+#### `setBuildEnvVars(config)`
 
 Set environment variables for build process:
 - `BGL_PROXY_PATH` - Proxy path (e.g., `/api`)
 - `BGL_API_HOST` - API host URL
 - `BGL_OPENAPI_URL` - OpenAPI specification URL
 
+```typescript
+import { setBuildEnvVars } from '@bagelink/workspace/vite'
+```
+
 ## License
 
 MIT © Bagel Studio

package/bin/bgl.ts

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
+import { resolve } from 'node:path'
 import process from 'node:process'
+import { runBuild } from '../src/build.js'
 import { isWorkspace } from '../src/detect.js'
+import { runDev } from '../src/dev.js'
 import { generateWorkspaceConfig } from '../src/init.js'
 import { setupLint } from '../src/lint.js'
 import { generateSDK, generateSDKForWorkspace } from '../src/sdk.js'
@@ -10,16 +13,29 @@ const [,, command, subcommand, ...args] = process.argv
 
 async function main() {
 	if (command === 'init') {
-		const createWorkspace = args.includes('--workspace') || args.includes('-w')
+		// Check both subcommand and args for --workspace flag
+		const createWorkspace
+			= subcommand === '--workspace'
+				|| subcommand === '-w'
+				|| args.includes('--workspace')
+				|| args.includes('-w')
+
+		// Support 'bgl init .' or 'bgl init <path>'
+		let targetPath = process.cwd()
+		if (subcommand && !subcommand.startsWith('-')) {
+			// If subcommand is not a flag, treat it as a path
+			targetPath = subcommand === '.' ? process.cwd() : resolve(process.cwd(), subcommand)
+		}
+
 		if (createWorkspace) {
 			await initWorkspace()
 		}
 		else {
-			await generateWorkspaceConfig()
+			await generateWorkspaceConfig(targetPath)
 		}
 	}
 	else if (command === 'add') {
-		const projectName = args[0]
+		const projectName = subcommand // 'bgl add admin' -> subcommand is 'admin'
 		if (!projectName) {
 			console.error('Error: Project name is required')
 			console.log('Usage: bgl add <project-name>')
@@ -92,21 +108,48 @@ SDK Commands:
 			process.exit(1)
 		}
 	}
+	else if (command === 'dev') {
+		const { filter, additionalArgs } = parseFilterArgs(
+			undefined,
+			subcommand,
+			args,
+		)
+		const exitCode = await runDev(filter, additionalArgs)
+		process.exit(exitCode)
+	}
+	else if (command === 'build') {
+		const { filter, additionalArgs } = parseFilterArgs(
+			undefined,
+			subcommand,
+			args,
+		)
+		const exitCode = await runBuild(filter, additionalArgs)
+		process.exit(exitCode)
+	}
 	else {
 		console.log(`
 Bagel Workspace CLI
 
 Usage:
-  bgl init                  Generate bgl.config.ts for single project
+  bgl init [path]           Generate bgl.config.ts for single project
+                            Examples: bgl init, bgl init ., bgl init ./my-app
   bgl init --workspace      Create a new workspace with multiple projects
   bgl add <name>            Add a new project to workspace
   bgl list                  List all projects in workspace
+  bgl dev [filter] [...args] Run dev servers with clean output (default: './!shared*')
+                            Examples:
+                              bgl dev --mode localhost
+                              bgl dev --mode staging
+                              bgl dev admin --mode production
+  bgl build [project] [...args] Build project by directory (default: all projects)
+                            Example: bgl build --mode production
   bgl lint init             Set up linting (auto-detects workspace)
   bgl sdk generate          Generate SDK (auto-detects workspace)
 
 Options:
   --workspace, -w           Force workspace mode
   --project, -p             Force single project mode
+  --mode <env>              Set environment (matches bgl.config.ts keys)
   --help, -h                Show this help message
 
 Note: Commands auto-detect workspace mode based on directory structure
@@ -115,6 +158,54 @@ Note: Commands auto-detect workspace mode based on directory structure
 	}
 }
 
+function normalizeFilter(input: string): string {
+	// Keep glob patterns as-is, otherwise ensure ./ prefix
+	if (input.startsWith('.') || input.includes('*') || input.includes('[')) {
+		return input
+	}
+	return `./${input}`
+}
+
+function parseFilterArgs(
+	defaultFilter: string | undefined,
+	subcommandArg?: string,
+	argsList: string[] = [],
+): { filter?: string, additionalArgs: string[] } {
+	const tokens = [subcommandArg, ...argsList].filter(Boolean) as string[]
+
+	// Flags that take values
+	const flagsWithValues = new Set(['--mode', '--host', '--port'])
+
+	// Find non-flag tokens (excluding flag values)
+	const nonFlagIndexes: number[] = []
+	for (let i = 0; i < tokens.length; i++) {
+		const token = tokens[i]
+		if (token.startsWith('-')) {
+			// If this flag takes a value, skip the next token
+			if (flagsWithValues.has(token)) {
+				i++ // Skip next token (the value)
+			}
+		} else {
+			// Not a flag and not a flag value
+			const prevToken = i > 0 ? tokens[i - 1] : null
+			if (!prevToken || !flagsWithValues.has(prevToken)) {
+				nonFlagIndexes.push(i)
+			}
+		}
+	}
+
+	const filterIndex = nonFlagIndexes.length > 0
+		? nonFlagIndexes[nonFlagIndexes.length - 1]
+		: -1
+	const filter = filterIndex >= 0
+		? normalizeFilter(tokens[filterIndex])
+		: defaultFilter
+	const additionalArgs = filterIndex >= 0
+		? tokens.filter((_, index) => index !== filterIndex)
+		: tokens
+	return { filter, additionalArgs }
+}
+
 main().catch((error: unknown) => {
 	console.error('Error:', error)
 	process.exit(1)