@bagelink/workspace 1.11.0 → 1.11.3

package/dist/shared/workspace.Bhp9XbPk.mjs

@@ -0,0 +1,581 @@
+import { existsSync, mkdirSync, writeFileSync, readdirSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import process from 'node:process';
+import prompts from 'prompts';
+
+async function resolveLatestVersion(pkg) {
+  try {
+    const res = await fetch(`https://registry.npmjs.org/${pkg}/latest`);
+    if (!res.ok) return "latest";
+    const data = await res.json();
+    return `^${data.version}`;
+  } catch {
+    return "latest";
+  }
+}
+async function initWorkspace(root = process.cwd()) {
+  console.log("\n\u{1F680} Creating Bagel workspace...\n");
+  const response = await prompts([
+    {
+      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.exit(1);
+  }
+  const { workspaceName, projectId, createFirstProject, firstProjectName } = response;
+  const workspaceDir = resolve(root, workspaceName);
+  console.log("Resolving package versions...");
+  const allPkgs = [
+    "@bagelink/auth",
+    "@bagelink/sdk",
+    "@bagelink/vue",
+    "pinia",
+    "vue",
+    "vue-router",
+    "@bagelink/lint-config",
+    "@bagelink/workspace",
+    "@vitejs/plugin-vue",
+    "eslint",
+    "vite"
+  ];
+  const versions = Object.fromEntries(
+    await Promise.all(allPkgs.map(async (pkg) => [pkg, await resolveLatestVersion(pkg)]))
+  );
+  createWorkspaceRoot(root, workspaceName, projectId, versions);
+  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, versions) {
+  const workspaceDir = resolve(root, name);
+  if (existsSync(workspaceDir)) {
+    console.error(`\u274C Directory ${name} already exists`);
+    process.exit(1);
+  }
+  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": versions["@bagelink/auth"],
+      "@bagelink/sdk": versions["@bagelink/sdk"],
+      "@bagelink/vue": versions["@bagelink/vue"],
+      "pinia": versions.pinia,
+      "vue": versions.vue,
+      "vue-router": versions["vue-router"]
+    },
+    devDependencies: {
+      "@bagelink/lint-config": versions["@bagelink/lint-config"],
+      "@bagelink/workspace": versions["@bagelink/workspace"],
+      "@vitejs/plugin-vue": versions["@vitejs/plugin-vue"],
+      "eslint": versions.eslint,
+      "typescript": "^5.0.0",
+      "vite": versions.vite
+    }
+  };
+  writeFileSync(
+    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',
+	},
+})
+`;
+  writeFileSync(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/*"]
+      }
+    }
+  };
+  writeFileSync(
+    resolve(workspaceDir, "tsconfig.json"),
+    `${JSON.stringify(tsConfig, null, 2)}
+`
+  );
+  const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`;
+  writeFileSync(resolve(workspaceDir, ".gitignore"), gitignore);
+  const scriptsDir = resolve(workspaceDir, "scripts");
+  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()
+})
+`;
+  writeFileSync(resolve(scriptsDir, "dev.ts"), devRunnerContent);
+  console.log(`\u2705 Created workspace: ${name}`);
+}
+function createSharedPackage(root) {
+  const sharedDir = resolve(root, "shared");
+  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"
+    }
+  };
+  writeFileSync(
+    resolve(sharedDir, "package.json"),
+    `${JSON.stringify(packageJson, null, 2)}
+`
+  );
+  writeFileSync(
+    resolve(sharedDir, "index.ts"),
+    "// Shared utilities and exports\nexport * from './utils'\n"
+  );
+  mkdirSync(resolve(sharedDir, "utils"), { recursive: true });
+  writeFileSync(
+    resolve(sharedDir, "utils", "index.ts"),
+    "// Shared utility functions\nexport function formatDate(date: Date): string {\n  return date.toISOString()\n}\n"
+  );
+  mkdirSync(resolve(sharedDir, "types"), { recursive: true });
+  writeFileSync(
+    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.cwd()) {
+  const projectDir = resolve(root, name);
+  if (existsSync(projectDir)) {
+    console.error(`\u274C Project ${name} already exists`);
+    process.exit(1);
+  }
+  console.log(`
+\u{1F4E6} Creating project: ${name}
+`);
+  console.log("Resolving package versions...");
+  const projectPkgs = ["@vitejs/plugin-vue", "vite", "vue", "pinia", "vue-router"];
+  const versions = Object.fromEntries(
+    await Promise.all(projectPkgs.map(async (pkg) => [pkg, await resolveLatestVersion(pkg)]))
+  );
+  mkdirSync(projectDir, { recursive: true });
+  const isWorkspace = existsSync(resolve(root, "bgl.config.ts"));
+  const packageJson = {
+    name,
+    type: "module",
+    scripts: {
+      dev: "vite",
+      build: "vite build",
+      preview: "vite preview"
+    },
+    dependencies: {
+      "pinia": versions.pinia,
+      "vue": versions.vue,
+      "vue-router": versions["vue-router"]
+    },
+    devDependencies: {
+      "@vitejs/plugin-vue": versions["@vitejs/plugin-vue"],
+      "vite": versions.vite
+    }
+  };
+  if (isWorkspace) {
+    packageJson.dependencies.shared = "workspace:*";
+  }
+  writeFileSync(
+    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',
+	},
+})
+`;
+  writeFileSync(resolve(projectDir, "bgl.config.ts"), bglConfigContent);
+  const viteConfig = `import { resolve } from 'node:path'
+import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { bagelink } from '@bagelink/workspace/vite'
+import workspace from './bgl.config'
+
+export default defineConfig({
+	resolve: {
+		alias: {
+			'@': resolve(__dirname, 'src'),
+		},
+	},
+	plugins: [
+		vue(),
+		bagelink({ workspace }),
+	],
+})
+`;
+  writeFileSync(resolve(projectDir, "vite.config.ts"), viteConfig);
+  const tsconfigJson = {
+    extends: "../tsconfig.app.json",
+    compilerOptions: {
+      types: ["vite/client"],
+      paths: {
+        "@/*": ["./src/*"]
+      }
+    },
+    include: ["src/**/*"]
+  };
+  writeFileSync(
+    resolve(projectDir, "tsconfig.json"),
+    `${JSON.stringify(tsconfigJson, null, 2)}
+`
+  );
+  const srcDir = resolve(projectDir, "src");
+  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>
+`;
+  writeFileSync(resolve(projectDir, "index.html"), indexHtml);
+  const routerDir = resolve(srcDir, "router");
+  mkdirSync(routerDir, { recursive: true });
+  const routerTs = `import { createRouter, createWebHistory } from 'vue-router'
+import HomeView from '../views/HomeView.vue'
+
+export default createRouter({
+	history: createWebHistory(import.meta.env.BASE_URL),
+	routes: [
+		{ path: '/', component: HomeView },
+	],
+})
+`;
+  writeFileSync(resolve(routerDir, "index.ts"), routerTs);
+  const viewsDir = resolve(srcDir, "views");
+  mkdirSync(viewsDir, { recursive: true });
+  const homeView = `<script setup lang="ts">
+${isWorkspace ? "import { formatDate } from 'shared/utils'\n" : ""}
+<\/script>
+
+<template>
+	<main>
+		<h1>${name}</h1>
+		${isWorkspace ? "<p>{{ formatDate(new Date()) }}</p>" : ""}
+	</main>
+</template>
+`;
+  writeFileSync(resolve(viewsDir, "HomeView.vue"), homeView);
+  const mainTs = `import { createApp } from 'vue'
+import { createPinia } from 'pinia'
+import { BagelVue } from '@bagelink/vue'
+import router from './router'
+import App from './App.vue'
+
+createApp(App)
+	.use(createPinia())
+	.use(router)
+	.use(BagelVue)
+	.mount('#app')
+`;
+  writeFileSync(resolve(srcDir, "main.ts"), mainTs);
+  const appVue = `<script setup lang="ts">
+import { RouterView } from 'vue-router'
+<\/script>
+
+<template>
+	<RouterView />
+</template>
+`;
+  writeFileSync(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 = resolve(root, "package.json");
+  if (!existsSync(packageJsonPath)) return;
+  try {
+    const packageJson = JSON.parse(
+      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`;
+    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.cwd()) {
+  try {
+    const items = 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 = resolve(root, item.name, "package.json");
+      if (!existsSync(packageJsonPath)) return false;
+      try {
+        const packageJson = JSON.parse(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 = resolve(outPath);
+  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.env.BGL_PROXY_PATH = config.proxy;
+  process.env.BGL_API_HOST = config.host;
+  if (config.openapi_url !== void 0 && config.openapi_url !== "") {
+    process.env.BGL_OPENAPI_URL = config.openapi_url;
+  }
+}
+
+export { addProject as a, generateNetlifyConfig as g, initWorkspace as i, listProjects as l, setBuildEnvVars as s, writeNetlifyConfig as w };