@dbx-tools/projen 0.9.5 → 0.9.6

package/src/barrels.ts

@@ -59,7 +59,7 @@
 import { existsSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { join, relative } from "node:path";
 import { find } from "@dbx-tools/path";
-import { json, string } from "@dbx-tools/shared-core";
+import { json, stringUtils } from "@dbx-tools/shared-core";
 import isIdentifier from "is-identifier";
 import { header, isGenerated, makeReadonly, makeWritable, type HeaderOpts } from "./generated.ts";
 import { moduleExports, moduleStatements, type ModuleExport } from "./module-exports.ts";
@@ -125,9 +125,11 @@ const UNIFFI_BINDINGS_FILE = "bindings.ts";
 const UNIFFI_GENERATED_FILE = "_bindings.ts";
 const UNIFFI_FFI_FILE = "_bindings-ffi.ts";
 
-/** `pnpm-workspace` -> `pnpmWorkspace`; `local-fs` -> `localFS` (`fs` -> `FS`). */
-function kebabToCamel(segment: string): string {
-  const tokens = [...string.tokenizeWithOptions({ lowerCase: true, capitalize: true }, segment)];
+/** `config-tools` / `config_tools` -> `configTools`; `local-fs` -> `localFS`. */
+function moduleSegmentToCamel(segment: string): string {
+  const tokens = [
+    ...stringUtils.tokenizeWithOptions({ lowerCase: true, capitalize: true }, segment),
+  ];
   if (tokens.length === 0) return segment;
   const [first, ...rest] = tokens;
   // Standalone acronym modules (`fs`, `ai`) stay lowercase so they match
@@ -145,14 +147,14 @@ function modulePathToNamespace(modulePath: string): string {
   const rel = modulePath.replace(/^\.\/src\//, "").replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
   const segments = rel.split("/");
   if (segments.at(-1) === "index" && segments.length > 1) segments.pop();
-  const names = segments.map(kebabToCamel);
+  const names = segments.map(moduleSegmentToCamel);
   let name =
     names.length === 1
       ? names[0]!
       : names[0]! +
         names
           .slice(1)
-          .map((s) => string.capitalize(s))
+          .map((s) => stringUtils.capitalize(s))
           .join("");
   if (!isIdentifier(name)) {
     name = `${name}Module`;
@@ -576,7 +578,7 @@ export function generateBarrels(
     const names = failures.map((f) => relative(projectRoot, f.dir) || f.dir);
     throw new AggregateError(
       failures.map((f) => f.err),
-      `${string.pluralize(failures.length, "barrel")} failed: ${names.join(", ")}`,
+      `${stringUtils.pluralize(failures.length, "barrel")} failed: ${names.join(", ")}`,
     );
   }
   return total;

package/src/engine-root.ts

@@ -6,8 +6,8 @@
  */
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { project } from "@dbx-tools/core";
-import { functionModule } from "@dbx-tools/shared-core";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { functionUtils } from "@dbx-tools/shared-core";
 
 const ENGINE_PKG = "@dbx-tools/projen";
 
@@ -17,11 +17,11 @@ const ENGINE_PKG = "@dbx-tools/projen";
  * Walks up from this module with shared-core's {@link project.root} (the nearest
  * package bounded by the enclosing npm/git root), so it resolves both in-repo and
  * when installed as a dependency. Memoized with shared-core's
- * {@link functionModule.memoize}, which caches only a successful result - a
+ * {@link functionUtils.memoize}, which caches only a successful result - a
  * throw is retried on the next call.
  */
-export const resolvePkgRoot = functionModule.memoize((): string => {
-  const found = project.root(dirname(fileURLToPath(import.meta.url)));
+export const resolvePkgRoot = functionUtils.memoize((): string => {
+  const found = projectUtils.root(dirname(fileURLToPath(import.meta.url)));
   if (!found) throw new Error(`${ENGINE_PKG} package root not found`);
   return found;
 });

package/src/openapi.ts

@@ -35,7 +35,7 @@ import {
 import { createRequire } from "node:module";
 import { join } from "node:path";
 import { promisify } from "node:util";
-import { bin } from "@dbx-tools/core";
+import * as bin from "@dbx-tools/core/bin";
 import { find } from "@dbx-tools/path";
 import { log } from "@dbx-tools/shared-core";
 import type * as ts from "typescript";

package/src/packages.ts

@@ -25,14 +25,14 @@
  */
 import { existsSync, readFileSync } from "node:fs";
 import { extname, relative, resolve, sep } from "node:path";
-import { project as coreProject } from "@dbx-tools/core";
+import * as projectUtils from "@dbx-tools/core/project-utils";
 import { find } from "@dbx-tools/path";
-import { json, object, string } from "@dbx-tools/shared-core";
+import { json, object, stringUtils } from "@dbx-tools/shared-core";
 import { parse } from "yaml";
 
 /** Resolve the nearest package/projenrc root at call time. */
 export function resolveRepoRoot(cwd: string = process.cwd()): string {
-  return coreProject.root(cwd) ?? cwd;
+  return projectUtils.root(cwd) ?? cwd;
 }
 
 /** Current-process repository root for executable task entrypoints. */
@@ -47,11 +47,11 @@ export const DEFAULT_PACKAGE_ROOTS = ["packages"] as const;
 /**
  * A project name: the root `package.json` name, else the git remote's repo
  * name, else the root folder name. Delegates to `@dbx-tools/core`'s
- * {@link coreProject.name}, which is also what a consuming repo's own tooling
+ * {@link projectUtils.name}, which is also what a consuming repo's own tooling
  * sees, so the engine and its host agree on the name.
  */
 export function projectName(projectRoot: string = resolveRepoRoot()): string {
-  return coreProject.name(projectRoot);
+  return projectUtils.name(projectRoot);
 }
 
 const MODULE_EXTS = new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
@@ -65,7 +65,7 @@ export function toPosix(p: string): string {
 
 /**
  * Cumulative nesting tags from a package's path segments relative to its discovery
- * root. Each segment is kebab-cased with {@link string.toSlug} (`coolDude` ->
+ * root. Each segment is kebab-cased with {@link stringUtils.toSlug} (`coolDude` ->
  * `cool-dude`). The leaf folder (the package name) is excluded when there are two
  * or more segments; a lone segment tags itself.
  */
@@ -75,7 +75,7 @@ function nestingTagsFromSegments(segments: readonly string[]): string[] {
   const out: string[] = [];
   let acc = "";
   for (const segment of prefix) {
-    const token = string.toSlug(segment);
+    const token = stringUtils.toSlug(segment);
     if (!token) continue;
     acc = acc ? `${acc}-${token}` : token;
     out.push(acc);
@@ -288,7 +288,7 @@ function readManifestTags(dir: string): string[] | undefined {
  */
 export function syncResynthPaths(projectRoot: string = resolveRepoRoot()): string[] {
   const paths = readDbxToolsConfig(projectRoot)?.syncResynthPaths;
-  return Array.isArray(paths) ? string.parseList(paths.map((p) => String(p))) : [];
+  return Array.isArray(paths) ? stringUtils.parseList(paths.map((p) => String(p))) : [];
 }
 
 /**
@@ -322,7 +322,7 @@ export function recordedPackages(projectRoot: string = resolveRepoRoot()): Recor
 export function recordedRoots(projectRoot: string = resolveRepoRoot()): string[] {
   const configured = readDbxToolsConfig(projectRoot)?.packageRoots;
   if (Array.isArray(configured)) {
-    const roots = string.parseList(configured.map((root) => String(root)));
+    const roots = stringUtils.parseList(configured.map((root) => String(root)));
     if (roots.length) return roots;
   }
   const roots = new Set<string>(DEFAULT_PACKAGE_ROOTS);

package/src/pnpm-workspace.ts

@@ -2,7 +2,7 @@
  * Inputs for `pnpm-workspace.yaml`, which projen's NATIVE
  * `javascript.PnpmWorkspaceYaml` owns.
  *
- * projen (>= 0.101.16) writes this file itself: every pnpm `NodeProject` gets a
+ * projen writes this file itself: every pnpm `NodeProject` gets a
  * `PnpmWorkspaceYaml` component typed by `PnpmWorkspaceYamlSchema`, fed from
  * `pnpmOptions.workspaceYamlOptions`. Nothing here writes a file; this only
  * supplies the options object it renders, so the whole pnpm schema (`overrides`,

package/src/project-js.ts

@@ -8,9 +8,9 @@
  */
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
-import { project as coreProject } from "@dbx-tools/core";
+import * as projectUtils from "@dbx-tools/core/project-utils";
 import { ignore, match } from "@dbx-tools/path";
-import { object, string, type OneOrMany } from "@dbx-tools/shared-core";
+import { object, stringUtils, type OneOrMany } from "@dbx-tools/shared-core";
 import { type IConstruct } from "constructs";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { BuildWorkflow } from "projen/lib/build";
@@ -40,6 +40,7 @@ import {
 } from "./packages.ts";
 import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
 import type { DBXToolsProject, DBXToolsProjectOptions as CommonProjectOptions } from "./project.ts";
+import { PROJEN_VERSION } from "./projen-version.ts";
 import { applyCompiledPublish } from "./publish.ts";
 import {
   DBXToolsReleaseCatalog,
@@ -120,17 +121,17 @@ export class PackageIdentifier {
    * `@<first>/<rest joined by ->`.
    *
    * The leading segment is the npm `@scope`, kebab-cased with
-   * {@link string.toSlug} so a multi-word scope survives intact
+   * {@link stringUtils.toSlug} so a multi-word scope survives intact
    * (`dbx-tools` -> `dbx-tools`, not `dbx`/`tools`). Every later path
-   * segment is tokenized with {@link string.tokenize}, so nested folders
+   * segment is tokenized with {@link stringUtils.tokenize}, so nested folders
    * split into their own dash-joined name parts.
    */
   static of(...names: OneOrMany<string>): PackageIdentifier {
     const segments = names.flatMap((part) => part.split("/")).filter(Boolean);
-    const scope = segments.length ? string.toSlug(segments[0]!) : "";
+    const scope = segments.length ? stringUtils.toSlug(segments[0]!) : "";
     const nameParts = [
       scope,
-      ...segments.slice(1).flatMap((segment) => [...string.tokenize(segment)]),
+      ...segments.slice(1).flatMap((segment) => [...stringUtils.tokenize(segment)]),
     ].filter(Boolean);
     if (!nameParts.length) throw new Error(`Invalid name: ${names.join(", ")}`);
     if (nameParts.length === 1) return new PackageIdentifier(undefined, nameParts[0]!);
@@ -154,13 +155,13 @@ function configureRootPackage(project: javascript.NodeProject): void {
  * published source (without it, publish fails with E422). A child also carries the
  * monorepo `directory` subpath (its path relative to the root); the root omits it.
  * No-op when no git remote is detected and no `repository` override was supplied.
- * The URL is auto-detected + cached by {@link coreProject.repositoryUrl} (gh, then
+ * The URL is auto-detected + cached by {@link projectUtils.repositoryUrl} (gh, then
  * a normalized git remote), in npm's `git+https://.../repo.git` form.
  */
 function applyRepository(project: javascript.NodeProject, override?: string): void {
   const workspaceRoot = resolve(project.root.outdir);
   const url =
-    override && override.length ? override : coreProject.repositoryUrl(workspaceRoot, "npm");
+    override && override.length ? override : projectUtils.repositoryUrl(workspaceRoot, "npm");
   if (!url) return;
   const directory = toPosix(relative(workspaceRoot, resolve(project.outdir)));
   project.package.addField("repository", {
@@ -278,7 +279,7 @@ export function projectRepositoryUrl(project: javascript.NodeProject): string |
     typeof repository === "string"
       ? repository
       : object.isRecord(repository)
-        ? (string.trimToNull(repository.url) ?? undefined)
+        ? (stringUtils.trimToNull(repository.url) ?? undefined)
         : undefined;
   return configured?.replace(/^git\+/, "").replace(/\.git$/, "");
 }
@@ -382,14 +383,7 @@ const PRETTIER_SETTINGS: javascript.PrettierSettings = {
   endOfLine: javascript.EndOfLine.LF,
 };
 
-/**
- * The `projen` version every generated manifest pins.
- *
- * Kept as one constant so the root's devDependency and this engine's own
- * dependency can never drift apart - a synth run loads the engine from one copy
- * of projen and the tasks execute against another otherwise.
- */
-export const PROJEN_VERSION = "^0.101.16";
+export { PROJEN_VERSION } from "./projen-version.ts";
 
 /** SPDX license shared by generated JavaScript, Python, and Rust packages. */
 export const DBX_TOOLS_LICENSE = "Apache-2.0";
@@ -412,7 +406,7 @@ function defaultProjectOptions(options: DBXToolsJavaScriptProjectOptions) {
     // phase installs with pnpm - so a deployed app keeps its catalog + build
     // allowances even though the local/CI manager is bun.
     packageManager: javascript.NodePackageManager.BUN,
-    // Pinned rather than left to projen's "latest": 0.101.16 is the first release
+    // Pinned rather than left to projen's "latest": this is the co-tested release
     // whose `NodePackage` renders bun's `trustedDependencies` natively. Under bun,
     // projen does NOT create the `pnpm-workspace.yaml` component itself (that call
     // site is gated to pnpm), so the engine constructs it directly ({@link
@@ -750,7 +744,7 @@ export class DBXToolsNodeProject
     const steps = super.renderWorkflowSetup(options);
     if (this.parent) return steps;
     return steps.flatMap((step) => {
-      if (step.uses === "oven-sh/setup-bun@v2") {
+      if (step.uses?.startsWith("oven-sh/setup-bun@")) {
         return [...bunCacheRestoreSteps(this, { ignorePaths: this.workflowCacheIgnorePaths })];
       }
       if (step.run === "bun install") {
@@ -963,7 +957,7 @@ function configureBuildWorkflow(
                 "!**/package.json",
                 "!**/pyproject.toml",
                 "!**/index.ts",
-                "!packages/js/node/rust-binary/src/_rust-release-binaries.ts",
+                "!packages/js/node/rust-binary/src/_release-binaries.ts",
                 "!packages/js/node/appkit-graphiti/src/_python-runtime.ts",
               ],
             },
@@ -1216,7 +1210,7 @@ const DEFAULT_OMIT_RELATIVE_PREFIX = ["node"];
 function resolveOmitRelativePrefix(option: OneOrMany<string> | undefined): string[] {
   const raw = option === undefined ? DEFAULT_OMIT_RELATIVE_PREFIX : option;
   const list = Array.isArray(raw) ? raw : [raw];
-  return list.map((segment) => string.toSlug(segment)).filter(Boolean);
+  return list.map((segment) => stringUtils.toSlug(segment)).filter(Boolean);
 }
 
 /**
@@ -1226,7 +1220,7 @@ function resolveOmitRelativePrefix(option: OneOrMany<string> | undefined): strin
  */
 function packageNameFor(scope: string, relPath: string, omitPrefixes: string[]): string {
   const segments = relPath.split("/").filter(Boolean);
-  if (segments.length > 1 && omitPrefixes.includes(string.toSlug(segments[0]!))) {
+  if (segments.length > 1 && omitPrefixes.includes(stringUtils.toSlug(segments[0]!))) {
     segments.shift();
   }
   return PackageIdentifier.of(scope, segments.join("/")).packageName;
@@ -1267,14 +1261,14 @@ function engineSelfDependency(project: javascript.NodeProject): string | undefin
   const enginePkgJson = join(resolvePkgRoot(), "package.json");
   if (!toPosix(enginePkgJson).includes("/node_modules/")) return undefined;
   const engine = readPackageManifest(dirname(enginePkgJson));
-  const name = string.trimToNull(engine?.name);
+  const name = stringUtils.trimToNull(engine?.name);
   if (!name) return undefined;
-  const version = string.trimToNull(engine?.version);
+  const version = stringUtils.trimToNull(engine?.version);
 
   // No existing consumer manifest (or no entry) falls through to a computed pin.
   const consumer = readPackageManifest(resolve(project.outdir));
   const dependencyOf = (field: unknown): string | undefined =>
-    object.isRecord(field) ? (string.trimToNull(field[name]) ?? undefined) : undefined;
+    object.isRecord(field) ? (stringUtils.trimToNull(field[name]) ?? undefined) : undefined;
   const existing = dependencyOf(consumer?.devDependencies) ?? dependencyOf(consumer?.dependencies);
   if (existing) return `${name}@${existing}`;
   return `${name}@^${version}`;

package/src/project-py.ts

@@ -1,6 +1,6 @@
 /** Reusable uv workspace generation for Python packages hosted in a projen tree. */
-import { project as coreProject } from "@dbx-tools/core";
-import { string } from "@dbx-tools/shared-core";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { stringUtils } from "@dbx-tools/shared-core";
 import { Component, License, TextFile, type Project, javascript, python, vscode } from "projen";
 import { JobPermission } from "projen/lib/github/workflows-model";
 import { BUN_VERSION, bunCacheRestoreSteps, bunCacheSaveStep } from "./bun-workflow.ts";
@@ -237,12 +237,12 @@ export class DBXToolsPythonWorkspace extends Component {
   constructor(project: javascript.NodeProject, options: DBXToolsPythonWorkspaceOptions) {
     super(project);
     const scope = isDBXToolsJavaScriptProject()(project)
-      ? string.toSlug(project.scope)
-      : string.toSlug(project.name).replace(/-root$/, "");
+      ? stringUtils.toSlug(project.scope)
+      : stringUtils.toSlug(project.name).replace(/-root$/, "");
     const repositoryUrl =
       options.repository?.url ??
       projectRepositoryUrl(project) ??
-      coreProject.repositoryUrl(project.outdir);
+      projectUtils.repositoryUrl(project.outdir);
     if (!repositoryUrl) {
       throw new Error("Python workspace repository URL was not configured or detected");
     }
@@ -253,7 +253,7 @@ export class DBXToolsPythonWorkspace extends Component {
     };
     const packageIdentities: ResolvedPythonPackageOptions[] = options.packages.map((pkg) => ({
       ...pkg,
-      name: pkg.name ?? `${scope}-${string.toSlug(pkg.directory)}`,
+      name: pkg.name ?? `${scope}-${stringUtils.toSlug(pkg.directory)}`,
       module: pkg.module ?? pythonModuleName(scope, pkg.directory),
     }));
     const packagesByDirectory = new Map(packageIdentities.map((pkg) => [pkg.directory, pkg]));