doc2vec 1.0.0 → 1.0.2

package/config.yaml.solo

@@ -0,0 +1,251 @@
+# Doc2Vec Configuration
+sources:
+  # Local directory Sources
+  - type: local_directory
+    product_name: 'solo-reference-architectures'
+    version: 'latest'
+    path: './solo-reference-architectures'
+    include_extensions: ['.md']
+    exclude_extensions: []
+    recursive: true
+    url_rewrite_prefix: https://github.com/solo-io/solo-reference-architectures/blob/main
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'github-solo-reference-architectures'
+
+  # GitHub Sources
+  - type: github
+    product_name: 'istio'
+    version: 'latest'
+    repo: 'istio/istio'
+    start_date: '2024-01-01'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'github-istio'
+
+  - type: github
+    product_name: 'solo-projects'
+    version: 'latest'
+    repo: 'solo-io/solo-projects'
+    start_date: '2024-01-01'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'github-solo-projects'
+
+  - type: github
+    product_name: 'gloo-mesh-enterprise'
+    version: 'latest'
+    repo: 'solo-io/gloo-mesh-enterprise'
+    start_date: '2024-01-01'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'github-gloo-mesh-enterprise'
+
+  # Website Sources
+  - type: website
+    product_name: 'ambient'
+    version: 'latest'
+    url: 'https://ambientmesh.io/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'ambient'
+
+  - type: website
+    product_name: 'argo'
+    version: 'latest'
+    url: 'https://argo-cd.readthedocs.io/en/stable/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'argo'
+
+  - type: website
+    product_name: 'argo-rollouts'
+    version: 'latest'
+    url: 'https://argoproj.github.io/argo-rollouts/installation/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'argo-rollouts'
+
+  - type: website
+    product_name: 'argo-rollouts'
+    version: 'latest'
+    url: 'https://rollouts-plugin-trafficrouter-gatewayapi.readthedocs.io/en/latest/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'argo-rollouts'
+
+  - type: website
+    product_name: 'cilium'
+    version: 'latest'
+    url: 'https://docs.cilium.io/en/stable/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'cilium'
+
+  - type: website
+    product_name: 'gateway-api'
+    version: 'latest'
+    url: 'https://gateway-api.sigs.k8s.io/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'gateway-api'
+
+  - type: website
+    product_name: 'gloo-mesh-core'
+    version: 'latest'
+    url: 'https://docs.solo.io/gloo-mesh/main/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'gloo-mesh-core'
+
+  - type: website
+    product_name: 'gloo-mesh-enterprise'
+    version: 'latest'
+    url: 'https://docs.solo.io/gloo-mesh-enterprise/main/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'gloo-mesh-enterprise'
+
+  - type: website
+    product_name: 'gloo-edge'
+    version: 'latest'
+    url: 'https://docs.solo.io/gloo-edge/main/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'gloo-edge'
+
+  - type: website
+    product_name: 'gloo-gateway'
+    version: 'latest'
+    url: 'https://docs.solo.io/gateway/main/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'gloo-gateway'
+
+  - type: website
+    product_name: 'helm'
+    version: 'latest'
+    url: 'https://helm.sh/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'helm'
+
+  - type: website
+    product_name: 'istio'
+    version: 'latest'
+    url: 'https://istio.io/latest/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'istio'
+
+  - type: website
+    product_name: 'kgateway'
+    version: 'latest'
+    url: 'https://kgateway.dev/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'kgateway'
+
+  - type: website
+    product_name: 'kubernetes'
+    version: 'latest'
+    url: 'https://kubernetes.io/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'kubernetes'
+
+  - type: website
+    product_name: 'otel'
+    version: 'latest'
+    url: 'https://opentelemetry.io/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'otel'
+
+  - type: website
+    product_name: 'prometheus'
+    version: 'latest'
+    url: 'https://prometheus.io/docs/'
+    max_size: 1048576
+    database_config:
+      type: 'qdrant'
+      params:
+        qdrant_url: 'https://qdrant.is.solo.io'
+        qdrant_port: 443
+        collection_name: 'prometheus'

package/dist/doc2vec.js

