@dbx-tools/projen 0.9.19 → 0.9.28

package/tasks/rust.ts

@@ -1,178 +0,0 @@
-#!/usr/bin/env -S bun
-import { spawnSync } from "node:child_process";
-import { existsSync } from "node:fs";
-import { dirname, isAbsolute, resolve, sep } from "node:path";
-import { fileURLToPath } from "node:url";
-import { log, object } from "@dbx-tools/shared-core";
-import { readDbxToolsConfig, repoRoot } from "../src/packages.ts";
-import {
-  discoverRustCrates,
-  hasUniFFIBindings,
-  orderRustBindings,
-  type RustBindingMapping,
-  type RustWorkspaceMapping,
-} from "../src/project-rs.ts";
-import { runSynth } from "../src/scaffold.ts";
-import { watchLoop } from "../src/watch.ts";
-
-const logger = log.logger("projen:rust");
-
-function rustConfig(): RustWorkspaceMapping | undefined {
-  const value = readDbxToolsConfig(repoRoot)?.rust;
-  if (!value || typeof value !== "object" || Array.isArray(value)) return undefined;
-  const candidate = value as Partial<RustWorkspaceMapping>;
-  if (typeof candidate.root !== "string") return undefined;
-  if (!Array.isArray(candidate.crates) || !Array.isArray(candidate.bindings)) return undefined;
-  return candidate as RustWorkspaceMapping;
-}
-
-function cargoAvailable(): boolean {
-  return spawnSync("cargo", ["--version"], { stdio: "ignore" }).status === 0;
-}
-
-function currentStructure(config: RustWorkspaceMapping): RustWorkspaceMapping {
-  const root = resolve(repoRoot, config.root);
-  const directories = discoverRustCrates(root);
-  const crates = directories.map((directory) => `${config.root}/${directory}`);
-  const recorded = new Map(config.bindings.map((binding) => [binding.rust, binding]));
-  const bindings = crates.flatMap((rust) => {
-    if (!hasUniFFIBindings(resolve(repoRoot, rust))) return [];
-    const binding = recorded.get(rust);
-    return binding ? [binding] : [{ crate: "", rust }];
-  });
-  return { ...config, crates, bindings };
-}
-
-/** Whether discovered crate membership or UniFFI marker membership changed. */
-export function rustStructureChanged(config: RustWorkspaceMapping): boolean {
-  return !sameStructure(config, currentStructure(config));
-}
-
-function sameStructure(left: RustWorkspaceMapping, right: RustWorkspaceMapping): boolean {
-  return (
-    JSON.stringify(left.crates) === JSON.stringify(right.crates) &&
-    JSON.stringify(left.bindings.map((binding) => binding.rust)) ===
-      JSON.stringify(right.bindings.map((binding) => binding.rust))
-  );
-}
-
-function ownerBinding(
-  path: string,
-  bindings: readonly RustBindingMapping[],
-): RustBindingMapping | undefined {
-  const absolute = isAbsolute(path) ? path : resolve(repoRoot, path);
-  return bindings.find((binding) => {
-    const directory = resolve(repoRoot, binding.rust);
-    return absolute === directory || absolute.startsWith(directory + sep);
-  });
-}
-
-function generate(binding: RustBindingMapping): void {
-  const targets = [
-    ...(binding.node ? ["--node", binding.node] : []),
-    ...(binding.python
-      ? ["--python", binding.python, "--python-module", binding.pythonModule ?? ""]
-      : []),
-  ];
-  const result = spawnSync(
-    process.execPath,
-    [
-      resolve(dirname(fileURLToPath(import.meta.url)), "uniffi.ts"),
-      "--crate",
-      binding.crate,
-      ...targets,
-    ],
-    { cwd: repoRoot, stdio: "inherit" },
-  );
-  if (result.status !== 0) throw new Error(`binding generation exited with ${result.status}`);
-}
-
-function* iterateAffectedRustBindings(
-  bindings: readonly RustBindingMapping[],
-  changed: ReadonlySet<string>,
-): Generator<RustBindingMapping> {
-  const affected = new Set(changed);
-  for (const binding of orderRustBindings(bindings)) {
-    if (binding.dependencies?.some((dependency) => affected.has(dependency))) {
-      affected.add(binding.crate);
-    }
-    if (affected.has(binding.crate)) yield binding;
-  }
-}
-
-export function affectedRustBindings(
-  bindings: readonly RustBindingMapping[],
-  changed: ReadonlySet<string>,
-): RustBindingMapping[] {
-  return [...iterateAffectedRustBindings(bindings, changed)];
-}
-
-/**
- * Lazily resolve direct binding owners so lock checks stop at the first match.
- */
-export function changedRustOwners(
-  config: RustWorkspaceMapping,
-  changed: readonly string[],
-): object.Sequence<RustBindingMapping> {
-  return object
-    .sequence(changed)
-    .map((path) => ownerBinding(path, config.bindings))
-    .nonNull()
-    .distinct();
-}
-
-/** Collect direct owners, then lazily yield them and their dependents in order. */
-export function changedRustBindings(
-  config: RustWorkspaceMapping,
-  changed: readonly string[],
-): object.Sequence<RustBindingMapping> {
-  const targets = new Set(changedRustOwners(config, changed).map((binding) => binding.crate));
-  return object.sequence(iterateAffectedRustBindings(config.bindings, targets));
-}
-
-const config = rustConfig();
-
-async function main(): Promise<void> {
-  if (!config || config.crates.length === 0 || !existsSync(resolve(repoRoot, config.root))) return;
-  if (!cargoAvailable()) {
-    throw new Error("Cargo is required because Rust projects were detected");
-  }
-  if (!process.argv.includes("--watch")) {
-    for (const binding of orderRustBindings(config.bindings)) generate(binding);
-    return;
-  }
-
-  watchLoop(
-    "rust",
-    [resolve(repoRoot, config.root)],
-    (changed) => {
-      const latest = rustConfig() ?? config;
-      if (rustStructureChanged(latest)) {
-        logger.start("Rust project structure changed - re-synthesizing (+install)");
-        runSynth({ post: true });
-        logger.success("Rust project structure synchronized");
-        const refreshed = rustConfig();
-        if (!refreshed) return;
-        for (const binding of changedRustBindings(refreshed, changed)) {
-          logger.start(`generating ${binding.crate} bindings`);
-          generate(binding);
-          logger.success(`generated ${binding.crate} bindings`);
-        }
-        return;
-      }
-      for (const binding of changedRustBindings(latest, changed)) {
-        logger.start(`generating ${binding.crate} bindings`);
-        generate(binding);
-        logger.success(`generated ${binding.crate} bindings`);
-      }
-    },
-    {
-      check: (changed) => {
-        const latest = rustConfig() ?? config;
-        return changedRustOwners(latest, changed).some(() => true) || rustStructureChanged(latest);
-      },
-    },
-  );
-}
-
-if (import.meta.main) await main();

