@azure/keyvault-certificates/dist/commonjs/transformations.js

Azure Key Vault Certificates

var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var transformations_exports = {};
__export(transformations_exports, {
  coreContactsToCertificateContacts: () => coreContactsToCertificateContacts,
  getCertificateFromCertificateBundle: () => getCertificateFromCertificateBundle,
  getCertificateOperationFromCoreOperation: () => getCertificateOperationFromCoreOperation,
  getCertificateWithPolicyFromCertificateBundle: () => getCertificateWithPolicyFromCertificateBundle,
  getDeletedCertificateFromDeletedCertificateBundle: () => getDeletedCertificateFromDeletedCertificateBundle,
  getDeletedCertificateFromItem: () => getDeletedCertificateFromItem,
  getPropertiesFromCertificateBundle: () => getPropertiesFromCertificateBundle,
  mapPagedAsyncIterable: () => mapPagedAsyncIterable,
  toCoreAttributes: () => toCoreAttributes,
  toCorePolicy: () => toCorePolicy,
  toPublicIssuer: () => toPublicIssuer,
  toPublicPolicy: () => toPublicPolicy
});
module.exports = __toCommonJS(transformations_exports);
var import_core_util = require("@azure/core-util");
var import_identifier = require("./identifier.js");
function toCoreAttributes(properties) {
  return {
    recoveryLevel: properties.recoveryLevel,
    enabled: properties.enabled,
    notBefore: properties.notBefore,
    expires: properties.expiresOn,
    created: properties.createdOn,
    updated: properties.updatedOn
  };
}
function toCorePolicy(id, policy, attributes = {}) {
  let subjectAlternativeNames = {};
  if (policy.subjectAlternativeNames) {
    subjectAlternativeNames = {
      emails: policy.subjectAlternativeNames.emails,
      dnsNames: policy.subjectAlternativeNames.dnsNames,
      upns: policy.subjectAlternativeNames.userPrincipalNames,
      uris: policy.subjectAlternativeNames.uniformResourceIdentifiers,
      ipAddresses: policy.subjectAlternativeNames.ipAddresses
    };
  }
  return {
    id,
    lifetimeActions: policy.lifetimeActions ? policy.lifetimeActions.map((action) => ({
      action: { actionType: action.action },
      trigger: {
        lifetimePercentage: action.lifetimePercentage,
        daysBeforeExpiry: action.daysBeforeExpiry
      }
    })) : void 0,
    keyProperties: {
      keyType: policy.keyType,
      keySize: policy.keySize,
      reuseKey: policy.reuseKey,
      curve: policy.keyCurveName,
      exportable: policy.exportable
    },
    secretProperties: {
      contentType: policy.contentType
    },
    x509CertificateProperties: {
      subject: policy.subject,
      ekus: policy.enhancedKeyUsage,
      subjectAlternativeNames,
      keyUsage: policy.keyUsage,
      validityInMonths: policy.validityInMonths
    },
    issuerParameters: {
      name: policy.issuerName,
      certificateType: policy.certificateType,
      certificateTransparency: policy.certificateTransparency
    },
    attributes
  };
}
function toPublicPolicy(policy = {}) {
  let subjectAlternativeNames;
  const x509Properties = policy.x509CertificateProperties || {};
  if (policy.x509CertificateProperties) {
    if (x509Properties.subjectAlternativeNames) {
      const names = x509Properties.subjectAlternativeNames;
      if (names.emails && names.emails.length) {
        subjectAlternativeNames = {
          ...subjectAlternativeNames,
          emails: names.emails
        };
      }
      if (names.dnsNames && names.dnsNames.length) {
        subjectAlternativeNames = {
          ...subjectAlternativeNames,
          dnsNames: names.dnsNames
        };
      }
      if (names.upns && names.upns.length) {
        subjectAlternativeNames = {
          ...subjectAlternativeNames,
          userPrincipalNames: names.upns
        };
      }
      if (names.uris && names.uris.length) {
        subjectAlternativeNames = {
          ...subjectAlternativeNames,
          uniformResourceIdentifiers: names.uris
        };
      }
      if (names.ipAddresses && names.ipAddresses.length) {
        subjectAlternativeNames = {
          ...subjectAlternativeNames,
          ipAddresses: names.ipAddresses
        };
      }
    }
  }
  const certificatePolicy = {
    lifetimeActions: policy.lifetimeActions ? policy.lifetimeActions.map((action) => ({
      action: action.action ? action.action.actionType : void 0,
      daysBeforeExpiry: action.trigger ? action.trigger.daysBeforeExpiry : void 0,
      lifetimePercentage: action.trigger ? action.trigger.lifetimePercentage : void 0
    })) : void 0,
    contentType: policy.secretProperties ? policy.secretProperties.contentType : void 0,
    enhancedKeyUsage: x509Properties.ekus,
    keyUsage: x509Properties.keyUsage,
    validityInMonths: x509Properties.validityInMonths,
    subject: x509Properties.subject,
    subjectAlternativeNames
  };
  if (policy.attributes) {
    certificatePolicy.enabled = policy.attributes.enabled;
  }
  if (policy.keyProperties) {
    certificatePolicy.keyType = policy.keyProperties.keyType;
    certificatePolicy.keySize = policy.keyProperties.keySize;
    certificatePolicy.reuseKey = policy.keyProperties.reuseKey;
    certificatePolicy.keyCurveName = policy.keyProperties.curve;
    certificatePolicy.exportable = policy.keyProperties.exportable;
  }
  if (policy.issuerParameters) {
    certificatePolicy.issuerName = policy.issuerParameters && policy.issuerParameters.name;
    certificatePolicy.certificateType = policy.issuerParameters.certificateType;
    certificatePolicy.certificateTransparency = policy.issuerParameters.certificateTransparency;
  }
  return certificatePolicy;
}
function toPublicIssuer(issuer = {}) {
  const parsedId = (0, import_identifier.parseKeyVaultCertificateIdentifier)(issuer.id);
  const attributes = issuer.attributes || {};
  const publicIssuer = {
    id: issuer.id,
    name: parsedId.name,
    provider: issuer.provider,
    accountId: issuer.credentials && issuer.credentials.accountId,
    password: issuer.credentials && issuer.credentials.password,
    enabled: attributes.enabled,
    createdOn: attributes.created,
    updatedOn: attributes.updated
  };
  if (issuer.organizationDetails) {
    publicIssuer.organizationId = issuer.organizationDetails.id;
    publicIssuer.administratorContacts = issuer.organizationDetails.adminDetails ? issuer.organizationDetails.adminDetails.map((x) => ({
      email: x.emailAddress,
      phone: x.phone,
      firstName: x.firstName,
      lastName: x.lastName
    })) : void 0;
  }
  return publicIssuer;
}
function getCertificateFromCertificateBundle(certificateBundle) {
  const parsedId = (0, import_identifier.parseKeyVaultCertificateIdentifier)(certificateBundle.id);
  const attributes = certificateBundle.attributes || {};
  const abstractProperties = {
    createdOn: attributes.created,
    updatedOn: attributes.updated,
    expiresOn: attributes.expires,
    id: certificateBundle.id,
    enabled: attributes.enabled,
    notBefore: attributes.notBefore,
    recoveryLevel: attributes.recoveryLevel,
    name: parsedId.name,
    vaultUrl: parsedId.vaultUrl,
    version: parsedId.version,
    tags: certificateBundle.tags,
    x509Thumbprint: certificateBundle.x509Thumbprint,
    x509ThumbprintString: certificateBundle.x509Thumbprint && (0, import_core_util.uint8ArrayToString)(certificateBundle.x509Thumbprint, "hex"),
    recoverableDays: attributes.recoverableDays,
    preserveCertificateOrder: certificateBundle.preserveCertOrder
  };
  return {
    keyId: certificateBundle.kid,
    secretId: certificateBundle.sid,
    name: parsedId.name,
    cer: certificateBundle.cer,
    properties: abstractProperties
  };
}
function getCertificateWithPolicyFromCertificateBundle(certificateBundle) {
  const parsedId = (0, import_identifier.parseKeyVaultCertificateIdentifier)(certificateBundle.id);
  const attributes = certificateBundle.attributes || {};
  const policy = toPublicPolicy(certificateBundle.policy || {});
  const abstractProperties = {
    createdOn: attributes.created,
    updatedOn: attributes.updated,
    expiresOn: attributes.expires,
    id: certificateBundle.id,
    enabled: attributes.enabled,
    notBefore: attributes.notBefore,
    recoveryLevel: attributes.recoveryLevel,
    name: parsedId.name,
    vaultUrl: parsedId.vaultUrl,
    version: parsedId.version,
    tags: certificateBundle.tags,
    x509Thumbprint: certificateBundle.x509Thumbprint,
    x509ThumbprintString: certificateBundle.x509Thumbprint && (0, import_core_util.uint8ArrayToString)(certificateBundle.x509Thumbprint, "hex"),
    recoverableDays: attributes.recoverableDays,
    preserveCertificateOrder: certificateBundle.preserveCertOrder
  };
  return {
    keyId: certificateBundle.kid,
    secretId: certificateBundle.sid,
    name: parsedId.name,
    cer: certificateBundle.cer,
    policy,
    properties: abstractProperties
  };
}
function getDeletedCertificateFromDeletedCertificateBundle(certificateBundle) {
  const certificate = getCertificateWithPolicyFromCertificateBundle(certificateBundle);
  return {
    policy: certificate.policy,
    cer: certificate.cer,
    id: certificate.id,
    keyId: certificate.keyId,
    secretId: certificate.secretId,
    name: certificate.name,
    properties: certificate.properties,
    recoveryId: certificateBundle.recoveryId,
    scheduledPurgeDate: certificateBundle.scheduledPurgeDate,
    deletedOn: certificateBundle.deletedDate
  };
}
function getDeletedCertificateFromItem(item) {
  const parsedId = (0, import_identifier.parseKeyVaultCertificateIdentifier)(item.id);
  const attributes = item.attributes || {};
  const abstractProperties = {
    createdOn: attributes.created,
    updatedOn: attributes.updated,
    expiresOn: attributes.expires,
    vaultUrl: parsedId.vaultUrl,
    version: parsedId.version,
    name: parsedId.name,
    id: item.id,
    tags: item.tags,
    x509Thumbprint: item.x509Thumbprint,
    x509ThumbprintString: item.x509Thumbprint && (0, import_core_util.uint8ArrayToString)(item.x509Thumbprint, "hex"),
    recoverableDays: item.attributes?.recoverableDays,
    recoveryLevel: item.attributes?.recoveryLevel
  };
  return {
    deletedOn: item.deletedDate,
    recoveryId: item.recoveryId,
    scheduledPurgeDate: item.scheduledPurgeDate,
    name: parsedId.name,
    properties: abstractProperties
  };
}
function getCertificateOperationErrorFromErrorModel(error) {
  if (error) {
    return {
      code: error.code,
      innerError: getCertificateOperationErrorFromErrorModel(error.innerError),
      message: error.message
    };
  }
  return void 0;
}
function getCertificateOperationFromCoreOperation(certificateName, operation) {
  return {
    cancellationRequested: operation.cancellationRequested,
    name: certificateName,
    issuerName: operation.issuerParameters ? operation.issuerParameters.name : void 0,
    certificateTransparency: operation.issuerParameters ? operation.issuerParameters.certificateTransparency : void 0,
    certificateType: operation.issuerParameters ? operation.issuerParameters.certificateType : void 0,
    csr: operation.csr,
    error: getCertificateOperationErrorFromErrorModel(operation.error),
    id: operation.id,
    requestId: operation.requestId,
    status: operation.status,
    statusDetails: operation.statusDetails,
    target: operation.target
  };
}
function coreContactsToCertificateContacts(contacts) {
  return contacts.contactList ? contacts.contactList.map(
    (x) => ({ email: x.emailAddress, phone: x.phone, name: x.name })
  ) : [];
}
function getPropertiesFromCertificateBundle(certificateBundle) {
  const parsedId = (0, import_identifier.parseKeyVaultCertificateIdentifier)(certificateBundle.id);
  const attributes = certificateBundle.attributes || {};
  const abstractProperties = {
    createdOn: attributes.created,
    updatedOn: attributes.updated,
    expiresOn: attributes.expires,
    id: certificateBundle.id,
    name: parsedId.name,
    enabled: attributes.enabled,
    notBefore: attributes.notBefore,
    recoveryLevel: attributes.recoveryLevel,
    vaultUrl: parsedId.vaultUrl,
    version: parsedId.version,
    tags: certificateBundle.tags,
    x509Thumbprint: certificateBundle.x509Thumbprint,
    x509ThumbprintString: certificateBundle.x509Thumbprint && (0, import_core_util.uint8ArrayToString)(certificateBundle.x509Thumbprint, "hex"),
    recoverableDays: attributes.recoverableDays,
    preserveCertificateOrder: certificateBundle.preserveCertOrder
  };
  return abstractProperties;
}
function mapPagedAsyncIterable(iter, mapper) {
  return {
    async next() {
      const result = await iter.next();
      return {
        ...result,
        value: result.value && mapper(result.value)
      };
    },
    [Symbol.asyncIterator]() {
      return this;
    },
    async *byPage(settings) {
      const iteratorByPage = iter.byPage(settings);
      for await (const page of iteratorByPage) {
        yield page.map(mapper);
      }
    }
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  coreContactsToCertificateContacts,
  getCertificateFromCertificateBundle,
  getCertificateOperationFromCoreOperation,
  getCertificateWithPolicyFromCertificateBundle,
  getDeletedCertificateFromDeletedCertificateBundle,
  getDeletedCertificateFromItem,
  getPropertiesFromCertificateBundle,
  mapPagedAsyncIterable,
  toCoreAttributes,
  toCorePolicy,
  toPublicIssuer,
  toPublicPolicy
});
//# sourceMappingURL=transformations.js.map