@@ -593,8 +593,31 @@ class Doc2Vec {
             processedFiles.add(filePath);
             logger.info(`Processing content from ${filePath} (${content.length} chars)`);
             try {
-                // Use the file path as URL for tracking
-                const fileUrl = `file://${filePath}`;
+                // Generate URL based on configuration
+                let fileUrl;
+                if (config.url_rewrite_prefix) {
+                    // Replace local path with URL prefix
+                    const relativePath = path.relative(config.path, filePath).replace(/\\/g, '/');
+                    // If relativePath starts with '..', it means the file is outside the base directory
+                    if (relativePath.startsWith('..')) {
+                        // For files outside the configured path, use the default file:// scheme
+                        fileUrl = `file://${filePath}`;
+                        logger.debug(`File outside configured path, using default URL: ${fileUrl}`);
+                    }
+                    else {
+                        // For files inside the configured path, rewrite the URL
+                        // Handle trailing slashes in the URL prefix to avoid double slashes
+                        const prefix = config.url_rewrite_prefix.endsWith('/')
+                            ? config.url_rewrite_prefix.slice(0, -1)
+                            : config.url_rewrite_prefix;
+                        fileUrl = `${prefix}/${relativePath}`;
+                        logger.debug(`URL rewritten: ${filePath} -> ${fileUrl}`);
+                    }
+                }
+                else {
+                    // Use default file:// URL
+                    fileUrl = `file://${filePath}`;
+                }
                 const chunks = await this.chunkMarkdown(content, config, fileUrl);
                 logger.info(`Created ${chunks.length} chunks`);
                 if (chunks.length > 0) {
@@ -667,15 +690,14 @@ class Doc2Vec {
                 logger.error(`Error during chunking or embedding for ${filePath}:`, error);
             }
         }, logger);
-        logger.info(`Found ${validChunkIds.size} valid chunks across processed files for ${config.path}`);
         logger.section('CLEANUP');
         if (dbConnection.type === 'sqlite') {
             logger.info(`Running SQLite cleanup for local directory ${config.path}`);
-            this.removeObsoleteFilesSQLite(dbConnection.db, processedFiles, config.path, logger);
+            this.removeObsoleteFilesSQLite(dbConnection.db, processedFiles, config, logger);
         }
         else if (dbConnection.type === 'qdrant') {
             logger.info(`Running Qdrant cleanup for local directory ${config.path} in collection ${dbConnection.collectionName}`);
-            await this.removeObsoleteFilesQdrant(dbConnection, processedFiles, config.path, logger);
+            await this.removeObsoleteFilesQdrant(dbConnection, processedFiles, config, logger);
         }
         logger.info(`Finished processing local directory: ${config.path}`);
     }
@@ -765,6 +787,139 @@ class Doc2Vec {
             logger.error(`Error reading directory ${dirPath}:`, error);
         }
     }
