@dbx-tools/auth 0.9.32 → 0.9.36

package/lib/src/_lifecycle.js

@@ -0,0 +1,214 @@
+import { AuthError } from "./_errors.js";
+import { authLogger, credentialId, failureMetadata, tokenMetadata } from "./_logging.js";
+const logger = authLogger("lifecycle");
+/** Provider-neutral check-lock-check authentication and persistent token lifecycle. */
+export class TokenLifecycle {
+    key;
+    provider;
+    store;
+    options;
+    now;
+    constructor(key, provider, store, options, now = () => new Date()) {
+        this.key = key;
+        this.provider = provider;
+        this.store = store;
+        this.options = options;
+        this.now = now;
+        logger.debug("created authentication lifecycle", {
+            credential: credentialId(key),
+            refreshBufferMs: options.refreshBufferMs,
+            lockTimeoutMs: options.lockTimeoutMs,
+            loginTimeoutMs: options.loginTimeoutMs,
+            silentProvider: provider.canAuthenticateSilently(),
+        });
+    }
+    async login() {
+        logger.debug("interactive login requested", this.context());
+        return this.withLock(async () => {
+            const token = validateToken(await this.provider.login(this.options.loginTimeoutMs));
+            await this.store.save(this.key, token);
+            logger.debug("interactive login stored credential", {
+                ...this.context(),
+                token: tokenMetadata(token, this.now()),
+            });
+            return publicToken(token);
+        });
+    }
+    token() {
+        return this.loadToken(false);
+    }
+    tokenOrLogin() {
+        return this.loadToken(true);
+    }
+    async tokenWithLogin(login) {
+        logger.debug("token requested", { ...this.context(), login: login ?? "auto" });
+        if (login === true)
+            return this.login();
+        if (login === false)
+            return this.token();
+        return this.tokenOrLogin();
+    }
+    forceRefresh(login = true) {
+        logger.debug("forced refresh requested", { ...this.context(), login });
+        return this.refresh(login);
+    }
+    async logout() {
+        logger.debug("logout requested", this.context());
+        await this.withLock(() => this.store.remove(this.key));
+        logger.debug("stored credential removed", this.context());
+    }
+    async loadToken(login) {
+        const existing = await this.store.load(this.key);
+        const reusable = Boolean(existing && this.canReuse(existing));
+        logger.debug("checked credential cache", {
+            ...this.context(),
+            login,
+            reusable,
+            token: tokenMetadata(existing, this.now()),
+        });
+        if (existing && reusable)
+            return publicToken(existing);
+        return this.withLock(async () => {
+            const current = await this.store.load(this.key);
+            const currentReusable = Boolean(current && this.canReuse(current));
+            logger.debug("rechecked credential cache after lock", {
+                ...this.context(),
+                reusable: currentReusable,
+                token: tokenMetadata(current, this.now()),
+            });
+            if (current && currentReusable)
+                return publicToken(current);
+            return this.renew(current, login);
+        });
+    }
+    async refresh(login) {
+        return this.withLock(async () => {
+            const current = await this.store.load(this.key);
+            return this.renew(current, login);
+        });
+    }
+    async renew(current, login) {
+        let token;
+        if (current) {
+            logger.debug("refreshing stored credential", {
+                ...this.context(),
+                loginFallback: login,
+                token: tokenMetadata(current, this.now()),
+            });
+            try {
+                token = await this.provider.refresh(current);
+            }
+            catch (error) {
+                logger.debug("credential refresh failed", {
+                    ...this.context(),
+                    loginFallback: login,
+                    error: failureMetadata(error),
+                });
+                if (!login)
+                    throw error;
+                logger.debug("falling back to interactive login", this.context());
+                token = await this.provider.login(this.options.loginTimeoutMs);
+            }
+        }
+        else if (this.provider.canAuthenticateSilently()) {
+            logger.debug("attempting silent credential acquisition", {
+                ...this.context(),
+                loginFallback: login,
+            });
+            try {
+                token = await this.provider.authenticate(this.options.loginTimeoutMs);
+            }
+            catch (error) {
+                logger.debug("silent credential acquisition failed", {
+                    ...this.context(),
+                    loginFallback: login,
+                    error: failureMetadata(error),
+                });
+                if (!login)
+                    throw error;
+                logger.debug("falling back to interactive login", this.context());
+                token = await this.provider.login(this.options.loginTimeoutMs);
+            }
+        }
+        else if (login) {
+            logger.debug("provider requires interactive login", this.context());
+            token = await this.provider.login(this.options.loginTimeoutMs);
+        }
+        else {
+            throw new AuthError("oauth", "No stored credential is available and interactive login is disabled");
+        }
+        token = validateToken(token, current);
+        logger.debug("credential acquisition completed", {
+            ...this.context(),
+            token: tokenMetadata(token, this.now()),
+        });
+        await this.store.save(this.key, token);
+        logger.debug("credential saved", this.context());
+        return publicToken(token);
+    }
+    canReuse(token) {
+        if (!isValid(token, this.now()))
+            return false;
+        if (!token.expiry)
+            return true;
+        return Date.parse(token.expiry) - this.now().getTime() > this.options.refreshBufferMs;
+    }
+    async withLock(action) {
+        logger.debug("waiting for credential lock", this.context());
+        // Omit the timeout (wait indefinitely) unless a positive cap is configured.
+        // The holder may run for minutes; the caller owns the overall request budget
+        // and the lock is always released when `action` settles (success or error).
+        const lockTimeoutMs = this.options.lockTimeoutMs > 0 ? this.options.lockTimeoutMs : undefined;
+        const lease = await this.store.acquireLock(this.key, lockTimeoutMs);
+        logger.debug("credential lock acquired", this.context());
+        let failure;
+        try {
+            return await action();
+        }
+        catch (error) {
+            failure = error;
+            throw error;
+        }
+        finally {
+            try {
+                await this.store.releaseLock(lease);
+                logger.debug("credential lock released", this.context());
+            }
+            catch (releaseError) {
+                logger.debug("credential lock release failed", {
+                    ...this.context(),
+                    error: failureMetadata(releaseError),
+                });
+                if (failure === undefined)
+                    throw releaseError;
+            }
+        }
+    }
+    context() {
+        return { credential: credentialId(this.key) };
+    }
+}
+export function publicToken(token) {
+    return {
+        accessToken: token.accessToken,
+        tokenType: token.tokenType,
+        ...(token.expiry ? { expiry: token.expiry } : {}),
+        scopes: [...token.scopes],
+    };
+}
+export function validateToken(token, previous) {
+    if (!token.accessToken.trim()) {
+        throw new AuthError("oauth", "Token response did not contain an access token");
+    }
+    return {
+        accessToken: token.accessToken,
+        tokenType: token.tokenType || "Bearer",
+        refreshToken: token.refreshToken ?? previous?.refreshToken,
+        expiry: token.expiry,
+        scopes: token.scopes.length ? [...token.scopes] : [...(previous?.scopes ?? [])],
+    };
+}
+function isValid(token, now) {
+    return Boolean(token.accessToken) && (!token.expiry || Date.parse(token.expiry) > now.getTime());
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_lifecycle.js","sourceRoot":"","sources":["../../src/_lifecycle.ts"],"names":[],"mappings":"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","sourcesContent":["import { AuthError } from \"./_errors.ts\";\nimport { authLogger, credentialId, failureMetadata, tokenMetadata } from \"./_logging.ts\";\nimport type { CredentialStore, Token, TokenProvider } from \"./_types.ts\";\nimport type { AccessToken } from \"./client.ts\";\nimport type { AuthOptions } from \"./config.ts\";\n\nconst logger = authLogger(\"lifecycle\");\n\n/** Provider-neutral check-lock-check authentication and persistent token lifecycle. */\nexport class TokenLifecycle {\n  constructor(\n    private readonly key: string,\n    private readonly provider: TokenProvider,\n    private readonly store: CredentialStore,\n    private readonly options: Required<AuthOptions>,\n    private readonly now: () => Date = () => new Date(),\n  ) {\n    logger.debug(\"created authentication lifecycle\", {\n      credential: credentialId(key),\n      refreshBufferMs: options.refreshBufferMs,\n      lockTimeoutMs: options.lockTimeoutMs,\n      loginTimeoutMs: options.loginTimeoutMs,\n      silentProvider: provider.canAuthenticateSilently(),\n    });\n  }\n\n  async login(): Promise<AccessToken> {\n    logger.debug(\"interactive login requested\", this.context());\n    return this.withLock(async () => {\n      const token = validateToken(await this.provider.login(this.options.loginTimeoutMs));\n      await this.store.save(this.key, token);\n      logger.debug(\"interactive login stored credential\", {\n        ...this.context(),\n        token: tokenMetadata(token, this.now()),\n      });\n      return publicToken(token);\n    });\n  }\n\n  token(): Promise<AccessToken> {\n    return this.loadToken(false);\n  }\n\n  tokenOrLogin(): Promise<AccessToken> {\n    return this.loadToken(true);\n  }\n\n  async tokenWithLogin(login?: boolean): Promise<AccessToken> {\n    logger.debug(\"token requested\", { ...this.context(), login: login ?? \"auto\" });\n    if (login === true) return this.login();\n    if (login === false) return this.token();\n    return this.tokenOrLogin();\n  }\n\n  forceRefresh(login = true): Promise<AccessToken> {\n    logger.debug(\"forced refresh requested\", { ...this.context(), login });\n    return this.refresh(login);\n  }\n\n  async logout(): Promise<void> {\n    logger.debug(\"logout requested\", this.context());\n    await this.withLock(() => this.store.remove(this.key));\n    logger.debug(\"stored credential removed\", this.context());\n  }\n\n  private async loadToken(login: boolean): Promise<AccessToken> {\n    const existing = await this.store.load(this.key);\n    const reusable = Boolean(existing && this.canReuse(existing));\n    logger.debug(\"checked credential cache\", {\n      ...this.context(),\n      login,\n      reusable,\n      token: tokenMetadata(existing, this.now()),\n    });\n    if (existing && reusable) return publicToken(existing);\n    return this.withLock(async () => {\n      const current = await this.store.load(this.key);\n      const currentReusable = Boolean(current && this.canReuse(current));\n      logger.debug(\"rechecked credential cache after lock\", {\n        ...this.context(),\n        reusable: currentReusable,\n        token: tokenMetadata(current, this.now()),\n      });\n      if (current && currentReusable) return publicToken(current);\n      return this.renew(current, login);\n    });\n  }\n\n  private async refresh(login: boolean): Promise<AccessToken> {\n    return this.withLock(async () => {\n      const current = await this.store.load(this.key);\n      return this.renew(current, login);\n    });\n  }\n\n  private async renew(current: Token | undefined, login: boolean): Promise<AccessToken> {\n    let token: Token;\n    if (current) {\n      logger.debug(\"refreshing stored credential\", {\n        ...this.context(),\n        loginFallback: login,\n        token: tokenMetadata(current, this.now()),\n      });\n      try {\n        token = await this.provider.refresh(current);\n      } catch (error) {\n        logger.debug(\"credential refresh failed\", {\n          ...this.context(),\n          loginFallback: login,\n          error: failureMetadata(error),\n        });\n        if (!login) throw error;\n        logger.debug(\"falling back to interactive login\", this.context());\n        token = await this.provider.login(this.options.loginTimeoutMs);\n      }\n    } else if (this.provider.canAuthenticateSilently()) {\n      logger.debug(\"attempting silent credential acquisition\", {\n        ...this.context(),\n        loginFallback: login,\n      });\n      try {\n        token = await this.provider.authenticate(this.options.loginTimeoutMs);\n      } catch (error) {\n        logger.debug(\"silent credential acquisition failed\", {\n          ...this.context(),\n          loginFallback: login,\n          error: failureMetadata(error),\n        });\n        if (!login) throw error;\n        logger.debug(\"falling back to interactive login\", this.context());\n        token = await this.provider.login(this.options.loginTimeoutMs);\n      }\n    } else if (login) {\n      logger.debug(\"provider requires interactive login\", this.context());\n      token = await this.provider.login(this.options.loginTimeoutMs);\n    } else {\n      throw new AuthError(\n        \"oauth\",\n        \"No stored credential is available and interactive login is disabled\",\n      );\n    }\n    token = validateToken(token, current);\n    logger.debug(\"credential acquisition completed\", {\n      ...this.context(),\n      token: tokenMetadata(token, this.now()),\n    });\n    await this.store.save(this.key, token);\n    logger.debug(\"credential saved\", this.context());\n    return publicToken(token);\n  }\n\n  private canReuse(token: Token): boolean {\n    if (!isValid(token, this.now())) return false;\n    if (!token.expiry) return true;\n    return Date.parse(token.expiry) - this.now().getTime() > this.options.refreshBufferMs;\n  }\n\n  private async withLock<T>(action: () => Promise<T>): Promise<T> {\n    logger.debug(\"waiting for credential lock\", this.context());\n    // Omit the timeout (wait indefinitely) unless a positive cap is configured.\n    // The holder may run for minutes; the caller owns the overall request budget\n    // and the lock is always released when `action` settles (success or error).\n    const lockTimeoutMs = this.options.lockTimeoutMs > 0 ? this.options.lockTimeoutMs : undefined;\n    const lease = await this.store.acquireLock(this.key, lockTimeoutMs);\n    logger.debug(\"credential lock acquired\", this.context());\n    let failure: unknown;\n    try {\n      return await action();\n    } catch (error) {\n      failure = error;\n      throw error;\n    } finally {\n      try {\n        await this.store.releaseLock(lease);\n        logger.debug(\"credential lock released\", this.context());\n      } catch (releaseError) {\n        logger.debug(\"credential lock release failed\", {\n          ...this.context(),\n          error: failureMetadata(releaseError),\n        });\n        if (failure === undefined) throw releaseError;\n      }\n    }\n  }\n\n  private context(): Record<string, unknown> {\n    return { credential: credentialId(this.key) };\n  }\n}\n\nexport function publicToken(token: Token): AccessToken {\n  return {\n    accessToken: token.accessToken,\n    tokenType: token.tokenType,\n    ...(token.expiry ? { expiry: token.expiry } : {}),\n    scopes: [...token.scopes],\n  };\n}\n\nexport function validateToken(token: Token, previous?: Token): Token {\n  if (!token.accessToken.trim()) {\n    throw new AuthError(\"oauth\", \"Token response did not contain an access token\");\n  }\n  return {\n    accessToken: token.accessToken,\n    tokenType: token.tokenType || \"Bearer\",\n    refreshToken: token.refreshToken ?? previous?.refreshToken,\n    expiry: token.expiry,\n    scopes: token.scopes.length ? [...token.scopes] : [...(previous?.scopes ?? [])],\n  };\n}\n\nfunction isValid(token: Token, now: Date): boolean {\n  return Boolean(token.accessToken) && (!token.expiry || Date.parse(token.expiry) > now.getTime());\n}\n"]}

