@databricks-solutions/lakebase-scm-utils 0.2.51 → 0.3.1

package/dist/scripts/util/index.cjs

@@ -1667,8 +1667,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.2.51".length > 0) {
-    cached = "0.2.51";
+  if ("0.3.1".length > 0) {
+    cached = "0.3.1";
     return cached;
   }
   cached = "unknown";

package/dist/scripts/util/index.js

@@ -1630,8 +1630,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.2.51".length > 0) {
-    cached = "0.2.51";
+  if ("0.3.1".length > 0) {
+    cached = "0.3.1";
     return cached;
   }
   cached = "unknown";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@databricks-solutions/lakebase-scm-utils",
-  "version": "0.2.51",
+  "version": "0.3.1",
   "description": "Lakebase SCM + substrate engine: database branching, paired-branch SCM workflows, connection/credential minting, schema migration, project scaffold + deploy primitives, and the git/github utility layer. Extracted from consort for portable, standalone consumption by lakebase-scm-extension and the SFTDD orchestration.",
   "type": "module",
   "private": false,

package/scripts/lakebase/adapters/efcore-adapter.ts

@@ -0,0 +1,158 @@
+// EfCoreAdapter: SchemaMigrationAdapter implementation for .NET projects
+// using EF Core migrations.
+//
+// Wraps scripts/lakebase/schema-migrate-runners/efcore.ts in the cross-tool
+// adapter contract from ADR-0005. Supports rollback (EF generates Down()) and
+// stamp (writes "__EFMigrationsHistory" rows without running migrations).
+// collapseHeads is omitted: EF history is linear (flat-list, like Flyway).
+
+import * as path from "node:path";
+
+import { getConnection } from "../get-connection.js";
+import { findEfCoreProject, isDotnetProject } from "../dotnet-project.js";
+import {
+  applyEfcore,
+  createEfcoreMigration,
+  efDescription,
+  efVersion,
+  localEfMigrationIds,
+  rollbackEfcore,
+  stampEfcore,
+  statusEfcore,
+} from "../schema-migrate-runners/efcore.js";
+import type { AppliedSchemaMigration, PendingSchemaMigration, SchemaMigrationFile } from "../schema-migrate.js";
+import {
+  registerSchemaMigrationAdapter,
+  type ApplyArgs,
+  type ApplyResult,
+  type ListArgs,
+  type ListResult,
+  type NewMigrationArgs,
+  type NewMigrationResult,
+  type RollbackArgs,
+  type RollbackResult,
+  type SchemaMigrationAdapter,
+  type StampArgs,
+  type StampResult,
+  type StatusArgs,
+  type StatusResult,
+} from "../schema-migration-adapter.js";
+
+async function buildDsn(args: {
+  instance: string;
+  branch: string;
+  database?: string;
+  endpointName?: string;
+}): Promise<string> {
+  const result = await getConnection({
+    output: "dsn",
+    instance: args.instance,
+    branch: args.branch,
+    database: args.database,
+    endpointName: args.endpointName,
+  });
+  return result.url;
+}
+
+function errMsg(err: unknown): string {
+  return err instanceof Error ? err.message : String(err);
+}
+
+/** Migration files in apply order: Migrations/<timestamp>_<Name>.cs (not .Designer.cs / the snapshot). */
+export function listEfCoreFiles(projectDir: string): SchemaMigrationFile[] {
+  return localEfMigrationIds(projectDir).map((id) => ({
+    version: efVersion(id),
+    filename: `${id}.cs`,
+    description: efDescription(id),
+    type: "CSharp" as const,
+    tool: "efcore" as const,
+  }));
+}
+
+export const EfCoreAdapter: SchemaMigrationAdapter = {
+  id: "efcore",
+  languages: ["dotnet"],
+
+  /** A .NET project (root marker) with a *.csproj that references Microsoft.EntityFrameworkCore.Design. */
+  detect(projectDir: string): boolean {
+    return isDotnetProject(projectDir) && findEfCoreProject(projectDir) !== null;
+  },
+
+  async apply(args: ApplyArgs): Promise<ApplyResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const r = await applyEfcore({ projectDir: args.projectDir, dsn });
+      return {
+        applied_migrations: r.applied,
+        status: r.alreadyAtLatest ? "noop" : "ok",
+        tool_specific: { alreadyAtLatest: r.alreadyAtLatest, tool: r.tool },
+      };
+    } catch (err) {
+      return { applied_migrations: [], status: "error", error: errMsg(err) };
+    }
+  },
+
+  async rollback(args: RollbackArgs): Promise<RollbackResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const r = await rollbackEfcore({ projectDir: args.projectDir, dsn, target: args.target });
+      return {
+        rolled_back: r.rolledBack as AppliedSchemaMigration[],
+        status: r.rolledBack.length === 0 ? "noop" : "ok",
+        tool_specific: { tool: r.tool },
+      };
+    } catch (err) {
+      return { rolled_back: [], status: "error", error: errMsg(err) };
+    }
+  },
+
+  async stamp(args: StampArgs): Promise<StampResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const stamped = await stampEfcore({ projectDir: args.projectDir, dsn, revision: args.revision });
+      return { status: "ok", stamped_revision: stamped, tool_specific: { tool: "efcore" } };
+    } catch (err) {
+      return { status: "error", stamped_revision: null, error: errMsg(err) };
+    }
+  },
+
+  async status(args: StatusArgs): Promise<StatusResult> {
+    try {
+      const dsn = await buildDsn(args);
+      const r = await statusEfcore({ projectDir: args.projectDir, dsn });
+      return {
+        applied_version: r.current ?? null,
+        pending: r.pending as PendingSchemaMigration[],
+        applied: [],
+        status: "ok",
+        tool_specific: { tool: r.tool },
+      };
+    } catch (err) {
+      return { applied_version: null, pending: [], applied: [], status: "error", error: errMsg(err) };
+    }
+  },
+
+  async list(args: ListArgs): Promise<ListResult> {
+    return { files: listEfCoreFiles(args.projectDir) };
+  },
+
+  // baseline: use stamp (EF has no separate baseline concept).
+
+  async newMigration(args: NewMigrationArgs): Promise<NewMigrationResult> {
+    // `dotnet ef migrations add` always generates from the model diff, so
+    // autogenerate is implicit and needs no database connection.
+    try {
+      const created = await createEfcoreMigration({ projectDir: args.projectDir, slug: args.slug });
+      return {
+        status: "ok",
+        version: efVersion(created.id),
+        filename: path.basename(created.path),
+        path: created.path,
+      };
+    } catch (err) {
+      return { status: "error", version: "", filename: "", path: "", error: errMsg(err) };
+    }
+  },
+};
+
+registerSchemaMigrationAdapter(EfCoreAdapter);