+    removeObsoleteFilesSQLite(db, processedFiles, pathConfig, logger) {
+        const getChunksForPathStmt = db.prepare(`
+            SELECT chunk_id, url FROM vec_items
+            WHERE url LIKE ? || '%'
+        `);
+        const deleteChunkStmt = db.prepare(`DELETE FROM vec_items WHERE chunk_id = ?`);
+        // Determine if we're using URL rewriting or direct file paths
+        const isRewriteMode = typeof pathConfig === 'object' && pathConfig.url_rewrite_prefix;
+        // Set up the URL prefix for searching
+        let urlPrefix;
+        if (isRewriteMode) {
+            // Handle URL rewriting case
+            urlPrefix = pathConfig.url_rewrite_prefix || '';
+            urlPrefix = urlPrefix.endsWith('/') ? urlPrefix.slice(0, -1) : urlPrefix;
+        }
+        else {
+            // Handle direct file path case
+            const dirPrefix = typeof pathConfig === 'string' ? pathConfig : pathConfig.path;
+            const cleanedDirPrefix = dirPrefix.replace(/^\.\/+/, '');
+            urlPrefix = `file://${cleanedDirPrefix}`;
+        }
+        logger.debug(`Searching for chunks with URL prefix: ${urlPrefix}`);
+        const existingChunks = getChunksForPathStmt.all(urlPrefix);
+        let deletedCount = 0;
+        const transaction = db.transaction(() => {
+            for (const { chunk_id, url } of existingChunks) {
+                // Skip if it's not from our URL prefix (safety check)
+                if (!url.startsWith(urlPrefix))
+                    continue;
+                let filePath;
+                let shouldDelete = false;
+                if (isRewriteMode) {
+                    // URL rewrite mode: extract relative path and construct full file path
+                    const config = pathConfig;
+                    const relativePath = url.substring(urlPrefix.length + 1); // +1 for the '/'
+                    filePath = path.join(config.path, relativePath);
+                    shouldDelete = !processedFiles.has(filePath);
+                }
+                else {
+                    // Direct file path mode: remove file:// prefix to match with processedFiles
+                    filePath = url.substring(7); // Remove 'file://' prefix
+                    shouldDelete = !processedFiles.has(filePath);
+                }
+                if (shouldDelete) {
+                    logger.debug(`Deleting obsolete chunk from SQLite: ${chunk_id.substring(0, 8)}... (File not processed: ${filePath})`);
+                    deleteChunkStmt.run(chunk_id);
+                    deletedCount++;
+                }
+            }
+        });
+        transaction();
+        logger.info(`Deleted ${deletedCount} obsolete chunks from SQLite for URL prefix ${urlPrefix}`);
+    }
+    async removeObsoleteFilesQdrant(db, processedFiles, pathConfig, logger) {
+        const { client, collectionName } = db;
+        try {
+            // Determine if we're using URL rewriting or direct file paths
+            const isRewriteMode = typeof pathConfig === 'object' && pathConfig.url_rewrite_prefix;
+            // Set up the URL prefix for searching
+            let urlPrefix;
+            if (isRewriteMode) {
+                // Handle URL rewriting case
+                urlPrefix = pathConfig.url_rewrite_prefix || '';
+                urlPrefix = urlPrefix.endsWith('/') ? urlPrefix.slice(0, -1) : urlPrefix;
+            }
+            else {
+                // Handle direct file path case
+                const dirPrefix = typeof pathConfig === 'string' ? pathConfig : pathConfig.path;
+                const cleanedDirPrefix = dirPrefix.replace(/^\.\/+/, '');
+                urlPrefix = `file://${cleanedDirPrefix}`;
+            }
+            logger.debug(`Checking for obsolete chunks with URL prefix: ${urlPrefix}`);
+            const response = await client.scroll(collectionName, {
+                limit: 10000,
+                with_payload: true,
+                with_vector: false,
+                filter: {
+                    must: [
+                        {
+                            key: "url",
+                            match: {
+                                text: urlPrefix
+                            }
+                        }
+                    ],
+                    must_not: [
+                        {
+                            key: "is_metadata",
+                            match: {
+                                value: true
+                            }
+                        }
+                    ]
+                }
+            });
+            const obsoletePointIds = response.points
+                .filter((point) => {
+                const url = point.payload?.url;
+                // Double check it's not a metadata record
+                if (point.payload?.is_metadata === true) {
+                    return false;
+                }
+                if (!url || !url.startsWith(urlPrefix)) {
+                    return false;
+                }
+                let filePath;
+                if (isRewriteMode) {
+                    // URL rewrite mode: extract relative path and construct full file path
+                    const config = pathConfig;
+                    const relativePath = url.substring(urlPrefix.length + 1); // +1 for the '/'
+                    filePath = path.join(config.path, relativePath);
+                }
+                else {
+                    // Direct file path mode: remove file:// prefix to match with processedFiles
+                    filePath = url.startsWith('file://') ? url.substring(7) : '';
+                }
+                return filePath && !processedFiles.has(filePath);
+            })
+                .map((point) => point.id);
+            if (obsoletePointIds.length > 0) {
+                await client.delete(collectionName, {
+                    points: obsoletePointIds,
+                });
+                logger.info(`Deleted ${obsoletePointIds.length} obsolete chunks from Qdrant for URL prefix ${urlPrefix}`);
+            }
+            else {
+                logger.info(`No obsolete chunks to delete from Qdrant for URL prefix ${urlPrefix}`);
+            }
+        }
+        catch (error) {
+            logger.error(`Error removing obsolete chunks from Qdrant:`, error);
+        }
+    }
     async initDatabase(config, parentLogger) {
         const logger = parentLogger.child('database');
         const dbConfig = config.database_config;
@@ -938,85 +1093,6 @@ class Doc2Vec {
         transaction();
         logger.info(`Deleted ${deletedCount} obsolete chunks from SQLite for URL ${urlPrefix}`);
     }
-    removeObsoleteFilesSQLite(db, processedFiles, dirPrefix, logger) {
-        const getChunksForDirStmt = db.prepare(`
-            SELECT chunk_id, url FROM vec_items
-            WHERE url LIKE 'file://%' AND url LIKE ?
-        `);
-        const deleteChunkStmt = db.prepare(`DELETE FROM vec_items WHERE chunk_id = ?`);
-        const cleanedDirPrefix = dirPrefix.replace(/^\.\/+/, '');
-        const filePrefix = `file://${cleanedDirPrefix}`;
-        const existingChunks = getChunksForDirStmt.all(`${filePrefix}%`);
-        let deletedCount = 0;
-        const transaction = db.transaction(() => {
-            for (const { chunk_id, url } of existingChunks) {
-                // Remove file:// prefix to match with processedFiles
-                const filePath = url.substring(7);
-                if (!processedFiles.has(filePath)) {
-                    logger.debug(`Deleting obsolete chunk from SQLite: ${chunk_id.substring(0, 8)}... (File not processed)`);
-                    deleteChunkStmt.run(chunk_id);
-                    deletedCount++;
-                }
-            }
-        });
-        transaction();
-        logger.info(`Deleted ${deletedCount} obsolete chunks from SQLite for directory ${dirPrefix}`);
-    }
-    async removeObsoleteFilesQdrant(db, processedFiles, dirPrefix, logger) {
-        const { client, collectionName } = db;
-        try {
-            const cleanedDirPrefix = dirPrefix.replace(/^\.\/+/, '');
-            const filePrefix = `file://${cleanedDirPrefix}`;
-            // Get all points that match the file prefix but are not metadata points
-            const response = await client.scroll(collectionName, {
-                limit: 10000,
-                with_payload: true,
-                with_vector: false,
-                filter: {
-                    must: [
-                        {
-                            key: "url",
-                            match: {
-                                text: `${filePrefix}`
-                            }
-                        }
-                    ],
-                    must_not: [
-                        {
-                            key: "is_metadata",
-                            match: {
-                                value: true
-                            }
-                        }
-                    ]
-                }
-            });
-            const obsoletePointIds = response.points
-                .filter((point) => {
-                const url = point.payload?.url;
-                // Double check it's not a metadata record
-                if (point.payload?.is_metadata === true) {
-                    return false;
-                }
-                // Remove file:// prefix to match with processedFiles
-                const filePath = url && url.startsWith('file://') ? url.substring(7) : '';
-                return filePath && !processedFiles.has(filePath);
-            })
-                .map((point) => point.id);
-            if (obsoletePointIds.length > 0) {
-                await client.delete(collectionName, {
-                    points: obsoletePointIds,
-                });
-                logger.info(`Deleted ${obsoletePointIds.length} obsolete chunks from Qdrant for directory ${dirPrefix}`);
-            }
-            else {
-                logger.info(`No obsolete chunks to delete from Qdrant for directory ${dirPrefix}`);
-            }
-        }
-        catch (error) {
-            logger.error(`Error removing obsolete chunks from Qdrant:`, error);
-        }
-    }
     isValidUuid(str) {
         const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
         return uuidRegex.test(str);

package/dist/solo-reference-architectures/Gloo_Edge/ALB_Last_Mile_Encryption/data/acm-waf-cdk/lib/acm-cdk-stack.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ACMCdkStack = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+class ACMCdkStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (!process.env.DOMAIN_NAME) {
+            throw new Error("DOMAIN_NAME environment variable is not defined");
+        }
+        const hostedZone = props.hostedZone;
+        const edgeSiteDomainName = "apps." + process.env.DOMAIN_NAME;
+        this.acmCertificate = new aws_cdk_lib_1.aws_certificatemanager.Certificate(this, 'SiteCertificate', {
+            domainName: edgeSiteDomainName,
+            validation: aws_cdk_lib_1.aws_certificatemanager.CertificateValidation.fromDns(hostedZone),
+        });
+        new aws_cdk_lib_1.CfnOutput(this, 'ACMCertificate', { value: this.acmCertificate.certificateArn });
+    }
+}
+exports.ACMCdkStack = ACMCdkStack;

