cabloy 5.1.221 → 5.1.223

package/vona/package.original.json

@@ -27,6 +27,9 @@
     "test": "node ../scripts/runIsolatedTest.ts unit",
     "cov": "node ../scripts/runIsolatedTest.ts unit --coverage",
     "tsc": "npm run prerun && npm run vona :bin:tsc",
+    "tsc:native": "npm run prerun && npm run vona :bin:tsc -- --compiler=native",
+    "tsc:native:force": "npm run prerun && npm run vona :bin:tsc -- --compiler=native --force",
+    "tsc:legacy": "npm run prerun && npm run vona :bin:tsc -- --force",
     "build": "npm run prerun && npm run vona :bin:build -- --flavor=normal",
     "build:docker": "npm run prerun && npm run vona :bin:build -- --flavor=docker",
     "start": "pnpm -C ./dist/normal install && node ./dist/normal/bootstrap.js",

package/vona/packages-cli/cabloy-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabloy/cli",
-  "version": "3.1.29",
+  "version": "3.1.30",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "@cabloy/cli",
   "keywords": [

package/vona/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli",
-  "version": "1.1.167",
+  "version": "1.1.169",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli",
   "keywords": [

package/vona/packages-cli/cli-set-api/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-cli-set-api",
-  "version": "1.1.165",
+  "version": "1.1.167",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona cli-set-api",
   "keywords": [
@@ -63,6 +63,7 @@
     "@rollup/plugin-replace": "^6.0.3",
     "@rollup/plugin-terser": "^1.0.0",
     "@rollup/plugin-typescript": "^12.3.0",
+    "@swc-node/register": "^1.12.1",
     "babel-plugin-transform-typescript-metadata": "^0.3.2",
     "babel-plugin-vona-bean-module": "workspace:^",
     "chalk": "^3.0.0",
@@ -76,7 +77,6 @@
     "randomatic": "^3.1.1",
     "rimraf": "^6.1.3",
     "rollup": "^4.60.1",
-    "ts-node-maintained": "^10.9.6",
     "urllib": "^4.9.0",
     "uuid": "^11.1.0",
     "vona-core": "workspace:^",

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.dev.ts

@@ -165,12 +165,5 @@ export class CliBinDev extends BeanCliBase {
           console.log('App restarted due to: ', files);
         });
     });
-    // await this.helper.spawnExe({
-    //   cmd: 'node',
-    //   args: ['--experimental-transform-types', '--loader=ts-node/esm', '.vona/bootstrap.ts'],
-    //   options: {
-    //     cwd: projectPath,
-    //   },
-    // });
   }
 }

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.test.ts

@@ -4,6 +4,7 @@ import type { VonaConfigMeta, VonaMetaFlavor, VonaMetaMode } from '@cabloy/modul
 import { BeanCliBase } from '@cabloy/cli';
 import { catchError } from '@cabloy/utils';
 import fse from 'fs-extra';
+import { spawn } from 'node:child_process';
 import path from 'node:path';
 import { rimraf } from 'rimraf';
 import { resolveVonaLocalPaths } from 'vona-core';
@@ -20,6 +21,26 @@ declare module '@cabloy/cli' {
   }
 }
 
