@microsoft/terraform-cdk-constructs 2.2.0 → 2.5.1

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";

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

@@ -0,0 +1,164 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYSTEM_TOPIC_TYPE = exports.ALL_SYSTEM_TOPIC_VERSIONS = exports.SYSTEM_TOPIC_VERSION_2025_02_15 = exports.SYSTEM_TOPIC_SCHEMA_2025_02_15 = void 0;
+const version_interfaces_1 = require("../../core-azure/lib/version-manager/interfaces/version-interfaces");
+const COMMON_PROPERTIES = {
+    location: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The Azure region where the Event Grid System Topic will be created",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Location is required for Event Grid System Topics",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.PATTERN_MATCH,
+                value: "^[a-z0-9]+$",
+                message: "Location must contain only lowercase letters and numbers",
+            },
+        ],
+    },
+    tags: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: false,
+        defaultValue: {},
+        description: "A dictionary of tags to apply to the Event Grid System Topic",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.OBJECT,
+                message: "Tags must be an object with string key-value pairs",
+            },
+        ],
+    },
+    name: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The name of the Event Grid System Topic",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Name is required for Event Grid System Topics",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.VALUE_RANGE,
+                value: { minLength: 1, maxLength: 64 },
+                message: "Name must be between 1 and 64 characters",
+            },
+        ],
+    },
+    source: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The source Azure resource ID for the system topic",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Source is required for Event Grid System Topics",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.STRING,
+                message: "Source must be a string containing a resource ID",
+            },
+        ],
+    },
+    topicType: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: true,
+        description: "The type of the source resource",
+        validation: [
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                message: "Topic type is required for Event Grid System Topics",
+            },
+            {
+                ruleType: version_interfaces_1.ValidationRuleType.TYPE_CHECK,
+                value: version_interfaces_1.PropertyType.STRING,
+                message: "Topic type must be a string",
+            },
+        ],
+    },
+    identity: {
+        dataType: version_interfaces_1.PropertyType.OBJECT,
+        required: false,
+        description: "Managed identity configuration for the Event Grid System Topic",
+    },
+    resourceGroupId: {
+        dataType: version_interfaces_1.PropertyType.STRING,
+        required: false,
+        description: "The resource group ID where the Event Grid System Topic is created",
+    },
+};
+exports.SYSTEM_TOPIC_SCHEMA_2025_02_15 = {
+    resourceType: "Microsoft.EventGrid/systemTopics",
+    version: "2025-02-15",
+    properties: {
+        ...COMMON_PROPERTIES,
+    },
+    required: ["location", "name", "source", "topicType"],
+    optional: ["tags", "identity", "resourceGroupId"],
+    deprecated: [],
+    transformationRules: {},
+    validationRules: [
+        {
+            property: "location",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Location is required for Event Grid System Topics",
+                },
+            ],
+        },
+        {
+            property: "name",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Name is required for Event Grid System Topics",
+                },
+            ],
+        },
+        {
+            property: "source",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Source is required for Event Grid System Topics",
+                },
+            ],
+        },
+        {
+            property: "topicType",
+            rules: [
+                {
+                    ruleType: version_interfaces_1.ValidationRuleType.REQUIRED,
+                    message: "Topic type is required for Event Grid System Topics",
+                },
+            ],
+        },
+    ],
+};
+exports.SYSTEM_TOPIC_VERSION_2025_02_15 = {
+    version: "2025-02-15",
+    schema: exports.SYSTEM_TOPIC_SCHEMA_2025_02_15,
+    supportLevel: version_interfaces_1.VersionSupportLevel.ACTIVE,
+    releaseDate: "2025-02-15",
+    deprecationDate: undefined,
+    sunsetDate: undefined,
+    breakingChanges: [],
+    migrationGuide: "/docs/event-grid-system-topic/migration-2025-02-15",
+    changeLog: [
+        {
+            changeType: "added",
+            description: "Initial stable release of Event Grid System Topic support",
+            breaking: false,
+        },
+    ],
+};
+exports.ALL_SYSTEM_TOPIC_VERSIONS = [
+    exports.SYSTEM_TOPIC_VERSION_2025_02_15,
+];
+exports.SYSTEM_TOPIC_TYPE = "Microsoft.EventGrid/systemTopics";
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"event-grid-system-topic-schemas.js","sourceRoot":"","sources":["../../../src/azure-eventgridsystemtopic/lib/event-grid-system-topic-schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ApiSchema,\n  PropertyDefinition,\n  PropertyType,\n  ValidationRuleType,\n  VersionConfig,\n  VersionSupportLevel,\n} from \"../../core-azure/lib/version-manager/interfaces/version-interfaces\";\n\nconst COMMON_PROPERTIES: { [key: string]: PropertyDefinition } = {\n  location: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description:\n      \"The Azure region where the Event Grid System Topic will be created\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Location is required for Event Grid System Topics\",\n      },\n      {\n        ruleType: ValidationRuleType.PATTERN_MATCH,\n        value: \"^[a-z0-9]+$\",\n        message: \"Location must contain only lowercase letters and numbers\",\n      },\n    ],\n  },\n  tags: {\n    dataType: PropertyType.OBJECT,\n    required: false,\n    defaultValue: {},\n    description: \"A dictionary of tags to apply to the Event Grid System Topic\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.OBJECT,\n        message: \"Tags must be an object with string key-value pairs\",\n      },\n    ],\n  },\n  name: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"The name of the Event Grid System Topic\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Name is required for Event Grid System Topics\",\n      },\n      {\n        ruleType: ValidationRuleType.VALUE_RANGE,\n        value: { minLength: 1, maxLength: 64 },\n        message: \"Name must be between 1 and 64 characters\",\n      },\n    ],\n  },\n  source: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"The source Azure resource ID for the system topic\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Source is required for Event Grid System Topics\",\n      },\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.STRING,\n        message: \"Source must be a string containing a resource ID\",\n      },\n    ],\n  },\n  topicType: {\n    dataType: PropertyType.STRING,\n    required: true,\n    description: \"The type of the source resource\",\n    validation: [\n      {\n        ruleType: ValidationRuleType.REQUIRED,\n        message: \"Topic type is required for Event Grid System Topics\",\n      },\n      {\n        ruleType: ValidationRuleType.TYPE_CHECK,\n        value: PropertyType.STRING,\n        message: \"Topic type must be a string\",\n      },\n    ],\n  },\n  identity: {\n    dataType: PropertyType.OBJECT,\n    required: false,\n    description:\n      \"Managed identity configuration for the Event Grid System Topic\",\n  },\n  resourceGroupId: {\n    dataType: PropertyType.STRING,\n    required: false,\n    description:\n      \"The resource group ID where the Event Grid System Topic is created\",\n  },\n};\n\nexport const SYSTEM_TOPIC_SCHEMA_2025_02_15: ApiSchema = {\n  resourceType: \"Microsoft.EventGrid/systemTopics\",\n  version: \"2025-02-15\",\n  properties: {\n    ...COMMON_PROPERTIES,\n  },\n  required: [\"location\", \"name\", \"source\", \"topicType\"],\n  optional: [\"tags\", \"identity\", \"resourceGroupId\"],\n  deprecated: [],\n  transformationRules: {},\n  validationRules: [\n    {\n      property: \"location\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Location is required for Event Grid System Topics\",\n        },\n      ],\n    },\n    {\n      property: \"name\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Name is required for Event Grid System Topics\",\n        },\n      ],\n    },\n    {\n      property: \"source\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Source is required for Event Grid System Topics\",\n        },\n      ],\n    },\n    {\n      property: \"topicType\",\n      rules: [\n        {\n          ruleType: ValidationRuleType.REQUIRED,\n          message: \"Topic type is required for Event Grid System Topics\",\n        },\n      ],\n    },\n  ],\n};\n\nexport const SYSTEM_TOPIC_VERSION_2025_02_15: VersionConfig = {\n  version: \"2025-02-15\",\n  schema: SYSTEM_TOPIC_SCHEMA_2025_02_15,\n  supportLevel: VersionSupportLevel.ACTIVE,\n  releaseDate: \"2025-02-15\",\n  deprecationDate: undefined,\n  sunsetDate: undefined,\n  breakingChanges: [],\n  migrationGuide: \"/docs/event-grid-system-topic/migration-2025-02-15\",\n  changeLog: [\n    {\n      changeType: \"added\",\n      description: \"Initial stable release of Event Grid System Topic support\",\n      breaking: false,\n    },\n  ],\n};\n\nexport const ALL_SYSTEM_TOPIC_VERSIONS: VersionConfig[] = [\n  SYSTEM_TOPIC_VERSION_2025_02_15,\n];\n\nexport const SYSTEM_TOPIC_TYPE = \"Microsoft.EventGrid/systemTopics\";\n"]}

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

