@bagelink/workspace 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Bagel Studio
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,221 @@
+# @bagelink/workspace
+
+Workspace tooling for Bagel projects - works for both single projects and monorepos.
+
+## Features
+
+- 🔧 **Simple Configuration**: One config file for all environments
+- 🔀 **Proxy Management**: Vite dev proxy + Netlify production redirects
+- 🏗️ **Build Tooling**: Auto-generate netlify.toml with environment injection
+- 📦 **Monorepo Support**: Cascading config for multi-project setups
+
+## Installation
+
+```bash
+pnpm add @bagelink/workspace
+```
+
+## Quick Start
+
+### Option 1: Run `npx bgl init`
+
+```bash
+npx bgl init
+
+🔧 No bgl.config.ts found. Let's create one!
+
+? What is your Bagel project ID? › my-project
+? Use custom production host? › No / Yes
+
+✅ Created bgl.config.ts
+   Production host: https://my-project.bagel.to
+   Local dev host: http://localhost:8000
+```
+
+### Option 2: Automatic on first use
+
+The first time you use `@bagelink/workspace`, it will automatically prompt you to create a config file if it doesn't exist.
+
+### Option 3: Create manually
+
+Create `bgl.config.ts`:
+
+```typescript
+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: 'https://project.bagel.to',
+    proxy: '/api',
+    openapi_url: 'https://project.bagel.to/openapi.json',
+  },
+  production: {
+    host: 'https://project.bagel.to',
+    proxy: '/api',
+  },
+}
+
+export default defineWorkspace(configs)
+```
+
+## Usage
+
+### 1. Configure Vite (`vite.config.ts`)
+
+```typescript
+import { defineConfig } from 'vite'
+import { createViteProxy } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+export default defineConfig(({ mode }) => {
+  const config = workspace(mode as WorkspaceEnvironment)
+  
+  return {
+    plugins: [vue()],
+    server: {
+      proxy: createViteProxy(config)
+    }
+  }
+})
+```
+
+### 2. Add scripts to `package.json`
+
+```json
+{
+  "scripts": {
+    "dev": "vite",
+    "dev:local": "vite --mode local",
+    "build": "vite build"
+  }
+}
+```
+
+### 3. Generate Netlify Config
+
+```typescript
+import { writeNetlifyConfig } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+const config = workspace('production')
+writeNetlifyConfig(config, './netlify.toml')
+```
+
+## Monorepo Support
+
+### Root Config (`/bgl.config.ts`)
+
+```typescript
+import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+  local: {
+    host: 'http://localhost:8000',
+    proxy: '/api',
+  },
+  development: {
+    host: 'https://shared.bagel.to',
+    proxy: '/api',
+  },
+  production: {
+    host: 'https://shared.bagel.to',
+    proxy: '/api',
+  },
+})
+```
+
+### Project Override (`/projects/admin/bgl.config.ts`)
+
+```typescript
+import { defineWorkspace } from '@bagelink/workspace'
+import rootWorkspace from '../../bgl.config'
+
+export default defineWorkspace({
+  local: rootWorkspace('local'),
+  development: rootWorkspace('development'),
+  production: {
+    ...rootWorkspace('production'),
+    host: 'https://admin.bagel.to', // Override
+  },
+})
+```
+
+## CLI
+
+### `npx bgl init`
+
+Interactively generate a `bgl.config.ts` file.
+
+```bash
+npx bgl init
+```
+
+### `npx bgl --help`
+
+Show CLI help.
+
+## API
+
+### `defineWorkspace(configs)`
+
+Define workspace configuration for all environments.
+
+```typescript
+const workspace = defineWorkspace({
+  local: { host: 'http://localhost:8000', proxy: '/api' },
+  development: { host: 'https://project.bagel.to', proxy: '/api' },
+  production: { host: 'https://project.bagel.to', proxy: '/api' },
+})
+```
+
+### `generateWorkspaceConfig(root?, configFile?)`
+
+Interactively generate a bgl.config.ts file (called automatically when no config is found).
+
+### `generateWorkspaceConfigSync(projectId, root?, configFile?, customHost?)`
+
+Generate a bgl.config.ts file programmatically.
+
+```typescript
+import { generateWorkspaceConfigSync } from '@bagelink/workspace'
+
+generateWorkspaceConfigSync('my-project')
+// Creates bgl.config.ts with host: https://my-project.bagel.to
+```
+
+### `createWorkspace(options?)`
+
+Create workspace instance with async config resolution (for advanced monorepo setups).
+
+```typescript
+const workspace = createWorkspace({ root: process.cwd() })
+
+const config = await workspace.getConfig('production')
+const proxy = workspace.createProxy(config)
+workspace.generateNetlify(config, './netlify.toml')
+```
+
+### `createViteProxy(config)`
+
+Generate Vite proxy configuration.
+
+### `writeNetlifyConfig(config, outPath?, additionalConfig?)`
+
+Generate and write netlify.toml file.
+
+### `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
+
+## License
+
+MIT © Bagel Studio

