aws-inventory-manager 0.13.2__py3-none-any.whl → 0.16.0__py3-none-any.whl

src/storage/group_store.py

@@ -485,7 +485,8 @@ class GroupStore:
             params.append(region_filter)
 
         query = f"""
-            SELECT r.arn, r.resource_type, r.name, r.canonical_name
+            SELECT r.arn, r.resource_type, r.name, r.canonical_name,
+                   r.normalized_name, r.normalization_method
             FROM resources r
             WHERE {" AND ".join(conditions)}
             ORDER BY r.resource_type, r.name
@@ -494,17 +495,24 @@ class GroupStore:
         resource_rows = self.db.fetchall(query, tuple(params))
 
         # Create group with members
-        # Use canonical_name (logical ID) when available for stable matching
+        # Choose the best match strategy based on how the resource was normalized
         members = []
         for row in resource_rows:
             physical_name = row["name"] or extract_resource_name(row["arn"], row["resource_type"])
-            canonical_name = row.get("canonical_name")
+            normalized_name = row.get("normalized_name")
+            normalization_method = row.get("normalization_method") or "none"
 
-            # If canonical_name differs from physical_name, it's a CloudFormation logical ID
-            if canonical_name and canonical_name != physical_name:
-                resource_name = canonical_name
+            # Choose match strategy based on normalization method
+            if normalization_method == "tag:logical-id":
+                # CloudFormation logical ID - most reliable
+                resource_name = row.get("canonical_name") or normalized_name
                 match_strategy = "logical_id"
+            elif normalization_method in ("tag:Name", "pattern"):
+                # Name tag or pattern extraction - use normalized name
+                resource_name = normalized_name or physical_name
+                match_strategy = "normalized"
             else:
+                # No normalization - use physical name
                 resource_name = physical_name
                 match_strategy = "physical_name"
 
@@ -672,10 +680,12 @@ class GroupStore:
         # Use NOT EXISTS to find resources not in group
         # Match strategy determines how to compare:
         # - 'logical_id': match on canonical_name (CloudFormation logical ID)
+        # - 'normalized': match on normalized_name (pattern-stripped semantic name)
         # - 'physical_name': match on physical name or ARN
         rows = self.db.fetchall(
             """
-            SELECT r.arn, r.resource_type, r.name, r.region, r.created_at, r.canonical_name
+            SELECT r.arn, r.resource_type, r.name, r.region, r.created_at,
+                   r.canonical_name, r.normalized_name, r.normalization_method
             FROM resources r
             WHERE r.snapshot_id = ?
                 AND NOT EXISTS (
@@ -684,6 +694,7 @@ class GroupStore:
                     AND r.resource_type = gm.resource_type
                     AND (
                         (gm.match_strategy = 'logical_id' AND r.canonical_name = gm.resource_name)
+                        OR (gm.match_strategy = 'normalized' AND r.normalized_name = gm.resource_name)
                         OR (COALESCE(gm.match_strategy, 'physical_name') = 'physical_name' AND COALESCE(r.name, r.arn) = gm.resource_name)
                     )
                 )
@@ -727,14 +738,17 @@ class GroupStore:
         # Use INNER JOIN to find resources in group
         # Match strategy determines how to compare:
         # - 'logical_id': match on canonical_name (CloudFormation logical ID)
