truemark-cdk-lib 1.21.0 → 1.21.1-alpha.1768569999

package/aws-ecs/lib/index.d.ts

@@ -1,6 +1,7 @@
 export * from './ecs-service-update';
 export * from './log-configuration';
 export * from './otel-configuration';
+export * from './priority-allocator';
 export * from './standard-fargate-cluster';
 export * from './standard-fargate-service';
 export * from './standard-application-fargate-service';

package/aws-ecs/lib/index.js

@@ -17,8 +17,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./ecs-service-update"), exports);
 __exportStar(require("./log-configuration"), exports);
 __exportStar(require("./otel-configuration"), exports);
+__exportStar(require("./priority-allocator"), exports);
 __exportStar(require("./standard-fargate-cluster"), exports);
 __exportStar(require("./standard-fargate-service"), exports);
 __exportStar(require("./standard-application-fargate-service"), exports);
 __exportStar(require("./standard-network-fargate-service"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsdURBQXFDO0FBQ3JDLHNEQUFvQztBQUNwQyx1REFBcUM7QUFDckMsNkRBQTJDO0FBQzNDLDZEQUEyQztBQUMzQyx5RUFBdUQ7QUFDdkQscUVBQW1EIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lY3Mtc2VydmljZS11cGRhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9sb2ctY29uZmlndXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL290ZWwtY29uZmlndXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL3N0YW5kYXJkLWZhcmdhdGUtY2x1c3Rlcic7XG5leHBvcnQgKiBmcm9tICcuL3N0YW5kYXJkLWZhcmdhdGUtc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0YW5kYXJkLWFwcGxpY2F0aW9uLWZhcmdhdGUtc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL3N0YW5kYXJkLW5ldHdvcmstZmFyZ2F0ZS1zZXJ2aWNlJztcbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsdURBQXFDO0FBQ3JDLHNEQUFvQztBQUNwQyx1REFBcUM7QUFDckMsdURBQXFDO0FBQ3JDLDZEQUEyQztBQUMzQyw2REFBMkM7QUFDM0MseUVBQXVEO0FBQ3ZELHFFQUFtRCIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZWNzLXNlcnZpY2UtdXBkYXRlJztcbmV4cG9ydCAqIGZyb20gJy4vbG9nLWNvbmZpZ3VyYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9vdGVsLWNvbmZpZ3VyYXRpb24nO1xuZXhwb3J0ICogZnJvbSAnLi9wcmlvcml0eS1hbGxvY2F0b3InO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFuZGFyZC1mYXJnYXRlLWNsdXN0ZXInO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFuZGFyZC1mYXJnYXRlLXNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFuZGFyZC1hcHBsaWNhdGlvbi1mYXJnYXRlLXNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9zdGFuZGFyZC1uZXR3b3JrLWZhcmdhdGUtc2VydmljZSc7XG4iXX0=

package/aws-ecs/lib/priority-allocator-handler.d.ts

@@ -0,0 +1,38 @@
+interface CustomResourceEvent {
+    readonly RequestType: 'Create' | 'Update' | 'Delete';
+    readonly ResponseURL: string;
+    readonly StackId: string;
+    readonly RequestId: string;
+    readonly ResourceType: string;
+    readonly LogicalResourceId: string;
+    readonly PhysicalResourceId?: string;
+    readonly ResourceProperties: {
+        readonly ListenerArn: string;
+        readonly ServiceIdentifier: string;
+        readonly TableName: string;
+        readonly PreferredPriority?: string;
+    };
+    readonly OldResourceProperties?: {
+        readonly ListenerArn: string;
+        readonly ServiceIdentifier: string;
+        readonly TableName: string;
+        readonly PreferredPriority?: string;
+    };
+}
+interface CustomResourceResponse {
+    Status: 'SUCCESS' | 'FAILED';
+    Reason?: string;
+    PhysicalResourceId: string;
+    StackId: string;
+    RequestId: string;
+    LogicalResourceId: string;
+    NoEcho?: boolean;
+    Data?: {
+        Priority: string;
+    };
+}
+/**
+ * Main Lambda handler for the Custom Resource
+ */
+export declare function handler(event: CustomResourceEvent): Promise<CustomResourceResponse>;
+export {};

package/aws-ecs/lib/priority-allocator-handler.js

@@ -0,0 +1,347 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = handler;
+const client_elastic_load_balancing_v2_1 = require("@aws-sdk/client-elastic-load-balancing-v2");
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const crypto = require("node:crypto");
+const elbv2Client = new client_elastic_load_balancing_v2_1.ElasticLoadBalancingV2Client({});
+const dynamoClient = new client_dynamodb_1.DynamoDBClient({});
+const MAX_PRIORITY = 50000;
+const MAX_RETRIES = 10;
+/**
+ * Creates a deterministic hash of the service identifier
+ */
+function hashServiceIdentifier(serviceIdentifier) {
+    return crypto.createHash('sha256').update(serviceIdentifier).digest('hex');
+}
+/**
+ * Creates a success response
+ */
+function success(event, physicalResourceId, priority) {
+    return {
+        Status: 'SUCCESS',
+        PhysicalResourceId: physicalResourceId,
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId,
+        NoEcho: false,
+        Data: {
+            Priority: priority.toString(),
+        },
+    };
+}
+/**
+ * Creates a failure response
+ */
+function fail(event, physicalResourceId, reason) {
+    return {
+        Status: 'FAILED',
+        Reason: reason,
+        PhysicalResourceId: physicalResourceId,
+        StackId: event.StackId,
+        RequestId: event.RequestId,
+        LogicalResourceId: event.LogicalResourceId,
+        NoEcho: false,
+    };
+}
+/**
+ * Extracts valid priority from a rule
+ */
+function extractPriorityFromRule(rule) {
+    if (!rule.Priority || rule.Priority === 'default') {
+        return null;
+    }
+    const priority = Number.parseInt(rule.Priority, 10);
+    return Number.isNaN(priority) ? null : priority;
+}
+/**
+ * Formats priority list for logging
+ */
+function formatPrioritiesForLog(priorities) {
+    const sorted = Array.from(priorities).sort((a, b) => a - b);
+    const preview = sorted.slice(0, 10).join(', ');
+    return priorities.size > 10 ? `${preview}...` : preview;
+}
+/**
+ * Gets all priorities currently in use on the ALB listener
+ */
+async function getAlbListenerPriorities(listenerArn) {
+    const priorities = new Set();
+    try {
+        let nextMarker = undefined;
+        do {
+            const command = new client_elastic_load_balancing_v2_1.DescribeRulesCommand({
+                ListenerArn: listenerArn,
+                Marker: nextMarker,
+            });
+            const response = await elbv2Client.send(command);
+            if (response.Rules) {
+                for (const rule of response.Rules) {
+                    const priority = extractPriorityFromRule(rule);
+                    if (priority !== null) {
+                        priorities.add(priority);
+                    }
+                }
+            }
+            nextMarker = response.NextMarker;
+        } while (nextMarker);
+        const formatted = formatPrioritiesForLog(priorities);
+        console.log(`Found ${priorities.size} priorities in use on ALB listener: ${formatted}`);
+    }
+    catch (error) {
+        console.error('Error fetching ALB listener priorities:', error);
+        throw error;
+    }
+    return priorities;
+}
+/**
+ * Extracts valid priority from a DynamoDB item
+ */
+function extractPriorityFromDynamoItem(item) {
+    var _a;
+    if (!((_a = item.Priority) === null || _a === void 0 ? void 0 : _a.N)) {
+        return null;
+    }
+    const priority = Number.parseInt(item.Priority.N, 10);
+    return Number.isNaN(priority) ? null : priority;
+}
+/**
+ * Gets all priorities tracked in DynamoDB for this listener
+ */
+async function getDynamoDbPriorities(tableName, listenerArn) {
+    const priorities = new Set();
+    try {
+        let lastEvaluatedKey = undefined;
+        do {
+            const command = new client_dynamodb_1.QueryCommand({
+                TableName: tableName,
+                KeyConditionExpression: 'ListenerArn = :arn',
+                ExpressionAttributeValues: {
+                    ':arn': { S: listenerArn },
+                },
+                ExclusiveStartKey: lastEvaluatedKey,
+            });
+            const response = await dynamoClient.send(command);
+            if (response.Items) {
+                for (const item of response.Items) {
+                    const priority = extractPriorityFromDynamoItem(item);
+                    if (priority !== null) {
+                        priorities.add(priority);
+                    }
+                }
+            }
+            lastEvaluatedKey = response.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+        console.log(`Found ${priorities.size} priorities tracked in DynamoDB for listener`);
+    }
+    catch (error) {
+        console.error('Error fetching DynamoDB priorities:', error);
+        throw error;
+    }
+    return priorities;
+}
+/**
+ * Checks if the service already has an allocated priority (for idempotency)
+ */
+async function getExistingAllocation(tableName, listenerArn, serviceIdentifier) {
+    var _a, _b;
+    try {
+        const command = new client_dynamodb_1.QueryCommand({
+            TableName: tableName,
+            IndexName: 'ServiceIdentifierIndex',
+            KeyConditionExpression: 'ServiceIdentifier = :sid AND ListenerArn = :arn',
+            ExpressionAttributeValues: {
+                ':sid': { S: serviceIdentifier },
+                ':arn': { S: listenerArn },
+            },
+        });
+        const response = await dynamoClient.send(command);
+        if ((_a = response.Items) === null || _a === void 0 ? void 0 : _a[0]) {
+            const item = response.Items[0];
+            if ((_b = item.Priority) === null || _b === void 0 ? void 0 : _b.N) {
+                const priority = Number.parseInt(item.Priority.N, 10);
+                console.log(`Found existing allocation: priority ${priority} for service ${serviceIdentifier}`);
+                return priority;
+            }
+        }
+        return null;
+    }
+    catch (error) {
+        console.error('Error checking existing allocation:', error);
+        throw error;
+    }
+}
+/**
+ * Attempts to allocate a specific priority atomically
+ */
+async function tryAllocatePriority(tableName, listenerArn, serviceIdentifier, priority) {
+    try {
+        const now = new Date().toISOString();
+        const command = new client_dynamodb_1.PutItemCommand({
+            TableName: tableName,
+            Item: {
+                ListenerArn: { S: listenerArn },
+                Priority: { N: priority.toString() },
+                ServiceIdentifier: { S: serviceIdentifier },
+                AllocatedAt: { S: now },
+                Source: { S: 'CDK' },
+            },
+            ConditionExpression: 'attribute_not_exists(ListenerArn)',
+        });
+        await dynamoClient.send(command);
+        console.log(`Successfully allocated priority ${priority} for service ${serviceIdentifier}`);
+        return true;
+    }
+    catch (error) {
+        if (error instanceof client_dynamodb_1.ConditionalCheckFailedException) {
+            console.log(`Priority ${priority} already taken (race condition), will try next available`);
+            return false;
+        }
+        console.error('Error allocating priority:', error);
+        throw error;
+    }
+}
+/**
+ * Validates if a priority is within valid range
+ */
+function isValidPriorityRange(priority) {
+    return priority >= 1 && priority <= MAX_PRIORITY;
+}
+/**
+ * Attempts to allocate preferred priority if available
+ */
+async function tryPreferredPriority(tableName, listenerArn, serviceIdentifier, preferredPriority, usedPriorities) {
+    if (!isValidPriorityRange(preferredPriority)) {
+        return null;
+    }
+    if (usedPriorities.has(preferredPriority)) {
+        console.log(`Preferred priority ${preferredPriority} is already in use, finding next available`);
+        return null;
+    }
+    const allocated = await tryAllocatePriority(tableName, listenerArn, serviceIdentifier, preferredPriority);
+    return allocated ? preferredPriority : null;
+}
+/**
+ * Finds lowest available priority with gap filling
+ */
+async function findLowestAvailablePriority(tableName, listenerArn, serviceIdentifier, usedPriorities) {
+    let retries = 0;
+    for (let priority = 1; priority <= MAX_PRIORITY; priority++) {
+        if (usedPriorities.has(priority)) {
+            continue;
+        }
+        const allocated = await tryAllocatePriority(tableName, listenerArn, serviceIdentifier, priority);
+        if (allocated) {
+            return priority;
+        }
+        // Race condition: someone else took this priority, try next
+        retries++;
+        if (retries >= MAX_RETRIES) {
+            throw new Error(`Failed to allocate priority after ${MAX_RETRIES} retries due to race conditions`);
+        }
+    }
+    throw new Error(`No available priorities found (all ${MAX_PRIORITY} in use)`);
+}
+/**
+ * Finds the lowest available priority and allocates it
+ */
+async function allocatePriority(tableName, listenerArn, serviceIdentifier, preferredPriority) {
+    // Step 1: Check if service already has an allocation (idempotency)
+    const existingPriority = await getExistingAllocation(tableName, listenerArn, serviceIdentifier);
+    if (existingPriority !== null) {
+        return existingPriority;
+    }
+    // Step 2: Get all used priorities from ALB
+    const albPriorities = await getAlbListenerPriorities(listenerArn);
+    // Step 3: Get all tracked priorities from DynamoDB
+    const dynamoPriorities = await getDynamoDbPriorities(tableName, listenerArn);
+    // Step 4: Merge both sources to get complete picture
+    const allUsedPriorities = new Set([...albPriorities, ...dynamoPriorities]);
+    console.log(`Total priorities in use (ALB + DynamoDB): ${allUsedPriorities.size}`);
+    // Step 5: Try preferred priority first if provided
+    if (preferredPriority) {
+        const result = await tryPreferredPriority(tableName, listenerArn, serviceIdentifier, preferredPriority, allUsedPriorities);
+        if (result !== null) {
+            return result;
+        }
+    }
+    // Step 6: Find lowest available priority (gap filling)
+    return findLowestAvailablePriority(tableName, listenerArn, serviceIdentifier, allUsedPriorities);
+}
+/**
+ * Deletes a priority allocation from DynamoDB
+ */
+async function deletePriorityAllocation(tableName, listenerArn, serviceIdentifier) {
+    var _a;
+    try {
+        // Find the priority allocated to this service
+        const command = new client_dynamodb_1.QueryCommand({
+            TableName: tableName,
+            IndexName: 'ServiceIdentifierIndex',
+            KeyConditionExpression: 'ServiceIdentifier = :sid AND ListenerArn = :arn',
+            ExpressionAttributeValues: {
+                ':sid': { S: serviceIdentifier },
+                ':arn': { S: listenerArn },
+            },
+        });
+        const response = await dynamoClient.send(command);
+        if (!response.Items || response.Items.length === 0) {
+            console.log(`No priority found for service ${serviceIdentifier}, nothing to delete`);
+            return;
+        }
+        const item = response.Items[0];
+        const priorityValue = (_a = item.Priority) === null || _a === void 0 ? void 0 : _a.N;
+        if (!priorityValue) {
+            console.error('Priority not found in item:', item);
+            return;
+        }
+        const priority = Number.parseInt(priorityValue, 10);
+        // Delete the allocation
+        const deleteCommand = new client_dynamodb_1.DeleteItemCommand({
+            TableName: tableName,
+            Key: {
+                ListenerArn: { S: listenerArn },
+                Priority: { N: priority.toString() },
+            },
+        });
+        await dynamoClient.send(deleteCommand);
+        console.log(`Successfully deleted priority ${priority} for service ${serviceIdentifier}`);
+    }
+    catch (error) {
+        console.error('Error deleting priority allocation:', error);
+        throw error;
+    }
+}
+/**
+ * Main Lambda handler for the Custom Resource
+ */
+async function handler(event) {
+    console.log('Received event:', JSON.stringify(event, null, 2));
+    const listenerArn = event.ResourceProperties.ListenerArn;
+    const serviceIdentifier = event.ResourceProperties.ServiceIdentifier;
+    const tableName = event.ResourceProperties.TableName;
+    const preferredPriority = event.ResourceProperties.PreferredPriority
+        ? Number.parseInt(event.ResourceProperties.PreferredPriority, 10)
+        : undefined;
+    // Physical resource ID is based on listener ARN and service identifier
+    const physicalResourceId = hashServiceIdentifier(`${listenerArn}/${serviceIdentifier}`);
+    try {
+        // Handle Delete operation
+        if (event.RequestType === 'Delete') {
+            console.log('Handling DELETE request - removing priority allocation');
+            await deletePriorityAllocation(tableName, listenerArn, serviceIdentifier);
+            // Return success with priority 0 (doesn't matter for delete)
+            return success(event, physicalResourceId, 0);
+        }
+        // Handle Create and Update operations
+        console.log(`Handling ${event.RequestType} request - allocating priority`);
+        const priority = await allocatePriority(tableName, listenerArn, serviceIdentifier, preferredPriority);
+        return success(event, physicalResourceId, priority);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('Error in handler:', errorMessage);
+        return fail(event, physicalResourceId, errorMessage);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"priority-allocator-handler.js","sourceRoot":"","sources":["priority-allocator-handler.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ElasticLoadBalancingV2Client,\n  DescribeRulesCommand,\n  type DescribeRulesCommandOutput,\n} from '@aws-sdk/client-elastic-load-balancing-v2';\nimport {\n  DynamoDBClient,\n  PutItemCommand,\n  QueryCommand,\n  DeleteItemCommand,\n  ConditionalCheckFailedException,\n  type QueryCommandOutput,\n  type AttributeValue,\n} from '@aws-sdk/client-dynamodb';\nimport * as crypto from 'node:crypto';\n\n// CloudFormation Custom Resource event interface\ninterface CustomResourceEvent {\n  readonly RequestType: 'Create' | 'Update' | 'Delete';\n  readonly ResponseURL: string;\n  readonly StackId: string;\n  readonly RequestId: string;\n  readonly ResourceType: string;\n  readonly LogicalResourceId: string;\n  readonly PhysicalResourceId?: string;\n  readonly ResourceProperties: {\n    readonly ListenerArn: string;\n    readonly ServiceIdentifier: string;\n    readonly TableName: string;\n    readonly PreferredPriority?: string;\n  };\n  readonly OldResourceProperties?: {\n    readonly ListenerArn: string;\n    readonly ServiceIdentifier: string;\n    readonly TableName: string;\n    readonly PreferredPriority?: string;\n  };\n}\n\ninterface CustomResourceResponse {\n  Status: 'SUCCESS' | 'FAILED';\n  Reason?: string;\n  PhysicalResourceId: string;\n  StackId: string;\n  RequestId: string;\n  LogicalResourceId: string;\n  NoEcho?: boolean;\n  Data?: {\n    Priority: string;\n  };\n}\n\nconst elbv2Client = new ElasticLoadBalancingV2Client({});\nconst dynamoClient = new DynamoDBClient({});\n\nconst MAX_PRIORITY = 50000;\nconst MAX_RETRIES = 10;\n\n/**\n * Creates a deterministic hash of the service identifier\n */\nfunction hashServiceIdentifier(serviceIdentifier: string): string {\n  return crypto.createHash('sha256').update(serviceIdentifier).digest('hex');\n}\n\n/**\n * Creates a success response\n */\nfunction success(\n  event: CustomResourceEvent,\n  physicalResourceId: string,\n  priority: number,\n): CustomResourceResponse {\n  return {\n    Status: 'SUCCESS',\n    PhysicalResourceId: physicalResourceId,\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    NoEcho: false,\n    Data: {\n      Priority: priority.toString(),\n    },\n  };\n}\n\n/**\n * Creates a failure response\n */\nfunction fail(\n  event: CustomResourceEvent,\n  physicalResourceId: string,\n  reason: string,\n): CustomResourceResponse {\n  return {\n    Status: 'FAILED',\n    Reason: reason,\n    PhysicalResourceId: physicalResourceId,\n    StackId: event.StackId,\n    RequestId: event.RequestId,\n    LogicalResourceId: event.LogicalResourceId,\n    NoEcho: false,\n  };\n}\n\n/**\n * Extracts valid priority from a rule\n */\nfunction extractPriorityFromRule(rule: {Priority?: string}): number | null {\n  if (!rule.Priority || rule.Priority === 'default') {\n    return null;\n  }\n  const priority = Number.parseInt(rule.Priority, 10);\n  return Number.isNaN(priority) ? null : priority;\n}\n\n/**\n * Formats priority list for logging\n */\nfunction formatPrioritiesForLog(priorities: Set<number>): string {\n  const sorted = Array.from(priorities).sort((a, b) => a - b);\n  const preview = sorted.slice(0, 10).join(', ');\n  return priorities.size > 10 ? `${preview}...` : preview;\n}\n\n/**\n * Gets all priorities currently in use on the ALB listener\n */\nasync function getAlbListenerPriorities(\n  listenerArn: string,\n): Promise<Set<number>> {\n  const priorities = new Set<number>();\n\n  try {\n    let nextMarker: string | undefined = undefined;\n\n    do {\n      const command = new DescribeRulesCommand({\n        ListenerArn: listenerArn,\n        Marker: nextMarker,\n      });\n\n      const response: DescribeRulesCommandOutput =\n        await elbv2Client.send(command);\n\n      if (response.Rules) {\n        for (const rule of response.Rules) {\n          const priority = extractPriorityFromRule(rule);\n          if (priority !== null) {\n            priorities.add(priority);\n          }\n        }\n      }\n\n      nextMarker = response.NextMarker;\n    } while (nextMarker);\n\n    const formatted = formatPrioritiesForLog(priorities);\n    console.log(\n      `Found ${priorities.size} priorities in use on ALB listener: ${formatted}`,\n    );\n  } catch (error) {\n    console.error('Error fetching ALB listener priorities:', error);\n    throw error;\n  }\n\n  return priorities;\n}\n\n/**\n * Extracts valid priority from a DynamoDB item\n */\nfunction extractPriorityFromDynamoItem(\n  item: Record<string, AttributeValue>,\n): number | null {\n  if (!item.Priority?.N) {\n    return null;\n  }\n  const priority = Number.parseInt(item.Priority.N, 10);\n  return Number.isNaN(priority) ? null : priority;\n}\n\n/**\n * Gets all priorities tracked in DynamoDB for this listener\n */\nasync function getDynamoDbPriorities(\n  tableName: string,\n  listenerArn: string,\n): Promise<Set<number>> {\n  const priorities = new Set<number>();\n\n  try {\n    let lastEvaluatedKey: Record<string, AttributeValue> | undefined =\n      undefined;\n\n    do {\n      const command = new QueryCommand({\n        TableName: tableName,\n        KeyConditionExpression: 'ListenerArn = :arn',\n        ExpressionAttributeValues: {\n          ':arn': {S: listenerArn},\n        },\n        ExclusiveStartKey: lastEvaluatedKey,\n      });\n\n      const response: QueryCommandOutput = await dynamoClient.send(command);\n\n      if (response.Items) {\n        for (const item of response.Items) {\n          const priority = extractPriorityFromDynamoItem(item);\n          if (priority !== null) {\n            priorities.add(priority);\n          }\n        }\n      }\n\n      lastEvaluatedKey = response.LastEvaluatedKey;\n    } while (lastEvaluatedKey);\n\n    console.log(\n      `Found ${priorities.size} priorities tracked in DynamoDB for listener`,\n    );\n  } catch (error) {\n    console.error('Error fetching DynamoDB priorities:', error);\n    throw error;\n  }\n\n  return priorities;\n}\n\n/**\n * Checks if the service already has an allocated priority (for idempotency)\n */\nasync function getExistingAllocation(\n  tableName: string,\n  listenerArn: string,\n  serviceIdentifier: string,\n): Promise<number | null> {\n  try {\n    const command = new QueryCommand({\n      TableName: tableName,\n      IndexName: 'ServiceIdentifierIndex',\n      KeyConditionExpression: 'ServiceIdentifier = :sid AND ListenerArn = :arn',\n      ExpressionAttributeValues: {\n        ':sid': {S: serviceIdentifier},\n        ':arn': {S: listenerArn},\n      },\n    });\n\n    const response: QueryCommandOutput = await dynamoClient.send(command);\n\n    if (response.Items?.[0]) {\n      const item = response.Items[0];\n      if (item.Priority?.N) {\n        const priority = Number.parseInt(item.Priority.N, 10);\n        console.log(\n          `Found existing allocation: priority ${priority} for service ${serviceIdentifier}`,\n        );\n        return priority;\n      }\n    }\n\n    return null;\n  } catch (error) {\n    console.error('Error checking existing allocation:', error);\n    throw error;\n  }\n}\n\n/**\n * Attempts to allocate a specific priority atomically\n */\nasync function tryAllocatePriority(\n  tableName: string,\n  listenerArn: string,\n  serviceIdentifier: string,\n  priority: number,\n): Promise<boolean> {\n  try {\n    const now = new Date().toISOString();\n\n    const command = new PutItemCommand({\n      TableName: tableName,\n      Item: {\n        ListenerArn: {S: listenerArn},\n        Priority: {N: priority.toString()},\n        ServiceIdentifier: {S: serviceIdentifier},\n        AllocatedAt: {S: now},\n        Source: {S: 'CDK'},\n      },\n      ConditionExpression: 'attribute_not_exists(ListenerArn)',\n    });\n\n    await dynamoClient.send(command);\n    console.log(\n      `Successfully allocated priority ${priority} for service ${serviceIdentifier}`,\n    );\n    return true;\n  } catch (error) {\n    if (error instanceof ConditionalCheckFailedException) {\n      console.log(\n        `Priority ${priority} already taken (race condition), will try next available`,\n      );\n      return false;\n    }\n    console.error('Error allocating priority:', error);\n    throw error;\n  }\n}\n\n/**\n * Validates if a priority is within valid range\n */\nfunction isValidPriorityRange(priority: number): boolean {\n  return priority >= 1 && priority <= MAX_PRIORITY;\n}\n\n/**\n * Attempts to allocate preferred priority if available\n */\nasync function tryPreferredPriority(\n  tableName: string,\n  listenerArn: string,\n  serviceIdentifier: string,\n  preferredPriority: number,\n  usedPriorities: Set<number>,\n): Promise<number | null> {\n  if (!isValidPriorityRange(preferredPriority)) {\n    return null;\n  }\n\n  if (usedPriorities.has(preferredPriority)) {\n    console.log(\n      `Preferred priority ${preferredPriority} is already in use, finding next available`,\n    );\n    return null;\n  }\n\n  const allocated = await tryAllocatePriority(\n    tableName,\n    listenerArn,\n    serviceIdentifier,\n    preferredPriority,\n  );\n  return allocated ? preferredPriority : null;\n}\n\n/**\n * Finds lowest available priority with gap filling\n */\nasync function findLowestAvailablePriority(\n  tableName: string,\n  listenerArn: string,\n  serviceIdentifier: string,\n  usedPriorities: Set<number>,\n): Promise<number> {\n  let retries = 0;\n\n  for (let priority = 1; priority <= MAX_PRIORITY; priority++) {\n    if (usedPriorities.has(priority)) {\n      continue;\n    }\n\n    const allocated = await tryAllocatePriority(\n      tableName,\n      listenerArn,\n      serviceIdentifier,\n      priority,\n    );\n\n    if (allocated) {\n      return priority;\n    }\n\n    // Race condition: someone else took this priority, try next\n    retries++;\n    if (retries >= MAX_RETRIES) {\n      throw new Error(\n        `Failed to allocate priority after ${MAX_RETRIES} retries due to race conditions`,\n      );\n    }\n  }\n\n  throw new Error(`No available priorities found (all ${MAX_PRIORITY} in use)`);\n}\n\n/**\n * Finds the lowest available priority and allocates it\n */\nasync function allocatePriority(\n  tableName: string,\n  listenerArn: string,\n  serviceIdentifier: string,\n  preferredPriority?: number,\n): Promise<number> {\n  // Step 1: Check if service already has an allocation (idempotency)\n  const existingPriority = await getExistingAllocation(\n    tableName,\n    listenerArn,\n    serviceIdentifier,\n  );\n  if (existingPriority !== null) {\n    return existingPriority;\n  }\n\n  // Step 2: Get all used priorities from ALB\n  const albPriorities = await getAlbListenerPriorities(listenerArn);\n\n  // Step 3: Get all tracked priorities from DynamoDB\n  const dynamoPriorities = await getDynamoDbPriorities(tableName, listenerArn);\n\n  // Step 4: Merge both sources to get complete picture\n  const allUsedPriorities = new Set([...albPriorities, ...dynamoPriorities]);\n\n  console.log(\n    `Total priorities in use (ALB + DynamoDB): ${allUsedPriorities.size}`,\n  );\n\n  // Step 5: Try preferred priority first if provided\n  if (preferredPriority) {\n    const result = await tryPreferredPriority(\n      tableName,\n      listenerArn,\n      serviceIdentifier,\n      preferredPriority,\n      allUsedPriorities,\n    );\n    if (result !== null) {\n      return result;\n    }\n  }\n\n  // Step 6: Find lowest available priority (gap filling)\n  return findLowestAvailablePriority(\n    tableName,\n    listenerArn,\n    serviceIdentifier,\n    allUsedPriorities,\n  );\n}\n\n/**\n * Deletes a priority allocation from DynamoDB\n */\nasync function deletePriorityAllocation(\n  tableName: string,\n  listenerArn: string,\n  serviceIdentifier: string,\n): Promise<void> {\n  try {\n    // Find the priority allocated to this service\n    const command = new QueryCommand({\n      TableName: tableName,\n      IndexName: 'ServiceIdentifierIndex',\n      KeyConditionExpression: 'ServiceIdentifier = :sid AND ListenerArn = :arn',\n      ExpressionAttributeValues: {\n        ':sid': {S: serviceIdentifier},\n        ':arn': {S: listenerArn},\n      },\n    });\n\n    const response = await dynamoClient.send(command);\n\n    if (!response.Items || response.Items.length === 0) {\n      console.log(\n        `No priority found for service ${serviceIdentifier}, nothing to delete`,\n      );\n      return;\n    }\n\n    const item = response.Items[0];\n    const priorityValue = item.Priority?.N;\n    if (!priorityValue) {\n      console.error('Priority not found in item:', item);\n      return;\n    }\n\n    const priority = Number.parseInt(priorityValue, 10);\n\n    // Delete the allocation\n    const deleteCommand = new DeleteItemCommand({\n      TableName: tableName,\n      Key: {\n        ListenerArn: {S: listenerArn},\n        Priority: {N: priority.toString()},\n      },\n    });\n\n    await dynamoClient.send(deleteCommand);\n    console.log(\n      `Successfully deleted priority ${priority} for service ${serviceIdentifier}`,\n    );\n  } catch (error) {\n    console.error('Error deleting priority allocation:', error);\n    throw error;\n  }\n}\n\n/**\n * Main Lambda handler for the Custom Resource\n */\nexport async function handler(\n  event: CustomResourceEvent,\n): Promise<CustomResourceResponse> {\n  console.log('Received event:', JSON.stringify(event, null, 2));\n\n  const listenerArn = event.ResourceProperties.ListenerArn;\n  const serviceIdentifier = event.ResourceProperties.ServiceIdentifier;\n  const tableName = event.ResourceProperties.TableName;\n  const preferredPriority = event.ResourceProperties.PreferredPriority\n    ? Number.parseInt(event.ResourceProperties.PreferredPriority, 10)\n    : undefined;\n\n  // Physical resource ID is based on listener ARN and service identifier\n  const physicalResourceId = hashServiceIdentifier(\n    `${listenerArn}/${serviceIdentifier}`,\n  );\n\n  try {\n    // Handle Delete operation\n    if (event.RequestType === 'Delete') {\n      console.log('Handling DELETE request - removing priority allocation');\n      await deletePriorityAllocation(tableName, listenerArn, serviceIdentifier);\n      // Return success with priority 0 (doesn't matter for delete)\n      return success(event, physicalResourceId, 0);\n    }\n\n    // Handle Create and Update operations\n    console.log(`Handling ${event.RequestType} request - allocating priority`);\n    const priority = await allocatePriority(\n      tableName,\n      listenerArn,\n      serviceIdentifier,\n      preferredPriority,\n    );\n\n    return success(event, physicalResourceId, priority);\n  } catch (error) {\n    const errorMessage = error instanceof Error ? error.message : String(error);\n    console.error('Error in handler:', errorMessage);\n    return fail(event, physicalResourceId, errorMessage);\n  }\n}\n"]}

package/aws-ecs/lib/priority-allocator.d.ts

@@ -0,0 +1,84 @@
+import { Construct } from 'constructs';
+import { CustomResource } from 'aws-cdk-lib';
+export interface PriorityAllocatorProps {
+    /**
+     * The ARN of the ALB listener for which to allocate a priority.
+     */
+    readonly listenerArn: string;
+    /**
+     * Optional preferred priority. If available, this priority will be allocated.
+     * If not available, the next available priority will be allocated.
+     *
+     * @default - Next available priority is allocated
+     */
+    readonly preferredPriority?: number;
+}
+/**
+ * Allocates a unique priority for an ALB listener rule using a Lambda-backed Custom Resource.
+ *
+ * This construct implements a singleton pattern for the Lambda function and DynamoDB table,
+ * ensuring that only one instance of each exists per AWS account/region regardless of how
+ * many services use priority allocation.
+ *
+ * The allocation algorithm:
+ * 1. Checks if this service already has an allocated priority (idempotent)
+ * 2. Queries all priorities currently on the ALB listener (source of truth)
+ * 3. Queries priorities tracked in DynamoDB
+ * 4. Merges both sources to get complete picture
+ * 5. Finds lowest available priority (gap filling)
+ * 6. Allocates atomically with DynamoDB conditional write
+ * 7. Returns allocated priority to CloudFormation
+ *
+ * On stack deletion, the priority is released back to the pool for reuse.
+ *
+ * @example
+ * ```typescript
+ * const allocator = new PriorityAllocator(this, 'PriorityAllocator', {
+ *   listenerArn: listener.listenerArn,
+ * });
+ *
+ * // Use the allocated priority
+ * listener.addTargetGroups('TargetGroup', {
+ *   targetGroups: [targetGroup],
+ *   priority: allocator.priority,
+ * });
+ * ```
+ */
+export declare class PriorityAllocator extends Construct {
+    /**
+     * The allocated priority for the ALB listener rule.
+     */
+    readonly priority: number;
+    /**
+     * The service identifier used for tracking this allocation.
+     */
+    readonly serviceIdentifier: string;
+    /**
+     * The Custom Resource that manages the priority allocation.
+     */
+    readonly resource: CustomResource;
+    /**
+     * Singleton table name - shared across all priority allocators in the account/region.
+     */
+    private static readonly TABLE_NAME;
+    /**
+     * Gets or creates the singleton DynamoDB table for priority tracking.
+     * Only one table exists per AWS account/region.
+     */
+    private static getOrCreateTable;
+    /**
+     * Gets or creates the singleton Lambda function for priority allocation.
+     * Only one Lambda function exists per AWS account/region.
+     */
+    private static getOrCreateLambda;
+    /**
+     * Gets or creates the singleton Custom Resource Provider.
+     * Only one provider exists per AWS account/region.
+     */
+    private static getOrCreateProvider;
+    /**
+     * Generates a deterministic service identifier based on the construct path and listener ARN.
+     */
+    private generateServiceIdentifier;
+    constructor(scope: Construct, id: string, props: PriorityAllocatorProps);
+}

package/aws-ecs/lib/priority-allocator.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PriorityAllocator = void 0;
+const constructs_1 = require("constructs");
+const aws_lambda_nodejs_1 = require("aws-cdk-lib/aws-lambda-nodejs");
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+const custom_resources_1 = require("aws-cdk-lib/custom-resources");
+const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
+const path = require("node:path");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_dynamodb_1 = require("aws-cdk-lib/aws-dynamodb");
+const crypto = require("node:crypto");
+/**
+ * Allocates a unique priority for an ALB listener rule using a Lambda-backed Custom Resource.
+ *
+ * This construct implements a singleton pattern for the Lambda function and DynamoDB table,
+ * ensuring that only one instance of each exists per AWS account/region regardless of how
+ * many services use priority allocation.
+ *
+ * The allocation algorithm:
+ * 1. Checks if this service already has an allocated priority (idempotent)
+ * 2. Queries all priorities currently on the ALB listener (source of truth)
+ * 3. Queries priorities tracked in DynamoDB
+ * 4. Merges both sources to get complete picture
+ * 5. Finds lowest available priority (gap filling)
+ * 6. Allocates atomically with DynamoDB conditional write
+ * 7. Returns allocated priority to CloudFormation
+ *
+ * On stack deletion, the priority is released back to the pool for reuse.
+ *
+ * @example
+ * ```typescript
+ * const allocator = new PriorityAllocator(this, 'PriorityAllocator', {
+ *   listenerArn: listener.listenerArn,
+ * });
+ *
+ * // Use the allocated priority
+ * listener.addTargetGroups('TargetGroup', {
+ *   targetGroups: [targetGroup],
+ *   priority: allocator.priority,
+ * });
+ * ```
+ */
+class PriorityAllocator extends constructs_1.Construct {
+    /**
+     * Gets or creates the singleton DynamoDB table for priority tracking.
+     * Only one table exists per AWS account/region.
+     */
+    static getOrCreateTable(scope) {
+        const stack = aws_cdk_lib_1.Stack.of(scope);
+        const tableId = 'PriorityAllocatorTable';
+        // Try to find existing table in the stack
+        const existing = stack.node.tryFindChild(tableId);
+        if (existing) {
+            return existing;
+        }
+        // Create new table at stack level (singleton)
+        const table = new aws_dynamodb_1.Table(stack, tableId, {
+            tableName: PriorityAllocator.TABLE_NAME,
+            partitionKey: {
+                name: 'ListenerArn',
+                type: aws_dynamodb_1.AttributeType.STRING,
+            },
+            sortKey: {
+                name: 'Priority',
+                type: aws_dynamodb_1.AttributeType.NUMBER,
+            },
+            billingMode: aws_dynamodb_1.BillingMode.PAY_PER_REQUEST,
+            removalPolicy: aws_cdk_lib_1.RemovalPolicy.RETAIN, // Never delete - shared infrastructure
+            pointInTimeRecoverySpecification: {
+                pointInTimeRecoveryEnabled: true,
+            },
+        });
+        // Add GSI for querying by service identifier
+        table.addGlobalSecondaryIndex({
+            indexName: 'ServiceIdentifierIndex',
+            partitionKey: {
+                name: 'ServiceIdentifier',
+                type: aws_dynamodb_1.AttributeType.STRING,
+            },
+            sortKey: {
+                name: 'ListenerArn',
+                type: aws_dynamodb_1.AttributeType.STRING,
+            },
+        });
+        return table;
+    }
+    /**
+     * Gets or creates the singleton Lambda function for priority allocation.
+     * Only one Lambda function exists per AWS account/region.
+     */
+    static getOrCreateLambda(scope, table) {
+        const stack = aws_cdk_lib_1.Stack.of(scope);
+        const lambdaId = 'PriorityAllocatorLambda';
+        // Try to find existing Lambda in the stack
+        const existing = stack.node.tryFindChild(lambdaId);
+        if (existing) {
+            return existing;
+        }
+        // Create IAM role for Lambda
+        const role = new aws_iam_1.Role(stack, 'PriorityAllocatorLambdaRole', {
+            assumedBy: new aws_iam_1.ServicePrincipal('lambda.amazonaws.com'),
+            description: 'Role for ALB Priority Allocator Lambda function',
+        });
+        // CloudWatch Logs permissions
+        role.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                'logs:CreateLogGroup',
+                'logs:CreateLogStream',
+                'logs:PutLogEvents',
+            ],
+            resources: ['*'],
+        }));
+        // ALB read permissions
+        role.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                'elasticloadbalancing:DescribeListeners',
+                'elasticloadbalancing:DescribeRules',
+            ],
+            resources: ['*'],
+        }));
+        // DynamoDB permissions
+        role.addToPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: [
+                'dynamodb:Query',
+                'dynamodb:GetItem',
+                'dynamodb:PutItem',
+                'dynamodb:DeleteItem',
+            ],
+            resources: [table.tableArn, `${table.tableArn}/index/*`],
+        }));
+        // Create Lambda function
+        return new aws_lambda_nodejs_1.NodejsFunction(stack, lambdaId, {
+            role,
+            runtime: aws_lambda_1.Runtime.NODEJS_20_X,
+            handler: 'handler',
+            entry: path.join(__dirname, 'priority-allocator-handler.js'),
+            timeout: aws_cdk_lib_1.Duration.seconds(30),
+            memorySize: 256,
+            description: 'Allocates unique priorities for ALB listener rules',
+            functionName: 'priority-allocator-singleton',
+        });
+    }
+    /**
+     * Gets or creates the singleton Custom Resource Provider.
+     * Only one provider exists per AWS account/region.
+     */
+    static getOrCreateProvider(scope, lambda) {
+        const stack = aws_cdk_lib_1.Stack.of(scope);
+        const providerId = 'PriorityAllocatorProvider';
+        // Try to find existing provider in the stack
+        const existing = stack.node.tryFindChild(providerId);
+        if (existing) {
+            return existing;
+        }
+        // Create new provider at stack level (singleton)
+        return new custom_resources_1.Provider(stack, providerId, {
+            onEventHandler: lambda,
+        });
+    }
+    /**
+     * Generates a deterministic service identifier based on the construct path and listener ARN.
+     */
+    generateServiceIdentifier(listenerArn) {
+        const stack = aws_cdk_lib_1.Stack.of(this);
+        const region = stack.region;
+        const account = stack.account;
+        const stackName = stack.stackName;
+        const constructPath = this.node.path;
+        // Create deterministic hash
+        const input = `${account}/${region}/${stackName}/${constructPath}/${listenerArn}`;
+        const hash = crypto
+            .createHash('sha256')
+            .update(input)
+            .digest('hex')
+            .substring(0, 12);
+        // Create human-readable identifier with stack name and hash
+        const sanitizedStackName = stackName
+            .replaceAll(/[^a-zA-Z0-9-]/g, '-')
+            .toLowerCase();
+        return `${sanitizedStackName}-${hash}`;
+    }
+    constructor(scope, id, props) {
+        var _a;
+        super(scope, id);
+        // Get or create singleton resources
+        const table = PriorityAllocator.getOrCreateTable(this);
+        const lambda = PriorityAllocator.getOrCreateLambda(this, table);
+        const provider = PriorityAllocator.getOrCreateProvider(this, lambda);
+        // Generate service identifier
+        this.serviceIdentifier = this.generateServiceIdentifier(props.listenerArn);
+        // Create Custom Resource for this specific service
+        this.resource = new aws_cdk_lib_1.CustomResource(this, 'Resource', {
+            serviceToken: provider.serviceToken,
+            properties: {
+                ListenerArn: props.listenerArn,
+                ServiceIdentifier: this.serviceIdentifier,
+                TableName: PriorityAllocator.TABLE_NAME,
+                PreferredPriority: (_a = props.preferredPriority) === null || _a === void 0 ? void 0 : _a.toString(),
+                // Add timestamp to ensure update on property changes
+                Timestamp: Date.now().toString(),
+            },
+        });
+        // Extract priority from custom resource
+        this.priority = aws_cdk_lib_1.Token.asNumber(this.resource.getAtt('Priority'));
+        // Add CloudFormation outputs for debugging
+        new aws_cdk_lib_1.CfnOutput(this, 'ServiceIdentifier', {
+            value: this.serviceIdentifier,
+            description: 'Service identifier for priority allocation tracking',
+        });
+        new aws_cdk_lib_1.CfnOutput(this, 'AllocatedPriority', {
+            value: this.priority.toString(),
+            description: 'Auto-allocated priority for ALB listener rule',
+        });
+    }
+}
+exports.PriorityAllocator = PriorityAllocator;
+/**
+ * Singleton table name - shared across all priority allocators in the account/region.
+ */
+PriorityAllocator.TABLE_NAME = 'alb-listener-priorities';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"priority-allocator.js","sourceRoot":"","sources":["priority-allocator.ts"],"names":[],"mappings":"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","sourcesContent":["import {Construct} from 'constructs';\nimport {NodejsFunction} from 'aws-cdk-lib/aws-lambda-nodejs';\nimport {\n  CustomResource,\n  Duration,\n  RemovalPolicy,\n  Stack,\n  CfnOutput,\n  Token,\n} from 'aws-cdk-lib';\nimport {Provider} from 'aws-cdk-lib/custom-resources';\nimport {Runtime} from 'aws-cdk-lib/aws-lambda';\nimport * as path from 'node:path';\nimport {\n  Effect,\n  PolicyStatement,\n  Role,\n  ServicePrincipal,\n} from 'aws-cdk-lib/aws-iam';\nimport {AttributeType, BillingMode, Table} from 'aws-cdk-lib/aws-dynamodb';\nimport * as crypto from 'node:crypto';\n\nexport interface PriorityAllocatorProps {\n  /**\n   * The ARN of the ALB listener for which to allocate a priority.\n   */\n  readonly listenerArn: string;\n\n  /**\n   * Optional preferred priority. If available, this priority will be allocated.\n   * If not available, the next available priority will be allocated.\n   *\n   * @default - Next available priority is allocated\n   */\n  readonly preferredPriority?: number;\n}\n\n/**\n * Allocates a unique priority for an ALB listener rule using a Lambda-backed Custom Resource.\n *\n * This construct implements a singleton pattern for the Lambda function and DynamoDB table,\n * ensuring that only one instance of each exists per AWS account/region regardless of how\n * many services use priority allocation.\n *\n * The allocation algorithm:\n * 1. Checks if this service already has an allocated priority (idempotent)\n * 2. Queries all priorities currently on the ALB listener (source of truth)\n * 3. Queries priorities tracked in DynamoDB\n * 4. Merges both sources to get complete picture\n * 5. Finds lowest available priority (gap filling)\n * 6. Allocates atomically with DynamoDB conditional write\n * 7. Returns allocated priority to CloudFormation\n *\n * On stack deletion, the priority is released back to the pool for reuse.\n *\n * @example\n * ```typescript\n * const allocator = new PriorityAllocator(this, 'PriorityAllocator', {\n *   listenerArn: listener.listenerArn,\n * });\n *\n * // Use the allocated priority\n * listener.addTargetGroups('TargetGroup', {\n *   targetGroups: [targetGroup],\n *   priority: allocator.priority,\n * });\n * ```\n */\nexport class PriorityAllocator extends Construct {\n  /**\n   * The allocated priority for the ALB listener rule.\n   */\n  readonly priority: number;\n\n  /**\n   * The service identifier used for tracking this allocation.\n   */\n  readonly serviceIdentifier: string;\n\n  /**\n   * The Custom Resource that manages the priority allocation.\n   */\n  readonly resource: CustomResource;\n\n  /**\n   * Singleton table name - shared across all priority allocators in the account/region.\n   */\n  private static readonly TABLE_NAME = 'alb-listener-priorities';\n\n  /**\n   * Gets or creates the singleton DynamoDB table for priority tracking.\n   * Only one table exists per AWS account/region.\n   */\n  private static getOrCreateTable(scope: Construct): Table {\n    const stack = Stack.of(scope);\n    const tableId = 'PriorityAllocatorTable';\n\n    // Try to find existing table in the stack\n    const existing = stack.node.tryFindChild(tableId) as Table | undefined;\n    if (existing) {\n      return existing;\n    }\n\n    // Create new table at stack level (singleton)\n    const table = new Table(stack, tableId, {\n      tableName: PriorityAllocator.TABLE_NAME,\n      partitionKey: {\n        name: 'ListenerArn',\n        type: AttributeType.STRING,\n      },\n      sortKey: {\n        name: 'Priority',\n        type: AttributeType.NUMBER,\n      },\n      billingMode: BillingMode.PAY_PER_REQUEST,\n      removalPolicy: RemovalPolicy.RETAIN, // Never delete - shared infrastructure\n      pointInTimeRecoverySpecification: {\n        pointInTimeRecoveryEnabled: true,\n      },\n    });\n\n    // Add GSI for querying by service identifier\n    table.addGlobalSecondaryIndex({\n      indexName: 'ServiceIdentifierIndex',\n      partitionKey: {\n        name: 'ServiceIdentifier',\n        type: AttributeType.STRING,\n      },\n      sortKey: {\n        name: 'ListenerArn',\n        type: AttributeType.STRING,\n      },\n    });\n\n    return table;\n  }\n\n  /**\n   * Gets or creates the singleton Lambda function for priority allocation.\n   * Only one Lambda function exists per AWS account/region.\n   */\n  private static getOrCreateLambda(\n    scope: Construct,\n    table: Table,\n  ): NodejsFunction {\n    const stack = Stack.of(scope);\n    const lambdaId = 'PriorityAllocatorLambda';\n\n    // Try to find existing Lambda in the stack\n    const existing = stack.node.tryFindChild(lambdaId) as\n      | NodejsFunction\n      | undefined;\n    if (existing) {\n      return existing;\n    }\n\n    // Create IAM role for Lambda\n    const role = new Role(stack, 'PriorityAllocatorLambdaRole', {\n      assumedBy: new ServicePrincipal('lambda.amazonaws.com'),\n      description: 'Role for ALB Priority Allocator Lambda function',\n    });\n\n    // CloudWatch Logs permissions\n    role.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          'logs:CreateLogGroup',\n          'logs:CreateLogStream',\n          'logs:PutLogEvents',\n        ],\n        resources: ['*'],\n      }),\n    );\n\n    // ALB read permissions\n    role.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          'elasticloadbalancing:DescribeListeners',\n          'elasticloadbalancing:DescribeRules',\n        ],\n        resources: ['*'],\n      }),\n    );\n\n    // DynamoDB permissions\n    role.addToPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: [\n          'dynamodb:Query',\n          'dynamodb:GetItem',\n          'dynamodb:PutItem',\n          'dynamodb:DeleteItem',\n        ],\n        resources: [table.tableArn, `${table.tableArn}/index/*`],\n      }),\n    );\n\n    // Create Lambda function\n    return new NodejsFunction(stack, lambdaId, {\n      role,\n      runtime: Runtime.NODEJS_20_X,\n      handler: 'handler',\n      entry: path.join(__dirname, 'priority-allocator-handler.js'),\n      timeout: Duration.seconds(30),\n      memorySize: 256,\n      description: 'Allocates unique priorities for ALB listener rules',\n      functionName: 'priority-allocator-singleton',\n    });\n  }\n\n  /**\n   * Gets or creates the singleton Custom Resource Provider.\n   * Only one provider exists per AWS account/region.\n   */\n  private static getOrCreateProvider(\n    scope: Construct,\n    lambda: NodejsFunction,\n  ): Provider {\n    const stack = Stack.of(scope);\n    const providerId = 'PriorityAllocatorProvider';\n\n    // Try to find existing provider in the stack\n    const existing = stack.node.tryFindChild(providerId) as\n      | Provider\n      | undefined;\n    if (existing) {\n      return existing;\n    }\n\n    // Create new provider at stack level (singleton)\n    return new Provider(stack, providerId, {\n      onEventHandler: lambda,\n    });\n  }\n\n  /**\n   * Generates a deterministic service identifier based on the construct path and listener ARN.\n   */\n  private generateServiceIdentifier(listenerArn: string): string {\n    const stack = Stack.of(this);\n    const region = stack.region;\n    const account = stack.account;\n    const stackName = stack.stackName;\n    const constructPath = this.node.path;\n\n    // Create deterministic hash\n    const input = `${account}/${region}/${stackName}/${constructPath}/${listenerArn}`;\n    const hash = crypto\n      .createHash('sha256')\n      .update(input)\n      .digest('hex')\n      .substring(0, 12);\n\n    // Create human-readable identifier with stack name and hash\n    const sanitizedStackName = stackName\n      .replaceAll(/[^a-zA-Z0-9-]/g, '-')\n      .toLowerCase();\n    return `${sanitizedStackName}-${hash}`;\n  }\n\n  constructor(scope: Construct, id: string, props: PriorityAllocatorProps) {\n    super(scope, id);\n\n    // Get or create singleton resources\n    const table = PriorityAllocator.getOrCreateTable(this);\n    const lambda = PriorityAllocator.getOrCreateLambda(this, table);\n    const provider = PriorityAllocator.getOrCreateProvider(this, lambda);\n\n    // Generate service identifier\n    this.serviceIdentifier = this.generateServiceIdentifier(props.listenerArn);\n\n    // Create Custom Resource for this specific service\n    this.resource = new CustomResource(this, 'Resource', {\n      serviceToken: provider.serviceToken,\n      properties: {\n        ListenerArn: props.listenerArn,\n        ServiceIdentifier: this.serviceIdentifier,\n        TableName: PriorityAllocator.TABLE_NAME,\n        PreferredPriority: props.preferredPriority?.toString(),\n        // Add timestamp to ensure update on property changes\n        Timestamp: Date.now().toString(),\n      },\n    });\n\n    // Extract priority from custom resource\n    this.priority = Token.asNumber(this.resource.getAtt('Priority'));\n\n    // Add CloudFormation outputs for debugging\n    new CfnOutput(this, 'ServiceIdentifier', {\n      value: this.serviceIdentifier,\n      description: 'Service identifier for priority allocation tracking',\n    });\n\n    new CfnOutput(this, 'AllocatedPriority', {\n      value: this.priority.toString(),\n      description: 'Auto-allocated priority for ALB listener rule',\n    });\n  }\n}\n"]}