+export async function runTestChild(args: string[], projectPath: string): Promise<void> {
+  const child = spawn(process.execPath, args, { cwd: projectPath, stdio: 'inherit' });
+  const onInterrupt = () => child.kill('SIGINT');
+  const onTerminate = () => child.kill('SIGTERM');
+  process.on('SIGINT', onInterrupt);
+  process.on('SIGTERM', onTerminate);
+  try {
+    await new Promise<void>((resolve, reject) => {
+      child.once('error', reject);
+      child.once('close', (code, signal) => {
+        if (code === 0) resolve();
+        else reject(new Error(`Test child exited: ${signal ?? code}`));
+      });
+    });
+  } finally {
+    process.off('SIGINT', onInterrupt);
+    process.off('SIGTERM', onTerminate);
+  }
+}
+
 export class CliBinTest extends BeanCliBase {
   async execute() {
     const { argv } = this.context;
@@ -82,13 +103,7 @@ export class CliBinTest extends BeanCliBase {
       patterns.join(','),
     ]);
     // args = args.concat(['--experimental-transform-types', getImportEsm(), testFile, projectPath, (!!argv.coverage).toString(), patterns.join(',')]);
-    await this.helper.spawnExe({
-      cmd: 'node',
-      args,
-      options: {
-        cwd: projectPath,
-      },
-    });
+    await runTestChild(args, projectPath);
   }
 
   async _outputCoverageReportViewer(projectPath: string) {

package/vona/packages-cli/cli-set-api/src/lib/bean/cli.bin.tsc.ts

@@ -1,8 +1,14 @@
 import { BeanCliBase } from '@cabloy/cli';
 
+import type { TypeScriptCompiler } from '../typescriptRunner.ts';
+
+import { runTypeScript } from '../typescriptRunner.ts';
+
 declare module '@cabloy/cli' {
   interface ICommandArgv {
     force: boolean;
+    compiler: TypeScriptCompiler;
+    builders: number;
   }
 }
 
@@ -13,10 +19,23 @@ export class CliBinTsc extends BeanCliBase {
     await super.execute();
     const projectPath = argv.projectPath;
     const force = argv.force;
-    await this._tsc(projectPath, force);
+    await this._tsc(projectPath, force, argv.compiler ?? 'typescript', argv.builders);
   }
 
-  async _tsc(projectPath: string, force: boolean) {
+  async _tsc(
+    projectPath: string,
+    force: boolean,
+    compiler: TypeScriptCompiler = 'typescript',
+    builders?: number,
+  ) {
+    if (builders !== undefined) {
+      if (!Number.isSafeInteger(builders) || builders < 1) {
+        throw new Error('--builders must be a positive safe integer');
+      }
+      if (compiler !== 'native') {
+        throw new Error('--builders requires --compiler=native');
+      }
+    }
     const suiteNames = Object.keys(this.modulesMeta.suites).filter(
       suiteName => !this.modulesMeta.suites[suiteName].info.node_modules,
     );
@@ -35,22 +54,32 @@ export class CliBinTsc extends BeanCliBase {
     if (force) {
       tscArgs.push('--force');
     }
+    if (builders !== undefined) {
+      tscArgs.push('--builders', String(builders));
+    }
+    const check = async (cwd: string) => {
+      if (compiler === 'native') {
+        await runTypeScript(compiler, tscArgs, { projectPath, cwd });
+      } else {
+        await this.helper.processHelper.tsc(tscArgs, { cwd });
+      }
+    };
     // tsc: project
     // eslint-disable-next-line
     console.log(`===>  ${++counter}/${count} project`);
-    await this.helper.processHelper.tsc(tscArgs, { cwd: projectPath });
+    await check(projectPath);
     // suites
     for (const key of suiteNames) {
       const suite = this.modulesMeta.suites[key];
       // eslint-disable-next-line
       console.log(`===>  ${++counter}/${count} suite: ${suite.info.originalName}`);
-      await this.helper.processHelper.tsc(tscArgs, { cwd: suite.root });
+      await check(suite.root);
     }
     // modules
     for (const module of modulesArray) {
       // eslint-disable-next-line
       console.log(`===>  ${++counter}/${count} module: ${module.info.originalName}`);
-      await this.helper.processHelper.tsc(tscArgs, { cwd: module.root });
+      await check(module.root);
     }
     // end
     const timeEnd = Date.now();

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/testCleanupProcess.test.ts

@@ -17,7 +17,7 @@ test('cleanup helper launches via process.execPath and resolves only fake source
     await writeFile(path.join(project, 'package.json'), '{"type":"module"}');
     await writeFile(
       path.join(project, 'tsconfig.json'),
-      '{"compilerOptions":{"module":"NodeNext","moduleResolution":"NodeNext","target":"ESNext","allowImportingTsExtensions":true},"ts-node":{"transpileOnly":true}}',
+      '{"compilerOptions":{"module":"NodeNext","moduleResolution":"NodeNext","target":"ESNext","allowImportingTsExtensions":true}}',
     );
     await writeFile(
       path.join(configDir, 'config.ts'),

package/vona/packages-cli/cli-set-api/src/lib/bean/toolsBin/testCleanupProcess.ts

@@ -4,7 +4,7 @@ import { pathToFileURL } from 'node:url';
 
 // Register before dynamically importing source config/framework (decorators and
 // workspace TS exports). Dependencies resolve from this checkout's Vona install.
-register(import.meta.resolve('ts-node-maintained/esm'), pathToFileURL(`${process.cwd()}/`));
+register(import.meta.resolve('@swc-node/register/esm'), pathToFileURL(`${process.cwd()}/`));
 const require = createRequire(pathToFileURL(path.join(process.cwd(), 'package.json')));
 let queue = Promise.resolve();
 let claim: import('vona-core').TestClaimManifest | undefined;

package/vona/packages-cli/cli-set-api/src/lib/command/bin.tsc.ts

@@ -3,9 +3,19 @@ export default {
   info: {
     version: '5.0.0',
     title: 'Cli: Bin: Tsc',
-    usage: 'npm run vona :bin:tsc -- [--force]',
+    usage: 'npm run vona :bin:tsc -- [--force] [--compiler=typescript|native] [--builders=]',
   },
   options: {
+    compiler: {
+      description:
+        'TypeScript compiler (native requires @typescript/native in the project or repository root)',
+      type: 'string',
+      choices: ['typescript', 'native'],
+    },
+    builders: {
+      description: 'Maximum number of projects to build concurrently (native only)',
+      type: 'number',
+    },
     force: {
       description: 'force',
       type: 'boolean',

package/vona/packages-cli/cli-set-api/src/lib/typescriptRunner.ts

@@ -0,0 +1,61 @@
+import { spawn } from 'node:child_process';
+import { readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+
+export type TypeScriptCompiler = 'native' | 'typescript';
+
+export function resolveTypeScriptCompiler(
+  compiler: TypeScriptCompiler,
+  projectPath: string,
+): string {
+  const packageName = compiler === 'native' ? '@typescript/native' : 'typescript';
+  const require = createRequire(path.resolve(projectPath, 'package.json'));
+  let manifestPath: string;
+  try {
+    manifestPath = require.resolve(`${packageName}/package.json`);
+  } catch (cause) {
+    throw new Error(
+      `Cannot resolve ${packageName}. Install the ${compiler === 'native' ? 'native TypeScript alias (npm:typescript@7.0.2)' : 'TypeScript package'} in the project or its repository root.`,
+      { cause },
+    );
+  }
+  const manifest = JSON.parse(readFileSync(manifestPath, 'utf8'));
+  if (typeof manifest.bin?.tsc !== 'string') {
+    throw new TypeError(`${packageName} does not declare a tsc executable.`);
+  }
+  return path.resolve(path.dirname(manifestPath), manifest.bin.tsc);
+}
+
+export async function runTypeScript(
+  compiler: TypeScriptCompiler,
+  args: string[],
+  { projectPath, cwd = projectPath }: { projectPath: string; cwd?: string },
+): Promise<void> {
+  const executable = resolveTypeScriptCompiler(compiler, projectPath);
+  await new Promise<void>((resolve, reject) => {
+    const child = spawn(process.execPath, [executable, ...args], {
+      cwd,
+      stdio: 'inherit',
+      shell: false,
+    });
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      if (code === 0) {
+        resolve();
+      } else {
+        reject(
+          Object.assign(
+            new Error(
+              `TypeScript (${compiler}) failed: ${signal ? `signal ${signal}` : `exit code ${code}`}`,
+            ),
+            {
+              exitCode: code ?? 1,
+              signal,
+            },
+          ),
+        );
+      }
+    });
+  });
+}

package/vona/packages-cli/cli-set-api/templates/app/register.js

@@ -1,4 +1,4 @@
 import { register } from 'node:module';
 import { pathToFileURL } from 'node:url';
 
-register('ts-node-maintained/esm', pathToFileURL('./'));
+register('@swc-node/register/esm', pathToFileURL('./'));

package/vona/packages-cli/cli-set-api/templates/config/_tsconfig_project.json

@@ -12,8 +12,5 @@
     "src/backend/typing"
   ],
   "exclude": [],
-  "ts-node": {
-    "swc": true
-  },
   "references": []
 }

package/vona/packages-cli/cli-set-api/templates/config/_tsconfig_source.json

@@ -12,9 +12,6 @@
     "src/backend/typing"
   ],
   "exclude": [],
-  "ts-node": {
-    "swc": true
-  },
   "references": [
     {
       "path": "packages-utils/compose"

package/vona/packages-cli/cli-set-api/test/binTestPatterns.test.ts

@@ -0,0 +1,57 @@
+import assert from 'node:assert/strict';
+import { mkdtempSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { it } from 'node:test';
+
+import { runTestChild } from '../src/lib/bean/cli.bin.test.ts';
+
+it('preserves literal test patterns and arguments through a real Node child', async () => {
+  const projectPath = mkdtempSync(join(tmpdir(), 'vona test argv '));
+  try {
+    const probe = join(projectPath, 'argv probe.mjs');
+    const output = join(projectPath, 'argv.json');
+    const fixtures = join(projectPath, 'test', 'support');
+    mkdirSync(fixtures, { recursive: true });
+    for (const name of ['first.ts', 'second.ts']) writeFileSync(join(fixtures, name), '');
+    writeFileSync(
+      probe,
+      `import { writeFileSync } from 'node:fs';
+writeFileSync(process.argv[2], JSON.stringify({ argv: process.argv.slice(3), cwd: process.cwd() }));
+`,
+    );
+    const args = [
+      'test/**/*.ts',
+      'test/*.ts,test/support/*.ts',
+      '',
+      'a value with spaces',
+      'literal & ; $HOME $(echo unexpected) %PATH% [brackets]',
+    ];
+    await runTestChild([probe, output, ...args], projectPath);
+    const observed = JSON.parse(readFileSync(output, 'utf8'));
+    assert.deepEqual(observed.argv, args);
+    assert.equal(realpathSync(observed.cwd), realpathSync(projectPath));
+  } finally {
+    rmSync(projectPath, { recursive: true, force: true });
+  }
+});
+
+it('rejects child failure and spawn failure without leaking signal listeners', async () => {
+  const projectPath = mkdtempSync(join(tmpdir(), 'vona test exit '));
+  try {
+    const listeners = [process.listenerCount('SIGINT'), process.listenerCount('SIGTERM')];
+    await assert.rejects(
+      runTestChild(['--eval', 'process.exit(7)'], projectPath),
+      /Test child exited: 7/,
+    );
+    await assert.rejects(runTestChild(['--eval', ''], join(projectPath, 'missing')), {
+      code: 'ENOENT',
+    });
+    assert.deepEqual(
+      [process.listenerCount('SIGINT'), process.listenerCount('SIGTERM')],
+      listeners,
+    );
+  } finally {
+    rmSync(projectPath, { recursive: true, force: true });
+  }
+});

package/vona/packages-utils/process-helper/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cabloy/process-helper",
-  "version": "3.1.8",
+  "version": "3.1.9",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "cabloy process-helper",
   "keywords": [

package/vona/packages-utils/process-helper/src/index.test.ts

@@ -0,0 +1,62 @@
+import assert from 'node:assert/strict';
+import ChildProcess from 'node:child_process';
+import { PassThrough } from 'node:stream';
+import { describe, it } from 'node:test';
+
+import { ProcessHelper } from './index.ts';
+
+describe('ProcessHelper child termination', { concurrency: false }, () => {
+  for (const { code, signal } of [
+    { code: 0, signal: null },
+    { code: 7, signal: null },
+    { code: null, signal: 'SIGKILL' },
+    { code: null, signal: null },
+  ] as const) {
+    it(`handles exit code ${code} and signal ${signal}`, async t => {
+      const child = new ChildProcess.ChildProcess();
+      t.mock.method(ChildProcess, 'spawn', () => child);
+      const result = new ProcessHelper().spawn({ cmd: 'test-owned-command' });
+      child.emit('exit', code, signal);
+      if (code === 0) {
+        assert.equal(await result, '');
+      } else {
+        await assert.rejects(result, (error: Error & { code?: number; signal?: string }) => {
+          if (code !== null) {
+            assert.equal(error.code, 10000 + code);
+            assert.match(error.message, /exit code: 7/);
+          } else {
+            assert.equal(error.signal, signal);
+            assert.match(error.message, signal ? /SIGKILL/ : /exit code: null/);
+          }
+          return true;
+        });
+      }
+    });
+  }
+
+  it('retains the termination signal alongside stderr', async t => {
+    const child = new ChildProcess.ChildProcess();
+    child.stderr = new PassThrough();
+    t.mock.method(ChildProcess, 'spawn', () => child);
+    const helper = new ProcessHelper();
+    t.mock.method(helper.console, 'log', async () => {});
+    const result = helper.spawn({ cmd: 'test-owned-command' });
+    child.stderr.emit('data', Buffer.from('controlled_stderr'));
+    child.emit('exit', null, 'SIGTERM');
+    await assert.rejects(result, (error: Error & { signal?: string }) => {
+      assert.equal(error.signal, 'SIGTERM');
+      assert.match(error.message, /controlled_stderr/);
+      assert.match(error.message, /SIGTERM/);
+      return true;
+    });
+  });
+
+  it('preserves spawn failures', async t => {
+    const child = new ChildProcess.ChildProcess();
+    t.mock.method(ChildProcess, 'spawn', () => child);
+    const failure = new Error('controlled_spawn_failure');
+    const result = new ProcessHelper().spawn({ cmd: 'test-owned-command' });
+    child.emit('error', failure);
+    await assert.rejects(result, error => error === failure);
+  });
+});

package/vona/packages-utils/process-helper/src/index.ts

@@ -172,12 +172,17 @@ export class ProcessHelper {
       proc.once('error', err => {
         reject(err);
       });
-      proc.once('exit', code => {
+      proc.once('exit', (code, signal) => {
         // if (options.gracefull) childs.delete(proc);
-        if (code) {
-          const message = stderr || `spawn ${cmd} ${args.join(' ')} fail, exit code: ${code}`;
+        if (code !== 0) {
+          const status = signal ? `signal: ${signal}` : `exit code: ${code}`;
+          const message =
+            signal || code === null
+              ? `${stderr ? `${stderr}\n` : ''}spawn ${cmd} ${args.join(' ')} fail, ${status}`
+              : stderr || `spawn ${cmd} ${args.join(' ')} fail, ${status}`;
           const err = new Error(message);
-          (err as any).code = 10000 + Number(code);
+          if (code !== null) (err as any).code = 10000 + code;
+          (err as any).signal = signal;
           return reject(err);
         }
         resolve(stdout);

package/vona/packages-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.112",
+  "version": "5.1.114",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "Vona is an intuitive, elegant and powerful Node.js framework for rapidly developing enterprise applications of any size",
   "keywords": [

package/vona/packages-vona/vona-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-core",
-  "version": "5.1.49",
+  "version": "5.1.50",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona",
   "keywords": [