@enfyra/create 0.1.4 → 0.1.5

package/README.md

@@ -10,10 +10,12 @@ The generated project contains:
 
 - `app/` - Enfyra Nuxt admin app
 - `server/` - Enfyra server
-- Root workspace scripts for running both together
+- Root scripts for running both together
 - `app/.env` connected to `http://localhost:1105`
 - `server/.env` with `PORT=1105`
 
+`app/` and `server/` are installed as separate applications. Their dependencies and lockfiles stay inside each folder; the root folder only coordinates scripts.
+
 The CLI prompts for:
 
 - Package manager: npm, yarn, or pnpm

package/components/project-setup.js

@@ -7,7 +7,6 @@ const { downloadTemplate } = require('giget');
 const { generateEnvFiles } = require('./env-builder');
 const {
   getInstallCommand,
-  getPackageExecCommand,
   getPackageRunCommand,
   getWorkspaceRunCommand,
 } = require('./package-managers');
@@ -36,14 +35,15 @@ async function createProject(config, projectPath) {
     });
     spinner.succeed(chalk.green('Server downloaded'));
 
-    spinner.start(chalk.blue(`Preparing ${config.packageManager} workspaces...`));
+    spinner.start(chalk.blue(`Preparing ${config.packageManager} project...`));
     await removeTemplateFiles(projectPath);
     await cleanPackageManagerRestrictions(projectPath);
-    await updateWorkspacePackageJson(projectPath, config);
-    await writePackageManagerConfig(projectPath, config);
     await updateAppPackageJson(path.join(projectPath, 'app'), config);
     await updateServerPackageJson(path.join(projectPath, 'server'), config);
-    spinner.succeed(chalk.green(`${config.packageManager} workspaces prepared`));
+    await updateWorkspacePackageJson(projectPath, config);
+    await writePackageManagerConfig(projectPath, config);
+    await writeRootScripts(projectPath, config);
+    spinner.succeed(chalk.green(`${config.packageManager} project prepared`));
 
     spinner.start(chalk.blue('Generating environment files...'));
     await generateEnvFiles(projectPath, config);
