terraconstructs 0.0.8

package/lib/aws/compute/function-url.d.ts

@@ -0,0 +1,210 @@
+import { lambdaFunctionUrl } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { IAwsConstruct, AwsConstructBase } from "..";
+import { IFunction } from "./function-base";
+import { Duration } from "../..";
+import * as iam from "../iam";
+/**
+ * The auth types for a function url
+ */
+export declare enum FunctionUrlAuthType {
+    /**
+     * Restrict access to authenticated IAM users only
+     */
+    AWS_IAM = "AWS_IAM",
+    /**
+     * Bypass IAM authentication to create a public endpoint
+     */
+    NONE = "NONE"
+}
+/**
+ * The invoke modes for a Lambda function
+ */
+export declare enum InvokeMode {
+    /**
+     * Default option. Lambda invokes your function using the Invoke API operation.
+     * Invocation results are available when the payload is complete.
+     * The maximum payload size is 6 MB.
+     */
+    BUFFERED = "BUFFERED",
+    /**
+     * Your function streams payload results as they become available.
+     * Lambda invokes your function using the InvokeWithResponseStream API operation.
+     * The maximum response payload size is 20 MB, however, you can request a quota increase.
+     */
+    RESPONSE_STREAM = "RESPONSE_STREAM"
+}
+/**
+ * All http request methods
+ */
+export declare enum HttpMethod {
+    /**
+     * The GET method requests a representation of the specified resource.
+     */
+    GET = "GET",
+    /**
+     * The PUT method replaces all current representations of the target resource with the request payload.
+     */
+    PUT = "PUT",
+    /**
+     * The HEAD method asks for a response identical to that of a GET request, but without the response body.
+     */
+    HEAD = "HEAD",
+    /**
+     * The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.
+     */
+    POST = "POST",
+    /**
+     * The DELETE method deletes the specified resource.
+     */
+    DELETE = "DELETE",
+    /**
+     * The PATCH method applies partial modifications to a resource.
+     */
+    PATCH = "PATCH",
+    /**
+     * The OPTIONS method describes the communication options for the target resource.
+     */
+    OPTIONS = "OPTIONS",
+    /**
+     * The wildcard entry to allow all methods.
+     */
+    ALL = "*"
+}
+/**
+ * Specifies a cross-origin access property for a function URL
+ */
+export interface FunctionUrlCorsOptions {
+    /**
+     * Whether to allow cookies or other credentials in requests to your function URL.
+     *
+     * @default false
+     */
+    readonly allowCredentials?: boolean;
+    /**
+     * Headers that are specified in the Access-Control-Request-Headers header.
+     *
+     * @default - No headers allowed.
+     */
+    readonly allowedHeaders?: string[];
+    /**
+     * An HTTP method that you allow the origin to execute.
+     *
+     * @default - [HttpMethod.ALL]
+     */
+    readonly allowedMethods?: HttpMethod[];
+    /**
+     * One or more origins you want customers to be able to access the bucket from.
+     *
+     * @default - No origins allowed.
+     */
+    readonly allowedOrigins?: string[];
+    /**
+     * One or more headers in the response that you want customers to be able to access from their applications.
+     *
+     * @default - No headers exposed.
+     */
+    readonly exposedHeaders?: string[];
+    /**
+     * The time in seconds that your browser is to cache the preflight response for the specified resource.
+     *
+     * @default - Browser default of 5 seconds.
+     */
+    readonly maxAge?: Duration;
+}
+/**
+ * Outputs that can be exposed through the grid
+ */
+export interface FunctionUrlOutputs {
+    /**
+     * The url of the Lambda function.
+     */
+    readonly url: string;
+    /**
+     * The ARN of the function this URL refers to
+     */
+    readonly functionArn: string;
+}
+/**
+ * A Lambda function Url
+ */
+export interface IFunctionUrl extends IAwsConstruct {
+    /** strongly typed FunctionUrlOutputs */
+    readonly functionUrlOutputs: FunctionUrlOutputs;
+    /**
+     * The url of the Lambda function.
+     *
+     * @attribute FunctionUrl
+     */
+    readonly url: string;
+    /**
+     * The ARN of the function this URL refers to
+     *
+     * @attribute FunctionArn
+     */
+    readonly functionArn: string;
+    /**
+     * Grant the given identity permissions to invoke this Lambda Function URL
+     */
+    grantInvokeUrl(identity: iam.IGrantable): iam.Grant;
+}
+/**
+ * Options to add a url to a Lambda function
+ */
+export interface FunctionUrlOptions {
+    /**
+     * The type of authentication that your function URL uses.
+     *
+     * @default FunctionUrlAuthType.AWS_IAM
+     */
+    readonly authType?: FunctionUrlAuthType;
+    /**
+     * The cross-origin resource sharing (CORS) settings for your function URL.
+     *
+     * @default - No CORS configuration.
+     */
+    readonly cors?: FunctionUrlCorsOptions;
+    /**
+     * The type of invocation mode that your Lambda function uses.
+     *
+     * @default InvokeMode.BUFFERED
+     */
+    readonly invokeMode?: InvokeMode;
+}
+/**
+ * Properties for a FunctionUrl
+ */
+export interface FunctionUrlProps extends FunctionUrlOptions {
+    /**
+     * The function to which this url refers.
+     * It can also be an `Alias` but not a `Version`.
+     */
+    readonly function: IFunction;
+}
+/**
+ * Defines a Lambda function url
+ *
+ * @resource aws_lambda_function_url
+ */
+export declare class FunctionUrl extends AwsConstructBase implements IFunctionUrl {
+    readonly functionUrlOutputs: FunctionUrlOutputs;
+    get outputs(): Record<string, any>;
+    readonly resource: lambdaFunctionUrl.LambdaFunctionUrl;
+    /**
+     * The url of the Lambda function.
+     */
+    readonly url: string;
+    /**
+     * The ARN of the function this URL refers to
+     */
+    readonly functionArn: string;
+    /**
+     * The authentication type used for this Function URL
+     */
+    readonly authType: FunctionUrlAuthType;
+    private readonly function;
+    constructor(scope: Construct, id: string, props: FunctionUrlProps);
+    grantInvokeUrl(grantee: iam.IGrantable): iam.Grant;
+    private instanceOfAlias;
+    private renderCors;
+}

