cabloy 5.1.218 → 5.1.220

package/vona/src/suite-vendor/a-vona/modules/a-version/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-module-a-version",
-  "version": "5.1.21",
+  "version": "5.1.22",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "vona-module-a-version",
   "keywords": [

package/vona/src/suite-vendor/a-vona/modules/a-version/src/service/database.ts

@@ -9,6 +9,8 @@ import {
   BeanBase,
   assertDisposableDatabaseName as assertDisposableDatabaseNameCore,
   assertIsolatedTestPath,
+  assertFreshTestResourcesReady,
+  requiresFreshTestResources,
   assertTestRunOwner,
   resolveVonaLocalPaths,
   withIsolatedTestDatabaseDiscovery,
@@ -39,6 +41,7 @@ interface IDevDatabasePreparation {
 }
 
 const devDatabasePreparations = new WeakMap<VonaApplication, IDevDatabasePreparation>();
+const freshDatabaseCreations = new WeakMap<VonaApplication, Map<string, string>>();
 
 export function assertDisposableDatabaseName(
   databaseName: string,
@@ -318,7 +321,7 @@ export class ServiceDatabase extends BeanBase {
     // client
     const client = this.bean.database.current.client;
     // get current database name
-    const databaseName = client.getDatabaseName();
+    const currentDatabaseName = client.getDatabaseName();
     const sqliteRoot =
       client.db.dialectName === 'better-sqlite3'
         ? resolveVonaLocalPaths(
@@ -327,9 +330,12 @@ export class ServiceDatabase extends BeanBase {
             this.app.meta.env.VONA_TEST_RUN_ID,
           ).sqliteRoot
         : undefined;
-    const currentFilename = sqliteRoot ? path.basename(databaseName, '.db') : databaseName;
+    const currentFilename = sqliteRoot
+      ? path.basename(currentDatabaseName, '.db')
+      : currentDatabaseName;
     const isTestDatabase = currentFilename.startsWith(databasePrefix);
-    if (isTestDatabase) assertDisposableDatabaseName(databaseName, databasePrefix, sqliteRoot);
+    if (isTestDatabase)
+      assertDisposableDatabaseName(currentDatabaseName, databasePrefix, sqliteRoot);
     if (
       this.app.meta.isTest &&
       this.app.meta.env.VONA_TEST_RUN_ID &&
@@ -337,11 +343,32 @@ export class ServiceDatabase extends BeanBase {
       !isTestDatabase
     ) {
       throw new Error(
-        `Isolated test database is outside its disposable namespace: ${databaseName}`,
+        `Isolated test database is outside its disposable namespace: ${currentDatabaseName}`,
       );
     }
     // test db
     if (this.app.meta.isTest) {
+      if (requiresFreshTestResources()) {
+        assertFreshTestResourcesReady(this.app);
+        const key = `${client.clientName}\0${databasePrefix}`;
+        const created = freshDatabaseCreations.get(this.app);
+        if (isTestDatabase) {
+          if (created?.get(key) !== currentDatabaseName) {
+            throw new Error('Strict test cannot reuse an unowned database');
+          }
+          return;
+        }
+        if ((await this.__fetchDatabases(client, instanceName, configInstanceBase)).length !== 0) {
+          throw new Error('Strict test database namespace is no longer fresh');
+        }
+        const name = await this.__createDatabase(client, instanceName, configInstanceBase);
+        assertDisposableDatabaseName(name, databasePrefix, sqliteRoot);
+        const creations = created ?? new Map<string, string>();
+        creations.set(key, name);
+        freshDatabaseCreations.set(this.app, creations);
+        await client.changeConfigConnectionAndReloadWorker(name);
+        return;
+      }
       // check
       if (isTestDatabase) {
         // donothing

package/vona/src/suite-vendor/a-vona/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vona-suite-a-vona",
-  "version": "5.1.101",
+  "version": "5.1.102",
   "gitHead": "a79189b882c17af5911573896a781bbb0046d37d",
   "description": "",
   "author": "",
@@ -54,7 +54,7 @@
     "vona-module-a-static": "workspace:^",
     "vona-module-a-summer": "workspace:^",
     "vona-module-a-swagger": "workspace:^",
-    "vona-module-a-telemetry": "^5.0.2",
+    "vona-module-a-telemetry": "^5.0.3",
     "vona-module-a-upload": "workspace:^",
     "vona-module-a-user": "workspace:^",
     "vona-module-a-validation": "workspace:^",

package/zova/packages-cli/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-cli",
-  "version": "1.2.115",
+  "version": "1.2.116",
   "gitHead": "6f675a8cc46d596142c591c28a40cc4d82fcc6cc",
   "description": "zova cli",
   "keywords": [
@@ -44,7 +44,7 @@
     "@cabloy/process-helper": "^3.1.8",
     "fs-extra": "^11.3.5",
     "semver": "^7.6.2",
-    "zova-cli-set-front": "^1.2.113"
+    "zova-cli-set-front": "^1.2.114"
   },
   "devDependencies": {
     "clean-package": "^2.2.0",

package/zova/packages-cli/cli-set-front/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zova-cli-set-front",
-  "version": "1.2.113",
+  "version": "1.2.114",
   "gitHead": "6f675a8cc46d596142c591c28a40cc4d82fcc6cc",
   "description": "zova cli-set-front",
   "keywords": [

package/zova/packages-cli/cli-set-front/src/lib/bean/cli.bin.buildRest.ts

@@ -12,9 +12,10 @@ import fse from 'fs-extra';
 import path from 'node:path';
 import { rimraf } from 'rimraf';
 import { build } from 'tsdown';
-import yaml from 'yaml';
 import { createConfigUtils, saveJSONFile } from 'zova-vite';
 
+import { extractRestDependencies } from '../common/restDependencies.ts';
+import { extractRestDependencyVersions } from '../common/restDependencyVersions.ts';
 import { loadJSONFile } from '../common/utils.ts';
 import { __ThisSetName__ } from '../this.ts';
 
@@ -61,6 +62,7 @@ interface IBinBuildRestContext {
   outDir: string;
   bundleModules?: string[];
   sideEffectImportModuleNames?: string[];
+  moduleRoots?: string[];
   packageJson?: IBinBuildRestPackageJson;
 }
 
@@ -116,11 +118,13 @@ export class CliBinBuildRest extends BeanCliBase {
     const modules: string[] = [];
     const bundleModules: string[] = [];
     const sideEffectImportModuleNames: string[] = [];
+    const moduleRoots: string[] = [];
     for (const module of modulesMeta.modulesArray) {
       const moduleName = module.info.fullName;
       modules.push(`import '${moduleName}';`);
       modules.push(`export * from '${moduleName}';`);
       const moduleRoot = module.root.replaceAll('\\', '/');
+      moduleRoots.push(moduleRoot);
       if (moduleRoot.includes('/src/module/') || moduleRoot.includes('/src/suite/')) {
         bundleModules.push(moduleName);
       } else {
@@ -129,6 +133,7 @@ export class CliBinBuildRest extends BeanCliBase {
     }
     context.bundleModules = bundleModules;
     context.sideEffectImportModuleNames = sideEffectImportModuleNames;
+    context.moduleRoots = moduleRoots;
     argv.Modules = modules.join('\n');
     // Name/Version
     argv.Name = bundleName;
@@ -181,8 +186,7 @@ export class CliBinBuildRest extends BeanCliBase {
       tsconfig: 'tsconfig.rest.json',
       clean: false,
       dts: {
-        // resolve: true,
-        resolver: 'tsc',
+        resolver: 'oxc',
         tsgo: true,
         eager: true,
         tsconfig: 'tsconfig.rest.json',
@@ -213,13 +217,13 @@ export class CliBinBuildRest extends BeanCliBase {
   }
 
   async _build(buildContext: IBinBuildRestContext) {
-    const { projectPath, flavor, bundleNameCopy, outDir, packageJson } = buildContext;
+    const { projectPath, flavor, bundleNameCopy, outDir, packageJson, moduleRoots } = buildContext;
     // build
     await this._buildTs(buildContext);
     await this._buildDts(buildContext);
     // deps
     const deps = await _extractDeps(path.join(outDir, 'index.d.mts'));
-    const depsVersion = await _extractDepsVersion(projectPath, deps);
+    const depsVersion = await extractRestDependencyVersions(projectPath, deps, moduleRoots);
     // package.json
     const pkgContent = {
       ...packageJson!,
@@ -256,100 +260,6 @@ function _copyToTarget(
 }
 
 async function _extractDeps(filePath: string): Promise<string[]> {
-  let content = (await fse.readFile(filePath)).toString();
-  const pos = content.indexOf('//#region');
-  content = content.substring(0, pos);
-  const packageNames = new Set();
-  const re = /import\s+(?:[\s\S]*?\s+from\s+)?['"]([^'"]+)['"]/g;
-
-  let match: any;
-  while (true) {
-    match = re.exec(content);
-    if (!match) break;
-    let pkg: string = match[1];
-    if (pkg.startsWith('.') || pkg.startsWith('/')) continue;
-    if (pkg.startsWith('@')) {
-      if (pkg.split('/').length > 2) {
-        pkg = pkg.split('/').slice(0, 2).join('/');
-      }
-    } else {
-      if (pkg.split('/').length > 1) {
-        pkg = pkg.split('/').slice(0, 1).join('/');
-      }
-    }
-    packageNames.add(pkg);
-  }
-  return Array.from(packageNames).sort() as string[];
-}
-
-async function _extractDepsVersion(
-  projectPath: string,
-  deps: string[],
-): Promise<Record<string, string>> {
-  const lockfilePath = path.join(projectPath, 'pnpm-lock.yaml');
-  const lockfileContent = (await fse.readFile(lockfilePath)).toString();
-  const parsedLockfile = yaml.parse(lockfileContent);
-  const depsVersion: Record<string, string> = {};
-  for (const dep of deps) {
-    let dependencyRange = getPackageDependencyRangeFromLock(parsedLockfile, dep);
-    if (!dependencyRange) {
-      const version = await getPackageVersionFromNodeModules(projectPath, dep);
-      dependencyRange = version ? `^${version}` : null;
-    }
-    if (!dependencyRange) {
-      console.warn('dep version not found: ', dep);
-      continue;
-    }
-    depsVersion[dep] = dependencyRange;
-  }
-  return depsVersion;
-}
-
-function getPackageDependencyRangeFromLock(
-  parsedLockfile: any,
-  packageName: string,
-): string | null {
-  const importer = parsedLockfile.importers?.['.'];
-  const sections = ['dependencies', 'devDependencies', 'optionalDependencies'];
-  for (const section of sections) {
-    const dependencyRange = getImporterDependencyRange(importer?.[section]?.[packageName]);
-    if (dependencyRange) return dependencyRange;
-  }
-  return null;
-}
-
-function getImporterDependencyRange(
-  importerDependency: { specifier?: string; version?: string } | undefined,
-): string | null {
-  if (!importerDependency) return null;
-
-  const specifier = importerDependency.specifier;
-  if (specifier?.startsWith('npm:')) return specifier;
-
-  const version = normalizeLockfileVersion(importerDependency.version);
-  if (!version) return null;
-  return `^${version}`;
-}
-
-function normalizeLockfileVersion(version: string | undefined): string | null {
-  if (!version) return null;
-  if (version.startsWith('link:') || version.startsWith('file:')) return null;
-
-  const versionWithoutPeers = version.split('(')[0];
-  if (!versionWithoutPeers) return null;
-  if (/^\d/.test(versionWithoutPeers)) return versionWithoutPeers;
-
-  const aliasSeparator = versionWithoutPeers.lastIndexOf('@');
-  if (aliasSeparator === -1) return null;
-
-  const aliasedVersion = versionWithoutPeers.slice(aliasSeparator + 1);
-  if (!aliasedVersion || !/^\d/.test(aliasedVersion)) return null;
-  return aliasedVersion;
-}
-
-async function getPackageVersionFromNodeModules(projectPath: string, packageName: string) {
-  const pkgFile = path.join(projectPath, 'node_modules', packageName, 'package.json');
-  if (!fse.existsSync(pkgFile)) return null;
-  const pkgContent = await loadJSONFile(pkgFile);
-  return pkgContent.version;
+  const content = await fse.readFile(filePath, 'utf8');
+  return extractRestDependencies(content);
 }

package/zova/packages-cli/cli-set-front/src/lib/common/restDependencies.ts

@@ -0,0 +1,78 @@
+import { isBuiltin } from 'node:module';
+import path from 'node:path';
+import ts from 'typescript';
+
+export function extractRestDependencies(content: string): string[] {
+  const source = ts.createSourceFile('index.d.mts', content, ts.ScriptTarget.Latest);
+  // createSourceFile exposes syntax diagnostics at runtime, but not in its public return type.
+  const { parseDiagnostics } = source as ts.SourceFile & {
+    parseDiagnostics: readonly ts.Diagnostic[];
+  };
+  if (parseDiagnostics.length) {
+    const diagnostic = parseDiagnostics[0];
+    const { line, character } = source.getLineAndCharacterOfPosition(diagnostic.start ?? 0);
+    throw new Error(
+      `Invalid REST declaration at ${source.fileName}:${line + 1}:${character + 1}: ${ts.flattenDiagnosticMessageText(diagnostic.messageText, '\n')}`,
+    );
+  }
+  for (const kind of ['path', 'types'] as const) {
+    const references = kind === 'path' ? source.referencedFiles : source.typeReferenceDirectives;
+    if (references.length) {
+      throw new Error(
+        `Unsupported REST declaration reference directive: ${kind} ${JSON.stringify(references[0].fileName)}. ` +
+          'The current REST bundling workflow does not support this directive.',
+      );
+    }
+  }
+  // lib references are compiler-owned, not package dependencies.
+  const dependencies = new Set<string>();
+
+  function addDependency(specifier: ts.Node | undefined) {
+    if (!specifier) return;
+    if (!ts.isStringLiteral(specifier)) {
+      throw new Error('Unsupported REST declaration module specifier');
+    }
+    const id = specifier.text;
+    if (
+      id.startsWith('.') ||
+      id.startsWith('#') ||
+      id.startsWith('\0') ||
+      path.isAbsolute(id) ||
+      path.win32.isAbsolute(id) ||
+      /^[a-z][a-z\d+.-]*:/i.test(id) ||
+      isBuiltin(id)
+    ) {
+      return;
+    }
+    if (!id || id.includes(':')) {
+      throw new Error(`Unsupported REST declaration package reference: ${id}`);
+    }
+    const parts = id.split('/');
+    if (id.startsWith('@') && (!parts[0].slice(1) || !parts[1])) {
+      throw new Error(`Invalid REST declaration package reference: ${id}`);
+    }
+    dependencies.add(parts.slice(0, id.startsWith('@') ? 2 : 1).join('/'));
+  }
+
+  function visit(node: ts.Node) {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      addDependency(node.moduleSpecifier);
+    } else if (ts.isImportTypeNode(node)) {
+      if (!ts.isLiteralTypeNode(node.argument)) {
+        throw new Error('Unsupported REST declaration import type');
+      }
+      addDependency(node.argument.literal);
+    } else if (
+      ts.isImportEqualsDeclaration(node) &&
+      ts.isExternalModuleReference(node.moduleReference)
+    ) {
+      addDependency(node.moduleReference.expression);
+    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
+      throw new Error('Unsupported REST declaration dynamic import');
+    }
+    ts.forEachChild(node, visit);
+  }
+
+  visit(source);
+  return Array.from(dependencies).sort();
+}

package/zova/packages-cli/cli-set-front/src/lib/common/restDependencyVersions.ts

@@ -0,0 +1,231 @@
+import fse from 'fs-extra';
+import path from 'node:path';
+import yaml from 'yaml';
+
+const dependencySections = ['dependencies', 'devDependencies', 'optionalDependencies'] as const;
+
+type ImporterDependency = {
+  specifier?: string;
+  version?: string;
+};
+
+type Importer = Partial<
+  Record<(typeof dependencySections)[number], Record<string, ImporterDependency>>
+>;
+
+type ParsedLockfile = {
+  importers?: Record<string, Importer>;
+};
+
+type ModuleCandidate = {
+  range: string;
+  moduleRoot: string;
+};
+
+export async function extractRestDependencyVersions(
+  projectPath: string,
+  deps: string[],
+  moduleRoots: string[] = [],
+): Promise<Record<string, string>> {
+  const lockfilePath = path.join(projectPath, 'pnpm-lock.yaml');
+  const lockfileContent = await fse.readFile(lockfilePath, 'utf8');
+  const parsedLockfile = yaml.parse(lockfileContent) as ParsedLockfile;
+  const depsVersion: Record<string, string> = {};
+
+  for (const dep of deps) {
+    const rootRange = getPackageDependencyRangeFromLock(parsedLockfile, dep);
+    if (rootRange) {
+      depsVersion[dep] = rootRange;
+      continue;
+    }
+
+    const moduleCandidates = await getModuleCandidates(
+      projectPath,
+      parsedLockfile,
+      dep,
+      moduleRoots,
+    );
+    const distinctCandidates = getDistinctCandidates(moduleCandidates);
+    if (distinctCandidates.length > 1) {
+      throw createConflictingCandidatesError(dep, distinctCandidates);
+    }
+    if (distinctCandidates.length === 1) {
+      depsVersion[dep] = distinctCandidates[0].range;
+      continue;
+    }
+
+    const rootVersion = await getPackageVersionFromNodeModules(projectPath, dep);
+    if (rootVersion) {
+      depsVersion[dep] = `^${rootVersion}`;
+      continue;
+    }
+
+    throw createUnresolvedDependencyError(projectPath, dep, moduleRoots);
+  }
+
+  return depsVersion;
+}
+
+function getPackageDependencyRangeFromLock(
+  parsedLockfile: ParsedLockfile,
+  packageName: string,
+): string | null {
+  const importer = parsedLockfile.importers?.['.'];
+  return getImporterDependencyRange(importer, packageName);
+}
+
+function getImporterDependencyRange(
+  importer: Importer | undefined,
+  packageName: string,
+): string | null {
+  if (!importer) return null;
+
+  for (const section of dependencySections) {
+    const dependencyRange = normalizeImporterDependency(importer[section]?.[packageName]);
+    if (dependencyRange) return dependencyRange;
+  }
+  return null;
+}
+
+function normalizeImporterDependency(
+  importerDependency: ImporterDependency | undefined,
+): string | null {
+  if (!importerDependency) return null;
+
+  const specifier = importerDependency.specifier;
+  if (specifier?.startsWith('npm:')) return specifier;
+
+  const version = normalizeLockfileVersion(importerDependency.version);
+  if (!version) return null;
+  return `^${version}`;
+}
+
+function normalizeLockfileVersion(version: string | undefined): string | null {
+  if (!version) return null;
+  if (version.startsWith('link:') || version.startsWith('file:')) return null;
+
+  const versionWithoutPeers = version.split('(')[0];
+  if (!versionWithoutPeers) return null;
+  if (/^\d/.test(versionWithoutPeers)) return versionWithoutPeers;
+
+  const aliasSeparator = versionWithoutPeers.lastIndexOf('@');
+  if (aliasSeparator === -1) return null;
+
+  const aliasedVersion = versionWithoutPeers.slice(aliasSeparator + 1);
+  if (!aliasedVersion || !/^\d/.test(aliasedVersion)) return null;
+  return aliasedVersion;
+}
+
+async function getModuleCandidates(
+  projectPath: string,
+  parsedLockfile: ParsedLockfile,
+  packageName: string,
+  moduleRoots: string[],
+): Promise<ModuleCandidate[]> {
+  const candidates: ModuleCandidate[] = [];
+  for (const moduleRoot of moduleRoots) {
+    const absoluteModuleRoot = path.resolve(projectPath, moduleRoot);
+    if (absoluteModuleRoot === path.resolve(projectPath)) continue;
+
+    const importerKey = getImporterKey(projectPath, absoluteModuleRoot);
+    const importerRange = getImporterDependencyRange(
+      parsedLockfile.importers?.[importerKey],
+      packageName,
+    );
+    if (importerRange) {
+      candidates.push({ range: importerRange, moduleRoot: importerKey });
+      continue;
+    }
+
+    const manifestSpecifier = await getManifestDependencySpecifier(absoluteModuleRoot, packageName);
+    if (!manifestSpecifier) continue;
+
+    const installedVersion = await getPackageVersionFromNodeModules(
+      absoluteModuleRoot,
+      packageName,
+    );
+    if (!installedVersion) continue;
+    candidates.push({
+      range: manifestSpecifier.startsWith('npm:') ? manifestSpecifier : `^${installedVersion}`,
+      moduleRoot: importerKey,
+    });
+  }
+  return candidates;
+}
+
+async function getManifestDependencySpecifier(
+  moduleRoot: string,
+  packageName: string,
+): Promise<string | null> {
+  const manifestPath = path.join(moduleRoot, 'package.json');
+  if (!fse.existsSync(manifestPath)) return null;
+
+  const manifest = (await fse.readJson(manifestPath)) as Record<string, unknown>;
+  for (const section of dependencySections) {
+    const sectionDependencies = manifest[section];
+    if (!sectionDependencies || typeof sectionDependencies !== 'object') continue;
+    const specifier = (sectionDependencies as Record<string, unknown>)[packageName];
+    if (typeof specifier === 'string') return specifier;
+  }
+  return null;
+}
+
+function getDistinctCandidates(candidates: ModuleCandidate[]): ModuleCandidate[] {
+  const distinctCandidates = new Map<string, ModuleCandidate>();
+  for (const candidate of candidates) {
+    if (!distinctCandidates.has(candidate.range)) {
+      distinctCandidates.set(candidate.range, candidate);
+    }
+  }
+  return Array.from(distinctCandidates.values());
+}
+
+async function getPackageVersionFromNodeModules(
+  packageRoot: string,
+  packageName: string,
+): Promise<string | null> {
+  const pkgFile = path.join(packageRoot, 'node_modules', packageName, 'package.json');
+  if (!fse.existsSync(pkgFile)) return null;
+  const pkgContent = (await fse.readJson(pkgFile)) as Record<string, unknown>;
+  return typeof pkgContent.version === 'string' && pkgContent.version ? pkgContent.version : null;
+}
+
+function getImporterKey(projectPath: string, moduleRoot: string): string {
+  const relativePath = path.relative(projectPath, moduleRoot);
+  return relativePath.replaceAll(path.sep, '/') || '.';
+}
+
+function getRepoRelativePath(projectPath: string, filePath: string): string {
+  const relativePath = path.relative(projectPath, filePath).replaceAll(path.sep, '/');
+  return relativePath || '.';
+}
+
+function createConflictingCandidatesError(
+  packageName: string,
+  candidates: ModuleCandidate[],
+): Error {
+  const details = candidates
+    .map(candidate => `${candidate.moduleRoot} (${candidate.range})`)
+    .join(', ');
+  return new Error(
+    `Conflicting REST dependency versions for ${packageName} in module importers: ${details}. ` +
+      `Align the dependency versions or declare ${packageName} in the project root package.json ` +
+      '(pnpm-lock.yaml).',
+  );
+}
+
+function createUnresolvedDependencyError(
+  projectPath: string,
+  packageName: string,
+  moduleRoots: string[],
+): Error {
+  const checkedModuleRoots = moduleRoots.length
+    ? moduleRoots
+        .map(moduleRoot => getRepoRelativePath(projectPath, path.resolve(projectPath, moduleRoot)))
+        .join(', ')
+    : '(none)';
+  return new Error(
+    `Unable to resolve REST dependency version for ${packageName}. Add it to the project or an owning ` +
+      `module and install it; checked module roots: ${checkedModuleRoots}; lockfile: pnpm-lock.yaml.`,
+  );
+}