@dbx-tools/auth 0.6.180 → 0.9.28

package/lib/src/_profile.js

@@ -0,0 +1,236 @@
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, resolve } from "node:path";
+import * as environmentUtils from "@dbx-tools/shared-core/environment-utils";
+import { authLogger } from "./_logging.js";
+import { cleanList, inferTarget, loadRawProfile, missing, nonempty, normalizeHost, parseDatabricksConfig, parseTarget, requestOboToken, resolveAuthKind, resolveProfileName, SETTINGS_SECTION, } from "./_profile-core.js";
+import { AuthError } from "./errors.js";
+import { AUTH_TYPE_APP_OBO, AUTH_TYPE_APP_SP, AuthKind, DEFAULT_CLIENT_ID, DEFAULT_CONFIG_FILE, } from "./types.js";
+const configCache = new Map();
+const logger = authLogger("profile");
+export { normalizeHost, parseDatabricksConfig } from "./_profile-core.js";
+/** Expand and resolve the selected Databricks CLI configuration path. */
+export function resolveConfigFile(explicit, environment = process.env) {
+    const selected = nonempty(explicit) ?? nonempty(environment.DATABRICKS_CONFIG_FILE) ?? DEFAULT_CONFIG_FILE;
+    const expanded = selected === "~"
+        ? homedir()
+        : selected.startsWith("~/")
+            ? resolve(homedir(), selected.slice(2))
+            : selected;
+    const path = isAbsolute(expanded) ? expanded : resolve(expanded);
+    logger.debug("resolved Databricks config file", {
+        path,
+        source: nonempty(explicit)
+            ? "option"
+            : nonempty(environment.DATABRICKS_CONFIG_FILE)
+                ? "environment"
+                : "default",
+    });
+    return path;
+}
+/** Invalidate the process-wide parsed configuration cache after an external write. */
+export function invalidateConfigFile(configFile) {
+    const path = resolveConfigFile(configFile);
+    configCache.delete(path);
+    logger.debug("invalidated Databricks config cache", { path });
+}
+/** Return whether a named profile exists in the selected configuration. */
+export function configProfileExists(profile, configFile) {
+    if (!profile.trim() || profile === SETTINGS_SECTION)
+        return false;
+    return loadConfig(resolveConfigFile(configFile))?.has(profile) ?? false;
+}
+/** Enumerate secret-free profile metadata from the cached CLI configuration. */
+export function listDatabricksProfiles(configFile, refresh = false, environment = process.env) {
+    const path = resolveConfigFile(configFile, environment);
+    if (refresh)
+        configCache.delete(path);
+    const config = loadConfig(path);
+    if (!config) {
+        logger.debug("listed Databricks profiles", { path, refresh, count: 0 });
+        return [];
+    }
+    const profiles = [...config.keys()]
+        .filter((name) => name !== SETTINGS_SECTION)
+        .map((name) => {
+        const profile = loadRawProfile(config, name);
+        const host = nonempty(profile.host);
+        const accountId = nonempty(profile.accountId);
+        return {
+            name,
+            ...(host ? { host } : {}),
+            ...(accountId ? { accountId } : {}),
+            ...(nonempty(profile.workspaceId) ? { workspaceId: nonempty(profile.workspaceId) } : {}),
+            target: inferTarget(host, accountId),
+            authKind: resolveAuthKind(profile.authType, profile.clientId, profile.clientSecret, profile.accessToken),
+        };
+    })
+        .sort((left, right) => left.name.localeCompare(right.name));
+    logger.debug("listed Databricks profiles", { path, refresh, count: profiles.length });
+    return profiles;
+}
+/** Resolve options, environment, request headers, and CLI configuration into one profile. */
+export function resolveDatabricksProfile(options, environment = process.env) {
+    const inApp = environmentUtils.isDatabricksAppEnv({ ...environment });
+    const environmentProfile = nonempty(environment.DATABRICKS_CONFIG_PROFILE);
+    const explicitProfile = Boolean(nonempty(options.profile) ?? environmentProfile);
+    const requestToken = requestOboToken(options.requestHeaders, options.accessTokenHeader);
+    const explicitAuthType = nonempty(options.authType)?.toLowerCase() ??
+        (!inApp && !explicitProfile
+            ? nonempty(environment.DATABRICKS_AUTH_TYPE)?.toLowerCase()
+            : undefined);
+    const appServicePrincipal = [
+        environment.DATABRICKS_HOST,
+        environment.DATABRICKS_CLIENT_ID,
+        environment.DATABRICKS_CLIENT_SECRET,
+    ].every(nonempty);
+    const selectedAuthType = !inApp || explicitProfile || explicitAuthType
+        ? explicitAuthType
+        : requestToken
+            ? AUTH_TYPE_APP_OBO
+            : appServicePrincipal
+                ? AUTH_TYPE_APP_SP
+                : undefined;
+    const appAuth = [AUTH_TYPE_APP_OBO, "app-obo", AUTH_TYPE_APP_SP, "app-sp"].includes(selectedAuthType ?? "");
+    const ignoreAmbientCredentials = explicitProfile && !appAuth;
+    const configPath = resolveConfigFile(options.configFile, environment);
+    const config = loadConfig(configPath);
+    const requestedName = nonempty(options.profile) ?? environmentProfile;
+    const profileName = resolveProfileName(requestedName, explicitProfile, config, options.preferUserToMachine);
+    const configured = loadRawProfile(config, profileName);
+    const ambient = (name) => ignoreAmbientCredentials ? undefined : nonempty(environment[name]);
+    const host = normalizeHost(options.host ?? ambient("DATABRICKS_HOST") ?? configured.host, profileName);
+    const accountId = nonempty(options.accountId) ??
+        ambient("DATABRICKS_ACCOUNT_ID") ??
+        nonempty(configured.accountId);
+    const workspaceId = nonempty(options.workspaceId) ??
+        ambient("DATABRICKS_WORKSPACE_ID") ??
+        nonempty(configured.workspaceId);
+    const clientIdValue = nonempty(options.clientId) ?? ambient("DATABRICKS_CLIENT_ID") ?? nonempty(configured.clientId);
+    const clientSecret = nonempty(options.clientSecret) ??
+        ambient("DATABRICKS_CLIENT_SECRET") ??
+        nonempty(configured.clientSecret);
+    const accessToken = selectedAuthType === AUTH_TYPE_APP_OBO || selectedAuthType === "app-obo"
+        ? requestToken
+        : (nonempty(options.accessToken) ??
+            ambient("DATABRICKS_TOKEN") ??
+            nonempty(configured.accessToken));
+    const authType = selectedAuthType ??
+        ambient("DATABRICKS_AUTH_TYPE") ??
+        nonempty(configured.authType)?.toLowerCase();
+    const authKind = resolveAuthKind(authType, clientIdValue, clientSecret, accessToken);
+    const clientId = authKind === AuthKind.UserToMachine
+        ? (clientIdValue ?? DEFAULT_CLIENT_ID)
+        : authKind === AuthKind.MachineToMachine || authKind === AuthKind.AppServicePrincipal
+            ? (clientIdValue ?? missing(profileName, "client_id"))
+            : (clientIdValue ?? "");
+    const scopes = options.scopes?.length
+        ? cleanList(options.scopes)
+        : cleanList(configured.scopes?.split(",") ?? ["all-apis"]);
+    const target = options.target ? parseTarget(options.target) : inferTarget(host, accountId);
+    const groupId = nonempty(options.groupId) ?? ambient("DATABRICKS_GROUP_ID") ?? nonempty(configured.groupId);
+    const principal = authKind === AuthKind.MachineToMachine || authKind === AuthKind.AppServicePrincipal
+        ? clientId
+        : profileName;
+    const cacheKey = credentialCacheKey({
+        name: profileName,
+        host,
+        accountId,
+        workspaceId,
+        clientId,
+        groupId,
+        scopes,
+        authKind,
+        accessToken,
+    });
+    logger.debug("resolved Databricks profile", {
+        profile: profileName,
+        host,
+        authKind,
+        target,
+        inApp,
+        explicitProfile,
+        authType: authType ?? "automatic",
+        hasAccountId: Boolean(accountId),
+        hasWorkspaceId: Boolean(workspaceId),
+        hasGroupId: Boolean(groupId),
+        scopeCount: scopes.length,
+        configPath,
+    });
+    return {
+        name: profileName,
+        host,
+        ...(accountId ? { accountId } : {}),
+        ...(workspaceId ? { workspaceId } : {}),
+        clientId,
+        ...(groupId ? { groupId } : {}),
+        scopes,
+        target,
+        authKind,
+        ...(authType ? { authType } : {}),
+        ...(clientSecret ? { clientSecret } : {}),
+        ...(accessToken ? { accessToken } : {}),
+        cacheKey,
+        principal,
+    };
+}
+function loadConfig(path) {
+    if (configCache.has(path)) {
+        const cached = configCache.get(path);
+        if (cached instanceof Error)
+            throw cached;
+        logger.debug("reused Databricks config cache", {
+            path,
+            exists: Boolean(cached),
+            profileCount: cached?.size ?? 0,
+        });
+        return cached;
+    }
+    if (!existsSync(path)) {
+        configCache.set(path, undefined);
+        logger.debug("Databricks config file not found", { path });
+        return undefined;
+    }
+    try {
+        const config = parseDatabricksConfig(readFileSync(path, "utf8"));
+        configCache.set(path, config);
+        logger.debug("parsed Databricks config file", { path, profileCount: config.size });
+        return config;
+    }
+    catch (cause) {
+        const error = cause instanceof Error ? cause : new AuthError("config", `Could not read ${path}`, { cause });
+        configCache.set(path, error);
+        throw error;
+    }
+}
+function credentialCacheKey(profile) {
+    if (profile.authKind === AuthKind.UserToMachine)
+        return profile.name;
+    if (profile.authKind === AuthKind.PersonalAccessToken) {
+        const digest = createHash("sha256")
+            .update(profile.accessToken ?? "")
+            .digest("hex");
+        return `${profile.name}-pat-${digest}`;
+    }
+    if (profile.authKind === AuthKind.AppOnBehalfOf)
+        return `${profile.name}-app-obo`;
+    const identity = [
+        profile.host,
+        profile.accountId ?? "",
+        profile.workspaceId ?? "",
+        profile.clientId,
+        profile.groupId ?? "",
+        machineScopes(profile.scopes).join(" "),
+    ].join("\0");
+    const digest = createHash("sha256").update(identity).digest("hex");
+    return `${profile.name}-${profile.authKind === AuthKind.AppServicePrincipal ? "app-sp" : "oauth-m2m"}-${digest}`;
+}
+export function effectiveScopes(scopes) {
+    return cleanList(["offline_access", ...scopes]);
+}
+export function machineScopes(scopes) {
+    const values = cleanList(scopes.length ? scopes : ["all-apis"]);
+    return [...values].sort();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"_profile.js","sourceRoot":"","sources":["../../src/_profile.ts"],"names":[],"mappings":"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","sourcesContent":["import { createHash } from \"node:crypto\";\nimport { existsSync, readFileSync } from \"node:fs\";\nimport { homedir } from \"node:os\";\nimport { isAbsolute, resolve } from \"node:path\";\n\nimport * as environmentUtils from \"@dbx-tools/shared-core/environment-utils\";\n\nimport { authLogger } from \"./_logging.ts\";\nimport {\n  cleanList,\n  type Environment,\n  inferTarget,\n  type IniConfig,\n  loadRawProfile,\n  missing,\n  nonempty,\n  normalizeHost,\n  parseDatabricksConfig,\n  parseTarget,\n  requestOboToken,\n  resolveAuthKind,\n  resolveProfileName,\n  SETTINGS_SECTION,\n} from \"./_profile-core.ts\";\nimport { AuthError } from \"./errors.ts\";\nimport {\n  AUTH_TYPE_APP_OBO,\n  AUTH_TYPE_APP_SP,\n  AuthKind,\n  type DatabricksAuthOptions,\n  type DatabricksProfile,\n  type DatabricksProfileSummary,\n  DEFAULT_CLIENT_ID,\n  DEFAULT_CONFIG_FILE,\n} from \"./types.ts\";\n\nconst configCache = new Map<string, IniConfig | Error | undefined>();\nconst logger = authLogger(\"profile\");\n\nexport { normalizeHost, parseDatabricksConfig } from \"./_profile-core.ts\";\n\n/** Expand and resolve the selected Databricks CLI configuration path. */\nexport function resolveConfigFile(\n  explicit?: string,\n  environment: Environment = process.env,\n): string {\n  const selected =\n    nonempty(explicit) ?? nonempty(environment.DATABRICKS_CONFIG_FILE) ?? DEFAULT_CONFIG_FILE;\n  const expanded =\n    selected === \"~\"\n      ? homedir()\n      : selected.startsWith(\"~/\")\n        ? resolve(homedir(), selected.slice(2))\n        : selected;\n  const path = isAbsolute(expanded) ? expanded : resolve(expanded);\n  logger.debug(\"resolved Databricks config file\", {\n    path,\n    source: nonempty(explicit)\n      ? \"option\"\n      : nonempty(environment.DATABRICKS_CONFIG_FILE)\n        ? \"environment\"\n        : \"default\",\n  });\n  return path;\n}\n\n/** Invalidate the process-wide parsed configuration cache after an external write. */\nexport function invalidateConfigFile(configFile?: string): void {\n  const path = resolveConfigFile(configFile);\n  configCache.delete(path);\n  logger.debug(\"invalidated Databricks config cache\", { path });\n}\n\n/** Return whether a named profile exists in the selected configuration. */\nexport function configProfileExists(profile: string, configFile?: string): boolean {\n  if (!profile.trim() || profile === SETTINGS_SECTION) return false;\n  return loadConfig(resolveConfigFile(configFile))?.has(profile) ?? false;\n}\n\n/** Enumerate secret-free profile metadata from the cached CLI configuration. */\nexport function listDatabricksProfiles(\n  configFile?: string,\n  refresh = false,\n  environment: Environment = process.env,\n): DatabricksProfileSummary[] {\n  const path = resolveConfigFile(configFile, environment);\n  if (refresh) configCache.delete(path);\n  const config = loadConfig(path);\n  if (!config) {\n    logger.debug(\"listed Databricks profiles\", { path, refresh, count: 0 });\n    return [];\n  }\n  const profiles = [...config.keys()]\n    .filter((name) => name !== SETTINGS_SECTION)\n    .map((name) => {\n      const profile = loadRawProfile(config, name);\n      const host = nonempty(profile.host);\n      const accountId = nonempty(profile.accountId);\n      return {\n        name,\n        ...(host ? { host } : {}),\n        ...(accountId ? { accountId } : {}),\n        ...(nonempty(profile.workspaceId) ? { workspaceId: nonempty(profile.workspaceId) } : {}),\n        target: inferTarget(host, accountId),\n        authKind: resolveAuthKind(\n          profile.authType,\n          profile.clientId,\n          profile.clientSecret,\n          profile.accessToken,\n        ),\n      };\n    })\n    .sort((left, right) => left.name.localeCompare(right.name));\n  logger.debug(\"listed Databricks profiles\", { path, refresh, count: profiles.length });\n  return profiles;\n}\n\n/** Resolve options, environment, request headers, and CLI configuration into one profile. */\nexport function resolveDatabricksProfile(\n  options: DatabricksAuthOptions,\n  environment: Environment = process.env,\n): DatabricksProfile {\n  const inApp = environmentUtils.isDatabricksAppEnv({ ...environment });\n  const environmentProfile = nonempty(environment.DATABRICKS_CONFIG_PROFILE);\n  const explicitProfile = Boolean(nonempty(options.profile) ?? environmentProfile);\n  const requestToken = requestOboToken(options.requestHeaders, options.accessTokenHeader);\n  const explicitAuthType =\n    nonempty(options.authType)?.toLowerCase() ??\n    (!inApp && !explicitProfile\n      ? nonempty(environment.DATABRICKS_AUTH_TYPE)?.toLowerCase()\n      : undefined);\n  const appServicePrincipal = [\n    environment.DATABRICKS_HOST,\n    environment.DATABRICKS_CLIENT_ID,\n    environment.DATABRICKS_CLIENT_SECRET,\n  ].every(nonempty);\n  const selectedAuthType =\n    !inApp || explicitProfile || explicitAuthType\n      ? explicitAuthType\n      : requestToken\n        ? AUTH_TYPE_APP_OBO\n        : appServicePrincipal\n          ? AUTH_TYPE_APP_SP\n          : undefined;\n  const appAuth = [AUTH_TYPE_APP_OBO, \"app-obo\", AUTH_TYPE_APP_SP, \"app-sp\"].includes(\n    selectedAuthType ?? \"\",\n  );\n  const ignoreAmbientCredentials = explicitProfile && !appAuth;\n  const configPath = resolveConfigFile(options.configFile, environment);\n  const config = loadConfig(configPath);\n  const requestedName = nonempty(options.profile) ?? environmentProfile;\n  const profileName = resolveProfileName(\n    requestedName,\n    explicitProfile,\n    config,\n    options.preferUserToMachine,\n  );\n  const configured = loadRawProfile(config, profileName);\n  const ambient = (name: keyof NodeJS.ProcessEnv): string | undefined =>\n    ignoreAmbientCredentials ? undefined : nonempty(environment[name]);\n  const host = normalizeHost(\n    options.host ?? ambient(\"DATABRICKS_HOST\") ?? configured.host,\n    profileName,\n  );\n  const accountId =\n    nonempty(options.accountId) ??\n    ambient(\"DATABRICKS_ACCOUNT_ID\") ??\n    nonempty(configured.accountId);\n  const workspaceId =\n    nonempty(options.workspaceId) ??\n    ambient(\"DATABRICKS_WORKSPACE_ID\") ??\n    nonempty(configured.workspaceId);\n  const clientIdValue =\n    nonempty(options.clientId) ?? ambient(\"DATABRICKS_CLIENT_ID\") ?? nonempty(configured.clientId);\n  const clientSecret =\n    nonempty(options.clientSecret) ??\n    ambient(\"DATABRICKS_CLIENT_SECRET\") ??\n    nonempty(configured.clientSecret);\n  const accessToken =\n    selectedAuthType === AUTH_TYPE_APP_OBO || selectedAuthType === \"app-obo\"\n      ? requestToken\n      : (nonempty(options.accessToken) ??\n        ambient(\"DATABRICKS_TOKEN\") ??\n        nonempty(configured.accessToken));\n  const authType =\n    selectedAuthType ??\n    ambient(\"DATABRICKS_AUTH_TYPE\") ??\n    nonempty(configured.authType)?.toLowerCase();\n  const authKind = resolveAuthKind(authType, clientIdValue, clientSecret, accessToken);\n  const clientId =\n    authKind === AuthKind.UserToMachine\n      ? (clientIdValue ?? DEFAULT_CLIENT_ID)\n      : authKind === AuthKind.MachineToMachine || authKind === AuthKind.AppServicePrincipal\n        ? (clientIdValue ?? missing(profileName, \"client_id\"))\n        : (clientIdValue ?? \"\");\n  const scopes = options.scopes?.length\n    ? cleanList(options.scopes)\n    : cleanList(configured.scopes?.split(\",\") ?? [\"all-apis\"]);\n  const target = options.target ? parseTarget(options.target) : inferTarget(host, accountId);\n  const groupId =\n    nonempty(options.groupId) ?? ambient(\"DATABRICKS_GROUP_ID\") ?? nonempty(configured.groupId);\n  const principal =\n    authKind === AuthKind.MachineToMachine || authKind === AuthKind.AppServicePrincipal\n      ? clientId\n      : profileName;\n  const cacheKey = credentialCacheKey({\n    name: profileName,\n    host,\n    accountId,\n    workspaceId,\n    clientId,\n    groupId,\n    scopes,\n    authKind,\n    accessToken,\n  });\n  logger.debug(\"resolved Databricks profile\", {\n    profile: profileName,\n    host,\n    authKind,\n    target,\n    inApp,\n    explicitProfile,\n    authType: authType ?? \"automatic\",\n    hasAccountId: Boolean(accountId),\n    hasWorkspaceId: Boolean(workspaceId),\n    hasGroupId: Boolean(groupId),\n    scopeCount: scopes.length,\n    configPath,\n  });\n  return {\n    name: profileName,\n    host,\n    ...(accountId ? { accountId } : {}),\n    ...(workspaceId ? { workspaceId } : {}),\n    clientId,\n    ...(groupId ? { groupId } : {}),\n    scopes,\n    target,\n    authKind,\n    ...(authType ? { authType } : {}),\n    ...(clientSecret ? { clientSecret } : {}),\n    ...(accessToken ? { accessToken } : {}),\n    cacheKey,\n    principal,\n  };\n}\n\nfunction loadConfig(path: string): IniConfig | undefined {\n  if (configCache.has(path)) {\n    const cached = configCache.get(path);\n    if (cached instanceof Error) throw cached;\n    logger.debug(\"reused Databricks config cache\", {\n      path,\n      exists: Boolean(cached),\n      profileCount: cached?.size ?? 0,\n    });\n    return cached;\n  }\n  if (!existsSync(path)) {\n    configCache.set(path, undefined);\n    logger.debug(\"Databricks config file not found\", { path });\n    return undefined;\n  }\n  try {\n    const config = parseDatabricksConfig(readFileSync(path, \"utf8\"));\n    configCache.set(path, config);\n    logger.debug(\"parsed Databricks config file\", { path, profileCount: config.size });\n    return config;\n  } catch (cause) {\n    const error =\n      cause instanceof Error ? cause : new AuthError(\"config\", `Could not read ${path}`, { cause });\n    configCache.set(path, error);\n    throw error;\n  }\n}\n\nfunction credentialCacheKey(\n  profile: Pick<\n    DatabricksProfile,\n    | \"name\"\n    | \"host\"\n    | \"accountId\"\n    | \"workspaceId\"\n    | \"clientId\"\n    | \"groupId\"\n    | \"scopes\"\n    | \"authKind\"\n    | \"accessToken\"\n  >,\n): string {\n  if (profile.authKind === AuthKind.UserToMachine) return profile.name;\n  if (profile.authKind === AuthKind.PersonalAccessToken) {\n    const digest = createHash(\"sha256\")\n      .update(profile.accessToken ?? \"\")\n      .digest(\"hex\");\n    return `${profile.name}-pat-${digest}`;\n  }\n  if (profile.authKind === AuthKind.AppOnBehalfOf) return `${profile.name}-app-obo`;\n  const identity = [\n    profile.host,\n    profile.accountId ?? \"\",\n    profile.workspaceId ?? \"\",\n    profile.clientId,\n    profile.groupId ?? \"\",\n    machineScopes(profile.scopes).join(\" \"),\n  ].join(\"\\0\");\n  const digest = createHash(\"sha256\").update(identity).digest(\"hex\");\n  return `${profile.name}-${profile.authKind === AuthKind.AppServicePrincipal ? \"app-sp\" : \"oauth-m2m\"}-${digest}`;\n}\n\nexport function effectiveScopes(scopes: readonly string[]): string[] {\n  return cleanList([\"offline_access\", ...scopes]);\n}\n\nexport function machineScopes(scopes: readonly string[]): string[] {\n  const values = cleanList(scopes.length ? scopes : [\"all-apis\"]);\n  return [...values].sort();\n}\n"]}

package/lib/src/databricks-auth.d.ts

@@ -0,0 +1,11 @@
+import { type AuthClient, type DatabricksAuthOptions, Storage } from "./types.ts";
+/** Injectable host capabilities for Databricks authentication. */
+export interface DatabricksAuthDependencies {
+    environment?: Readonly<Record<string, string | undefined>>;
+    fetch?: typeof globalThis.fetch;
+    resolveCli?: (options: {
+        install: boolean;
+    }) => Promise<string | undefined>;
+}
+/** Create a Databricks authentication client. */
+export declare function createAuthClient(options?: DatabricksAuthOptions, storage?: Storage, dependencies?: DatabricksAuthDependencies): Promise<AuthClient>;