@databricks-solutions/lakebase-scm-utils 0.3.9 → 0.3.10

package/dist/scripts/lakebase/ci-resolve-branch.cli.js

@@ -510,9 +510,46 @@ function dbcli2(args, host, timeout = KIT_TIMEOUTS.cliDefault) {
 }
 
 // scripts/lakebase/branch-create.ts
+function snapshotPath(instance, snapshot) {
+  return snapshot.includes("/") ? snapshot : `${projectPath(instance)}/snapshots/${snapshot}`;
+}
+function applyExpiration(spec, ttl, noExpiry) {
+  if (ttl && noExpiry === true) {
+    throw new LakebaseBranchError(
+      `Cannot set both ttl ("${ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+    );
+  }
+  if (ttl) spec.ttl = ttl;
+  else if (noExpiry ?? true) spec.no_expiry = true;
+}
 async function createBranch(args) {
   const sanitized = sanitizeBranchName(args.branch);
   const lookup = { instance: args.instance, host: args.host };
+  if (args.fromSnapshot) {
+    if (args.parentBranch || args.sourceBranchTime || args.sourceBranchLsn) {
+      throw new LakebaseBranchError(
+        `fromSnapshot is mutually exclusive with parentBranch / sourceBranchTime / sourceBranchLsn (the Lakebase API rejects source_snapshot combined with any source_branch field).`
+      );
+    }
+    const existing2 = await getBranchByName(sanitized, lookup);
+    if (existing2) return existing2;
+    const spec = { source_snapshot: snapshotPath(args.instance, args.fromSnapshot) };
+    applyExpiration(spec, args.ttl, args.noExpiry);
+    try {
+      await createWithTtlRecovery(args.instance, sanitized, spec, args.host);
+    } catch (err) {
+      if (err instanceof LakebaseBranchTtlTooLongError) throw err;
+      const landed = await getBranchByName(sanitized, lookup);
+      if (!landed) throw err;
+    }
+    return waitForBranchReady({
+      instance: args.instance,
+      host: args.host,
+      branch: sanitized,
+      timeoutMs: args.readyTimeoutMs ?? KIT_TIMEOUTS.readyWait,
+      pollIntervalMs: args.pollIntervalMs ?? KIT_TIMEOUTS.readyPoll
+    });
+  }
   let sourceBranchPath;
   if (args.parentBranch) {
     if (looksLikeBranchUid(args.parentBranch)) {
@@ -560,19 +597,15 @@ async function createBranch(args) {
     assertSourceMatches(existing, sourceBranchPath, sanitized);
     return existing;
   }
-  if (args.ttl && args.noExpiry === true) {
+  if (args.sourceBranchTime && args.sourceBranchLsn) {
     throw new LakebaseBranchError(
-      `Cannot set both ttl ("${args.ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+      `sourceBranchTime and sourceBranchLsn are mutually exclusive \u2013 pass at most one point-in-time.`
     );
   }
-  const specObj = {
-    source_branch: sourceBranchPath
-  };
-  if (args.ttl) {
-    specObj.ttl = args.ttl;
-  } else if (args.noExpiry ?? true) {
-    specObj.no_expiry = true;
-  }
+  const specObj = { source_branch: sourceBranchPath };
+  if (args.sourceBranchTime) specObj.source_branch_time = args.sourceBranchTime;
+  else if (args.sourceBranchLsn) specObj.source_branch_lsn = args.sourceBranchLsn;
+  applyExpiration(specObj, args.ttl, args.noExpiry);
   try {
     await createWithTtlRecovery(args.instance, sanitized, specObj, args.host);
   } catch (err) {
@@ -721,8 +754,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.3.9".length > 0) {
-    cached = "0.3.9";
+  if ("0.3.10".length > 0) {
+    cached = "0.3.10";
     return cached;
   }
   cached = "unknown";
@@ -769,22 +802,24 @@ async function getConnection(args) {
   const endpointPath = `projects/${args.instance}/branches/${branchId}/endpoints/${endpointName}`;
   if (args.output === "dsn") {
     const host2 = await resolveEndpointHost(args.instance, branchId);
-    const { token, email: email2 } = await mintCredential(endpointPath);
-    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token });
+    const { token: token2, email: email2 } = await mintCredential(endpointPath);
+    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token2 });
     return { url, host: host2, port: POSTGRES_PORT, database, user: email2, endpointPath };
   }
   const host = await resolveEndpointHost(args.instance, branchId);
