cdk-nextjs 0.1.0 → 0.1.1

package/lib/generated-structs/OptionalDistributionProps.d.ts

@@ -0,0 +1,155 @@
+import type { aws_certificatemanager, aws_cloudfront, aws_s3 } from 'aws-cdk-lib';
+/**
+ * OptionalDistributionProps
+ */
+export interface OptionalDistributionProps {
+    /**
+     * Unique identifier that specifies the AWS WAF web ACL to associate with this CloudFront distribution.
+     * To specify a web ACL created using the latest version of AWS WAF, use the ACL ARN, for example
+     * `arn:aws:wafv2:us-east-1:123456789012:global/webacl/ExampleWebACL/473e64fd-f30b-4765-81a0-62ad96dd167a`.
+     * To specify a web ACL created using AWS WAF Classic, use the ACL ID, for example `473e64fd-f30b-4765-81a0-62ad96dd167a`.
+     * @default - No AWS Web Application Firewall web access control list (web ACL).
+     * @stability stable
+     */
+    readonly webAclId?: string;
+    /**
+     * The SSL method CloudFront will use for your distribution.
+     * Server Name Indication (SNI) - is an extension to the TLS computer networking protocol by which a client indicates
+     * which hostname it is attempting to connect to at the start of the handshaking process. This allows a server to present
+     * multiple certificates on the same IP address and TCP port number and hence allows multiple secure (HTTPS) websites
+     * (or any other service over TLS) to be served by the same IP address without requiring all those sites to use the same certificate.
+     *
+     * CloudFront can use SNI to host multiple distributions on the same IP - which a large majority of clients will support.
+     *
+     * If your clients cannot support SNI however - CloudFront can use dedicated IPs for your distribution - but there is a prorated monthly charge for
+     * using this feature. By default, we use SNI - but you can optionally enable dedicated IPs (VIP).
+     *
+     * See the CloudFront SSL for more details about pricing : https://aws.amazon.com/cloudfront/custom-ssl-domains/
+     * @default SSLMethod.SNI
+     * @stability stable
+     */
+    readonly sslSupportMethod?: aws_cloudfront.SSLMethod;
+    /**
+     * Whether to enable additional CloudWatch metrics.
+     * @default false
+     * @stability stable
+     */
+    readonly publishAdditionalMetrics?: boolean;
+    /**
+     * The price class that corresponds with the maximum price that you want to pay for CloudFront service.
+     * If you specify PriceClass_All, CloudFront responds to requests for your objects from all CloudFront edge locations.
+     * If you specify a price class other than PriceClass_All, CloudFront serves your objects from the CloudFront edge location
+     * that has the lowest latency among the edge locations in your price class.
+     * @default PriceClass.PRICE_CLASS_ALL
+     * @stability stable
+     */
+    readonly priceClass?: aws_cloudfront.PriceClass;
+    /**
+     * The minimum version of the SSL protocol that you want CloudFront to use for HTTPS connections.
+     * CloudFront serves your objects only to browsers or devices that support at
+     * least the SSL version that you specify.
+     * @default - SecurityPolicyProtocol.TLS_V1_2_2021 if the '@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021' feature flag is set; otherwise, SecurityPolicyProtocol.TLS_V1_2_2019.
+     * @stability stable
+     */
+    readonly minimumProtocolVersion?: aws_cloudfront.SecurityPolicyProtocol;
+    /**
+     * Specifies whether you want CloudFront to include cookies in access logs.
+     * @default false
+     * @stability stable
+     */
+    readonly logIncludesCookies?: boolean;
+    /**
+     * An optional string that you want CloudFront to prefix to the access log filenames for this distribution.
+     * @default - no prefix
+     * @stability stable
+     */
+    readonly logFilePrefix?: string;
+    /**
+     * The Amazon S3 bucket to store the access logs in.
+     * Make sure to set `objectOwnership` to `s3.ObjectOwnership.OBJECT_WRITER` in your custom bucket.
+     * @default - A bucket is created if `enableLogging` is true
+     * @stability stable
+     */
+    readonly logBucket?: aws_s3.IBucket;
+    /**
+     * Specify the maximum HTTP version that you want viewers to use to communicate with CloudFront.
+     * For viewers and CloudFront to use HTTP/2, viewers must support TLS 1.2 or later, and must support server name identification (SNI).
+     * @default HttpVersion.HTTP2
+     * @stability stable
+     */
+    readonly httpVersion?: aws_cloudfront.HttpVersion;
+    /**
+     * Controls the countries in which your content is distributed.
+     * @default - No geographic restrictions
+     * @stability stable
+     */
+    readonly geoRestriction?: aws_cloudfront.GeoRestriction;
+    /**
+     * How CloudFront should handle requests that are not successful (e.g., PageNotFound).
+     * @default - No custom error responses.
+     * @stability stable
+     */
+    readonly errorResponses?: Array<aws_cloudfront.ErrorResponse>;
+    /**
+     * Enable access logging for the distribution.
+     * @default - false, unless `logBucket` is specified.
+     * @stability stable
+     */
+    readonly enableLogging?: boolean;
+    /**
+     * Whether CloudFront will respond to IPv6 DNS requests with an IPv6 address.
+     * If you specify false, CloudFront responds to IPv6 DNS requests with the DNS response code NOERROR and with no IP addresses.
+     * This allows viewers to submit a second request, for an IPv4 address for your distribution.
+     * @default true
+     * @stability stable
+     */
+    readonly enableIpv6?: boolean;
+    /**
+     * Enable or disable the distribution.
+     * @default true
+     * @stability stable
+     */
+    readonly enabled?: boolean;
+    /**
+     * Alternative domain names for this distribution.
+     * If you want to use your own domain name, such as www.example.com, instead of the cloudfront.net domain name,
+     * you can add an alternate domain name to your distribution. If you attach a certificate to the distribution,
+     * you should add (at least one of) the domain names of the certificate to this list.
+     *
+     * When you want to move a domain name between distributions, you can associate a certificate without specifying any domain names.
+     * For more information, see the _Moving an alternate domain name to a different distribution_ section in the README.
+     * @default - The distribution will only support the default generated name (e.g., d111111abcdef8.cloudfront.net)
+     * @stability stable
+     */
+    readonly domainNames?: Array<string>;
+    /**
+     * The object that you want CloudFront to request from your origin (for example, index.html) when a viewer requests the root URL for your distribution. If no default object is set, the request goes to the origin's root (e.g., example.com/).
+     * @default - no default root object
+     * @stability stable
+     */
+    readonly defaultRootObject?: string;
+    /**
+     * Any comments you want to include about the distribution.
+     * @default - no comment
+     * @stability stable
+     */
+    readonly comment?: string;
+    /**
+     * A certificate to associate with the distribution.
+     * The certificate must be located in N. Virginia (us-east-1).
+     * @default - the CloudFront wildcard certificate (*.cloudfront.net) will be used.
+     * @stability stable
+     */
+    readonly certificate?: aws_certificatemanager.ICertificate;
+    /**
+     * Additional behaviors for the distribution, mapped by the pathPattern that specifies which requests to apply the behavior to.
+     * @default - no additional behaviors are added.
+     * @stability stable
+     */
+    readonly additionalBehaviors?: Record<string, aws_cloudfront.BehaviorOptions>;
+    /**
+     * The default behavior for the distribution.
+     * @stability stable
+     */
+    readonly defaultBehavior?: aws_cloudfront.BehaviorOptions;
+}