package/bin/bgl.ts

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import process from 'node:process'
+import { generateWorkspaceConfig } from '../src/init.js'
+
+const [,, command] = process.argv
+
+async function main() {
+	if (command === 'init') {
+		await generateWorkspaceConfig()
+	}
+	else {
+		console.log(`
+Bagel Workspace CLI
+
+Usage:
+  bgl init          Generate bgl.config.ts interactively
+
+Options:
+  --help, -h        Show this help message
+`)
+		process.exit(command === '--help' || command === '-h' ? 0 : 1)
+	}
+}
+
+main().catch((error: unknown) => {
+	console.error('Error:', error)
+	process.exit(1)
+})

package/dist/bin/bgl.cjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+'use strict';
+
+const process = require('node:process');
+const init = require('../shared/workspace.CmoK7Tc1.cjs');
+require('node:fs');
+require('node:path');
+require('prompts');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+const [, , command] = process__default.argv;
+async function main() {
+  if (command === "init") {
+    await init.generateWorkspaceConfig();
+  } else {
+    console.log(`
+Bagel Workspace CLI
+
+Usage:
+  bgl init          Generate bgl.config.ts interactively
+
+Options:
+  --help, -h        Show this help message
+`);
+    process__default.exit(command === "--help" || command === "-h" ? 0 : 1);
+  }
+}
+main().catch((error) => {
+  console.error("Error:", error);
+  process__default.exit(1);
+});

package/dist/bin/bgl.d.cts

@@ -0,0 +1 @@
+

package/dist/bin/bgl.d.mts

@@ -0,0 +1 @@
+

package/dist/bin/bgl.d.ts

@@ -0,0 +1 @@
+

package/dist/bin/bgl.mjs

@@ -0,0 +1,28 @@
+#!/usr/bin/env node
+import process from 'node:process';
+import { g as generateWorkspaceConfig } from '../shared/workspace.BbV_HGYT.mjs';
+import 'node:fs';
+import 'node:path';
+import 'prompts';
+
+const [, , command] = process.argv;
+async function main() {
+  if (command === "init") {
+    await generateWorkspaceConfig();
+  } else {
+    console.log(`
+Bagel Workspace CLI
+
+Usage:
+  bgl init          Generate bgl.config.ts interactively
+
+Options:
+  --help, -h        Show this help message
+`);
+    process.exit(command === "--help" || command === "-h" ? 0 : 1);
+  }
+}
+main().catch((error) => {
+  console.error("Error:", error);
+  process.exit(1);
+});

package/dist/index.cjs