-  const email = await resolveCurrentUser();
   process.env.PGAPPNAME = connectionApplicationName();
-  return createLakebasePool({
-    endpoint: endpointPath,
-    host,
-    database,
-    user: email,
-    // workspaceClient is passed through verbatim. createLakebasePool falls
-    // back to environment / ServiceContext when omitted.
-    ...args.workspaceClient !== void 0 ? { workspaceClient: args.workspaceClient } : {}
-  });
+  if (args.workspaceClient !== void 0) {
+    const email2 = await resolveCurrentUser();
+    return createLakebasePool({
+      endpoint: endpointPath,
+      host,
+      database,
+      user: email2,
+      workspaceClient: args.workspaceClient
+    });
+  }
+  const { token, email } = await mintCredential(endpointPath);
+  return createLakebasePool({ host, database, user: email, password: token });
 }
 async function resolveEndpointHost(instance, branch) {
   const branchId = await resolveBranchId({ instance, branch });

package/dist/scripts/lakebase/collapse-heads.cli.cjs

@@ -79290,8 +79290,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.3.9".length > 0) {
-    cached = "0.3.9";
+  if ("0.3.10".length > 0) {
+    cached = "0.3.10";
     return cached;
   }
   cached = "unknown";
@@ -79338,22 +79338,24 @@ async function getConnection(args) {
   const endpointPath = `projects/${args.instance}/branches/${branchId}/endpoints/${endpointName}`;
   if (args.output === "dsn") {
     const host2 = await resolveEndpointHost(args.instance, branchId);
-    const { token, email: email2 } = await mintCredential(endpointPath);
-    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token });
+    const { token: token2, email: email2 } = await mintCredential(endpointPath);
+    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token2 });
     return { url, host: host2, port: POSTGRES_PORT, database, user: email2, endpointPath };
   }
   const host = await resolveEndpointHost(args.instance, branchId);
-  const email = await resolveCurrentUser();
   process.env.PGAPPNAME = connectionApplicationName();
-  return createLakebasePool({
-    endpoint: endpointPath,
-    host,
-    database,
-    user: email,
-    // workspaceClient is passed through verbatim. createLakebasePool falls
-    // back to environment / ServiceContext when omitted.
-    ...args.workspaceClient !== void 0 ? { workspaceClient: args.workspaceClient } : {}
-  });
+  if (args.workspaceClient !== void 0) {
+    const email2 = await resolveCurrentUser();
+    return createLakebasePool({
+      endpoint: endpointPath,
+      host,
+      database,
+      user: email2,
+      workspaceClient: args.workspaceClient
+    });
+  }
+  const { token, email } = await mintCredential(endpointPath);
+  return createLakebasePool({ host, database, user: email, password: token });
 }
 async function resolveEndpointHost(instance, branch) {
   const branchId = await resolveBranchId({ instance, branch });

package/dist/scripts/lakebase/collapse-heads.cli.js

@@ -393,8 +393,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.3.9".length > 0) {
-    cached = "0.3.9";
+  if ("0.3.10".length > 0) {
+    cached = "0.3.10";
     return cached;
   }
   cached = "unknown";
@@ -441,22 +441,24 @@ async function getConnection(args) {
   const endpointPath = `projects/${args.instance}/branches/${branchId}/endpoints/${endpointName}`;
   if (args.output === "dsn") {
     const host2 = await resolveEndpointHost(args.instance, branchId);
-    const { token, email: email2 } = await mintCredential(endpointPath);
-    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token });
+    const { token: token2, email: email2 } = await mintCredential(endpointPath);
+    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token2 });
     return { url, host: host2, port: POSTGRES_PORT, database, user: email2, endpointPath };
   }
   const host = await resolveEndpointHost(args.instance, branchId);
-  const email = await resolveCurrentUser();
   process.env.PGAPPNAME = connectionApplicationName();