package/dist/solo-reference-architectures/Gloo_Edge/ALB_Last_Mile_Encryption/data/acm-waf-cdk/lib/route53-cdk-stack.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Route53CdkStack = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+class Route53CdkStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        if (!process.env.PARENT_DOMAIN_NAME) {
+            throw new Error("PARENT_DOMAIN_NAME environment variable is not defined");
+        }
+        if (!process.env.DOMAIN_NAME) {
+            throw new Error("DOMAIN_NAME environment variable is not defined");
+        }
+        this.hostedZone = new aws_cdk_lib_1.aws_route53.PublicHostedZone(this, "HostedZone", {
+            zoneName: process.env.DOMAIN_NAME,
+            comment: "Managed by CDK"
+        });
+        const parent = aws_cdk_lib_1.aws_route53.HostedZone.fromLookup(this, "ParentHostedZone", {
+            domainName: process.env.PARENT_DOMAIN_NAME + "."
+        });
+        if (!this.hostedZone.hostedZoneNameServers) {
+            throw new Error("NS record is undefined.");
+        }
+        new aws_cdk_lib_1.aws_route53.ZoneDelegationRecord(this, "NS", {
+            zone: parent,
+            recordName: process.env.DOMAIN_NAME,
+            nameServers: this.hostedZone.hostedZoneNameServers,
+            comment: "Managed by CDK"
+        });
+        new aws_cdk_lib_1.CfnOutput(this, 'ZoneId', { value: this.hostedZone.hostedZoneId });
+    }
+}
+exports.Route53CdkStack = Route53CdkStack;

