< Summary - Envilder Node.js SDK

Information
Class: src/sdks/nodejs/src/infrastructure/azure/azure-key-vault-secret-provider.ts
Assembly: Default
File(s): src/sdks/nodejs/src/infrastructure/azure/azure-key-vault-secret-provider.ts
Tag: 605_44106794472
Line coverage
100%
Covered lines: 52
Uncovered lines: 0
Coverable lines: 52
Total lines: 149
Line coverage: 100%
Branch coverage
94%
Covered branches: 36
Total branches: 38
Branch coverage: 94.7%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

File(s)

src/sdks/nodejs/src/infrastructure/azure/azure-key-vault-secret-provider.ts

#LineLine coverage
 1import type { SecretClient } from '@azure/keyvault-secrets';
 2import type { SecretExistence } from '../../domain/contract-validation-result.js';
 3import type { ISecretExistenceChecker } from '../../domain/ports/secret-existence-checker.js';
 4import type { ISecretProvider } from '../../domain/ports/secret-provider.js';
 5import { describeError } from '../describe-error.js';
 6import { toAzureSecretName } from './azure-secret-name.js';
 7
 8/**
 9 * {@link ISecretProvider} backed by Azure Key Vault.
 10 *
 11 * Secrets are fetched in parallel. Secrets that return HTTP 404
 12 * are treated as missing and silently omitted from the result.
 13 * Each reference is mapped to its Key Vault name with
 14 * {@link toAzureSecretName}, the same rule the CLI uses.
 15 */
 16export class AzureKeyVaultSecretProvider
 17  implements ISecretProvider, ISecretExistenceChecker
 18{
 19  private readonly secretClient: SecretClient;
 20
 21  constructor(secretClient: SecretClient) {
 1622    if (!secretClient) {
 123      throw new Error('secretClient cannot be null');
 24    }
 1525    this.secretClient = secretClient;
 26  }
 27
 28  async getSecrets(names: string[]): Promise<Map<string, string>> {
 929    const result = new Map<string, string>();
 930    if (names.length === 0) {
 131      return result;
 32    }
 33
 834    for (const name of names) {
 1435      if (!name?.trim()) {
 136        throw new Error('Secret name cannot be null or empty');
 37      }
 38    }
 739    const secretNames = names.map(toAzureSecretName);
 40
 741    const entries = await Promise.all(
 42      names.map(async (name, index) => {
 1243        const value = await this.fetchSecret(secretNames[index]);
 1144        return [name, value] as const;
 45      }),
 46    );
 47
 648    for (const [name, value] of entries) {
 1149      if (value !== null) {
 950        result.set(name, value);
 51      }
 52    }
 53
 654    return result;
 55  }
 56
 57  /**
 58   * Lists the vault's secret names once, which reads metadata only, and
 59   * matches every name against it the way Key Vault does, ignoring case. A
 60   * disabled secret cannot be read, so it counts as missing. Needs the `List`
 61   * secret permission (access policies) or
 62   * `Microsoft.KeyVault/vaults/secrets/readMetadata/action` (Azure RBAC,
 63   * included in Key Vault Secrets User).
 64   */
 65  async checkSecretsExist(
 66    names: readonly string[],
 67  ): Promise<ReadonlyMap<string, SecretExistence>> {
 968    const results = new Map<string, SecretExistence>();
 969    const distinct = [...new Set(names)];
 970    if (distinct.length === 0) {
 171      return results;
 72    }
 73
 74    let enabled: Set<string>;
 875    try {
 876      enabled = await this.listEnabledSecretNames();
 77    } catch (error) {
 478      const existence = toExistence(error);
 479      for (const name of distinct) {
 880        results.set(name, existence);
 81      }
 482      return results;
 83    }
 484    for (const name of distinct) {
 785      const secretName = toAzureSecretName(name).toLowerCase();
 786      results.set(name, {
 87        status: enabled.has(secretName) ? 'exists' : 'missing',
 88      });
 89    }
 490    return results;
 91  }
 92
 93  private async listEnabledSecretNames(): Promise<Set<string>> {
 894    const enabled = new Set<string>();
 895    for await (const properties of this.secretClient.listPropertiesOfSecrets()) {
 796      if (properties.enabled !== false) {
 697        enabled.add(properties.name.toLowerCase());
 98      }
 99    }
 4100    return enabled;
 101  }
 102
 103  private async fetchSecret(name: string): Promise<string | null> {
 12104    try {
 12105      const response = await this.secretClient.getSecret(name);
 9106      return response.value ?? null;
 107    } catch (error: unknown) {
 3108      if (isNotFound(error)) {
 2109        return null;
 110      }
 1111      throw error;
 112    }
 113  }
 114}
 115
 116function isNotFound(error: unknown): boolean {
 3117  return (
 118    typeof error === 'object' &&
 119    error !== null &&
 120    'statusCode' in error &&
 121    (error as { statusCode: number }).statusCode === 404
 122  );
 123}
 124
 4125const AUTHENTICATION_ERROR_NAMES = new Set([
 126  'CredentialUnavailableError',
 127  'AuthenticationError',
 128  'AuthenticationRequiredError',
 129  'AggregateAuthenticationError',
 130]);
 131
 132function toExistence(error: unknown): SecretExistence {
 4133  const reason = describeError(error);
 134  const statusCode =
 4135    typeof error === 'object' && error !== null && 'statusCode' in error
 136      ? error.statusCode
 137      : undefined;
 138  const name =
 4139    typeof error === 'object' && error !== null && 'name' in error
 140      ? String(error.name)
 141      : '';
 4142  if (statusCode === 403) {
 1143    return { status: 'access_denied', reason };
 144  }
 3145  if (statusCode === 401 || AUTHENTICATION_ERROR_NAMES.has(name)) {
 2146    return { status: 'authentication_failed', reason };
 147  }
 1148  return { status: 'provider_error', reason };
 149}