@@ -66,81 +66,62 @@ async function createProject(config, projectPath) {
 async function updateWorkspacePackageJson(projectPath, config) {
   const packageName = toPackageName(config.projectName);
   const packageManager = config.packageManager;
-  const resolutions = await collectTemplateResolutions(projectPath);
-  const serverReadyTarget = `tcp:localhost:${config.serverPort}`;
-  const waitForServerCommand = getPackageExecCommand(packageManager, 'wait-on', [serverReadyTarget]);
   const packageJson = {
     name: packageName,
     version: '0.1.0',
     private: true,
-    workspaces: [
-      'app',
-      'server',
-    ],
     scripts: {
-      dev: `concurrently -k -n server,app -c cyan,green "${getWorkspaceRunCommand(packageManager, 'server', 'dev')}" "${waitForServerCommand} && ${getWorkspaceRunCommand(packageManager, 'app', 'dev')}"`,
+      dev: 'node scripts/run-both.js dev',
       'dev:app': getWorkspaceRunCommand(packageManager, 'app', 'dev'),
       'dev:server': getWorkspaceRunCommand(packageManager, 'server', 'dev'),
       build: `${getWorkspaceRunCommand(packageManager, 'server', 'build')} && ${getWorkspaceRunCommand(packageManager, 'app', 'build')}`,
       'build:app': getWorkspaceRunCommand(packageManager, 'app', 'build'),
       'build:server': getWorkspaceRunCommand(packageManager, 'server', 'build'),
-      start: `concurrently -k -n server,app -c cyan,green "${getWorkspaceRunCommand(packageManager, 'server', 'start')}" "${waitForServerCommand} && ${getWorkspaceRunCommand(packageManager, 'app', 'start')}"`,
+      start: 'node scripts/run-both.js start',
       'start:app': getWorkspaceRunCommand(packageManager, 'app', 'start'),
       'start:server': getWorkspaceRunCommand(packageManager, 'server', 'start'),
       serve: getPackageRunCommand(packageManager, 'start'),
       'preview:app': getWorkspaceRunCommand(packageManager, 'app', 'preview'),
     },
-    devDependencies: {
-      concurrently: '^9.2.1',
-      'wait-on': '^8.0.3',
-    },
   };
 
   if (config.packageManagerVersion) {
     packageJson.packageManager = `${packageManager}@${config.packageManagerVersion}`;
   }
 
-  if (packageManager === 'yarn' && Object.keys(resolutions).length > 0) {
-    packageJson.resolutions = resolutions;
-  }
-
   await fs.writeJson(path.join(projectPath, 'package.json'), packageJson, { spaces: 2 });
   await fs.writeFile(path.join(projectPath, '.gitignore'), buildGitignore());
   await ensureWorkspaceGitignores(projectPath);
-  if (packageManager === 'pnpm') {
-    await fs.writeFile(path.join(projectPath, 'pnpm-workspace.yaml'), buildPnpmWorkspaceYaml(resolutions, config.packageManagerVersion));
-  }
 }
 
 async function writePackageManagerConfig(projectPath, config) {
-  if (config.packageManager === 'npm') {
-    await fs.writeFile(
-      path.join(projectPath, '.npmrc'),
-      [
-        'install-strategy=nested',
-        '',
-      ].join('\n'),
-    );
+  if (config.packageManager === 'pnpm') {
+    for (const workspace of ['app', 'server']) {
+      await fs.writeFile(
+        path.join(projectPath, workspace, 'pnpm-workspace.yaml'),
+        buildPnpmProjectConfig(config.packageManagerVersion),
+      );
+    }
     return;
   }
 
   if (config.packageManager !== 'yarn') return;
 
+  await fs.writeFile(path.join(projectPath, '.yarnrc.yml'), buildYarnConfig());
+  await fs.writeFile(path.join(projectPath, 'yarn.lock'), buildRootYarnLock(toPackageName(config.projectName)));
+
+  for (const workspace of ['app', 'server']) {
+    await fs.writeFile(path.join(projectPath, workspace, '.yarnrc.yml'), buildYarnConfig());
+    await fs.ensureFile(path.join(projectPath, workspace, 'yarn.lock'));
+  }
+}
+
+async function writeRootScripts(projectPath, config) {
+  const scriptsPath = path.join(projectPath, 'scripts');
+  await fs.ensureDir(scriptsPath);
   await fs.writeFile(
-    path.join(projectPath, '.yarnrc.yml'),
-    [
-      'approvedGitRepositories:',
-      '  - "**"',
-      '',
-      'enableScripts: true',
-      '',
-      'nodeLinker: node-modules',
-      '',
-      'nmHoistingLimits: workspaces',
-      '',
-      'npmMinimalAgeGate: 0',
-      '',
-    ].join('\n'),
+    path.join(scriptsPath, 'run-both.js'),
+    buildRunBothScript(config.packageManager, config.serverPort),
   );
 }
 
@@ -257,11 +238,16 @@ function ensureAppDirectDependencies(packageJson) {
   }
 }
 
-function installDependencies(projectPath, packageManager) {
+async function installDependencies(projectPath, packageManager) {
+  await installWorkspaceDependencies(path.join(projectPath, 'server'), packageManager);
+  await installWorkspaceDependencies(path.join(projectPath, 'app'), packageManager);
+}
+
+function installWorkspaceDependencies(workspacePath, packageManager) {
   return new Promise((resolve, reject) => {
     const { command, args } = getInstallCommand(packageManager);
     const install = spawn(command, args, {
-      cwd: projectPath,
+      cwd: workspacePath,
       stdio: 'pipe',
     });
 
@@ -282,7 +268,7 @@ function installDependencies(projectPath, packageManager) {
         return;
       }
 
-      reject(new Error(stderr || stdout || `npm install failed with code ${code}`));
+      reject(new Error(stderr || stdout || `${command} install failed with code ${code}`));
     });
 
     install.on('error', (error) => {
@@ -291,6 +277,127 @@ function installDependencies(projectPath, packageManager) {
   });
 }
 
+function buildYarnConfig() {
+  return [
+    'approvedGitRepositories:',
+    '  - "**"',
+    '',
+    'enableScripts: true',
+    '',
+    'nodeLinker: node-modules',
+    '',
+    'npmMinimalAgeGate: 0',
+    '',
+  ].join('\n');
+}
+
+function buildRootYarnLock(packageName) {
+  return [
+    '# This file is generated by @enfyra/create for root scripts.',
+    '',
+    '__metadata:',
+    '  version: 10',
+    '  cacheKey: 10c0',
+    '',
+    `"${packageName}@workspace:.":`,
+    '  version: 0.0.0-use.local',
+    `  resolution: "${packageName}@workspace:."`,
+    '  languageName: unknown',
+    '  linkType: soft',
+    '',
+  ].join('\n');
+}
+
+function buildRunBothScript(packageManager, serverPort) {
+  const escapedPackageManager = JSON.stringify(packageManager);
+  const escapedServerPort = JSON.stringify(serverPort);
+
+  return `const net = require('net');
+const path = require('path');
+const { spawn } = require('child_process');
+
+const packageManager = ${escapedPackageManager};
+const serverPort = ${escapedServerPort};
+const script = process.argv[2] || 'dev';
+const root = path.resolve(__dirname, '..');
+const children = new Set();
+let shuttingDown = false;
+
+function runArgs(name) {
+  if (packageManager === 'yarn') return [name];
+  return ['run', name];
+}
+
+function spawnWorkspace(label, workspace, name) {
+  const child = spawn(packageManager, runArgs(name), {
+    cwd: path.join(root, workspace),
+    stdio: 'inherit',
+    shell: process.platform === 'win32',
+  });
+
+  children.add(child);
+  child.on('exit', (code, signal) => {
+    children.delete(child);
+    if (!shuttingDown && (code || signal)) {
+      console.error(\`\\n\${label} exited\${signal ? \` with signal \${signal}\` : \` with code \${code}\`}.\`);
+      shutdown(code || 1);
+    }
+  });
+
+  return child;
+}
+
+function waitForPort(port, host = '127.0.0.1', timeoutMs = 120000) {
+  const startedAt = Date.now();
+
+  return new Promise((resolve, reject) => {
+    const attempt = () => {
+      const socket = net.createConnection({ port, host });
+
+      socket.once('connect', () => {
+        socket.destroy();
+        resolve();
+      });
+
+      socket.once('error', () => {
+        socket.destroy();
+        if (Date.now() - startedAt >= timeoutMs) {
+          reject(new Error(\`Timed out waiting for server on port \${port}\`));
+          return;
+        }
+        setTimeout(attempt, 500);
+      });
+    };
+
+    attempt();
+  });
+}
+
+function shutdown(code = 0) {
+  if (shuttingDown) return;
+  shuttingDown = true;
+
+  for (const child of children) {
+    if (!child.killed) child.kill('SIGTERM');
+  }
+
+  setTimeout(() => process.exit(code), 250);
+}
+
+process.on('SIGINT', () => shutdown(0));
+process.on('SIGTERM', () => shutdown(0));
+
+(async () => {
+  spawnWorkspace('server', 'server', script);
+  await waitForPort(serverPort);
+  spawnWorkspace('app', 'app', script);
+})().catch((error) => {
+  console.error(error.message);
+  shutdown(1);
+});
+`;
+}
+
 function buildGitignore() {
   return [
     'node_modules',
@@ -326,21 +433,7 @@ function mergeGitignoreEntries(content, entries) {
   return `${lines.join('\n').replace(/\n+$/, '')}\n`;
 }
 
-async function collectTemplateResolutions(projectPath) {
-  const resolutions = {};
-
-  for (const workspace of ['app', 'server']) {
-    const packageJsonPath = path.join(projectPath, workspace, 'package.json');
-    if (!fs.existsSync(packageJsonPath)) continue;
-
-    const packageJson = await fs.readJson(packageJsonPath);
-    Object.assign(resolutions, packageJson.resolutions || {});
-  }
-
-  return resolutions;
-}
-
-function buildPnpmWorkspaceYaml(resolutions, pnpmVersion) {
+function buildPnpmProjectConfig(pnpmVersion) {
   const allowedBuildDependencies = [
     '@parcel/watcher',
     'esbuild',
@@ -349,12 +442,7 @@ function buildPnpmWorkspaceYaml(resolutions, pnpmVersion) {
     'sharp',
     'vue-demi',
   ];
-  const lines = [
-    'packages:',
-    '  - app',
-    '  - server',
-    '',
-  ];
+  const lines = [];
 
   if (getMajorVersion(pnpmVersion) >= 11) {
     lines.push('allowBuilds:');
@@ -368,14 +456,6 @@ function buildPnpmWorkspaceYaml(resolutions, pnpmVersion) {
     }
   }
 
-  const overrideEntries = Object.entries(resolutions);
-  if (overrideEntries.length > 0) {
-    lines.push('', 'overrides:');
-    for (const [name, version] of overrideEntries) {
-      lines.push(`  ${yamlQuote(name)}: ${yamlQuote(version)}`);
-    }
-  }
-
   return `${lines.join('\n')}\n`;
 }
 
@@ -401,7 +481,9 @@ module.exports = {
   cleanPackageManagerRestrictions,
   rewritePackageManagerScripts,
   toPackageName,
-  buildPnpmWorkspaceYaml,
-  ensureAppDirectDependencies,
   mergeGitignoreEntries,
+  ensureAppDirectDependencies,
+  buildPnpmProjectConfig,
+  buildRunBothScript,
+  buildRootYarnLock,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@enfyra/create",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Create a complete Enfyra app with frontend and server workspaces",
   "main": "index.js",
   "bin": {