+        # - 'normalized': match on normalized_name (pattern-stripped semantic name)
         # - 'physical_name': match on physical name or ARN
         rows = self.db.fetchall(
             """
-            SELECT r.arn, r.resource_type, r.name, r.region, r.created_at, r.canonical_name
+            SELECT r.arn, r.resource_type, r.name, r.region, r.created_at,
+                   r.canonical_name, r.normalized_name, r.normalization_method
             FROM resources r
             INNER JOIN resource_group_members gm
                 ON (
                     (gm.match_strategy = 'logical_id' AND r.canonical_name = gm.resource_name)
+                    OR (gm.match_strategy = 'normalized' AND r.normalized_name = gm.resource_name)
                     OR (COALESCE(gm.match_strategy, 'physical_name') = 'physical_name' AND COALESCE(r.name, r.arn) = gm.resource_name)
                 )
                 AND r.resource_type = gm.resource_type

src/storage/resource_store.py

@@ -90,6 +90,9 @@ class ResourceStore:
                 r.config_hash,
                 r.created_at,
                 r.source,
+                r.canonical_name,
+                r.normalized_name,
+                r.normalization_method,
                 s.name as snapshot_name,
                 s.created_at as snapshot_created_at,
                 s.account_id

src/storage/schema.py

@@ -1,6 +1,6 @@
 """SQLite schema definitions for AWS Inventory Manager."""
 
-SCHEMA_VERSION = "1.1.0"
+SCHEMA_VERSION = "1.2.0"
 
 # Schema creation SQL
 SCHEMA_SQL = """
@@ -40,6 +40,9 @@ CREATE TABLE IF NOT EXISTS resources (
     created_at TIMESTAMP,
     source TEXT DEFAULT 'direct_api',
     canonical_name TEXT,
+    normalized_name TEXT,
+    extracted_patterns TEXT,
+    normalization_method TEXT,
     FOREIGN KEY (snapshot_id) REFERENCES snapshots(id) ON DELETE CASCADE,
     UNIQUE(snapshot_id, arn)
 );
@@ -190,6 +193,7 @@ CREATE INDEX IF NOT EXISTS idx_resources_created ON resources(created_at);
 CREATE INDEX IF NOT EXISTS idx_resources_snapshot ON resources(snapshot_id);
 CREATE INDEX IF NOT EXISTS idx_resources_type_region ON resources(resource_type, region);
 CREATE INDEX IF NOT EXISTS idx_resources_canonical_name_type ON resources(canonical_name, resource_type);
+CREATE INDEX IF NOT EXISTS idx_resources_normalized_name_type ON resources(normalized_name, resource_type);
 
 -- Tags indexes (for efficient tag queries)
 CREATE INDEX IF NOT EXISTS idx_tags_resource ON resource_tags(resource_id);
@@ -266,6 +270,53 @@ MIGRATIONS = {
         WHERE canonical_name IS NULL
         """,
     ],
+    "1.2.0": [
+        # Add normalized_name column for pattern-stripped names
+        "ALTER TABLE resources ADD COLUMN normalized_name TEXT",
+        # Add extracted_patterns column for storing what was stripped (JSON)
+        "ALTER TABLE resources ADD COLUMN extracted_patterns TEXT",
+        # Add normalization_method column for tracking how normalization was done
+        "ALTER TABLE resources ADD COLUMN normalization_method TEXT",
+        # Backfill normalized_name from CloudFormation logical-id tag
+        """
+        UPDATE resources
+        SET normalized_name = (
+            SELECT value FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'aws:cloudformation:logical-id'
+        ),
+        normalization_method = 'tag:logical-id'
+        WHERE normalized_name IS NULL
+        AND EXISTS (
+            SELECT 1 FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'aws:cloudformation:logical-id'
+        )
+        """,
+        # Backfill from Name tag
+        """
+        UPDATE resources
+        SET normalized_name = (
+            SELECT value FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'Name'
+        ),
+        normalization_method = 'tag:Name'
+        WHERE normalized_name IS NULL
+        AND EXISTS (
+            SELECT 1 FROM resource_tags
+            WHERE resource_tags.resource_id = resources.id
+            AND key = 'Name'
+        )
+        """,
+        # Fallback to physical name (pattern extraction needs Python, done on re-snapshot)
+        """
+        UPDATE resources
+        SET normalized_name = COALESCE(name, arn),
+            normalization_method = 'none'
+        WHERE normalized_name IS NULL
+        """,
+    ],
 }
 
 

src/storage/snapshot_store.py

@@ -6,6 +6,7 @@ from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Dict, List, Optional
 
+from ..matching import ResourceNormalizer
 from ..models.resource import Resource
 from ..models.snapshot import Snapshot
 from .database import Database, json_deserialize, json_serialize
@@ -54,6 +55,9 @@ class SnapshotStore:
         Returns:
             Database ID of saved snapshot
         """
+        # Create normalizer for computing normalized names
+        normalizer = ResourceNormalizer()
+
         with self.db.transaction() as cursor:
             # Insert snapshot
             cursor.execute(
@@ -83,13 +87,23 @@ class SnapshotStore:
 
             # Insert resources
             for resource in snapshot.resources:
+                # Compute canonical name (for backward compatibility)
                 canonical = compute_canonical_name(resource.name, resource.tags, resource.arn)
+
+                # Compute normalized name with pattern extraction
+                norm_result = normalizer.normalize_single(
+                    resource.name,
+                    resource.resource_type,
+                    resource.tags,
+                )
+
                 cursor.execute(
                     """
                     INSERT INTO resources (
                         snapshot_id, arn, resource_type, name, region,
-                        config_hash, raw_config, created_at, source, canonical_name
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                        config_hash, raw_config, created_at, source, canonical_name,
+                        normalized_name, extracted_patterns, normalization_method
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
                     """,
                     (
                         snapshot_id,
@@ -102,6 +116,9 @@ class SnapshotStore:
                         resource.created_at.isoformat() if resource.created_at else None,
                         resource.source,
                         canonical,
+                        norm_result.normalized_name,
+                        json_serialize(norm_result.extracted_patterns),
+                        norm_result.method,
                     ),
                 )
                 resource_id = cursor.lastrowid

src/web/templates/pages/resources.html

@@ -122,6 +122,9 @@
         { field: 'resource_type', label: 'Type', visible: true, isBase: true, width: 160, frozen: false },
         { field: 'region', label: 'Region', visible: true, isBase: true, width: 130, frozen: false },
         { field: 'snapshot_name', label: 'Snapshot', visible: true, isBase: true, width: 180, frozen: false },
+        { field: 'canonical_name', label: 'Canonical Name', visible: false, isBase: true, width: 200, frozen: false },
+        { field: 'normalized_name', label: 'Normalized Name', visible: false, isBase: true, width: 200, frozen: false },
+        { field: 'normalization_method', label: 'Normalization Method', visible: false, isBase: true, width: 150, frozen: false },
         { field: 'tags', label: 'All Tags', visible: false, isBase: true, width: 280, frozen: false },
         { field: 'created_at', label: 'Created', visible: false, isBase: true, width: 180, frozen: false },
         { field: 'config_hash', label: 'Config Hash', visible: false, isBase: true, width: 160, frozen: false }