@@ -0,0 +1,194 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const process = require('node:process');
+const init = require('./shared/workspace.CmoK7Tc1.cjs');
+require('prompts');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+async function resolveConfig(mode = "development", options = {}) {
+  const root = options.root ?? process__default.cwd();
+  const configFile = options.configFile ?? "bgl.config.ts";
+  const localConfigPath = node_path.resolve(root, configFile);
+  const localConfig = await loadConfig(localConfigPath, mode);
+  if (localConfig) {
+    return localConfig;
+  }
+  let currentDir = root;
+  const rootDir = node_path.resolve("/");
+  while (currentDir !== rootDir) {
+    const parentDir = node_path.resolve(currentDir, "..");
+    const parentConfigPath = node_path.join(parentDir, configFile);
+    if (node_fs.existsSync(parentConfigPath)) {
+      const config = await loadConfig(parentConfigPath, mode);
+      if (config) {
+        return config;
+      }
+    }
+    currentDir = parentDir;
+  }
+  if (options.interactive !== false) {
+    await init.generateWorkspaceConfig(root, configFile);
+    const newConfig = await loadConfig(localConfigPath, mode);
+    if (newConfig) {
+      return newConfig;
+    }
+  }
+  throw new Error(`No bgl.config.ts found in ${root} or parent directories`);
+}
+async function loadConfig(configPath, mode) {
+  if (!node_fs.existsSync(configPath)) {
+    return null;
+  }
+  try {
+    const module = await import(`file://${configPath}`);
+    const configMap = module.default ?? module.configs ?? module.config;
+    if (typeof configMap === "function") {
+      return configMap(mode);
+    }
+    if (typeof configMap === "object" && configMap !== null) {
+      const modeConfig = configMap[mode];
+      if (mode in configMap && modeConfig !== void 0 && modeConfig !== null) {
+        return modeConfig;
+      }
+      return configMap;
+    }
+    return null;
+  } catch (error) {
+    console.warn(`Failed to load config from ${configPath}:`, error);
+    return null;
+  }
+}
+function mergeConfigs(base, override) {
+  return {
+    ...base,
+    ...override
+  };
+}
+
+function generateNetlifyRedirect(config) {
+  const redirect = `[[redirects]]
+  from = "${config.proxy}/*"
+  to = "${config.host}/:splat"
+  status = 200
+  force = true
+  headers = {X-From = "Netlify"}
+`;
+  return redirect;
+}
+function generateNetlifyConfig(config, additionalConfig) {
+  const redirect = generateNetlifyRedirect(config);
+  if (additionalConfig !== void 0 && additionalConfig !== "") {
+    return `${redirect}
+${additionalConfig}`;
+  }
+  return redirect;
+}
+function writeNetlifyConfig(config, outPath = "./netlify.toml", additionalConfig) {
+  const content = generateNetlifyConfig(config, additionalConfig);
+  const resolvedPath = node_path.resolve(outPath);
+  node_fs.writeFileSync(resolvedPath, content, "utf-8");
+  console.log(`\u2713 Generated netlify.toml at ${resolvedPath}`);
+}
+function setBuildEnvVars(config) {
+  process__default.env.BGL_PROXY_PATH = config.proxy;
+  process__default.env.BGL_API_HOST = config.host;
+  if (config.openapi_url !== void 0 && config.openapi_url !== "") {
+    process__default.env.BGL_OPENAPI_URL = config.openapi_url;
+  }
+}
+
+function createViteProxy(config) {
+  const proxy = {};
+  if (config.proxy && config.host) {
+    proxy[config.proxy] = {
+      target: config.host,
+      changeOrigin: true,
+      rewrite: (path) => path.replace(new RegExp(`^${config.proxy}`), ""),
+      secure: true
+    };
+  }
+  if (config.host) {
+    proxy["/files"] = {
+      target: config.host,
+      changeOrigin: true,
+      secure: true
+    };
+  }
+  return proxy;
+}
+function createCustomProxy(paths, target, options = {}) {
+  const proxy = {};
+  for (const path of paths) {
+    proxy[path] = {
+      target,
+      changeOrigin: options.changeOrigin ?? true,
+      secure: options.secure ?? true,
+      ...options.rewrite === true && {
+        rewrite: (p) => p.replace(new RegExp(`^${path}`), "")
+      }
+    };
+  }
+  return proxy;
+}
+
+function defineWorkspace(configs) {
+  return (mode = "development") => {
+    return configs[mode] || configs.development;
+  };
+}
+function createWorkspace(options = {}) {
+  let cachedConfig = null;
+  return {
+    /**
+     * Get resolved config for the specified environment
+     */
+    async getConfig(mode = "development") {
+      if (!cachedConfig) {
+        cachedConfig = await resolveConfig(mode, options);
+      }
+      return cachedConfig;
+    },
+    /**
+     * Create Vite proxy configuration
+     */
+    createProxy(config) {
+      return createViteProxy(config);
+    },
+    /**
+     * Generate Netlify configuration file
+     */
+    generateNetlify(config, outPath = "./netlify.toml", additionalConfig) {
+      writeNetlifyConfig(config, outPath, additionalConfig);
+    },
+    /**
+     * Set build environment variables
+     */
+    setBuildEnv(config) {
+      setBuildEnvVars(config);
+    },
+    /**
+     * Clear cached configuration
+     */
+    clearCache() {
+      cachedConfig = null;
+    }
+  };
+}
+
+exports.generateWorkspaceConfig = init.generateWorkspaceConfig;
+exports.generateWorkspaceConfigSync = init.generateWorkspaceConfigSync;
+exports.createCustomProxy = createCustomProxy;
+exports.createViteProxy = createViteProxy;
+exports.createWorkspace = createWorkspace;
+exports.defineWorkspace = defineWorkspace;
+exports.generateNetlifyConfig = generateNetlifyConfig;
+exports.generateNetlifyRedirect = generateNetlifyRedirect;
+exports.mergeConfigs = mergeConfigs;
+exports.resolveConfig = resolveConfig;
+exports.setBuildEnvVars = setBuildEnvVars;
+exports.writeNetlifyConfig = writeNetlifyConfig;