@@ -0,0 +1,46 @@
+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 EventGridSystemTopicIdentity {
+    readonly type: string;
+    readonly userAssignedIdentities?: {
+        [key: string]: any;
+    };
+}
+export interface EventGridSystemTopicProps extends AzapiResourceProps {
+    /** Source Azure resource ID for the system topic */
+    readonly source: string;
+    /** Topic type (e.g., "Microsoft.Storage.StorageAccounts") */
+    readonly topicType: string;
+    /** Managed identity configuration */
+    readonly identity?: EventGridSystemTopicIdentity;
+    /** Resource group ID */
+    readonly resourceGroupId?: string;
+}
+export interface EventGridSystemTopicBodyProperties {
+    readonly source: string;
+    readonly topicType: string;
+}
+export interface EventGridSystemTopicBody {
+    readonly location: string;
+    readonly tags?: {
+        [key: string]: string;
+    };
+    readonly properties: EventGridSystemTopicBodyProperties;
+    readonly identity?: EventGridSystemTopicIdentity;
+}
+export declare class EventGridSystemTopic extends AzapiResource {
+    readonly props: EventGridSystemTopicProps;
+    readonly idOutput: cdktn.TerraformOutput;
+    readonly locationOutput: cdktn.TerraformOutput;
+    readonly nameOutput: cdktn.TerraformOutput;
+    readonly tagsOutput: cdktn.TerraformOutput;
+    constructor(scope: Construct, id: string, props: EventGridSystemTopicProps);
+    protected defaultVersion(): string;
+    protected resourceType(): string;
+    protected apiSchema(): ApiSchema;
+    protected requiresLocation(): boolean;
+    protected createResourceBody(props: any): any;
+    get resourceId(): string;
+}

