@dbx-tools/projen 0.9.21 → 0.9.28

package/src/module-exports.ts

@@ -19,8 +19,9 @@
  * `export { ... }` is a hard error (TS1205). `export function` names are marked
  * `isFunction` so the barrel leaves them namespace-only.
  */
-import { readFileSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
+import { dirname, extname, resolve } from "node:path";
 import type { parseSync as OxcParseSync } from "oxc-parser";
 
 const require = createRequire(import.meta.url);
@@ -63,6 +64,13 @@ export interface ModuleExport {
   readonly isFunction: boolean;
 }
 
+/** Plain public function reachable through a module's re-export graph. */
+export interface PublicFunctionExport {
+  readonly name: string;
+  readonly sourceFile: string;
+  readonly sourceName: string;
+}
+
 /** Declaration node types that are inherently type-only. */
 const TYPE_DECLARATIONS = new Set(["TSInterfaceDeclaration", "TSTypeAliasDeclaration"]);
 
@@ -132,3 +140,169 @@ export function moduleExports(file: string): ModuleExport[] {
   }
   return [...byName.values()];
 }
+
+/**
+ * Resolve every plain named function exported by `file`, following relative
+ * named and star re-exports. Non-function values and types are ignored. A
+ * generator, declaration-only overload, or conflicting function definition is
+ * rejected because a generic runtime bridge cannot preserve those semantics.
+ */
+export function publicFunctionExports(file: string): PublicFunctionExport[] {
+  return [...collectPublicFunctions(resolve(file), new Set()).values()]
+    .map(({ name, sourceFile, sourceName }) => ({ name, sourceFile, sourceName }))
+    .sort((left, right) => left.name.localeCompare(right.name));
+}
+
+interface ResolvedFunctionExport extends PublicFunctionExport {
+  readonly source: string;
+}
+
+function collectPublicFunctions(
+  file: string,
+  visiting: Set<string>,
+): Map<string, ResolvedFunctionExport> {
+  if (visiting.has(file)) return new Map();
+  visiting.add(file);
+  const source = readFileSync(file, "utf8");
+  const body = parseSync(file, source).program.body;
+  const functions = new Map<string, ResolvedFunctionExport>();
+  const localFunctions = new Map<string, FunctionNode>();
+
+  for (const statement of body) {
+    const node = statement as FunctionNode & { declaration?: FunctionNode | null };
+    const declaration =
+      node.type === "FunctionDeclaration" || node.type === "TSDeclareFunction"
+        ? node
+        : node.declaration;
+    if (declaration?.type === "FunctionDeclaration" || declaration?.type === "TSDeclareFunction") {
+      const name = declaration.id?.name;
+      if (name) localFunctions.set(name, declaration);
+    }
+  }
+
+  const add = (exported: ResolvedFunctionExport): void => {
+    const existing = functions.get(exported.name);
+    if (existing && existing.source !== exported.source) {
+      throw new Error(
+        `Conflicting function export ${exported.name} from ${existing.source} and ${exported.source}`,
+      );
+    }
+    functions.set(exported.name, exported);
+  };
+
+  for (const statement of body) {
+    if (statement.type === "ExportAllDeclaration") {
+      const node = statement as { exported?: unknown; source?: { value?: string } };
+      if (node.exported || !node.source?.value) continue;
+      for (const exported of collectPublicFunctions(
+        resolveModuleSpecifier(file, node.source.value),
+        visiting,
+      ).values()) {
+        add(exported);
+      }
+      continue;
+    }
+    if (statement.type !== "ExportNamedDeclaration") continue;
+    const node = statement as {
+      declaration?: FunctionNode | null;
+      source?: { value?: string } | null;
+      specifiers?: {
+        local?: { name?: string; value?: string };
+        exported?: { name?: string; value?: string };
+        exportKind?: "value" | "type";
+      }[];
+      exportKind?: "value" | "type";
+    };
+    if (
+      node.declaration?.type === "FunctionDeclaration" ||
+      node.declaration?.type === "TSDeclareFunction"
+    ) {
+      add(parseFunctionNode(file, node.declaration));
+    }
+    if (node.exportKind === "type") continue;
+    if (node.source?.value) {
+      const available = collectPublicFunctions(
+        resolveModuleSpecifier(file, node.source.value),
+        visiting,
+      );
+      for (const specifier of node.specifiers ?? []) {
+        if (specifier.exportKind === "type") continue;
+        const local = specifier.local?.name ?? specifier.local?.value;
+        const exportedName = specifier.exported?.name ?? specifier.exported?.value;
+        const target = local ? available.get(local) : undefined;
+        if (target && exportedName)
+          add({
+            name: exportedName,
+            source: target.source,
+            sourceFile: target.sourceFile,
+            sourceName: target.sourceName,
+          });
+      }
+      continue;
+    }
+    for (const specifier of node.specifiers ?? []) {
+      if (specifier.exportKind === "type") continue;
+      const local = specifier.local?.name ?? specifier.local?.value;
+      const exportedName = specifier.exported?.name ?? specifier.exported?.value;
+      const target = local ? localFunctions.get(local) : undefined;
+      if (target && exportedName) {
+        const parsed = parseFunctionNode(file, target);
+        add({
+          name: exportedName,
+          source: parsed.source,
+          sourceFile: parsed.sourceFile,
+          sourceName: parsed.sourceName,
+        });
+      }
+    }
+  }
+
+  visiting.delete(file);
+  return functions;
+}
+
+interface FunctionNode {
+  readonly type: string;
+  readonly id?: { readonly name?: string } | null;
+  readonly generator?: boolean;
+  readonly declare?: boolean;
+  readonly body?: unknown;
+}
+
+function parseFunctionNode(file: string, node: FunctionNode): ResolvedFunctionExport {
+  const name = node.id?.name;
+  if (!name) throw new Error(`Anonymous exported function is not supported in ${file}`);
+  if (node.generator) throw new Error(`Generator export ${name} is not supported in ${file}`);
+  if (node.type === "TSDeclareFunction" || node.declare || !node.body) {
+    throw new Error(`Declaration-only function export ${name} is not supported in ${file}`);
+  }
+  return { name, source: `${file}#${name}`, sourceFile: file, sourceName: name };
+}
+
+function resolveModuleSpecifier(importer: string, specifier: string): string {
+  if (!specifier.startsWith(".")) return createRequire(importer).resolve(specifier);
+  const base = resolve(dirname(importer), specifier);
+  const extension = extname(base);
+  const candidates = extension
+    ? [
+        base,
+        ...(extension === ".js" || extension === ".jsx"
+          ? [`${base.slice(0, -extension.length)}.ts`, `${base.slice(0, -extension.length)}.tsx`]
+          : []),
+      ]
+    : [
+        `${base}.ts`,
+        `${base}.tsx`,
+        `${base}.js`,
+        `${base}.jsx`,
+        `${base}.mjs`,
+        `${base}.cjs`,
+        resolve(base, "index.ts"),
+        resolve(base, "index.tsx"),
+        resolve(base, "index.js"),
+      ];
+  for (const candidate of candidates) {
+    if (existsSync(candidate)) return candidate;
+  }
+  throw new Error(`Could not resolve ${specifier} from ${importer}`);
+}

