@bagelink/workspace 1.10.6 → 1.10.9

package/dist/shared/workspace.DRlDHdPw.cjs

@@ -0,0 +1,512 @@
+'use strict';
+
+const node_fs = require('node:fs');
+const node_path = require('node:path');
+const process = require('node:process');
+const prompts = require('prompts');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+const prompts__default = /*#__PURE__*/_interopDefaultCompat(prompts);
+
+async function initWorkspace(root = process__default.cwd()) {
+  console.log("\n\u{1F680} Creating Bagel workspace...\n");
+  const response = await prompts__default([
+    {
+      type: "text",
+      name: "workspaceName",
+      message: "Workspace name:",
+      initial: "my-workspace"
+    },
+    {
+      type: "text",
+      name: "projectId",
+      message: "Bagel project ID:",
+      initial: "my-project"
+    },
+    {
+      type: "confirm",
+      name: "createFirstProject",
+      message: "Create first project?",
+      initial: true
+    },
+    {
+      type: (prev) => prev ? "text" : null,
+      name: "firstProjectName",
+      message: "First project name:",
+      initial: "web"
+    }
+  ]);
+  if (!response || !response.workspaceName) {
+    console.log("\n\u274C Workspace creation cancelled.\n");
+    process__default.exit(1);
+  }
+  const { workspaceName, projectId, createFirstProject, firstProjectName } = response;
+  const workspaceDir = node_path.resolve(root, workspaceName);
+  createWorkspaceRoot(root, workspaceName, projectId);
+  createSharedPackage(workspaceDir);
+  if (createFirstProject && firstProjectName) {
+    await addProject(firstProjectName, workspaceDir);
+  }
+  console.log("\n\u2705 Workspace created successfully!");
+  console.log("\nNext steps:");
+  console.log(`  cd ${workspaceName}`);
+  console.log("  bun install");
+  if (createFirstProject) {
+    console.log(`  bun run dev:${firstProjectName}`);
+  } else {
+    console.log("  bgl add <project-name>  # Add a project");
+  }
+  console.log("");
+}
+function createWorkspaceRoot(root, name, projectId) {
+  const workspaceDir = node_path.resolve(root, name);
+  if (node_fs.existsSync(workspaceDir)) {
+    console.error(`\u274C Directory ${name} already exists`);
+    process__default.exit(1);
+  }
+  node_fs.mkdirSync(workspaceDir, { recursive: true });
+  const packageJson = {
+    name,
+    private: true,
+    workspaces: ["*", "!node_modules"],
+    scripts: {
+      "dev": "bgl dev",
+      "dev:local": "bgl dev --mode localhost",
+      "dev:verbose": "bun run --filter './!shared*' dev",
+      "build": "bgl build",
+      "typecheck": "tsc --noEmit",
+      "lint": "eslint . --cache",
+      "lint:fix": "eslint . --cache --fix"
+    },
+    dependencies: {
+      "@bagelink/auth": "latest",
+      "@bagelink/sdk": "latest",
+      "@bagelink/vue": "latest",
+      "pinia": "latest",
+      "vue": "latest",
+      "vue-router": "latest"
+    },
+    devDependencies: {
+      "@bagelink/lint-config": "latest",
+      "@bagelink/workspace": "latest",
+      "@vitejs/plugin-vue": "latest",
+      "eslint": "latest",
+      "typescript": "^5.0.0",
+      "vite": "latest"
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(workspaceDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  const bglConfig = `import { defineWorkspace } 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>
+ */
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api', // Optional: remove to skip proxy setup
+		openapi_url: 'http://localhost:8000/openapi.json',
+	},
+	development: {
+		host: 'https://${projectId}.bagel.to',
+		proxy: '/api',
+		openapi_url: 'https://${projectId}.bagel.to/openapi.json',
+	},
+	production: {
+		host: 'https://${projectId}.bagel.to',
+		proxy: '/api',
+		openapi_url: 'https://${projectId}.bagel.to/openapi.json',
+	},
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(workspaceDir, "bgl.config.ts"), bglConfig);
+  const tsConfig = {
+    compilerOptions: {
+      target: "ES2020",
+      useDefineForClassFields: true,
+      module: "ESNext",
+      lib: ["ES2020", "DOM", "DOM.Iterable"],
+      skipLibCheck: true,
+      moduleResolution: "bundler",
+      allowImportingTsExtensions: true,
+      resolveJsonModule: true,
+      isolatedModules: true,
+      noEmit: true,
+      jsx: "preserve",
+      strict: true,
+      noUnusedLocals: true,
+      noUnusedParameters: true,
+      noFallthroughCasesInSwitch: true,
+      baseUrl: ".",
+      paths: {
+        "shared/*": ["./shared/*"]
+      }
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(workspaceDir, "tsconfig.json"),
+    `${JSON.stringify(tsConfig, null, 2)}
+`
+  );
+  const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`;
+  node_fs.writeFileSync(node_path.resolve(workspaceDir, ".gitignore"), gitignore);
+  const scriptsDir = node_path.resolve(workspaceDir, "scripts");
+  node_fs.mkdirSync(scriptsDir, { recursive: true });
+  const devRunnerContent = `#!/usr/bin/env bun
+import { spawn } from 'bun'
+import { readdir } from 'fs/promises'
+import { resolve } from 'path'
+
+const projectsRoot = process.cwd()
+const projects = (await readdir(projectsRoot, { withFileTypes: true }))
+	.filter(
+		item =>
+			item.isDirectory()
+			&& item.name !== 'node_modules'
+			&& item.name !== 'shared'
+			&& item.name !== 'scripts'
+			&& item.name !== '.git'
+			&& !item.name.startsWith('.'),
+	)
+	.map(item => item.name)
+
+console.log(\`\\n\u{1F680} Starting \${projects.length} project\${projects.length > 1 ? 's' : ''}...\\n\`)
+
+const urlPattern = /Local:\\s+(http:\\/\\/localhost:\\d+)/
+
+projects.forEach((project) => {
+	const proc = spawn({
+		cmd: ['bun', 'run', 'dev'],
+		cwd: resolve(projectsRoot, project),
+		stdout: 'pipe',
+		stderr: 'pipe',
+	})
+
+	const decoder = new TextDecoder()
+
+	proc.stdout.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				const match = text.match(urlPattern)
+				if (match) {
+					console.log(\`  \u2713 \${project.padEnd(15)} \u2192 \${match[1]}\`)
+				}
+			},
+		}),
+	)
+
+	proc.stderr.pipeTo(
+		new WritableStream({
+			write(chunk) {
+				const text = decoder.decode(chunk)
+				if (text.includes('error') || text.includes('Error')) {
+					console.error(\`  \u2717 \${project}: \${text.trim()}\`)
+				}
+			},
+		}),
+	)
+})
+
+console.log('\\n\u{1F4A1} Press Ctrl+C to stop all servers\\n')
+
+process.on('SIGINT', () => {
+	console.log('\\n\\n\u{1F44B} Stopping all servers...\\n')
+	process.exit()
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(scriptsDir, "dev.ts"), devRunnerContent);
+  console.log(`\u2705 Created workspace: ${name}`);
+}
+function createSharedPackage(root) {
+  const sharedDir = node_path.resolve(root, "shared");
+  node_fs.mkdirSync(sharedDir, { recursive: true });
+  const packageJson = {
+    name: "shared",
+    version: "1.0.0",
+    type: "module",
+    exports: {
+      ".": "./index.ts",
+      "./utils": "./utils/index.ts",
+      "./types": "./types/index.ts"
+    }
+  };
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "index.ts"),
+    "// Shared utilities and exports\nexport * from './utils'\n"
+  );
+  node_fs.mkdirSync(node_path.resolve(sharedDir, "utils"), { recursive: true });
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "utils", "index.ts"),
+    "// Shared utility functions\nexport function formatDate(date: Date): string {\n  return date.toISOString()\n}\n"
+  );
+  node_fs.mkdirSync(node_path.resolve(sharedDir, "types"), { recursive: true });
+  node_fs.writeFileSync(
+    node_path.resolve(sharedDir, "types", "index.ts"),
+    "// Shared types\nexport interface User {\n  id: string\n  name: string\n}\n"
+  );
+  console.log("\u2705 Created shared package");
+}
+async function addProject(name, root = process__default.cwd()) {
+  const projectDir = node_path.resolve(root, name);
+  if (node_fs.existsSync(projectDir)) {
+    console.error(`\u274C Project ${name} already exists`);
+    process__default.exit(1);
+  }
+  console.log(`
+\u{1F4E6} Creating project: ${name}
+`);
+  node_fs.mkdirSync(projectDir, { recursive: true });
+  const isWorkspace = node_fs.existsSync(node_path.resolve(root, "bgl.config.ts"));
+  const packageJson = {
+    name,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {},
+    devDependencies: {
+      "@vitejs/plugin-vue": "latest",
+      "vite": "latest",
+      "vue": "latest"
+    }
+  };
+  if (isWorkspace) {
+    packageJson.dependencies.shared = "workspace:*";
+  }
+  node_fs.writeFileSync(
+    node_path.resolve(projectDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  const bglConfigContent = isWorkspace ? `import { defineWorkspace } from '@bagelink/workspace'
+import rootWorkspace from '../bgl.config'
+
+export default defineWorkspace({
+	localhost: rootWorkspace('localhost'),
+	development: rootWorkspace('development'),
+	production: rootWorkspace('production'),
+})
+` : `import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+	},
+	development: {
+		host: 'https://my-project.bagel.to',
+		proxy: '/api',
+	},
+	production: {
+		host: 'https://my-project.bagel.to',
+		proxy: '/api',
+	},
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "bgl.config.ts"), bglConfigContent);
+  const viteConfig = `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 }),
+	],
+})
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "vite.config.ts"), viteConfig);
+  const srcDir = node_path.resolve(projectDir, "src");
+  node_fs.mkdirSync(srcDir, { recursive: true });
+  const indexHtml = `<!DOCTYPE html>
+<html lang="en">
+<head>
+	<meta charset="UTF-8">
+	<meta name="viewport" content="width=device-width, initial-scale=1.0">
+	<title>${name}</title>
+</head>
+<body>
+	<div id="app"></div>
+	<script type="module" src="/src/main.ts"><\/script>
+</body>
+</html>
+`;
+  node_fs.writeFileSync(node_path.resolve(projectDir, "index.html"), indexHtml);
+  const mainTs = `import { createApp } from 'vue'
+import { BagelVue } from '@bagelink/vue'
+import App from './App.vue'
+
+createApp(App)
+	.use(BagelVue)
+	.mount('#app')
+`;
+  node_fs.writeFileSync(node_path.resolve(srcDir, "main.ts"), mainTs);
+  const appVue = `<script setup lang="ts">
+import { ref } from 'vue'
+${isWorkspace ? "import { formatDate } from 'shared/utils'\n" : ""}
+const count = ref(0)
+<\/script>
+
+<template>
+	<div>
+		<h1>${name}</h1>
+		<button @click="count++">Count: {{ count }}</button>
+		${isWorkspace ? "<p>{{ formatDate(new Date()) }}</p>" : ""}
+	</div>
+</template>
+`;
+  node_fs.writeFileSync(node_path.resolve(srcDir, "App.vue"), appVue);
+  console.log(`\u2705 Created project: ${name}`);
+  if (isWorkspace) {
+    updateWorkspaceScripts(root, name);
+  }
+  console.log("\nNext steps:");
+  console.log(`  cd ${name}`);
+  console.log("  bun install");
+  console.log("  bun run dev");
+  console.log("");
+}
+function updateWorkspaceScripts(root, projectName) {
+  const packageJsonPath = node_path.resolve(root, "package.json");
+  if (!node_fs.existsSync(packageJsonPath)) return;
+  try {
+    const packageJson = JSON.parse(
+      node_fs.readFileSync(packageJsonPath, "utf-8")
+    );
+    if (!packageJson.scripts) {
+      packageJson.scripts = {};
+    }
+    packageJson.scripts[`dev:${projectName}`] = `bun --filter ${projectName} dev`;
+    packageJson.scripts[`build:${projectName}`] = `bun --filter ${projectName} build`;
+    node_fs.writeFileSync(
+      packageJsonPath,
+      `${JSON.stringify(packageJson, null, 2)}
+`
+    );
+    console.log(`\u2705 Added scripts: dev:${projectName}, build:${projectName}`);
+  } catch (error) {
+    console.warn("\u26A0\uFE0F  Could not update workspace scripts");
+  }
+}
+function listProjects(root = process__default.cwd()) {
+  try {
+    const items = node_fs.readdirSync(root, { withFileTypes: true });
+    return items.filter(
+      (item) => item.isDirectory() && item.name !== "node_modules" && item.name !== "shared" && item.name !== "scripts" && item.name !== ".git" && !item.name.startsWith(".")
+    ).filter((item) => {
+      const packageJsonPath = node_path.resolve(root, item.name, "package.json");
+      if (!node_fs.existsSync(packageJsonPath)) return false;
+      try {
+        const packageJson = JSON.parse(node_fs.readFileSync(packageJsonPath, "utf-8"));
+        return packageJson.scripts?.dev !== void 0;
+      } catch {
+        return false;
+      }
+    }).map((item) => item.name).sort();
+  } catch {
+    return [];
+  }
+}
+
+function generateNetlifyRedirect(config) {
+  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
+  force = true
+  headers = {X-From = "Netlify"}
+`;
+  return redirect;
+}
+function generateNetlifyConfigTemplate() {
+  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
+`;
+}
+function generateNetlifyConfig(config, additionalConfig, useTemplate = false) {
+  if (useTemplate) {
+    return generateNetlifyConfigTemplate();
+  }
+  const redirect = generateNetlifyRedirect(config);
+  if (additionalConfig !== void 0 && additionalConfig !== "") {
+    return `${redirect}
+${additionalConfig}`;
+  }
+  return redirect;
+}
+function writeNetlifyConfig(config, outPath = "./netlify.toml", additionalConfig, useTemplate = false) {
+  const content = generateNetlifyConfig(config, additionalConfig, useTemplate);
+  const resolvedPath = node_path.resolve(outPath);
+  node_fs.writeFileSync(resolvedPath, content, "utf-8");
+  console.log(`\u2713 Generated netlify.toml at ${resolvedPath}`);
+  if (!useTemplate) {
+    console.log("\n\u{1F4A1} 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("");
+  }
+}
+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;
+  }
+}
+
+exports.addProject = addProject;
+exports.generateNetlifyConfig = generateNetlifyConfig;
+exports.initWorkspace = initWorkspace;
+exports.listProjects = listProjects;
+exports.setBuildEnvVars = setBuildEnvVars;
+exports.writeNetlifyConfig = writeNetlifyConfig;

package/dist/vite.cjs

@@ -0,0 +1,135 @@
+'use strict';
+
+const node_path = require('node:path');
+const process = require('node:process');
+const node_url = require('node:url');
+const netlify = require('./shared/workspace.DRlDHdPw.cjs');
+require('node:fs');
+require('prompts');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+const process__default = /*#__PURE__*/_interopDefaultCompat(process);
+
+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: false,
+      ws: true,
+      followRedirects: true,
+      autoRewrite: true,
+      protocolRewrite: "http",
+      configure: (proxy2, _options) => {
+        proxy2.on("proxyReq", (proxyReq, req, _res) => {
+          if (req.headers.origin) {
+            proxyReq.setHeader("origin", config.host);
+          }
+        });
+        proxy2.on("error", (err, _req, _res) => {
+          console.log("proxy error", err);
+        });
+      }
+    };
+  }
+  if (config.host) {
+    proxy["/files"] = {
+      target: config.host,
+      changeOrigin: true,
+      secure: false,
+      ws: true,
+      followRedirects: 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 ?? false,
+      ws: options.ws ?? true,
+      ...options.rewrite === true && {
+        rewrite: (p) => p.replace(new RegExp(`^${path}`), "")
+      }
+    };
+  }
+  return proxy;
+}
+
+function bagelink(options) {
+  const { workspace, config = {} } = options;
+  let workspaceConfig;
+  return {
+    name: "vite-plugin-bagelink",
+    enforce: "pre",
+    configResolved(resolved) {
+      workspaceConfig = workspace(resolved.mode);
+    },
+    config(userConfig, { mode }) {
+      workspaceConfig = workspace(mode);
+      const alias = {};
+      if (config.includeSharedAlias !== false) {
+        const sharedPath = config.sharedPath ?? "../shared";
+        alias["@shared"] = node_url.fileURLToPath(new URL(sharedPath, `file://${process__default.cwd()}/`));
+      }
+      alias["@"] = node_url.fileURLToPath(new URL("./src", `file://${process__default.cwd()}/`));
+      if (config.additionalAliases) {
+        Object.assign(alias, config.additionalAliases);
+      }
+      let port;
+      try {
+        const currentDir = process__default.cwd();
+        const projectName = node_path.basename(currentDir);
+        const parentDir = node_url.fileURLToPath(new URL("..", `file://${currentDir}/`));
+        const allProjects = netlify.listProjects(parentDir);
+        const projectIndex = allProjects.indexOf(projectName);
+        if (projectIndex !== -1) {
+          port = 5173 + projectIndex;
+        }
+      } catch {
+      }
+      const server = {
+        ...config.configureProxy !== false && {
+          proxy: createViteProxy(workspaceConfig)
+        },
+        ...port !== void 0 && {
+          port,
+          strictPort: false
+          // use next available port if preferred is taken
+        }
+      };
+      const define = {
+        ...workspaceConfig.proxy && {
+          "import.meta.env.VITE_BGL_PROXY": JSON.stringify(workspaceConfig.proxy)
+        },
+        "import.meta.env.VITE_BGL_HOST": JSON.stringify(workspaceConfig.host),
+        ...workspaceConfig.openapi_url && {
+          "import.meta.env.VITE_BGL_OPENAPI_URL": JSON.stringify(workspaceConfig.openapi_url)
+        }
+      };
+      return {
+        resolve: {
+          alias
+        },
+        define,
+        server,
+        optimizeDeps: {
+          exclude: ["@bagelink/workspace"]
+        }
+      };
+    }
+  };
+}
+
+exports.generateNetlifyConfig = netlify.generateNetlifyConfig;
+exports.setBuildEnvVars = netlify.setBuildEnvVars;
+exports.writeNetlifyConfig = netlify.writeNetlifyConfig;
+exports.bagelink = bagelink;
+exports.createCustomProxy = createCustomProxy;
+exports.createViteProxy = createViteProxy;