package/lib/azure-eventgridsystemtopic/lib/event-grid-system-topic.js

@@ -0,0 +1,68 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventGridSystemTopic = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const cdktn = require("cdktn");
+const event_grid_system_topic_schemas_1 = require("./event-grid-system-topic-schemas");
+const azapi_resource_1 = require("../../core-azure/lib/azapi/azapi-resource");
+class EventGridSystemTopic 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 Event Grid System Topic",
+        });
+        this.locationOutput = new cdktn.TerraformOutput(this, "location", {
+            value: `\${${this.terraformResource.fqn}.location}`,
+            description: "The location of the Event Grid System Topic",
+        });
+        this.nameOutput = new cdktn.TerraformOutput(this, "name", {
+            value: `\${${this.terraformResource.fqn}.name}`,
+            description: "The name of the Event Grid System Topic",
+        });
+        this.tagsOutput = new cdktn.TerraformOutput(this, "tags", {
+            value: `\${${this.terraformResource.fqn}.tags}`,
+            description: "The tags assigned to the Event Grid System Topic",
+        });
+        this.idOutput.overrideLogicalId("id");
+        this.locationOutput.overrideLogicalId("location");
+        this.nameOutput.overrideLogicalId("name");
+        this.tagsOutput.overrideLogicalId("tags");
+    }
+    defaultVersion() {
+        return "2025-02-15";
+    }
+    resourceType() {
+        return event_grid_system_topic_schemas_1.SYSTEM_TOPIC_TYPE;
+    }
+    apiSchema() {
+        return this.resolveSchema();
+    }
+    requiresLocation() {
+        return true;
+    }
+    createResourceBody(props) {
+        const typedProps = props;
+        return {
+            location: this.location,
+            tags: this.allTags(),
+            properties: {
+                source: typedProps.source,
+                topicType: typedProps.topicType,
+            },
+            identity: typedProps.identity,
+        };
+    }
+    get resourceId() {
+        return this.id;
+    }
+}
+exports.EventGridSystemTopic = EventGridSystemTopic;
+_a = JSII_RTTI_SYMBOL_1;
+EventGridSystemTopic[_a] = { fqn: "@microsoft/terraform-cdk-constructs.EventGridSystemTopic", version: "2.5.1" };
+(() => {
+    azapi_resource_1.AzapiResource.registerSchemas(event_grid_system_topic_schemas_1.SYSTEM_TOPIC_TYPE, event_grid_system_topic_schemas_1.ALL_SYSTEM_TOPIC_VERSIONS);
+})();
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,2 @@
+export * from "./event-grid-system-topic-schemas";
+export * from "./event-grid-system-topic";