terraconstructs 0.0.8

package/lib/aws/iam/oidc-provider.js

@@ -0,0 +1,82 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenIdConnectProvider = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const provider_aws_1 = require("@cdktf/provider-aws");
+const arn_1 = require("../arn");
+const aws_construct_1 = require("../aws-construct");
+/**
+ * IAM OIDC identity providers are entities in IAM that describe an external
+ * identity provider (IdP) service that supports the OpenID Connect (OIDC)
+ * standard, such as Google or Salesforce. You use an IAM OIDC identity provider
+ * when you want to establish trust between an OIDC-compatible IdP and your AWS
+ * account. This is useful when creating a mobile app or web application that
+ * requires access to AWS resources, but you don't want to create custom sign-in
+ * code or manage your own user identities.
+ *
+ * @see http://openid.net/connect
+ * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html
+ *
+ * @resource AWS::CloudFormation::CustomResource
+ */
+class OpenIdConnectProvider extends aws_construct_1.AwsConstructBase {
+    /**
+     * Imports an Open ID connect provider from an ARN.
+     * @param scope The definition scope
+     * @param id ID of the construct
+     * @param openIdConnectProviderArn the ARN to import
+     */
+    static fromOpenIdConnectProviderArn(scope, id, openIdConnectProviderArn) {
+        const resourceName = arn_1.Arn.extractResourceName(openIdConnectProviderArn, "oidc-provider");
+        class Import extends aws_construct_1.AwsConstructBase {
+            constructor() {
+                super(...arguments);
+                this.openIdConnectProviderArn = openIdConnectProviderArn;
+                this.openIdConnectProviderIssuer = resourceName;
+                this.openIdConnectProviderOutputs = {
+                    arn: openIdConnectProviderArn,
+                    issuer: resourceName,
+                };
+            }
+            get outputs() {
+                return this.openIdConnectProviderOutputs;
+            }
+        }
+        return new Import(scope, id, {});
+    }
+    get outputs() {
+        return this.openIdConnectProviderOutputs;
+    }
+    /**
+     * Defines an OpenID Connect provider.
+     * @param scope The definition scope
+     * @param id Construct ID
+     * @param props Initialization properties
+     */
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        // thumbprints is still required for terraform-provider-aws, use dummy ...
+        // https://github.com/hashicorp/terraform-provider-aws/issues/35112
+        let thumbprintList = props.thumbprints ?? [
+            "afafafafafafafafafafafafafafafafafafafaf",
+        ];
+        // TODO: this may cause unexpected errors if thumbprints are not provided
+        this.resource = new provider_aws_1.iamOpenidConnectProvider.IamOpenidConnectProvider(this, "Resource", {
+            url: props.url,
+            clientIdList: props.clientIds,
+            thumbprintList,
+        });
+        this.openIdConnectProviderArn = this.resource.arn;
+        this.openIdConnectProviderIssuer = arn_1.Arn.extractResourceName(this.openIdConnectProviderArn, "oidc-provider");
+        this.openIdConnectProviderthumbprints = this.resource.thumbprintList;
+        this.openIdConnectProviderOutputs = {
+            arn: this.openIdConnectProviderArn,
+            issuer: this.openIdConnectProviderIssuer,
+        };
+    }
+}
+exports.OpenIdConnectProvider = OpenIdConnectProvider;
+_a = JSII_RTTI_SYMBOL_1;
+OpenIdConnectProvider[_a] = { fqn: "terraconstructs.aws.iam.OpenIdConnectProvider", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oidc-provider.js","sourceRoot":"","sources":["../../../src/aws/iam/oidc-provider.ts"],"names":[],"mappings":";;;;;AAAA,sDAA+D;AAE/D,gCAA6B;AAC7B,oDAI0B;AAqF1B;;;;;;;;;;;;;GAaG;AACH,MAAa,qBACX,SAAQ,gCAAgB;IAGxB;;;;;OAKG;IACI,MAAM,CAAC,4BAA4B,CACxC,KAAgB,EAChB,EAAU,EACV,wBAAgC;QAEhC,MAAM,YAAY,GAAG,SAAG,CAAC,mBAAmB,CAC1C,wBAAwB,EACxB,eAAe,CAChB,CAAC;QAEF,MAAM,MAAO,SAAQ,gCAAgB;YAArC;;gBACkB,6BAAwB,GAAG,wBAAwB,CAAC;gBACpD,gCAA2B,GAAG,YAAY,CAAC;gBAC3C,iCAA4B,GAAG;oBAC7C,GAAG,EAAE,wBAAwB;oBAC7B,MAAM,EAAE,YAAY;iBACrB,CAAC;YAIJ,CAAC;YAHC,IAAW,OAAO;gBAChB,OAAO,IAAI,CAAC,4BAA4B,CAAC;YAC3C,CAAC;SACF;QAED,OAAO,IAAI,MAAM,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;IACnC,CAAC;IAED,IAAW,OAAO;QAChB,OAAO,IAAI,CAAC,4BAA4B,CAAC;IAC3C,CAAC;IAeD;;;;;OAKG;IACH,YACE,KAAgB,EAChB,EAAU,EACV,KAAiC;QAEjC,KAAK,CAAC,KAAK,EAAE,EAAE,EAAE,KAAK,CAAC,CAAC;QACxB,0EAA0E;QAC1E,mEAAmE;QACnE,IAAI,cAAc,GAAG,KAAK,CAAC,WAAW,IAAI;YACxC,0CAA0C;SAC3C,CAAC;QACF,yEAAyE;QAEzE,IAAI,CAAC,QAAQ,GAAG,IAAI,uCAAwB,CAAC,wBAAwB,CACnE,IAAI,EACJ,UAAU,EACV;YACE,GAAG,EAAE,KAAK,CAAC,GAAG;YACd,YAAY,EAAE,KAAK,CAAC,SAAS;YAC7B,cAAc;SACf,CACF,CAAC;QACF,IAAI,CAAC,wBAAwB,GAAG,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC;QAClD,IAAI,CAAC,2BAA2B,GAAG,SAAG,CAAC,mBAAmB,CACxD,IAAI,CAAC,wBAAwB,EAC7B,eAAe,CAChB,CAAC;QACF,IAAI,CAAC,gCAAgC,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;QACrE,IAAI,CAAC,4BAA4B,GAAG;YAClC,GAAG,EAAE,IAAI,CAAC,wBAAwB;YAClC,MAAM,EAAE,IAAI,CAAC,2BAA2B;SACzC,CAAC;IACJ,CAAC;;AA1FH,sDA2FC","sourcesContent":["import { iamOpenidConnectProvider } from \"@cdktf/provider-aws\";\nimport { Construct } from \"constructs\";\nimport { Arn } from \"../arn\";\nimport {\n  IAwsConstruct,\n  AwsConstructBase,\n  AwsConstructProps,\n} from \"../aws-construct\";\n\nexport interface OpenIdConnectProviderOutputs {\n  /**\n   * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.\n   * @stability stable\n   */\n  readonly arn: string;\n  /**\n   * The issuer for OIDC Provider\n   * @stability stable\n   */\n  readonly issuer: string;\n}\n\n/**\n * Represents an IAM OpenID Connect provider.\n *\n */\nexport interface IOpenIdConnectProvider extends IAwsConstruct {\n  // strongly typed outputs\n  readonly openIdConnectProviderOutputs: OpenIdConnectProviderOutputs;\n\n  /**\n   * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.\n   */\n  readonly openIdConnectProviderArn: string;\n\n  /**\n   * The issuer for OIDC Provider\n   */\n  readonly openIdConnectProviderIssuer: string;\n}\n\n/**\n * Initialization properties for `OpenIdConnectProvider`.\n */\nexport interface OpenIdConnectProviderProps extends AwsConstructProps {\n  /**\n   * The URL of the identity provider. The URL must begin with https:// and\n   * should correspond to the iss claim in the provider's OpenID Connect ID\n   * tokens. Per the OIDC standard, path components are allowed but query\n   * parameters are not. Typically the URL consists of only a hostname, like\n   * https://server.example.org or https://example.com.\n   *\n   * You cannot register the same provider multiple times in a single AWS\n   * account. If you try to submit a URL that has already been used for an\n   * OpenID Connect provider in the AWS account, you will get an error.\n   */\n  readonly url: string;\n\n  /**\n   * A list of client IDs (also known as audiences). When a mobile or web app\n   * registers with an OpenID Connect provider, they establish a value that\n   * identifies the application. (This is the value that's sent as the client_id\n   * parameter on OAuth requests.)\n   *\n   * You can register multiple client IDs with the same provider. For example,\n   * you might have multiple applications that use the same OIDC provider. You\n   * cannot register more than 100 client IDs with a single IAM OIDC provider.\n   *\n   * Client IDs are up to 255 characters long.\n   */\n  readonly clientIds: string[];\n\n  /**\n   * A list of server certificate thumbprints for the OpenID Connect (OIDC)\n   * identity provider's server certificates.\n   *\n   * AWS secures communication with OIDC identity providers (IdPs) using our\n   * library of trusted root certificate authorities (CAs) to verify the\n   * JSON Web Key Set (JWKS) endpoint's TLS certificate.\n   *\n   * If your OIDC IdP relies on a certificate that is not signed by one of\n   * these trusted CAs, only then we secure communication using the\n   * thumbprints set in the IdP's configuration.\n   *\n   * AWS will fall back to thumbprint verification if we are unable to retrieve\n   * the TLS certificate or if TLS v1.3 is required.\n   *\n   * See [AWS OIDC Docs](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_create_oidc.html#manage-oidc-provider-console)\n   */\n  readonly thumbprints?: string[];\n}\n\n/**\n * IAM OIDC identity providers are entities in IAM that describe an external\n * identity provider (IdP) service that supports the OpenID Connect (OIDC)\n * standard, such as Google or Salesforce. You use an IAM OIDC identity provider\n * when you want to establish trust between an OIDC-compatible IdP and your AWS\n * account. This is useful when creating a mobile app or web application that\n * requires access to AWS resources, but you don't want to create custom sign-in\n * code or manage your own user identities.\n *\n * @see http://openid.net/connect\n * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_providers_oidc.html\n *\n * @resource AWS::CloudFormation::CustomResource\n */\nexport class OpenIdConnectProvider\n  extends AwsConstructBase\n  implements IOpenIdConnectProvider\n{\n  /**\n   * Imports an Open ID connect provider from an ARN.\n   * @param scope The definition scope\n   * @param id ID of the construct\n   * @param openIdConnectProviderArn the ARN to import\n   */\n  public static fromOpenIdConnectProviderArn(\n    scope: Construct,\n    id: string,\n    openIdConnectProviderArn: string,\n  ): IOpenIdConnectProvider {\n    const resourceName = Arn.extractResourceName(\n      openIdConnectProviderArn,\n      \"oidc-provider\",\n    );\n\n    class Import extends AwsConstructBase implements IOpenIdConnectProvider {\n      public readonly openIdConnectProviderArn = openIdConnectProviderArn;\n      public readonly openIdConnectProviderIssuer = resourceName;\n      public readonly openIdConnectProviderOutputs = {\n        arn: openIdConnectProviderArn,\n        issuer: resourceName,\n      };\n      public get outputs() {\n        return this.openIdConnectProviderOutputs;\n      }\n    }\n\n    return new Import(scope, id, {});\n  }\n  public readonly openIdConnectProviderOutputs: OpenIdConnectProviderOutputs;\n  public get outputs(): Record<string, any> {\n    return this.openIdConnectProviderOutputs;\n  }\n  public readonly resource: iamOpenidConnectProvider.IamOpenidConnectProvider;\n\n  /**\n   * The Amazon Resource Name (ARN) of the IAM OpenID Connect provider.\n   */\n  public readonly openIdConnectProviderArn: string;\n\n  public readonly openIdConnectProviderIssuer: string;\n\n  /**\n   * The thumbprints configured for this provider.\n   */\n  public readonly openIdConnectProviderthumbprints: string[];\n\n  /**\n   * Defines an OpenID Connect provider.\n   * @param scope The definition scope\n   * @param id Construct ID\n   * @param props Initialization properties\n   */\n  public constructor(\n    scope: Construct,\n    id: string,\n    props: OpenIdConnectProviderProps,\n  ) {\n    super(scope, id, props);\n    // thumbprints is still required for terraform-provider-aws, use dummy ...\n    // https://github.com/hashicorp/terraform-provider-aws/issues/35112\n    let thumbprintList = props.thumbprints ?? [\n      \"afafafafafafafafafafafafafafafafafafafaf\",\n    ];\n    // TODO: this may cause unexpected errors if thumbprints are not provided\n\n    this.resource = new iamOpenidConnectProvider.IamOpenidConnectProvider(\n      this,\n      \"Resource\",\n      {\n        url: props.url,\n        clientIdList: props.clientIds,\n        thumbprintList,\n      },\n    );\n    this.openIdConnectProviderArn = this.resource.arn;\n    this.openIdConnectProviderIssuer = Arn.extractResourceName(\n      this.openIdConnectProviderArn,\n      \"oidc-provider\",\n    );\n    this.openIdConnectProviderthumbprints = this.resource.thumbprintList;\n    this.openIdConnectProviderOutputs = {\n      arn: this.openIdConnectProviderArn,\n      issuer: this.openIdConnectProviderIssuer,\n    };\n  }\n}\n"]}

