cabloy 5.1.222 → 5.1.224

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-vona/vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona",
-  "version": "5.1.113",
+  "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": [