package/src/openapi.ts

@@ -1,9 +1,7 @@
 /**
- * OpenAPI generator for tsoa controllers and code-first Rust producers.
+ * OpenAPI generator for tsoa controllers.
  *
- * TypeScript packages are discovered from tsoa imports. Rust producers are
- * recorded by `DBXToolsRustWorkspace`. Both feed the same optimized generated
- * package:
+ * TypeScript packages are discovered from tsoa imports and feed the optimized generated package:
  *
  *   - `openapi.json`   - the OpenAPI 3 spec (tsoa `generateSpec`, then Speakeasy
  *     optimization to extract duplicate inline schemas into components).
@@ -48,7 +46,6 @@ import {
   toPosix,
   recordedPackages,
 } from "./packages.ts";
-import type { RustOpenApiMapping, RustWorkspaceMapping } from "./project-rs.ts";
 import type { ReleaseUnitGraph } from "./release-catalog.ts";
 import { readWorkspaceVersion } from "./workspace-version.ts";
 
@@ -100,15 +97,6 @@ function controllerPackages(): object.Sequence<RecordedPackage> {
   return object.sequence(recordedPackages()).filter(isTsoaCandidate).filter(hasTsoaControllers);
 }
 
-function rustOpenapiMappings(): RustOpenApiMapping[] {
-  const manifest = JSON.parse(readFileSync(join(repoRoot, "package.json"), "utf8")) as unknown;
-  if (!object.isRecord(manifest)) return [];
-  const config = manifest.dbxToolsConfig;
-  if (!object.isRecord(config) || !object.isRecord(config.rust)) return [];
-  const mapping = config.rust as unknown as Partial<RustWorkspaceMapping>;
-  return Array.isArray(mapping.openapi) ? [...mapping.openapi] : [];
-}
-
 function inside(path: string, directory: string): boolean {
   const child = relative(resolve(directory), resolve(path));
   return child === "" || (!child.startsWith("..") && !isAbsolute(child));
@@ -120,16 +108,11 @@ export function isOpenapiProducerSource(path: string, producers: readonly string
   return object.sequence(producers).some((producer) => inside(absolute, producer));
 }
 
-function rustOpenapiSources(mapping: RustOpenApiMapping): string[] {
-  return [resolve(repoRoot, mapping.rust, "src"), resolve(repoRoot, mapping.rust, "Cargo.toml")];
-}
-
-/** Source roots consumed by TypeScript and Rust OpenAPI producers. */
+/** Source roots consumed by TypeScript OpenAPI producers. */
 export function openapiWatchRoots(): string[] {
   return [
     ...controllerPackages()
       .map((pkg) => resolve(tsoaSource(pkg)))
-      .join(object.sequence(rustOpenapiMappings()).flatMap(rustOpenapiSources))
       .distinct(),
   ];
 }