package/lib/aws/iam/policy-document-config.generated.d.ts

@@ -0,0 +1,78 @@
+import type { PolicyStatement } from './';
+import type { FileProvisioner, ITerraformDependable, ITerraformIterator, LocalExecProvisioner, RemoteExecProvisioner, SSHProvisionerConnection, TerraformCount, TerraformProvider, TerraformResourceLifecycle, WinrmProvisionerConnection } from 'cdktf';
+/**
+ * IAM policy Document Config
+ */
+export interface PolicyDocumentConfig {
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#version DataAwsIamPolicyDocument#version}.
+     * @stability stable
+     */
+    readonly version?: string;
+    /**
+     * Configuration block for a policy statement
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#statement DataAwsIamPolicyDocument#statement}
+     * @stability stable
+     */
+    readonly statement?: Array<PolicyStatement>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#source_policy_documents DataAwsIamPolicyDocument#source_policy_documents}.
+     * @stability stable
+     */
+    readonly sourcePolicyDocuments?: Array<string>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#source_json DataAwsIamPolicyDocument#source_json}.
+     * @stability stable
+     */
+    readonly sourceJson?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#policy_id DataAwsIamPolicyDocument#policy_id}.
+     * @stability stable
+     */
+    readonly policyId?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#override_policy_documents DataAwsIamPolicyDocument#override_policy_documents}.
+     * @stability stable
+     */
+    readonly overridePolicyDocuments?: Array<string>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#override_json DataAwsIamPolicyDocument#override_json}.
+     * @stability stable
+     */
+    readonly overrideJson?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#id DataAwsIamPolicyDocument#id}.
+     * Please be aware that the id field is automatically added to all resources in Terraform providers using a Terraform provider SDK version below 2.
+     * If you experience problems setting this value it might not be settable. Please take a look at the provider documentation to ensure it should be settable.
+     * @stability stable
+     */
+    readonly id?: string;
+    /**
+     * @stability experimental
+     */
+    readonly provisioners?: Array<FileProvisioner | LocalExecProvisioner | RemoteExecProvisioner>;
+    /**
+     * @stability experimental
+     */
+    readonly provider?: TerraformProvider;
+    /**
+     * @stability experimental
+     */
+    readonly lifecycle?: TerraformResourceLifecycle;
+    /**
+     * @stability experimental
+     */
+    readonly forEach?: ITerraformIterator;
+    /**
+     * @stability experimental
+     */
+    readonly dependsOn?: Array<ITerraformDependable>;
+    /**
+     * @stability experimental
+     */
+    readonly count?: number | TerraformCount;
+    /**
+     * @stability experimental
+     */
+    readonly connection?: SSHProvisionerConnection | WinrmProvisionerConnection;
+}