package/aws-ecs/lib/standard-application-fargate-service.d.ts

@@ -138,8 +138,12 @@ export interface StandardApplicationFargateServiceProps extends StandardFargateS
     readonly listener?: IApplicationListener;
     /**
      * The priority to give the target group on the ALB.
+     * If not specified, a unique priority is automatically allocated using
+     * the PriorityAllocator, which coordinates with other services across
+     * multiple teams and tools (CDK, Terraform, manual) to find the lowest
+     * available priority.
      *
-     * @default - 1
+     * @default - Automatically allocated (recommended for most use cases)
      */
     readonly targetGroupPriority?: number;
     /**

package/aws-ecs/lib/standard-application-fargate-service.js

@@ -7,12 +7,13 @@ const aws_elasticloadbalancingv2_1 = require("aws-cdk-lib/aws-elasticloadbalanci
 const aws_route53_1 = require("aws-cdk-lib/aws-route53");
 const aws_route53_2 = require("../../aws-route53");
 const aws_route53_targets_1 = require("aws-cdk-lib/aws-route53-targets");
+const priority_allocator_1 = require("./priority-allocator");
 /**
  * Creates an ECS Fargate service and maps it to an Application Load Balancer (ALB).
  */
 class StandardApplicationFargateService extends standard_fargate_service_1.StandardFargateService {
     constructor(scope, id, props) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r;
         super(scope, id, {
             ...props,
             healthCheckGracePeriod: (_a = props.healthCheckGracePeriod) !== null && _a !== void 0 ? _a : aws_cdk_lib_1.Duration.seconds(60),
@@ -87,10 +88,23 @@ class StandardApplicationFargateService extends standard_fargate_service_1.Stand
             loadBalancerArn: loadBalancer.loadBalancerArn,
             listenerProtocol: aws_elasticloadbalancingv2_1.ApplicationProtocol.HTTPS,
         });
+        // Determine priority: use explicit value, or allocate automatically
+        let priority;
+        if (props.targetGroupPriority !== undefined) {
+            // Manual priority specified - use it directly
+            priority = props.targetGroupPriority;
+        }
+        else {
+            // No priority specified - use automatic allocation
+            const allocator = new priority_allocator_1.PriorityAllocator(this, 'PriorityAllocator', {
+                listenerArn: listener.listenerArn,
+            });
+            priority = allocator.priority;
+        }
         listener.addTargetGroups(`${id}TargetGroups`, {
             targetGroups: [targetGroup],
             conditions: targetGroupConditions,
-            priority: (_s = props.targetGroupPriority) !== null && _s !== void 0 ? _s : 1,
+            priority,
         });
         if (props.domainName !== undefined &&
             props.domainZone !== undefined &&
@@ -108,4 +122,4 @@ class StandardApplicationFargateService extends standard_fargate_service_1.Stand
     }
 }
 exports.StandardApplicationFargateService = StandardApplicationFargateService;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard-application-fargate-service.js","sourceRoot":"","sources":["standard-application-fargate-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  StandardFargateService,\n  StandardFargateServiceProps,\n} from './standard-fargate-service';\nimport {Construct} from 'constructs';\nimport {Duration} from 'aws-cdk-lib';\nimport {\n  ApplicationListener,\n  ApplicationLoadBalancer,\n  ApplicationProtocol,\n  ApplicationTargetGroup,\n  IApplicationListener,\n  IApplicationLoadBalancer,\n  IApplicationTargetGroup,\n  ListenerCondition,\n  TargetGroupLoadBalancingAlgorithmType,\n} from 'aws-cdk-lib/aws-elasticloadbalancingv2';\nimport {ARecord, IHostedZone, RecordTarget} from 'aws-cdk-lib/aws-route53';\nimport {DomainName} from '../../aws-route53';\nimport {LoadBalancerTarget} from 'aws-cdk-lib/aws-route53-targets';\nimport {MetricOptions} from 'aws-cdk-lib/aws-cloudwatch';\n\n/**\n * Properties for StandardApplicationFargateService\n */\nexport interface StandardApplicationFargateServiceProps extends StandardFargateServiceProps {\n  /**\n   * The name of an application-based stickiness cookie.\n   *\n   * @default - lb_affinity\n   */\n  readonly stickinessCookieName?: string;\n\n  /**\n   * The stickiness cookie expiration period. Set to 0 to disable.\n   *\n   * @default - Duration.days(1)\n   */\n  readonly stickinessCookieDuration?: Duration;\n\n  /**\n   * The time period during which the load balancer sends a newly registered target a\n   * linearly increasing share of the traffic to the target group. Set this to 0\n   * to disable.\n   *\n   * @default - Duration.seconds(30)\n   */\n  readonly slowStart?: Duration;\n\n  /**\n   * The protocol used by the application in the container.\n   *\n   * @default - ApplicationProtocol.HTTP\n   */\n  readonly applicationProtocol?: ApplicationProtocol;\n\n  /**\n   * The amount of time for Elastic Load Balancing to wait before deregistering a target.\n   *\n   * @default - Duration.seconds(10)\n   */\n  readonly deregistrationDelay?: Duration;\n\n  /**\n   * The approximate number of seconds between health checks for an individual target.\n   *\n   * @default - Duration.seconds(10)\n   */\n  readonly healthCheckInterval?: Duration;\n\n  /**\n   * The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy\n   * Elastic Load Balancing target health checks after a task has first started.\n   *\n   * @default - defaults to 60 seconds\n   */\n  readonly healthCheckGracePeriod?: Duration;\n\n  /**\n   * The ping path destination where Elastic Load Balancing sends health check requests.\n   *\n   * @default - /health\n   */\n  readonly healthCheckPath?: string;\n\n  /**\n   * The amount of time, in seconds, during which no response from a target means a failed health check\n   *\n   * @default - Duration.seconds(3)\n   */\n  readonly healthCheckTimeout?: Duration;\n\n  /**\n   * The number of consecutive health checks successes required before considering an unhealthy target healthy.\n   *\n   * @default - 2\n   */\n  readonly healthyThresholdCount?: number;\n\n  /**\n   * The number of consecutive health check failures required before considering a target unhealthy.\n   *\n   * @default - 2\n   */\n  readonly unhealthyThresholdCount?: number;\n\n  /**\n   * HTTP code to use when checking for a successful response from a target\n   *\n   * @default - 200-299\n   */\n  readonly healthyHttpCodes?: string;\n\n  /**\n   * The load balancing algorithm to select targets for routing requests.\n   * To set this to LEAST_OUTSTANDING_REQUESTS, stickiness must be disabled.\n   *\n   * @default - ROUND_ROBIN\n   */\n  readonly loadBalancingAlgorithmType?: TargetGroupLoadBalancingAlgorithmType;\n\n  /**\n   * The number of ALB requests to target for scaling.\n   * Disabled by default.\n   */\n  readonly scaleRequestPerTarget?: number;\n\n  /**\n   * Target response time for scaling\n   * Disabled by default\n   */\n  readonly scaleOnTargetResponseTime?: {\n    /** Threshold in seconds */\n    threshold: number;\n    metricOptions?: MetricOptions;\n  };\n\n  /**\n   * Domain name associated with this service.\n   */\n  readonly domainName?: string;\n\n  /**\n   * Additional domain names to associate with this service.\n   */\n  readonly domainNames?: string[];\n\n  /**\n   * Set this to true to skip the creation of route53 records. By default records will be created in domainName and domainZone is provided.\n   *\n   * @default - false\n   */\n  readonly skipCreateRoute53Records?: boolean;\n\n  /**\n   * Path pattern to match on the load balancer.\n   *\n   * @default - [\"/*\"]\n   */\n  readonly pathPattern?: string[];\n\n  /**\n   * Load balancer to attach this service to. If passed an ARN or name a lookup will be\n   * performed to locate the load balancer.\n   */\n  readonly loadBalancer: IApplicationLoadBalancer | string;\n\n  /**\n   * The listener to attach this service to. If one is not provided an HTTPS listener is obtained from a lookup.\n   *\n   * @default - ApplicationProtocol.HTTPS\n   */\n  readonly listener?: IApplicationListener;\n\n  /**\n   * The priority to give the target group on the ALB.\n   *\n   * @default - 1\n   */\n  readonly targetGroupPriority?: number;\n\n  /**\n   * Zone of the domain name. If set, a route53 record is created for the service.\n   *\n   */\n  readonly domainZone?: IHostedZone;\n}\n\n/**\n * Creates an ECS Fargate service and maps it to an Application Load Balancer (ALB).\n */\nexport class StandardApplicationFargateService extends StandardFargateService {\n  readonly loadBalancer: IApplicationLoadBalancer;\n  readonly listener: IApplicationListener;\n  readonly domainName?: DomainName;\n  readonly route53Record?: ARecord;\n  readonly targetGroup: IApplicationTargetGroup;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: StandardApplicationFargateServiceProps,\n  ) {\n    super(scope, id, {\n      ...props,\n      healthCheckGracePeriod:\n        props.healthCheckGracePeriod ?? Duration.seconds(60),\n    });\n\n    let stickinessCookieDuration: Duration | undefined =\n      props.stickinessCookieDuration ?? Duration.days(1);\n    if (stickinessCookieDuration.toSeconds() === 0) {\n      stickinessCookieDuration = undefined;\n    }\n\n    let stickinessCookieName: string | undefined;\n    if (stickinessCookieDuration !== undefined) {\n      stickinessCookieName = props.stickinessCookieName ?? 'lb_affinity';\n    }\n\n    let slowStart: Duration | undefined =\n      props.slowStart ?? Duration.seconds(30);\n    if (slowStart.toSeconds() === 0) {\n      slowStart = undefined;\n    }\n\n    const targetGroup = new ApplicationTargetGroup(this, 'TargetGroup', {\n      targets: [this.service],\n      vpc: props.cluster.vpc,\n      port: this.port,\n      protocol: props.applicationProtocol ?? ApplicationProtocol.HTTP,\n      deregistrationDelay: props.deregistrationDelay ?? Duration.seconds(10),\n      slowStart,\n      healthCheck: {\n        enabled: true,\n        interval: props.healthCheckInterval ?? Duration.seconds(10),\n        path: props.healthCheckPath ?? '/health',\n        timeout: props.healthCheckTimeout ?? Duration.seconds(3),\n        healthyThresholdCount: props.healthyThresholdCount ?? 2,\n        unhealthyThresholdCount: props.unhealthyThresholdCount ?? 2,\n        healthyHttpCodes: props.healthyHttpCodes ?? '200-299',\n      },\n      stickinessCookieName,\n      stickinessCookieDuration,\n      loadBalancingAlgorithmType:\n        props.loadBalancingAlgorithmType ??\n        TargetGroupLoadBalancingAlgorithmType.ROUND_ROBIN,\n    });\n\n    if (props.scaleRequestPerTarget !== undefined) {\n      this.scaling.scaleOnRequestCount('RequestCountScaling', {\n        scaleInCooldown: this.scaleInCooldown,\n        scaleOutCooldown: this.scaleOutCooldown,\n        targetGroup,\n        requestsPerTarget: props.scaleRequestPerTarget,\n      });\n    }\n\n    const targetGroupConditions: ListenerCondition[] = [];\n    targetGroupConditions.push(\n      ListenerCondition.pathPatterns(props.pathPattern ?? ['/*']),\n    );\n    if (props.domainName !== undefined) {\n      targetGroupConditions.push(\n        ListenerCondition.hostHeaders([\n          props.domainName,\n          ...(props.domainNames ?? []),\n        ]),\n      );\n    }\n\n    let loadBalancer: IApplicationLoadBalancer;\n    if (typeof props.loadBalancer === 'string') {\n      if (props.loadBalancer.startsWith('arn:')) {\n        loadBalancer = ApplicationLoadBalancer.fromLookup(\n          this,\n          'LoadBalancer',\n          {\n            loadBalancerArn: props.loadBalancer,\n          },\n        );\n      } else {\n        loadBalancer = ApplicationLoadBalancer.fromLookup(\n          this,\n          'LoadBalancer',\n          {\n            loadBalancerTags: {\n              Name: props.loadBalancer,\n            },\n          },\n        );\n      }\n    } else {\n      loadBalancer = props.loadBalancer;\n    }\n\n    const listener =\n      props.listener ??\n      ApplicationListener.fromLookup(this, 'Listener', {\n        loadBalancerArn: loadBalancer.loadBalancerArn,\n        listenerProtocol: ApplicationProtocol.HTTPS,\n      });\n\n    listener.addTargetGroups(`${id}TargetGroups`, {\n      targetGroups: [targetGroup],\n      conditions: targetGroupConditions,\n      priority: props.targetGroupPriority ?? 1,\n    });\n\n    if (\n      props.domainName !== undefined &&\n      props.domainZone !== undefined &&\n      !props.skipCreateRoute53Records\n    ) {\n      this.domainName = DomainName.fromFqdn(props.domainName, props.domainZone);\n      this.route53Record = this.domainName.createARecord(\n        this,\n        RecordTarget.fromAlias(new LoadBalancerTarget(loadBalancer)),\n      );\n    }\n\n    this.loadBalancer = loadBalancer;\n    this.listener = listener;\n    this.targetGroup = targetGroup;\n\n    if (props.scaleOnTargetResponseTime) {\n      // Attach scaling policy to the service\n      this.scaleToTrackCustomMetric(\n        'TargetResponseTimeScaling',\n        targetGroup.metrics.targetResponseTime(\n          props.scaleOnTargetResponseTime.metricOptions,\n        ),\n        props.scaleOnTargetResponseTime.threshold,\n      );\n    }\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"standard-application-fargate-service.js","sourceRoot":"","sources":["standard-application-fargate-service.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  StandardFargateService,\n  StandardFargateServiceProps,\n} from './standard-fargate-service';\nimport {Construct} from 'constructs';\nimport {Duration} from 'aws-cdk-lib';\nimport {\n  ApplicationListener,\n  ApplicationLoadBalancer,\n  ApplicationProtocol,\n  ApplicationTargetGroup,\n  IApplicationListener,\n  IApplicationLoadBalancer,\n  IApplicationTargetGroup,\n  ListenerCondition,\n  TargetGroupLoadBalancingAlgorithmType,\n} from 'aws-cdk-lib/aws-elasticloadbalancingv2';\nimport {ARecord, IHostedZone, RecordTarget} from 'aws-cdk-lib/aws-route53';\nimport {DomainName} from '../../aws-route53';\nimport {LoadBalancerTarget} from 'aws-cdk-lib/aws-route53-targets';\nimport {MetricOptions} from 'aws-cdk-lib/aws-cloudwatch';\nimport {PriorityAllocator} from './priority-allocator';\n\n/**\n * Properties for StandardApplicationFargateService\n */\nexport interface StandardApplicationFargateServiceProps extends StandardFargateServiceProps {\n  /**\n   * The name of an application-based stickiness cookie.\n   *\n   * @default - lb_affinity\n   */\n  readonly stickinessCookieName?: string;\n\n  /**\n   * The stickiness cookie expiration period. Set to 0 to disable.\n   *\n   * @default - Duration.days(1)\n   */\n  readonly stickinessCookieDuration?: Duration;\n\n  /**\n   * The time period during which the load balancer sends a newly registered target a\n   * linearly increasing share of the traffic to the target group. Set this to 0\n   * to disable.\n   *\n   * @default - Duration.seconds(30)\n   */\n  readonly slowStart?: Duration;\n\n  /**\n   * The protocol used by the application in the container.\n   *\n   * @default - ApplicationProtocol.HTTP\n   */\n  readonly applicationProtocol?: ApplicationProtocol;\n\n  /**\n   * The amount of time for Elastic Load Balancing to wait before deregistering a target.\n   *\n   * @default - Duration.seconds(10)\n   */\n  readonly deregistrationDelay?: Duration;\n\n  /**\n   * The approximate number of seconds between health checks for an individual target.\n   *\n   * @default - Duration.seconds(10)\n   */\n  readonly healthCheckInterval?: Duration;\n\n  /**\n   * The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy\n   * Elastic Load Balancing target health checks after a task has first started.\n   *\n   * @default - defaults to 60 seconds\n   */\n  readonly healthCheckGracePeriod?: Duration;\n\n  /**\n   * The ping path destination where Elastic Load Balancing sends health check requests.\n   *\n   * @default - /health\n   */\n  readonly healthCheckPath?: string;\n\n  /**\n   * The amount of time, in seconds, during which no response from a target means a failed health check\n   *\n   * @default - Duration.seconds(3)\n   */\n  readonly healthCheckTimeout?: Duration;\n\n  /**\n   * The number of consecutive health checks successes required before considering an unhealthy target healthy.\n   *\n   * @default - 2\n   */\n  readonly healthyThresholdCount?: number;\n\n  /**\n   * The number of consecutive health check failures required before considering a target unhealthy.\n   *\n   * @default - 2\n   */\n  readonly unhealthyThresholdCount?: number;\n\n  /**\n   * HTTP code to use when checking for a successful response from a target\n   *\n   * @default - 200-299\n   */\n  readonly healthyHttpCodes?: string;\n\n  /**\n   * The load balancing algorithm to select targets for routing requests.\n   * To set this to LEAST_OUTSTANDING_REQUESTS, stickiness must be disabled.\n   *\n   * @default - ROUND_ROBIN\n   */\n  readonly loadBalancingAlgorithmType?: TargetGroupLoadBalancingAlgorithmType;\n\n  /**\n   * The number of ALB requests to target for scaling.\n   * Disabled by default.\n   */\n  readonly scaleRequestPerTarget?: number;\n\n  /**\n   * Target response time for scaling\n   * Disabled by default\n   */\n  readonly scaleOnTargetResponseTime?: {\n    /** Threshold in seconds */\n    threshold: number;\n    metricOptions?: MetricOptions;\n  };\n\n  /**\n   * Domain name associated with this service.\n   */\n  readonly domainName?: string;\n\n  /**\n   * Additional domain names to associate with this service.\n   */\n  readonly domainNames?: string[];\n\n  /**\n   * Set this to true to skip the creation of route53 records. By default records will be created in domainName and domainZone is provided.\n   *\n   * @default - false\n   */\n  readonly skipCreateRoute53Records?: boolean;\n\n  /**\n   * Path pattern to match on the load balancer.\n   *\n   * @default - [\"/*\"]\n   */\n  readonly pathPattern?: string[];\n\n  /**\n   * Load balancer to attach this service to. If passed an ARN or name a lookup will be\n   * performed to locate the load balancer.\n   */\n  readonly loadBalancer: IApplicationLoadBalancer | string;\n\n  /**\n   * The listener to attach this service to. If one is not provided an HTTPS listener is obtained from a lookup.\n   *\n   * @default - ApplicationProtocol.HTTPS\n   */\n  readonly listener?: IApplicationListener;\n\n  /**\n   * The priority to give the target group on the ALB.\n   * If not specified, a unique priority is automatically allocated using\n   * the PriorityAllocator, which coordinates with other services across\n   * multiple teams and tools (CDK, Terraform, manual) to find the lowest\n   * available priority.\n   *\n   * @default - Automatically allocated (recommended for most use cases)\n   */\n  readonly targetGroupPriority?: number;\n\n  /**\n   * Zone of the domain name. If set, a route53 record is created for the service.\n   *\n   */\n  readonly domainZone?: IHostedZone;\n}\n\n/**\n * Creates an ECS Fargate service and maps it to an Application Load Balancer (ALB).\n */\nexport class StandardApplicationFargateService extends StandardFargateService {\n  readonly loadBalancer: IApplicationLoadBalancer;\n  readonly listener: IApplicationListener;\n  readonly domainName?: DomainName;\n  readonly route53Record?: ARecord;\n  readonly targetGroup: IApplicationTargetGroup;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: StandardApplicationFargateServiceProps,\n  ) {\n    super(scope, id, {\n      ...props,\n      healthCheckGracePeriod:\n        props.healthCheckGracePeriod ?? Duration.seconds(60),\n    });\n\n    let stickinessCookieDuration: Duration | undefined =\n      props.stickinessCookieDuration ?? Duration.days(1);\n    if (stickinessCookieDuration.toSeconds() === 0) {\n      stickinessCookieDuration = undefined;\n    }\n\n    let stickinessCookieName: string | undefined;\n    if (stickinessCookieDuration !== undefined) {\n      stickinessCookieName = props.stickinessCookieName ?? 'lb_affinity';\n    }\n\n    let slowStart: Duration | undefined =\n      props.slowStart ?? Duration.seconds(30);\n    if (slowStart.toSeconds() === 0) {\n      slowStart = undefined;\n    }\n\n    const targetGroup = new ApplicationTargetGroup(this, 'TargetGroup', {\n      targets: [this.service],\n      vpc: props.cluster.vpc,\n      port: this.port,\n      protocol: props.applicationProtocol ?? ApplicationProtocol.HTTP,\n      deregistrationDelay: props.deregistrationDelay ?? Duration.seconds(10),\n      slowStart,\n      healthCheck: {\n        enabled: true,\n        interval: props.healthCheckInterval ?? Duration.seconds(10),\n        path: props.healthCheckPath ?? '/health',\n        timeout: props.healthCheckTimeout ?? Duration.seconds(3),\n        healthyThresholdCount: props.healthyThresholdCount ?? 2,\n        unhealthyThresholdCount: props.unhealthyThresholdCount ?? 2,\n        healthyHttpCodes: props.healthyHttpCodes ?? '200-299',\n      },\n      stickinessCookieName,\n      stickinessCookieDuration,\n      loadBalancingAlgorithmType:\n        props.loadBalancingAlgorithmType ??\n        TargetGroupLoadBalancingAlgorithmType.ROUND_ROBIN,\n    });\n\n    if (props.scaleRequestPerTarget !== undefined) {\n      this.scaling.scaleOnRequestCount('RequestCountScaling', {\n        scaleInCooldown: this.scaleInCooldown,\n        scaleOutCooldown: this.scaleOutCooldown,\n        targetGroup,\n        requestsPerTarget: props.scaleRequestPerTarget,\n      });\n    }\n\n    const targetGroupConditions: ListenerCondition[] = [];\n    targetGroupConditions.push(\n      ListenerCondition.pathPatterns(props.pathPattern ?? ['/*']),\n    );\n    if (props.domainName !== undefined) {\n      targetGroupConditions.push(\n        ListenerCondition.hostHeaders([\n          props.domainName,\n          ...(props.domainNames ?? []),\n        ]),\n      );\n    }\n\n    let loadBalancer: IApplicationLoadBalancer;\n    if (typeof props.loadBalancer === 'string') {\n      if (props.loadBalancer.startsWith('arn:')) {\n        loadBalancer = ApplicationLoadBalancer.fromLookup(\n          this,\n          'LoadBalancer',\n          {\n            loadBalancerArn: props.loadBalancer,\n          },\n        );\n      } else {\n        loadBalancer = ApplicationLoadBalancer.fromLookup(\n          this,\n          'LoadBalancer',\n          {\n            loadBalancerTags: {\n              Name: props.loadBalancer,\n            },\n          },\n        );\n      }\n    } else {\n      loadBalancer = props.loadBalancer;\n    }\n\n    const listener =\n      props.listener ??\n      ApplicationListener.fromLookup(this, 'Listener', {\n        loadBalancerArn: loadBalancer.loadBalancerArn,\n        listenerProtocol: ApplicationProtocol.HTTPS,\n      });\n\n    // Determine priority: use explicit value, or allocate automatically\n    let priority: number;\n    if (props.targetGroupPriority !== undefined) {\n      // Manual priority specified - use it directly\n      priority = props.targetGroupPriority;\n    } else {\n      // No priority specified - use automatic allocation\n      const allocator = new PriorityAllocator(this, 'PriorityAllocator', {\n        listenerArn: listener.listenerArn,\n      });\n      priority = allocator.priority;\n    }\n\n    listener.addTargetGroups(`${id}TargetGroups`, {\n      targetGroups: [targetGroup],\n      conditions: targetGroupConditions,\n      priority,\n    });\n\n    if (\n      props.domainName !== undefined &&\n      props.domainZone !== undefined &&\n      !props.skipCreateRoute53Records\n    ) {\n      this.domainName = DomainName.fromFqdn(props.domainName, props.domainZone);\n      this.route53Record = this.domainName.createARecord(\n        this,\n        RecordTarget.fromAlias(new LoadBalancerTarget(loadBalancer)),\n      );\n    }\n\n    this.loadBalancer = loadBalancer;\n    this.listener = listener;\n    this.targetGroup = targetGroup;\n\n    if (props.scaleOnTargetResponseTime) {\n      // Attach scaling policy to the service\n      this.scaleToTrackCustomMetric(\n        'TargetResponseTimeScaling',\n        targetGroup.metrics.targetResponseTime(\n          props.scaleOnTargetResponseTime.metricOptions,\n        ),\n        props.scaleOnTargetResponseTime.threshold,\n      );\n    }\n  }\n}\n"]}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "truemark-cdk-lib",
   "description": "AWS CDK constructs created by TrueMark",
-  "version": "1.21.0",
+  "version": "1.21.1-alpha.1768569999",
   "main": "index.js",
   "types": "index.d.ts",
   "author": "TrueMark Technologies, Inc.",
@@ -22,8 +22,11 @@
   ],
   "devDependencies": {
     "@eslint/js": "^9.39.1",
+    "@smithy/types": "^4.9.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^22.19.2",
+    "aws-sdk-client-mock": "^4.1.0",
+    "aws-sdk-client-mock-jest": "^4.1.0",
     "esbuild": "^0.27.1",
     "eslint": "^9.39.1",
     "jest": "^29.7.0",
@@ -33,7 +36,8 @@
     "typescript": "~5.9.3",
     "typescript-eslint": "^8.49.0",
     "@aws-sdk/util-dynamodb": "^3.947.0",
-    "@aws-sdk/client-dynamodb": "^3.947.0"
+    "@aws-sdk/client-dynamodb": "^3.947.0",
+    "@aws-sdk/client-elastic-load-balancing-v2": "^3.947.0"
   },
   "dependencies": {
     "@aws-cdk/aws-lambda-go-alpha": "^2.232.1-alpha.0",