package/lib/generated-structs/OptionalDistributionProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"OptionalDistributionProps.js","sourceRoot":"","sources":["../../src/generated-structs/OptionalDistributionProps.ts"],"names":[],"mappings":"","sourcesContent":["// ~~ Generated by projen. To modify, edit .projenrc.ts and run \"pnpm dlx projen\".\nimport type { aws_certificatemanager, aws_cloudfront, aws_s3 } from 'aws-cdk-lib';\n\n/**\n * OptionalDistributionProps\n */\nexport interface OptionalDistributionProps {\n  /**\n   * Unique identifier that specifies the AWS WAF web ACL to associate with this CloudFront distribution.\n   * To specify a web ACL created using the latest version of AWS WAF, use the ACL ARN, for example\n   * `arn:aws:wafv2:us-east-1:123456789012:global/webacl/ExampleWebACL/473e64fd-f30b-4765-81a0-62ad96dd167a`.\n   * To specify a web ACL created using AWS WAF Classic, use the ACL ID, for example `473e64fd-f30b-4765-81a0-62ad96dd167a`.\n   * @default - No AWS Web Application Firewall web access control list (web ACL).\n   * @stability stable\n   */\n  readonly webAclId?: string;\n  /**\n   * The SSL method CloudFront will use for your distribution.\n   * Server Name Indication (SNI) - is an extension to the TLS computer networking protocol by which a client indicates\n   * which hostname it is attempting to connect to at the start of the handshaking process. This allows a server to present\n   * multiple certificates on the same IP address and TCP port number and hence allows multiple secure (HTTPS) websites\n   * (or any other service over TLS) to be served by the same IP address without requiring all those sites to use the same certificate.\n   *\n   * CloudFront can use SNI to host multiple distributions on the same IP - which a large majority of clients will support.\n   *\n   * If your clients cannot support SNI however - CloudFront can use dedicated IPs for your distribution - but there is a prorated monthly charge for\n   * using this feature. By default, we use SNI - but you can optionally enable dedicated IPs (VIP).\n   *\n   * See the CloudFront SSL for more details about pricing : https://aws.amazon.com/cloudfront/custom-ssl-domains/\n   * @default SSLMethod.SNI\n   * @stability stable\n   */\n  readonly sslSupportMethod?: aws_cloudfront.SSLMethod;\n  /**\n   * Whether to enable additional CloudWatch metrics.\n   * @default false\n   * @stability stable\n   */\n  readonly publishAdditionalMetrics?: boolean;\n  /**\n   * The price class that corresponds with the maximum price that you want to pay for CloudFront service.\n   * If you specify PriceClass_All, CloudFront responds to requests for your objects from all CloudFront edge locations.\n   * If you specify a price class other than PriceClass_All, CloudFront serves your objects from the CloudFront edge location\n   * that has the lowest latency among the edge locations in your price class.\n   * @default PriceClass.PRICE_CLASS_ALL\n   * @stability stable\n   */\n  readonly priceClass?: aws_cloudfront.PriceClass;\n  /**\n   * The minimum version of the SSL protocol that you want CloudFront to use for HTTPS connections.\n   * CloudFront serves your objects only to browsers or devices that support at\n   * least the SSL version that you specify.\n   * @default - SecurityPolicyProtocol.TLS_V1_2_2021 if the '@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021' feature flag is set; otherwise, SecurityPolicyProtocol.TLS_V1_2_2019.\n   * @stability stable\n   */\n  readonly minimumProtocolVersion?: aws_cloudfront.SecurityPolicyProtocol;\n  /**\n   * Specifies whether you want CloudFront to include cookies in access logs.\n   * @default false\n   * @stability stable\n   */\n  readonly logIncludesCookies?: boolean;\n  /**\n   * An optional string that you want CloudFront to prefix to the access log filenames for this distribution.\n   * @default - no prefix\n   * @stability stable\n   */\n  readonly logFilePrefix?: string;\n  /**\n   * The Amazon S3 bucket to store the access logs in.\n   * Make sure to set `objectOwnership` to `s3.ObjectOwnership.OBJECT_WRITER` in your custom bucket.\n   * @default - A bucket is created if `enableLogging` is true\n   * @stability stable\n   */\n  readonly logBucket?: aws_s3.IBucket;\n  /**\n   * Specify the maximum HTTP version that you want viewers to use to communicate with CloudFront.\n   * For viewers and CloudFront to use HTTP/2, viewers must support TLS 1.2 or later, and must support server name identification (SNI).\n   * @default HttpVersion.HTTP2\n   * @stability stable\n   */\n  readonly httpVersion?: aws_cloudfront.HttpVersion;\n  /**\n   * Controls the countries in which your content is distributed.\n   * @default - No geographic restrictions\n   * @stability stable\n   */\n  readonly geoRestriction?: aws_cloudfront.GeoRestriction;\n  /**\n   * How CloudFront should handle requests that are not successful (e.g., PageNotFound).\n   * @default - No custom error responses.\n   * @stability stable\n   */\n  readonly errorResponses?: Array<aws_cloudfront.ErrorResponse>;\n  /**\n   * Enable access logging for the distribution.\n   * @default - false, unless `logBucket` is specified.\n   * @stability stable\n   */\n  readonly enableLogging?: boolean;\n  /**\n   * Whether CloudFront will respond to IPv6 DNS requests with an IPv6 address.\n   * If you specify false, CloudFront responds to IPv6 DNS requests with the DNS response code NOERROR and with no IP addresses.\n   * This allows viewers to submit a second request, for an IPv4 address for your distribution.\n   * @default true\n   * @stability stable\n   */\n  readonly enableIpv6?: boolean;\n  /**\n   * Enable or disable the distribution.\n   * @default true\n   * @stability stable\n   */\n  readonly enabled?: boolean;\n  /**\n   * Alternative domain names for this distribution.\n   * If you want to use your own domain name, such as www.example.com, instead of the cloudfront.net domain name,\n   * you can add an alternate domain name to your distribution. If you attach a certificate to the distribution,\n   * you should add (at least one of) the domain names of the certificate to this list.\n   *\n   * When you want to move a domain name between distributions, you can associate a certificate without specifying any domain names.\n   * For more information, see the _Moving an alternate domain name to a different distribution_ section in the README.\n   * @default - The distribution will only support the default generated name (e.g., d111111abcdef8.cloudfront.net)\n   * @stability stable\n   */\n  readonly domainNames?: Array<string>;\n  /**\n   * The object that you want CloudFront to request from your origin (for example, index.html) when a viewer requests the root URL for your distribution. If no default object is set, the request goes to the origin's root (e.g., example.com/).\n   * @default - no default root object\n   * @stability stable\n   */\n  readonly defaultRootObject?: string;\n  /**\n   * Any comments you want to include about the distribution.\n   * @default - no comment\n   * @stability stable\n   */\n  readonly comment?: string;\n  /**\n   * A certificate to associate with the distribution.\n   * The certificate must be located in N. Virginia (us-east-1).\n   * @default - the CloudFront wildcard certificate (*.cloudfront.net) will be used.\n   * @stability stable\n   */\n  readonly certificate?: aws_certificatemanager.ICertificate;\n  /**\n   * Additional behaviors for the distribution, mapped by the pathPattern that specifies which requests to apply the behavior to.\n   * @default - no additional behaviors are added.\n   * @stability stable\n   */\n  readonly additionalBehaviors?: Record<string, aws_cloudfront.BehaviorOptions>;\n  /**\n   * The default behavior for the distribution.\n   * @stability stable\n   */\n  readonly defaultBehavior?: aws_cloudfront.BehaviorOptions;\n}\n"]}

