@dbx-tools/projen 0.6.61 → 0.6.63

package/package.json

@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@clack/prompts": "^1.7.0",
-    "@dbx-tools/core": "0.6.61",
-    "@dbx-tools/path": "0.6.61",
-    "@dbx-tools/shared-core": "0.6.61",
+    "@dbx-tools/core": "0.6.63",
+    "@dbx-tools/path": "0.6.63",
+    "@dbx-tools/shared-core": "0.6.63",
     "commander": "^15.0.0",
     "concurrently": "^10.0.3",
     "constructs": "^10.6.0",
@@ -47,7 +47,7 @@
   },
   "main": "index.ts",
   "license": "Apache-2.0",
-  "version": "0.6.61",
+  "version": "0.6.63",
   "types": "index.ts",
   "type": "module",
   "exports": {

package/src/codegen.ts

@@ -46,10 +46,10 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { basename, dirname, join, resolve } from "node:path";
+import { log, object } from "@dbx-tools/shared-core";
 import type * as ts from "typescript";
 import { lazyRequire } from "./_lazy-require.ts";
 import { header, isReadonly, makeReadonly, makeWritable } from "./generated.ts";
-import { log, object } from "@dbx-tools/shared-core";
 import { readPackageManifest, repoRoot, recordedPackages } from "./packages.ts";
 
 const logger = log.logger("projen:codegen");

package/src/dbx-tools-config.ts

@@ -31,11 +31,12 @@ function readDBXToolsConfig(pkg: javascript.NodePackage): Record<string, unknown
 
 function loadConfig(dbxToolsConfig: DBXToolsConfig, pkg: javascript.NodePackage) {
   const { tags, ...config } = readDBXToolsConfig(pkg);
-  if (Array.isArray(tags))
+  if (Array.isArray(tags)) {
     object
       .sequence(tags)
       .filter((v: unknown) => typeof v === "string")
       .forEach((v: string) => dbxToolsConfig.tags.push(v));
+  }
   Object.entries(config).forEach(([key, value]) => {
     dbxToolsConfig[key] = value;
   });

package/src/openapi.ts

@@ -23,11 +23,11 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { createRequire } from "node:module";
 import { join } from "node:path";
-import type * as ts from "typescript";
 import { find } from "@dbx-tools/path";
+import { log } from "@dbx-tools/shared-core";
+import type * as ts from "typescript";
 import { lazyRequire } from "./_lazy-require.ts";
 import { makeReadonly, makeWritable, stampGenerated } from "./generated.ts";
-import { log } from "@dbx-tools/shared-core";
 import {
   type RecordedPackage,
   isModuleFile,

package/src/packages.ts

@@ -26,8 +26,8 @@
 import { existsSync, readFileSync } from "node:fs";
 import { extname, relative, resolve, sep } from "node:path";
 import { project as coreProject } from "@dbx-tools/core";
-import { json, object, string } from "@dbx-tools/shared-core";
 import { find } from "@dbx-tools/path";
+import { json, object, string } from "@dbx-tools/shared-core";
 import { parse } from "yaml";
 
 /**

package/src/project-predicate.ts

@@ -1,3 +1,5 @@
+import { relative } from "node:path";
+import { match, PathMatchInput, PathMatchPredicate } from "@dbx-tools/path";
 import {
   object,
   predicate,
@@ -7,11 +9,9 @@ import {
 } from "@dbx-tools/shared-core";
 import { IConstruct } from "constructs";
 import { Project } from "projen";
-import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project.ts";
-import { toPosix } from "./packages.ts";
-import { relative } from "node:path";
-import { match, PathMatchInput, PathMatchPredicate } from "@dbx-tools/path";
 import { project } from "..";
+import { toPosix } from "./packages.ts";
+import { DBXToolsProject, DBXToolsNodeProject, DBXToolsTypeScriptProject } from "./project.ts";
 
 /**
  * Guard: the construct is a projen {@link Project} - the base every builder here

package/src/project.ts

@@ -6,22 +6,16 @@
  * {@link DBXToolsNodeProject} (monorepo root) and {@link DBXToolsTypeScriptProject}
  * (a package, or a standalone compiling root) both implement {@link DBXToolsProject}.
  */
-import { object, string, type OneOrMany } from "@dbx-tools/shared-core";
-import { ignore, match, PathMatchInput } from "@dbx-tools/path";
-import { project as coreProject } from "@dbx-tools/core";
 import { existsSync, readdirSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import { project as coreProject } from "@dbx-tools/core";
+import { ignore, match, PathMatchInput } from "@dbx-tools/path";
+import { object, string, type OneOrMany } from "@dbx-tools/shared-core";
+import { IConstruct } from "constructs";
 import { Component, IgnoreFile, Project, type TaskOptions, javascript, typescript } from "projen";
 import { ReleaseTrigger } from "projen/lib/release";
+import { mixin, projectPredicate } from "..";
 import { generateBarrels } from "./barrels.ts";
-import { codegenModulePaths, generateCodegen } from "./codegen.ts";
-import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
-import { resolvePkgRoot } from "./engine-root.ts";
-import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
-import { applyCompiledPublish } from "./publish.ts";
-import { DBXToolsRelease, type StandaloneRelease } from "./release.ts";
-import { AGNOSTIC_COMPILER_OPTIONS, PACKAGE_TAG_MIXINS, type PackageTag } from "./tags.ts";
-import { DBXToolsRootTsconfig } from "./tsconfig.ts";
 import {
   BUN_APP_OVERRIDES,
   BunBuildFile,
@@ -29,7 +23,9 @@ import {
   BunfigFile,
   RootBunfigFile,
 } from "./bun-app.ts";
-import { DBXToolsVsCode } from "./vscode.ts";
+import { codegenModulePaths, generateCodegen } from "./codegen.ts";
+import { DBXToolsConfig, type DBXToolsConfigOptions } from "./dbx-tools-config.ts";
+import { resolvePkgRoot } from "./engine-root.ts";
 import {
   DEFAULT_PACKAGE_ROOTS,
   type DiscoveredPackage,
@@ -39,8 +35,12 @@ import {
   scanPackages,
   toPosix,
 } from "./packages.ts";
-import { mixin, projectPredicate } from "..";
-import { IConstruct } from "constructs";
+import { PnpmWorkspaceState, type DBXToolsPNPMWorkspaceOptions } from "./pnpm-workspace.ts";
+import { applyCompiledPublish } from "./publish.ts";
+import { DBXToolsRelease, type StandaloneRelease } 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";
 
 /**
  * The dbx-tools project surface, backed by projen's Node toolchain. A single
@@ -953,14 +953,20 @@ function initProject(
   // each file to its own package tsconfig (so type-aware rules work tree-wide), and
   // `import/no-extraneous-dependencies` still checks each file against its nearest
   // package.json. Formatting defers to the root Prettier to avoid rule/formatter
-  // conflicts (e.g. quote style). Spawned from `test`, so ignorePatterns must cover
-  // every read-only generated path - `--fix` EACCES-crashes on them otherwise.
+  // conflicts (e.g. quote style). The normal task is check-only so CI never
+  // repairs the worktree it is meant to validate; `eslint:fix` is the explicit
+  // local mutation path.
   const eslint = new javascript.Eslint(project, {
-    dirs: [...roots],
+    dirs: [...roots, "projen"],
     fileExtensions: [".ts", ".tsx"],
     projectService: true,
     prettier: Boolean(project.prettier),
     tsconfigPath: "./tsconfig.json",
+    commandOptions: { fix: false },
+  });
+  project.addTask("eslint:fix", {
+    description: "Fix ESLint issues across the codebase",
+    exec: "bun run eslint -- --fix",
   });
   // Generated read-only outputs (barrels, openapi clients, app scripts, codegen).
   // ESLint --fix cannot rewrite them; they are stamped by the barrel generator /
@@ -969,6 +975,7 @@ function initProject(
     eslint.addIgnorePattern(`${root}/openapi/**`);
     eslint.addIgnorePattern(`${root}/**/index.ts`);
   }
+  eslint.addIgnorePattern("projen/index.ts");
   // The generated bun app scripts + unmanaged overrides live at the package root,
   // outside any `src/**` tsconfig include, so the type-aware parser cannot resolve
   // them to a project. ESLint still cannot parse them.
@@ -1242,21 +1249,24 @@ export function applyToProjects<P extends Project>(
   let pred = projectPredicate.isProject();
   if (!options?.includeNonDBXToolsProjects) pred = pred.and(projectPredicate.isDBXToolsProject());
   if (!options?.includeRoots) pred = pred.and((p) => p.parent != null);
-  if (options?.identifierPackageName)
+  if (options?.identifierPackageName) {
     pred = pred.and(
       projectPredicate.hasIdentifierPackageName(
         ...object.toOneOrMany(options.identifierPackageName),
       ),
     );
+  }
   if (options?.name) pred = pred.and(projectPredicate.hasName(...object.toOneOrMany(options.name)));
-  if (options?.identifierScope)
+  if (options?.identifierScope) {
     pred = pred.and(
       projectPredicate.hasIdentifierScope(...object.toOneOrMany(options.identifierScope)),
     );
-  if (options?.identifierName)
+  }
+  if (options?.identifierName) {
     pred = pred.and(
       projectPredicate.hasIdentifierName(...object.toOneOrMany(options.identifierName)),
     );
+  }
   if (options?.tags) pred = pred.and(projectPredicate.hasTag(...object.toOneOrMany(options.tags)));
   if (options?.path) pred = pred.and(projectPredicate.hasPath(...object.toOneOrMany(options.path)));
   const projectMixin = mixin.create(pred, (p) => {

package/src/publish.ts

@@ -29,8 +29,8 @@
  */
 import type { javascript } from "projen";
 import { typescript } from "projen";
-import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
 import { isDBXToolsProject } from "./project-predicate.ts";
+import { addPackageFiles, applyCompilerOptions, applyIncludes } from "./project.ts";
 
 /** Directory `tsc` emits into, and the root of every published entry point. */
 export const COMPILED_DIR = "lib";

package/src/tags.ts

@@ -17,6 +17,7 @@ import type { IMixin as ConstructsMixin } from "constructs";
 import { javascript } from "projen";
 import { BunBuildFile, BunDevServerFile, BunfigFile } from "./bun-app.ts";
 import { create } from "./mixin.ts";
+import * as projectPredicate from "./project-predicate.ts";
 import {
   addPackageFiles,
   applyCompilerOptions,
@@ -25,7 +26,6 @@ import {
   applyTasks,
   srcModuleExports,
 } from "./project.ts";
-import * as projectPredicate from "./project-predicate.ts";
 
 /** Node compiler options: ES2022 lib + node types, deliberately no DOM. */
 const NODE_COMPILER_OPTIONS: javascript.TypeScriptCompilerOptions = {
@@ -137,7 +137,7 @@ export const PACKAGE_TAG_MIXINS = {
     // register and no launcher shim to generate. In a WORKSPACE checkout the
     // manifest still points at the `.ts` entry, which Node type-strips on its own
     // because the package is not under `node_modules`.
-    p.addDeps("commander@catalog:", "@clack/prompts@catalog:");
+    p.addDeps("commander@catalog:");
     p.addDevDeps("@types/node@catalog:");
     // A CLI compiles code OUTSIDE `src/` - its root `index.ts` barrel and the
     // `bin/` entries - which the src-only tag default doesn't reach.

package/tasks/barrels.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
 import { sep } from "node:path";
-import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
-import { watchLoop, watchRoots } from "../src/watch.ts";
+import { generateBarrels } from "../src/barrels.ts";
 import { recordedPackages } from "../src/packages.ts";
+import { watchLoop, watchRoots } from "../src/watch.ts";
 
 const logger = log.logger("projen:barrels");
 

package/tasks/bump.ts

@@ -39,12 +39,12 @@
  *   - `false`: never publish locally.
  *   - a URL: always publish to that registry.
  */
-import { exec, project } from "@dbx-tools/core";
-import { log, net } from "@dbx-tools/shared-core";
-import { Command, Option } from "commander";
 import { chmodSync, existsSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { exec, project } from "@dbx-tools/core";
+import { log, net } from "@dbx-tools/shared-core";
+import { Command, Option } from "commander";
 
 const logger = log.logger("projen:bump");
 const LEVELS = ["patch", "minor", "major"] as const;
@@ -294,9 +294,11 @@ program
         // keep `0.0.0` on disk, projen-owned, so it unlocks each briefly), then
         // `bun publish`es each non-private one - and bun natively strips the
         // `workspace:`/`catalog:` protocols in the packed tarball, resolving each
-        // to the version just set. The next `projen` synth restores the manifests
-        // to `0.0.0`; the release version lives in the git tag. Provenance is off
-        // for a local registry (no OIDC), so `NPM_CONFIG_PROVENANCE` is unset.
+        // to the version just set. `publish.ts` restores every manifest it touched
+        // at exit, so this leaves the worktree matching the release commit that was
+        // just pushed - the release version lives in the git tag, not on disk.
+        // Provenance is off for a local registry (no OIDC), so
+        // `NPM_CONFIG_PROVENANCE` is unset.
         // `publish.ts` is this task's SIBLING in the engine's `tasks/` dir; resolve
         // it off `import.meta.url` (works whether the engine is source-linked in-repo
         // or installed under node_modules) rather than a repo-relative `tasks/...`

package/tasks/clean.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 import { relative } from "node:path";
-import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { log, string } from "@dbx-tools/shared-core";
+import { listGeneratedFiles, listNodeModulesDirs, removePaths } from "../src/clean.ts";
 import { repoRoot, toPosix } from "../src/packages.ts";
 
 const logger = log.logger("projen:clean");

package/tasks/openapi.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env -S bun
-import { generateBarrels } from "../src/barrels.ts";
 import { log, string } from "@dbx-tools/shared-core";
+import { generateBarrels } from "../src/barrels.ts";
 import { generateOpenapi, isTsoaController } from "../src/openapi.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { watchLoop, watchRoots } from "../src/watch.ts";

package/tasks/projenrc.ts

@@ -1,9 +1,9 @@
 #!/usr/bin/env -S bun
 import { resolve } from "node:path";
 import { log } from "@dbx-tools/shared-core";
+import { repoRoot, syncResynthPaths } from "../src/packages.ts";
 import { runSynth } from "../src/scaffold.ts";
 import { watchLoop } from "../src/watch.ts";
-import { repoRoot, syncResynthPaths } from "../src/packages.ts";
 
 const logger = log.logger("projen:projenrc");
 

package/tasks/publish.ts

@@ -37,9 +37,15 @@
  * repo-relative) skips a member that releases on its OWN tag namespace (e.g.
  * `projen`, published by `projen-release`, not the main `release`).
  *
+ * `--no-restore` keeps the edits on disk instead of undoing them at exit. Only
+ * needed when a LATER process must still see them - `--stamp-only` implies it,
+ * since its whole job is to stamp the workspace for a `bun publish` that runs
+ * afterwards from another directory.
+ *
  * The disk manifests normally carry `version: 0.0.0` (projen owns them, read-only);
- * this unlocks each only long enough to set the version + publish. The next
- * `projen` synth restores them - the release version lives in the git tag.
+ * this unlocks each only long enough to set the version + publish, then RESTORES
+ * every one it touched byte-for-byte (and re-locks the mode) on the way out - see
+ * {@link restoreManifests}. The release version lives in the git tag, not on disk.
  */
 import { chmodSync, existsSync, readFileSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
@@ -49,6 +55,29 @@ import { parse } from "yaml";
 
 const logger = log.logger("dbx-tools:publish");
 
+/** A manifest's on-disk bytes + mode, captured before this task edits it. */
+interface ManifestBackup {
+  readonly content: string;
+  readonly mode: number;
+}
+
+/**
+ * Original state of every manifest this task has unlocked, keyed by path.
+ *
+ * Publishing has to mutate manifests projen owns (the version stamp, so a
+ * `workspace:*` sibling resolves to the release version, and the `publishConfig`
+ * entry-point substitution bun won't do itself). Those edits are only ever meant
+ * to reach the packed TARBALL, so every one is undone by {@link restoreManifests}
+ * before the process ends.
+ *
+ * Leaving them on disk is what used to strand a local `bun run bump` with ~34
+ * modified `package.json` files - version stamps and `lib/` entry points - after
+ * the release commit was already made, so the tree diverged from the commit that
+ * was just pushed and every subsequent `git status` needed a manual revert. CI
+ * never noticed because a fresh checkout is discarded.
+ */
+const manifestBackups = new Map<string, ManifestBackup>();
+
 /**
  * Workspace member dirs (absolute), read from the root `pnpm-workspace.yaml` - the
  * file the engine keeps for the Databricks Apps pnpm deploy, which also lists every
@@ -74,9 +103,43 @@ function run(cwd: string, command: string, args: string[], path: string): void {
   });
 }
 
-/** Make a projen-readonly manifest writable so `bun pm pkg set` / `bun publish` can edit it. */
+/**
+ * Make a projen-readonly manifest writable so `bun pm pkg set` / `bun publish` can
+ * edit it, recording its original bytes + mode for {@link restoreManifests} the
+ * first time it is seen. Idempotent, so a manifest unlocked twice (version stamp,
+ * then `publishConfig`) keeps its PRE-EDIT backup rather than overwriting it with
+ * the already-stamped content.
+ */
 function unlockManifest(pkgPath: string): void {
-  chmodSync(pkgPath, statSync(pkgPath).mode | 0o200);
+  const mode = statSync(pkgPath).mode;
+  if (!manifestBackups.has(pkgPath)) {
+    manifestBackups.set(pkgPath, { content: readFileSync(pkgPath, "utf8"), mode });
+  }
+  chmodSync(pkgPath, mode | 0o200);
+}
+
+/**
+ * Put every manifest this task edited back exactly as it was found, mode included.
+ *
+ * Runs from an `exit` handler so a clean finish and a failure partway through the
+ * publish loop are covered alike - a `bun publish` that dies on package 12 of 34
+ * must not leave the first 11 stamped. Best-effort per file: one unwritable
+ * manifest is logged and the rest are still restored, since a partial restore
+ * beats none.
+ *
+ * Not registered under `--stamp-only`, where the stamps ARE the deliverable.
+ */
+function restoreManifests(): void {
+  for (const [pkgPath, backup] of manifestBackups) {
+    try {
+      chmodSync(pkgPath, backup.mode | 0o200);
+      writeFileSync(pkgPath, backup.content);
+      chmodSync(pkgPath, backup.mode);
+    } catch (cause) {
+      logger.warn(`could not restore ${pkgPath}`, { cause });
+    }
+  }
+  manifestBackups.clear();
 }
 
 /** Entry-point fields projen writes as `.ts` source in-repo and rewrites to `lib/` for publish. */
@@ -87,8 +150,9 @@ const PUBLISH_CONFIG_ENTRY_FIELDS = ["main", "types", "bin", "exports"] as const
  * the way pnpm/npm do at pack time but `bun publish` does NOT (see the module
  * doc). Idempotent, writes only when something changes, and leaves `publishConfig`
  * in place (npm ignores it once the top-level fields already point at `lib/`). The
- * manifest must already be unlocked. The next `projen` synth restores the `.ts`
- * entry points, so this only affects the packed tarball - like the version stamp.
+ * manifest must already be unlocked. {@link restoreManifests} puts the `.ts` entry
+ * points back at exit, so this only ever affects the packed tarball - like the
+ * version stamp.
  */
 function applyPublishConfig(pkgPath: string): void {
   const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as Record<string, unknown>;
@@ -133,12 +197,19 @@ const dryRun = rest.includes("--dry-run");
 // own `bun publish` (run separately, in `projen/`) resolves `workspace:*` siblings
 // to the release version; publishing every member here would double-publish them.
 const stampOnly = rest.includes("--stamp-only");
+// Undo the manifest edits at exit unless a later process still needs them. Implied
+// off by `--stamp-only`, whose stamps exist precisely for a subsequent `bun publish`.
+const restore = !stampOnly && !rest.includes("--no-restore");
 const excluded = new Set(
   rest.reduce<string[]>((acc, arg, i) => (arg === "--exclude" ? [...acc, rest[i + 1]] : acc), []),
 );
 
 const root = process.cwd();
 const path = enrichedPath(root);
+// Registered BEFORE the first manifest edit so no exit path can skip it: a clean
+// finish and a `bun publish` failure mid-loop both land here, so a publish that
+// dies partway does not leave half the workspace stamped.
+if (restore) process.on("exit", restoreManifests);
 const members = workspaceMembers(root)
   .filter((dir) => existsSync(join(dir, "package.json")))
   .filter((dir) => !excluded.has(resolve(root, dir).replace(`${resolve(root)}/`, "")));

package/tasks/sync.ts

@@ -1,7 +1,7 @@
 #!/usr/bin/env -S bun
 import { fileURLToPath } from "node:url";
-import concurrently from "concurrently";
 import { log } from "@dbx-tools/shared-core";
+import concurrently from "concurrently";
 import { runSynth } from "../src/scaffold.ts";
 
 const logger = log.logger("projen:sync");