@jaypie/constructs 1.1.34 → 1.1.36-beta.1

package/dist/cjs/JaypieLambda.d.ts

@@ -35,11 +35,12 @@ export interface JaypieLambdaProps {
 }
 export declare class JaypieLambda extends Construct implements lambda.IFunction {
     private readonly _lambda;
-    private readonly _alias?;
+    private readonly _provisioned?;
     private readonly _code;
+    private readonly _reference;
     constructor(scope: Construct, id: string, props: JaypieLambdaProps);
     get lambda(): lambda.Function;
-    get alias(): lambda.Alias | undefined;
+    get provisioned(): lambda.Alias | undefined;
     get code(): lambda.Code;
     get functionArn(): string;
     get functionName(): string;

package/dist/cjs/index.cjs

@@ -7,12 +7,12 @@ var apiGateway = require('aws-cdk-lib/aws-apigateway');
 var route53 = require('aws-cdk-lib/aws-route53');
 var route53Targets = require('aws-cdk-lib/aws-route53-targets');
 var cdk = require('@jaypie/cdk');
+var lambda = require('aws-cdk-lib/aws-lambda');
+var secretsmanager = require('aws-cdk-lib/aws-secretsmanager');
 var s3 = require('aws-cdk-lib/aws-s3');
 var s3n = require('aws-cdk-lib/aws-s3-notifications');
-var lambda = require('aws-cdk-lib/aws-lambda');
 var sqs = require('aws-cdk-lib/aws-sqs');
 var lambdaEventSources = require('aws-cdk-lib/aws-lambda-event-sources');
-var secretsmanager = require('aws-cdk-lib/aws-secretsmanager');
 var awsIam = require('aws-cdk-lib/aws-iam');
 var awsLogs = require('aws-cdk-lib/aws-logs');
 var sso = require('aws-cdk-lib/aws-sso');
@@ -41,12 +41,12 @@ var acm__namespace = /*#__PURE__*/_interopNamespaceDefault(acm);
 var apiGateway__namespace = /*#__PURE__*/_interopNamespaceDefault(apiGateway);
 var route53__namespace = /*#__PURE__*/_interopNamespaceDefault(route53);
 var route53Targets__namespace = /*#__PURE__*/_interopNamespaceDefault(route53Targets);
+var lambda__namespace = /*#__PURE__*/_interopNamespaceDefault(lambda);
+var secretsmanager__namespace = /*#__PURE__*/_interopNamespaceDefault(secretsmanager);
 var s3__namespace = /*#__PURE__*/_interopNamespaceDefault(s3);
 var s3n__namespace = /*#__PURE__*/_interopNamespaceDefault(s3n);
-var lambda__namespace = /*#__PURE__*/_interopNamespaceDefault(lambda);
 var sqs__namespace = /*#__PURE__*/_interopNamespaceDefault(sqs);
 var lambdaEventSources__namespace = /*#__PURE__*/_interopNamespaceDefault(lambdaEventSources);
-var secretsmanager__namespace = /*#__PURE__*/_interopNamespaceDefault(secretsmanager);
 var sso__namespace = /*#__PURE__*/_interopNamespaceDefault(sso);
 var cloudfront__namespace = /*#__PURE__*/_interopNamespaceDefault(cloudfront);
 var origins__namespace = /*#__PURE__*/_interopNamespaceDefault(origins);
@@ -138,186 +138,6 @@ function stackTagger(stack, { name } = {}) {
     return true;
 }
 
-class JaypieApiGateway extends constructs.Construct {
-    constructor(scope, id, props) {
-        super(scope, id);
-        const { certificate = true, handler, host: propsHost, name, roleTag = cdk.CDK.ROLE.API, zone: propsZone, } = props;
-        // Determine zone from props or environment
-        let zone = propsZone;
-        if (!zone && process.env.CDK_ENV_API_HOSTED_ZONE) {
-            zone = process.env.CDK_ENV_API_HOSTED_ZONE;
-        }
-        // Determine host from props or environment
-        let host = propsHost;
-        if (!host) {
-            if (process.env.CDK_ENV_API_HOST_NAME) {
-                host = process.env.CDK_ENV_API_HOST_NAME;
-            }
-            else if (process.env.CDK_ENV_API_SUBDOMAIN &&
-                process.env.CDK_ENV_API_HOSTED_ZONE) {
-                host = cdk.mergeDomain(process.env.CDK_ENV_API_SUBDOMAIN, process.env.CDK_ENV_API_HOSTED_ZONE);
-            }
-        }
-        const apiGatewayName = name || constructEnvName("ApiGateway");
-        const certificateName = constructEnvName("Certificate");
-        const apiDomainName = constructEnvName("ApiDomainName");
-        let hostedZone;
-        let certificateToUse;
-        if (host && zone) {
-            if (typeof zone === "string") {
-                hostedZone = route53__namespace.HostedZone.fromLookup(this, "HostedZone", {
-                    domainName: zone,
-                });
-            }
-            else {
-                hostedZone = zone;
-            }
-            if (certificate === true) {
-                certificateToUse = new acm__namespace.Certificate(this, certificateName, {
-                    domainName: host,
-                    validation: acm__namespace.CertificateValidation.fromDns(hostedZone),
-                });
-                cdk$1.Tags.of(certificateToUse).add(cdk.CDK.TAG.ROLE, cdk.CDK.ROLE.HOSTING);
-            }
-            else if (typeof certificate === "object") {
-                certificateToUse = certificate;
-            }
-            this._certificate = certificateToUse;
-            this._host = host;
-        }
-        const { 
-        // * `...lambdaRestApiProps` cannot be moved to the first const destructuring because it needs to exclude the custom properties first.
-        // Ignore the variables we already assigned to other properties
-        /* eslint-disable @typescript-eslint/no-unused-vars */
-        certificate: _certificate, host: _host, name: _name, roleTag: _roleTag, zone: _zone, handler: _handler, 
-        /* eslint-enable @typescript-eslint/no-unused-vars */
-        ...lambdaRestApiProps } = props;
-        this._api = new apiGateway__namespace.LambdaRestApi(this, apiGatewayName, {
-            handler,
-            ...lambdaRestApiProps,
-        });
-        cdk$1.Tags.of(this._api).add(cdk.CDK.TAG.ROLE, roleTag);
-        if (host && certificateToUse && hostedZone) {
-            this._domainName = this._api.addDomainName(apiDomainName, {
-                domainName: host,
-                certificate: certificateToUse,
-            });
-            cdk$1.Tags.of(this._domainName).add(cdk.CDK.TAG.ROLE, roleTag);
-            const record = new route53__namespace.ARecord(this, "AliasRecord", {
-                recordName: host,
-                target: route53__namespace.RecordTarget.fromAlias(new route53Targets__namespace.ApiGatewayDomain(this._domainName)),
-                zone: hostedZone,
-            });
-            cdk$1.Tags.of(record).add(cdk.CDK.TAG.ROLE, cdk.CDK.ROLE.NETWORKING);
-        }
-    }
-    get api() {
-        return this._api;
-    }
-    get url() {
-        return this._api.url;
-    }
-    get certificateArn() {
-        return this._certificate?.certificateArn;
-    }
-    get domainName() {
-        return this._domainName?.domainName;
-    }
-    get host() {
-        return this._host;
-    }
-    get restApiId() {
-        return this._api.restApiId;
-    }
-    get restApiName() {
-        return this._api.restApiName;
-    }
-    get restApiRootResourceId() {
-        return this._api.restApiRootResourceId;
-    }
-    get deploymentStage() {
-        return this._api.deploymentStage;
-    }
-    get domainNameAliasDomainName() {
-        return this._domainName?.domainNameAliasDomainName;
-    }
-    get domainNameAliasHostedZoneId() {
-        return this._domainName?.domainNameAliasHostedZoneId;
-    }
-    get root() {
-        return this._api.root;
-    }
-    get env() {
-        return {
-            account: cdk$1.Stack.of(this).account,
-            region: cdk$1.Stack.of(this).region,
-        };
-    }
-    get stack() {
-        return this._api.stack;
-    }
-    arnForExecuteApi(method, path, stage) {
-        return this._api.arnForExecuteApi(method, path, stage);
-    }
-    metric(metricName, props) {
-        return this._api.metric(metricName, props);
-    }
-    metricCacheHitCount(props) {
-        return this._api.metricCacheHitCount(props);
-    }
-    metricCacheMissCount(props) {
-        return this._api.metricCacheMissCount(props);
-    }
-    metricClientError(props) {
-        return this._api.metricClientError(props);
-    }
-    metricCount(props) {
-        return this._api.metricCount(props);
-    }
-    metricIntegrationLatency(props) {
-        return this._api.metricIntegrationLatency(props);
-    }
-    metricLatency(props) {
-        return this._api.metricLatency(props);
-    }
-    metricServerError(props) {
-        return this._api.metricServerError(props);
-    }
-    applyRemovalPolicy(policy) {
-        this._api.applyRemovalPolicy(policy);
-    }
-}
-
-class JaypieStack extends cdk$1.Stack {
-    constructor(scope, id, props = {}) {
-        const { key, ...stackProps } = props;
-        // Handle stackName
-        if (!stackProps.stackName) {
-            stackProps.stackName = constructStackName(key);
-        }
-        // Handle env
-        stackProps.env = {
-            account: process.env.CDK_DEFAULT_ACCOUNT,
-            region: process.env.CDK_DEFAULT_REGION,
-            ...stackProps.env,
-        };
-        super(scope, id, stackProps);
-        // Apply tags
-        stackTagger(this, { name: stackProps.stackName });
-    }
-}
-
-class JaypieAppStack extends JaypieStack {
-    constructor(scope, id, props = {}) {
-        const { key = "app", ...stackProps } = props;
-        // Handle stackName
-        if (!stackProps.stackName) {
-            stackProps.stackName = constructStackName(key);
-        }
-        super(scope, id, { key, ...stackProps });
-    }
-}
-
 class JaypieLambda extends constructs.Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -460,7 +280,6 @@ class JaypieLambda extends constructs.Construct {
         });
         // Grant read permissions for JaypieEnvSecrets
         secrets.forEach((secret) => {
-            secret.grantRead(this);
             secret.grantRead(this._lambda);
         });
         // Grant Datadog API key read permission if applicable