package/lib/aws/iam/policy-document-config.generated.js

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

package/lib/aws/iam/policy-document.d.ts

@@ -0,0 +1,150 @@
+import { dataAwsIamPolicyDocument } from "@cdktf/provider-aws";
+import { Construct } from "constructs";
+import { PolicyDocumentConfig } from "./policy-document-config.generated";
+import { PolicyStatement } from "./policy-statement";
+import { AwsConstructBase, IAwsConstruct } from "../aws-construct";
+export interface PolicyDocumentOutputs {
+    /**
+     * The policy document JSON
+     */
+    readonly policy: any;
+}
+export interface IPolicyDocument extends IAwsConstruct {
+    readonly policyDocumentOutputs: PolicyDocumentOutputs;
+    readonly isEmpty: boolean;
+    readonly statementCount: number;
+    readonly json: string;
+    /**
+     * Adds a statement to the policy document.
+     *
+     * @param statement the statement to add.
+     */
+    addStatements(...statement: PolicyStatement[]): void;
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for any policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForAnyPolicy(): string[];
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for a resource-based policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForResourcePolicy(): string[] /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for an identity-based policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */;
+    validateForIdentityPolicy(): string[];
+    /**
+     * Get AWS IAM Policy document JSON
+     *
+     * NOTE: This may contain unresolved tokens, use spec.resolve() to resolve them.
+     */
+    toDocumentJson(): any;
+}
+export interface PolicyDocumentProps extends PolicyDocumentConfig {
+    /**
+     * Try to minimize the policy by merging statements
+     *
+     * To avoid overrunning the maximum policy size, combine statements if they produce
+     * the same result. Merging happens according to the following rules:
+     *
+     * - The Effect of both statements is the same
+     * - Neither of the statements have a 'Sid'
+     * - Combine Principals if the rest of the statement is exactly the same.
+     * - Combine Resources if the rest of the statement is exactly the same.
+     * - Combine Actions if the rest of the statement is exactly the same.
+     * - We will never combine NotPrincipals, NotResources or NotActions, because doing
+     *   so would change the meaning of the policy document.
+     *
+     * @default - false, unless the feature flag `@aws-cdk/aws-iam:minimizePolicies` is set
+     */
+    readonly minimize?: boolean;
+    /**
+     * Automatically assign Statement Ids to all statements
+     *
+     * @default false
+     */
+    readonly assignSids?: boolean;
+}
+export declare class PolicyDocument extends AwsConstructBase implements IPolicyDocument {
+    /**
+     * Creates a new PolicyDocument based on the object provided.
+     * This will accept an object created from the `.toDocumentJson()` call
+     * @param obj the PolicyDocument in object form.
+     */
+    static fromJson(scope: Construct, id: string, obj: any): PolicyDocument;
+    readonly statements: PolicyStatement[];
+    readonly resource: dataAwsIamPolicyDocument.DataAwsIamPolicyDocument;
+    get policyDocumentOutputs(): PolicyDocumentOutputs;
+    get outputs(): Record<string, any>;
+    get json(): string;
+    private readonly autoAssignSids;
+    private readonly minimize?;
+    constructor(scope: Construct, id: string, props?: PolicyDocumentProps);
+    /**
+     * Perform statement merging (if enabled and not done yet)
+     *
+     * @internal
+     */
+    _maybeMergeStatements(): void;
+    /**
+     * Get AWS IAM Policy document JSON
+     *
+     * NOTE: May contain tokens, use spec.resolve() to resolve them.
+     */
+    toDocumentJson(): any;
+    /**
+     * Whether the policy document contains any statements.
+     */
+    get isEmpty(): boolean;
+    /**
+     * The number of statements already added to this policy.
+     * Can be used, for example, to generate unique "sid"s within the policy.
+     */
+    get statementCount(): number;
+    /**
+     * Adds a statement to the policy document.
+     *
+     * @param statement the statement to add.
+     */
+    addStatements(...statement: PolicyStatement[]): void;
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for any policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForAnyPolicy(): string[];
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for a resource-based policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForResourcePolicy(): string[];
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for an identity-based policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForIdentityPolicy(): string[];
+}

