@microsoft/terraform-cdk-constructs 1.10.0 → 2.5.0

package/lib/azure-eventgrideventsubscription/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("./event-grid-event-subscription-schemas"), exports);
+__exportStar(require("./event-grid-event-subscription"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYXp1cmUtZXZlbnRncmlkZXZlbnRzdWJzY3JpcHRpb24vbGliL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwRUFBd0Q7QUFDeEQsa0VBQWdEIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vZXZlbnQtZ3JpZC1ldmVudC1zdWJzY3JpcHRpb24tc2NoZW1hc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZXZlbnQtZ3JpZC1ldmVudC1zdWJzY3JpcHRpb25cIjtcbiJdfQ==

package/lib/azure-eventgrideventsubscription/test/event-grid-event-subscription.integ.d.ts

@@ -0,0 +1 @@
+import "cdktn/lib/testing/adapters/jest";

package/lib/azure-eventgrideventsubscription/test/event-grid-event-subscription.integ.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+require("cdktn/lib/testing/adapters/jest");
+const azure_eventgridsystemtopic_1 = require("../../azure-eventgridsystemtopic");
+const azure_resourcegroup_1 = require("../../azure-resourcegroup");
+const azure_storageaccount_1 = require("../../azure-storageaccount");
+const provider_1 = require("../../core-azure/lib/azapi/providers-azapi/provider");
+const resource_1 = require("../../core-azure/lib/azapi/providers-azapi/resource");
+const testing_1 = require("../../testing");
+const metadata_1 = require("../../testing/lib/metadata");
+const event_grid_event_subscription_1 = require("../lib/event-grid-event-subscription");
+const testMetadata = new metadata_1.TestRunMetadata("event-grid-event-subscription-integration", {
+    maxAgeHours: 4,
+});
+class EventGridEventSubscriptionExampleStack extends testing_1.BaseTestStack {
+    constructor(scope, id) {
+        super(scope, id, {
+            testRunOptions: {
+                maxAgeHours: testMetadata.maxAgeHours,
+                autoCleanup: testMetadata.autoCleanup,
+                cleanupPolicy: testMetadata.cleanupPolicy,
+            },
+        });
+        new provider_1.AzapiProvider(this, "azapi", {});
+        const rgName = this.generateResourceName("Microsoft.Resources/resourceGroups", "egeventsub");
+        const sourceStorageName = this.generateResourceName("Microsoft.Storage/storageAccounts", "egsource");
+        const destinationStorageName = this.generateResourceName("Microsoft.Storage/storageAccounts", "egdest");
+        const systemTopicName = this.generateResourceName("Microsoft.EventGrid/systemTopics", "topic");
+        const resourceGroup = new azure_resourcegroup_1.ResourceGroup(this, "example-rg", {
+            name: rgName,
+            location: "eastus",
+            tags: {
+                ...this.systemTags(),
+            },
+        });
+        const sourceStorage = new azure_storageaccount_1.StorageAccount(this, "source-storage", {
+            name: sourceStorageName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: { name: "Standard_LRS" },
+            tags: {
+                ...this.systemTags(),
+                role: "source",
+            },
+        });
+        const destinationStorage = new azure_storageaccount_1.StorageAccount(this, "destination-storage", {
+            name: destinationStorageName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            sku: { name: "Standard_LRS" },
+            tags: {
+                ...this.systemTags(),
+                role: "destination",
+            },
+        });
+        new resource_1.Resource(this, "destination-queue", {
+            type: "Microsoft.Storage/storageAccounts/queueServices/queues@2024-01-01",
+            parentId: `${destinationStorage.id}/queueServices/default`,
+            name: "events",
+            body: {
+                properties: {},
+            },
+        });
+        const systemTopic = new azure_eventgridsystemtopic_1.EventGridSystemTopic(this, "example-system-topic", {
+            name: systemTopicName,
+            location: resourceGroup.props.location,
+            resourceGroupId: resourceGroup.id,
+            source: sourceStorage.id,
+            topicType: "Microsoft.Storage.StorageAccounts",
+            tags: {
+                ...this.systemTags(),
+            },
+        });
+        new event_grid_event_subscription_1.EventGridEventSubscription(this, "example-event-subscription", {
+            name: "storage-events",
+            scope: systemTopic.id,
+            destination: {
+                endpointType: "StorageQueue",
+                properties: {
+                    resourceId: destinationStorage.id,
+                    queueName: "events",
+                },
+            },
+            filter: {
+                includedEventTypes: ["Microsoft.Storage.BlobCreated"],
+            },
+            labels: ["integration"],
+        });
+    }
+}
+describe("Event Grid Event Subscription Integration Test", () => {
+    it("should deploy, validate idempotency, and cleanup event grid event subscription resources", () => {
+        const app = cdktn_1.Testing.app();
+        const stack = new EventGridEventSubscriptionExampleStack(app, "test-event-grid-event-subscription");
+        const synthesized = cdktn_1.Testing.fullSynth(stack);
+        (0, testing_1.TerraformApplyCheckAndDestroy)(synthesized, { verifyCleanup: true });
+    }, 600000);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-grid-event-subscription.integ.js","sourceRoot":"","sources":["../../../src/azure-eventgrideventsubscription/test/event-grid-event-subscription.integ.ts"],"names":[],"mappings":"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","sourcesContent":["import { Testing } from \"cdktn\";\nimport { Construct } from \"constructs\";\nimport \"cdktn/lib/testing/adapters/jest\";\nimport { EventGridSystemTopic } from \"../../azure-eventgridsystemtopic\";\nimport { ResourceGroup } from \"../../azure-resourcegroup\";\nimport { StorageAccount } from \"../../azure-storageaccount\";\nimport { AzapiProvider } from \"../../core-azure/lib/azapi/providers-azapi/provider\";\nimport { Resource } from \"../../core-azure/lib/azapi/providers-azapi/resource\";\nimport { BaseTestStack, TerraformApplyCheckAndDestroy } from \"../../testing\";\nimport { TestRunMetadata } from \"../../testing/lib/metadata\";\nimport { EventGridEventSubscription } from \"../lib/event-grid-event-subscription\";\n\nconst testMetadata = new TestRunMetadata(\n  \"event-grid-event-subscription-integration\",\n  {\n    maxAgeHours: 4,\n  },\n);\n\nclass EventGridEventSubscriptionExampleStack extends BaseTestStack {\n  constructor(scope: Construct, id: string) {\n    super(scope, id, {\n      testRunOptions: {\n        maxAgeHours: testMetadata.maxAgeHours,\n        autoCleanup: testMetadata.autoCleanup,\n        cleanupPolicy: testMetadata.cleanupPolicy,\n      },\n    });\n\n    new AzapiProvider(this, \"azapi\", {});\n\n    const rgName = this.generateResourceName(\n      \"Microsoft.Resources/resourceGroups\",\n      \"egeventsub\",\n    );\n    const sourceStorageName = this.generateResourceName(\n      \"Microsoft.Storage/storageAccounts\",\n      \"egsource\",\n    );\n    const destinationStorageName = this.generateResourceName(\n      \"Microsoft.Storage/storageAccounts\",\n      \"egdest\",\n    );\n    const systemTopicName = this.generateResourceName(\n      \"Microsoft.EventGrid/systemTopics\",\n      \"topic\",\n    );\n\n    const resourceGroup = new ResourceGroup(this, \"example-rg\", {\n      name: rgName,\n      location: \"eastus\",\n      tags: {\n        ...this.systemTags(),\n      },\n    });\n\n    const sourceStorage = new StorageAccount(this, \"source-storage\", {\n      name: sourceStorageName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      sku: { name: \"Standard_LRS\" },\n      tags: {\n        ...this.systemTags(),\n        role: \"source\",\n      },\n    });\n\n    const destinationStorage = new StorageAccount(this, \"destination-storage\", {\n      name: destinationStorageName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      sku: { name: \"Standard_LRS\" },\n      tags: {\n        ...this.systemTags(),\n        role: \"destination\",\n      },\n    });\n\n    new Resource(this, \"destination-queue\", {\n      type: \"Microsoft.Storage/storageAccounts/queueServices/queues@2024-01-01\",\n      parentId: `${destinationStorage.id}/queueServices/default`,\n      name: \"events\",\n      body: {\n        properties: {},\n      },\n    });\n\n    const systemTopic = new EventGridSystemTopic(this, \"example-system-topic\", {\n      name: systemTopicName,\n      location: resourceGroup.props.location!,\n      resourceGroupId: resourceGroup.id,\n      source: sourceStorage.id,\n      topicType: \"Microsoft.Storage.StorageAccounts\",\n      tags: {\n        ...this.systemTags(),\n      },\n    });\n\n    new EventGridEventSubscription(this, \"example-event-subscription\", {\n      name: \"storage-events\",\n      scope: systemTopic.id,\n      destination: {\n        endpointType: \"StorageQueue\",\n        properties: {\n          resourceId: destinationStorage.id,\n          queueName: \"events\",\n        },\n      },\n      filter: {\n        includedEventTypes: [\"Microsoft.Storage.BlobCreated\"],\n      },\n      labels: [\"integration\"],\n    });\n  }\n}\n\ndescribe(\"Event Grid Event Subscription Integration Test\", () => {\n  it(\"should deploy, validate idempotency, and cleanup event grid event subscription resources\", () => {\n    const app = Testing.app();\n    const stack = new EventGridEventSubscriptionExampleStack(\n      app,\n      \"test-event-grid-event-subscription\",\n    );\n    const synthesized = Testing.fullSynth(stack);\n\n    TerraformApplyCheckAndDestroy(synthesized, { verifyCleanup: true });\n  }, 600000);\n});\n"]}

package/lib/azure-eventgrideventsubscription/test/event-grid-event-subscription.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/azure-eventgrideventsubscription/test/event-grid-event-subscription.spec.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const cdktn_1 = require("cdktn");
+const cdktn = require("cdktn");
+const api_version_manager_1 = require("../../core-azure/lib/version-manager/api-version-manager");
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const event_grid_event_subscription_1 = require("../lib/event-grid-event-subscription");
+const event_grid_event_subscription_schemas_1 = require("../lib/event-grid-event-subscription-schemas");
+describe("EventGridEventSubscription - Implementation", () => {
+    let app;
+    let stack;
+    let manager;
+    const scope = "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.EventGrid/systemTopics/test-topic";
+    const destination = {
+        endpointType: "WebHook",
+        properties: {
+            endpointUrl: "https://example.com/webhook",
+        },
+    };
+    beforeEach(() => {
+        app = cdktn_1.Testing.app();
+        stack = new cdktn.TerraformStack(app, "TestStack");
+        manager = api_version_manager_1.ApiVersionManager.instance();
+        try {
+            manager.registerResourceType(event_grid_event_subscription_schemas_1.EVENT_SUBSCRIPTION_TYPE, event_grid_event_subscription_schemas_1.ALL_EVENT_SUBSCRIPTION_VERSIONS);
+        }
+        catch (error) {
+            // Ignore if already registered
+        }
+    });
+    describe("Constructor and Basic Properties", () => {
+        it("should create event subscription with automatic latest version resolution", () => {
+            const props = {
+                name: "test-event-subscription",
+                scope,
+                destination,
+            };
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "TestEventSubscription", props);
+            expect(eventSubscription).toBeInstanceOf(event_grid_event_subscription_1.EventGridEventSubscription);
+            expect(eventSubscription.resolvedApiVersion).toBe("2025-02-15");
+            expect(eventSubscription.props).toBe(props);
+            expect(eventSubscription.name).toBe("test-event-subscription");
+        });
+        it("should create event subscription with explicit version pinning", () => {
+            const props = {
+                name: "test-event-subscription-pinned",
+                scope,
+                destination,
+                apiVersion: "2025-02-15",
+            };
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "PinnedEventSubscription", props);
+            expect(eventSubscription.resolvedApiVersion).toBe("2025-02-15");
+        });
+        it("should create event subscription with optional filter and delivery properties", () => {
+            const props = {
+                name: "test-event-subscription-full",
+                scope,
+                destination,
+                filter: {
+                    subjectBeginsWith: "/blobServices/default/containers/images/",
+                    subjectEndsWith: ".jpg",
+                    includedEventTypes: ["Microsoft.Storage.BlobCreated"],
+                    isSubjectCaseSensitive: false,
+                    advancedFilters: [
+                        {
+                            operatorType: "NumberGreaterThan",
+                            key: "data.contentLength",
+                            value: 0,
+                        },
+                    ],
+                },
+                retryPolicy: {
+                    maxDeliveryAttempts: 10,
+                    eventTimeToLiveInMinutes: 1440,
+                },
+                deadLetterDestination: {
+                    endpointType: "StorageBlob",
+                    properties: {
+                        resourceId: "/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Storage/storageAccounts/testdeadletter",
+                        blobContainerName: "deadletters",
+                    },
+                },
+                labels: ["production", "images"],
+                expirationTimeUtc: "2026-01-01T00:00:00Z",
+            };
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "FullEventSubscription", props);
+            expect(eventSubscription.props.filter).toEqual(props.filter);
+            expect(eventSubscription.props.retryPolicy).toEqual(props.retryPolicy);
+            expect(eventSubscription.props.deadLetterDestination).toEqual(props.deadLetterDestination);
+            expect(eventSubscription.props.labels).toEqual(props.labels);
+            expect(eventSubscription.props.expirationTimeUtc).toBe(props.expirationTimeUtc);
+        });
+    });
+    describe("Framework Integration", () => {
+        it("should resolve latest API version automatically", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "TestEventSubscription", {
+                name: "test-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.resolvedApiVersion).toBe("2025-02-15");
+            expect(eventSubscription.latestVersion()).toBe("2025-02-15");
+        });
+        it("should provide supported versions", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "TestEventSubscription", {
+                name: "test-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.supportedVersions()).toEqual(["2025-02-15"]);
+        });
+        it("should validate version support", () => {
+            expect(() => {
+                new event_grid_event_subscription_1.EventGridEventSubscription(stack, "ValidVersion", {
+                    name: "test-event-subscription",
+                    scope,
+                    destination,
+                    apiVersion: "2025-02-15",
+                });
+            }).not.toThrow();
+            expect(() => {
+                new event_grid_event_subscription_1.EventGridEventSubscription(stack, "InvalidVersion", {
+                    name: "test-event-subscription",
+                    scope,
+                    destination,
+                    apiVersion: "2026-01-01",
+                });
+            }).toThrow("Unsupported API version '2026-01-01'");
+        });
+        it("should load correct schema for resolved version", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "TestEventSubscription", {
+                name: "test-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.schema).toBeDefined();
+            expect(eventSubscription.schema.resourceType).toBe(event_grid_event_subscription_schemas_1.EVENT_SUBSCRIPTION_TYPE);
+            expect(eventSubscription.schema.version).toBe("2025-02-15");
+            expect(eventSubscription.schema.properties).toBeDefined();
+        });
+        it("should load version configuration correctly", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "TestEventSubscription", {
+                name: "test-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.versionConfig).toBeDefined();
+            expect(eventSubscription.versionConfig.version).toBe("2025-02-15");
+            expect(eventSubscription.versionConfig.supportLevel).toBe(version_interfaces_1.VersionSupportLevel.ACTIVE);
+        });
+    });
+    describe("Property Validation", () => {
+        it("should validate properties when validation is enabled", () => {
+            expect(() => {
+                new event_grid_event_subscription_1.EventGridEventSubscription(stack, "ValidatedEventSubscription", {
+                    name: "validated-event-subscription",
+                    scope,
+                    destination,
+                    enableValidation: true,
+                });
+            }).not.toThrow();
+        });
+        it("should have validation results for valid properties", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "ValidatedEventSubscription", {
+                name: "validated-event-subscription",
+                scope,
+                destination,
+                enableValidation: true,
+            });
+            expect(eventSubscription.validationResult).toBeDefined();
+            expect(eventSubscription.validationResult.valid).toBe(true);
+            expect(eventSubscription.validationResult.errors).toHaveLength(0);
+        });
+        it("should create Terraform outputs", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "OutputsEventSubscription", {
+                name: "outputs-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.idOutput).toBeInstanceOf(cdktn.TerraformOutput);
+            expect(eventSubscription.nameOutput).toBeInstanceOf(cdktn.TerraformOutput);
+        });
+    });
+    describe("Parent-Child Resource Relationship", () => {
+        it("should use scope as parent ID", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "ParentEventSubscription", {
+                name: "parent-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.props.scope).toBe(scope);
+        });
+        it("should synthesize as a child resource without location", () => {
+            new event_grid_event_subscription_1.EventGridEventSubscription(stack, "SynthEventSubscription", {
+                name: "synth-event-subscription",
+                scope,
+                destination,
+            });
+            const synthesized = cdktn_1.Testing.synth(stack);
+            expect(synthesized).toContain("eventSubscriptions");
+            expect(synthesized).toContain(scope);
+        });
+    });
+    describe("Version Compatibility", () => {
+        it("should work with all supported API versions", () => {
+            const versions = ["2025-02-15"];
+            versions.forEach((version) => {
+                const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, `EventSubscription-${version.replace(/-/g, "")}`, {
+                    name: `test-event-subscription-${version}`,
+                    scope,
+                    destination,
+                    apiVersion: version,
+                });
+                expect(eventSubscription.resolvedApiVersion).toBe(version);
+                expect(eventSubscription.schema.version).toBe(version);
+            });
+        });
+        it("should expose expected schema properties", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "SchemaEventSubscription", {
+                name: "schema-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.schema.properties.name).toBeDefined();
+            expect(eventSubscription.schema.properties.destination).toBeDefined();
+            expect(eventSubscription.schema.properties.filter).toBeDefined();
+            expect(eventSubscription.schema.properties.retryPolicy).toBeDefined();
+            expect(eventSubscription.schema.properties.labels).toBeDefined();
+        });
+    });
+    describe("Public Methods and Properties", () => {
+        it("should have resourceId property matching id", () => {
+            const eventSubscription = new event_grid_event_subscription_1.EventGridEventSubscription(stack, "ResourceIdEventSubscription", {
+                name: "resource-id-event-subscription",
+                scope,
+                destination,
+            });
+            expect(eventSubscription.resourceId).toBe(eventSubscription.id);
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-grid-event-subscription.spec.js","sourceRoot":"","sources":["../../../src/azure-eventgrideventsubscription/test/event-grid-event-subscription.spec.ts"],"names":[],"mappings":"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","sourcesContent":["import { Testing } from \"cdktn\";\nimport * as cdktn from \"cdktn\";\nimport { ApiVersionManager } from \"../../core-azure/lib/version-manager/api-version-manager\";\nimport { VersionSupportLevel } from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\nimport {\n  EventGridEventSubscription,\n  EventGridEventSubscriptionProps,\n} from \"../lib/event-grid-event-subscription\";\nimport {\n  ALL_EVENT_SUBSCRIPTION_VERSIONS,\n  EVENT_SUBSCRIPTION_TYPE,\n} from \"../lib/event-grid-event-subscription-schemas\";\n\ndescribe(\"EventGridEventSubscription - Implementation\", () => {\n  let app: cdktn.App;\n  let stack: cdktn.TerraformStack;\n  let manager: ApiVersionManager;\n\n  const scope =\n    \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.EventGrid/systemTopics/test-topic\";\n  const destination = {\n    endpointType: \"WebHook\",\n    properties: {\n      endpointUrl: \"https://example.com/webhook\",\n    },\n  };\n\n  beforeEach(() => {\n    app = Testing.app();\n    stack = new cdktn.TerraformStack(app, \"TestStack\");\n    manager = ApiVersionManager.instance();\n\n    try {\n      manager.registerResourceType(\n        EVENT_SUBSCRIPTION_TYPE,\n        ALL_EVENT_SUBSCRIPTION_VERSIONS,\n      );\n    } catch (error) {\n      // Ignore if already registered\n    }\n  });\n\n  describe(\"Constructor and Basic Properties\", () => {\n    it(\"should create event subscription with automatic latest version resolution\", () => {\n      const props: EventGridEventSubscriptionProps = {\n        name: \"test-event-subscription\",\n        scope,\n        destination,\n      };\n\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"TestEventSubscription\",\n        props,\n      );\n\n      expect(eventSubscription).toBeInstanceOf(EventGridEventSubscription);\n      expect(eventSubscription.resolvedApiVersion).toBe(\"2025-02-15\");\n      expect(eventSubscription.props).toBe(props);\n      expect(eventSubscription.name).toBe(\"test-event-subscription\");\n    });\n\n    it(\"should create event subscription with explicit version pinning\", () => {\n      const props: EventGridEventSubscriptionProps = {\n        name: \"test-event-subscription-pinned\",\n        scope,\n        destination,\n        apiVersion: \"2025-02-15\",\n      };\n\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"PinnedEventSubscription\",\n        props,\n      );\n\n      expect(eventSubscription.resolvedApiVersion).toBe(\"2025-02-15\");\n    });\n\n    it(\"should create event subscription with optional filter and delivery properties\", () => {\n      const props: EventGridEventSubscriptionProps = {\n        name: \"test-event-subscription-full\",\n        scope,\n        destination,\n        filter: {\n          subjectBeginsWith: \"/blobServices/default/containers/images/\",\n          subjectEndsWith: \".jpg\",\n          includedEventTypes: [\"Microsoft.Storage.BlobCreated\"],\n          isSubjectCaseSensitive: false,\n          advancedFilters: [\n            {\n              operatorType: \"NumberGreaterThan\",\n              key: \"data.contentLength\",\n              value: 0,\n            },\n          ],\n        },\n        retryPolicy: {\n          maxDeliveryAttempts: 10,\n          eventTimeToLiveInMinutes: 1440,\n        },\n        deadLetterDestination: {\n          endpointType: \"StorageBlob\",\n          properties: {\n            resourceId:\n              \"/subscriptions/test-sub/resourceGroups/test-rg/providers/Microsoft.Storage/storageAccounts/testdeadletter\",\n            blobContainerName: \"deadletters\",\n          },\n        },\n        labels: [\"production\", \"images\"],\n        expirationTimeUtc: \"2026-01-01T00:00:00Z\",\n      };\n\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"FullEventSubscription\",\n        props,\n      );\n\n      expect(eventSubscription.props.filter).toEqual(props.filter);\n      expect(eventSubscription.props.retryPolicy).toEqual(props.retryPolicy);\n      expect(eventSubscription.props.deadLetterDestination).toEqual(\n        props.deadLetterDestination,\n      );\n      expect(eventSubscription.props.labels).toEqual(props.labels);\n      expect(eventSubscription.props.expirationTimeUtc).toBe(\n        props.expirationTimeUtc,\n      );\n    });\n  });\n\n  describe(\"Framework Integration\", () => {\n    it(\"should resolve latest API version automatically\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"TestEventSubscription\",\n        {\n          name: \"test-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.resolvedApiVersion).toBe(\"2025-02-15\");\n      expect(eventSubscription.latestVersion()).toBe(\"2025-02-15\");\n    });\n\n    it(\"should provide supported versions\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"TestEventSubscription\",\n        {\n          name: \"test-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.supportedVersions()).toEqual([\"2025-02-15\"]);\n    });\n\n    it(\"should validate version support\", () => {\n      expect(() => {\n        new EventGridEventSubscription(stack, \"ValidVersion\", {\n          name: \"test-event-subscription\",\n          scope,\n          destination,\n          apiVersion: \"2025-02-15\",\n        });\n      }).not.toThrow();\n\n      expect(() => {\n        new EventGridEventSubscription(stack, \"InvalidVersion\", {\n          name: \"test-event-subscription\",\n          scope,\n          destination,\n          apiVersion: \"2026-01-01\",\n        });\n      }).toThrow(\"Unsupported API version '2026-01-01'\");\n    });\n\n    it(\"should load correct schema for resolved version\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"TestEventSubscription\",\n        {\n          name: \"test-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.schema).toBeDefined();\n      expect(eventSubscription.schema.resourceType).toBe(\n        EVENT_SUBSCRIPTION_TYPE,\n      );\n      expect(eventSubscription.schema.version).toBe(\"2025-02-15\");\n      expect(eventSubscription.schema.properties).toBeDefined();\n    });\n\n    it(\"should load version configuration correctly\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"TestEventSubscription\",\n        {\n          name: \"test-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.versionConfig).toBeDefined();\n      expect(eventSubscription.versionConfig.version).toBe(\"2025-02-15\");\n      expect(eventSubscription.versionConfig.supportLevel).toBe(\n        VersionSupportLevel.ACTIVE,\n      );\n    });\n  });\n\n  describe(\"Property Validation\", () => {\n    it(\"should validate properties when validation is enabled\", () => {\n      expect(() => {\n        new EventGridEventSubscription(stack, \"ValidatedEventSubscription\", {\n          name: \"validated-event-subscription\",\n          scope,\n          destination,\n          enableValidation: true,\n        });\n      }).not.toThrow();\n    });\n\n    it(\"should have validation results for valid properties\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"ValidatedEventSubscription\",\n        {\n          name: \"validated-event-subscription\",\n          scope,\n          destination,\n          enableValidation: true,\n        },\n      );\n\n      expect(eventSubscription.validationResult).toBeDefined();\n      expect(eventSubscription.validationResult!.valid).toBe(true);\n      expect(eventSubscription.validationResult!.errors).toHaveLength(0);\n    });\n\n    it(\"should create Terraform outputs\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"OutputsEventSubscription\",\n        {\n          name: \"outputs-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.idOutput).toBeInstanceOf(cdktn.TerraformOutput);\n      expect(eventSubscription.nameOutput).toBeInstanceOf(\n        cdktn.TerraformOutput,\n      );\n    });\n  });\n\n  describe(\"Parent-Child Resource Relationship\", () => {\n    it(\"should use scope as parent ID\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"ParentEventSubscription\",\n        {\n          name: \"parent-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.props.scope).toBe(scope);\n    });\n\n    it(\"should synthesize as a child resource without location\", () => {\n      new EventGridEventSubscription(stack, \"SynthEventSubscription\", {\n        name: \"synth-event-subscription\",\n        scope,\n        destination,\n      });\n\n      const synthesized = Testing.synth(stack);\n      expect(synthesized).toContain(\"eventSubscriptions\");\n      expect(synthesized).toContain(scope);\n    });\n  });\n\n  describe(\"Version Compatibility\", () => {\n    it(\"should work with all supported API versions\", () => {\n      const versions = [\"2025-02-15\"];\n\n      versions.forEach((version) => {\n        const eventSubscription = new EventGridEventSubscription(\n          stack,\n          `EventSubscription-${version.replace(/-/g, \"\")}`,\n          {\n            name: `test-event-subscription-${version}`,\n            scope,\n            destination,\n            apiVersion: version,\n          },\n        );\n\n        expect(eventSubscription.resolvedApiVersion).toBe(version);\n        expect(eventSubscription.schema.version).toBe(version);\n      });\n    });\n\n    it(\"should expose expected schema properties\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"SchemaEventSubscription\",\n        {\n          name: \"schema-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.schema.properties.name).toBeDefined();\n      expect(eventSubscription.schema.properties.destination).toBeDefined();\n      expect(eventSubscription.schema.properties.filter).toBeDefined();\n      expect(eventSubscription.schema.properties.retryPolicy).toBeDefined();\n      expect(eventSubscription.schema.properties.labels).toBeDefined();\n    });\n  });\n\n  describe(\"Public Methods and Properties\", () => {\n    it(\"should have resourceId property matching id\", () => {\n      const eventSubscription = new EventGridEventSubscription(\n        stack,\n        \"ResourceIdEventSubscription\",\n        {\n          name: \"resource-id-event-subscription\",\n          scope,\n          destination,\n        },\n      );\n\n      expect(eventSubscription.resourceId).toBe(eventSubscription.id);\n    });\n  });\n});\n"]}

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

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

package/lib/azure-eventgridsystemtopic/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYXp1cmUtZXZlbnRncmlkc3lzdGVtdG9waWMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHdDQUFzQiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2xpYlwiO1xuIl19

package/lib/azure-eventgridsystemtopic/lib/event-grid-system-topic-schemas.d.ts

@@ -0,0 +1,5 @@
+import { ApiSchema, VersionConfig } from "../../core-azure/lib/version-manager/interfaces/version-interfaces";
+export declare const SYSTEM_TOPIC_SCHEMA_2025_02_15: ApiSchema;
+export declare const SYSTEM_TOPIC_VERSION_2025_02_15: VersionConfig;
+export declare const ALL_SYSTEM_TOPIC_VERSIONS: VersionConfig[];
+export declare const SYSTEM_TOPIC_TYPE = "Microsoft.EventGrid/systemTopics";