@microsoft/terraform-cdk-constructs 2.2.0 → 2.5.1

package/lib/azure-staticwebapp/test/static-web-app.spec.js

@@ -0,0 +1,293 @@
+"use strict";
+/**
+ * Unit tests for Azure Static Web App construct
+ *
+ * Tests cover:
+ * - Resource type validation
+ * - API version support (2022-03-01, 2023-12-01, 2024-04-01)
+ * - Basic creation scenarios
+ * - SKU configurations (Free, Standard)
+ * - Source control integration
+ * - Build properties
+ * - Tag management
+ * - Output properties
+ * - Ignore changes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+const cdktn = require("cdktn");
+const static_web_app_1 = require("../lib/static-web-app");
+describe("StaticWebApp", () => {
+    let app;
+    let stack;
+    beforeEach(() => {
+        app = cdktn_1.Testing.app();
+        stack = new cdktn.TerraformStack(app, "TestStack");
+    });
+    describe("Resource Type", () => {
+        it("should create a Static Web App instance", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa).toBeInstanceOf(static_web_app_1.StaticWebApp);
+        });
+    });
+    describe("API Version Support", () => {
+        it("should support API version 2022-03-01", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                apiVersion: "2022-03-01",
+            });
+            expect(swa.resolvedApiVersion).toBe("2022-03-01");
+        });
+        it("should support API version 2023-12-01", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                apiVersion: "2023-12-01",
+            });
+            expect(swa.resolvedApiVersion).toBe("2023-12-01");
+        });
+        it("should support API version 2024-04-01", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                apiVersion: "2024-04-01",
+            });
+            expect(swa.resolvedApiVersion).toBe("2024-04-01");
+        });
+        it("should default to 2024-04-01", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa.resolvedApiVersion).toBe("2024-04-01");
+        });
+    });
+    describe("Basic Creation", () => {
+        it("should create a Free-tier Static Web App", () => {
+            const props = {
+                name: "test-swa",
+                location: "eastus2",
+                sku: {
+                    name: "Free",
+                    tier: "Free",
+                },
+            };
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", props);
+            expect(swa).toBeInstanceOf(static_web_app_1.StaticWebApp);
+            expect(swa.props).toBe(props);
+            expect(swa.props.sku?.name).toBe("Free");
+            expect(swa.props.sku?.tier).toBe("Free");
+        });
+        it("should create a Standard-tier Static Web App", () => {
+            const props = {
+                name: "test-swa",
+                location: "westus2",
+                sku: {
+                    name: "Standard",
+                    tier: "Standard",
+                },
+            };
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", props);
+            expect(swa.props.sku?.name).toBe("Standard");
+            expect(swa.props.sku?.tier).toBe("Standard");
+        });
+        it("should default SKU to Free in the resource body", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa).toBeInstanceOf(static_web_app_1.StaticWebApp);
+            expect(swa.props.sku).toBeUndefined();
+        });
+    });
+    describe("Source Control Integration", () => {
+        it("should configure GitHub source control integration", () => {
+            const props = {
+                name: "test-swa",
+                location: "eastus2",
+                sku: { name: "Standard", tier: "Standard" },
+                repositoryUrl: "https://github.com/my-org/my-repo",
+                branch: "main",
+                repositoryToken: "github_token_placeholder",
+                buildProperties: {
+                    appLocation: "/",
+                    apiLocation: "api",
+                    outputLocation: "dist",
+                },
+            };
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", props);
+            expect(swa.props.repositoryUrl).toBe("https://github.com/my-org/my-repo");
+            expect(swa.props.branch).toBe("main");
+            expect(swa.props.repositoryToken).toBe("github_token_placeholder");
+            expect(swa.props.buildProperties?.appLocation).toBe("/");
+            expect(swa.props.buildProperties?.apiLocation).toBe("api");
+            expect(swa.props.buildProperties?.outputLocation).toBe("dist");
+        });
+        it("should support build commands", () => {
+            const props = {
+                name: "test-swa",
+                location: "eastus2",
+                repositoryUrl: "https://github.com/my-org/my-repo",
+                branch: "main",
+                buildProperties: {
+                    appLocation: "/",
+                    appBuildCommand: "npm run build",
+                    apiBuildCommand: "npm run build:api",
+                    skipGithubActionWorkflowGeneration: true,
+                },
+            };
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", props);
+            expect(swa.props.buildProperties?.appBuildCommand).toBe("npm run build");
+            expect(swa.props.buildProperties?.apiBuildCommand).toBe("npm run build:api");
+            expect(swa.props.buildProperties?.skipGithubActionWorkflowGeneration).toBe(true);
+        });
+    });
+    describe("Configuration Options", () => {
+        it("should configure staging environment policy", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                stagingEnvironmentPolicy: "Disabled",
+            });
+            expect(swa.props.stagingEnvironmentPolicy).toBe("Disabled");
+        });
+        it("should configure allowConfigFileUpdates", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                allowConfigFileUpdates: false,
+            });
+            expect(swa.props.allowConfigFileUpdates).toBe(false);
+        });
+    });
+    describe("Tags", () => {
+        it("should add tags to the Static Web App", () => {
+            const props = {
+                name: "test-swa",
+                location: "eastus2",
+                tags: {
+                    Environment: "Production",
+                    Department: "IT",
+                },
+            };
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", props);
+            expect(swa.props.tags?.Environment).toBe("Production");
+            expect(swa.props.tags?.Department).toBe("IT");
+        });
+        it("should support adding tags", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                tags: { environment: "test" },
+            });
+            swa.addTag("newTag", "newValue");
+            expect(swa.props.tags.newTag).toBe("newValue");
+            expect(swa.props.tags.environment).toBe("test");
+        });
+        it("should support removing tags", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                tags: {
+                    environment: "test",
+                    temporary: "true",
+                },
+            });
+            swa.removeTag("temporary");
+            expect(swa.props.tags.temporary).toBeUndefined();
+            expect(swa.props.tags.environment).toBe("test");
+        });
+        it("should handle empty tags by default", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa.tags).toEqual({});
+        });
+    });
+    describe("Output Properties", () => {
+        it("should expose id, name, location, tags and default hostname outputs", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa.id).toBeDefined();
+            expect(swa.idOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(swa.nameOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(swa.locationOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(swa.tagsOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(swa.defaultHostnameOutput).toBeInstanceOf(cdktn.TerraformOutput);
+        });
+        it("should have correct id format and resourceId alias", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa.id).toMatch(/^\$\{.*\.id\}$/);
+            expect(swa.resourceId).toBe(swa.id);
+        });
+        it("should expose a defaultHostname interpolation", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+            });
+            expect(swa.defaultHostname).toContain("defaultHostname");
+        });
+    });
+    describe("Ignore Changes Configuration", () => {
+        it("should apply ignore changes lifecycle rules", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                ignoreChanges: ["tags", "body.properties.repositoryToken"],
+            });
+            expect(swa).toBeInstanceOf(static_web_app_1.StaticWebApp);
+            expect(swa.props.ignoreChanges).toEqual([
+                "tags",
+                "body.properties.repositoryToken",
+            ]);
+        });
+        it("should handle empty ignore changes array", () => {
+            const swa = new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                ignoreChanges: [],
+            });
+            expect(swa).toBeInstanceOf(static_web_app_1.StaticWebApp);
+        });
+    });
+    describe("CDK Terraform Integration", () => {
+        it("should synthesize to valid Terraform configuration", () => {
+            new static_web_app_1.StaticWebApp(stack, "test-swa", {
+                name: "test-swa",
+                location: "eastus2",
+                tags: { test: "synthesis" },
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+            const stackConfig = JSON.parse(synthesized);
+            expect(stackConfig.resource).toBeDefined();
+        });
+        it("should handle multiple Static Web Apps in the same stack", () => {
+            const swa1 = new static_web_app_1.StaticWebApp(stack, "SWA1", {
+                name: "swa-1",
+                location: "eastus2",
+            });
+            const swa2 = new static_web_app_1.StaticWebApp(stack, "SWA2", {
+                name: "swa-2",
+                location: "westus2",
+                apiVersion: "2022-03-01",
+                sku: { name: "Standard", tier: "Standard" },
+            });
+            expect(swa1.resolvedApiVersion).toBe("2024-04-01");
+            expect(swa2.resolvedApiVersion).toBe("2022-03-01");
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toBeDefined();
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"static-web-app.spec.js","sourceRoot":"","sources":["../../../src/azure-staticwebapp/test/static-web-app.spec.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Unit tests for Azure Static Web App construct\n *\n * Tests cover:\n * - Resource type validation\n * - API version support (2022-03-01, 2023-12-01, 2024-04-01)\n * - Basic creation scenarios\n * - SKU configurations (Free, Standard)\n * - Source control integration\n * - Build properties\n * - Tag management\n * - Output properties\n * - Ignore changes\n */\n\nimport { Testing } from \"cdktn\";\nimport * as cdktn from \"cdktn\";\nimport { StaticWebApp, StaticWebAppProps } from \"../lib/static-web-app\";\n\ndescribe(\"StaticWebApp\", () => {\n  let app: cdktn.App;\n  let stack: cdktn.TerraformStack;\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktn.TerraformStack(app, \"TestStack\");\n  });\n\n  describe(\"Resource Type\", () => {\n    it(\"should create a Static Web App instance\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa).toBeInstanceOf(StaticWebApp);\n    });\n  });\n\n  describe(\"API Version Support\", () => {\n    it(\"should support API version 2022-03-01\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        apiVersion: \"2022-03-01\",\n      });\n\n      expect(swa.resolvedApiVersion).toBe(\"2022-03-01\");\n    });\n\n    it(\"should support API version 2023-12-01\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        apiVersion: \"2023-12-01\",\n      });\n\n      expect(swa.resolvedApiVersion).toBe(\"2023-12-01\");\n    });\n\n    it(\"should support API version 2024-04-01\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        apiVersion: \"2024-04-01\",\n      });\n\n      expect(swa.resolvedApiVersion).toBe(\"2024-04-01\");\n    });\n\n    it(\"should default to 2024-04-01\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa.resolvedApiVersion).toBe(\"2024-04-01\");\n    });\n  });\n\n  describe(\"Basic Creation\", () => {\n    it(\"should create a Free-tier Static Web App\", () => {\n      const props: StaticWebAppProps = {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        sku: {\n          name: \"Free\",\n          tier: \"Free\",\n        },\n      };\n\n      const swa = new StaticWebApp(stack, \"test-swa\", props);\n\n      expect(swa).toBeInstanceOf(StaticWebApp);\n      expect(swa.props).toBe(props);\n      expect(swa.props.sku?.name).toBe(\"Free\");\n      expect(swa.props.sku?.tier).toBe(\"Free\");\n    });\n\n    it(\"should create a Standard-tier Static Web App\", () => {\n      const props: StaticWebAppProps = {\n        name: \"test-swa\",\n        location: \"westus2\",\n        sku: {\n          name: \"Standard\",\n          tier: \"Standard\",\n        },\n      };\n\n      const swa = new StaticWebApp(stack, \"test-swa\", props);\n\n      expect(swa.props.sku?.name).toBe(\"Standard\");\n      expect(swa.props.sku?.tier).toBe(\"Standard\");\n    });\n\n    it(\"should default SKU to Free in the resource body\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa).toBeInstanceOf(StaticWebApp);\n      expect(swa.props.sku).toBeUndefined();\n    });\n  });\n\n  describe(\"Source Control Integration\", () => {\n    it(\"should configure GitHub source control integration\", () => {\n      const props: StaticWebAppProps = {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        sku: { name: \"Standard\", tier: \"Standard\" },\n        repositoryUrl: \"https://github.com/my-org/my-repo\",\n        branch: \"main\",\n        repositoryToken: \"github_token_placeholder\",\n        buildProperties: {\n          appLocation: \"/\",\n          apiLocation: \"api\",\n          outputLocation: \"dist\",\n        },\n      };\n\n      const swa = new StaticWebApp(stack, \"test-swa\", props);\n\n      expect(swa.props.repositoryUrl).toBe(\"https://github.com/my-org/my-repo\");\n      expect(swa.props.branch).toBe(\"main\");\n      expect(swa.props.repositoryToken).toBe(\"github_token_placeholder\");\n      expect(swa.props.buildProperties?.appLocation).toBe(\"/\");\n      expect(swa.props.buildProperties?.apiLocation).toBe(\"api\");\n      expect(swa.props.buildProperties?.outputLocation).toBe(\"dist\");\n    });\n\n    it(\"should support build commands\", () => {\n      const props: StaticWebAppProps = {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        repositoryUrl: \"https://github.com/my-org/my-repo\",\n        branch: \"main\",\n        buildProperties: {\n          appLocation: \"/\",\n          appBuildCommand: \"npm run build\",\n          apiBuildCommand: \"npm run build:api\",\n          skipGithubActionWorkflowGeneration: true,\n        },\n      };\n\n      const swa = new StaticWebApp(stack, \"test-swa\", props);\n\n      expect(swa.props.buildProperties?.appBuildCommand).toBe(\"npm run build\");\n      expect(swa.props.buildProperties?.apiBuildCommand).toBe(\n        \"npm run build:api\",\n      );\n      expect(\n        swa.props.buildProperties?.skipGithubActionWorkflowGeneration,\n      ).toBe(true);\n    });\n  });\n\n  describe(\"Configuration Options\", () => {\n    it(\"should configure staging environment policy\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        stagingEnvironmentPolicy: \"Disabled\",\n      });\n\n      expect(swa.props.stagingEnvironmentPolicy).toBe(\"Disabled\");\n    });\n\n    it(\"should configure allowConfigFileUpdates\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        allowConfigFileUpdates: false,\n      });\n\n      expect(swa.props.allowConfigFileUpdates).toBe(false);\n    });\n  });\n\n  describe(\"Tags\", () => {\n    it(\"should add tags to the Static Web App\", () => {\n      const props: StaticWebAppProps = {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        tags: {\n          Environment: \"Production\",\n          Department: \"IT\",\n        },\n      };\n\n      const swa = new StaticWebApp(stack, \"test-swa\", props);\n\n      expect(swa.props.tags?.Environment).toBe(\"Production\");\n      expect(swa.props.tags?.Department).toBe(\"IT\");\n    });\n\n    it(\"should support adding tags\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        tags: { environment: \"test\" },\n      });\n\n      swa.addTag(\"newTag\", \"newValue\");\n      expect(swa.props.tags!.newTag).toBe(\"newValue\");\n      expect(swa.props.tags!.environment).toBe(\"test\");\n    });\n\n    it(\"should support removing tags\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        tags: {\n          environment: \"test\",\n          temporary: \"true\",\n        },\n      });\n\n      swa.removeTag(\"temporary\");\n      expect(swa.props.tags!.temporary).toBeUndefined();\n      expect(swa.props.tags!.environment).toBe(\"test\");\n    });\n\n    it(\"should handle empty tags by default\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa.tags).toEqual({});\n    });\n  });\n\n  describe(\"Output Properties\", () => {\n    it(\"should expose id, name, location, tags and default hostname outputs\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa.id).toBeDefined();\n      expect(swa.idOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(swa.nameOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(swa.locationOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(swa.tagsOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(swa.defaultHostnameOutput).toBeInstanceOf(cdktn.TerraformOutput);\n    });\n\n    it(\"should have correct id format and resourceId alias\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa.id).toMatch(/^\\$\\{.*\\.id\\}$/);\n      expect(swa.resourceId).toBe(swa.id);\n    });\n\n    it(\"should expose a defaultHostname interpolation\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n      });\n\n      expect(swa.defaultHostname).toContain(\"defaultHostname\");\n    });\n  });\n\n  describe(\"Ignore Changes Configuration\", () => {\n    it(\"should apply ignore changes lifecycle rules\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        ignoreChanges: [\"tags\", \"body.properties.repositoryToken\"],\n      });\n\n      expect(swa).toBeInstanceOf(StaticWebApp);\n      expect(swa.props.ignoreChanges).toEqual([\n        \"tags\",\n        \"body.properties.repositoryToken\",\n      ]);\n    });\n\n    it(\"should handle empty ignore changes array\", () => {\n      const swa = new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        ignoreChanges: [],\n      });\n\n      expect(swa).toBeInstanceOf(StaticWebApp);\n    });\n  });\n\n  describe(\"CDK Terraform Integration\", () => {\n    it(\"should synthesize to valid Terraform configuration\", () => {\n      new StaticWebApp(stack, \"test-swa\", {\n        name: \"test-swa\",\n        location: \"eastus2\",\n        tags: { test: \"synthesis\" },\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n\n      const stackConfig = JSON.parse(synthesized);\n      expect(stackConfig.resource).toBeDefined();\n    });\n\n    it(\"should handle multiple Static Web Apps in the same stack\", () => {\n      const swa1 = new StaticWebApp(stack, \"SWA1\", {\n        name: \"swa-1\",\n        location: \"eastus2\",\n      });\n\n      const swa2 = new StaticWebApp(stack, \"SWA2\", {\n        name: \"swa-2\",\n        location: \"westus2\",\n        apiVersion: \"2022-03-01\",\n        sku: { name: \"Standard\", tier: \"Standard\" },\n      });\n\n      expect(swa1.resolvedApiVersion).toBe(\"2024-04-01\");\n      expect(swa2.resolvedApiVersion).toBe(\"2022-03-01\");\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toBeDefined();\n    });\n  });\n});\n"]}