package/lib/generated-structs/OptionalDockerImageAssetProps.d.ts

@@ -0,0 +1,124 @@
+import type { aws_ecr_assets, IgnoreMode, SymlinkFollowMode } from 'aws-cdk-lib';
+/**
+ * OptionalDockerImageAssetProps
+ */
+export interface OptionalDockerImageAssetProps {
+    /**
+     * The directory where the Dockerfile is stored.
+     * Any directory inside with a name that matches the CDK output folder (cdk.out by default) will be excluded from the asset
+     * @stability stable
+     */
+    readonly directory?: string;
+    /**
+     * Docker target to build to.
+     * @default - no target
+     * @stability stable
+     */
+    readonly target?: string;
+    /**
+     * Platform to build for.
+     * _Requires Docker Buildx_.
+     * @default - no platform specified (the current machine architecture will be used)
+     * @stability stable
+     */
+    readonly platform?: aws_ecr_assets.Platform;
+    /**
+     * Outputs to pass to the `docker build` command.
+     * @default - no outputs are passed to the build command (default outputs are used)
+     * @stability stable
+     */
+    readonly outputs?: Array<string>;
+    /**
+     * Networking mode for the RUN commands during build.
+     * Support docker API 1.25+.
+     * @default - no networking mode specified (the default networking mode `NetworkMode.DEFAULT` will be used)
+     * @stability stable
+     */
+    readonly networkMode?: aws_ecr_assets.NetworkMode;
+    /**
+     * Options to control which parameters are used to invalidate the asset hash.
+     * @default - hash all parameters
+     * @stability stable
+     */
+    readonly invalidation?: aws_ecr_assets.DockerImageAssetInvalidationOptions;
+    /**
+     * Path to the Dockerfile (relative to the directory).
+     * @default 'Dockerfile'
+     * @stability stable
+     */
+    readonly file?: string;
+    /**
+     * Cache to options to pass to the `docker build` command.
+     * @default - no cache to options are passed to the build command
+     * @stability stable
+     */
+    readonly cacheTo?: aws_ecr_assets.DockerCacheOption;
+    /**
+     * Cache from options to pass to the `docker build` command.
+     * @default - no cache from options are passed to the build command
+     * @stability stable
+     */
+    readonly cacheFrom?: Array<aws_ecr_assets.DockerCacheOption>;
+    /**
+     * Disable the cache and pass `--no-cache` to the `docker build` command.
+     * @default - cache is used
+     * @stability stable
+     */
+    readonly cacheDisabled?: boolean;
+    /**
+     * SSH agent socket or keys to pass to the `docker build` command.
+     * Docker BuildKit must be enabled to use the ssh flag
+     * @default - no --ssh flag
+     * @stability stable
+     */
+    readonly buildSsh?: string;
+    /**
+     * Build secrets.
+     * Docker BuildKit must be enabled to use build secrets.
+     * @default - no build secrets
+     * @stability stable
+     */
+    readonly buildSecrets?: Record<string, string>;
+    /**
+     * Build args to pass to the `docker build` command.
+     * Since Docker build arguments are resolved before deployment, keys and
+     * values cannot refer to unresolved tokens (such as `lambda.functionArn` or
+     * `queue.queueUrl`).
+     * @default - no build args are passed
+     * @stability stable
+     */
+    readonly buildArgs?: Record<string, string>;
+    /**
+     * Unique identifier of the docker image asset and its potential revisions.
+     * Required if using AppScopedStagingSynthesizer.
+     * @default - no asset name
+     * @stability stable
+     */
+    readonly assetName?: string;
+    /**
+     * Extra information to encode into the fingerprint (e.g. build instructions and other inputs).
+     * @default - hash is only based on source content
+     * @stability stable
+     */
+    readonly extraHash?: string;
+    /**
+     * The ignore behavior to use for `exclude` patterns.
+     * @default IgnoreMode.GLOB
+     * @stability stable
+     */
+    readonly ignoreMode?: IgnoreMode;
+    /**
+     * A strategy for how to handle symlinks.
+     * @default SymlinkFollowMode.NEVER
+     * @stability stable
+     */
+    readonly followSymlinks?: SymlinkFollowMode;
+    /**
+     * File paths matching the patterns will be excluded.
+     * See `ignoreMode` to set the matching behavior.
+     * Has no effect on Assets bundled using the `bundling` property.
+     * @default - nothing is excluded
+     * @stability stable
+     */
+    readonly exclude?: Array<string>;
+}

package/lib/generated-structs/OptionalDockerImageAssetProps.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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