@trautonen/cdk-dns-validated-certificate 0.0.2

package/lib/lambda/handler.d.ts

@@ -0,0 +1,19 @@
+import type { CloudFormationCustomResourceEvent } from 'aws-lambda';
+export type Properties = {
+    HostedZoneId: string;
+    DomainName: string;
+    SubjectAlternativeNames?: string[];
+    CertificateRegion: string;
+    ValidationRoleArn?: string;
+    ValidationExternalId?: string;
+    CleanupValidationRecords: boolean;
+    TransparencyLoggingEnabled: boolean;
+    Tags?: Record<string, string>;
+    RemovalPolicy: string;
+};
+export declare const handler: (event: CloudFormationCustomResourceEvent) => Promise<{
+    PhysicalResourceId: string;
+    Data: {
+        Arn: string;
+    };
+}>;

package/lib/lambda/handler.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = void 0;
+const crypto = require("crypto");
+const client_acm_1 = require("@aws-sdk/client-acm");
+const client_route_53_1 = require("@aws-sdk/client-route-53");
+const client_sts_1 = require("@aws-sdk/client-sts");
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const containsSame = (array1, array2) => {
+    if (array1.length !== array2.length)
+        return false;
+    return array1.every((v1) => array2.includes(v1));
+};
+const tryFor = async (maxSeconds, timeoutError, fn) => {
+    const startTime = Date.now();
+    // eslint-disable-next-line no-constant-condition
+    for (let i = 0; true; i++) {
+        if (Date.now() > startTime + maxSeconds * 1000) {
+            throw new Error(timeoutError);
+        }
+        const result = await fn();
+        if (result !== null) {
+            return result;
+        }
+        const base = Math.pow(2, i);
+        await sleep(Math.random() * base * 50 + base * 150);
+    }
+};
+const parseProperties = (properties) => {
+    // maybe should actually parse and not just assume
+    return properties;
+};
+const parseDomainValidationRecords = (certificate) => {
+    const options = certificate.DomainValidationOptions ?? [];
+    console.log('options: ', options);
+    if (options.length > 0 && options.every((opt) => opt.ResourceRecord?.Name)) {
+        const uniqueRecords = [...new Map(options.map((opt) => [opt.ResourceRecord?.Name, opt.ResourceRecord])).values()];
+        return uniqueRecords.map((record) => {
+            return {
+                Name: record.Name,
+                Type: record.Type,
+                TTL: 30,
+                ResourceRecords: [
+                    {
+                        Value: record.Value,
+                    },
+                ],
+            };
+        });
+    }
+    return null;
+};
+const changeRecordSets = async (route53, action, records, hostedZoneId) => {
+    const changeRecordSetsInput = {
+        HostedZoneId: hostedZoneId,
+        ChangeBatch: {
+            Changes: records.map((record) => ({
+                Action: action,
+                ResourceRecordSet: record,
+            })),
+        },
+    };
+    const { ChangeInfo } = await route53.send(new client_route_53_1.ChangeResourceRecordSetsCommand(changeRecordSetsInput));
+    const result = await (0, client_route_53_1.waitUntilResourceRecordSetsChanged)({ client: route53, maxWaitTime: 180 }, { Id: ChangeInfo?.Id });
+    if (result.state !== 'SUCCESS') {
+        throw new Error(`Record sets never changed for hosted zone ${hostedZoneId}: [${result.state}] ${result.reason ?? ''}`);
+    }
+    return ChangeInfo?.Id;
+};
+const requestCertificate = async (acm, route53, requestId, properties) => {
+    const { HostedZoneId, DomainName, SubjectAlternativeNames, TransparencyLoggingEnabled } = properties;
+    console.log(`Requesting certificate for ${DomainName}`);
+    const requestCertificateInput = {
+        DomainName,
+        SubjectAlternativeNames: SubjectAlternativeNames,
+        IdempotencyToken: crypto.createHash('sha256').update(requestId).digest('hex').slice(0, 32),
+        ValidationMethod: 'DNS',
+        Options: {
+            CertificateTransparencyLoggingPreference: TransparencyLoggingEnabled ? 'ENABLED' : 'DISABLED',
+        },
+    };
+    const { CertificateArn } = await acm.send(new client_acm_1.RequestCertificateCommand(requestCertificateInput));
+    console.log(`Certificate ${CertificateArn} requested`);
+    const validationMaxSeconds = 180;
+    const validationTimeoutError = `Domain validation options were not found in ${validationMaxSeconds} seconds`;
+    const validationRecords = await tryFor(validationMaxSeconds, validationTimeoutError, async () => {
+        const describeCertificateInput = {
+            CertificateArn,
+        };
+        const { Certificate } = await acm.send(new client_acm_1.DescribeCertificateCommand(describeCertificateInput));
+        return parseDomainValidationRecords(Certificate);
+    });
+    console.log(`Upserting ${validationRecords.length} validation record(s) into hosted zone ${HostedZoneId}:`);
+    validationRecords.forEach((record) => console.log(`${record.Name} ${record.Type} ${record.ResourceRecords?.map((rr) => rr.Value).join(',')}`));
+    const changeId = await changeRecordSets(route53, 'UPSERT', validationRecords, HostedZoneId);
+    console.log(`All validation records changed succesfully for change id ${changeId}`);
+    console.log(`Waiting for certificate ${CertificateArn} to validate`);
+    const result = await (0, client_acm_1.waitUntilCertificateValidated)({ client: acm, maxWaitTime: 300 }, { CertificateArn });
+    if (result.state !== 'SUCCESS') {
+        throw new Error(`Certificate failed ${CertificateArn} to validate: [${result.state}] ${result.reason ?? ''}`);
+    }
+    console.log(`Certificate ${CertificateArn} successfully validated`);
+    return CertificateArn;
+};
+const deleteCertificate = async (acm, route53, certificateArn, hostedZoneId, cleanupValidationRecords) => {
+    console.log(`Waiting for certificate ${certificateArn} usage to drain before deletion`);
+    const waitUsageMaxSeconds = 600;
+    const waitUsageTimeoutError = `Certificate was still in use after ${waitUsageMaxSeconds} seconds`;
+    const certificate = await tryFor(waitUsageMaxSeconds, waitUsageTimeoutError, async () => {
+        const describeCertificateInput = {
+            CertificateArn: certificateArn,
+        };
+        const { Certificate } = await acm.send(new client_acm_1.DescribeCertificateCommand(describeCertificateInput));
+        const inUseBy = Certificate?.InUseBy ?? [];
+        if (inUseBy.length > 0) {
+            return null;
+        }
+        return Certificate;
+    });
+    console.log('Certificate is unused and will be deleted');
+    const validationRecords = parseDomainValidationRecords(certificate);
+    if (validationRecords && cleanupValidationRecords) {
+        console.log(`Deleting ${validationRecords.length} validation record(s) from hosted zone ${hostedZoneId}`);
+        try {
+            const changeId = await changeRecordSets(route53, 'DELETE', validationRecords, hostedZoneId);
+            console.log(`All validation records removed successfully for change id ${changeId}`);
+        }
+        catch (error) {
+            if (error instanceof client_route_53_1.InvalidChangeBatch && error.message.includes('not found')) {
+                // there's a deletion race condition where some other certificate has already deleted the records
+                console.log(`All validation records have already been removed by some other certificate`);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    console.log(`Deleting certificate ${certificateArn}`);
+    const deleteCertificateInput = {
+        CertificateArn: certificateArn,
+    };
+    await acm.send(new client_acm_1.DeleteCertificateCommand(deleteCertificateInput));
+    console.log(`Certificate ${certificateArn} successfully deleted`);
+};
+const addTags = async (acm, certificateArn, tags) => {
+    const tagList = Array.from(Object.entries(tags).map(([Key, Value]) => ({ Key, Value })));
+    const addTagsInput = {
+        CertificateArn: certificateArn,
+        Tags: tagList,
+    };
+    console.log(`Adding ${tagList.length} tags to certificate ${certificateArn}`);
+    await acm.send(new client_acm_1.AddTagsToCertificateCommand(addTagsInput));
+    console.log(`All tags successfully added to certificate ${certificateArn}`);
+};
+const shouldRequestNew = (oldProperties, newProperties) => {
+    if (oldProperties.HostedZoneId !== newProperties.HostedZoneId)
+        return true;
+    if (oldProperties.DomainName !== newProperties.DomainName)
+        return true;
+    if (oldProperties.CertificateRegion !== newProperties.CertificateRegion)
+        return true;
+    if (!containsSame(oldProperties.SubjectAlternativeNames ?? [], newProperties.SubjectAlternativeNames ?? []))
+        return true;
+    if (oldProperties.CleanupValidationRecords !== newProperties.CleanupValidationRecords)
+        return true;
+    if (oldProperties.TransparencyLoggingEnabled !== newProperties.TransparencyLoggingEnabled)
+        return true;
+    if (oldProperties.RemovalPolicy !== newProperties.RemovalPolicy)
+        return true;
+    return false;
+};
+const assumeRole = (roleArn, externalId) => {
+    if (!roleArn) {
+        return undefined;
+    }
+    return async () => {
+        const sts = new client_sts_1.STSClient({ retryMode: 'adaptive' });
+        const assumeRoleInput = {
+            RoleArn: roleArn,
+            RoleSessionName: 'CertificateRequestor',
+            ExternalId: externalId,
+        };
+        const { Credentials } = await sts.send(new client_sts_1.AssumeRoleCommand(assumeRoleInput));
+        return {
+            accessKeyId: Credentials?.AccessKeyId,
+            secretAccessKey: Credentials?.SecretAccessKey,
+            sessionToken: Credentials?.SessionToken,
+            expiration: Credentials?.Expiration,
+        };
+    };
+};
+const handler = async (event) => {
+    const properties = parseProperties(event.ResourceProperties);
+    const acm = new client_acm_1.ACMClient({ region: properties.CertificateRegion, retryMode: 'adaptive' });
+    const route53 = new client_route_53_1.Route53Client({
+        retryMode: 'adaptive',
+        credentials: assumeRole(properties.ValidationRoleArn, properties.ValidationExternalId),
+    });
+    switch (event.RequestType) {
+        case 'Create': {
+            const certificateArn = await requestCertificate(acm, route53, event.RequestId, properties);
+            if (properties.Tags && Object.entries(properties.Tags).length > 0) {
+                await addTags(acm, certificateArn, properties.Tags);
+            }
+            return {
+                PhysicalResourceId: certificateArn,
+                Data: {
+                    Arn: certificateArn,
+                },
+            };
+        }
+        case 'Update': {
+            let certificateArn = event.PhysicalResourceId;
+            if (shouldRequestNew(parseProperties(event.OldResourceProperties), properties)) {
+                certificateArn = await requestCertificate(acm, route53, event.RequestId, properties);
+            }
+            if (properties.Tags && Object.entries(properties.Tags).length > 0) {
+                await addTags(acm, certificateArn, properties.Tags);
+            }
+            return {
+                PhysicalResourceId: certificateArn,
+                Data: {
+                    Arn: certificateArn,
+                },
+            };
+        }
+        case 'Delete': {
+            const certificateArn = event.PhysicalResourceId;
+            if (properties.RemovalPolicy === 'destroy') {
+                await deleteCertificate(acm, route53, certificateArn, properties.HostedZoneId, properties.CleanupValidationRecords);
+            }
+            return {
+                PhysicalResourceId: certificateArn,
+                Data: {
+                    Arn: certificateArn,
+                },
+            };
+        }
+    }
+    throw new Error(`Invalid request type`);
+};
+exports.handler = handler;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"handler.js","sourceRoot":"","sources":["../../src/lambda/handler.ts"],"names":[],"mappings":";;;AAAA,iCAAgC;AAChC,oDAY4B;AAC5B,8DAQiC;AACjC,oDAA0F;AAiB1F,MAAM,KAAK,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAA;AAE/E,MAAM,YAAY,GAAG,CAAI,MAAW,EAAE,MAAW,EAAW,EAAE;IAC5D,IAAI,MAAM,CAAC,MAAM,KAAK,MAAM,CAAC,MAAM;QAAE,OAAO,KAAK,CAAA;IACjD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAA;AAClD,CAAC,CAAA;AAED,MAAM,MAAM,GAAG,KAAK,EAAK,UAAkB,EAAE,YAAoB,EAAE,EAA2B,EAAc,EAAE;IAC5G,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAA;IAC5B,iDAAiD;IACjD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,EAAE;QACzB,IAAI,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,GAAG,UAAU,GAAG,IAAI,EAAE;YAC9C,MAAM,IAAI,KAAK,CAAC,YAAY,CAAC,CAAA;SAC9B;QACD,MAAM,MAAM,GAAG,MAAM,EAAE,EAAE,CAAA;QACzB,IAAI,MAAM,KAAK,IAAI,EAAE;YACnB,OAAO,MAAM,CAAA;SACd;QACD,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAA;QAC3B,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE,GAAG,IAAI,GAAG,EAAE,GAAG,IAAI,GAAG,GAAG,CAAC,CAAA;KACpD;AACH,CAAC,CAAA;AAED,MAAM,eAAe,GAAG,CAAC,UAA+B,EAAc,EAAE;IACtE,kDAAkD;IAClD,OAAO,UAAmC,CAAA;AAC5C,CAAC,CAAA;AAED,MAAM,4BAA4B,GAAG,CAAC,WAA8B,EAA8B,EAAE;IAClG,MAAM,OAAO,GAAG,WAAW,CAAC,uBAAuB,IAAI,EAAE,CAAA;IACzD,OAAO,CAAC,GAAG,CAAC,WAAW,EAAE,OAAO,CAAC,CAAA;IACjC,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,cAAc,EAAE,IAAI,CAAC,EAAE;QAC1E,MAAM,aAAa,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,cAAc,EAAE,IAAK,EAAE,GAAG,CAAC,cAAe,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAA;QACnH,OAAO,aAAa,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE;YAClC,OAAO;gBACL,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,IAAI,EAAE,MAAM,CAAC,IAAI;gBACjB,GAAG,EAAE,EAAE;gBACP,eAAe,EAAE;oBACf;wBACE,KAAK,EAAE,MAAM,CAAC,KAAK;qBACpB;iBACF;aACF,CAAA;QACH,CAAC,CAAC,CAAA;KACH;IACD,OAAO,IAAI,CAAA;AACb,CAAC,CAAA;AAED,MAAM,gBAAgB,GAAG,KAAK,EAC5B,OAAsB,EACtB,MAAoB,EACpB,OAA4B,EAC5B,YAAoB,EACH,EAAE;IACnB,MAAM,qBAAqB,GAAyC;QAClE,YAAY,EAAE,YAAY;QAC1B,WAAW,EAAE;YACX,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC;gBAChC,MAAM,EAAE,MAAM;gBACd,iBAAiB,EAAE,MAAM;aAC1B,CAAC,CAAC;SACJ;KACF,CAAA;IACD,MAAM,EAAE,UAAU,EAAE,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,IAAI,iDAA+B,CAAC,qBAAqB,CAAC,CAAC,CAAA;IACrG,MAAM,MAAM,GAAG,MAAM,IAAA,oDAAkC,EAAC,EAAE,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,EAAE,EAAE,EAAE,EAAE,UAAU,EAAE,EAAE,EAAE,CAAC,CAAA;IACtH,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;QAC9B,MAAM,IAAI,KAAK,CACb,6CAA6C,YAAY,MAAM,MAAM,CAAC,KAAK,KAAK,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,CACtG,CAAA;KACF;IACD,OAAO,UAAU,EAAE,EAAG,CAAA;AACxB,CAAC,CAAA;AAED,MAAM,kBAAkB,GAAG,KAAK,EAC9B,GAAc,EACd,OAAsB,EACtB,SAAiB,EACjB,UAAsB,EACL,EAAE;IACnB,MAAM,EAAE,YAAY,EAAE,UAAU,EAAE,uBAAuB,EAAE,0BAA0B,EAAE,GAAG,UAAU,CAAA;IAEpG,OAAO,CAAC,GAAG,CAAC,8BAA8B,UAAU,EAAE,CAAC,CAAA;IAEvD,MAAM,uBAAuB,GAAmC;QAC9D,UAAU;QACV,uBAAuB,EAAE,uBAAuB;QAChD,gBAAgB,EAAE,MAAM,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC;QAC1F,gBAAgB,EAAE,KAAK;QACvB,OAAO,EAAE;YACP,wCAAwC,EAAE,0BAA0B,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU;SAC9F;KACF,CAAA;IACD,MAAM,EAAE,cAAc,EAAE,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,sCAAyB,CAAC,uBAAuB,CAAC,CAAC,CAAA;IAEjG,OAAO,CAAC,GAAG,CAAC,eAAe,cAAc,YAAY,CAAC,CAAA;IAEtD,MAAM,oBAAoB,GAAG,GAAG,CAAA;IAChC,MAAM,sBAAsB,GAAG,+CAA+C,oBAAoB,UAAU,CAAA;IAC5G,MAAM,iBAAiB,GAAG,MAAM,MAAM,CAAC,oBAAoB,EAAE,sBAAsB,EAAE,KAAK,IAAI,EAAE;QAC9F,MAAM,wBAAwB,GAAoC;YAChE,cAAc;SACf,CAAA;QACD,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,uCAA0B,CAAC,wBAAwB,CAAC,CAAC,CAAA;QAChG,OAAO,4BAA4B,CAAC,WAAY,CAAC,CAAA;IACnD,CAAC,CAAC,CAAA;IAEF,OAAO,CAAC,GAAG,CAAC,aAAa,iBAAiB,CAAC,MAAM,0CAA0C,YAAY,GAAG,CAAC,CAAA;IAC3G,iBAAiB,CAAC,OAAO,CAAC,CAAC,MAAM,EAAE,EAAE,CACnC,OAAO,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,IAAI,MAAM,CAAC,eAAe,EAAE,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,CACxG,CAAA;IACD,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAA;IAC3F,OAAO,CAAC,GAAG,CAAC,4DAA4D,QAAQ,EAAE,CAAC,CAAA;IAEnF,OAAO,CAAC,GAAG,CAAC,2BAA2B,cAAc,cAAc,CAAC,CAAA;IACpE,MAAM,MAAM,GAAG,MAAM,IAAA,0CAA6B,EAAC,EAAE,MAAM,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,EAAE,EAAE,cAAc,EAAE,CAAC,CAAA;IACzG,IAAI,MAAM,CAAC,KAAK,KAAK,SAAS,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,sBAAsB,cAAc,kBAAkB,MAAM,CAAC,KAAK,KAAK,MAAM,CAAC,MAAM,IAAI,EAAE,EAAE,CAAC,CAAA;KAC9G;IACD,OAAO,CAAC,GAAG,CAAC,eAAe,cAAc,yBAAyB,CAAC,CAAA;IACnE,OAAO,cAAe,CAAA;AACxB,CAAC,CAAA;AAED,MAAM,iBAAiB,GAAG,KAAK,EAC7B,GAAc,EACd,OAAsB,EACtB,cAAsB,EACtB,YAAoB,EACpB,wBAAiC,EAClB,EAAE;IACjB,OAAO,CAAC,GAAG,CAAC,2BAA2B,cAAc,iCAAiC,CAAC,CAAA;IAEvF,MAAM,mBAAmB,GAAG,GAAG,CAAA;IAC/B,MAAM,qBAAqB,GAAG,sCAAsC,mBAAmB,UAAU,CAAA;IACjG,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,mBAAmB,EAAE,qBAAqB,EAAE,KAAK,IAAI,EAAE;QACtF,MAAM,wBAAwB,GAAoC;YAChE,cAAc,EAAE,cAAc;SAC/B,CAAA;QACD,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,uCAA0B,CAAC,wBAAwB,CAAC,CAAC,CAAA;QAChG,MAAM,OAAO,GAAG,WAAW,EAAE,OAAO,IAAI,EAAE,CAAA;QAC1C,IAAI,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE;YACtB,OAAO,IAAI,CAAA;SACZ;QACD,OAAO,WAAY,CAAA;IACrB,CAAC,CAAC,CAAA;IACF,OAAO,CAAC,GAAG,CAAC,2CAA2C,CAAC,CAAA;IAExD,MAAM,iBAAiB,GAAG,4BAA4B,CAAC,WAAW,CAAC,CAAA;IACnE,IAAI,iBAAiB,IAAI,wBAAwB,EAAE;QACjD,OAAO,CAAC,GAAG,CAAC,YAAY,iBAAiB,CAAC,MAAM,0CAA0C,YAAY,EAAE,CAAC,CAAA;QACzG,IAAI;YACF,MAAM,QAAQ,GAAG,MAAM,gBAAgB,CAAC,OAAO,EAAE,QAAQ,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAA;YAC3F,OAAO,CAAC,GAAG,CAAC,6DAA6D,QAAQ,EAAE,CAAC,CAAA;SACrF;QAAC,OAAO,KAAK,EAAE;YACd,IAAI,KAAK,YAAY,oCAAkB,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC,EAAE;gBAC9E,iGAAiG;gBACjG,OAAO,CAAC,GAAG,CAAC,4EAA4E,CAAC,CAAA;aAC1F;iBAAM;gBACL,MAAM,KAAK,CAAA;aACZ;SACF;KACF;IAED,OAAO,CAAC,GAAG,CAAC,wBAAwB,cAAc,EAAE,CAAC,CAAA;IACrD,MAAM,sBAAsB,GAAkC;QAC5D,cAAc,EAAE,cAAc;KAC/B,CAAA;IACD,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,qCAAwB,CAAC,sBAAsB,CAAC,CAAC,CAAA;IACpE,OAAO,CAAC,GAAG,CAAC,eAAe,cAAc,uBAAuB,CAAC,CAAA;AACnE,CAAC,CAAA;AAED,MAAM,OAAO,GAAG,KAAK,EAAE,GAAc,EAAE,cAAsB,EAAE,IAA4B,EAAE,EAAE;IAC7F,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,EAAE,KAAK,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC,CAAA;IACxF,MAAM,YAAY,GAAqC;QACrD,cAAc,EAAE,cAAc;QAC9B,IAAI,EAAE,OAAO;KACd,CAAA;IAED,OAAO,CAAC,GAAG,CAAC,UAAU,OAAO,CAAC,MAAM,wBAAwB,cAAc,EAAE,CAAC,CAAA;IAC7E,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,wCAA2B,CAAC,YAAY,CAAC,CAAC,CAAA;IAC7D,OAAO,CAAC,GAAG,CAAC,8CAA8C,cAAc,EAAE,CAAC,CAAA;AAC7E,CAAC,CAAA;AAED,MAAM,gBAAgB,GAAG,CAAC,aAAyB,EAAE,aAAyB,EAAW,EAAE;IACzF,IAAI,aAAa,CAAC,YAAY,KAAK,aAAa,CAAC,YAAY;QAAE,OAAO,IAAI,CAAA;IAC1E,IAAI,aAAa,CAAC,UAAU,KAAK,aAAa,CAAC,UAAU;QAAE,OAAO,IAAI,CAAA;IACtE,IAAI,aAAa,CAAC,iBAAiB,KAAK,aAAa,CAAC,iBAAiB;QAAE,OAAO,IAAI,CAAA;IACpF,IAAI,CAAC,YAAY,CAAC,aAAa,CAAC,uBAAuB,IAAI,EAAE,EAAE,aAAa,CAAC,uBAAuB,IAAI,EAAE,CAAC;QACzG,OAAO,IAAI,CAAA;IACb,IAAI,aAAa,CAAC,wBAAwB,KAAK,aAAa,CAAC,wBAAwB;QAAE,OAAO,IAAI,CAAA;IAClG,IAAI,aAAa,CAAC,0BAA0B,KAAK,aAAa,CAAC,0BAA0B;QAAE,OAAO,IAAI,CAAA;IACtG,IAAI,aAAa,CAAC,aAAa,KAAK,aAAa,CAAC,aAAa;QAAE,OAAO,IAAI,CAAA;IAC5E,OAAO,KAAK,CAAA;AACd,CAAC,CAAA;AAED,MAAM,UAAU,GAAG,CACjB,OAA2B,EAC3B,UAA8B,EACe,EAAE;IAC/C,IAAI,CAAC,OAAO,EAAE;QACZ,OAAO,SAAS,CAAA;KACjB;IACD,OAAO,KAAK,IAAI,EAAE;QAChB,MAAM,GAAG,GAAG,IAAI,sBAAS,CAAC,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAA;QACpD,MAAM,eAAe,GAA2B;YAC9C,OAAO,EAAE,OAAO;YAChB,eAAe,EAAE,sBAAsB;YACvC,UAAU,EAAE,UAAU;SACvB,CAAA;QACD,MAAM,EAAE,WAAW,EAAE,GAAG,MAAM,GAAG,CAAC,IAAI,CAAC,IAAI,8BAAiB,CAAC,eAAe,CAAC,CAAC,CAAA;QAC9E,OAAO;YACL,WAAW,EAAE,WAAW,EAAE,WAAY;YACtC,eAAe,EAAE,WAAW,EAAE,eAAgB;YAC9C,YAAY,EAAE,WAAW,EAAE,YAAa;YACxC,UAAU,EAAE,WAAW,EAAE,UAAU;SACpC,CAAA;IACH,CAAC,CAAA;AACH,CAAC,CAAA;AAEM,MAAM,OAAO,GAAG,KAAK,EAAE,KAAwC,EAAE,EAAE;IACxE,MAAM,UAAU,GAAG,eAAe,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAA;IAE5D,MAAM,GAAG,GAAG,IAAI,sBAAS,CAAC,EAAE,MAAM,EAAE,UAAU,CAAC,iBAAiB,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC,CAAA;IAC1F,MAAM,OAAO,GAAG,IAAI,+BAAa,CAAC;QAChC,SAAS,EAAE,UAAU;QACrB,WAAW,EAAE,UAAU,CAAC,UAAU,CAAC,iBAAiB,EAAE,UAAU,CAAC,oBAAoB,CAAC;KACvF,CAAC,CAAA;IAEF,QAAQ,KAAK,CAAC,WAAW,EAAE;QACzB,KAAK,QAAQ,CAAC,CAAC;YACb,MAAM,cAAc,GAAG,MAAM,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;YAC1F,IAAI,UAAU,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;gBACjE,MAAM,OAAO,CAAC,GAAG,EAAE,cAAc,EAAE,UAAU,CAAC,IAAI,CAAC,CAAA;aACpD;YACD,OAAO;gBACL,kBAAkB,EAAE,cAAc;gBAClC,IAAI,EAAE;oBACJ,GAAG,EAAE,cAAc;iBACpB;aACF,CAAA;SACF;QACD,KAAK,QAAQ,CAAC,CAAC;YACb,IAAI,cAAc,GAAG,KAAK,CAAC,kBAAkB,CAAA;YAC7C,IAAI,gBAAgB,CAAC,eAAe,CAAC,KAAK,CAAC,qBAAqB,CAAC,EAAE,UAAU,CAAC,EAAE;gBAC9E,cAAc,GAAG,MAAM,kBAAkB,CAAC,GAAG,EAAE,OAAO,EAAE,KAAK,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;aACrF;YACD,IAAI,UAAU,CAAC,IAAI,IAAI,MAAM,CAAC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;gBACjE,MAAM,OAAO,CAAC,GAAG,EAAE,cAAc,EAAE,UAAU,CAAC,IAAI,CAAC,CAAA;aACpD;YACD,OAAO;gBACL,kBAAkB,EAAE,cAAc;gBAClC,IAAI,EAAE;oBACJ,GAAG,EAAE,cAAc;iBACpB;aACF,CAAA;SACF;QACD,KAAK,QAAQ,CAAC,CAAC;YACb,MAAM,cAAc,GAAG,KAAK,CAAC,kBAAkB,CAAA;YAC/C,IAAI,UAAU,CAAC,aAAa,KAAK,SAAS,EAAE;gBAC1C,MAAM,iBAAiB,CACrB,GAAG,EACH,OAAO,EACP,cAAc,EACd,UAAU,CAAC,YAAY,EACvB,UAAU,CAAC,wBAAwB,CACpC,CAAA;aACF;YACD,OAAO;gBACL,kBAAkB,EAAE,cAAc;gBAClC,IAAI,EAAE;oBACJ,GAAG,EAAE,cAAc;iBACpB;aACF,CAAA;SACF;KACF;IACD,MAAM,IAAI,KAAK,CAAC,sBAAsB,CAAC,CAAA;AACzC,CAAC,CAAA;AAzDY,QAAA,OAAO,WAyDnB","sourcesContent":["import * as crypto from 'crypto'\nimport {\n  ACMClient,\n  AddTagsToCertificateCommand,\n  AddTagsToCertificateCommandInput,\n  CertificateDetail,\n  DeleteCertificateCommand,\n  DeleteCertificateCommandInput,\n  DescribeCertificateCommand,\n  DescribeCertificateCommandInput,\n  RequestCertificateCommand,\n  RequestCertificateCommandInput,\n  waitUntilCertificateValidated,\n} from '@aws-sdk/client-acm'\nimport {\n  ChangeAction,\n  ChangeResourceRecordSetsCommand,\n  ChangeResourceRecordSetsCommandInput,\n  InvalidChangeBatch,\n  ResourceRecordSet,\n  Route53Client,\n  waitUntilResourceRecordSetsChanged,\n} from '@aws-sdk/client-route-53'\nimport { AssumeRoleCommand, AssumeRoleCommandInput, STSClient } from '@aws-sdk/client-sts'\nimport type { AwsCredentialIdentity, Provider } from '@aws-sdk/types'\nimport type { CloudFormationCustomResourceEvent } from 'aws-lambda'\n\nexport type Properties = {\n  HostedZoneId: string\n  DomainName: string\n  SubjectAlternativeNames?: string[]\n  CertificateRegion: string\n  ValidationRoleArn?: string\n  ValidationExternalId?: string\n  CleanupValidationRecords: boolean\n  TransparencyLoggingEnabled: boolean\n  Tags?: Record<string, string>\n  RemovalPolicy: string\n}\n\nconst sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms))\n\nconst containsSame = <T>(array1: T[], array2: T[]): boolean => {\n  if (array1.length !== array2.length) return false\n  return array1.every((v1) => array2.includes(v1))\n}\n\nconst tryFor = async <T>(maxSeconds: number, timeoutError: string, fn: () => Promise<T | null>): Promise<T> => {\n  const startTime = Date.now()\n  // eslint-disable-next-line no-constant-condition\n  for (let i = 0; true; i++) {\n    if (Date.now() > startTime + maxSeconds * 1000) {\n      throw new Error(timeoutError)\n    }\n    const result = await fn()\n    if (result !== null) {\n      return result\n    }\n    const base = Math.pow(2, i)\n    await sleep(Math.random() * base * 50 + base * 150)\n  }\n}\n\nconst parseProperties = (properties: Record<string, any>): Properties => {\n  // maybe should actually parse and not just assume\n  return properties as unknown as Properties\n}\n\nconst parseDomainValidationRecords = (certificate: CertificateDetail): ResourceRecordSet[] | null => {\n  const options = certificate.DomainValidationOptions ?? []\n  console.log('options: ', options)\n  if (options.length > 0 && options.every((opt) => opt.ResourceRecord?.Name)) {\n    const uniqueRecords = [...new Map(options.map((opt) => [opt.ResourceRecord?.Name!, opt.ResourceRecord!])).values()]\n    return uniqueRecords.map((record) => {\n      return {\n        Name: record.Name,\n        Type: record.Type,\n        TTL: 30,\n        ResourceRecords: [\n          {\n            Value: record.Value,\n          },\n        ],\n      }\n    })\n  }\n  return null\n}\n\nconst changeRecordSets = async (\n  route53: Route53Client,\n  action: ChangeAction,\n  records: ResourceRecordSet[],\n  hostedZoneId: string\n): Promise<string> => {\n  const changeRecordSetsInput: ChangeResourceRecordSetsCommandInput = {\n    HostedZoneId: hostedZoneId,\n    ChangeBatch: {\n      Changes: records.map((record) => ({\n        Action: action,\n        ResourceRecordSet: record,\n      })),\n    },\n  }\n  const { ChangeInfo } = await route53.send(new ChangeResourceRecordSetsCommand(changeRecordSetsInput))\n  const result = await waitUntilResourceRecordSetsChanged({ client: route53, maxWaitTime: 180 }, { Id: ChangeInfo?.Id })\n  if (result.state !== 'SUCCESS') {\n    throw new Error(\n      `Record sets never changed for hosted zone ${hostedZoneId}: [${result.state}] ${result.reason ?? ''}`\n    )\n  }\n  return ChangeInfo?.Id!\n}\n\nconst requestCertificate = async (\n  acm: ACMClient,\n  route53: Route53Client,\n  requestId: string,\n  properties: Properties\n): Promise<string> => {\n  const { HostedZoneId, DomainName, SubjectAlternativeNames, TransparencyLoggingEnabled } = properties\n\n  console.log(`Requesting certificate for ${DomainName}`)\n\n  const requestCertificateInput: RequestCertificateCommandInput = {\n    DomainName,\n    SubjectAlternativeNames: SubjectAlternativeNames,\n    IdempotencyToken: crypto.createHash('sha256').update(requestId).digest('hex').slice(0, 32),\n    ValidationMethod: 'DNS',\n    Options: {\n      CertificateTransparencyLoggingPreference: TransparencyLoggingEnabled ? 'ENABLED' : 'DISABLED',\n    },\n  }\n  const { CertificateArn } = await acm.send(new RequestCertificateCommand(requestCertificateInput))\n\n  console.log(`Certificate ${CertificateArn} requested`)\n\n  const validationMaxSeconds = 180\n  const validationTimeoutError = `Domain validation options were not found in ${validationMaxSeconds} seconds`\n  const validationRecords = await tryFor(validationMaxSeconds, validationTimeoutError, async () => {\n    const describeCertificateInput: DescribeCertificateCommandInput = {\n      CertificateArn,\n    }\n    const { Certificate } = await acm.send(new DescribeCertificateCommand(describeCertificateInput))\n    return parseDomainValidationRecords(Certificate!)\n  })\n\n  console.log(`Upserting ${validationRecords.length} validation record(s) into hosted zone ${HostedZoneId}:`)\n  validationRecords.forEach((record) =>\n    console.log(`${record.Name} ${record.Type} ${record.ResourceRecords?.map((rr) => rr.Value).join(',')}`)\n  )\n  const changeId = await changeRecordSets(route53, 'UPSERT', validationRecords, HostedZoneId)\n  console.log(`All validation records changed succesfully for change id ${changeId}`)\n\n  console.log(`Waiting for certificate ${CertificateArn} to validate`)\n  const result = await waitUntilCertificateValidated({ client: acm, maxWaitTime: 300 }, { CertificateArn })\n  if (result.state !== 'SUCCESS') {\n    throw new Error(`Certificate failed ${CertificateArn} to validate: [${result.state}] ${result.reason ?? ''}`)\n  }\n  console.log(`Certificate ${CertificateArn} successfully validated`)\n  return CertificateArn!\n}\n\nconst deleteCertificate = async (\n  acm: ACMClient,\n  route53: Route53Client,\n  certificateArn: string,\n  hostedZoneId: string,\n  cleanupValidationRecords: boolean\n): Promise<void> => {\n  console.log(`Waiting for certificate ${certificateArn} usage to drain before deletion`)\n\n  const waitUsageMaxSeconds = 600\n  const waitUsageTimeoutError = `Certificate was still in use after ${waitUsageMaxSeconds} seconds`\n  const certificate = await tryFor(waitUsageMaxSeconds, waitUsageTimeoutError, async () => {\n    const describeCertificateInput: DescribeCertificateCommandInput = {\n      CertificateArn: certificateArn,\n    }\n    const { Certificate } = await acm.send(new DescribeCertificateCommand(describeCertificateInput))\n    const inUseBy = Certificate?.InUseBy ?? []\n    if (inUseBy.length > 0) {\n      return null\n    }\n    return Certificate!\n  })\n  console.log('Certificate is unused and will be deleted')\n\n  const validationRecords = parseDomainValidationRecords(certificate)\n  if (validationRecords && cleanupValidationRecords) {\n    console.log(`Deleting ${validationRecords.length} validation record(s) from hosted zone ${hostedZoneId}`)\n    try {\n      const changeId = await changeRecordSets(route53, 'DELETE', validationRecords, hostedZoneId)\n      console.log(`All validation records removed successfully for change id ${changeId}`)\n    } catch (error) {\n      if (error instanceof InvalidChangeBatch && error.message.includes('not found')) {\n        // there's a deletion race condition where some other certificate has already deleted the records\n        console.log(`All validation records have already been removed by some other certificate`)\n      } else {\n        throw error\n      }\n    }\n  }\n\n  console.log(`Deleting certificate ${certificateArn}`)\n  const deleteCertificateInput: DeleteCertificateCommandInput = {\n    CertificateArn: certificateArn,\n  }\n  await acm.send(new DeleteCertificateCommand(deleteCertificateInput))\n  console.log(`Certificate ${certificateArn} successfully deleted`)\n}\n\nconst addTags = async (acm: ACMClient, certificateArn: string, tags: Record<string, string>) => {\n  const tagList = Array.from(Object.entries(tags).map(([Key, Value]) => ({ Key, Value })))\n  const addTagsInput: AddTagsToCertificateCommandInput = {\n    CertificateArn: certificateArn,\n    Tags: tagList,\n  }\n\n  console.log(`Adding ${tagList.length} tags to certificate ${certificateArn}`)\n  await acm.send(new AddTagsToCertificateCommand(addTagsInput))\n  console.log(`All tags successfully added to certificate ${certificateArn}`)\n}\n\nconst shouldRequestNew = (oldProperties: Properties, newProperties: Properties): boolean => {\n  if (oldProperties.HostedZoneId !== newProperties.HostedZoneId) return true\n  if (oldProperties.DomainName !== newProperties.DomainName) return true\n  if (oldProperties.CertificateRegion !== newProperties.CertificateRegion) return true\n  if (!containsSame(oldProperties.SubjectAlternativeNames ?? [], newProperties.SubjectAlternativeNames ?? []))\n    return true\n  if (oldProperties.CleanupValidationRecords !== newProperties.CleanupValidationRecords) return true\n  if (oldProperties.TransparencyLoggingEnabled !== newProperties.TransparencyLoggingEnabled) return true\n  if (oldProperties.RemovalPolicy !== newProperties.RemovalPolicy) return true\n  return false\n}\n\nconst assumeRole = (\n  roleArn: string | undefined,\n  externalId: string | undefined\n): Provider<AwsCredentialIdentity> | undefined => {\n  if (!roleArn) {\n    return undefined\n  }\n  return async () => {\n    const sts = new STSClient({ retryMode: 'adaptive' })\n    const assumeRoleInput: AssumeRoleCommandInput = {\n      RoleArn: roleArn,\n      RoleSessionName: 'CertificateRequestor',\n      ExternalId: externalId,\n    }\n    const { Credentials } = await sts.send(new AssumeRoleCommand(assumeRoleInput))\n    return {\n      accessKeyId: Credentials?.AccessKeyId!,\n      secretAccessKey: Credentials?.SecretAccessKey!,\n      sessionToken: Credentials?.SessionToken!,\n      expiration: Credentials?.Expiration,\n    }\n  }\n}\n\nexport const handler = async (event: CloudFormationCustomResourceEvent) => {\n  const properties = parseProperties(event.ResourceProperties)\n\n  const acm = new ACMClient({ region: properties.CertificateRegion, retryMode: 'adaptive' })\n  const route53 = new Route53Client({\n    retryMode: 'adaptive',\n    credentials: assumeRole(properties.ValidationRoleArn, properties.ValidationExternalId),\n  })\n\n  switch (event.RequestType) {\n    case 'Create': {\n      const certificateArn = await requestCertificate(acm, route53, event.RequestId, properties)\n      if (properties.Tags && Object.entries(properties.Tags).length > 0) {\n        await addTags(acm, certificateArn, properties.Tags)\n      }\n      return {\n        PhysicalResourceId: certificateArn,\n        Data: {\n          Arn: certificateArn,\n        },\n      }\n    }\n    case 'Update': {\n      let certificateArn = event.PhysicalResourceId\n      if (shouldRequestNew(parseProperties(event.OldResourceProperties), properties)) {\n        certificateArn = await requestCertificate(acm, route53, event.RequestId, properties)\n      }\n      if (properties.Tags && Object.entries(properties.Tags).length > 0) {\n        await addTags(acm, certificateArn, properties.Tags)\n      }\n      return {\n        PhysicalResourceId: certificateArn,\n        Data: {\n          Arn: certificateArn,\n        },\n      }\n    }\n    case 'Delete': {\n      const certificateArn = event.PhysicalResourceId\n      if (properties.RemovalPolicy === 'destroy') {\n        await deleteCertificate(\n          acm,\n          route53,\n          certificateArn,\n          properties.HostedZoneId,\n          properties.CleanupValidationRecords\n        )\n      }\n      return {\n        PhysicalResourceId: certificateArn,\n        Data: {\n          Arn: certificateArn,\n        },\n      }\n    }\n  }\n  throw new Error(`Invalid request type`)\n}\n"]}

package/package.json

@@ -0,0 +1,140 @@
+{
+  "name": "@trautonen/cdk-dns-validated-certificate",
+  "description": "CDK certificate construct that supports cross-region and cross-account DNS validation",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/trautonen/cdk-dns-validated-certificate.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Tapio Rautonen",
+    "email": "trautonen@users.noreply.github.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@aws-sdk/client-acm": "^3.0.0",
+    "@aws-sdk/client-route-53": "^3.0.0",
+    "@aws-sdk/client-sts": "^3.0.0",
+    "@aws-sdk/types": "^3.0.0",
+    "@types/aws-lambda": "^8.10.117",
+    "@types/jest": "^29.5.2",
+    "@types/node": "^16",
+    "@typescript-eslint/eslint-plugin": "^5",
+    "@typescript-eslint/parser": "^5",
+    "aws-cdk-lib": "2.83.1",
+    "aws-lambda": "^1.0.7",
+    "constructs": "10.0.5",
+    "esbuild": "^0.18.2",
+    "eslint": "^8",
+    "eslint-config-prettier": "^8.8.0",
+    "eslint-import-resolver-node": "^0.3.7",
+    "eslint-import-resolver-typescript": "^3.5.5",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-prettier": "^4.2.1",
+    "jest": "^29.5.0",
+    "jest-junit": "^15",
+    "jsii": "~5.0.0",
+    "jsii-diff": "^1.83.0",
+    "jsii-docgen": "^8.0.44",
+    "jsii-pacmak": "^1.83.0",
+    "npm-check-updates": "^16",
+    "prettier": "^2.8.8",
+    "projen": "^0.71.87",
+    "standard-version": "^9",
+    "ts-jest": "^29.1.0",
+    "ts-node": "^10.9.1",
+    "typescript": "^5.1.3"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.83.1",
+    "constructs": "^10.0.5"
+  },
+  "keywords": [
+    "aws",
+    "cdk",
+    "certificate",
+    "cross-account",
+    "cross-region",
+    "dns"
+  ],
+  "main": "lib/index.js",
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "version": "0.0.2",
+  "jest": {
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/(test|src)/**/*(*.)@(spec|test).ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "preset": "ts-jest",
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.dev.json"
+      }
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "stable",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {},
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.ts and run \"npx projen\"."
+}