package/lib/azure-storageaccount/lib/storage-account.js

@@ -343,7 +343,7 @@ class StorageAccount extends azapi_resource_1.AzapiResource {
 }
 exports.StorageAccount = StorageAccount;
 _a = JSII_RTTI_SYMBOL_1;
-StorageAccount[_a] = { fqn: "@microsoft/terraform-cdk-constructs.StorageAccount", version: "2.2.0" };
+StorageAccount[_a] = { fqn: "@microsoft/terraform-cdk-constructs.StorageAccount", version: "2.5.1" };
 // Static initializer runs once when the class is first loaded
 (() => {
     azapi_resource_1.AzapiResource.registerSchemas(storage_account_schemas_1.STORAGE_ACCOUNT_TYPE, storage_account_schemas_1.ALL_STORAGE_ACCOUNT_VERSIONS);

package/lib/azure-storageblobcontainer/index.d.ts

@@ -0,0 +1 @@
+export * from "./lib";

package/lib/azure-storageblobcontainer/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lib"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtc3RvcmFnZWJsb2Jjb250YWluZXIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

package/lib/azure-storageblobcontainer/lib/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./storage-blob-container-schemas";
+export * from "./storage-blob-container";

package/lib/azure-storageblobcontainer/lib/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./storage-blob-container-schemas"), exports);
+__exportStar(require("./storage-blob-container"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtc3RvcmFnZWJsb2Jjb250YWluZXIvbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSxtRUFBaUQ7QUFDakQsMkRBQXlDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vc3RvcmFnZS1ibG9iLWNvbnRhaW5lci1zY2hlbWFzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9zdG9yYWdlLWJsb2ItY29udGFpbmVyXCI7XG4iXX0=

package/lib/azure-storageblobcontainer/lib/storage-blob-container-schemas.d.ts

@@ -0,0 +1,5 @@
+import { ApiSchema, VersionConfig } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+export declare const STORAGE_BLOB_CONTAINER_SCHEMA_2024_01_01: ApiSchema;
+export declare const STORAGE_BLOB_CONTAINER_VERSION_2024_01_01: VersionConfig;
+export declare const ALL_STORAGE_BLOB_CONTAINER_VERSIONS: VersionConfig[];
+export declare const STORAGE_BLOB_CONTAINER_TYPE = "Microsoft.Storage/storageAccounts/blobServices/containers";

package/lib/azure-storageblobcontainer/lib/storage-blob-container-schemas.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STORAGE_BLOB_CONTAINER_TYPE = exports.ALL_STORAGE_BLOB_CONTAINER_VERSIONS = exports.STORAGE_BLOB_CONTAINER_VERSION_2024_01_01 = exports.STORAGE_BLOB_CONTAINER_SCHEMA_2024_01_01 = void 0;
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const COMMON_PROPERTIES = {
+    name: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "Container name",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Name is required for Storage Blob Containers",
+            },
+        ],
+    },
+    publicAccess: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: 'Public access level: "None", "Blob", "Container"',
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.PATTERN_MATCH,
+                value: "^(None|Blob|Container)$",
+                message: "PublicAccess must be one of: None, Blob, Container",
+            },
+        ],
+    },
+    metadata: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: false,
+        description: "Container metadata dictionary",
+    },
+    defaultEncryptionScope: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "Default encryption scope",
+    },
+    denyEncryptionScopeOverride: {
+        dataType: version_interfaces_1.PropertyType.BOOLEAN,
+        required: false,
+        description: "Deny encryption scope override",
+    },
+    immutableStorageWithVersioning: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: false,
+        description: "Immutability policy",
+    },
+    storageAccountId: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The storage account ID (parent resource)",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "StorageAccountId is required for Storage Blob Containers",
+            },
+        ],
+    },
+};
+exports.STORAGE_BLOB_CONTAINER_SCHEMA_2024_01_01 = {
+    resourceType: "Microsoft.Storage/storageAccounts/blobServices/containers",
+    version: "2024-01-01",
+    properties: {
+        ...COMMON_PROPERTIES,
+    },
+    required: ["name", "storageAccountId"],
+    optional: [
+        "publicAccess",
+        "metadata",
+        "defaultEncryptionScope",
+        "denyEncryptionScopeOverride",
+        "immutableStorageWithVersioning",
+    ],
+    deprecated: [],
+    transformationRules: {},
+    validationRules: [
+        {
+            property: "name",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Name is required for Storage Blob Containers",
+                },
+            ],
+        },
+        {
+            property: "storageAccountId",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "StorageAccountId is required for Storage Blob Containers",
+                },
+            ],
+        },
+    ],
+};
+exports.STORAGE_BLOB_CONTAINER_VERSION_2024_01_01 = {
+    version: "2024-01-01",
+    schema: exports.STORAGE_BLOB_CONTAINER_SCHEMA_2024_01_01,
+    supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+    releaseDate: "2024-01-01",
+};
+exports.ALL_STORAGE_BLOB_CONTAINER_VERSIONS = [
+    exports.STORAGE_BLOB_CONTAINER_VERSION_2024_01_01,
+];
+exports.STORAGE_BLOB_CONTAINER_TYPE = "Microsoft.Storage/storageAccounts/blobServices/containers";
+//# sourceMappingURL=data:application/json;base64,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

