@jaypie/constructs 1.1.61 → 1.1.62-rc.1

package/dist/cjs/JaypieDistribution.d.ts

@@ -0,0 +1,65 @@
+import { RemovalPolicy, Stack } from "aws-cdk-lib";
+import * as acm from "aws-cdk-lib/aws-certificatemanager";
+import * as cloudfront from "aws-cdk-lib/aws-cloudfront";
+import * as lambda from "aws-cdk-lib/aws-lambda";
+import * as route53 from "aws-cdk-lib/aws-route53";
+import { Construct } from "constructs";
+export interface JaypieDistributionProps extends Omit<cloudfront.DistributionProps, "certificate" | "defaultBehavior"> {
+    /**
+     * SSL certificate for the CloudFront distribution
+     * @default true (creates a new certificate)
+     */
+    certificate?: boolean | acm.ICertificate;
+    /**
+     * Override default behavior (optional if handler is provided)
+     */
+    defaultBehavior?: cloudfront.BehaviorOptions;
+    /**
+     * The origin handler - can be an IOrigin, IFunctionUrl, or IFunction
+     * If IFunction, a FunctionUrl will be created with auth NONE
+     */
+    handler?: cloudfront.IOrigin | lambda.IFunctionUrl | lambda.IFunction;
+    /**
+     * The domain name for the distribution
+     * @default mergeDomain(CDK_ENV_API_SUBDOMAIN, CDK_ENV_API_HOSTED_ZONE || CDK_ENV_HOSTED_ZONE)
+     */
+    host?: string;
+    /**
+     * Invoke mode for Lambda Function URLs
+     * @default InvokeMode.BUFFERED
+     */
+    invokeMode?: lambda.InvokeMode;
+    /**
+     * Role tag for tagging resources
+     * @default CDK.ROLE.HOSTING
+     */
+    roleTag?: string;
+    /**
+     * The hosted zone for DNS records
+     * @default CDK_ENV_API_HOSTED_ZONE || CDK_ENV_HOSTED_ZONE
+     */
+    zone?: string | route53.IHostedZone;
+}
+export declare class JaypieDistribution extends Construct implements cloudfront.IDistribution {
+    readonly certificate?: acm.ICertificate;
+    readonly distribution: cloudfront.Distribution;
+    readonly distributionArn: string;
+    readonly distributionDomainName: string;
+    readonly distributionId: string;
+    readonly domainName: string;
+    readonly functionUrl?: lambda.FunctionUrl;
+    readonly host?: string;
+    constructor(scope: Construct, id: string, props: JaypieDistributionProps);
+    private isIOrigin;
+    private isIFunctionUrl;
+    private isIFunction;
+    get env(): {
+        account: string;
+        region: string;
+    };
+    get stack(): Stack;
+    applyRemovalPolicy(policy: RemovalPolicy): void;
+    grant(identity: import("aws-cdk-lib/aws-iam").IGrantable, ...actions: string[]): import("aws-cdk-lib/aws-iam").Grant;
+    grantCreateInvalidation(identity: import("aws-cdk-lib/aws-iam").IGrantable): import("aws-cdk-lib/aws-iam").Grant;
+    get distributionRef(): cloudfront.DistributionReference;
+}

package/dist/cjs/JaypieLambda.d.ts

@@ -1,9 +1,10 @@
 import { Construct } from "constructs";
 import { Duration, Stack, RemovalPolicy } from "aws-cdk-lib";
 import * as lambda from "aws-cdk-lib/aws-lambda";
-import * as iam from "aws-cdk-lib/aws-iam";
 import * as cloudwatch from "aws-cdk-lib/aws-cloudwatch";
 import * as ec2 from "aws-cdk-lib/aws-ec2";
