@bagelink/workspace 1.7.3 → 1.8.0

package/src/workspace.ts

@@ -0,0 +1,432 @@
+import { existsSync, mkdirSync, readdirSync, writeFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+import process from 'node:process'
+import prompts from 'prompts'
+
+/**
+ * Initialize a new workspace with flat structure
+ */
+export async function initWorkspace(root: string = process.cwd()): Promise<void> {
+	console.log('\n🚀 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: boolean) => (prev ? 'text' : null),
+			name: 'firstProjectName',
+			message: 'First project name:',
+			initial: 'web',
+		},
+	])
+
+	if (!response || !response.workspaceName) {
+		console.log('\n❌ Workspace creation cancelled.\n')
+		process.exit(1)
+	}
+
+	const { workspaceName, projectId, createFirstProject, firstProjectName } = response
+
+	// Create workspace structure
+	createWorkspaceRoot(root, workspaceName, projectId)
+
+	// Create shared package
+	createSharedPackage(root)
+
+	if (createFirstProject && firstProjectName) {
+		await addProject(firstProjectName, root)
+	}
+
+	console.log('\n✅ 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('')
+}
+
+/**
+ * Create workspace root files
+ */
+function createWorkspaceRoot(root: string, name: string, projectId: string): void {
+	const workspaceDir = resolve(root, name)
+
+	if (existsSync(workspaceDir)) {
+		console.error(`❌ Directory ${name} already exists`)
+		process.exit(1)
+	}
+
+	mkdirSync(workspaceDir, { recursive: true })
+
+	// package.json
+	const packageJson = {
+		name,
+		private: true,
+		workspaces: ['*', '!node_modules'],
+		scripts: {
+			dev: 'bun run --filter \'./[!shared]*\' dev',
+			build: 'bun run --filter \'./[!shared]*\' build',
+			typecheck: 'tsc --noEmit',
+		},
+		devDependencies: {
+			'@bagelink/workspace': 'latest',
+			typescript: '^5.0.0',
+			vite: 'latest',
+		},
+	}
+
+	writeFileSync(
+		resolve(workspaceDir, 'package.json'),
+		`${JSON.stringify(packageJson, null, 2)}\n`,
+	)
+
+	// bgl.config.ts (shared)
+	const bglConfig = `import { defineWorkspace } from '@bagelink/workspace'
+
+export default defineWorkspace({
+	localhost: {
+		host: 'http://localhost:8000',
+		proxy: '/api',
+		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)
+
+	// tsconfig.json
+	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)}\n`,
+	)
+
+	// .gitignore
+	const gitignore = `node_modules
+dist
+.DS_Store
+*.local
+.env.local
+.vite
+`
+
+	writeFileSync(resolve(workspaceDir, '.gitignore'), gitignore)
+
+	console.log(`✅ Created workspace: ${name}`)
+}
+
+/**
+ * Create shared package
+ */
+function createSharedPackage(root: string): void {
+	const sharedDir = resolve(root, 'shared')
+	mkdirSync(sharedDir, { recursive: true })
+
+	// package.json
+	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)}\n`,
+	)
+
+	// index.ts
+	writeFileSync(
+		resolve(sharedDir, 'index.ts'),
+		'// Shared utilities and exports\nexport * from \'./utils\'\n',
+	)
+
+	// utils/index.ts
+	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',
+	)
+
+	// types/index.ts
+	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('✅ Created shared package')
+}
+
+/**
+ * Add a new project to the workspace
+ */
+export async function addProject(
+	name: string,
+	root: string = process.cwd(),
+): Promise<void> {
+	const projectDir = resolve(root, name)
+
+	if (existsSync(projectDir)) {
+		console.error(`❌ Project ${name} already exists`)
+		process.exit(1)
+	}
+
+	console.log(`\n📦 Creating project: ${name}\n`)
+
+	mkdirSync(projectDir, { recursive: true })
+
+	// Determine if this is part of a workspace
+	const isWorkspace = existsSync(resolve(root, 'bgl.config.ts'))
+
+	// package.json
+	const packageJson: Record<string, unknown> = {
+		name,
+		type: 'module',
+		scripts: {
+			dev: 'vite',
+			build: 'vite build',
+			preview: 'vite preview',
+		},
+		dependencies: {} as Record<string, string>,
+		devDependencies: {
+			'@vitejs/plugin-vue': 'latest',
+			vite: 'latest',
+			vue: 'latest',
+		},
+	}
+
+	// Add shared dependency if in workspace
+	if (isWorkspace) {
+		(packageJson.dependencies as Record<string, string>).shared = 'workspace:*'
+	}
+
+	writeFileSync(
+		resolve(projectDir, 'package.json'),
+		`${JSON.stringify(packageJson, null, 2)}\n`,
+	)
+
+	// bgl.config.ts
+	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)
+
+	// vite.config.ts
+	const viteConfig = `import { defineConfig } from 'vite'
+import vue from '@vitejs/plugin-vue'
+import { createViteProxy } from '@bagelink/workspace'
+import workspace from './bgl.config'
+
+export default defineConfig(({ mode }) => {
+	const config = workspace(mode as 'localhost' | 'development' | 'production')
+
+	return {
+		plugins: [vue()],
+		server: {
+			proxy: createViteProxy(config),
+		},
+	}
+})
+`
+
+	writeFileSync(resolve(projectDir, 'vite.config.ts'), viteConfig)
+
+	// Create basic src structure
+	const srcDir = resolve(projectDir, 'src')
+	mkdirSync(srcDir, { recursive: true })
+
+	// index.html
+	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)
+
+	// main.ts
+	const mainTs = `import { createApp } from 'vue'
+import App from './App.vue'
+
+createApp(App).mount('#app')
+`
+
+	writeFileSync(resolve(srcDir, 'main.ts'), mainTs)
+
+	// App.vue
+	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>
+`
+
+	writeFileSync(resolve(srcDir, 'App.vue'), appVue)
+
+	console.log(`✅ Created project: ${name}`)
+
+	// Update workspace package.json if needed
+	if (isWorkspace) {
+		updateWorkspaceScripts(root, name)
+	}
+
+	console.log('\nNext steps:')
+	console.log(`  cd ${name}`)
+	console.log('  bun install')
+	console.log('  bun run dev')
+	console.log('')
+}
+
+/**
+ * Update workspace root package.json with new project scripts
+ */
+function updateWorkspaceScripts(root: string, projectName: string): void {
+	const packageJsonPath = resolve(root, 'package.json')
+	if (!existsSync(packageJsonPath)) return
+
+	try {
+		const packageJson = JSON.parse(
+			require('fs').readFileSync(packageJsonPath, 'utf-8'),
+		)
+
+		if (!packageJson.scripts) {
+			packageJson.scripts = {}
+		}
+
+		// Add project-specific scripts
+		packageJson.scripts[`dev:${projectName}`] = `bun --filter ${projectName} dev`
+		packageJson.scripts[`build:${projectName}`] = `bun --filter ${projectName} build`
+
+		writeFileSync(
+			packageJsonPath,
+			`${JSON.stringify(packageJson, null, 2)}\n`,
+		)
+
+		console.log(`✅ Added scripts: dev:${projectName}, build:${projectName}`)
+	}
+	catch (error) {
+		console.warn('⚠️  Could not update workspace scripts')
+	}
+}
+
+/**
+ * List all projects in workspace
+ */
+export function listProjects(root: string = process.cwd()): string[] {
+	try {
+		const items = readdirSync(root, { withFileTypes: true })
+		return items
+			.filter(
+				item =>
+					item.isDirectory()
+					&& item.name !== 'node_modules'
+					&& item.name !== 'shared'
+					&& item.name !== '.git'
+					&& !item.name.startsWith('.'),
+			)
+			.map(item => item.name)
+	}
+	catch {
+		return []
+	}
+}

