ecs-pf/dist/inference/cluster-inference.js

CLI for port-forwarding to RDS via AWS ECS

import { splitByHyphenUnderscore, splitByWordSeparators } from "../regex.js";
export function inferClustersFromRDSName(params) {
    const { rdsName, allClusters } = params;
    const rdsSegments = splitByHyphenUnderscore(rdsName.toLowerCase());
    const rdsWords = splitByWordSeparators(rdsName.toLowerCase());
    const rdsLower = rdsName.toLowerCase();
    const envIndicators = [
        "dev",
        "development",
        "staging",
        "stage",
        "stg",
        "prod",
        "production",
        "test",
    ];
    const commonPatterns = [
        "app",
        "web",
        "api",
        "service",
        "backend",
        "frontend",
    ];
    return allClusters
        .map((cluster) => {
        const clusterName = cluster.clusterName.toLowerCase();
        const scoreCalculations = [
            { condition: clusterName === rdsLower, score: 100 },
            {
                condition: clusterName.startsWith(rdsLower) ||
                    rdsLower.startsWith(clusterName),
                score: 80,
            },
            { condition: clusterName.includes(rdsLower), score: 70 },
            {
                condition: rdsLower.includes(clusterName) && clusterName.length > 3,
                score: 60,
            },
        ];
        const segmentScore = rdsSegments.filter((segment) => segment.length > 2 && clusterName.includes(segment)).length * 30;
        const wordScore = rdsWords.filter((word) => word.length > 2 && clusterName.includes(word))
            .length * 15;
        const envScore = envIndicators.filter((env) => rdsLower.includes(env) && clusterName.includes(env)).length * 25;
        const patternScore = commonPatterns.filter((pattern) => rdsLower.includes(pattern) && clusterName.includes(pattern)).length * 20;
        const baseScore = scoreCalculations
            .filter((calc) => calc.condition)
            .reduce((total, calc) => total + calc.score, 0);
        const totalScore = baseScore + segmentScore + wordScore + envScore + patternScore;
        return { clusterName: cluster.clusterName, score: totalScore };
    })
        .filter((item) => item.score > 0)
        .sort((a, b) => b.score - a.score)
        .map((item) => item.clusterName);
}