package/tasks/stamp-python.ts

@@ -1,13 +0,0 @@
-#!/usr/bin/env -S bun
-import { Command } from "commander";
-import { stampPythonProjects } from "./publish-python.ts";
-
-const program = new Command();
-program
-  .argument("<version>", "Python package version")
-  .option("--root <path>", "Python workspace package root", "packages/py")
-  .action((version: string, options: { root: string }) => {
-    stampPythonProjects(options.root, version);
-  });
-
-await program.parseAsync();

package/tasks/uniffi-python.d.ts

@@ -1,61 +0,0 @@
-export interface TomlCodec {
-  parse(source: string): unknown;
-  stringify(document: unknown): string;
-}
-
-export interface PythonPackageMapping {
-  readonly directory: string;
-  readonly name: string;
-  readonly version: string;
-  readonly uniffi: boolean;
-}
-
-export interface PythonProjectInfo {
-  readonly name: string;
-  readonly version: string;
-  readonly private: boolean;
-  readonly uniffi: boolean;
-}
-
-/** Read the project identity and publication flag from parsed TOML metadata. */
-export function pythonProjectInfo(source: string, toml: TomlCodec): PythonProjectInfo;
-
-/** Stamp a temporary publication version and exact sibling dependencies. */
-export function stampPythonProject(
-  source: string,
-  options: {
-    readonly packages: readonly PythonPackageMapping[];
-    readonly rewriteDependencies?: boolean;
-    readonly usePackageVersions?: boolean;
-    readonly toml: TomlCodec;
-    readonly version: string;
-  },
-): string;
-
-/** Return the target-specific UniFFI generator executable name. */
-export function pythonBindingGeneratorName(crate: string, platform: string): string;
-
-/** Build the canonical UniFFI Python generator argument list. */
-export function pythonBindingGeneratorArgs(options: {
-  readonly crate: string;
-  readonly library: string;
-  readonly output: string;
-}): string[];
-
-export interface InstalledPythonBindings {
-  readonly bindings: string;
-  readonly init: string;
-  readonly library: string;
-}
-
-/** Generate and place one Python binding module and its native library. */
-export function installPythonBindings(options: {
-  readonly crate: string;
-  readonly library: string;
-  readonly module: string;
-  readonly packageRoot: string;
-  readonly platform: string;
-  readonly readonly?: boolean;
-  readonly run: (command: string, args: string[]) => void;
-  readonly targetDirectory: string;
-}): InstalledPythonBindings;

