@lark-apaas/coding-template-nestjs-react-fullstack 0.1.36-alpha.20260904132704 → 0.1.36-alpha.20260904234124

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lark-apaas/coding-template-nestjs-react-fullstack",
-  "version": "0.1.36-alpha.20260904132704",
+  "version": "0.1.36-alpha.20260904234124",
   "description": "NestJS + React fullstack template for miaoda coding",
   "type": "module",
   "files": [

package/template/package.json

@@ -10,7 +10,7 @@
   },
   "scripts": {
     "dev": "./scripts/dev.sh",
-    "dev:server": "NODE_ENV=development nest start --watch",
+    "dev:server": "NODE_ENV=development node scripts/nest-type-check.cjs",
     "dev:client": "NODE_ENV=development vite --config vite.config.ts",
     "gen:db-schema": "npx -y @lark-apaas/db-schema-sync@latest --output server/database/schema.ts --export-custom-types",
     "gen:openapi": "echo 'UNSUPPORTED, SKIP'",

package/template/scripts/dev.js

@@ -5,7 +5,6 @@ const fs = require('fs');
 const path = require('path');
 const { spawn, execSync } = require('child_process');
 const readline = require('readline');
-const { buildNestServerArgs } = require('./nest-type-check.cjs');
 
 // ── Project root ──────────────────────────────────────────────────────────────
 const PROJECT_ROOT = path.resolve(__dirname, '..');
@@ -32,10 +31,9 @@ loadEnv();
 
 // ── Configuration ─────────────────────────────────────────────────────────────
 const LOG_DIR = process.env.LOG_DIR || 'logs';
-const MAX_RESTART_COUNT =
-  process.env.MAX_RESTART_COUNT != null && process.env.MAX_RESTART_COUNT !== ''
-    ? parseInt(process.env.MAX_RESTART_COUNT, 10)
-    : Infinity;
+const MAX_RESTART_COUNT = process.env.MAX_RESTART_COUNT != null && process.env.MAX_RESTART_COUNT !== ''
+  ? parseInt(process.env.MAX_RESTART_COUNT, 10)
+  : Infinity;
 const RESTART_DELAY = parseInt(process.env.RESTART_DELAY, 10) || 2;
 const MAX_DELAY = 8;
 const SERVER_PORT = process.env.SERVER_PORT || '3000';
@@ -52,37 +50,26 @@ const devLogFd = fs.openSync(devLogPath, 'a');
 function timestamp() {
   const now = new Date();
   return (
-    now.getFullYear() +
-    '-' +
-    String(now.getMonth() + 1).padStart(2, '0') +
-    '-' +
-    String(now.getDate()).padStart(2, '0') +
-    ' ' +
-    String(now.getHours()).padStart(2, '0') +
-    ':' +
-    String(now.getMinutes()).padStart(2, '0') +
-    ':' +
+    now.getFullYear() + '-' +
+    String(now.getMonth() + 1).padStart(2, '0') + '-' +
+    String(now.getDate()).padStart(2, '0') + ' ' +
+    String(now.getHours()).padStart(2, '0') + ':' +
+    String(now.getMinutes()).padStart(2, '0') + ':' +
     String(now.getSeconds()).padStart(2, '0')
   );
 }
 
 /** Write to terminal + dev.std.log */
 function writeOutput(msg) {
-  try {
-    process.stdout.write(msg);
-  } catch {}
-  try {
-    fs.writeSync(devStdLogFd, msg);
-  } catch {}
+  try { process.stdout.write(msg); } catch {}
+  try { fs.writeSync(devStdLogFd, msg); } catch {}
 }
 
 /** Structured event log → terminal + dev.std.log + dev.log */
 function logEvent(level, name, message) {
   const msg = `[${timestamp()}] [${level}] [${name}] ${message}\n`;
   writeOutput(msg);
-  try {
-    fs.writeSync(devLogFd, msg);
-  } catch {}
+  try { fs.writeSync(devLogFd, msg); } catch {}
 }
 
 // ── Process group management ──────────────────────────────────────────────────
@@ -94,16 +81,11 @@ function killProcessGroup(pid, signal) {
 
 function killOrphansByPort(port) {
   try {
-    const pids = execSync(`lsof -ti :${port}`, {
-      encoding: 'utf8',
-      timeout: 5000,
-    }).trim();
+    const pids = execSync(`lsof -ti :${port}`, { encoding: 'utf8', timeout: 5000 }).trim();
     if (pids) {
       const pidList = pids.split('\n').filter(Boolean);
       for (const p of pidList) {
-        try {
-          process.kill(parseInt(p, 10), 'SIGKILL');
-        } catch {}
+        try { process.kill(parseInt(p, 10), 'SIGKILL'); } catch {}
       }
       return pidList;
     }
@@ -146,23 +128,14 @@ function startProcess({ name, command, args, cleanupPort }) {
       entry.child = child;
 
       const startTime = Date.now();
-      logEvent(
-        'INFO',
-        name,
-        `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`,
-      );
+      logEvent('INFO', name, `Process started (PGID: ${child.pid}): ${command} ${args.join(' ')}`);
 
       // Pipe stdout and stderr through readline for timestamped logging
       const pipeLines = (stream) => {
-        const rl = readline.createInterface({
-          input: stream,
-          crlfDelay: Infinity,
-        });
+        const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
         rl.on('line', (line) => {
           const msg = `[${timestamp()}] [${name}] ${line}\n`;
-          try {
-            fs.writeSync(logFd, msg);
-          } catch {}
+          try { fs.writeSync(logFd, msg); } catch {}
           writeOutput(msg);
         });
       };
@@ -191,11 +164,7 @@ function startProcess({ name, command, args, cleanupPort }) {
       if (cleanupPort) {
         const orphans = killOrphansByPort(cleanupPort);
         if (orphans.length > 0) {
-          logEvent(
-            'WARN',
-            name,
-            `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`,
-          );
+          logEvent('WARN', name, `Killed orphan processes on port ${cleanupPort}: ${orphans.join(' ')}`);
           await sleep(500);
         }
       }
@@ -205,38 +174,21 @@ function startProcess({ name, command, args, cleanupPort }) {
       const runDuration = (Date.now() - startTime) / 1000;
       if (runDuration >= 60) {
         restartCount = 0;
-        logEvent(
-          'INFO',
-          name,
-          `Ran for ${Math.round(runDuration)}s, resetting restart counter`,
-        );
+        logEvent('INFO', name, `Ran for ${Math.round(runDuration)}s, resetting restart counter`);
       } else {
         restartCount++;
       }
       if (restartCount >= MAX_RESTART_COUNT) {
-        logEvent(
-          'ERROR',
-          name,
-          `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`,
-        );
+        logEvent('ERROR', name, `Max restart count (${MAX_RESTART_COUNT}) reached, giving up`);
         break;
       }
 
-      const delay = Math.min(
-        RESTART_DELAY * (1 << Math.max(0, restartCount - 1)),
-        MAX_DELAY,
-      );
-      logEvent(
-        'WARN',
-        name,
-        `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`,
-      );
+      const delay = Math.min(RESTART_DELAY * (1 << Math.max(0, restartCount - 1)), MAX_DELAY);
+      logEvent('WARN', name, `Process exited with code ${exitCode}, restarting (${restartCount}/${MAX_RESTART_COUNT}) in ${delay}s...`);
       await sleep(delay * 1000);
     }
 
-    try {
-      fs.closeSync(logFd);
-    } catch {}
+    try { fs.closeSync(logFd); } catch {}
   };
 
   return run();
@@ -266,11 +218,7 @@ async function cleanup() {
   // Force kill any remaining
   for (const entry of managedProcesses) {
     if (entry.pid) {
-      logEvent(
-        'WARN',
-        'main',
-        `Force killing process group (PGID: ${entry.pid})`,
-      );
+      logEvent('WARN', 'main', `Force killing process group (PGID: ${entry.pid})`);
       killProcessGroup(entry.pid, 'SIGKILL');
     }
   }
@@ -281,12 +229,8 @@ async function cleanup() {
 
   logEvent('INFO', 'main', 'All processes stopped');
 
-  try {
-    fs.closeSync(devStdLogFd);
-  } catch {}
-  try {
-    fs.closeSync(devLogFd);
-  } catch {}
+  try { fs.closeSync(devStdLogFd); } catch {}
+  try { fs.closeSync(devLogFd); } catch {}
 
   process.exit(0);
 }
@@ -313,22 +257,17 @@ async function main() {
   // Initialize action plugins
   writeOutput('\n🔌 Initializing action plugins...\n');
   try {
-    execSync('fullstack-cli action-plugin init', {
-      cwd: PROJECT_ROOT,
-      stdio: 'inherit',
-    });
+    execSync('fullstack-cli action-plugin init', { cwd: PROJECT_ROOT, stdio: 'inherit' });
     writeOutput('✅ Action plugins initialized\n\n');
   } catch {
-    writeOutput(
-      '⚠️  Action plugin initialization failed, continuing anyway...\n\n',
-    );
+    writeOutput('⚠️  Action plugin initialization failed, continuing anyway...\n\n');
   }
 
   // Start server and client
   const serverPromise = startProcess({
     name: 'server',
     command: 'npm',
-    args: buildNestServerArgs({ projectRoot: PROJECT_ROOT, env: process.env }),
+    args: ['run', 'dev:server'],
     cleanupPort: SERVER_PORT,
   });
 

package/template/scripts/nest-type-check.cjs

@@ -2,25 +2,26 @@
 
 const fs = require('fs');
 const path = require('path');
+const { spawn } = require('child_process');
 
 const TYPE_CHECK_ENV = 'MIAODA_NEST_TYPE_CHECK_ENABLED';
 const DISABLED_CONFIG_RELATIVE_PATH = 'logs/nest-cli.type-check-disabled.json';
 
 /**
- * Build the npm arguments used to launch Nest in development.
+ * Build the Nest CLI arguments used to launch the development server.
  *
  * Missing or malformed values deliberately preserve the project's existing
  * nest-cli.json behavior.  The platform injects an exact true/false value;
  * exact true forces the checker on, while exact false writes a narrow runtime
  * config override so the checked-in project config is never mutated.
  */
-function buildNestServerArgs({ projectRoot, env = process.env }) {
+function buildNestCliArgs({ projectRoot, env = process.env }) {
   const enabled = env[TYPE_CHECK_ENV];
   if (enabled === 'true') {
-    return ['run', 'dev:server', '--', '--type-check'];
+    return ['start', '--watch', '--type-check'];
   }
   if (enabled !== 'false') {
-    return ['run', 'dev:server'];
+    return ['start', '--watch'];
   }
 
   const sourcePath = path.join(projectRoot, 'nest-cli.json');
@@ -47,7 +48,38 @@ function buildNestServerArgs({ projectRoot, env = process.env }) {
   );
   fs.renameSync(temporaryPath, runtimePath);
 
-  return ['run', 'dev:server', '--', '--config', DISABLED_CONFIG_RELATIVE_PATH];
+  return ['start', '--watch', '--config', DISABLED_CONFIG_RELATIVE_PATH];
 }
 
-module.exports = { buildNestServerArgs };
+function runNestServer({ projectRoot = path.resolve(__dirname, '..'), env = process.env } = {}) {
+  const executable = path.join(
+    projectRoot,
+    'node_modules',
+    '.bin',
+    process.platform === 'win32' ? 'nest.cmd' : 'nest',
+  );
+  const child = spawn(executable, buildNestCliArgs({ projectRoot, env }), {
+    cwd: projectRoot,
+    env,
+    stdio: 'inherit',
+  });
+
+  child.once('error', (error) => {
+    console.error(`[nest-type-check] failed to start Nest CLI: ${error.message}`);
+    process.exitCode = 1;
+  });
+  child.once('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal);
+      return;
+    }
+    process.exitCode = code ?? 1;
+  });
+  return child;
+}
+
+if (require.main === module) {
+  runNestServer();
+}
+
+module.exports = { buildNestCliArgs, runNestServer };