@@ -473,13 +292,13 @@ class JaypieLambda extends constructs.Construct {
             // Use currentVersion which is auto-published with proper configuration
             const version = this._lambda.currentVersion;
             // Create alias for provisioned concurrency
-            this._alias = new lambda__namespace.Alias(this, "ProvisionedAlias", {
+            this._provisioned = new lambda__namespace.Alias(this, "ProvisionedAlias", {
                 aliasName: "provisioned",
                 version,
                 provisionedConcurrentExecutions,
             });
             // Add explicit dependencies to ensure proper creation order
-            this._alias.node.addDependency(version);
+            this._provisioned.node.addDependency(version);
         }
         if (roleTag) {
             cdk$1.Tags.of(this._lambda).add(cdk.CDK.TAG.ROLE, roleTag);
@@ -487,100 +306,230 @@ class JaypieLambda extends constructs.Construct {
         if (vendorTag) {
             cdk$1.Tags.of(this._lambda).add(cdk.CDK.TAG.VENDOR, vendorTag);
         }
+        // Assign _reference based on provisioned state
+        this._reference =
+            this._provisioned !== undefined ? this._provisioned : this._lambda;
     }
     // Public accessors
     get lambda() {
         return this._lambda;
     }
-    get alias() {
-        return this._alias;
+    get provisioned() {
+        return this._provisioned;
     }
     get code() {
         return this._code;
     }
     // IFunction implementation
     get functionArn() {
-        return this._alias?.functionArn ?? this._lambda.functionArn;
+        return this._reference.functionArn;
     }
     get functionName() {
-        return this._alias?.functionName ?? this._lambda.functionName;
+        return this._reference.functionName;
     }
     get grantPrincipal() {
-        return this._lambda.grantPrincipal;
+        return this._reference.grantPrincipal;
     }
     get role() {
-        return this._lambda.role;
+        return this._reference.role;
     }
     get architecture() {
-        return this._lambda.architecture;
+        return this._reference.architecture;
     }
     get connections() {
-        return this._lambda.connections;
+        return this._reference.connections;
     }
     get isBoundToVpc() {
-        return this._lambda.isBoundToVpc;
+        return this._reference.isBoundToVpc;
     }
     get latestVersion() {
-        return this._lambda.latestVersion;
+        return this._reference.latestVersion;
     }
     get permissionsNode() {
-        return this._lambda.permissionsNode;
+        return this._reference.permissionsNode;
     }
     get resourceArnsForGrantInvoke() {
-        return (this._alias?.resourceArnsForGrantInvoke ??
-            this._lambda.resourceArnsForGrantInvoke);
+        return this._reference.resourceArnsForGrantInvoke;
     }
     addEventSource(source) {
-        this._lambda.addEventSource(source);
+        this._reference.addEventSource(source);
     }
     addEventSourceMapping(id, options) {
-        return this._lambda.addEventSourceMapping(id, options);
+        return this._reference.addEventSourceMapping(id, options);
     }
     addFunctionUrl(options) {
-        return this._lambda.addFunctionUrl(options);
+        return this._reference.addFunctionUrl(options);
     }
     addPermission(id, permission) {
-        this._lambda.addPermission(id, permission);
+        this._reference.addPermission(id, permission);
     }
     addToRolePolicy(statement) {
-        this._lambda.addToRolePolicy(statement);
+        this._reference.addToRolePolicy(statement);
     }
     addEnvironment(key, value, options) {
         return this._lambda.addEnvironment(key, value, options);
     }
     configureAsyncInvoke(options) {
-        this._lambda.configureAsyncInvoke(options);
+        this._reference.configureAsyncInvoke(options);
     }
     grantInvoke(grantee) {
-        return (this._alias?.grantInvoke(grantee) ?? this._lambda.grantInvoke(grantee));
+        return this._reference.grantInvoke(grantee);
     }
     grantInvokeCompositePrincipal(compositePrincipal) {
-        return this._lambda.grantInvokeCompositePrincipal(compositePrincipal);
+        return this._reference.grantInvokeCompositePrincipal(compositePrincipal);
     }
     grantInvokeUrl(grantee) {
-        return this._lambda.grantInvokeUrl(grantee);
+        return this._reference.grantInvokeUrl(grantee);
     }
     metric(metricName, props) {
-        return this._lambda.metric(metricName, props);
+        return this._reference.metric(metricName, props);
     }
     metricDuration(props) {
-        return this._lambda.metricDuration(props);
+        return this._reference.metricDuration(props);
     }
     metricErrors(props) {
-        return this._lambda.metricErrors(props);
+        return this._reference.metricErrors(props);
     }
     metricInvocations(props) {
-        return this._lambda.metricInvocations(props);
+        return this._reference.metricInvocations(props);
     }
     metricThrottles(props) {
-        return this._lambda.metricThrottles(props);
+        return this._reference.metricThrottles(props);
     }
     // Additional IFunction implementation
     grantInvokeLatestVersion(grantee) {
-        return this._lambda.grantInvokeLatestVersion(grantee);
+        return this._reference.grantInvokeLatestVersion(grantee);
     }
     grantInvokeVersion(grantee, version) {
-        return this._lambda.grantInvokeVersion(grantee, version);
+        return this._reference.grantInvokeVersion(grantee, version);
+    }
+    get env() {
+        return {
+            account: cdk$1.Stack.of(this).account,
+            region: cdk$1.Stack.of(this).region,
+        };
+    }
+    get stack() {
+        return this._reference.stack;
+    }
+    applyRemovalPolicy(policy) {
+        this._reference.applyRemovalPolicy(policy);
+    }
+}
+
+class JaypieApiGateway extends constructs.Construct {
+    constructor(scope, id, props) {
+        super(scope, id);
+        const { certificate = true, handler, host: propsHost, name, roleTag = cdk.CDK.ROLE.API, zone: propsZone, } = props;
+        // Determine zone from props or environment
+        let zone = propsZone;
+        if (!zone && process.env.CDK_ENV_API_HOSTED_ZONE) {
+            zone = process.env.CDK_ENV_API_HOSTED_ZONE;
+        }
+        // Determine host from props or environment
+        let host = propsHost;
+        if (!host) {
+            if (process.env.CDK_ENV_API_HOST_NAME) {
+                host = process.env.CDK_ENV_API_HOST_NAME;
+            }
+            else if (process.env.CDK_ENV_API_SUBDOMAIN &&
+                process.env.CDK_ENV_API_HOSTED_ZONE) {
+                host = cdk.mergeDomain(process.env.CDK_ENV_API_SUBDOMAIN, process.env.CDK_ENV_API_HOSTED_ZONE);
+            }
+        }
+        const apiGatewayName = name || constructEnvName("ApiGateway");
+        const certificateName = constructEnvName("Certificate");
+        const apiDomainName = constructEnvName("ApiDomainName");
+        let hostedZone;
+        let certificateToUse;
+        if (host && zone) {
+            if (typeof zone === "string") {
+                hostedZone = route53__namespace.HostedZone.fromLookup(this, "HostedZone", {
+                    domainName: zone,
+                });
+            }
+            else {
+                hostedZone = zone;
+            }
+            if (certificate === true) {
+                certificateToUse = new acm__namespace.Certificate(this, certificateName, {
+                    domainName: host,
+                    validation: acm__namespace.CertificateValidation.fromDns(hostedZone),
+                });
+                cdk$1.Tags.of(certificateToUse).add(cdk.CDK.TAG.ROLE, cdk.CDK.ROLE.HOSTING);
+            }
+            else if (typeof certificate === "object") {
+                certificateToUse = certificate;
+            }
+            this._certificate = certificateToUse;
+            this._host = host;
+        }
+        const { 
+        // * `...lambdaRestApiProps` cannot be moved to the first const destructuring because it needs to exclude the custom properties first.
+        // Ignore the variables we already assigned to other properties
+        /* eslint-disable @typescript-eslint/no-unused-vars */
+        certificate: _certificate, host: _host, name: _name, roleTag: _roleTag, zone: _zone, handler: _handler, 
+        /* eslint-enable @typescript-eslint/no-unused-vars */
+        ...lambdaRestApiProps } = props;
+        // Check if handler is a JaypieLambda instance and use provisioned alias if available
+        let handlerToUse = handler;
+        if (handler instanceof JaypieLambda && handler.provisioned) {
+            handlerToUse = handler.provisioned;
+        }
+        this._api = new apiGateway__namespace.LambdaRestApi(this, apiGatewayName, {
+            handler: handlerToUse,
+            ...lambdaRestApiProps,
+        });
+        cdk$1.Tags.of(this._api).add(cdk.CDK.TAG.ROLE, roleTag);
+        if (host && certificateToUse && hostedZone) {
+            this._domainName = this._api.addDomainName(apiDomainName, {
+                domainName: host,
+                certificate: certificateToUse,
+            });
+            cdk$1.Tags.of(this._domainName).add(cdk.CDK.TAG.ROLE, roleTag);
+            const record = new route53__namespace.ARecord(this, "AliasRecord", {
+                recordName: host,
+                target: route53__namespace.RecordTarget.fromAlias(new route53Targets__namespace.ApiGatewayDomain(this._domainName)),
+                zone: hostedZone,
+            });
+            cdk$1.Tags.of(record).add(cdk.CDK.TAG.ROLE, cdk.CDK.ROLE.NETWORKING);
+        }
+    }
+    get api() {
+        return this._api;
+    }
+    get url() {
+        return this._api.url;
+    }
+    get certificateArn() {
+        return this._certificate?.certificateArn;
+    }
+    get domainName() {
+        return this._domainName?.domainName;
+    }
+    get host() {
+        return this._host;
+    }
+    get restApiId() {
+        return this._api.restApiId;
+    }
+    get restApiName() {
+        return this._api.restApiName;
+    }
+    get restApiRootResourceId() {
+        return this._api.restApiRootResourceId;
+    }
+    get deploymentStage() {
+        return this._api.deploymentStage;
+    }
+    get domainNameAliasDomainName() {
+        return this._domainName?.domainNameAliasDomainName;
+    }
+    get domainNameAliasHostedZoneId() {
+        return this._domainName?.domainNameAliasHostedZoneId;
+    }
+    get root() {
+        return this._api.root;
     }
     get env() {
         return {
@@ -589,10 +538,67 @@ class JaypieLambda extends constructs.Construct {
         };
     }
     get stack() {
-        return this._lambda.stack;
+        return this._api.stack;
+    }
+    arnForExecuteApi(method, path, stage) {
+        return this._api.arnForExecuteApi(method, path, stage);
+    }
+    metric(metricName, props) {
+        return this._api.metric(metricName, props);
+    }
+    metricCacheHitCount(props) {
+        return this._api.metricCacheHitCount(props);
+    }
+    metricCacheMissCount(props) {
+        return this._api.metricCacheMissCount(props);
+    }
+    metricClientError(props) {
+        return this._api.metricClientError(props);
+    }
+    metricCount(props) {
+        return this._api.metricCount(props);
+    }
+    metricIntegrationLatency(props) {
+        return this._api.metricIntegrationLatency(props);
+    }
+    metricLatency(props) {
+        return this._api.metricLatency(props);
+    }
+    metricServerError(props) {
+        return this._api.metricServerError(props);
     }
     applyRemovalPolicy(policy) {
-        this._lambda.applyRemovalPolicy(policy);
+        this._api.applyRemovalPolicy(policy);
+    }
+}
+
+class JaypieStack extends cdk$1.Stack {
+    constructor(scope, id, props = {}) {
+        const { key, ...stackProps } = props;
+        // Handle stackName
+        if (!stackProps.stackName) {
+            stackProps.stackName = constructStackName(key);
+        }
+        // Handle env
+        stackProps.env = {
+            account: process.env.CDK_DEFAULT_ACCOUNT,
+            region: process.env.CDK_DEFAULT_REGION,
+            ...stackProps.env,
+        };
+        super(scope, id, stackProps);
+        // Apply tags
+        stackTagger(this, { name: stackProps.stackName });
+    }
+}
+
+class JaypieAppStack extends JaypieStack {
+    constructor(scope, id, props = {}) {
+        const { key = "app", ...stackProps } = props;
+        // Handle stackName
+        if (!stackProps.stackName) {
+            stackProps.stackName = constructStackName(key);
+        }
+        super(scope, id, { key, ...stackProps });
     }
 }