+import * as iam from "aws-cdk-lib/aws-iam";
+import * as logs from "aws-cdk-lib/aws-logs";
 import * as secretsmanager from "aws-cdk-lib/aws-secretsmanager";
 import { JaypieEnvSecret } from "./JaypieEnvSecret.js";
 export interface JaypieLambdaProps {
@@ -27,9 +28,8 @@ export interface JaypieLambdaProps {
     handler: string;
     initialPolicy?: iam.PolicyStatement[];
     layers?: lambda.ILayerVersion[];
-    logRetention?: number;
-    logRetentionRole?: iam.IRole;
-    logRetentionRetryOptions?: lambda.LogRetentionRetryOptions;
+    logGroup?: logs.ILogGroup;
+    logRetention?: logs.RetentionDays | number;
     maxEventAge?: Duration;
     memorySize?: number;
     paramsAndSecrets?: lambda.ParamsAndSecretsLayerVersion | boolean;

package/dist/cjs/__tests__/JaypieDistribution.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/index.cjs

@@ -16,16 +16,16 @@ var logDestinations = require('aws-cdk-lib/aws-logs-destinations');
 var s3n = require('aws-cdk-lib/aws-s3-notifications');
 var sqs = require('aws-cdk-lib/aws-sqs');
 var lambdaEventSources = require('aws-cdk-lib/aws-lambda-event-sources');
+var logs = require('aws-cdk-lib/aws-logs');
 var awsEvents = require('aws-cdk-lib/aws-events');
 var awsEventsTargets = require('aws-cdk-lib/aws-events-targets');
-var awsLogs = require('aws-cdk-lib/aws-logs');
+var cloudfront = require('aws-cdk-lib/aws-cloudfront');
+var origins = require('aws-cdk-lib/aws-cloudfront-origins');
 var cdkNextjsStandalone = require('cdk-nextjs-standalone');
 var path = require('path');
 var awsCloudtrail = require('aws-cdk-lib/aws-cloudtrail');
 var awsSso = require('aws-cdk-lib/aws-sso');
 var awsSam = require('aws-cdk-lib/aws-sam');
-var cloudfront = require('aws-cdk-lib/aws-cloudfront');
-var origins = require('aws-cdk-lib/aws-cloudfront-origins');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -56,9 +56,10 @@ var logDestinations__namespace = /*#__PURE__*/_interopNamespaceDefault(logDestin
 var s3n__namespace = /*#__PURE__*/_interopNamespaceDefault(s3n);
 var sqs__namespace = /*#__PURE__*/_interopNamespaceDefault(sqs);
 var lambdaEventSources__namespace = /*#__PURE__*/_interopNamespaceDefault(lambdaEventSources);
-var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var logs__namespace = /*#__PURE__*/_interopNamespaceDefault(logs);
 var cloudfront__namespace = /*#__PURE__*/_interopNamespaceDefault(cloudfront);
 var origins__namespace = /*#__PURE__*/_interopNamespaceDefault(origins);
+var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
 
 const CDK$2 = {
     ACCOUNT: {
@@ -900,7 +901,7 @@ class JaypieAppStack extends JaypieStack {
 class JaypieLambda extends constructs.Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { allowAllOutbound, allowPublicSubnet, architecture = lambda__namespace.Architecture.X86_64, code, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, environment: initialEnvironment = {}, envSecrets = {}, ephemeralStorageSize, filesystem, handler = "index.handler", initialPolicy, layers = [], logRetention = CDK$2.LAMBDA.LOG_RETENTION, logRetentionRole, logRetentionRetryOptions, maxEventAge, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag = CDK$2.ROLE.PROCESSING, runtime = lambda__namespace.Runtime.NODEJS_22_X, runtimeManagementMode, secrets = [], securityGroups, timeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), tracing, vendorTag, vpc, vpcSubnets, } = props;
+        const { allowAllOutbound, allowPublicSubnet, architecture = lambda__namespace.Architecture.X86_64, code, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, environment: initialEnvironment = {}, envSecrets = {}, ephemeralStorageSize, filesystem, handler = "index.handler", initialPolicy, layers = [], logGroup, logRetention = CDK$2.LAMBDA.LOG_RETENTION, maxEventAge, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag = CDK$2.ROLE.PROCESSING, runtime = lambda__namespace.Runtime.NODEJS_22_X, runtimeManagementMode, secrets = [], securityGroups, timeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), tracing, vendorTag, vpc, vpcSubnets, } = props;
         // Get base environment with defaults
         const environment = jaypieLambdaEnv({ initialEnvironment });
         const codeAsset = typeof code === "string" ? lambda__namespace.Code.fromAsset(code) : code;
@@ -926,6 +927,12 @@ class JaypieLambda extends constructs.Construct {
             paramsAndSecrets,
             options: paramsAndSecretsOptions,
         });
+        // Create LogGroup if not provided
+        const resolvedLogGroup = logGroup ??
+            new logs__namespace.LogGroup(this, "LogGroup", {
+                retention: logRetention,
+                removalPolicy: cdk.RemovalPolicy.DESTROY,
+            });
         // Create Lambda Function
         this._lambda = new lambda__namespace.Function(this, "Function", {
             allowAllOutbound,
@@ -946,9 +953,7 @@ class JaypieLambda extends constructs.Construct {
             handler,
             initialPolicy,
             layers: resolvedLayers,
-            logRetention,
-            logRetentionRole,
-            logRetentionRetryOptions,
+            logGroup: resolvedLogGroup,
             maxEventAge,
             memorySize,
             paramsAndSecrets: resolvedParamsAndSecrets,
@@ -1119,7 +1124,7 @@ class JaypieLambda extends constructs.Construct {
 class JaypieQueuedLambda extends constructs.Construct {
     constructor(scope, id, props) {
         super(scope, id);
-        const { allowAllOutbound, allowPublicSubnet, architecture, batchSize = 1, code, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, environment = {}, envSecrets = {}, ephemeralStorageSize, fifo = true, filesystem, handler = "index.handler", initialPolicy, layers = [], logRetention = CDK$2.LAMBDA.LOG_RETENTION, logRetentionRole, logRetentionRetryOptions, maxEventAge, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag, runtime = lambda__namespace.Runtime.NODEJS_22_X, runtimeManagementMode, secrets = [], securityGroups, timeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), tracing, vendorTag, visibilityTimeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), vpc, vpcSubnets, } = props;
+        const { allowAllOutbound, allowPublicSubnet, architecture, batchSize = 1, code, datadogApiKeyArn, deadLetterQueue, deadLetterQueueEnabled, deadLetterTopic, description, environment = {}, envSecrets = {}, ephemeralStorageSize, fifo = true, filesystem, handler = "index.handler", initialPolicy, layers = [], logGroup, logRetention = CDK$2.LAMBDA.LOG_RETENTION, maxEventAge, memorySize = CDK$2.LAMBDA.MEMORY_SIZE, paramsAndSecrets, paramsAndSecretsOptions, profiling, profilingGroup, provisionedConcurrentExecutions, reservedConcurrentExecutions, retryAttempts, roleTag, runtime = lambda__namespace.Runtime.NODEJS_22_X, runtimeManagementMode, secrets = [], securityGroups, timeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), tracing, vendorTag, visibilityTimeout = cdk.Duration.seconds(CDK$2.DURATION.LAMBDA_WORKER), vpc, vpcSubnets, } = props;
         // Create SQS Queue
         this._queue = new sqs__namespace.Queue(this, "Queue", {
             fifo,
@@ -1154,9 +1159,8 @@ class JaypieQueuedLambda extends constructs.Construct {
             handler,
             initialPolicy,
             layers,
+            logGroup,
             logRetention,
-            logRetentionRole,
-            logRetentionRetryOptions,
             maxEventAge,
             memorySize,
             paramsAndSecrets,
@@ -1659,6 +1663,178 @@ class JaypieDatadogForwarder extends constructs.Construct {
     }
 }
 
+class JaypieDistribution extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { certificate: certificateProp = true, handler, host: propsHost, invokeMode = lambda__namespace.InvokeMode.BUFFERED, roleTag = CDK$2.ROLE.API, zone: propsZone, defaultBehavior: propsDefaultBehavior, ...distributionProps } = props;
+        // Validate environment variables
+        if (process.env.CDK_ENV_API_SUBDOMAIN &&
+            !isValidSubdomain(process.env.CDK_ENV_API_SUBDOMAIN)) {
+            throw new Error("CDK_ENV_API_SUBDOMAIN is not a valid subdomain");
+        }
+        if (process.env.CDK_ENV_API_HOSTED_ZONE &&
+            !isValidHostname$1(process.env.CDK_ENV_API_HOSTED_ZONE)) {
+            throw new Error("CDK_ENV_API_HOSTED_ZONE is not a valid hostname");
+        }
+        if (process.env.CDK_ENV_HOSTED_ZONE &&
+            !isValidHostname$1(process.env.CDK_ENV_HOSTED_ZONE)) {
+            throw new Error("CDK_ENV_HOSTED_ZONE is not a valid hostname");
+        }
+        // Determine host from props or environment
+        let host = propsHost;
+        if (!host) {
+            try {
+                if (process.env.CDK_ENV_API_HOST_NAME) {
+                    host = process.env.CDK_ENV_API_HOST_NAME;
+                }
+                else if (process.env.CDK_ENV_API_SUBDOMAIN) {
+                    host = mergeDomain(process.env.CDK_ENV_API_SUBDOMAIN, process.env.CDK_ENV_API_HOSTED_ZONE ||
+                        process.env.CDK_ENV_HOSTED_ZONE ||
+                        "");
+                }
+            }
+            catch {
+                host = undefined;
+            }
+        }
+        if (host && !isValidHostname$1(host)) {
+            throw new Error("Host is not a valid hostname");
+        }
+        this.host = host;
+        // Determine zone from props or environment
+        const zone = propsZone || process.env.CDK_ENV_HOSTED_ZONE;
+        // Resolve the origin from handler
+        // Check order matters: IFunctionUrl before IOrigin (FunctionUrl also has bind method)
+        // IFunction before IFunctionUrl (IFunction doesn't have functionUrlId)
+        let origin;
+        if (handler) {
+            if (this.isIFunction(handler)) {
+                // Create FunctionUrl for the Lambda function
+                const functionUrl = new lambda__namespace.FunctionUrl(this, "FunctionUrl", {
+                    function: handler,
+                    authType: lambda__namespace.FunctionUrlAuthType.NONE,
+                    invokeMode,
+                });
+                this.functionUrl = functionUrl;
+                origin = new origins__namespace.FunctionUrlOrigin(functionUrl);
+            }
+            else if (this.isIFunctionUrl(handler)) {
+                origin = new origins__namespace.FunctionUrlOrigin(handler);
+            }
+            else if (this.isIOrigin(handler)) {
+                origin = handler;
+            }
+        }
+        // Build default behavior
+        let defaultBehavior;
+        if (propsDefaultBehavior) {
+            defaultBehavior = propsDefaultBehavior;
+        }
+        else if (origin) {
+            defaultBehavior = {
+                cachePolicy: cloudfront__namespace.CachePolicy.CACHING_DISABLED,
+                origin,
+                originRequestPolicy: cloudfront__namespace.OriginRequestPolicy.ALL_VIEWER,
+                viewerProtocolPolicy: cloudfront__namespace.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
+            };
+        }
+        else {
+            throw new Error("Either handler or defaultBehavior must be provided to JaypieDistribution");
+        }
+        // Resolve hosted zone and certificate
+        // Only resolve zone when we need it (for certificate or DNS)
+        let hostedZone;
+        let certificateToUse;
+        if (host && zone && certificateProp !== false) {
+            hostedZone = resolveHostedZone(this, { zone });
+            if (certificateProp === true) {
+                certificateToUse = new acm__namespace.Certificate(this, constructEnvName("Certificate"), {
+                    domainName: host,
+                    validation: acm__namespace.CertificateValidation.fromDns(hostedZone),
+                });
+                cdk.Tags.of(certificateToUse).add(CDK$2.TAG.ROLE, roleTag);
+            }
+            else if (typeof certificateProp === "object") {
+                certificateToUse = certificateProp;
+            }
+            this.certificate = certificateToUse;
+        }
+        // Create the CloudFront distribution
+        this.distribution = new cloudfront__namespace.Distribution(this, constructEnvName("Distribution"), {
+            defaultBehavior,
+            ...(host && certificateToUse
+                ? {
+                    certificate: certificateToUse,
+                    domainNames: [host],
+                }
+                : {}),
+            ...distributionProps,
+        });
+        cdk.Tags.of(this.distribution).add(CDK$2.TAG.ROLE, roleTag);
+        this.distributionArn = `arn:aws:cloudfront::${cdk.Stack.of(this).account}:distribution/${this.distribution.distributionId}`;
+        this.distributionDomainName = this.distribution.distributionDomainName;
+        this.distributionId = this.distribution.distributionId;
+        this.domainName = this.distribution.domainName;
+        // Create DNS record if we have host and zone
+        if (host && hostedZone) {
+            const record = new route53__namespace.ARecord(this, "AliasRecord", {
+                recordName: host,
+                target: route53__namespace.RecordTarget.fromAlias(new route53Targets__namespace.CloudFrontTarget(this.distribution)),
+                zone: hostedZone,
+            });
+            cdk.Tags.of(record).add(CDK$2.TAG.ROLE, CDK$2.ROLE.NETWORKING);
+        }
+    }
+    // Type guards for handler types
+    isIOrigin(handler) {
+        return (typeof handler === "object" &&
+            handler !== null &&
+            "bind" in handler &&
+            typeof handler.bind === "function");
+    }
+    isIFunctionUrl(handler) {
+        // FunctionUrl has 'url' property which is the function URL string
+        // IFunction does not have 'url' property
+        return (typeof handler === "object" &&
+            handler !== null &&
+            "url" in handler &&
+            "functionArn" in handler);
+    }
+    isIFunction(handler) {
+        // IFunction has functionArn and functionName but NOT 'url'
+        // (FunctionUrl also has functionArn but also has 'url')
+        return (typeof handler === "object" &&
+            handler !== null &&
+            "functionArn" in handler &&
+            "functionName" in handler &&
+            !("url" in handler));
+    }
+    // Implement IDistribution interface
+    get env() {
+        return {
+            account: cdk.Stack.of(this).account,
+            region: cdk.Stack.of(this).region,
+        };
+    }
+    get stack() {
+        return this.distribution.stack;
+    }
+    applyRemovalPolicy(policy) {
+        this.distribution.applyRemovalPolicy(policy);
+    }
+    grant(identity, ...actions) {
+        return this.distribution.grant(identity, ...actions);
+    }
+    grantCreateInvalidation(identity) {
+        return this.distribution.grantCreateInvalidation(identity);
+    }
+    get distributionRef() {
+        return {
+            distributionId: this.distribution.distributionId,
+        };
+    }
+}
+
 // It is a consumer if the environment is ephemeral
 function checkEnvIsConsumer(env = process.env) {
     return (env.PROJECT_ENV === CDK$2.ENV.PERSONAL ||
@@ -2118,11 +2294,11 @@ class JaypieHostedZone extends constructs.Construct {
         const destination = props.destination ?? true;
         const service = props.service || CDK$2.SERVICE.INFRASTRUCTURE;
         // Create the log group
-        this.logGroup = new awsLogs.LogGroup(this, "LogGroup", {
+        this.logGroup = new logs.LogGroup(this, "LogGroup", {
             logGroupName: process.env.PROJECT_NONCE
                 ? `/aws/route53/${zoneName}-${process.env.PROJECT_NONCE}`
                 : `/aws/route53/${zoneName}`,
-            retention: awsLogs.RetentionDays.ONE_WEEK,
+            retention: logs.RetentionDays.ONE_WEEK,
         });
         // Add tags
         cdk__namespace.Tags.of(this.logGroup).add(CDK$2.TAG.SERVICE, service);
@@ -2139,7 +2315,7 @@ class JaypieHostedZone extends constructs.Construct {
                 : destination;
             this.logGroup.addSubscriptionFilter("DatadogLambdaDestination", {
                 destination: lambdaDestination,
-                filterPattern: awsLogs.FilterPattern.allEvents(),
+                filterPattern: logs.FilterPattern.allEvents(),
             });
         }
         // Create the hosted zone
@@ -2800,7 +2976,7 @@ class JaypieWebDeploymentBucket extends constructs.Construct {
         this.bucket = new s3__namespace.Bucket(this, "DestinationBucket", {
             accessControl: s3__namespace.BucketAccessControl.BUCKET_OWNER_FULL_CONTROL,
             autoDeleteObjects: true,
-            blockPublicAccess: s3__namespace.BlockPublicAccess.BLOCK_ACLS,
+            blockPublicAccess: s3__namespace.BlockPublicAccess.BLOCK_ACLS_ONLY,
             bucketName: props.name || constructEnvName("web"),
             publicReadAccess: true,
             removalPolicy: cdk.RemovalPolicy.DESTROY,
@@ -2853,11 +3029,14 @@ class JaypieWebDeploymentBucket extends constructs.Construct {
                 actions: ["s3:ListBucket"],
                 resources: [this.bucket.bucketArn],
             }));
-            // Allow the role to deploy CDK apps
+            // Allow the role to describe the current stack
+            const stack = cdk.Stack.of(this);
             bucketDeployRole.addToPolicy(new awsIam.PolicyStatement({
                 actions: ["cloudformation:DescribeStacks"],
                 effect: awsIam.Effect.ALLOW,
-                resources: ["*"], // TODO: restrict to this stack
+                resources: [
+                    `arn:aws:cloudformation:${stack.region}:${stack.account}:stack/${stack.stackName}/*`,
+                ],
             }));
             this.deployRoleArn = bucketDeployRole.roleArn;
             // Output the deploy role ARN
@@ -2890,7 +3069,7 @@ class JaypieWebDeploymentBucket extends constructs.Construct {
             this.distribution = new cloudfront__namespace.Distribution(this, "Distribution", {
                 defaultBehavior: {
                     cachePolicy: cloudfront__namespace.CachePolicy.CACHING_DISABLED,
-                    origin: new origins__namespace.S3Origin(this.bucket),
+                    origin: new origins__namespace.S3StaticWebsiteOrigin(this.bucket),
                     viewerProtocolPolicy: cloudfront__namespace.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
                 },
                 certificate: this.certificate,
@@ -2899,7 +3078,7 @@ class JaypieWebDeploymentBucket extends constructs.Construct {
             cdk.Tags.of(this.distribution).add(CDK$2.TAG.ROLE, roleTag);
             // If this is production, enable caching on everything but index.html
             if (isProductionEnv()) {
-                this.distribution.addBehavior("/*", new origins__namespace.S3Origin(this.bucket), {
+                this.distribution.addBehavior("/*", new origins__namespace.S3StaticWebsiteOrigin(this.bucket), {
                     viewerProtocolPolicy: cloudfront__namespace.ViewerProtocolPolicy.REDIRECT_TO_HTTPS,
                     cachePolicy: cloudfront__namespace.CachePolicy.CACHING_OPTIMIZED,
                 });
@@ -3020,6 +3199,7 @@ exports.JaypieBucketQueuedLambda = JaypieBucketQueuedLambda;
 exports.JaypieDatadogBucket = JaypieDatadogBucket;
 exports.JaypieDatadogForwarder = JaypieDatadogForwarder;
 exports.JaypieDatadogSecret = JaypieDatadogSecret;
+exports.JaypieDistribution = JaypieDistribution;
 exports.JaypieDnsRecord = JaypieDnsRecord;
 exports.JaypieEnvSecret = JaypieEnvSecret;
 exports.JaypieEventsRule = JaypieEventsRule;