@jaypie/constructs 1.1.22 → 1.1.23

package/dist/esm/index.js

@@ -1,195 +1,18 @@
-import { Construct } from 'constructs';
 import * as cdk from 'aws-cdk-lib';
-import { Fn, CfnOutput, SecretValue, Tags, Stack, Duration } from 'aws-cdk-lib';
-import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import { Duration, Stack, Tags, RemovalPolicy, Fn, CfnOutput, SecretValue } from 'aws-cdk-lib';
+import * as s3 from 'aws-cdk-lib/aws-s3';
+import * as s3n from 'aws-cdk-lib/aws-s3-notifications';
 import { CDK } from '@jaypie/cdk';
-import { ServicePrincipal } from 'aws-cdk-lib/aws-iam';
-import { LogGroup, RetentionDays, FilterPattern } from 'aws-cdk-lib/aws-logs';
-import { HostedZone } from 'aws-cdk-lib/aws-route53';
+import { Construct } from 'constructs';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
 import * as sqs from 'aws-cdk-lib/aws-sqs';
 import * as lambdaEventSources from 'aws-cdk-lib/aws-lambda-event-sources';
+import * as secretsmanager from 'aws-cdk-lib/aws-secretsmanager';
+import { ServicePrincipal } from 'aws-cdk-lib/aws-iam';
+import { LogGroup, RetentionDays, FilterPattern } from 'aws-cdk-lib/aws-logs';
+import { HostedZone } from 'aws-cdk-lib/aws-route53';
 import * as sso from 'aws-cdk-lib/aws-sso';
 
