@dga-itc/aws-cdk-constructs 1.0.0

package/dist/terraform-cdk/interfaces/ecs-service-config.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * ECS Service Configuration Interface
+ *
+ * Defines the configuration structure for creating ECS services with ALB integration.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ECS_SERVICE_DEFAULTS = void 0;
+/**
+ * Default values for optional ECS service configuration
+ */
+exports.ECS_SERVICE_DEFAULTS = {
+    healthCheckInterval: 30,
+    healthCheckTimeout: 5,
+    healthCheckHealthyThreshold: 2,
+    healthCheckUnhealthyThreshold: 3,
+    deregistrationDelay: 30,
+    targetGroupProtocol: 'HTTP',
+    logRetentionDays: 7,
+    enableAutoScaling: false,
+    minCapacity: 1,
+    maxCapacity: 10,
+    targetCpuUtilization: 70,
+    targetMemoryUtilization: 80,
+};

package/dist/terraform-cdk/interfaces/infrastructure-refs.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Infrastructure References Interface
+ *
+ * Defines the structure for referencing existing infrastructure resources
+ * from AWS CDK (unicorn-rx-0) to be used in Terraform CDK (banshee-rx-0)
+ */
+export interface InfrastructureRefs {
+    vpcId: string;
+    privateSubnetIds: string[];
+    albListenerArn: string;
+    albSecurityGroupId: string;
+    ecsClusterName: string;
+    ecsClusterArn: string;
+    region: string;
+    accountId: string;
+}

package/dist/terraform-cdk/interfaces/infrastructure-refs.js

@@ -0,0 +1,8 @@
+"use strict";
+/**
+ * Infrastructure References Interface
+ *
+ * Defines the structure for referencing existing infrastructure resources
+ * from AWS CDK (unicorn-rx-0) to be used in Terraform CDK (banshee-rx-0)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/terraform-cdk/utils/priority-tracker.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Priority Tracker for ALB Listener Rules
+ *
+ * Manages priority assignments for ALB Listener Rules to prevent conflicts.
+ * Priorities must be unique within a listener (range: 1-50000).
+ */
+export interface PriorityAssignment {
+    serviceName: string;
+    priority: number;
+    path?: string;
+    host?: string;
+}
+export declare class PriorityTracker {
+    private assignments;
+    private serviceNames;
+    /**
+     * Register a priority assignment
+     * @param serviceName Name of the ECS service
+     * @param priority Priority value (1-50000)
+     * @param path Optional path pattern
+     * @param host Optional host header
+     * @throws Error if priority is already assigned or out of range
+     */
+    registerPriority(serviceName: string, priority: number, path?: string, host?: string): void;
+    /**
+     * Get all priority assignments sorted by priority
+     * @returns Array of priority assignments
+     */
+    getAssignments(): PriorityAssignment[];
+    /**
+     * Check if a priority is available
+     * @param priority Priority value to check
+     * @returns True if priority is available
+     */
+    isPriorityAvailable(priority: number): boolean;
+    /**
+     * Get the next available priority
+     * @param startFrom Starting priority (default: 1)
+     * @returns Next available priority
+     */
+    getNextAvailablePriority(startFrom?: number): number;
+    /**
+     * Print a summary of all priority assignments
+     */
+    printSummary(): void;
+    /**
+     * Validate all assignments for conflicts
+     * @throws Error if conflicts are detected
+     */
+    validate(): void;
+    /**
+     * Clear all assignments
+     */
+    clear(): void;
+    /**
+     * Get total number of assignments
+     * @returns Number of registered assignments
+     */
+    get count(): number;
+}

package/dist/terraform-cdk/utils/priority-tracker.js

