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

Azure Key Vault Certificates

// Copyright (c) Microsoft Corporation.
// Licensed under the MIT License.
import { uint8ArrayToString } from "@azure/core-util";
import { parseKeyVaultCertificateIdentifier } from "./identifier.js";
export function toCoreAttributes(properties) {
    return {
        recoveryLevel: properties.recoveryLevel,
        enabled: properties.enabled,
        notBefore: properties.notBefore,
        expires: properties.expiresOn,
        created: properties.createdOn,
        updated: properties.updatedOn,
    };
}
export 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,
                },
            }))
            : undefined,
        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,
    };
}
export 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 : undefined,
                daysBeforeExpiry: action.trigger ? action.trigger.daysBeforeExpiry : undefined,
                lifetimePercentage: action.trigger ? action.trigger.lifetimePercentage : undefined,
            }))
            : undefined,
        contentType: policy.secretProperties
            ? policy.secretProperties.contentType
            : undefined,
        enhancedKeyUsage: x509Properties.ekus,
        keyUsage: x509Properties.keyUsage,
        validityInMonths: x509Properties.validityInMonths,
        subject: x509Properties.subject,
        subjectAlternativeNames: 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;
}
export function toPublicIssuer(issuer = {}) {
    const parsedId = 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,
            }))
            : undefined;
    }
    return publicIssuer;
}
export function getCertificateFromCertificateBundle(certificateBundle) {
    const parsedId = 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 &&
            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,
    };
}
export function getCertificateWithPolicyFromCertificateBundle(certificateBundle) {
    const parsedId = 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 &&
            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,
    };
}
export 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,
    };
}
export function getDeletedCertificateFromItem(item) {
    const parsedId = 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 && 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 undefined;
}
export function getCertificateOperationFromCoreOperation(certificateName, operation) {
    return {
        cancellationRequested: operation.cancellationRequested,
        name: certificateName,
        issuerName: operation.issuerParameters ? operation.issuerParameters.name : undefined,
        certificateTransparency: operation.issuerParameters
            ? operation.issuerParameters.certificateTransparency
            : undefined,
        certificateType: operation.issuerParameters
            ? operation.issuerParameters.certificateType
            : undefined,
        csr: operation.csr,
        error: getCertificateOperationErrorFromErrorModel(operation.error),
        id: operation.id,
        requestId: operation.requestId,
        status: operation.status,
        statusDetails: operation.statusDetails,
        target: operation.target,
    };
}
export function coreContactsToCertificateContacts(contacts) {
    return contacts.contactList
        ? contacts.contactList.map((x) => ({ email: x.emailAddress, phone: x.phone, name: x.name }))
        : [];
}
export function getPropertiesFromCertificateBundle(certificateBundle) {
    const parsedId = 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 &&
            uint8ArrayToString(certificateBundle.x509Thumbprint, "hex"),
        recoverableDays: attributes.recoverableDays,
        preserveCertificateOrder: certificateBundle.preserveCertOrder,
    };
    return abstractProperties;
}
export 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);
            }
        },
    };
}
//# sourceMappingURL=transformations.js.map