package/lib/aws/compute/function-url.js

@@ -0,0 +1,148 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FunctionUrl = exports.HttpMethod = exports.InvokeMode = exports.FunctionUrlAuthType = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const __1 = require("..");
+const iam = require("../iam");
+/**
+ * The auth types for a function url
+ */
+var FunctionUrlAuthType;
+(function (FunctionUrlAuthType) {
+    /**
+     * Restrict access to authenticated IAM users only
+     */
+    FunctionUrlAuthType["AWS_IAM"] = "AWS_IAM";
+    /**
+     * Bypass IAM authentication to create a public endpoint
+     */
+    FunctionUrlAuthType["NONE"] = "NONE";
+})(FunctionUrlAuthType || (exports.FunctionUrlAuthType = FunctionUrlAuthType = {}));
+/**
+ * The invoke modes for a Lambda function
+ */
+var InvokeMode;
+(function (InvokeMode) {
+    /**
+     * Default option. Lambda invokes your function using the Invoke API operation.
+     * Invocation results are available when the payload is complete.
+     * The maximum payload size is 6 MB.
+     */
+    InvokeMode["BUFFERED"] = "BUFFERED";
+    /**
+     * Your function streams payload results as they become available.
+     * Lambda invokes your function using the InvokeWithResponseStream API operation.
+     * The maximum response payload size is 20 MB, however, you can request a quota increase.
+     */
+    InvokeMode["RESPONSE_STREAM"] = "RESPONSE_STREAM";
+})(InvokeMode || (exports.InvokeMode = InvokeMode = {}));
+/**
+ * All http request methods
+ */
+var HttpMethod;
+(function (HttpMethod) {
+    /**
+     * The GET method requests a representation of the specified resource.
+     */
+    HttpMethod["GET"] = "GET";
+    /**
+     * The PUT method replaces all current representations of the target resource with the request payload.
+     */
+    HttpMethod["PUT"] = "PUT";
+    /**
+     * The HEAD method asks for a response identical to that of a GET request, but without the response body.
+     */
+    HttpMethod["HEAD"] = "HEAD";
+    /**
+     * The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.
+     */
+    HttpMethod["POST"] = "POST";
+    /**
+     * The DELETE method deletes the specified resource.
+     */
+    HttpMethod["DELETE"] = "DELETE";
+    /**
+     * The PATCH method applies partial modifications to a resource.
+     */
+    HttpMethod["PATCH"] = "PATCH";
+    /**
+     * The OPTIONS method describes the communication options for the target resource.
+     */
+    HttpMethod["OPTIONS"] = "OPTIONS";
+    /**
+     * The wildcard entry to allow all methods.
+     */
+    HttpMethod["ALL"] = "*";
+})(HttpMethod || (exports.HttpMethod = HttpMethod = {}));
+/**
+ * Defines a Lambda function url
+ *
+ * @resource aws_lambda_function_url
+ */
+class FunctionUrl extends __1.AwsConstructBase {
+    get outputs() {
+        return this.functionUrlOutputs;
+    }
+    constructor(scope, id, props) {
+        super(scope, id);
+        // If the target function is an alias, then it must be configured using the underlying function
+        // ARN, and the alias name as a qualifier.
+        const { targetFunction, alias } = this.instanceOfAlias(props.function)
+            ? { targetFunction: props.function.lambda, alias: props.function }
+            : { targetFunction: props.function, alias: undefined };
+        this.authType = props.authType ?? FunctionUrlAuthType.AWS_IAM;
+        this.resource = new provider_aws_1.lambdaFunctionUrl.LambdaFunctionUrl(this, "Resource", {
+            authorizationType: this.authType,
+            cors: props.cors ? this.renderCors(props.cors) : undefined,
+            invokeMode: props.invokeMode,
+            functionName: targetFunction.functionArn, // The name (or ARN) of the Lambda function.
+            qualifier: alias?.aliasName,
+        });
+        // The aliasName is a required physical name, so using it does not imply a dependency, so we
+        // must "manually" register the dependency, or else TF may attempt to use before it exists.
+        if (alias?.node.defaultChild != null) {
+            this.resource.node.addDependency(alias.node.defaultChild);
+        }
+        this.url = this.resource.functionUrl;
+        this.functionArn = this.resource.functionArn;
+        this.function = props.function;
+        if (props.authType === FunctionUrlAuthType.NONE) {
+            props.function.addPermission("invoke-function-url", {
+                principal: new iam.AnyPrincipal(),
+                action: "lambda:InvokeFunctionUrl",
+                functionUrlAuthType: props.authType,
+            });
+        }
+        this.functionUrlOutputs = {
+            url: this.url,
+            functionArn: this.functionArn,
+        };
+    }
+    grantInvokeUrl(grantee) {
+        return this.function.grantInvokeUrl(grantee);
+    }
+    instanceOfAlias(fn) {
+        return "aliasName" in fn;
+    }
+    renderCors(cors) {
+        if (cors.maxAge &&
+            !cors.maxAge.isUnresolved() &&
+            cors.maxAge.toSeconds() > 86400) {
+            throw new Error(`FunctionUrl CORS maxAge should be less than or equal to 86400 secs (got ${cors.maxAge.toSeconds()})`);
+        }
+        return {
+            allowCredentials: cors.allowCredentials,
+            allowHeaders: cors.allowedHeaders,
+            allowMethods: cors.allowedMethods ?? [HttpMethod.ALL],
+            allowOrigins: cors.allowedOrigins,
+            exposeHeaders: cors.exposedHeaders,
+            maxAge: cors.maxAge?.toSeconds(),
+        };
+    }
+}
+exports.FunctionUrl = FunctionUrl;
+_a = JSII_RTTI_SYMBOL_1;
+FunctionUrl[_a] = { fqn: "terraconstructs.aws.compute.FunctionUrl", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"function-url.js","sourceRoot":"","sources":["../../../src/aws/compute/function-url.ts"],"names":[],"mappings":"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","sourcesContent":["import { lambdaFunctionUrl } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { IAwsConstruct, AwsConstructBase } from \"..\";\nimport { IAlias } from \"./function-alias\";\nimport { IFunction } from \"./function-base\";\nimport { Duration } from \"../..\";\nimport * as iam from \"../iam\";\n\n/**\n * The auth types for a function url\n */\nexport enum FunctionUrlAuthType {\n  /**\n   * Restrict access to authenticated IAM users only\n   */\n  AWS_IAM = \"AWS_IAM\",\n\n  /**\n   * Bypass IAM authentication to create a public endpoint\n   */\n  NONE = \"NONE\",\n}\n\n/**\n * The invoke modes for a Lambda function\n */\nexport enum InvokeMode {\n  /**\n   * Default option. Lambda invokes your function using the Invoke API operation.\n   * Invocation results are available when the payload is complete.\n   * The maximum payload size is 6 MB.\n   */\n  BUFFERED = \"BUFFERED\",\n\n  /**\n   * Your function streams payload results as they become available.\n   * Lambda invokes your function using the InvokeWithResponseStream API operation.\n   * The maximum response payload size is 20 MB, however, you can request a quota increase.\n   */\n  RESPONSE_STREAM = \"RESPONSE_STREAM\",\n}\n\n/**\n * All http request methods\n */\nexport enum HttpMethod {\n  /**\n   * The GET method requests a representation of the specified resource.\n   */\n  GET = \"GET\",\n  /**\n   * The PUT method replaces all current representations of the target resource with the request payload.\n   */\n  PUT = \"PUT\",\n  /**\n   * The HEAD method asks for a response identical to that of a GET request, but without the response body.\n   */\n  HEAD = \"HEAD\",\n  /**\n   * The POST method is used to submit an entity to the specified resource, often causing a change in state or side effects on the server.\n   */\n  POST = \"POST\",\n  /**\n   * The DELETE method deletes the specified resource.\n   */\n  DELETE = \"DELETE\",\n  /**\n   * The PATCH method applies partial modifications to a resource.\n   */\n  PATCH = \"PATCH\",\n  /**\n   * The OPTIONS method describes the communication options for the target resource.\n   */\n  OPTIONS = \"OPTIONS\",\n  /**\n   * The wildcard entry to allow all methods.\n   */\n  ALL = \"*\",\n}\n\n/**\n * Specifies a cross-origin access property for a function URL\n */\nexport interface FunctionUrlCorsOptions {\n  /**\n   * Whether to allow cookies or other credentials in requests to your function URL.\n   *\n   * @default false\n   */\n  readonly allowCredentials?: boolean;\n\n  /**\n   * Headers that are specified in the Access-Control-Request-Headers header.\n   *\n   * @default - No headers allowed.\n   */\n  readonly allowedHeaders?: string[];\n\n  /**\n   * An HTTP method that you allow the origin to execute.\n   *\n   * @default - [HttpMethod.ALL]\n   */\n  readonly allowedMethods?: HttpMethod[];\n\n  /**\n   * One or more origins you want customers to be able to access the bucket from.\n   *\n   * @default - No origins allowed.\n   */\n  readonly allowedOrigins?: string[];\n\n  /**\n   * One or more headers in the response that you want customers to be able to access from their applications.\n   *\n   * @default - No headers exposed.\n   */\n  readonly exposedHeaders?: string[];\n\n  /**\n   * The time in seconds that your browser is to cache the preflight response for the specified resource.\n   *\n   * @default - Browser default of 5 seconds.\n   */\n  readonly maxAge?: Duration;\n}\n\n/**\n * Outputs that can be exposed through the grid\n */\nexport interface FunctionUrlOutputs {\n  /**\n   * The url of the Lambda function.\n   */\n  readonly url: string;\n\n  /**\n   * The ARN of the function this URL refers to\n   */\n  readonly functionArn: string;\n}\n\n/**\n * A Lambda function Url\n */\nexport interface IFunctionUrl extends IAwsConstruct {\n  /** strongly typed FunctionUrlOutputs */\n  readonly functionUrlOutputs: FunctionUrlOutputs;\n\n  /**\n   * The url of the Lambda function.\n   *\n   * @attribute FunctionUrl\n   */\n  readonly url: string;\n\n  /**\n   * The ARN of the function this URL refers to\n   *\n   * @attribute FunctionArn\n   */\n  readonly functionArn: string;\n\n  /**\n   * Grant the given identity permissions to invoke this Lambda Function URL\n   */\n  grantInvokeUrl(identity: iam.IGrantable): iam.Grant;\n}\n\n/**\n * Options to add a url to a Lambda function\n */\nexport interface FunctionUrlOptions {\n  /**\n   * The type of authentication that your function URL uses.\n   *\n   * @default FunctionUrlAuthType.AWS_IAM\n   */\n  readonly authType?: FunctionUrlAuthType;\n\n  /**\n   * The cross-origin resource sharing (CORS) settings for your function URL.\n   *\n   * @default - No CORS configuration.\n   */\n  readonly cors?: FunctionUrlCorsOptions;\n\n  /**\n   * The type of invocation mode that your Lambda function uses.\n   *\n   * @default InvokeMode.BUFFERED\n   */\n  readonly invokeMode?: InvokeMode;\n}\n\n/**\n * Properties for a FunctionUrl\n */\nexport interface FunctionUrlProps extends FunctionUrlOptions {\n  /**\n   * The function to which this url refers.\n   * It can also be an `Alias` but not a `Version`.\n   */\n  readonly function: IFunction;\n}\n\n/**\n * Defines a Lambda function url\n *\n * @resource aws_lambda_function_url\n */\nexport class FunctionUrl extends AwsConstructBase implements IFunctionUrl {\n  public readonly functionUrlOutputs: FunctionUrlOutputs;\n  public get outputs(): Record<string, any> {\n    return this.functionUrlOutputs;\n  }\n  public readonly resource: lambdaFunctionUrl.LambdaFunctionUrl;\n  /**\n   * The url of the Lambda function.\n   */\n  public readonly url: string;\n\n  /**\n   * The ARN of the function this URL refers to\n   */\n  public readonly functionArn: string;\n\n  /**\n   * The authentication type used for this Function URL\n   */\n  public readonly authType: FunctionUrlAuthType;\n\n  private readonly function: IFunction;\n\n  constructor(scope: Construct, id: string, props: FunctionUrlProps) {\n    super(scope, id);\n\n    // If the target function is an alias, then it must be configured using the underlying function\n    // ARN, and the alias name as a qualifier.\n    const { targetFunction, alias } = this.instanceOfAlias(props.function)\n      ? { targetFunction: props.function.lambda, alias: props.function }\n      : { targetFunction: props.function, alias: undefined };\n\n    this.authType = props.authType ?? FunctionUrlAuthType.AWS_IAM;\n\n    this.resource = new lambdaFunctionUrl.LambdaFunctionUrl(this, \"Resource\", {\n      authorizationType: this.authType,\n      cors: props.cors ? this.renderCors(props.cors) : undefined,\n      invokeMode: props.invokeMode,\n      functionName: targetFunction.functionArn, // The name (or ARN) of the Lambda function.\n      qualifier: alias?.aliasName,\n    });\n    // The aliasName is a required physical name, so using it does not imply a dependency, so we\n    // must \"manually\" register the dependency, or else TF may attempt to use before it exists.\n    if (alias?.node.defaultChild != null) {\n      this.resource.node.addDependency(alias.node.defaultChild);\n    }\n\n    this.url = this.resource.functionUrl;\n    this.functionArn = this.resource.functionArn;\n    this.function = props.function;\n\n    if (props.authType === FunctionUrlAuthType.NONE) {\n      props.function.addPermission(\"invoke-function-url\", {\n        principal: new iam.AnyPrincipal(),\n        action: \"lambda:InvokeFunctionUrl\",\n        functionUrlAuthType: props.authType,\n      });\n    }\n    this.functionUrlOutputs = {\n      url: this.url,\n      functionArn: this.functionArn,\n    };\n  }\n\n  public grantInvokeUrl(grantee: iam.IGrantable): iam.Grant {\n    return this.function.grantInvokeUrl(grantee);\n  }\n\n  private instanceOfAlias(fn: IFunction): fn is IAlias {\n    return \"aliasName\" in fn;\n  }\n\n  private renderCors(\n    cors: FunctionUrlCorsOptions,\n  ): lambdaFunctionUrl.LambdaFunctionUrlCors {\n    if (\n      cors.maxAge &&\n      !cors.maxAge.isUnresolved() &&\n      cors.maxAge.toSeconds() > 86400\n    ) {\n      throw new Error(\n        `FunctionUrl CORS maxAge should be less than or equal to 86400 secs (got ${cors.maxAge.toSeconds()})`,\n      );\n    }\n\n    return {\n      allowCredentials: cors.allowCredentials,\n      allowHeaders: cors.allowedHeaders,\n      allowMethods: cors.allowedMethods ?? [HttpMethod.ALL],\n      allowOrigins: cors.allowedOrigins,\n      exposeHeaders: cors.exposedHeaders,\n      maxAge: cors.maxAge?.toSeconds(),\n    };\n  }\n}\n"]}