@@ -139,14 +122,6 @@ export function isOpenapiSource(path: string): boolean {
   const absolute = resolve(path);
   const segments = toPosix(relative(repoRoot, absolute)).split("/");
   if (segments.includes(OPENAPI_TAG)) return false;
-  if (
-    object
-      .sequence(rustOpenapiMappings())
-      .flatMap(rustOpenapiSources)
-      .some((source) => inside(absolute, source))
-  ) {
-    return true;
-  }
   return object
     .sequence(recordedPackages())
     .filter(isTsoaCandidate)
@@ -196,28 +171,6 @@ export async function optimizeOpenapiSpec(specPath: string, executable?: string)
   await execFileAsync(openapi, ["spec", "optimize", specPath, "--write", "--non-interactive"]);
 }
 
-/** Cargo arguments that export one Rust producer's aide document. */
-export function rustOpenapiArgs(
-  mapping: RustOpenApiMapping,
-  output: string,
-  targetDir = join(repoRoot, "target/openapi"),
-): string[] {
-  return [
-    "run",
-    "--quiet",
-    "--target-dir",
-    targetDir,
-    "--package",
-    mapping.crate,
-    ...(mapping.noDefaultFeatures ? ["--no-default-features"] : []),
-    ...(mapping.features.length ? ["--features", mapping.features.join(",")] : []),
-    ...(mapping.binary ? ["--bin", mapping.binary] : []),
-    "--",
-    "--generate-spec",
-    output,
-  ];
-}
-
 type OpenApiTypeTools = {
   openapiTS: typeof import("openapi-typescript").default;
   astToString: typeof import("openapi-typescript").astToString;
@@ -257,11 +210,10 @@ async function writeClientPackage(
  */
 export async function generateOpenapi(): Promise<string[]> {
   const pkgs = controllerPackages().toArray();
-  const rustMappings = rustOpenapiMappings();
   // Same reasoning as codegen's empty case: a workspace with no tsoa controllers
   // is not a condition worth a line on every synth.
-  if (pkgs.length === 0 && rustMappings.length === 0) {
-    logger.debug("no TypeScript or Rust OpenAPI producers found");
+  if (pkgs.length === 0) {
+    logger.debug("no TypeScript OpenAPI producers found");
     return [];
   }
 
@@ -341,24 +293,5 @@ export async function generateOpenapi(): Promise<string[]> {
     written.push(outDir);
     logger.success(`openapi/${leaf} (from ${p.relPath})`);
   }
-  for (const mapping of rustMappings) {
-    const outDir = resolve(repoRoot, mapping.output);
-    mkdirSync(outDir, { recursive: true });
-    const specPath = join(outDir, "openapi.json");
-    const tempDir = mkdtempSync(join(outDir, ".openapi-"));
-    const tempSpecPath = join(tempDir, "openapi.json");
-    try {
-      await execFileAsync("cargo", rustOpenapiArgs(mapping, tempSpecPath), { cwd: repoRoot });
-      await optimizeOpenapiSpec(tempSpecPath);
-      makeWritable(specPath);
-      renameSync(tempSpecPath, specPath);
-    } finally {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
-    makeReadonly(specPath);
-    await writeClientPackage(outDir, `the aide routes in ${mapping.rust}`, tools);
-    written.push(outDir);
-    logger.success(`${mapping.output} (from ${mapping.rust})`);
-  }
   return written;
 }

package/src/packages.ts

@@ -291,6 +291,19 @@ export function syncResynthPaths(projectRoot: string = resolveRepoRoot()): strin
   return Array.isArray(paths) ? stringUtils.parseList(paths.map((p) => String(p))) : [];
 }
 
+/** Python projects with Node bindings registered for the root sync watcher. */
+export function pythonNodeBindingProjects(projectRoot: string = resolveRepoRoot()): string[] {
+  const configured = readDbxToolsConfig(projectRoot)?.pythonNodeBindings;
+  if (!Array.isArray(configured)) return [];
+  return [
+    ...new Set(
+      configured.flatMap((value) =>
+        typeof value === "string" && value.trim() ? [value.trim()] : [],
+      ),
+    ),
+  ].sort();
+}
+
 /**
  * The recorded workspace members from `pnpm-workspace.yaml` (the source of truth),
  * each augmented with the `tags` read back from its `package.json`. This is what
@@ -314,6 +327,38 @@ export function recordedPackages(projectRoot: string = resolveRepoRoot()): Recor
   return out.sort((a, b) => a.path.localeCompare(b.path));
 }
 
+/**
+ * Absolute directories for a workspace package and its transitive runtime
+ * workspace dependencies. Dependency edges come from package manifests; external
+ * packages are ignored. Returns `[]` when `packageName` is not a workspace member.
+ */
+export function workspaceDependencyDirectories(
+  packageName: string,
+  projectRoot: string = resolveRepoRoot(),
+): string[] {
+  const packages = new Map<string, { dir: string; manifest: Record<string, unknown> }>();
+  for (const pkg of recordedPackages(projectRoot)) {
+    const manifest = readPackageManifest(pkg.dir);
+    if (!manifest || typeof manifest.name !== "string") continue;
+    packages.set(manifest.name, { dir: pkg.dir, manifest });
+  }
+  if (!packages.has(packageName)) return [];
+
+  const directories = new Set<string>();
+  const visit = (name: string): void => {
+    const pkg = packages.get(name);
+    if (!pkg || directories.has(pkg.dir)) return;
+    directories.add(pkg.dir);
+    for (const field of ["dependencies", "optionalDependencies", "peerDependencies"] as const) {
+      const dependencies = pkg.manifest[field];
+      if (!object.isRecord(dependencies)) continue;
+      for (const dependency of Object.keys(dependencies)) visit(dependency);
+    }
+  };
+  visit(packageName);
+  return [...directories].sort();
+}
+
 /**
  * The configured roots recorded in the root manifest. Older workspaces without
  * that field fall back to the distinct first segment of every recorded member,

package/src/project-js.ts

@@ -48,7 +48,7 @@ import {
   type ReleaseDependencyInput,
   type ReleaseUnitRule,
 } from "./release-catalog.ts";
-import { DBXToolsRelease, type ReleaseDocsOptions, type ReleaseSummaryOptions } from "./release.ts";
+import { DBXToolsRelease, type ReleaseDocsOptions } from "./release.ts";
 import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags.ts";
 import { DBXToolsRootTsconfig } from "./tsconfig.ts";
 import { DBXToolsVsCode } from "./vscode.ts";
@@ -384,7 +384,7 @@ const PRETTIER_SETTINGS: javascript.PrettierSettings = {
 
 export { PROJEN_VERSION } from "./projen-version.ts";
 
-/** SPDX license shared by generated JavaScript, Python, and Rust packages. */
+/** SPDX license shared by generated JavaScript and Python packages. */
 export const DBX_TOOLS_LICENSE = "Apache-2.0";
 
 /**
@@ -625,8 +625,6 @@ export type DBXToolsJavaScriptProjectOptions = CommonProjectOptions &
     readonly releasePythonRoot?: string;
     /** Repository task names run during local release preparation before publication. */
     readonly releaseValidationTasks?: readonly string[];
-    /** Optional AI-generated release summary. Defaults to enabled. */
-    readonly releaseSummary?: boolean | ReleaseSummaryOptions;
     /** Set to `false` to omit normal npm workspace publication. */
     readonly nodeRelease?: boolean;
     /** Unified dbx-tools release workflow, or no release surface. Defaults to `dbx-tools`. */
@@ -1324,7 +1322,7 @@ class PublishedPackageDescriptionValidation extends Component {
  * fail with ERR_MODULE_NOT_FOUND after such an update. bun runs the `.ts`
  * directly (no tsx, no build step).
  */
-export function taskScript(_project: javascript.NodeProject, script: string, args = ""): string {
+export function taskScript(_project: Project, script: string, args = ""): string {
   const scriptPath = toPosix(join("node_modules", "@dbx-tools", "projen", "tasks", script));
   return args ? `bun ${scriptPath} ${args}` : `bun ${scriptPath}`;
 }
@@ -1580,7 +1578,6 @@ function initProject(
       docs: options.releaseDocs,
       pythonRoot: options.releasePythonRoot,
       validationTasks: options.releaseValidationTasks,
-      summary: options.releaseSummary,
     });
   }
 }

package/src/project-predicate.ts

@@ -33,8 +33,7 @@ export function isDBXToolsProject(): Predicate<IConstruct, DBXToolsProject> {
   return isProject().and(
     (project): project is DBXToolsProject =>
       (project as Partial<DBXToolsProject>).language === "javascript" ||
-      (project as Partial<DBXToolsProject>).language === "python" ||
-      (project as Partial<DBXToolsProject>).language === "rust",
+      (project as Partial<DBXToolsProject>).language === "python",
   );
 }