package/lib/aws/iam/policy-document.js

@@ -0,0 +1,172 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PolicyDocument = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+// ref: https://github.com/aws/aws-cdk/tree/v2.161.1/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts
+// CAVEAT: instead of using IResolvable, this is a Construct and its constructor requires scope and id
+// This synths directly to the terraform-provider-aws `aws_iam_policy_document` data source.
+// This is not undefined when the policy document is empty.
+// TODO: Add validation and errors for empty policy documents
+const provider_aws_1 = require("@cdktf/provider-aws");
+const cdktf_1 = require("cdktf");
+const policy_statement_1 = require("./policy-statement");
+const aws_construct_1 = require("../aws-construct");
+const merge_statements_1 = require("./private/merge-statements");
+const postprocess_policy_document_1 = require("./private/postprocess-policy-document");
+class PolicyDocument extends aws_construct_1.AwsConstructBase {
+    /**
+     * Creates a new PolicyDocument based on the object provided.
+     * This will accept an object created from the `.toDocumentJson()` call
+     * @param obj the PolicyDocument in object form.
+     */
+    static fromJson(scope, id, obj) {
+        const newPolicyDocument = new PolicyDocument(scope, id);
+        const statement = obj.Statement ?? [];
+        if (statement && !Array.isArray(statement)) {
+            throw new Error("Statement must be an array");
+        }
+        newPolicyDocument.addStatements(...statement.map((s) => policy_statement_1.PolicyStatement.fromJson(s)));
+        return newPolicyDocument;
+    }
+    // private readonly autoAssignSids: boolean;
+    // private readonly minimize?: boolean;
+    get policyDocumentOutputs() {
+        return { policy: this.json };
+    }
+    get outputs() {
+        return this.policyDocumentOutputs;
+    }
+    get json() {
+        return this.resource.json;
+    }
+    constructor(scope, id, props = {}) {
+        super(scope, id, props);
+        this.statements = new Array();
+        this.autoAssignSids = !!props.assignSids;
+        this.minimize = props.minimize ?? false;
+        this.addStatements(...(props.statement || []));
+        const self = this;
+        // TODO: move in toTerraform() and don't generate anything if isEmpty()?
+        this.resource = new provider_aws_1.dataAwsIamPolicyDocument.DataAwsIamPolicyDocument(this, "Resource", {
+            ...props,
+            statement: cdktf_1.Lazy.anyValue({
+                produce: (context) => {
+                    this._maybeMergeStatements();
+                    context.registerPostProcessor(new postprocess_policy_document_1.PostProcessPolicyDocument(self.autoAssignSids));
+                    return this.statements.map((s) => provider_aws_1.dataAwsIamPolicyDocument.dataAwsIamPolicyDocumentStatementToTerraform(s.toJSON()));
+                },
+            }),
+        });
+    }
+    /**
+     * Perform statement merging (if enabled and not done yet)
+     *
+     * @internal
+     */
+    _maybeMergeStatements() {
+        if (this.minimize && this.statements.length > 1) {
+            const result = (0, merge_statements_1.mergeStatements)(this.statements, { scope: this });
+            this.statements.splice(0, this.statements.length, ...result.mergedStatements);
+        }
+    }
+    // /**
+    //  * JSON-ify the document
+    //  *
+    //  * Used when JSON.stringify() is called
+    //  */
+    // public toJSON(): any {
+    //   return {
+    //     statement: this.statements.map((s) => s.toJSON()),
+    //   };
+    // }
+    //TODO: Caution - toTerraform() returns nothing by design!
+    // Adding toTerraform() will cause infinite recursion
+    /**
+     * Get AWS IAM Policy document JSON
+     *
+     * NOTE: May contain tokens, use spec.resolve() to resolve them.
+     */
+    toDocumentJson() {
+        if (this.isEmpty) {
+            return undefined;
+        }
+        // merge resolved statements
+        this._maybeMergeStatements();
+        const doc = {
+            Statement: this.statements.map((s) => s.toStatementJson()),
+            Version: "2012-10-17",
+        };
+        return doc;
+    }
+    /**
+     * Whether the policy document contains any statements.
+     */
+    get isEmpty() {
+        return this.statements.length === 0;
+    }
+    /**
+     * The number of statements already added to this policy.
+     * Can be used, for example, to generate unique "sid"s within the policy.
+     */
+    get statementCount() {
+        return this.statements.length;
+    }
+    /**
+     * Adds a statement to the policy document.
+     *
+     * @param statement the statement to add.
+     */
+    addStatements(...statement) {
+        this.statements.push(...statement);
+    }
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for any policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForAnyPolicy() {
+        const errors = new Array();
+        for (const statement of this.statements) {
+            errors.push(...statement.validateForAnyPolicy());
+        }
+        return errors;
+    }
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for a resource-based policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForResourcePolicy() {
+        const errors = new Array();
+        for (const statement of this.statements) {
+            errors.push(...statement.validateForResourcePolicy());
+        }
+        return errors;
+    }
+    /**
+     * Validate that all policy statements in the policy document satisfies the
+     * requirements for an identity-based policy.
+     *
+     * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json
+     *
+     * @returns An array of validation error messages, or an empty array if the document is valid.
+     */
+    validateForIdentityPolicy() {
+        const errors = new Array();
+        for (const statement of this.statements) {
+            errors.push(...statement.validateForIdentityPolicy());
+        }
+        return errors;
+    }
+}
+exports.PolicyDocument = PolicyDocument;
+_a = JSII_RTTI_SYMBOL_1;
+PolicyDocument[_a] = { fqn: "terraconstructs.aws.iam.PolicyDocument", version: "0.0.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"policy-document.js","sourceRoot":"","sources":["../../../src/aws/iam/policy-document.ts"],"names":[],"mappings":"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","sourcesContent":["// ref: https://github.com/aws/aws-cdk/tree/v2.161.1/packages/aws-cdk-lib/aws-iam/lib/policy-document.ts\n// CAVEAT: instead of using IResolvable, this is a Construct and its constructor requires scope and id\n// This synths directly to the terraform-provider-aws `aws_iam_policy_document` data source.\n// This is not undefined when the policy document is empty.\n// TODO: Add validation and errors for empty policy documents\nimport { dataAwsIamPolicyDocument } from \"@cdktf/provider-aws\";\nimport { Lazy, IResolveContext } from \"cdktf\";\nimport { Construct } from \"constructs\";\nimport { PolicyDocumentConfig } from \"./policy-document-config.generated\";\nimport { PolicyStatement } from \"./policy-statement\";\nimport { AwsConstructBase, IAwsConstruct } from \"../aws-construct\";\nimport { mergeStatements } from \"./private/merge-statements\";\nimport { PostProcessPolicyDocument } from \"./private/postprocess-policy-document\";\n\nexport interface PolicyDocumentOutputs {\n  /**\n   * The policy document JSON\n   */\n  readonly policy: any;\n}\n\nexport interface IPolicyDocument extends IAwsConstruct {\n  // strongly typed access to outputs\n  readonly policyDocumentOutputs: PolicyDocumentOutputs;\n  readonly isEmpty: boolean;\n  readonly statementCount: number;\n  readonly json: string;\n  /**\n   * Adds a statement to the policy document.\n   *\n   * @param statement the statement to add.\n   */\n  addStatements(...statement: PolicyStatement[]): void;\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for any policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  validateForAnyPolicy(): string[];\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for a resource-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  validateForResourcePolicy(): string[] /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for an identity-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */;\n  validateForIdentityPolicy(): string[];\n  /**\n   * Get AWS IAM Policy document JSON\n   *\n   * NOTE: This may contain unresolved tokens, use spec.resolve() to resolve them.\n   */\n  toDocumentJson(): any;\n}\n\nexport interface PolicyDocumentProps extends PolicyDocumentConfig {\n  /**\n   * Try to minimize the policy by merging statements\n   *\n   * To avoid overrunning the maximum policy size, combine statements if they produce\n   * the same result. Merging happens according to the following rules:\n   *\n   * - The Effect of both statements is the same\n   * - Neither of the statements have a 'Sid'\n   * - Combine Principals if the rest of the statement is exactly the same.\n   * - Combine Resources if the rest of the statement is exactly the same.\n   * - Combine Actions if the rest of the statement is exactly the same.\n   * - We will never combine NotPrincipals, NotResources or NotActions, because doing\n   *   so would change the meaning of the policy document.\n   *\n   * @default - false, unless the feature flag `@aws-cdk/aws-iam:minimizePolicies` is set\n   */\n  readonly minimize?: boolean;\n  /**\n   * Automatically assign Statement Ids to all statements\n   *\n   * @default false\n   */\n  readonly assignSids?: boolean;\n}\n\nexport class PolicyDocument\n  extends AwsConstructBase\n  implements IPolicyDocument\n{\n  /**\n   * Creates a new PolicyDocument based on the object provided.\n   * This will accept an object created from the `.toDocumentJson()` call\n   * @param obj the PolicyDocument in object form.\n   */\n  public static fromJson(\n    scope: Construct,\n    id: string,\n    obj: any,\n  ): PolicyDocument {\n    const newPolicyDocument = new PolicyDocument(scope, id);\n    const statement = obj.Statement ?? [];\n    if (statement && !Array.isArray(statement)) {\n      throw new Error(\"Statement must be an array\");\n    }\n    newPolicyDocument.addStatements(\n      ...statement.map((s: any) => PolicyStatement.fromJson(s)),\n    );\n    return newPolicyDocument;\n  }\n\n  public readonly statements = new Array<PolicyStatement>();\n  public readonly resource: dataAwsIamPolicyDocument.DataAwsIamPolicyDocument;\n  // private readonly autoAssignSids: boolean;\n  // private readonly minimize?: boolean;\n\n  public get policyDocumentOutputs(): PolicyDocumentOutputs {\n    return { policy: this.json };\n  }\n  public get outputs(): Record<string, any> {\n    return this.policyDocumentOutputs;\n  }\n\n  public get json(): string {\n    return this.resource.json;\n  }\n  private readonly autoAssignSids: boolean;\n  private readonly minimize?: boolean;\n\n  constructor(scope: Construct, id: string, props: PolicyDocumentProps = {}) {\n    super(scope, id, props);\n    this.autoAssignSids = !!props.assignSids;\n    this.minimize = props.minimize ?? false;\n    this.addStatements(...(props.statement || []));\n    const self = this;\n    // TODO: move in toTerraform() and don't generate anything if isEmpty()?\n    this.resource = new dataAwsIamPolicyDocument.DataAwsIamPolicyDocument(\n      this,\n      \"Resource\",\n      {\n        ...props,\n        statement: Lazy.anyValue({\n          produce: (context: IResolveContext) => {\n            this._maybeMergeStatements();\n            context.registerPostProcessor(\n              new PostProcessPolicyDocument(self.autoAssignSids),\n            );\n            return this.statements.map((s) =>\n              dataAwsIamPolicyDocument.dataAwsIamPolicyDocumentStatementToTerraform(\n                s.toJSON(),\n              ),\n            );\n          },\n        }),\n      },\n    );\n  }\n\n  /**\n   * Perform statement merging (if enabled and not done yet)\n   *\n   * @internal\n   */\n  public _maybeMergeStatements(): void {\n    if (this.minimize && this.statements.length > 1) {\n      const result = mergeStatements(this.statements, { scope: this });\n      this.statements.splice(\n        0,\n        this.statements.length,\n        ...result.mergedStatements,\n      );\n    }\n  }\n\n  // /**\n  //  * JSON-ify the document\n  //  *\n  //  * Used when JSON.stringify() is called\n  //  */\n  // public toJSON(): any {\n  //   return {\n  //     statement: this.statements.map((s) => s.toJSON()),\n  //   };\n  // }\n\n  //TODO: Caution - toTerraform() returns nothing by design!\n  // Adding toTerraform() will cause infinite recursion\n\n  /**\n   * Get AWS IAM Policy document JSON\n   *\n   * NOTE: May contain tokens, use spec.resolve() to resolve them.\n   */\n  public toDocumentJson(): any {\n    if (this.isEmpty) {\n      return undefined;\n    }\n\n    // merge resolved statements\n    this._maybeMergeStatements();\n    const doc = {\n      Statement: this.statements.map((s) => s.toStatementJson()),\n      Version: \"2012-10-17\",\n    };\n\n    return doc;\n  }\n\n  /**\n   * Whether the policy document contains any statements.\n   */\n  public get isEmpty(): boolean {\n    return this.statements.length === 0;\n  }\n\n  /**\n   * The number of statements already added to this policy.\n   * Can be used, for example, to generate unique \"sid\"s within the policy.\n   */\n  public get statementCount(): number {\n    return this.statements.length;\n  }\n\n  /**\n   * Adds a statement to the policy document.\n   *\n   * @param statement the statement to add.\n   */\n  public addStatements(...statement: PolicyStatement[]) {\n    this.statements.push(...statement);\n  }\n\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for any policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  public validateForAnyPolicy(): string[] {\n    const errors = new Array<string>();\n    for (const statement of this.statements) {\n      errors.push(...statement.validateForAnyPolicy());\n    }\n    return errors;\n  }\n\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for a resource-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  public validateForResourcePolicy(): string[] {\n    const errors = new Array<string>();\n    for (const statement of this.statements) {\n      errors.push(...statement.validateForResourcePolicy());\n    }\n    return errors;\n  }\n\n  /**\n   * Validate that all policy statements in the policy document satisfies the\n   * requirements for an identity-based policy.\n   *\n   * @see https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html#access_policies-json\n   *\n   * @returns An array of validation error messages, or an empty array if the document is valid.\n   */\n  public validateForIdentityPolicy(): string[] {\n    const errors = new Array<string>();\n    for (const statement of this.statements) {\n      errors.push(...statement.validateForIdentityPolicy());\n    }\n    return errors;\n  }\n\n  // /**\n  //  * Freeze all statements\n  //  */\n  // private freezeStatements() {\n  //   for (const statement of this.statements) {\n  //     statement.freeze();\n  //   }\n  // }\n}\n"]}

package/lib/aws/iam/policy-statement-props.generated.d.ts

@@ -0,0 +1,55 @@
+import type { Condition, Effect, IPrincipal } from './';
+/**
+ * Interface for creating a policy statement
+ */
+export interface PolicyStatementProps {
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#sid DataAwsIamPolicyDocument#sid}.
+     * @stability stable
+     */
+    readonly sid?: string;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#resources DataAwsIamPolicyDocument#resources}.
+     * @stability stable
+     */
+    readonly resources?: Array<string>;
+    /**
+     * principals block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#principals DataAwsIamPolicyDocument#principals}
+     * @stability stable
+     */
+    readonly principals?: Array<IPrincipal>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#not_resources DataAwsIamPolicyDocument#not_resources}.
+     * @stability stable
+     */
+    readonly notResources?: Array<string>;
+    /**
+     * not_principals block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#not_principals DataAwsIamPolicyDocument#not_principals}
+     * @stability stable
+     */
+    readonly notPrincipals?: Array<IPrincipal>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#not_actions DataAwsIamPolicyDocument#not_actions}.
+     * @stability stable
+     */
+    readonly notActions?: Array<string>;
+    /**
+     * Whether to allow or deny the actions in this statement.
+     * @default Effect.ALLOW
+     * @stability stable
+     */
+    readonly effect?: Effect;
+    /**
+     * condition block.
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#condition DataAwsIamPolicyDocument#condition}
+     * @stability stable
+     */
+    readonly condition?: Array<Condition>;
+    /**
+     * Docs at Terraform Registry: {@link https://registry.terraform.io/providers/hashicorp/aws/5.68.0/docs/data-sources/iam_policy_document#actions DataAwsIamPolicyDocument#actions}.
+     * @stability stable
+     */
+    readonly actions?: Array<string>;
+}

package/lib/aws/iam/policy-statement-props.generated.js

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