package/lib/aws/compute/function-vpc-config.generated.d.ts

@@ -0,0 +1,36 @@
+import type { IResolvable } from 'cdktf';
+import type { securityGroup } from '@cdktf/provider-aws';
+/**
+ * Config for network connectivity to AWS resources in a VPC, specify a list
+ * of security groups and subnets in the VPC.
+ * When you connect a function to a VPC, it can only access resources and the internet through that VPC.
+ *
+ * See [VPC Settings](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc.html).
+ */
+export interface VpcConfig {
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_function#ipv6_allowed_for_dual_stack LambdaFunction#ipv6_allowed_for_dual_stack}.
+     * @stability stable
+     */
+    readonly ipv6AllowedForDualStack?: boolean | IResolvable;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_function#subnet_ids LambdaFunction#subnet_ids}.
+     * @stability stable
+     */
+    readonly subnetIds: Array<string>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/resources/lambda_function#security_group_ids LambdaFunction#security_group_ids}.
+     * @default created
+     * @stability stable
+     */
+    readonly securityGroupIds?: Array<string>;
+    /**
+     * Egress rules, used for created securityGroup if `securityGroupIds` are not provided
+     * @default egress world
+     */
+    readonly egress?: Array<securityGroup.SecurityGroupEgress>;
+    /**
+     * The VPC ID, required if `securityGroupIds` are not provided
+     */
+    readonly vpcId?: string;
+}

package/lib/aws/compute/function-vpc-config.generated.js

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