package/lib/src/_logging.d.ts

@@ -1,5 +1,5 @@
 import * as log from "@dbx-tools/shared-core/log";
-import type { Token } from "./types.ts";
+import type { Token } from "./_types.ts";
 /** Auth logger with a stable capability-specific tag. */
 export declare function authLogger(scope: string): log.Logger;
 /** Stable non-secret identifier for a credential cache key. */

package/lib/src/_logging.js

@@ -1,6 +1,6 @@
 import * as hash from "@dbx-tools/shared-core/hash";
 import * as log from "@dbx-tools/shared-core/log";
-import { AuthError } from "./errors.js";
+import { AuthError } from "./_errors.js";
 /** Auth logger with a stable capability-specific tag. */
 export function authLogger(scope) {
     return log.logger(`auth:${scope}`);
@@ -35,4 +35,4 @@ export function failureMetadata(cause) {
         ...(cause instanceof AuthError ? { kind: cause.kind } : {}),
     };
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/{personal-access-token.d.ts → _personal-access-token.d.ts}

@@ -1,4 +1,4 @@
-import type { Token, TokenProvider } from "./types.ts";
+import type { Token, TokenProvider } from "./_types.ts";
 /** Non-refreshing provider for a configured Databricks personal access token. */
 export declare class DatabricksPersonalAccessTokenProvider implements TokenProvider {
     private readonly accessToken;

package/lib/src/_personal-access-token.js

@@ -0,0 +1,30 @@
+import { authLogger } from "./_logging.js";
+const logger = authLogger("pat");
+/** Non-refreshing provider for a configured Databricks personal access token. */
+export class DatabricksPersonalAccessTokenProvider {
+    accessToken;
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+    }
+    authenticate() {
+        return Promise.resolve(this.token());
+    }
+    login() {
+        return Promise.resolve(this.token());
+    }
+    refresh() {
+        return Promise.resolve(this.token());
+    }
+    canAuthenticateSilently() {
+        return true;
+    }
+    token() {
+        logger.debug("using configured personal access token");
+        return {
+            accessToken: this.accessToken,
+            tokenType: "Bearer",
+            scopes: [],
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/src/_profile-config.d.ts

@@ -0,0 +1,43 @@
+import { AuthType, TargetKind } from "@dbx-tools/shared-auth/config";
+import type { DatabricksProfileSummary } from "@dbx-tools/shared-auth/profile";
+import type { DatabricksProfile } from "./_types.ts";
+import { type DatabricksAuthOptions } from "./config.ts";
+export declare const SETTINGS_SECTION = "__settings__";
+export type Environment = Readonly<Record<string, string | undefined>>;
+export type IniConfig = Map<string, Map<string, string>>;
+export interface RawProfile {
+    host?: string;
+    accountId?: string;
+    workspaceId?: string;
+    clientId?: string;
+    clientSecret?: string;
+    accessToken?: string;
+    groupId?: string;
+    scopes?: string;
+    authType?: string;
+}
+/** Resolve the selected Databricks configuration path. */
+export declare function resolveConfigFile(explicit?: string, environment?: Environment): string;
+/** Load and cache the selected Databricks configuration. */
+export declare function loadConfig(configFile?: string, refresh?: boolean, environment?: Environment): IniConfig | undefined;
+/** Invalidate cached configuration after an external write. */
+export declare function invalidateConfigFile(configFile?: string): void;
+/** Parse Databricks INI text through the maintained `ini` package. */
+export declare function parseDatabricksConfig(source: string): IniConfig;
+export declare function loadRawProfile(config: IniConfig | undefined, name: string): RawProfile;
+export declare function resolveProfileName(requested: string | undefined, explicit: boolean, config: IniConfig | undefined, preferUserToMachine: boolean): string;
+/** Normalize Databricks hosts and require TLS outside loopback development. */
+export declare function normalizeHost(value: string | undefined, profile?: string): string;
+export declare function resolveAuthType(authType: AuthType | undefined, clientId: string | undefined, clientSecret: string | undefined, accessToken: string | undefined): AuthType;
+/** Parse one external auth-type value into the canonical enum. */
+export declare function parseAuthType(value: string | undefined): AuthType | undefined;
+export declare function requestOboToken(headers?: Record<string, string>, headerName?: string): string | undefined;
+export declare function inferTarget(host: string | undefined, accountId: string | undefined): TargetKind;
+export declare function parseTarget(value: string): TargetKind;
+export declare function missing(profile: string, field: string): never;
+/** Enumerate secret-free profile metadata from cached configuration. */
+export declare function listDatabricksProfiles(configFile?: string, refresh?: boolean, environment?: Environment): DatabricksProfileSummary[];
+/** Resolve options, environment, request headers, and configuration into credentials. */
+export declare function resolveDatabricksProfile(options: DatabricksAuthOptions, environment?: Environment): DatabricksProfile;
+/** Normalize OAuth scopes for machine credentials. */
+export declare function machineScopes(scopes: readonly string[]): string[];