package/lib/azure-storageblobcontainer/lib/storage-blob-container.d.ts

@@ -0,0 +1,37 @@
+import * as cdktn from "cdktn";
+import { Construct } from "constructs";
+import { AzapiResource, AzapiResourceProps } from "../../core-azure/lib/azapi/azapi-resource";
+import { ApiSchema } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+export interface StorageBlobContainerImmutableStorageWithVersioning {
+    readonly enabled: boolean;
+}
+export interface StorageBlobContainerProps extends AzapiResourceProps {
+    /** The storage account ID (parent resource) */
+    readonly storageAccountId: string;
+    /** Public access level. Default: "None" */
+    readonly publicAccess?: string;
+    /** Container metadata */
+    readonly metadata?: {
+        [key: string]: string;
+    };
+    /** Default encryption scope */
+    readonly defaultEncryptionScope?: string;
+    /** Deny encryption scope override */
+    readonly denyEncryptionScopeOverride?: boolean;
+    /** Immutable storage with versioning */
+    readonly immutableStorageWithVersioning?: StorageBlobContainerImmutableStorageWithVersioning;
+}
+export declare class StorageBlobContainer extends AzapiResource {
+    readonly props: StorageBlobContainerProps;
+    readonly idOutput: cdktn.TerraformOutput;
+    readonly nameOutput: cdktn.TerraformOutput;
+    constructor(scope: Construct, id: string, props: StorageBlobContainerProps);
+    protected defaultVersion(): string;
+    protected resourceType(): string;
+    protected apiSchema(): ApiSchema;
+    protected requiresLocation(): boolean;
+    protected createResourceBody(props: any): any;
+    /** Override parentId to use storage account's blob service as parent */
+    protected resolveParentId(props: any): string;
+    get resourceId(): string;
+}