-  return createLakebasePool({
-    endpoint: endpointPath,
-    host,
-    database,
-    user: email,
-    // workspaceClient is passed through verbatim. createLakebasePool falls
-    // back to environment / ServiceContext when omitted.
-    ...args.workspaceClient !== void 0 ? { workspaceClient: args.workspaceClient } : {}
-  });
+  if (args.workspaceClient !== void 0) {
+    const email2 = await resolveCurrentUser();
+    return createLakebasePool({
+      endpoint: endpointPath,
+      host,
+      database,
+      user: email2,
+      workspaceClient: args.workspaceClient
+    });
+  }
+  const { token, email } = await mintCredential(endpointPath);
+  return createLakebasePool({ host, database, user: email, password: token });
 }
 async function resolveEndpointHost(instance, branch) {
   const branchId = await resolveBranchId({ instance, branch });

package/dist/scripts/lakebase/cut-backup.cli.cjs

@@ -487,9 +487,46 @@ function dbcli2(args, host, timeout = KIT_TIMEOUTS.cliDefault) {
 }
 
 // scripts/lakebase/branch-create.ts
+function snapshotPath(instance, snapshot) {
+  return snapshot.includes("/") ? snapshot : `${projectPath(instance)}/snapshots/${snapshot}`;
+}
+function applyExpiration(spec, ttl, noExpiry) {
+  if (ttl && noExpiry === true) {
+    throw new LakebaseBranchError(
+      `Cannot set both ttl ("${ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+    );
+  }
+  if (ttl) spec.ttl = ttl;
+  else if (noExpiry ?? true) spec.no_expiry = true;
+}
 async function createBranch(args) {
   const sanitized = sanitizeBranchName(args.branch);
   const lookup = { instance: args.instance, host: args.host };
+  if (args.fromSnapshot) {
+    if (args.parentBranch || args.sourceBranchTime || args.sourceBranchLsn) {
+      throw new LakebaseBranchError(
+        `fromSnapshot is mutually exclusive with parentBranch / sourceBranchTime / sourceBranchLsn (the Lakebase API rejects source_snapshot combined with any source_branch field).`
+      );
+    }
+    const existing2 = await getBranchByName(sanitized, lookup);
+    if (existing2) return existing2;
+    const spec = { source_snapshot: snapshotPath(args.instance, args.fromSnapshot) };
+    applyExpiration(spec, args.ttl, args.noExpiry);
+    try {
+      await createWithTtlRecovery(args.instance, sanitized, spec, args.host);
+    } catch (err) {
+      if (err instanceof LakebaseBranchTtlTooLongError) throw err;
+      const landed = await getBranchByName(sanitized, lookup);
+      if (!landed) throw err;
+    }
+    return waitForBranchReady({
+      instance: args.instance,
+      host: args.host,
+      branch: sanitized,
+      timeoutMs: args.readyTimeoutMs ?? KIT_TIMEOUTS.readyWait,
+      pollIntervalMs: args.pollIntervalMs ?? KIT_TIMEOUTS.readyPoll
+    });
+  }
   let sourceBranchPath;
   if (args.parentBranch) {
     if (looksLikeBranchUid(args.parentBranch)) {
@@ -537,19 +574,15 @@ async function createBranch(args) {
     assertSourceMatches(existing, sourceBranchPath, sanitized);
     return existing;
   }
-  if (args.ttl && args.noExpiry === true) {
+  if (args.sourceBranchTime && args.sourceBranchLsn) {
     throw new LakebaseBranchError(
-      `Cannot set both ttl ("${args.ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+      `sourceBranchTime and sourceBranchLsn are mutually exclusive \u2013 pass at most one point-in-time.`
     );
   }
-  const specObj = {
-    source_branch: sourceBranchPath
-  };
-  if (args.ttl) {
-    specObj.ttl = args.ttl;
-  } else if (args.noExpiry ?? true) {
-    specObj.no_expiry = true;
-  }
+  const specObj = { source_branch: sourceBranchPath };
+  if (args.sourceBranchTime) specObj.source_branch_time = args.sourceBranchTime;
+  else if (args.sourceBranchLsn) specObj.source_branch_lsn = args.sourceBranchLsn;
+  applyExpiration(specObj, args.ttl, args.noExpiry);
   try {
     await createWithTtlRecovery(args.instance, sanitized, specObj, args.host);
   } catch (err) {

package/dist/scripts/lakebase/cut-backup.cli.js

@@ -464,9 +464,46 @@ function dbcli2(args, host, timeout = KIT_TIMEOUTS.cliDefault) {
 }
 
 // scripts/lakebase/branch-create.ts
+function snapshotPath(instance, snapshot) {
+  return snapshot.includes("/") ? snapshot : `${projectPath(instance)}/snapshots/${snapshot}`;
+}
+function applyExpiration(spec, ttl, noExpiry) {
+  if (ttl && noExpiry === true) {
+    throw new LakebaseBranchError(
+      `Cannot set both ttl ("${ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+    );
+  }
+  if (ttl) spec.ttl = ttl;
+  else if (noExpiry ?? true) spec.no_expiry = true;
+}
 async function createBranch(args) {
   const sanitized = sanitizeBranchName(args.branch);
   const lookup = { instance: args.instance, host: args.host };
+  if (args.fromSnapshot) {
+    if (args.parentBranch || args.sourceBranchTime || args.sourceBranchLsn) {
+      throw new LakebaseBranchError(
+        `fromSnapshot is mutually exclusive with parentBranch / sourceBranchTime / sourceBranchLsn (the Lakebase API rejects source_snapshot combined with any source_branch field).`
+      );
+    }
+    const existing2 = await getBranchByName(sanitized, lookup);
+    if (existing2) return existing2;
+    const spec = { source_snapshot: snapshotPath(args.instance, args.fromSnapshot) };
+    applyExpiration(spec, args.ttl, args.noExpiry);
+    try {
+      await createWithTtlRecovery(args.instance, sanitized, spec, args.host);
+    } catch (err) {
+      if (err instanceof LakebaseBranchTtlTooLongError) throw err;
+      const landed = await getBranchByName(sanitized, lookup);
+      if (!landed) throw err;
+    }
+    return waitForBranchReady({
+      instance: args.instance,
+      host: args.host,
+      branch: sanitized,
+      timeoutMs: args.readyTimeoutMs ?? KIT_TIMEOUTS.readyWait,
+      pollIntervalMs: args.pollIntervalMs ?? KIT_TIMEOUTS.readyPoll
+    });
+  }
   let sourceBranchPath;
   if (args.parentBranch) {
     if (looksLikeBranchUid(args.parentBranch)) {
@@ -514,19 +551,15 @@ async function createBranch(args) {
     assertSourceMatches(existing, sourceBranchPath, sanitized);
     return existing;
   }
-  if (args.ttl && args.noExpiry === true) {
+  if (args.sourceBranchTime && args.sourceBranchLsn) {
     throw new LakebaseBranchError(
-      `Cannot set both ttl ("${args.ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+      `sourceBranchTime and sourceBranchLsn are mutually exclusive \u2013 pass at most one point-in-time.`
     );
   }
-  const specObj = {
-    source_branch: sourceBranchPath
-  };
-  if (args.ttl) {
-    specObj.ttl = args.ttl;
-  } else if (args.noExpiry ?? true) {
-    specObj.no_expiry = true;
-  }
+  const specObj = { source_branch: sourceBranchPath };
+  if (args.sourceBranchTime) specObj.source_branch_time = args.sourceBranchTime;
+  else if (args.sourceBranchLsn) specObj.source_branch_lsn = args.sourceBranchLsn;
+  applyExpiration(specObj, args.ttl, args.noExpiry);
   try {
     await createWithTtlRecovery(args.instance, sanitized, specObj, args.host);
   } catch (err) {

package/dist/scripts/lakebase/cut-tier.cli.cjs

@@ -531,9 +531,46 @@ function dbcli2(args, host, timeout = KIT_TIMEOUTS.cliDefault) {
 }
 
 // scripts/lakebase/branch-create.ts
+function snapshotPath(instance, snapshot) {
+  return snapshot.includes("/") ? snapshot : `${projectPath(instance)}/snapshots/${snapshot}`;
+}
+function applyExpiration(spec, ttl, noExpiry) {
+  if (ttl && noExpiry === true) {
+    throw new LakebaseBranchError(
+      `Cannot set both ttl ("${ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+    );
+  }
+  if (ttl) spec.ttl = ttl;
+  else if (noExpiry ?? true) spec.no_expiry = true;
+}
 async function createBranch(args) {
   const sanitized = sanitizeBranchName(args.branch);
   const lookup = { instance: args.instance, host: args.host };
+  if (args.fromSnapshot) {
+    if (args.parentBranch || args.sourceBranchTime || args.sourceBranchLsn) {
+      throw new LakebaseBranchError(
+        `fromSnapshot is mutually exclusive with parentBranch / sourceBranchTime / sourceBranchLsn (the Lakebase API rejects source_snapshot combined with any source_branch field).`
+      );
+    }
+    const existing2 = await getBranchByName(sanitized, lookup);
+    if (existing2) return existing2;
+    const spec = { source_snapshot: snapshotPath(args.instance, args.fromSnapshot) };
+    applyExpiration(spec, args.ttl, args.noExpiry);
+    try {
+      await createWithTtlRecovery(args.instance, sanitized, spec, args.host);
+    } catch (err) {
+      if (err instanceof LakebaseBranchTtlTooLongError) throw err;
+      const landed = await getBranchByName(sanitized, lookup);
+      if (!landed) throw err;
+    }
+    return waitForBranchReady({
+      instance: args.instance,
+      host: args.host,
+      branch: sanitized,
+      timeoutMs: args.readyTimeoutMs ?? KIT_TIMEOUTS.readyWait,
+      pollIntervalMs: args.pollIntervalMs ?? KIT_TIMEOUTS.readyPoll
+    });
+  }
   let sourceBranchPath;
   if (args.parentBranch) {
     if (looksLikeBranchUid(args.parentBranch)) {
@@ -581,19 +618,15 @@ async function createBranch(args) {
     assertSourceMatches(existing, sourceBranchPath, sanitized);
     return existing;
   }
-  if (args.ttl && args.noExpiry === true) {
+  if (args.sourceBranchTime && args.sourceBranchLsn) {
     throw new LakebaseBranchError(
-      `Cannot set both ttl ("${args.ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+      `sourceBranchTime and sourceBranchLsn are mutually exclusive \u2013 pass at most one point-in-time.`
     );
   }
-  const specObj = {
-    source_branch: sourceBranchPath
-  };
-  if (args.ttl) {
-    specObj.ttl = args.ttl;
-  } else if (args.noExpiry ?? true) {
-    specObj.no_expiry = true;
-  }
+  const specObj = { source_branch: sourceBranchPath };
+  if (args.sourceBranchTime) specObj.source_branch_time = args.sourceBranchTime;
+  else if (args.sourceBranchLsn) specObj.source_branch_lsn = args.sourceBranchLsn;
+  applyExpiration(specObj, args.ttl, args.noExpiry);
   try {
     await createWithTtlRecovery(args.instance, sanitized, specObj, args.host);
   } catch (err) {

package/dist/scripts/lakebase/cut-tier.cli.js

@@ -491,9 +491,46 @@ function dbcli2(args, host, timeout = KIT_TIMEOUTS.cliDefault) {
 }
 
 // scripts/lakebase/branch-create.ts
+function snapshotPath(instance, snapshot) {
+  return snapshot.includes("/") ? snapshot : `${projectPath(instance)}/snapshots/${snapshot}`;
+}
+function applyExpiration(spec, ttl, noExpiry) {
+  if (ttl && noExpiry === true) {
+    throw new LakebaseBranchError(
+      `Cannot set both ttl ("${ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+    );
+  }
+  if (ttl) spec.ttl = ttl;
+  else if (noExpiry ?? true) spec.no_expiry = true;
+}
 async function createBranch(args) {
   const sanitized = sanitizeBranchName(args.branch);
   const lookup = { instance: args.instance, host: args.host };
+  if (args.fromSnapshot) {
+    if (args.parentBranch || args.sourceBranchTime || args.sourceBranchLsn) {
+      throw new LakebaseBranchError(
+        `fromSnapshot is mutually exclusive with parentBranch / sourceBranchTime / sourceBranchLsn (the Lakebase API rejects source_snapshot combined with any source_branch field).`
+      );
+    }
+    const existing2 = await getBranchByName(sanitized, lookup);
+    if (existing2) return existing2;
+    const spec = { source_snapshot: snapshotPath(args.instance, args.fromSnapshot) };
+    applyExpiration(spec, args.ttl, args.noExpiry);
+    try {
+      await createWithTtlRecovery(args.instance, sanitized, spec, args.host);
+    } catch (err) {
+      if (err instanceof LakebaseBranchTtlTooLongError) throw err;
+      const landed = await getBranchByName(sanitized, lookup);
+      if (!landed) throw err;
+    }
+    return waitForBranchReady({
+      instance: args.instance,
+      host: args.host,
+      branch: sanitized,
+      timeoutMs: args.readyTimeoutMs ?? KIT_TIMEOUTS.readyWait,
+      pollIntervalMs: args.pollIntervalMs ?? KIT_TIMEOUTS.readyPoll
+    });
+  }
   let sourceBranchPath;
   if (args.parentBranch) {
     if (looksLikeBranchUid(args.parentBranch)) {
@@ -541,19 +578,15 @@ async function createBranch(args) {
     assertSourceMatches(existing, sourceBranchPath, sanitized);
     return existing;
   }
-  if (args.ttl && args.noExpiry === true) {
+  if (args.sourceBranchTime && args.sourceBranchLsn) {
     throw new LakebaseBranchError(
-      `Cannot set both ttl ("${args.ttl}") and noExpiry: true on the same branch \u2013 they are mutually exclusive. Pass one or the other.`
+      `sourceBranchTime and sourceBranchLsn are mutually exclusive \u2013 pass at most one point-in-time.`
     );
   }
-  const specObj = {
-    source_branch: sourceBranchPath
-  };
-  if (args.ttl) {
-    specObj.ttl = args.ttl;
-  } else if (args.noExpiry ?? true) {
-    specObj.no_expiry = true;
-  }
+  const specObj = { source_branch: sourceBranchPath };
+  if (args.sourceBranchTime) specObj.source_branch_time = args.sourceBranchTime;
+  else if (args.sourceBranchLsn) specObj.source_branch_lsn = args.sourceBranchLsn;
+  applyExpiration(specObj, args.ttl, args.noExpiry);
   try {
     await createWithTtlRecovery(args.instance, sanitized, specObj, args.host);
   } catch (err) {

package/dist/scripts/lakebase/detect-language.cli.cjs

@@ -79290,8 +79290,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.3.9".length > 0) {
-    cached = "0.3.9";
+  if ("0.3.10".length > 0) {
+    cached = "0.3.10";
     return cached;
   }
   cached = "unknown";
@@ -79338,22 +79338,24 @@ async function getConnection(args) {
   const endpointPath = `projects/${args.instance}/branches/${branchId}/endpoints/${endpointName}`;
   if (args.output === "dsn") {
     const host2 = await resolveEndpointHost(args.instance, branchId);
-    const { token, email: email2 } = await mintCredential(endpointPath);
-    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token });
+    const { token: token2, email: email2 } = await mintCredential(endpointPath);
+    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token2 });
     return { url, host: host2, port: POSTGRES_PORT, database, user: email2, endpointPath };
   }
   const host = await resolveEndpointHost(args.instance, branchId);
-  const email = await resolveCurrentUser();
   process.env.PGAPPNAME = connectionApplicationName();
-  return createLakebasePool({
-    endpoint: endpointPath,
-    host,
-    database,
-    user: email,
-    // workspaceClient is passed through verbatim. createLakebasePool falls
-    // back to environment / ServiceContext when omitted.
-    ...args.workspaceClient !== void 0 ? { workspaceClient: args.workspaceClient } : {}
-  });
+  if (args.workspaceClient !== void 0) {
+    const email2 = await resolveCurrentUser();
+    return createLakebasePool({
+      endpoint: endpointPath,
+      host,
+      database,
+      user: email2,
+      workspaceClient: args.workspaceClient
+    });
+  }
+  const { token, email } = await mintCredential(endpointPath);
+  return createLakebasePool({ host, database, user: email, password: token });
 }
 async function resolveEndpointHost(instance, branch) {
   const branchId = await resolveBranchId({ instance, branch });

package/dist/scripts/lakebase/detect-language.cli.js

@@ -393,8 +393,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.3.9".length > 0) {
-    cached = "0.3.9";
+  if ("0.3.10".length > 0) {
+    cached = "0.3.10";
     return cached;
   }
   cached = "unknown";
@@ -441,22 +441,24 @@ async function getConnection(args) {
   const endpointPath = `projects/${args.instance}/branches/${branchId}/endpoints/${endpointName}`;
   if (args.output === "dsn") {
     const host2 = await resolveEndpointHost(args.instance, branchId);
-    const { token, email: email2 } = await mintCredential(endpointPath);
-    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token });
+    const { token: token2, email: email2 } = await mintCredential(endpointPath);
+    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token2 });
     return { url, host: host2, port: POSTGRES_PORT, database, user: email2, endpointPath };
   }
   const host = await resolveEndpointHost(args.instance, branchId);
-  const email = await resolveCurrentUser();
   process.env.PGAPPNAME = connectionApplicationName();
-  return createLakebasePool({
-    endpoint: endpointPath,
-    host,
-    database,
-    user: email,
-    // workspaceClient is passed through verbatim. createLakebasePool falls
-    // back to environment / ServiceContext when omitted.
-    ...args.workspaceClient !== void 0 ? { workspaceClient: args.workspaceClient } : {}
-  });
+  if (args.workspaceClient !== void 0) {
+    const email2 = await resolveCurrentUser();
+    return createLakebasePool({
+      endpoint: endpointPath,
+      host,
+      database,
+      user: email2,
+      workspaceClient: args.workspaceClient
+    });
+  }
+  const { token, email } = await mintCredential(endpointPath);
+  return createLakebasePool({ host, database, user: email, password: token });
 }
 async function resolveEndpointHost(instance, branch) {
   const branchId = await resolveBranchId({ instance, branch });

package/dist/scripts/lakebase/doctor.cli.cjs

@@ -80800,8 +80800,8 @@ var PKG_NAME = "@databricks-solutions/lakebase-scm-utils";
 var cached;
 function substrateSelfVersion() {
   if (cached !== void 0) return cached;
-  if ("0.3.9".length > 0) {
-    cached = "0.3.9";
+  if ("0.3.10".length > 0) {
+    cached = "0.3.10";
     return cached;
   }
   cached = "unknown";
@@ -80848,22 +80848,24 @@ async function getConnection(args) {
   const endpointPath = `projects/${args.instance}/branches/${branchId}/endpoints/${endpointName}`;
   if (args.output === "dsn") {
     const host2 = await resolveEndpointHost(args.instance, branchId);
-    const { token, email: email2 } = await mintCredential(endpointPath);
-    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token });
+    const { token: token2, email: email2 } = await mintCredential(endpointPath);
+    const url = buildPostgresUrl({ host: host2, port: POSTGRES_PORT, database, user: email2, password: token2 });
     return { url, host: host2, port: POSTGRES_PORT, database, user: email2, endpointPath };
   }
   const host = await resolveEndpointHost(args.instance, branchId);
-  const email = await resolveCurrentUser();
   process.env.PGAPPNAME = connectionApplicationName();
-  return createLakebasePool({
-    endpoint: endpointPath,
-    host,
-    database,
-    user: email,
-    // workspaceClient is passed through verbatim. createLakebasePool falls
-    // back to environment / ServiceContext when omitted.
-    ...args.workspaceClient !== void 0 ? { workspaceClient: args.workspaceClient } : {}
-  });
+  if (args.workspaceClient !== void 0) {
+    const email2 = await resolveCurrentUser();
+    return createLakebasePool({
+      endpoint: endpointPath,
+      host,
+      database,
+      user: email2,
+      workspaceClient: args.workspaceClient
+    });
+  }
+  const { token, email } = await mintCredential(endpointPath);
+  return createLakebasePool({ host, database, user: email, password: token });
 }
 async function resolveEndpointHost(instance, branch) {
   const branchId = await resolveBranchId({ instance, branch });