@mainset/cli 0.1.1 → 0.2.0-rc.2

package/dist/esm/commands/node-package.mjs

@@ -2,7 +2,7 @@ import fs from 'fs';
 import path from 'path';
 import { runtimePathById } from '../runtime/index.mjs';
 import { consoleColorize, initProcessCatchErrorLogger, } from '../utils/index.mjs';
-import { execPurgeDist, execRslibCLICommand, execTypeScriptCompileTypeOnly, runRslibCLICommand, runTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
+import { execImmediatePurgeDist, execImmediateRslibCLICommand, execImmediateTypeScriptCompileTypeOnly, runStreamingRslibCLICommand, runStreamingTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
 function registerNodePackageCommand(program) {
     program
         .command('node-package')
@@ -23,12 +23,12 @@ function registerNodePackageCommand(program) {
             console.log('\n🏗️  [mainset cli] node-package: build');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: build source code
                 console.log('\n📦 Compiling Source Code with Rslib ...');
-                execRslibCLICommand(`build --config ${rslibConfigPath}`);
+                execImmediateRslibCLICommand(`build --config ${rslibConfigPath}`);
                 // Step 3: build type only
-                execTypeScriptCompileTypeOnly();
+                execImmediateTypeScriptCompileTypeOnly();
                 console.log('\n✅ Build completed successfully\n');
             }
             catch (error) {
@@ -40,11 +40,16 @@ function registerNodePackageCommand(program) {
             console.log('\n🏗️  [mainset cli] node-package: watch');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: watch source code
-                runRslibCLICommand(['build', '--config', rslibConfigPath, '--watch']);
+                runStreamingRslibCLICommand([
+                    'build',
+                    '--config',
+                    rslibConfigPath,
+                    '--watch',
+                ]);
                 // Step 3: watch type only
-                runTypeScriptCompileTypeOnly();
+                runStreamingTypeScriptCompileTypeOnly();
             }
             catch (error) {
                 initProcessCatchErrorLogger('node-package', error, 'watch');

package/dist/esm/commands/process-runner-chunks/rslib.chunk.mjs

@@ -4,12 +4,12 @@ function getRslibCLICommandPath() {
     const rslibCLICommandPath = resolveHostPackageBinForCLICommandPath('@mainset/builder-rslib', 'rslib');
     return rslibCLICommandPath;
 }
-function execRslibCLICommand(command) {
+function execImmediateRslibCLICommand(command) {
     const rslibCLICommandPath = getRslibCLICommandPath();
     return execImmediateCommand(`${rslibCLICommandPath} ${command}`);
 }
-function runRslibCLICommand(commandParams) {
+function runStreamingRslibCLICommand(commandParams) {
     const rslibCLICommandPath = getRslibCLICommandPath();
     return runStreamingCommand(rslibCLICommandPath, [...commandParams]);
 }
-export { execRslibCLICommand, runRslibCLICommand };
+export { execImmediateRslibCLICommand, runStreamingRslibCLICommand };

package/dist/esm/commands/process-runner-chunks/system.chunk.mjs

@@ -1,8 +1,8 @@
 import { runtimePathById } from '../../runtime/index.mjs';
 import { execImmediateCommand } from '../../utils/index.mjs';
 // Cleanup
-function execPurgeDist() {
+function execImmediatePurgeDist() {
     console.log('🧹 Cleaning dist folder ...');
     execImmediateCommand(`rm -rf ${runtimePathById.dist}`);
 }
-export { execPurgeDist };
+export { execImmediatePurgeDist };

package/dist/esm/commands/process-runner-chunks/typescript.chunk.mjs

@@ -6,12 +6,12 @@ function getTscCLICommandPath() {
     return tscCLICommandPath;
 }
 // Source code
-function execTypeScriptCompileSourceCode({ configPath, }) {
+function execImmediateTypeScriptCompileSourceCode({ configPath, }) {
     const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📦 Compiling Source Code with TypeScript ...');
     execImmediateCommand(`${tscCLICommandPath} --project ${configPath}`);
 }
-function runTypeScriptCompileSourceCode({ configPath, }) {
+function runStreamingTypeScriptCompileSourceCode({ configPath, }) {
     const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📝 Compiling .d.ts Types in watch mode ...');
     runStreamingCommand(tscCLICommandPath, ['--project', configPath, '--watch']);
@@ -23,16 +23,16 @@ function getTypeScriptTypeOnlyConfigPath() {
         configPath: customTypeScriptTypeOnlyConfigPath,
     };
 }
-function execTypeScriptCompileTypeOnly() {
+function execImmediateTypeScriptCompileTypeOnly() {
     const { configPath } = getTypeScriptTypeOnlyConfigPath();
     const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📝 Compiling .d.ts Types in build mode ...');
     execImmediateCommand(`${tscCLICommandPath} --project ${configPath}`);
 }
-function runTypeScriptCompileTypeOnly() {
+function runStreamingTypeScriptCompileTypeOnly() {
     const { configPath } = getTypeScriptTypeOnlyConfigPath();
     const tscCLICommandPath = getTscCLICommandPath();
     console.log('\n📝 Compiling .d.ts Types in watch mode ...');
     runStreamingCommand(tscCLICommandPath, ['--project', configPath, '--watch']);
 }
-export { execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, };
+export { execImmediateTypeScriptCompileSourceCode, execImmediateTypeScriptCompileTypeOnly, runStreamingTypeScriptCompileSourceCode, runStreamingTypeScriptCompileTypeOnly, };

package/dist/esm/commands/source-code.mjs

@@ -1,7 +1,7 @@
 import path from 'path';
 import { runtimePathById } from '../runtime/index.mjs';
 import { consoleColorize, initProcessCatchErrorLogger, } from '../utils/index.mjs';
-import { execPurgeDist, execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
+import { execImmediatePurgeDist, execImmediateTypeScriptCompileSourceCode, execImmediateTypeScriptCompileTypeOnly, runStreamingTypeScriptCompileSourceCode, runStreamingTypeScriptCompileTypeOnly, } from './process-runner-chunks/index.mjs';
 function registerSourceCodeCommand(program) {
     program
         .command('source-code')
@@ -17,13 +17,13 @@ function registerSourceCodeCommand(program) {
             console.log('\n🏗️  [mainset cli] source-code: compile');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: compile source code
-                execTypeScriptCompileSourceCode({
+                execImmediateTypeScriptCompileSourceCode({
                     configPath: typeScriptSourceCodeConfigPath,
                 });
                 // Step 3: compile type only
-                execTypeScriptCompileTypeOnly();
+                execImmediateTypeScriptCompileTypeOnly();
                 console.log('\n✅ Build completed successfully\n');
             }
             catch (error) {
@@ -35,13 +35,13 @@ function registerSourceCodeCommand(program) {
             console.log('\n🏗️  [mainset cli] source-code: watch');
             try {
                 // Step 1: purge dist folder
-                execPurgeDist();
+                execImmediatePurgeDist();
                 // Step 2: watch source code
-                runTypeScriptCompileSourceCode({
+                runStreamingTypeScriptCompileSourceCode({
                     configPath: typeScriptSourceCodeConfigPath,
                 });
                 // Step 3: watch type only
-                runTypeScriptCompileTypeOnly();
+                runStreamingTypeScriptCompileTypeOnly();
             }
             catch (error) {
                 initProcessCatchErrorLogger('source-code', error, 'watch');

package/dist/esm/commands/web-app.mjs

@@ -1,8 +1,8 @@
 import fs from 'fs';
 import path from 'path';
 import { resolveHostPackageBinForCLICommandPath, runtimePathById, } from '../runtime/index.mjs';
-import { consoleColorize, execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, } from '../utils/index.mjs';
-import { execPurgeDist, execRslibCLICommand, runRslibCLICommand, } from './process-runner-chunks/index.mjs';
+import { consoleColorize, execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, runStreamingInSync, } from '../utils/index.mjs';
+import { execImmediatePurgeDist } from './process-runner-chunks/index.mjs';
 function registerWebAppCommand(program) {
     program
         .command('web-app')
@@ -18,12 +18,22 @@ function registerWebAppCommand(program) {
         .action((options) => {
         // Step 0: determinate command params
         const customWebpackConfigPath = path.resolve(runtimePathById.root, options.config || './config/webpack.config.mjs');
+        // SSR server path
+        const ssrServerEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/ssr-server/ssr-server.mjs');
+        const ssrServerConfigCompiledPath = path.resolve(runtimePathById.dist, './private/ssr-server.config.mjs');
         // Webpack paths
         const webpackCLICommandPath = resolveHostPackageBinForCLICommandPath('@mainset/bundler-webpack', 'webpack');
         const webpackSSRConfigPath = fs.existsSync(customWebpackConfigPath)
             ? customWebpackConfigPath
             : path.resolve(runtimePathById.root, 'node_modules', '@mainset/bundler-webpack/dist/esm/webpack-config/webapp.ssr.config.mjs');
-        const rslibSSRConfigPath = path.resolve(runtimePathById.root, 'node_modules', '@mainset/builder-rslib/dist/esm/rslib.ssr-server.config.mjs');
+        /*
+        // Rslib paths
+        const rslibSSRConfigPath = path.resolve(
+          runtimePathById.root,
+          'node_modules',
+          '@mainset/builder-rslib/dist/esm/rslib.ssr-server.config.mjs',
+        );
+        */
         if (options.exec === 'build') {
             // ========== Build mode ==========
             console.log('\n🏗️  [mainset cli] web-app: build');
@@ -31,13 +41,15 @@ function registerWebAppCommand(program) {
                 if (options.serveMode === 'ssr') {
                     // ========== [Build] SSR mode ==========
                     // Step 1: purge dist folder
-                    execPurgeDist();
+                    execImmediatePurgeDist();
                     // Step 2: build:ssr-webapp source code
                     console.log('\n📦 Compiling SSR WebApp with Webpack ...');
                     execImmediateCommand(`${webpackCLICommandPath} --config ${webpackSSRConfigPath}`);
+                    /*
                     // Step 3: build:ssr-server source code
                     console.log('\n📦 Compiling SSR Server with Rslib ...');
-                    execRslibCLICommand(`build --config ${rslibSSRConfigPath}`);
+                    execImmediateRslibCLICommand(`build --config ${rslibSSRConfigPath}`);
+                    */
                     console.log('\n✅ SSR Build completed successfully\n');
                 }
                 else {
@@ -46,7 +58,7 @@ function registerWebAppCommand(program) {
                         ? customWebpackConfigPath
                         : path.resolve(runtimePathById.root, 'node_modules', '@mainset/bundler-webpack/dist/esm/webpack-config/webapp.csr.config.mjs');
                     // Step 1: purge dist folder
-                    execPurgeDist();
+                    execImmediatePurgeDist();
                     // Step 2: build:csr-webapp source code
                     console.log('\n📦 Compiling CSR WebApp with Webpack ...');
                     execImmediateCommand(`${webpackCLICommandPath} --config ${webpackCSRConfigPath}`);
@@ -63,27 +75,35 @@ function registerWebAppCommand(program) {
             try {
                 if (options.serveMode === 'ssr') {
                     // ========== [Serve] SSR mode ==========
-                    const ssrServerEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/ssr-server/ssr-server.mjs');
-                    const ssrServerConfigCompiledPath = path.resolve(runtimePathById.dist, './private/ssr-server.config.mjs');
+                    /*
                     // Step 1: watch:ssr-server start ssr server
-                    runRslibCLICommand([
-                        'build',
-                        '--config',
-                        rslibSSRConfigPath,
-                        '--watch',
+                    runStreamingRslibCLICommand([
+                      'build',
+                      '--config',
+                      rslibSSRConfigPath,
+                      '--watch',
                     ]);
-                    // Step 2: watch:ssr-webapp source code of web app
-                    runStreamingCommand(webpackCLICommandPath, [
-                        '--config',
-                        webpackSSRConfigPath,
-                        '--watch',
-                    ]);
-                    // Step 3: start:ssr-server which is compiled web app and ssr-server code
-                    runStreamingCommand('node', [
-                        '--watch', // Enable watch mode for {node}
-                        ssrServerEntryPath,
-                        '--ssrServerConfig',
-                        ssrServerConfigCompiledPath,
+                    */
+                    // NOTE: node SSR server requires webpack to compile web app files first
+                    runStreamingInSync([
+                        // Step 2: watch:ssr-webapp source code of web app
+                        {
+                            runCommand: () => runStreamingCommand(webpackCLICommandPath, [
+                                '--config',
+                                webpackSSRConfigPath,
+                                '--watch',
+                            ]),
+                            waitForOutput: 'compiled successfully',
+                        },
+                        // Step 3: start:ssr-server which is compiled web app and ssr-server code
+                        {
+                            runCommand: () => runStreamingCommand('node', [
+                                '--watch', // Enable watch mode for {node}
+                                ssrServerEntryPath,
+                                '--ssrServerConfig',
+                                ssrServerConfigCompiledPath,
+                            ]),
+                        },
                     ]);
                 }
                 else {
@@ -108,18 +128,31 @@ function registerWebAppCommand(program) {
             // ========== Serve static mode ==========
             console.log('\n🏗️  [mainset cli] web-app: serve-static');
             try {
-                // Step 1: determinate command params
-                const serverEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/serve-static/serve-static.mjs');
-                const customServeStaticConfigPath = path.resolve(runtimePathById.root, options.config || './config/serve-static.config.json');
-                const serveStaticConfigPath = fs.existsSync(customServeStaticConfigPath)
-                    ? customServeStaticConfigPath
-                    : path.resolve(runtimePathById.msCLISrc, '../services/express-base-app/express-base-app.config.json');
-                // Step 2: serve static compiled files
-                runStreamingCommand('node', [
-                    serverEntryPath,
-                    '--serveStaticConfig',
-                    serveStaticConfigPath,
-                ]);
+                if (options.serveMode === 'ssr') {
+                    // ========== [Serve Static] SSR mode ==========
+                    // Step 1: start:ssr-server which is compiled web app and ssr-server code
+                    runStreamingCommand('node', [
+                        '--watch', // Enable watch mode for {node}
+                        ssrServerEntryPath,
+                        '--ssrServerConfig',
+                        ssrServerConfigCompiledPath,
+                    ]);
+                }
+                else {
+                    // ========== [Serve Static] CSR mode ==========
+                    // Step 1: determinate command params
+                    const serverEntryPath = path.resolve(runtimePathById.msCLISrc, '../services/serve-static/serve-static.mjs');
+                    const customServeStaticConfigPath = path.resolve(runtimePathById.root, options.config || './config/serve-static.config.json');
+                    const serveStaticConfigPath = fs.existsSync(customServeStaticConfigPath)
+                        ? customServeStaticConfigPath
+                        : path.resolve(runtimePathById.msCLISrc, '../services/express-base-app/express-base-app.config.json');
+                    // Step 2: serve static compiled files
+                    runStreamingCommand('node', [
+                        serverEntryPath,
+                        '--serveStaticConfig',
+                        serveStaticConfigPath,
+                    ]);
+                }
             }
             catch (error) {
                 initProcessCatchErrorLogger('web-app', error, 'serve-static');

package/dist/esm/runtime/resolve-host-package.mjs

@@ -1,5 +1,6 @@
 import fs from 'fs';
 import path from 'path';
+import { fileURLToPath } from 'url';
 import { runtimePathById } from './path.mjs';
 function resolveHostPackageNodeModulesPath(hostPackageName, dependencyPackageName) {
     const hostPackageNodeModulesPath = path.resolve(runtimePathById.root, `node_modules/${hostPackageName}/node_modules`);
@@ -9,7 +10,7 @@ function resolveHostPackageNodeModulesPath(hostPackageName, dependencyPackageNam
     // Otherwise, return just the package name (for packages installed from the registry)
     return isNodeModulesLinkedOrWorkspace
         ? hostPackageDependencyPackagePath
-        : dependencyPackageName;
+        : fileURLToPath(import.meta.resolve(dependencyPackageName));
 }
 function resolveHostPackageBinForCLICommandPath(hostPackageName, 
 // dependencyPackageName: string,

package/dist/esm/utils/process-runner/process-runner.mjs

@@ -48,9 +48,45 @@ function runStreamingCommand(command, args) {
         // 2. rm -rf ./node_modules
         processManager.trackProcess(child);
         child.on('exit', (code) => process.exit(code !== null && code !== void 0 ? code : 1));
+        // NOTE: return isn't required, but it uses in combination with {runStreamingInSync} func
+        return child;
     }
     catch (error) {
         initProcessCatchErrorLogger('runStreamingCommand', error);
     }
 }
-export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, };
+/**
+ * Runs a streaming command in sync mode.
+ * This is a placeholder function and does not execute any command.
+ * It is used to maintain compatibility with the existing code structure.
+ *
+ * Example: runStreamingInSync([{ runCommand: () => runStreamingCommand(), waitForOutput: 'compiled successfully' }]);
+ */
+async function runStreamingInSync(streamings) {
+    for (const streaming of streamings) {
+        // eslint-disable-next-line no-await-in-loop
+        await new Promise((resolve, reject) => {
+            const child = streaming.runCommand();
+            if (!child) {
+                reject(new Error('[mainset cli][runStreamingInSync] Previous command failed, aborting sequence.'));
+                return;
+            }
+            if (streaming.waitForOutput && child.stdout) {
+                child.stdout.on('data', (data) => {
+                    const text = data.toString();
+                    if (text.includes(streaming.waitForOutput)) {
+                        resolve();
+                    }
+                });
+            }
+            else {
+                resolve();
+            }
+            child.on('error', reject);
+        }).catch((err) => {
+            // Stop further execution if a command fails
+            throw err;
+        });
+    }
+}
+export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, runStreamingInSync, };

package/dist/types/commands/process-runner-chunks/rslib.chunk.d.mts

@@ -1,3 +1,3 @@
-declare function execRslibCLICommand(command: string): void;
-declare function runRslibCLICommand(commandParams: string[]): void;
-export { execRslibCLICommand, runRslibCLICommand };
+declare function execImmediateRslibCLICommand(command: string): void;
+declare function runStreamingRslibCLICommand(commandParams: string[]): import("child_process").ChildProcess | undefined;
+export { execImmediateRslibCLICommand, runStreamingRslibCLICommand };

package/dist/types/commands/process-runner-chunks/system.chunk.d.mts

@@ -1,2 +1,2 @@
-declare function execPurgeDist(): void;
-export { execPurgeDist };
+declare function execImmediatePurgeDist(): void;
+export { execImmediatePurgeDist };

package/dist/types/commands/process-runner-chunks/typescript.chunk.d.mts

@@ -1,9 +1,9 @@
-declare function execTypeScriptCompileSourceCode({ configPath, }: {
+declare function execImmediateTypeScriptCompileSourceCode({ configPath, }: {
     configPath: string;
 }): void;
-declare function runTypeScriptCompileSourceCode({ configPath, }: {
+declare function runStreamingTypeScriptCompileSourceCode({ configPath, }: {
     configPath: string;
 }): void;
-declare function execTypeScriptCompileTypeOnly(): void;
-declare function runTypeScriptCompileTypeOnly(): void;
-export { execTypeScriptCompileSourceCode, execTypeScriptCompileTypeOnly, runTypeScriptCompileSourceCode, runTypeScriptCompileTypeOnly, };
+declare function execImmediateTypeScriptCompileTypeOnly(): void;
+declare function runStreamingTypeScriptCompileTypeOnly(): void;
+export { execImmediateTypeScriptCompileSourceCode, execImmediateTypeScriptCompileTypeOnly, runStreamingTypeScriptCompileSourceCode, runStreamingTypeScriptCompileTypeOnly, };

package/dist/types/utils/process-runner/process-runner.d.mts

@@ -12,5 +12,16 @@ declare function execImmediateCommand(fullCommandString: string): void;
  *
  * Example: runStreamingCommand('rspack', ['serve', '--config', './config/rspack.config.ts']);
  */
-declare function runStreamingCommand(command: string, args: string[]): void;
-export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, };
+declare function runStreamingCommand(command: string, args: string[]): import("child_process").ChildProcess | undefined;
+/**
+ * Runs a streaming command in sync mode.
+ * This is a placeholder function and does not execute any command.
+ * It is used to maintain compatibility with the existing code structure.
+ *
+ * Example: runStreamingInSync([{ runCommand: () => runStreamingCommand(), waitForOutput: 'compiled successfully' }]);
+ */
+declare function runStreamingInSync(streamings: {
+    runCommand: () => ReturnType<typeof runStreamingCommand>;
+    waitForOutput?: string;
+}[]): Promise<void>;
+export { execImmediateCommand, initProcessCatchErrorLogger, runStreamingCommand, runStreamingInSync, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mainset/cli",
-  "version": "0.1.1",
+  "version": "0.2.0-rc.2",
   "description": "A unified CLI tool for accelerating development, based on mainset vision of front-end infrastructure",
   "homepage": "https://github.com/mainset/dev-stack-fe/tree/main/packages/cli",
   "bugs": {