package/lib/azure-storageblobcontainer/lib/storage-blob-container.js

@@ -0,0 +1,63 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageBlobContainer = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktn = require("cdktn");
+const storage_blob_container_schemas_1 = require("./storage-blob-container-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+class StorageBlobContainer extends azapi_resource_1.AzapiResource {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        this.props = props;
+        this.idOutput = new cdktn.TerraformOutput(this, "id", {
+            value: this.id,
+            description: "The ID of the Storage Blob Container",
+        });
+        this.nameOutput = new cdktn.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Storage Blob Container",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.nameOutput.overrideLogicalId("name");
+    }
+    defaultVersion() {
+        return "2024-01-01";
+    }
+    resourceType() {
+        return storage_blob_container_schemas_1.STORAGE_BLOB_CONTAINER_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return false;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        return {
+            properties: {
+                publicAccess: typedProps.publicAccess || "None",
+                metadata: typedProps.metadata,
+                defaultEncryptionScope: typedProps.defaultEncryptionScope,
+                denyEncryptionScopeOverride: typedProps.denyEncryptionScopeOverride,
+                immutableStorageWithVersioning: typedProps.immutableStorageWithVersioning,
+            },
+        };
+    }
+    /** Override parentId to use storage account's blob service as parent */
+    resolveParentId(props) {
+        const typedProps = props;
+        return `${typedProps.storageAccountId}/blobServices/default`;
+    }
+    get resourceId() {
+        return this.id;
+    }
+}
+exports.StorageBlobContainer = StorageBlobContainer;
+_a = JSII_RTTI_SYMBOL_1;
+StorageBlobContainer[_a] = { fqn: "@microsoft/terraform-cdk-constructs.StorageBlobContainer", version: "2.5.1" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(storage_blob_container_schemas_1.STORAGE_BLOB_CONTAINER_TYPE, storage_blob_container_schemas_1.ALL_STORAGE_BLOB_CONTAINER_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,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