@@ -0,0 +1,131 @@
+"use strict";
+/**
+ * Priority Tracker for ALB Listener Rules
+ *
+ * Manages priority assignments for ALB Listener Rules to prevent conflicts.
+ * Priorities must be unique within a listener (range: 1-50000).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityTracker = void 0;
+class PriorityTracker {
+    constructor() {
+        this.assignments = new Map();
+        this.serviceNames = new Set();
+    }
+    /**
+     * Register a priority assignment
+     * @param serviceName Name of the ECS service
+     * @param priority Priority value (1-50000)
+     * @param path Optional path pattern
+     * @param host Optional host header
+     * @throws Error if priority is already assigned or out of range
+     */
+    registerPriority(serviceName, priority, path, host) {
+        // Validate priority range
+        if (priority < 1 || priority > 50000) {
+            throw new Error(`Invalid priority ${priority} for service ${serviceName}. Priority must be between 1 and 50000.`);
+        }
+        // Check for duplicate priority
+        if (this.assignments.has(priority)) {
+            const existing = this.assignments.get(priority);
+            throw new Error(`Priority conflict: Priority ${priority} is already assigned to service "${existing.serviceName}". ` +
+                `Cannot assign to service "${serviceName}".`);
+        }
+        // Check for duplicate service name
+        if (this.serviceNames.has(serviceName)) {
+            throw new Error(`Service name conflict: Service "${serviceName}" is already registered.`);
+        }
+        // Register the assignment
+        this.assignments.set(priority, {
+            serviceName,
+            priority,
+            path,
+            host,
+        });
+        this.serviceNames.add(serviceName);
+    }
+    /**
+     * Get all priority assignments sorted by priority
+     * @returns Array of priority assignments
+     */
+    getAssignments() {
+        return Array.from(this.assignments.values()).sort((a, b) => a.priority - b.priority);
+    }
+    /**
+     * Check if a priority is available
+     * @param priority Priority value to check
+     * @returns True if priority is available
+     */
+    isPriorityAvailable(priority) {
+        return !this.assignments.has(priority);
+    }
+    /**
+     * Get the next available priority
+     * @param startFrom Starting priority (default: 1)
+     * @returns Next available priority
+     */
+    getNextAvailablePriority(startFrom = 1) {
+        let priority = startFrom;
+        while (this.assignments.has(priority) && priority <= 50000) {
+            priority++;
+        }
+        if (priority > 50000) {
+            throw new Error('No available priorities. Maximum priority limit (50000) reached.');
+        }
+        return priority;
+    }
+    /**
+     * Print a summary of all priority assignments
+     */
+    printSummary() {
+        const assignments = this.getAssignments();
+        if (assignments.length === 0) {
+            console.log('\n📋 Priority Tracker: No assignments registered\n');
+            return;
+        }
+        console.log('\n📋 Priority Tracker Summary');
+        console.log('═══════════════════════════════════════════════════════════════');
+        console.log(`Total Services: ${assignments.length}`);
+        console.log('───────────────────────────────────────────────────────────────');
+        assignments.forEach((assignment) => {
+            const conditions = [];
+            if (assignment.path)
+                conditions.push(`Path: ${assignment.path}`);
+            if (assignment.host)
+                conditions.push(`Host: ${assignment.host}`);
+            const conditionStr = conditions.length > 0 ? ` (${conditions.join(', ')})` : '';
+            console.log(`Priority ${assignment.priority.toString().padStart(5)}: ${assignment.serviceName}${conditionStr}`);
+        });
+        console.log('═══════════════════════════════════════════════════════════════\n');
+    }
+    /**
+     * Validate all assignments for conflicts
+     * @throws Error if conflicts are detected
+     */
+    validate() {
+        const priorities = Array.from(this.assignments.keys());
+        const uniquePriorities = new Set(priorities);
+        if (priorities.length !== uniquePriorities.size) {
+            throw new Error('Priority conflict detected: Duplicate priorities found.');
+        }
+        const services = Array.from(this.serviceNames);
+        if (services.length !== this.assignments.size) {
+            throw new Error('Service name conflict detected: Duplicate service names found.');
+        }
+    }
+    /**
+     * Clear all assignments
+     */
+    clear() {
+        this.assignments.clear();
+        this.serviceNames.clear();
+    }
+    /**
+     * Get total number of assignments
+     * @returns Number of registered assignments
+     */
+    get count() {
+        return this.assignments.size;
+    }
+}
+exports.PriorityTracker = PriorityTracker;

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@dga-itc/aws-cdk-constructs",
+  "version": "1.0.0",
+  "description": "Reusable AWS infrastructure constructs for AWS CDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --passWithNoTests",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "aws",
+    "cdk",
+    "infrastructure",
+    "constructs",
+    "vpc",
+    "alb",
+    "nlb",
+    "ecs",
+    "rds",
+    "elasticache",
+    "efs",
+    "acm",
+    "cloudfront",
+    "sqs",
+    "waf"
+  ],
+  "author": "DGA-ITC",
+  "license": "MIT",
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.0.0",
+    "constructs": "^10.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "ts-jest": "^29.0.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}