-// It is a consumer if the environment is ephemeral
-function checkEnvIsConsumer(env = process.env) {
-    return (env.PROJECT_ENV === CDK.ENV.PERSONAL ||
-        !!env.CDK_ENV_PERSONAL ||
-        /** @deprecated */ env.PROJECT_ENV === "ephemeral" ||
-        /** @deprecated */ !!env.CDK_ENV_EPHEMERAL);
-}
-function checkEnvIsProvider(env = process.env) {
-    return env.PROJECT_ENV === CDK.ENV.SANDBOX;
-}
-function cleanName(name) {
-    return name.replace(/[^a-zA-Z0-9:-]/g, "");
-}
-function exportEnvName(name, env = process.env) {
-    let rawName;
-    if (checkEnvIsProvider(env)) {
-        rawName = `env-${env.PROJECT_ENV}-${env.PROJECT_KEY}-${name}`;
-        // Clean the entire name to only allow alphanumeric, colons, and hyphens
-        return cleanName(rawName);
-    }
-    else {
-        if (checkEnvIsConsumer(env)) {
-            rawName = `env-${CDK.ENV.SANDBOX}-${env.PROJECT_KEY}-${name}`;
-        }
-        else {
-            rawName = `env-${env.PROJECT_ENV}-${env.PROJECT_KEY}-${name}`;
-        }
-    }
-    return cleanName(rawName);
-}
-class JaypieEnvSecret extends Construct {
-    constructor(scope, id, props) {
-        super(scope, id);
-        const { consumer = checkEnvIsConsumer(), envKey, export: exportParam, provider = checkEnvIsProvider(), roleTag, vendorTag, value, } = props || {};
-        this._envKey = envKey;
-        let exportName;
-        if (!exportParam) {
-            exportName = exportEnvName(id);
-        }
-        else {
-            exportName = cleanName(exportParam);
-        }
-        if (consumer) {
-            const secretName = Fn.importValue(exportName);
-            this._secret = secretsmanager.Secret.fromSecretNameV2(this, id, secretName);
-            // Add CfnOutput for consumer secrets
-            new CfnOutput(this, `ConsumedName`, {
-                value: this._secret.secretName,
-            });
-        }
-        else {
-            const secretValue = envKey && process.env[envKey] ? process.env[envKey] : value;
-            const secretProps = {
-                secretStringValue: secretValue
-                    ? SecretValue.unsafePlainText(secretValue)
-                    : undefined,
-            };
-            this._secret = new secretsmanager.Secret(this, id, secretProps);
-            if (roleTag) {
-                Tags.of(this._secret).add(CDK.TAG.ROLE, roleTag);
-            }
-            if (vendorTag) {
-                Tags.of(this._secret).add(CDK.TAG.VENDOR, vendorTag);
-            }
-            if (provider) {
-                new CfnOutput(this, `ProvidedName`, {
-                    value: this._secret.secretName,
-                    exportName,
-                });
-            }
-            else {
-                new CfnOutput(this, `CreatedName`, {
-                    value: this._secret.secretName,
-                });
-            }
-        }
-    }
-    // IResource implementation
-    get stack() {
-        return Stack.of(this);
-    }
-    get env() {
-        return {
-            account: Stack.of(this).account,
-            region: Stack.of(this).region,
-        };
-    }
-    applyRemovalPolicy(policy) {
-        this._secret.applyRemovalPolicy(policy);
-    }
-    // ISecret implementation
-    get secretArn() {
-        return this._secret.secretArn;
-    }
-    get secretName() {
-        return this._secret.secretName;
-    }
-    get secretFullArn() {
-        return this._secret.secretFullArn;
-    }
-    get encryptionKey() {
-        return this._secret.encryptionKey;
-    }
-    get secretValue() {
-        return this._secret.secretValue;
-    }
-    secretValueFromJson(key) {
-        return this._secret.secretValueFromJson(key);
-    }
-    grantRead(grantee, versionStages) {
-        return this._secret.grantRead(grantee, versionStages);
-    }
-    grantWrite(grantee) {
-        return this._secret.grantWrite(grantee);
-    }
-    addRotationSchedule(id, options) {
-        return this._secret.addRotationSchedule(id, options);
-    }
-    addToResourcePolicy(statement) {
-        return this._secret.addToResourcePolicy(statement);
-    }
-    denyAccountRootDelete() {
-        this._secret.denyAccountRootDelete();
-    }
-    attach(target) {
-        return this._secret.attach(target);
-    }
-    get envKey() {
-        return this._envKey;
-    }
-}
-
-const SERVICE = {
-    ROUTE53: "route53.amazonaws.com",
-};
-class JaypieHostedZone extends Construct {
-    /**
-     * Create a new hosted zone with query logging
-     */
-    constructor(scope, id, props) {
-        super(scope, id);
-        const { destination, zoneName, project } = props;
-        const service = props.service || CDK.SERVICE.INFRASTRUCTURE;
-        // Create the log group
-        this.logGroup = new LogGroup(this, "LogGroup", {
-            logGroupName: process.env.PROJECT_NONCE
-                ? `/aws/route53/${zoneName}-${process.env.PROJECT_NONCE}`
-                : `/aws/route53/${zoneName}`,
-            retention: RetentionDays.ONE_WEEK,
-        });
-        // Add tags
-        cdk.Tags.of(this.logGroup).add(CDK.TAG.SERVICE, service);
-        cdk.Tags.of(this.logGroup).add(CDK.TAG.ROLE, CDK.ROLE.NETWORKING);
-        if (project) {
-            cdk.Tags.of(this.logGroup).add(CDK.TAG.PROJECT, project);
-        }
-        // Grant Route 53 permissions to write to the log group
-        this.logGroup.grantWrite(new ServicePrincipal(SERVICE.ROUTE53));
-        // Add destination if provided
-        if (destination) {
-            this.logGroup.addSubscriptionFilter("DatadogLambdaDestination", {
-                destination,
-                filterPattern: FilterPattern.allEvents(),
-            });
-        }
-        // Create the hosted zone
-        this.hostedZone = new HostedZone(this, "HostedZone", {
-            queryLogsLogGroupArn: this.logGroup.logGroupArn,
-            zoneName,
-        });
-        // Add tags
-        cdk.Tags.of(this.hostedZone).add(CDK.TAG.SERVICE, service);
-        cdk.Tags.of(this.hostedZone).add(CDK.TAG.ROLE, CDK.ROLE.NETWORKING);
-        if (project) {
-            cdk.Tags.of(this.hostedZone).add(CDK.TAG.PROJECT, project);
-        }
-    }
-}
-
 class JaypieLambda extends Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -393,30 +216,6 @@ class JaypieLambda extends Construct {
     }
 }
 