package/tasks/uniffi-python.js

@@ -1,191 +0,0 @@
-import {
-  chmodSync,
-  cpSync,
-  existsSync,
-  mkdirSync,
-  mkdtempSync,
-  readFileSync,
-  readdirSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { tmpdir } from "node:os";
-import { basename, join, resolve } from "node:path";
-
-const READONLY = 0o444;
-const WRITABLE = 0o644;
-
-const projectTable = (document) => {
-  const project = document?.project;
-  if (!project || typeof project !== "object" || Array.isArray(project)) {
-    throw new Error("Missing Python project metadata");
-  }
-  return project;
-};
-
-const directSibling = (dependency, sibling) => {
-  const prefix = `${sibling.name} @ git+`;
-  if (!dependency.startsWith(prefix)) return false;
-  const marker = "#subdirectory=";
-  const markerIndex = dependency.indexOf(marker, prefix.length);
-  if (markerIndex < 0) return false;
-  const directory = dependency.slice(markerIndex + marker.length);
-  return directory === sibling.directory || directory.endsWith(`/${sibling.directory}`);
-};
-
-const setWritable = (path) => {
-  if (existsSync(path)) chmodSync(path, WRITABLE);
-};
-
-const setReadonly = (path) => {
-  if (existsSync(path)) chmodSync(path, READONLY);
-};
-
-const generatedHeader = (crate) =>
-  [
-    "# GENERATED by UniFFI binding generation - DO NOT EDIT.",
-    `# Regenerated from the ${crate} Rust exports.`,
-    "# Hand edits are overwritten on the next watch; this file is read-only.",
-    "",
-  ].join("\n");
-
-export const pythonProjectInfo = (source, toml) => {
-  const document = toml.parse(source);
-  const project = projectTable(document);
-  if (typeof project.name !== "string" || !project.name) {
-    throw new Error("Missing Python project name");
-  }
-  if (typeof project.version !== "string" || !project.version) {
-    throw new Error("Missing Python project version");
-  }
-  const config = document?.tool?.["dbx-tools"];
-  return {
-    name: project.name,
-    version: project.version,
-    private: Boolean(config && typeof config === "object" && config.private === true),
-    uniffi: Boolean(config && typeof config === "object" && config.uniffi === true),
-  };
-};
-
-const compatibleRequirement = (version) => {
-  const [major, minor] = version.split(".").map(Number);
-  const upper = major === 0 ? `0.${minor + 1}.0` : `${major + 1}.0.0`;
-  return `>=${version},<${upper}`;
-};
-
-export const stampPythonProject = (
-  source,
-  { packages, rewriteDependencies = true, usePackageVersions = false, toml, version },
-) => {
-  const marker = source.startsWith("# ") ? source.slice(0, source.indexOf("\n")) : undefined;
-  const document = toml.parse(source);
-  const project = projectTable(document);
-  if (typeof project.version !== "string") {
-    throw new Error("Missing Python project version");
-  }
-  project.version = version;
-  if (rewriteDependencies) {
-    const dependencies = project.dependencies;
-    if (dependencies !== undefined && !Array.isArray(dependencies)) {
-      throw new Error("Python project dependencies must be an array");
-    }
-    if (dependencies) {
-      project.dependencies = dependencies.map((dependency) => {
-        if (typeof dependency !== "string") {
-          throw new Error("Python project dependencies must be strings");
-        }
-        const sibling = packages.find((candidate) => directSibling(dependency, candidate));
-        return sibling
-          ? `${sibling.name}${
-              usePackageVersions
-                ? sibling.uniffi
-                  ? `==${sibling.version}`
-                  : compatibleRequirement(sibling.version)
-                : `==${version}`
-            }`
-          : dependency;
-      });
-    }
-  }
-  const body = toml.stringify(document).trimEnd();
-  return `${marker ? `${marker}\n\n` : ""}${body}\n`;
-};
-
-export const pythonBindingGeneratorName = (crate, platform) =>
-  `${crate}-uniffi-bindgen${platform === "win32" ? ".exe" : ""}`;
-
-export const pythonBindingGeneratorArgs = ({ crate, library, output }) => [
-  "generate",
-  "--language",
-  "python",
-  "--crate",
-  crate.replaceAll("-", "_"),
-  "--out-dir",
-  output,
-  library,
-];
-
-export const installPythonBindings = ({
-  crate,
-  library,
-  module,
-  packageRoot,
-  platform,
-  generatedSource,
-  readonly = false,
-  run,
-  targetDirectory,
-}) => {
-  const packageName = module.split(".").at(-1);
-  if (!packageName) throw new Error(`Invalid Python module ${module}`);
-  const packageDirectory = resolve(packageRoot, "src", ...module.split("."));
-  const generatedDirectory = generatedSource
-    ? undefined
-    : mkdtempSync(join(tmpdir(), `${packageName}-python-`));
-  const generator = resolve(targetDirectory, pythonBindingGeneratorName(crate, platform));
-
-  try {
-    if (!generatedSource) {
-      if (!existsSync(generator)) throw new Error(`Missing UniFFI generator ${generator}`);
-      run(
-        generator,
-        pythonBindingGeneratorArgs({
-          crate,
-          library,
-          output: generatedDirectory,
-        }),
-      );
-    }
-    const generated =
-      generatedSource ?? join(generatedDirectory, `${crate.replaceAll("-", "_")}.py`);
-    if (!existsSync(generated)) throw new Error(`Missing generated binding ${generated}`);
-    mkdirSync(packageDirectory, { recursive: true });
-
-    const bindings = join(packageDirectory, "bindings.py");
-    setWritable(bindings);
-    writeFileSync(bindings, `${generatedHeader(crate)}${readFileSync(generated, "utf8")}`);
-
-    const init = join(packageDirectory, "__init__.py");
-    setWritable(init);
-    writeFileSync(init, `${generatedHeader(crate)}from .bindings import *\n`);
-
-    for (const candidate of readdirSync(packageDirectory)) {
-      if (/\.(?:dll|dylib|so)$/.test(candidate)) {
-        rmSync(join(packageDirectory, candidate), { force: true });
-      }
-    }
-    const nativeLibrary = join(packageDirectory, basename(library));
-    setWritable(nativeLibrary);
-    cpSync(library, nativeLibrary);
-
-    if (readonly) {
-      setReadonly(bindings);
-      setReadonly(init);
-      setReadonly(nativeLibrary);
-    }
-    rmSync(join(packageDirectory, "_generated"), { recursive: true, force: true });
-    return { bindings, init, library: nativeLibrary };
-  } finally {
-    if (generatedDirectory) rmSync(generatedDirectory, { recursive: true, force: true });
-  }
-};