package/dist/solo-reference-architectures/Gloo_Edge/ALB_Last_Mile_Encryption/data/acm-waf-cdk/lib/waf-cdk-stack.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WAFCdkStack = void 0;
+const aws_cdk_lib_1 = require("aws-cdk-lib");
+class WAFCdkStack extends aws_cdk_lib_1.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const webAcl = new aws_cdk_lib_1.aws_wafv2.CfnWebACL(this, 'RateLimitWebAcl', {
+            description: 'WebACL to rate limit the calls',
+            defaultAction: { allow: {} },
+            scope: 'REGIONAL',
+            visibilityConfig: {
+                metricName: 'RateLimitWebAclMetric',
+                cloudWatchMetricsEnabled: true,
+                sampledRequestsEnabled: true,
+            },
+            rules: [
+                {
+                    // rate limit to 100 based on IP within 5 minutes
+                    name: 'AWSRateLimitRuleSet',
+                    priority: 1,
+                    action: { block: {} },
+                    visibilityConfig: {
+                        metricName: "AWSRateLimitIP",
+                        cloudWatchMetricsEnabled: true,
+                        sampledRequestsEnabled: false
+                    },
+                    statement: {
+                        rateBasedStatement: {
+                            aggregateKeyType: "IP",
+                            limit: 100,
+                            evaluationWindowSec: 300
+                        }
+                    }
+                },
+                {
+                    // common rule set
+                    name: 'AWSManagedRulesCommonRuleSet',
+                    priority: 2,
+                    overrideAction: { none: {} },
+                    visibilityConfig: {
+                        metricName: 'AWSManagedRulesCommonRuleSetMetric',
+                        cloudWatchMetricsEnabled: true,
+                        sampledRequestsEnabled: true
+                    },
+                    statement: {
+                        managedRuleGroupStatement: {
+                            vendorName: 'AWS',
+                            name: 'AWSManagedRulesCommonRuleSet'
+                        }
+                    }
+                }
+            ]
+        });
+        const alb = aws_cdk_lib_1.aws_elasticloadbalancingv2.ApplicationLoadBalancer.fromLookup(this, 'ALBListener', {
+            loadBalancerTags: {
+                'elbv2.k8s.aws/cluster': process.env.CLUSTER_OWNER + '-' + process.env.PROJECT
+            }
+        });
+        new aws_cdk_lib_1.aws_wafv2.CfnWebACLAssociation(this, "ALBWebACLAssociation", {
+            webAclArn: webAcl.attrArn,
+            resourceArn: alb.loadBalancerArn
+        });
+    }
+}
+exports.WAFCdkStack = WAFCdkStack;

package/dist/solo-reference-architectures/Gloo_Edge/ALB_Last_Mile_Encryption/data/acm-waf-cdk/test/s3-cloudfront-cdk.test.js

@@ -0,0 +1,16 @@
+"use strict";
+// import * as cdk from 'aws-cdk-lib';
+// import { Template } from 'aws-cdk-lib/assertions';
+// import * as S3CloudfrontCdk from '../lib/s3-cloudfront-cdk-stack';
+// example test. To run these tests, uncomment this file along with the
+// example resource in lib/s3-cloudfront-cdk-stack.ts
+test('SQS Queue Created', () => {
+    //   const app = new cdk.App();
+    //     // WHEN
+    //   const stack = new S3CloudfrontCdk.S3CloudfrontCdkStack(app, 'MyTestStack');
+    //     // THEN
+    //   const template = Template.fromStack(stack);
+    //   template.hasResourceProperties('AWS::SQS::Queue', {
+    //     VisibilityTimeout: 300
+    //   });
+});