-class JaypieMongoDbSecret extends JaypieEnvSecret {
-    constructor(scope, id = "MongoConnectionString", props) {
-        const defaultProps = {
-            envKey: "MONGODB_URI",
-            roleTag: CDK.ROLE.STORAGE,
-            vendorTag: CDK.VENDOR.MONGODB,
-            ...props,
-        };
-        super(scope, id, defaultProps);
-    }
-}
-
-class JaypieOpenAiSecret extends JaypieEnvSecret {
-    constructor(scope, id = "OpenAiApiKey", props) {
-        const defaultProps = {
-            envKey: "OPENAI_API_KEY",
-            roleTag: CDK.ROLE.PROCESSING,
-            vendorTag: CDK.VENDOR.OPENAI,
-            ...props,
-        };
-        super(scope, id, defaultProps);
-    }
-}
-
 class JaypieQueuedLambda extends Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -625,6 +424,387 @@ class JaypieQueuedLambda extends Construct {
     }
 }
 
+class JaypieBucketQueuedLambda extends JaypieQueuedLambda {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const { bucketName, roleTag, vendorTag, bucketOptions = {} } = props;
+        // Create S3 Bucket
+        this._bucket = new s3.Bucket(this, "Bucket", {
+            bucketName: bucketOptions.bucketName || bucketName,
+            removalPolicy: bucketOptions.removalPolicy || RemovalPolicy.RETAIN,
+            ...bucketOptions,
+        });
+        // Add tags to bucket
+        if (roleTag) {
+            Tags.of(this._bucket).add(CDK.TAG.ROLE, roleTag);
+        }
+        if (vendorTag) {
+            Tags.of(this._bucket).add(CDK.TAG.VENDOR, vendorTag);
+        }
+        // Add an event notification from the bucket to the queue
+        this._bucket.addEventNotification(s3.EventType.OBJECT_CREATED, new s3n.SqsDestination(this.queue));
+        // Grant the lambda access to the bucket
+        this._bucket.grantReadWrite(this);
+        // Add environment variable for bucket name
+        this.lambda.addEnvironment("CDK_ENV_BUCKET_NAME", this._bucket.bucketName);
+    }
+    // Public accessors
+    get bucket() {
+        return this._bucket;
+    }
+    // IBucket implementation
+    get bucketArn() {
+        return this._bucket.bucketArn;
+    }
+    get bucketDomainName() {
+        return this._bucket.bucketDomainName;
+    }
+    get bucketDualStackDomainName() {
+        return this._bucket.bucketDualStackDomainName;
+    }
+    get bucketName() {
+        return this._bucket.bucketName;
+    }
+    get bucketRegionalDomainName() {
+        return this._bucket.bucketRegionalDomainName;
+    }
+    get bucketWebsiteDomainName() {
+        return this._bucket.bucketWebsiteDomainName;
+    }
+    get bucketWebsiteUrl() {
+        return this._bucket.bucketWebsiteUrl;
+    }
+    get encryptionKey() {
+        return this._bucket.encryptionKey;
+    }
+    get isWebsite() {
+        return this._bucket.isWebsite || false;
+    }
+    get policy() {
+        return this._bucket.policy;
+    }
+    addEventNotification(event, dest, filters) {
+        this._bucket.addEventNotification(event, dest, ...filters);
+    }
+    addObjectCreatedNotification(dest, ...filters) {
+        this._bucket.addObjectCreatedNotification(dest, ...filters);
+    }
+    addObjectRemovedNotification(dest, ...filters) {
+        this._bucket.addObjectRemovedNotification(dest, ...filters);
+    }
+    addToResourcePolicy(permission) {
+        return this._bucket.addToResourcePolicy(permission);
+    }
+    arnForObjects(objectKeyPattern) {
+        return this._bucket.arnForObjects(objectKeyPattern);
+    }
+    enableEventBridgeNotification() {
+        this._bucket.enableEventBridgeNotification();
+    }
+    grant(grantee, ...actions) {
+        return this._bucket.grant(grantee, ...actions);
+    }
+    grantDelete(grantee, objectsKeyPattern) {
+        return this._bucket.grantDelete(grantee, objectsKeyPattern);
+    }
+    grantPublicAccess(keyPrefix, ...allowedActions) {
+        return this._bucket.grantPublicAccess(keyPrefix, ...allowedActions);
+    }
+    grantPut(grantee, objectsKeyPattern) {
+        return this._bucket.grantPut(grantee, objectsKeyPattern);
+    }
+    grantPutAcl(grantee, objectsKeyPattern) {
+        return this._bucket.grantPutAcl(grantee, objectsKeyPattern);
+    }
+    grantRead(grantee, objectsKeyPattern) {
+        return this._bucket.grantRead(grantee, objectsKeyPattern);
+    }
+    grantReadWrite(grantee, objectsKeyPattern) {
+        return this._bucket.grantReadWrite(grantee, objectsKeyPattern);
+    }
+    grantWrite(grantee, objectsKeyPattern) {
+        return this._bucket.grantWrite(grantee, objectsKeyPattern);
+    }
+    onCloudTrailEvent(id, options) {
+        return this._bucket.onCloudTrailEvent(id, options);
+    }
+    onCloudTrailPutObject(id, options) {
+        return this._bucket.onCloudTrailPutObject(id, options);
+    }
+    onCloudTrailWriteObject(id, options) {
+        return this._bucket.onCloudTrailWriteObject(id, options);
+    }
+    s3UrlForObject(key) {
+        return this._bucket.s3UrlForObject(key);
+    }
+    transferAccelerationUrlForObject(key, options) {
+        return this._bucket.transferAccelerationUrlForObject(key, options);
+    }
+    urlForObject(key) {
+        return this._bucket.urlForObject(key);
+    }
+    virtualHostedUrlForObject(key, options) {
+        return this._bucket.virtualHostedUrlForObject(key, options);
+    }
+    // Bucket metrics
+    metricAllRequests(props) {
+        return this._bucket.metricAllRequests(props);
+    }
+    metricBucketSizeBytes(props) {
+        return this._bucket.metricBucketSizeBytes(props);
+    }
+    metricDeleteRequests(props) {
+        return this._bucket.metricDeleteRequests(props);
+    }
+    metricDownloadBytes(props) {
+        return this._bucket.metricDownloadBytes(props);
+    }
+    metricFirstByteLatency(props) {
+        return this._bucket.metricFirstByteLatency(props);
+    }
+    metricGetRequests(props) {
+        return this._bucket.metricGetRequests(props);
+    }
+    metricHeadRequests(props) {
+        return this._bucket.metricHeadRequests(props);
+    }
+    metricHttpRequests(props) {
+        return this._bucket.metricHttpRequests(props);
+    }
+    metricListRequests(props) {
+        return this._bucket.metricListRequests(props);
+    }
+    metricNumberOfObjects(props) {
+        return this._bucket.metricNumberOfObjects(props);
+    }
+    metricPostRequests(props) {
+        return this._bucket.metricPostRequests(props);
+    }
+    metricPutRequests(props) {
+        return this._bucket.metricPutRequests(props);
+    }
+    metricSelectRequests(props) {
+        return this._bucket.metricSelectRequests(props);
+    }
+    metricSelectScannedBytes(props) {
+        return this._bucket.metricSelectScannedBytes(props);
+    }
+    metricUploadBytes(props) {
+        return this._bucket.metricUploadBytes(props);
+    }
+    metricSelectReturnedBytes(props) {
+        return this._bucket.metricSelectReturnedBytes(props);
+    }
+    // Override applyRemovalPolicy to apply to all resources
+    applyRemovalPolicy(policy) {
+        super.applyRemovalPolicy(policy);
+        this._bucket.applyRemovalPolicy(policy);
+    }
+}
+
+// It is a consumer if the environment is ephemeral
+function checkEnvIsConsumer(env = process.env) {
+    return (env.PROJECT_ENV === CDK.ENV.PERSONAL ||
+        !!env.CDK_ENV_PERSONAL ||
+        /** @deprecated */ env.PROJECT_ENV === "ephemeral" ||
+        /** @deprecated */ !!env.CDK_ENV_EPHEMERAL);
+}
+function checkEnvIsProvider(env = process.env) {
+    return env.PROJECT_ENV === CDK.ENV.SANDBOX;
+}
+function cleanName(name) {
+    return name.replace(/[^a-zA-Z0-9:-]/g, "");
+}
+function exportEnvName(name, env = process.env) {
+    let rawName;
+    if (checkEnvIsProvider(env)) {
+        rawName = `env-${env.PROJECT_ENV}-${env.PROJECT_KEY}-${name}`;
+        // Clean the entire name to only allow alphanumeric, colons, and hyphens
+        return cleanName(rawName);
+    }
+    else {
+        if (checkEnvIsConsumer(env)) {
+            rawName = `env-${CDK.ENV.SANDBOX}-${env.PROJECT_KEY}-${name}`;
+        }
+        else {
+            rawName = `env-${env.PROJECT_ENV}-${env.PROJECT_KEY}-${name}`;
+        }
+    }
+    return cleanName(rawName);
+}
+class JaypieEnvSecret extends Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { consumer = checkEnvIsConsumer(), envKey, export: exportParam, provider = checkEnvIsProvider(), roleTag, vendorTag, value, } = props || {};
+        this._envKey = envKey;
+        let exportName;
+        if (!exportParam) {
+            exportName = exportEnvName(id);
+        }
+        else {
+            exportName = cleanName(exportParam);
+        }
+        if (consumer) {
+            const secretName = Fn.importValue(exportName);
+            this._secret = secretsmanager.Secret.fromSecretNameV2(this, id, secretName);
+            // Add CfnOutput for consumer secrets
+            new CfnOutput(this, `ConsumedName`, {
+                value: this._secret.secretName,
+            });
+        }
+        else {
+            const secretValue = envKey && process.env[envKey] ? process.env[envKey] : value;
+            const secretProps = {
+                secretStringValue: secretValue
+                    ? SecretValue.unsafePlainText(secretValue)
+                    : undefined,
+            };
+            this._secret = new secretsmanager.Secret(this, id, secretProps);
+            if (roleTag) {
+                Tags.of(this._secret).add(CDK.TAG.ROLE, roleTag);
+            }
+            if (vendorTag) {
+                Tags.of(this._secret).add(CDK.TAG.VENDOR, vendorTag);
+            }
+            if (provider) {
+                new CfnOutput(this, `ProvidedName`, {
+                    value: this._secret.secretName,
+                    exportName,
+                });
+            }
+            else {
+                new CfnOutput(this, `CreatedName`, {
+                    value: this._secret.secretName,
+                });
+            }
+        }
+    }
+    // IResource implementation
+    get stack() {
+        return Stack.of(this);
+    }
+    get env() {
+        return {
+            account: Stack.of(this).account,
+            region: Stack.of(this).region,
+        };
+    }
+    applyRemovalPolicy(policy) {
+        this._secret.applyRemovalPolicy(policy);
+    }
+    // ISecret implementation
+    get secretArn() {
+        return this._secret.secretArn;
+    }
+    get secretName() {
+        return this._secret.secretName;
+    }
+    get secretFullArn() {
+        return this._secret.secretFullArn;
+    }
+    get encryptionKey() {
+        return this._secret.encryptionKey;
+    }
+    get secretValue() {
+        return this._secret.secretValue;
+    }
+    secretValueFromJson(key) {
+        return this._secret.secretValueFromJson(key);
+    }
+    grantRead(grantee, versionStages) {
+        return this._secret.grantRead(grantee, versionStages);
+    }
+    grantWrite(grantee) {
+        return this._secret.grantWrite(grantee);
+    }
+    addRotationSchedule(id, options) {
+        return this._secret.addRotationSchedule(id, options);
+    }
+    addToResourcePolicy(statement) {
+        return this._secret.addToResourcePolicy(statement);
+    }
+    denyAccountRootDelete() {
+        this._secret.denyAccountRootDelete();
+    }
+    attach(target) {
+        return this._secret.attach(target);
+    }
+    get envKey() {
+        return this._envKey;
+    }
+}
+
+const SERVICE = {
+    ROUTE53: "route53.amazonaws.com",
+};
+class JaypieHostedZone extends Construct {
+    /**
+     * Create a new hosted zone with query logging
+     */
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { destination, zoneName, project } = props;
+        const service = props.service || CDK.SERVICE.INFRASTRUCTURE;
+        // Create the log group
+        this.logGroup = new LogGroup(this, "LogGroup", {
+            logGroupName: process.env.PROJECT_NONCE
+                ? `/aws/route53/${zoneName}-${process.env.PROJECT_NONCE}`
+                : `/aws/route53/${zoneName}`,
+            retention: RetentionDays.ONE_WEEK,
+        });
+        // Add tags
+        cdk.Tags.of(this.logGroup).add(CDK.TAG.SERVICE, service);
+        cdk.Tags.of(this.logGroup).add(CDK.TAG.ROLE, CDK.ROLE.NETWORKING);
+        if (project) {
+            cdk.Tags.of(this.logGroup).add(CDK.TAG.PROJECT, project);
+        }
+        // Grant Route 53 permissions to write to the log group
+        this.logGroup.grantWrite(new ServicePrincipal(SERVICE.ROUTE53));
+        // Add destination if provided
+        if (destination) {
+            this.logGroup.addSubscriptionFilter("DatadogLambdaDestination", {
+                destination,
+                filterPattern: FilterPattern.allEvents(),
+            });
+        }
+        // Create the hosted zone
+        this.hostedZone = new HostedZone(this, "HostedZone", {
+            queryLogsLogGroupArn: this.logGroup.logGroupArn,
+            zoneName,
+        });
+        // Add tags
+        cdk.Tags.of(this.hostedZone).add(CDK.TAG.SERVICE, service);
+        cdk.Tags.of(this.hostedZone).add(CDK.TAG.ROLE, CDK.ROLE.NETWORKING);
+        if (project) {
+            cdk.Tags.of(this.hostedZone).add(CDK.TAG.PROJECT, project);
+        }
+    }
+}
+
+class JaypieMongoDbSecret extends JaypieEnvSecret {
+    constructor(scope, id = "MongoConnectionString", props) {
+        const defaultProps = {
+            envKey: "MONGODB_URI",
+            roleTag: CDK.ROLE.STORAGE,
+            vendorTag: CDK.VENDOR.MONGODB,
+            ...props,
+        };
+        super(scope, id, defaultProps);
+    }
+}
+
+class JaypieOpenAiSecret extends JaypieEnvSecret {
+    constructor(scope, id = "OpenAiApiKey", props) {
+        const defaultProps = {
+            envKey: "OPENAI_API_KEY",
+            roleTag: CDK.ROLE.PROCESSING,
+            vendorTag: CDK.VENDOR.OPENAI,
+            ...props,
+        };
+        super(scope, id, defaultProps);
+    }
+}
+
 /**
  * Permission set types with corresponding AWS managed policies
  */
@@ -911,5 +1091,5 @@ class JaypieTraceSigningKeySecret extends JaypieEnvSecret {
     }
 }
 
-export { JaypieEnvSecret, JaypieHostedZone, JaypieLambda, JaypieMongoDbSecret, JaypieOpenAiSecret, JaypieQueuedLambda, JaypieSsoGroups, JaypieTraceSigningKeySecret, PermissionSetType };
+export { JaypieBucketQueuedLambda, JaypieEnvSecret, JaypieHostedZone, JaypieLambda, JaypieMongoDbSecret, JaypieOpenAiSecret, JaypieQueuedLambda, JaypieSsoGroups, JaypieTraceSigningKeySecret, PermissionSetType };
 //# sourceMappingURL=index.js.map