package/dist/shared/workspace.BaaKkm9b.mjs

@@ -1,182 +0,0 @@
-import { writeFileSync, existsSync, readFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-import process from 'node:process';
-import prompts from 'prompts';
-
-async function generateWorkspaceConfig(root = process.cwd(), configFile = "bgl.config.ts") {
-  console.log("\n\u{1F527} 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) => value.length > 0 ? true : "Project ID is required"
-    },
-    {
-      type: "confirm",
-      name: "useCustomHost",
-      message: "Use custom production host?",
-      initial: false
-    },
-    {
-      type: (prev) => prev ? "text" : null,
-      name: "customHost",
-      message: "Enter production host URL:",
-      initial: "https://api.example.com"
-    }
-  ]);
-  if (!response || !response.projectId) {
-    console.log("\n\u274C Config generation cancelled.\n");
-    process.exit(1);
-  }
-  const productionHost = response.useCustomHost === true ? response.customHost : `https://${response.projectId}.bagel.to`;
-  const configContent = `import { defineWorkspace } from '@bagelink/workspace'
-import type { WorkspaceConfig, WorkspaceEnvironment } from '@bagelink/workspace'
-
-const configs: Record<WorkspaceEnvironment, WorkspaceConfig> = {
-	localhost: {
-		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(`
-\u2705 Created ${configFile}`);
-  console.log(`   Production host: ${productionHost}`);
-  console.log(`   Local dev host: http://localhost:8000
-`);
-  const setupResponse = await prompts([
-    {
-      type: "confirm",
-      name: "updatePackageJson",
-      message: "Add dev scripts to package.json?",
-      initial: true
-    },
-    {
-      type: "confirm",
-      name: "updateViteConfig",
-      message: "Create/update vite.config.ts?",
-      initial: true
-    }
-  ]);
-  if (setupResponse.updatePackageJson) {
-    updatePackageJsonScripts(root);
-  }
-  if (setupResponse.updateViteConfig) {
-    updateViteConfig(root);
-  }
-  console.log("\n\u{1F4A1} You can edit these files to customize your configuration.\n");
-}
-function generateWorkspaceConfigSync(projectId, root = process.cwd(), configFile = "bgl.config.ts", customHost) {
-  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> = {
-	localhost: {
-		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(`\u2705 Created ${configPath}`);
-}
-function updatePackageJsonScripts(root) {
-  const packageJsonPath = resolve(root, "package.json");
-  if (!existsSync(packageJsonPath)) {
-    console.log("\u26A0\uFE0F  No package.json found, skipping script update");
-    return;
-  }
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    if (!packageJson.scripts) {
-      packageJson.scripts = {};
-    }
-    const scriptsToAdd = {
-      "dev": "vite",
-      "dev:local": "vite --mode localhost",
-      "build": "vite build",
-      "preview": "vite preview"
-    };
-    let added = false;
-    for (const [key, value] of Object.entries(scriptsToAdd)) {
-      if (!packageJson.scripts[key]) {
-        packageJson.scripts[key] = value;
-        added = true;
-      }
-    }
-    if (added) {
-      writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
-`, "utf-8");
-      console.log("\u2705 Updated package.json with dev scripts");
-    } else {
-      console.log("\u2139\uFE0F  Scripts already exist in package.json");
-    }
-  } catch (error) {
-    console.error("\u274C Failed to update package.json:", error);
-  }
-}
-function updateViteConfig(root) {
-  const viteConfigPath = resolve(root, "vite.config.ts");
-  const viteConfigExists = existsSync(viteConfigPath);
-  if (viteConfigExists) {
-    const existingConfig = readFileSync(viteConfigPath, "utf-8");
-    if (existingConfig.includes("@bagelink/workspace")) {
-      console.log("\u2139\uFE0F  vite.config.ts already configured");
-      return;
-    }
-    console.log("\u26A0\uFE0F  vite.config.ts exists. Please manually add the workspace configuration.");
-    console.log("    See: https://github.com/bageldb/bagelink/tree/master/packages/workspace#readme");
-    return;
-  }
-  const viteConfigContent = `import { defineConfig } from 'vite'
-import { createViteProxy } from '@bagelink/workspace'
-import workspace from './bgl.config'
-
-// https://vitejs.dev/config/
-export default defineConfig(({ mode }) => {
-	const config = workspace(mode as 'localhost' | 'development' | 'production')
-
-	return {
-		server: {
-			proxy: createViteProxy(config),
-		},
-	}
-})
-`;
-  writeFileSync(viteConfigPath, viteConfigContent, "utf-8");
-  console.log("\u2705 Created vite.config.ts");
-}
-
-export { generateWorkspaceConfigSync as a, generateWorkspaceConfig as g };