package/dist/index.d.cts

@@ -0,0 +1,127 @@
+type WorkspaceEnvironment = 'local' | 'development' | 'production';
+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;
+}
+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;
+}
+interface ProxyConfig {
+    [path: string]: {
+        target: string;
+        changeOrigin: boolean;
+        rewrite?: (path: string) => string;
+        secure: boolean;
+    };
+}
+
+/**
+ * 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
+ */
+declare function resolveConfig(mode?: WorkspaceEnvironment, options?: WorkspaceOptions): Promise<WorkspaceConfig>;
+/**
+ * Merge two configs, with the second one taking precedence
+ */
+declare function mergeConfigs(base: WorkspaceConfig, override: Partial<WorkspaceConfig>): WorkspaceConfig;
+
+/**
+ * Generate bgl.config.ts file interactively
+ */
+declare function generateWorkspaceConfig(root?: string, configFile?: string): Promise<void>;
+/**
+ * Generate bgl.config.ts non-interactively
+ */
+declare function generateWorkspaceConfigSync(projectId: string, root?: string, configFile?: string, customHost?: string): void;
+
+/**
+ * Generate netlify.toml redirect configuration
+ */
+declare function generateNetlifyRedirect(config: WorkspaceConfig): string;
+/**
+ * Generate complete netlify.toml file
+ */
+declare function generateNetlifyConfig(config: WorkspaceConfig, additionalConfig?: string): string;
+/**
+ * Write netlify.toml file to disk
+ */
+declare function writeNetlifyConfig(config: WorkspaceConfig, outPath?: string, additionalConfig?: string): void;
+/**
+ * Set environment variables for build process
+ */
+declare function setBuildEnvVars(config: WorkspaceConfig): void;
+
+/**
+ * Create Vite proxy configuration from WorkspaceConfig
+ */
+declare function createViteProxy(config: WorkspaceConfig): ProxyConfig;
+/**
+ * Create custom proxy configuration
+ */
+declare function createCustomProxy(paths: string[], target: string, options?: {
+    changeOrigin?: boolean;
+    rewrite?: boolean;
+    secure?: boolean;
+}): ProxyConfig;
+
+/**
+ * Define workspace configuration
+ * Simple helper to get config from a config map
+ */
+declare function defineWorkspace(configs: Record<WorkspaceEnvironment, WorkspaceConfig>): (mode?: WorkspaceEnvironment) => WorkspaceConfig;
+/**
+ * Create a workspace instance for managing project configuration
+ * Supports both single project and monorepo setups
+ */
+declare function createWorkspace(options?: WorkspaceOptions): {
+    /**
+     * Get resolved config for the specified environment
+     */
+    getConfig(mode?: WorkspaceEnvironment): Promise<WorkspaceConfig>;
+    /**
+     * Create Vite proxy configuration
+     */
+    createProxy(config: WorkspaceConfig): ProxyConfig;
+    /**
+     * Generate Netlify configuration file
+     */
+    generateNetlify(config: WorkspaceConfig, outPath?: string, additionalConfig?: string): void;
+    /**
+     * Set build environment variables
+     */
+    setBuildEnv(config: WorkspaceConfig): void;
+    /**
+     * Clear cached configuration
+     */
+    clearCache(): void;
+};
+
+export { createCustomProxy, createViteProxy, createWorkspace, defineWorkspace, generateNetlifyConfig, generateNetlifyRedirect, generateWorkspaceConfig, generateWorkspaceConfigSync, mergeConfigs, resolveConfig, setBuildEnvVars, writeNetlifyConfig };
+export type { ProxyConfig, WorkspaceConfig, WorkspaceEnvironment, WorkspaceOptions };