package/scripts/lakebase/adapters/flyway-adapter.ts

@@ -14,6 +14,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 
 import { getConnection } from "../get-connection.js";
+import { flywayMigrationsDir, isDotnetFlywayProject } from "../dotnet-project.js";
 import {
   applyFlyway,
   statusFlyway,
@@ -55,8 +56,9 @@ async function buildDsn(args: {
 }
 
 function listFlywayFiles(projectDir: string): SchemaMigrationFile[] {
-  // Flyway convention: src/main/resources/db/migration/V<n>__<desc>.sql
-  const dir = path.join(projectDir, "src", "main", "resources", "db", "migration");
+  // Flyway convention: V<n>__<desc>.sql under the Maven layout (Java/Kotlin)
+  // or db/migrations/ (.NET); see flywayMigrationsDir.
+  const dir = flywayMigrationsDir(projectDir);
   if (!fs.existsSync(dir)) return [];
   const files = fs.readdirSync(dir).filter((f) => /^V\d+(\.\d+)*__.+\.sql$/.test(f));
   return files
@@ -83,10 +85,11 @@ function versionCompare(a: string, b: string): number {
 
 export const FlywayAdapter: SchemaMigrationAdapter = {
   id: "flyway",
-  languages: ["java", "kotlin"],
+  languages: ["java", "kotlin", "dotnet"],
 
   detect(projectDir: string): boolean {
-    return fs.existsSync(path.join(projectDir, "pom.xml"));
+    // Maven project, or a .NET project that keeps Flyway SQL in db/migrations/.
+    return fs.existsSync(path.join(projectDir, "pom.xml")) || isDotnetFlywayProject(projectDir);
   },
 
   async apply(args: ApplyArgs): Promise<ApplyResult> {
@@ -155,7 +158,7 @@ export const FlywayAdapter: SchemaMigrationAdapter = {
     // so a flat Flyway list never collides across sibling branches. Flyway has
     // no DAG, so no merge-time head collapse is needed. autogenerate is ignored.
     try {
-      const dir = path.join(args.projectDir, "src", "main", "resources", "db", "migration");
+      const dir = flywayMigrationsDir(args.projectDir);
       fs.mkdirSync(dir, { recursive: true });
       const version = migrationTimestamp();
       const slug = migrationSlug(args.slug);

package/scripts/lakebase/client-lockfile.ts

@@ -0,0 +1,102 @@
+// Generate + normalize the client's package-lock.json at scaffold time, so a
+// scaffolded UI project ships a COMMITTED lockfile that resolves from the
+// public npm registry.
+//
+// WHY: createProject writes the client template + wires Playwright but never
+// runs `npm install` in client/, so no package-lock.json exists at the initial
+// commit. The user had to generate it by hand (README: `cd client && npm
+// install`), and when they did it on the Databricks network the lock pinned
+// npm-proxy.cloud.databricks.com in its `resolved` URLs — which hangs a cold
+// install off-network (the lockfile-registry-guard hazard: the proxy host
+// resolves but never accepts a TCP connection off the Databricks network).
+//
+// WHAT: `npm install --package-lock-only` resolves the dep tree and writes
+// client/package-lock.json WITHOUT installing node_modules (fast, no tarball
+// downloads), then we host-swap any Databricks-proxy `resolved` host to
+// registry.npmjs.org (integrity hashes are unchanged — the proxy is a
+// passthrough mirror of the same tarballs). The scaffold's `git add -A` initial
+// commit then picks the normalized lock up for free.
+//
+// Non-fatal: a resolve failure (offline, registry down) is a warning, not a
+// create abort — the user can still `cd client && npm install` as before.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { exec } from "../util/exec.js";
+import { withProxyEnv } from "../util/proxy-env.js";
+
+/** The Databricks npm proxy host a cold off-network install hangs on. */
+const PROXY_HOST = "npm-proxy.cloud.databricks.com";
+/** The public registry every tracked lockfile must resolve from. */
+const PUBLIC_HOST = "registry.npmjs.org";
+
+export interface EnsureClientLockfileArgs {
+  /** The project root (the client dir lives at <projectDir>/<clientDir>). */
+  projectDir: string;
+  /** The client dir name under projectDir. Default "client". */
+  clientDir?: string;
+}
+
+export interface EnsureClientLockfileResult {
+  /** True when a package-lock.json exists in the client dir after this ran. */
+  generated: boolean;
+  /** Count of proxy-host `resolved` URLs rewritten to the public registry. */
+  swaps: number;
+  /** Why it did not run / generate (no client package.json, exec error). */
+  reason?: string;
+}
+
+/**
+ * Host-swap any Databricks-proxy `resolved` URL to the public registry. A pure
+ * string substitution — integrity hashes are left untouched because the proxy
+ * is a passthrough mirror of the same tarballs. Returns the rewritten text and
+ * the number of swaps.
+ */
+export function normalizeLockfileRegistry(lockText: string): { text: string; swaps: number } {
+  let swaps = 0;
+  const text = lockText.replace(new RegExp(PROXY_HOST.replace(/\./g, "\\."), "g"), () => {
+    swaps++;
+    return PUBLIC_HOST;
+  });
+  return { text, swaps };
+}
+
+/**
+ * For a UI project, generate client/package-lock.json (lock only, no install)
+ * and normalize its registry host. Idempotent, non-fatal: callers push the
+ * reason onto their warnings and continue.
+ */
+export async function ensureClientLockfile(
+  args: EnsureClientLockfileArgs,
+): Promise<EnsureClientLockfileResult> {
+  const clientDir = path.join(args.projectDir, args.clientDir ?? "client");
+  const pkg = path.join(clientDir, "package.json");
+  if (!fs.existsSync(pkg)) {
+    return { generated: false, swaps: 0, reason: "no client package.json" };
+  }
+  const lockPath = path.join(clientDir, "package-lock.json");
+  try {
+    // --package-lock-only resolves the dep tree + writes the lock, skipping
+    // node_modules (no tarball downloads), so the scaffold stays fast.
+    await exec("npm install --package-lock-only", {
+      cwd: clientDir,
+      env: withProxyEnv(),
+      timeout: 180_000,
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { generated: fs.existsSync(lockPath), swaps: 0, reason: `npm resolve failed: ${msg}` };
+  }
+  if (!fs.existsSync(lockPath)) {
+    return { generated: false, swaps: 0, reason: "npm wrote no package-lock.json" };
+  }
+  // Normalize proxy -> public registry so a cold off-network install never hangs.
+  try {
+    const { text, swaps } = normalizeLockfileRegistry(fs.readFileSync(lockPath, "utf8"));
+    if (swaps > 0) fs.writeFileSync(lockPath, text);
+    return { generated: true, swaps };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { generated: true, swaps: 0, reason: `lock normalize failed: ${msg}` };
+  }
+}

package/scripts/lakebase/collapse-heads.cli.ts

@@ -67,7 +67,7 @@ Usage:
 
 Flags:
   --project-dir <dir>  Project root (default: cwd)
-  --language <lang>    java | kotlin | python | nodejs (default: auto-detect)
+  --language <lang>    java | kotlin | python | nodejs | dotnet (default: auto-detect)
   --message, -m <txt>  Message for the merge revision (Alembic; default: "merge heads")
   --dry-run            Report the heads without creating a merge revision
   --pretty             Pretty-print JSON output

package/scripts/lakebase/create-project.ts

@@ -28,6 +28,7 @@ import { scaffoldAll, substrateVersion } from "./scaffold.js";
 import type { ClientFramework } from "./scaffold-language.js";
 import { createLongRunningBranch } from "./long-running-branch.js";
 import { enableE2eForProject } from "./enable-e2e.js";
+import { ensureClientLockfile } from "./client-lockfile.js";
 import { enableInfraForProject } from "./enable-infra.js";
 import { setupRunner } from "./runner-setup.js";
 import { syncCiSecrets, missingCiSecrets } from "../util/ci-secrets.js";
@@ -54,7 +55,7 @@ export interface ConsortSetupHooks {
       agentModels?: Record<string, string>;
       uiTrack?: boolean;
       clientFramework?: string;
-      language?: "java" | "kotlin" | "python" | "nodejs";
+      language?: "java" | "kotlin" | "python" | "nodejs" | "dotnet";
     },
   ): void;
 }
@@ -77,7 +78,9 @@ export interface CreateProjectArgs {
   /** Whether to make the GitHub repo private (default: true). */
   privateRepo?: boolean;
   /** Project language stack (default: 'java'). */
-  language?: "java" | "kotlin" | "python" | "nodejs";
+  language?: "java" | "kotlin" | "python" | "nodejs" | "dotnet";
+  /** .NET only: migration tool, "efcore" (default) or "flyway". */
+  migrationTool?: "efcore" | "flyway";
   /** CI runner type (default: 'self-hosted'). */
   runnerType?: "self-hosted" | "github-hosted";
   /**
@@ -365,6 +368,7 @@ export async function createProject(
     databricksHost: host,
     lakebaseProjectId,
     language,
+    migrationTool: input.migrationTool,
     runnerType,
     skipCommands,
     clientFramework,
@@ -581,8 +585,27 @@ export async function createProject(
     kotlin: "Kotlin/Spring Boot",
     python: "Python/FastAPI",
     nodejs: "Node.js/Express",
+    dotnet: `.NET/ASP.NET Core (${input.migrationTool === "flyway" ? "Flyway" : "EF Core"})`,
   };
   const langLabel = langLabels[language] ?? language;
+
+  // ── Step 7f: client lockfile (UI projects) ───────────────────
+  // Generate + registry-normalize client/package-lock.json BEFORE the commit so
+  // `git add -A` tracks it. Without this the scaffold ships no client lock, and
+  // the user's hand-generated one (made on the Databricks network) pins the npm
+  // proxy and hangs a cold off-network install. Non-fatal: warn + continue.
+  if (clientFramework !== "none") {
+    report("Generating client package-lock.json (registry-normalized)...");
+    const lock = await ensureClientLockfile({ projectDir });
+    if (lock.generated) {
+      report(`  wrote client/package-lock.json${lock.swaps > 0 ? ` (normalized ${lock.swaps} proxy URL(s) to the public registry)` : ""}`);
+    } else {
+      const m = `Could not generate client/package-lock.json (${lock.reason ?? "unknown"}). Generate it with: (cd client && npm install) — the lock is committed on first push.`;
+      warnings.push(m);
+      report(`WARNING: ${m}`);
+    }
+  }
+
   report("Creating initial commit...");
   await commitAndPush({
     projectDir,

package/scripts/lakebase/detect-language.cli.ts

@@ -3,7 +3,7 @@
 // pr.yml + merge.yml to populate `steps.detect-lang.outputs.lang` without
 // duplicating the detection bash inline.
 //
-// Output: prints "java" | "python" | "nodejs" to stdout. Exits non-zero
+// Output: prints "java" | "kotlin" | "python" | "nodejs" | "dotnet" to stdout. Exits non-zero
 // if no recognised marker file is present.
 //
 // Optional flag: --project-dir <path> (defaults to cwd).
@@ -38,7 +38,7 @@ function printHelpAndExit(): never {
     `lakebase-detect-language – print the project's language\n\n` +
       `Usage:\n` +
       `  lakebase-detect-language [--project-dir <path>]\n\n` +
-      `Output (stdout): one of "java", "python", "nodejs"\n` +
+      `Output (stdout): one of "java", "kotlin", "python", "nodejs", "dotnet"\n` +
       `Exits 1 with an error message on stderr if no marker found.\n`,
   );
   process.exit(0);

package/scripts/lakebase/doctor.ts

@@ -285,6 +285,33 @@ async function checkPrereq(
   };
 }
 
+/** .NET SDK floor for `dotnet` projects (the scaffold targets net10.0). */
+const DOTNET_PREREQ: PrereqSpec = {
+  name: "dotnet-sdk",
+  cmd: "dotnet",
+  versionArgs: ["--version"],
+  minMajor: 10,
+  label: ".NET SDK",
+  hint: "Install the .NET 10 SDK (e.g. `brew install --cask dotnet-sdk` or https://dot.net). EF Core's dotnet-ef is restored per project from .config/dotnet-tools.json.",
+};
+
+/**
+ * Language-gated prerequisites: checked only when the project is that
+ * language, so a Java or Python user never sees a missing-.NET failure.
+ */
+export async function checkLanguagePrerequisites(
+  projectDir: string,
+  run: VersionRunner = defaultVersionRunner
+): Promise<CheckResult[]> {
+  let lang: string;
+  try {
+    lang = detectLanguage(projectDir);
+  } catch {
+    return [];
+  }
+  return lang === "dotnet" ? [await checkPrereq(DOTNET_PREREQ, run)] : [];
+}
+
 /** All cold-start prerequisite checks, in README order. */
 export async function checkPrerequisites(
   run: VersionRunner = defaultVersionRunner
@@ -712,6 +739,7 @@ export async function runDoctor(args: DoctorArgs = {}): Promise<DoctorReport> {
   // Cold-start prerequisites (Node/Python/JDK/gh/npm): always run, they are
   // local-environment checks with no auth dependency.
   const prereqs = await checkPrerequisites();
+  const languagePrereqs = await checkLanguagePrerequisites(projectDir);
 
   // Lakebase-enabled probe: needs a reachable workspace, so gate on auth like
   // the identity + lakebase-project checks.
@@ -727,6 +755,7 @@ export async function runDoctor(args: DoctorArgs = {}): Promise<DoctorReport> {
   const checks: CheckResult[] = [
     cli,
     ...prereqs,
+    ...languagePrereqs,
     auth,
     identity,
     lakebaseEnabled,

package/scripts/lakebase/dotnet-project.ts

@@ -0,0 +1,112 @@
+// .NET project discovery shared by language detection, the Flyway adapter
+// (dotnet layout), and the EF Core adapter. Pure filesystem scans; no
+// `dotnet` invocation, so detection stays fast and runtime-light.
+//
+// Layout the kit scaffolds (templates/project/dotnet*):
+//   App.sln
+//   src/App/App.csproj            <- application project
+//   src/App/Migrations/           <- EF Core migrations (efcore variant)
+//   db/migrations/V1__*.sql       <- Flyway migrations (flyway variant)
+//   tests/App.Tests/App.Tests.csproj
+//
+// A .NET project is identified by a *.sln / *.slnx / *.csproj at the ROOT
+// (the same rule language detection uses, so the kit never half-recognizes a
+// repo). Once identified, the EF Core project may live up to two levels down
+// (src/<Name>/, <Name>/).
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+/** Package whose reference marks a project as the EF Core migrations owner. */
+export const EF_DESIGN_PACKAGE = "Microsoft.EntityFrameworkCore.Design";
+
+/** Flyway migrations directory for .NET projects (relative to the project root). */
+export const DOTNET_FLYWAY_DIR = path.join("db", "migrations");
+
+const SKIP_DIRS = new Set(["bin", "obj", "node_modules", ".git", "client", "tests", "test"]);
+
+function safeReaddir(dir: string): fs.Dirent[] {
+  try {
+    return fs.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+}
+
+/** True when `dir` itself carries a .NET marker (*.sln, *.slnx, *.csproj). */
+export function hasDotnetMarker(dir: string): boolean {
+  return safeReaddir(dir).some(
+    (e) => e.isFile() && /\.(sln|slnx|csproj)$/i.test(e.name),
+  );
+}
+
+/**
+ * Find *.csproj files at the root and up to two directory levels below it,
+ * skipping build output and test folders. Sorted for deterministic results.
+ */
+export function findCsprojFiles(projectDir: string): string[] {
+  const found: string[] = [];
+  const walk = (dir: string, depth: number) => {
+    for (const e of safeReaddir(dir)) {
+      const full = path.join(dir, e.name);
+      if (e.isFile() && e.name.toLowerCase().endsWith(".csproj")) {
+        found.push(full);
+      } else if (e.isDirectory() && depth < 2 && !SKIP_DIRS.has(e.name.toLowerCase()) && !e.name.startsWith(".")) {
+        walk(full, depth + 1);
+      }
+    }
+  };
+  walk(projectDir, 0);
+  return found.sort();
+}
+
+export interface EfCoreProject {
+  /** Absolute path to the .csproj that references EF Core Design. */
+  csproj: string;
+  /** Directory containing the .csproj. */
+  projectDir: string;
+  /** Absolute path to the project's Migrations/ directory (may not exist yet). */
+  migrationsDir: string;
+}
+
+/** Locate the project that owns EF Core migrations, or null. */
+export function findEfCoreProject(projectDir: string): EfCoreProject | null {
+  for (const csproj of findCsprojFiles(projectDir)) {
+    let content = "";
+    try {
+      content = fs.readFileSync(csproj, "utf-8");
+    } catch {
+      continue;
+    }
+    if (content.includes(EF_DESIGN_PACKAGE)) {
+      const dir = path.dirname(csproj);
+      return { csproj, projectDir: dir, migrationsDir: path.join(dir, "Migrations") };
+    }
+  }
+  return null;
+}
+
+/** True for a .NET repo: a *.sln / *.slnx / *.csproj at the root. */
+export function isDotnetProject(projectDir: string): boolean {
+  return hasDotnetMarker(projectDir);
+}
+
+/** True for a .NET repo that uses Flyway SQL migrations under db/migrations/. */
+export function isDotnetFlywayProject(projectDir: string): boolean {
+  return isDotnetProject(projectDir) && fs.existsSync(path.join(projectDir, DOTNET_FLYWAY_DIR));
+}
+
+/** Maven/Spring Flyway layout (Java/Kotlin). */
+export const MAVEN_FLYWAY_DIR = path.join("src", "main", "resources", "db", "migration");
+
+/**
+ * Absolute Flyway migrations directory for a project: the Maven layout for
+ * Java/Kotlin (and as the historical default), or `db/migrations` for a .NET
+ * project that uses Flyway.
+ */
+export function flywayMigrationsDir(projectDir: string): string {
+  const maven = path.join(projectDir, MAVEN_FLYWAY_DIR);
+  if (fs.existsSync(maven) || fs.existsSync(path.join(projectDir, "pom.xml"))) return maven;
+  if (isDotnetFlywayProject(projectDir)) return path.join(projectDir, DOTNET_FLYWAY_DIR);
+  return maven;
+}

package/scripts/lakebase/index.ts

@@ -73,6 +73,7 @@ export * from "./workflow-drift.js";
 export * from "./spring-initializr.js";
 export * from "./uc-resources.js";
 export * from "./migration-layout.js";
+export * from "./dotnet-project.js";
 export {
   applySchemaMigrations,
   rollbackSchemaMigration,