Enhance watch command

README.md

@@ -5,8 +5,9 @@
 [![Github Star](https://img.shields.io/github/stars/imjuni/fast-maker.svg?style=flat-square)](https://github.com/imjuni/fast-maker)
 [![Github Issues](https://img.shields.io/github/issues-raw/imjuni/fast-maker.svg?style=flat-square)](https://github.com/imjuni/fast-maker/issues)
 [![NPM version](https://img.shields.io/npm/v/fast-maker.svg?style=flat-square)](https://www.npmjs.com/package/fast-maker)
-[![License](https://img.shields.io/npm/l/fast-maker.svg)](https://github.com/imjuni/fast-maker/blob/master/LICENSE?style=flat-square)
-[![fast-maker](https://circleci.com/gh/imjuni/fast-maker.svg??style=flat-square)](https://app.circleci.com/pipelines/github/imjuni/fast-maker?branch=master)
+[![License](https://img.shields.io/npm/l/fast-maker.svg?style=flat-square)](https://github.com/imjuni/fast-maker/blob/master/LICENSE)
+[![ci](https://github.com/imjuni/fast-maker/actions/workflows/ci.yml/badge.svg?branch=master&style=flat-square)](https://github.com/imjuni/fast-maker/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/imjuni/fast-maker/branch/master/graph/badge.svg?token=YrUlnfDbso&style=flat-square)](https://codecov.io/gh/imjuni/fast-maker)
 [![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
 
 fast-maker is micro utility for [fastify.js](https://www.fastify.io/) over 3.x. fast-maker inspired by codeigniter(in PHP) and Next.js directory structure based route system. fast-maker auto generate route.ts file using directory structure futhermore include type declaration that inheritance RequestGenericInterface. This method have varity benefits.

src/cli.ts

@@ -3,7 +3,8 @@ import routeBuilder from '#cli/builder/routeBuilder';
 import watchBuilder from '#cli/builder/watchBuilder';
 import routeCommandClusterHandler from '#cli/command/routeCommandClusterHandler';
 import routeCommandSyncHandler from '#cli/command/routeCommandSyncHandler';
-import watchCommandHandler from '#cli/command/watchCommandHandler';
+import watchCommandClusterHandler from '#cli/command/watchCommandClusterHandler';
+import watchCommandSyncHandler from '#cli/command/watchCommandSyncHandler';
 import progress from '#cli/display/progress';
 import spinner from '#cli/display/spinner';
 import { CE_COMMAND_LIST } from '#cli/interfaces/CE_COMMAND_LIST';
@@ -48,7 +49,14 @@ const watchCmd: CommandModule<TWatchOption, TWatchOption> = {
   builder: (argv) => watchBuilder(builder(argv)),
   handler: async (argv) => {
     try {
-      await watchCommandHandler(argv);
+      progress.isEnable = true;
+      spinner.isEnable = true;
+
+      if (process.env.SYNC_MODE === 'true') {
+        await watchCommandSyncHandler(argv);
+      } else {
+        await watchCommandClusterHandler(argv);
+      }
     } catch (caught) {
       const err = isError(caught, new Error('unknown error raised'));
       log.error(err);

src/cli/command/routeCommandClusterHandler.ts

@@ -25,6 +25,7 @@ import { CE_WORKER_ACTION } from '#workers/interfaces/CE_WORKER_ACTION';
 import type TSendMasterToWorkerMessage from '#workers/interfaces/TSendMasterToWorkerMessage';
 import {
   isFailTaskComplete,
+  isPassTaskComplete,
   type TPickPassWorkerToMasterTaskComplete,
 } from '#workers/interfaces/TSendWorkerToMasterMessage';
 import workers from '#workers/workers';
@@ -46,8 +47,7 @@ export default async function routeCommandClusterHandler(baseOption: TRouteBaseO
       });
     } else {
       spinner.start('Fast Maker start');
-      spinner.update('Fast Maker start', 'info');
-      spinner.stop();
+      spinner.stop('Fast Maker start', 'info');
     }
 
     const resolvedPaths = getResolvedPaths(baseOption);
@@ -93,15 +93,15 @@ export default async function routeCommandClusterHandler(baseOption: TRouteBaseO
 
     reply = await workers.wait();
 
-    spinner.start('handler file searching');
-
     // master check project diagostic on worker
     if (reply.data.some((workerReply) => workerReply.result === 'fail')) {
       const failReplies = reply.data.filter(isFailTaskComplete);
       const failReply = atOrThrow(failReplies, 0);
       throw new FastMakerError(failReply.error);
     }
 
+    spinner.start('handler file searching');
+
     workers.broadcast({
       command: CE_WORKER_ACTION.SUMMARY_ROUTE_HANDLER_FILE,
     } satisfies Extract<TSendMasterToWorkerMessage, { command: typeof CE_WORKER_ACTION.SUMMARY_ROUTE_HANDLER_FILE }>);
@@ -135,8 +135,13 @@ export default async function routeCommandClusterHandler(baseOption: TRouteBaseO
     >;
 
     const handlers = Object.values(validation.valid).flat();
+    const count = Object.values(validation.valid).reduce((sum, validHandlers) => sum + validHandlers.length, 0);
+
+    spinner.stop(`handler file searched: ${chalk.cyanBright(count)}`, 'succeed');
 
-    spinner.stop(`handler file searched: ${chalk.cyanBright(handlers.length)}`, 'succeed');
+    if (count <= 0) {
+      throw new Error(`Cannot found valid route handler file: ${count}/ ${Object.values(handlerFiles).flat().length}`);
+    }
 
     const job = createAnalysisRequestStatementBulkCommand(workerSize, handlers);
 
@@ -157,7 +162,7 @@ export default async function routeCommandClusterHandler(baseOption: TRouteBaseO
 
     spinner.start(`${chalk.greenBright('route.ts')} code generating`);
 
-    const data = reply.data as TPickPassWorkerToMasterTaskComplete<
+    const data = reply.data.filter(isPassTaskComplete) as TPickPassWorkerToMasterTaskComplete<
       typeof CE_WORKER_ACTION.ANALYSIS_REQUEST_STATEMENT
     >[];
 
@@ -182,13 +187,7 @@ export default async function routeCommandClusterHandler(baseOption: TRouteBaseO
         await writeOutputFile(routeMapOutputFilePath, prettfiedRouteMapCode);
       }
 
-      reasons.clear();
-      reasons.add(
-        ...data
-          .map((failReply) => failReply.data.fail)
-          .flat()
-          .map((failReply) => failReply.reason),
-      );
+      reasons.add(...data.map((passReply) => passReply.data.fail.map((reason) => reason.reason)).flat());
     }
 
     spinner.stop('route.ts code generation', 'succeed');

src/cli/command/routeCommandSyncHandler.ts

@@ -4,6 +4,7 @@ import show from '#cli/display/show';
 import spinner from '#cli/display/spinner';
 import getHandlerWithOption from '#compilers/navigate/getHandlerWithOption';
 import getTypeScriptProject from '#compilers/tools/getTypeScriptProject';
+import getDiagnostics from '#compilers/validators/getDiagnostics';
 import getResolvedPaths from '#configs/getResolvedPaths';
 import type { TRouteBaseOption, TRouteOption } from '#configs/interfaces/TRouteOption';
 import importCodeGenerator from '#generators/importCodeGenerator';
@@ -22,23 +23,38 @@ import writeOutputFile from '#modules/writeOutputFile';
 import sortRoutePaths from '#routes/sortRoutePaths';
 import getReasonMessages from '#tools/getReasonMessages';
 import logger from '#tools/logger';
+import { showLogo } from '@maeum/cli-logo';
+import chalk from 'chalk';
 import { isDescendant } from 'my-node-fp';
 
 const log = logger();
 
 export default async function routeCommandSyncHandler(baseOption: TRouteBaseOption) {
+  if (baseOption.cliLogo) {
+    await showLogo({
+      message: 'Fast Maker',
+      figlet: { font: 'ANSI Shadow', width: 80 },
+      color: 'cyan',
+    });
+  } else {
+    spinner.start('Fast Maker start');
+    spinner.stop('Fast Maker start', 'info');
+  }
+
   const resolvedPaths = getResolvedPaths(baseOption);
-  const option: TRouteOption = { ...baseOption, ...resolvedPaths };
+  const option: TRouteOption = { ...baseOption, ...resolvedPaths, kind: 'route' };
 
-  spinner.update(`load tsconfig.json: ${option.project}`);
+  spinner.start(`load tsconfig.json: ${option.project}`);
 
-  const project = await new Promise<ReturnType<typeof getTypeScriptProject>>((resolve) => {
-    setImmediate(() => resolve(getTypeScriptProject(option.project)));
-  });
+  const project = getTypeScriptProject(option.project);
 
   spinner.update(`load tsconfig.json: ${option.project}`, 'succeed');
 
-  spinner.update('find handler files');
+  if (option.skipError === false && getDiagnostics({ option, project }) === false) {
+    throw new Error(`Error occur project compile: ${option.project}`);
+  }
+
+  spinner.start('find handler files');
 
   const sourceFilePaths = project
     .getSourceFiles()
@@ -51,19 +67,17 @@ export default async function routeCommandSyncHandler(baseOption: TRouteBaseOpti
   log.debug(`count: ${sourceFilePaths.length}`);
 
   const handlerMap = await summaryRouteHandlerFiles(sourceFilePaths, option);
-
-  spinner.update('find handler files', 'succeed');
-
   const validationMap = getValidRoutePath(handlerMap);
-
-  spinner.stop();
-
   const count = Object.values(validationMap.valid).reduce((sum, handlers) => sum + handlers.length, 0);
 
   log.debug(`count: ${count}`);
 
+  spinner.stop(`handler file searched: ${chalk.cyanBright(count)}`, 'succeed');
+
   if (count <= 0) {
-    return false;
+    throw new Error(
+      `Cannot found valid route handler file: ${count}/ ${Object.values(handlerMap.summary).flat().length}`,
+    );
   }
 
   progress.start(count, 0);

src/cli/command/watchCommandClusterHandler.ts

@@ -0,0 +1,106 @@
+import spinner from '#cli/display/spinner';
+import getResolvedPaths from '#configs/getResolvedPaths';
+import type { TWatchOption } from '#configs/interfaces/TWatchOption';
+import FastMakerError from '#errors/FastMakerError';
+import errorTrace from '#modules/errorTrace';
+import getWatchFiles from '#modules/getWatchFiles';
+import type IWatchEvent from '#modules/interfaces/IWatchEvent';
+import WatcherClusterModule from '#modules/WatcherClusterModule';
+import { CE_WORKER_ACTION } from '#workers/interfaces/CE_WORKER_ACTION';
+import type TSendMasterToWorkerMessage from '#workers/interfaces/TSendMasterToWorkerMessage';
+import { isFailTaskComplete } from '#workers/interfaces/TSendWorkerToMasterMessage';
+import workers from '#workers/workers';
+import { showLogo } from '@maeum/cli-logo';
+import chokidar from 'chokidar';
+import { atOrThrow, populate } from 'my-easy-fp';
+import cluster from 'node:cluster';
+import os from 'node:os';
+import { buffer, debounceTime, Subject } from 'rxjs';
+
+export default async function watchCommandClusterHandler(baseOption: TWatchOption) {
+  if (baseOption.cliLogo) {
+    await showLogo({
+      message: 'Fast Maker',
+      figlet: { font: 'ANSI Shadow', width: 80 },
+      color: 'cyan',
+    });
+  } else {
+    spinner.start('Fast Maker start');
+    spinner.stop('Fast Maker start', 'info');
+  }
+
+  const resolvedPaths = getResolvedPaths(baseOption);
+  const option: TWatchOption = { ...baseOption, ...resolvedPaths, kind: 'watch' };
+  const watchFiles = await getWatchFiles(option);
+
+  const workerSize = baseOption.maxWorkers ?? os.cpus().length - 1;
+  populate(workerSize).forEach(() => workers.add(cluster.fork()));
+
+  spinner.start(`TypeScript project loading: ${resolvedPaths.project}`);
+
+  workers.broadcast({
+    command: CE_WORKER_ACTION.OPTION_LOAD,
+    data: { option },
+  } satisfies Extract<TSendMasterToWorkerMessage, { command: typeof CE_WORKER_ACTION.OPTION_LOAD }>);
+
+  await workers.wait();
+
+  workers.broadcast({
+    command: CE_WORKER_ACTION.PROJECT_LOAD,
+  } satisfies Extract<TSendMasterToWorkerMessage, { command: typeof CE_WORKER_ACTION.PROJECT_LOAD }>);
+
+  let reply = await workers.wait(option.workerTimeout);
+
+  await workers.wait();
+
+  // master check project loading on worker
+  if (reply.data.some((workerReply) => workerReply.result === 'fail')) {
+    const failReplies = reply.data.filter(isFailTaskComplete);
+    const failReply = atOrThrow(failReplies, 0);
+    throw new FastMakerError(failReply.error);
+  }
+
+  workers.send({
+    command: CE_WORKER_ACTION.PROJECT_DIAGONOSTIC,
+  } satisfies Extract<TSendMasterToWorkerMessage, { command: typeof CE_WORKER_ACTION.PROJECT_DIAGONOSTIC }>);
+
+  reply = await workers.wait();
+
+  // master check project diagostic on worker
+  if (reply.data.some((workerReply) => workerReply.result === 'fail')) {
+    const failReplies = reply.data.filter(isFailTaskComplete);
+    const failReply = atOrThrow(failReplies, 0);
+    throw new FastMakerError(failReply.error);
+  }
+
+  spinner.stop(`TypeScript project loaded: ${resolvedPaths.project}`, 'succeed');
+
+  const wm = new WatcherClusterModule({ option, workerSize });
+
+  const watchHandle = chokidar.watch(watchFiles, { cwd: option.cwd, ignoreInitial: true });
+
+  const addSubject = new Subject<IWatchEvent>();
+  const changeSubject = new Subject<IWatchEvent>();
+  const unlinkSubject = new Subject<IWatchEvent>();
+  const updateSubject = new Subject<IWatchEvent>();
+
+  const debounceObserable = updateSubject.pipe(debounceTime(1000));
+
+  const handler = async (events: IWatchEvent[]) => {
+    const statements = await wm.bulk(events);
+    await wm.write(statements);
+  };
+
+  updateSubject.pipe(buffer(debounceObserable)).subscribe((events) => {
+    handler(events).catch(errorTrace);
+  });
+
+  addSubject.subscribe((change) => updateSubject.next(change));
+  changeSubject.subscribe((change) => updateSubject.next(change));
+  unlinkSubject.subscribe((change) => updateSubject.next(change));
+
+  watchHandle
+    .on('add', (filePath) => addSubject.next({ kind: 'add', filePath }))
+    .on('change', (filePath) => changeSubject.next({ kind: 'change', filePath }))
+    .on('unlink', (filePath) => unlinkSubject.next({ kind: 'unlink', filePath }));
+}

src/cli/command/watchCommandSyncHandler.ts

@@ -0,0 +1,68 @@
+import spinner from '#cli/display/spinner';
+import getTypeScriptProject from '#compilers/tools/getTypeScriptProject';
+import getDiagnostics from '#compilers/validators/getDiagnostics';
+import getResolvedPaths from '#configs/getResolvedPaths';
+import type { TWatchBaseOption, TWatchOption } from '#configs/interfaces/TWatchOption';
+import errorTrace from '#modules/errorTrace';
+import getWatchFiles from '#modules/getWatchFiles';
+import type IWatchEvent from '#modules/interfaces/IWatchEvent';
+import WatcherModule from '#modules/WatcherModule';
+import { showLogo } from '@maeum/cli-logo';
+import chokidar from 'chokidar';
+import { buffer, debounceTime, Subject } from 'rxjs';
+
+export default async function watchCommandSyncHandler(baseOption: TWatchBaseOption) {
+  if (baseOption.cliLogo) {
+    await showLogo({
+      message: 'Fast Maker',
+      figlet: { font: 'ANSI Shadow', width: 80 },
+      color: 'cyan',
+    });
+  } else {
+    spinner.start('Fast Maker start');
+    spinner.stop('Fast Maker start', 'info');
+  }
+
+  const resolvedPaths = getResolvedPaths(baseOption);
+  const option: TWatchOption = { ...baseOption, ...resolvedPaths, kind: 'watch' };
+  const watchFiles = await getWatchFiles(option);
+
+  spinner.start(`load tsconfig.json: ${option.project}`);
+
+  const project = getTypeScriptProject(option.project);
+
+  spinner.update(`load tsconfig.json: ${option.project}`, 'succeed');
+
+  if (option.skipError === false && getDiagnostics({ option, project }) === false) {
+    throw new Error(`Error occur project compile: ${option.project}`);
+  }
+
+  const wm = new WatcherModule({ project, option });
+
+  const watchHandle = chokidar.watch(watchFiles, { cwd: option.cwd, ignoreInitial: true });
+
+  const addSubject = new Subject<IWatchEvent>();
+  const changeSubject = new Subject<IWatchEvent>();
+  const unlinkSubject = new Subject<IWatchEvent>();
+  const updateSubject = new Subject<IWatchEvent>();
+
+  const debounceObserable = updateSubject.pipe(debounceTime(1000));
+
+  updateSubject.pipe(buffer(debounceObserable)).subscribe((events) => {
+    const handler = async () => {
+      const statements = await wm.bulk(events);
+      await wm.write(statements);
+    };
+
+    handler().catch(errorTrace);
+  });
+
+  addSubject.subscribe((change) => updateSubject.next(change));
+  changeSubject.subscribe((change) => updateSubject.next(change));
+  unlinkSubject.subscribe((change) => updateSubject.next(change));
+
+  watchHandle
+    .on('add', (filePath) => addSubject.next({ kind: 'add', filePath }))
+    .on('change', (filePath) => changeSubject.next({ kind: 'change', filePath }))
+    .on('unlink', (filePath) => unlinkSubject.next({ kind: 'unlink', filePath }));
+}

src/configs/interfaces/IBaseOption.ts

@@ -26,6 +26,12 @@ export default interface IBaseOption {
   /** create route-map source file */
   routeMap: boolean;
 
+  /** max worker count */
+  maxWorkers?: number;
+
+  /** route code generation worker timeout: default 90 seconds */
+  workerTimeout: number;
+
   /**
    * route function in output file that use default export
    * @default true

src/configs/interfaces/TRouteOption.ts

@@ -3,12 +3,6 @@ import type IResolvedPaths from '#configs/interfaces/IResolvedPaths';
 
 export interface IRouteOption {
   kind: 'route';
-
-  /** max worker count */
-  maxWorkers?: number;
-
-  /** route code generation worker timeout: default 90 seconds */
-  workerTimeout: number;
 }
 
 export type TRouteBaseOption = IBaseOption & IRouteOption;