#!/bin/bash
# Description: Check latest versions and security advisories for dependencies

# Check NPM for latest versions
echo "Checking latest versions..."
npm view webflow-api version
npm view @pipedream/platform version

# Check for known vulnerabilities
echo "Checking for vulnerabilities..."
npm audit --package-lock-only <<EOF
{
  "dependencies": {
    "@pipedream/platform": "^3.0.3",
    "webflow-api": "2.4.2"
  }
}
EOF

# Check GitHub Advisory Database
gh api graphql -f query='
{
  securityVulnerabilities(first: 5, ecosystem: NPM, package: "webflow-api") {
    nodes {
      advisory {
        summary
        severity
        publishedAt
      }
      vulnerableVersionRange
      firstPatchedVersion {
        identifier
      }
    }
  }
}'

#!/bin/bash
# Description: Check version patterns across V2 components
# Expected: Consistent use of dynamic versioning

rg -g "webflow_v2/**/*.{mjs,js}" 'version:.*".*"' -A 1

#!/bin/bash
# Let's try a different approach to find version patterns
# First, let's verify the directory structure
fd . components/webflow_v2/

# Then search for version patterns in the found files
fd . components/webflow_v2/ -t f -e mjs -e js --exec grep -l "version:" {} \; | while read -r file; do
  echo "=== $file ==="
  grep -A 1 "version:" "$file"
done

#!/bin/bash
# Description: Verify the sites propDefinition in the V2 app module
# Expected: Should find the propDefinition implementation

ast-grep --pattern 'sites: {
  $$$
}' webflow_v2.app.mjs

#!/bin/bash
# Let's first find the correct path to the app file
fd -t f "webflow.*app.*" -E "*.test.*"

# Then search for prop definitions related to sites
rg -l "sites.*propDefinition" --type js

#!/bin/bash
# Now that we found the correct path, let's check the content of the V2 app file
# for any sites-related properties or methods
rg -A 5 "sites" components/webflow_v2/webflow_v2.app.mjs

# Also check for any prop definitions in general
ast-grep --pattern 'propDefinitions: {
  $$$
}' components/webflow_v2/webflow_v2.app.mjs

#!/bin/bash
# Description: Check for response handling patterns across V2 components
# Expected: Consistent response handling

# Search for getSite usage and response handling
rg -g "webflow_v2/**/*.{mjs,js}" 'getSite.*response' -B 2 -A 5

#!/bin/bash
# Let's try a broader search pattern and check the implementation
rg -g "**/*.{mjs,js}" "getSite" -B 2 -A 5

# Also check for any API response handling patterns in V2
rg -g "webflow_v2/**/*.{mjs,js}" "response" -B 2 -A 5

# Look for the app.getSite implementation
ast-grep --pattern 'getSite($$$) { $$$ }'

#!/bin/bash
# Let's check the webflow client implementation and response structure
ast-grep --pattern 'webflowClient() { $$$ }'

# Check for any response type definitions or documentation
rg -g "webflow_v2/**/*" -i "response|type|interface" -A 5 -B 2

# Look for site-related types or interfaces
ast-grep --pattern 'interface $_ { $$$ site $$$ }'

#!/bin/bash
# Description: Search for V2 collection-related breaking changes in documentation or migration guides
fd -t f . | grep -i "migration\|upgrade\|breaking" | xargs rg -l "collection"

# Description: Check for other collection-related implementations that might need similar updates
ast-grep --pattern 'listCollections($$$)'

#!/bin/bash
# Let's try a different approach to find collection-related API changes and implementations

# Check the app file for collection-related methods and their implementation
rg -A 5 "listCollections|collection" components/webflow_v2/webflow_v2.app.mjs

# Look for any V2 API documentation or breaking changes
fd -t f "README|CHANGELOG" -e md | xargs rg -i "v2.*collection|collection.*v2"

# Check the actual implementation of listCollections method
ast-grep --pattern 'async listCollections($_) {
  $$$
}'

#!/bin/bash
# Description: Check integration points with other V2 components
# Expected: Find related order components and verify consistent approach

# Look for other order-related V2 components
fd . components/webflow_v2/actions -x grep -l "order"

# Check for consistent error handling patterns across V2 components
ast-grep --pattern 'try {
  $$$
  await this.app.$_($$$)
  $$$
} catch'

#!/bin/bash
# Let's examine the error handling and response patterns in order-related components

# Check the implementation of order-related actions
for file in $(fd . components/webflow_v2/actions -t f -e mjs | grep -E 'order|Order'); do
  echo "=== $file ==="
  cat "$file"
  echo -e "\n\n"
done

# Check for consistent prop definitions
ast-grep --pattern 'props: {
  $$$
  orderId: {
    propDefinition: [
      $$$
    ],
  },
  $$$
}'

#!/bin/bash
# Description: Check order ID handling in V2 implementation
# Expected: Should find V2-specific order ID validation or transformation

# Look for order ID handling in V2 app implementation
ast-grep --pattern 'orders = {
  $$$
  type: $_,
  $$$
}'

# Check for any V2-specific order ID transformation
rg -A 5 "orderId" components/webflow_v2/webflow_v2.app.mjs

#!/bin/bash
# Check Webflow client implementation for order ID handling
rg -A 5 "orders\.(get|refund|update)" components/webflow_v2/webflow.client.mjs

# Look for any order-related types or interfaces
ast-grep --pattern 'interface $_ {
  $$$
  orderId: $_,
  $$$
}'

# Check for any order ID validation
rg -B 2 -A 5 "validateOrder|orderSchema|order.*validation" components/webflow_v2/

#!/bin/bash
# Find the Webflow client file
fd -e js -e mjs -e ts "webflow.*client"

# Look for order-related API calls in any potential client files
rg -l "orders?\.(get|refund|update)"

# Check for any order ID validation or types
rg -B 2 -A 5 "Order.*Type|OrderId|order.*interface"

#!/bin/bash
# Search for V1 order consumers that might need updates
rg -g '!*.test.{js,mjs}' -A 5 'webflow-get-order'

# Check V2 app implementation
ast-grep --pattern 'getOrder($_,$_) {
  $$$
}'

#!/bin/bash
# Let's try different search patterns and check the app implementation

# Search for the app implementation of getOrder
rg -l "getOrder.*siteId.*orderId" --type js

# Check for any usage of webflow_v2-get-order
rg -l "webflow_v2-get-order"

# Look for the V2 app file specifically
fd -e mjs -e js "webflow_v2.app"

# If found, let's see its content
cat components/webflow_v2/webflow_v2.app.mjs

#!/bin/bash
# Check if the documentation URL is correct and accessible
curl -s -I "https://developers.webflow.com/#get-order" | grep "HTTP/"

# Search for other version templates to confirm consistency
rg -g '*.{js,mjs}' '"version":\s*"0\.0\.\{\{ts\}\}"'

#!/bin/bash
# Let's verify the correct documentation URL for Webflow V2 API
rg -g '*.{md,mjs}' -i "webflow.*v2.*api.*documentation|webflow.*api.*v2"

# Check other Webflow V2 components for documentation links
fd -e mjs -p 'webflow_v2' --exec grep -l "docs here" {}

# Check version pattern usage across Webflow V2 components
fd -e mjs -p 'webflow_v2' --exec grep -l "version.*{{ts}}" {}

# Look for the app file to check API version details
fd webflow_v2.app.mjs -x cat {}

#!/bin/bash
# Let's check one of the other Webflow V2 actions to see their documentation links
fd -e mjs -p 'webflow_v2/actions' -x grep -A 1 "description.*docs here" {}

# Check the webflow-api package for API endpoint documentation
cat package.json | grep -A 5 "webflow-api"

#!/bin/bash
# Description: Check version patterns across Webflow V2 components
# Expected: All components should follow the same versioning pattern

rg -g '*.mjs' 'version:.*' components/webflow_v2/

#!/bin/bash
# Search for components that might be using this action's output
rg -l "webflow.*list-collection-items" --type js

# Search for potential workflow configurations using this action
rg -l "webflow.*list-collection-items" --type json

#!/bin/bash
# Let's try a broader search to find any references to this action
rg -l "webflow_v2-list-collection-items"

# Also search for potential usage of the component's key
rg "webflow.*list.*collection.*items" -i

#!/bin/bash
# Let's check if there's a v1 version of this action and compare the implementations
fd "list-collection-items" components/webflow/

# Also check the webflow v1 app file for the corresponding API method
rg "listCollectionItems" components/webflow/

#!/bin/bash
# Search for prop definitions in the app module
ast-grep --pattern 'export default {
  $$$
  propDefinitions: {
    $$$
    sites: {
      $$$
    },
    domains: {
      $$$
    },
    $$$
  }
}'

#!/bin/bash
# Let's try a different approach to find the app module and its prop definitions
# First, find the app.mjs file in the same directory
fd -e mjs app.mjs $(dirname "components/webflow_v2/actions/publish-site/publish-site.mjs")

# Then let's search for prop definitions with ripgrep for better context
rg -U "propDefinitions.*sites|propDefinitions.*domains" --type js -A 10

#!/bin/bash
# Let's try to find the app module in the webflow_v2 component directory
fd app.mjs components/webflow_v2

# Once we find it, let's look at its content focusing on propDefinitions
rg -l "propDefinitions" components/webflow_v2

#!/bin/bash
# Now that we found the app module, let's examine its content
cat components/webflow_v2/webflow_v2.app.mjs | grep -A 20 "propDefinitions"

#!/bin/bash
# Search for similar version patterns in other files
rg -g '*.{js,mjs}' '"version":\s*"[^"]*\{\{ts\}\}"'

#!/bin/bash
# Let's try a broader search for version patterns and {{ts}} usage
echo "=== Searching for version patterns ==="
rg -g '*.{js,mjs}' 'version:.*"[^"]*"'

echo -e "\n=== Searching for {{ts}} usage ==="
rg -g '*.{js,mjs}' '\{\{ts\}\}'

echo -e "\n=== Looking for version-related code in the same directory ==="
fd . components/webflow_v2/actions/publish-site/ -t f -x cat {}

#!/bin/bash
# Look for any implementation files that might handle the version placeholder
echo "=== Searching for version placeholder handling ==="
rg -g '*.{js,mjs}' -l "version.*ts" components/webflow_v2/

echo -e "\n=== Looking for app implementation ==="
cat components/webflow_v2/webflow_v2.app.mjs || true

echo -e "\n=== Looking for common code ==="
cat components/webflow_v2/common/ || true

#!/bin/bash
# Check for any timestamp-related code in common directory
echo "=== Checking common directory files ==="
fd . components/webflow_v2/common/ -t f -x cat {}

echo -e "\n=== Looking for timestamp handling in the component ==="
rg -g '*.{js,mjs}' "ts.*version|version.*ts" components/webflow_v2/

#!/bin/bash
# Description: Check the order statuses defined in constants
cat components/webflow_v2/actions/common/constants.mjs | grep -A 10 "ORDER_STATUSES"

#!/bin/bash
# Search for Webflow API documentation or references in the codebase
rg -i "webflow.*api.*order.*status" -g '!node_modules' -g '!dist'

# Search for any test files or documentation related to order statuses
fd -e md -e test.js -e test.mjs -e spec.js -e spec.mjs | xargs rg -l "order.*status"

#!/bin/bash
# Let's check the Webflow V2 API documentation or implementation files
rg -i "webflow.*v2.*order" -g '!node_modules' -g '!dist'

# Also check any Webflow V2 test files that might contain order status information
fd -g '*webflow*v2*.test.*' -g '*webflow*v2*.spec.*' | xargs rg -l "order.*status"

# Look for any Webflow V2 documentation files
fd -g '*webflow*v2*.md'

#!/bin/bash
# Search for other V2 order fulfillment implementations to compare parameters
rg -l "fulfillOrder" | xargs rg "propDefinition|description.*fulfill"

#!/bin/bash
# Get the full implementation of the fulfill-order action
cat components/webflow_v2/actions/fulfill-order/fulfill-order.mjs

# Also check the app.mjs for any order-related prop definitions
cat components/webflow_v2/webflow_v2.app.mjs

#!/bin/bash
# Check the webflow-api client implementation
rg -A 5 "updateFulfill.*orders" node_modules/webflow-api/

#!/bin/bash
# Description: Check for consistency in V2 component structure
# Verify import patterns
echo "Checking import patterns across V2 components:"
rg "import.*webflow_v2\.app" components/webflow_v2/

# Verify component key naming
echo "\nChecking component key naming:"
rg '"key":\s*"webflow_v2-' components/webflow_v2/

# Verify version patterns
echo "\nChecking version patterns:"
rg '"version":\s*"[^"]+"' components/webflow_v2/

#!/bin/bash
# Check if all V2 API required fields are implemented
rg -l "propDefinition.*webflow_v2" --type js

# Verify documentation links
rg "developers\.webflow\.com/#" --type js

#!/bin/bash
# Let's check the app file first to understand the API implementation
cat components/webflow_v2/webflow_v2.app.mjs

# Check the actual implementation of the update order action
cat components/webflow_v2/actions/update-order/update-order.mjs

# Search for any other V2 order-related files for comparison
fd "order" --type f --full-path components/webflow_v2

#!/bin/bash
# Description: Check naming consistency across V2 components
# Expected: All V2 components should follow similar naming pattern

# Check for consistent key naming pattern
echo "Checking component key naming consistency..."
rg -l "key: \"webflow_v2-" components/webflow_v2/

# Check for any remaining V1 references
echo "Checking for remaining V1 references..."
rg -l "key: \"webflow-" components/webflow_v2/

#!/bin/bash
# Description: Check webhook trigger type consistency
# Expected: All V2 webhook triggers should match Webflow V2 API specifications

echo "Checking webhook trigger types..."
rg "getWebhookTriggerType.*return" components/webflow_v2/

#!/bin/bash
# Let's try a broader search to understand the webhook trigger types and their usage

# Search for webhook trigger types in the webflow_v2 component
echo "Searching for webhook trigger types in webflow_v2..."
rg -A 2 "getWebhookTriggerType|triggerType|webhookTrigger" components/webflow_v2/

# Check for any Webflow V2 API documentation or configuration files
echo -e "\nSearching for Webflow V2 API related files..."
fd -e json -e md -e txt . components/webflow_v2/ | xargs rg -l "webhook|trigger|collection"

# Search for collection item related triggers
echo -e "\nSearching for collection item triggers..."
rg "collection.*item.*(?:deleted|created|updated)" components/webflow_v2/

#!/bin/bash
# Description: Search for documentation or examples of webhook trigger types
# Expected: Find confirmation of "form_submission" trigger type in V2

echo "Searching for webhook trigger type documentation:"
rg -A 5 "form_submission|webhook.*trigger" --type js

echo "Searching for other uses of _id field:"
rg "data\._id" --type js

#!/bin/bash
# Let's search for Webflow V2 API documentation and implementation details

# Search for Webflow V2 API related files and their content
echo "Searching for Webflow V2 API related files:"
fd -e mjs -e js webflow.*v2

echo "\nSearching for form submission related code in Webflow V2:"
rg -l "form.*submission" --type js

echo "\nLooking for API response handling in the new form submission source:"
cat components/webflow_v2/sources/new-form-submission/new-form-submission.mjs

echo "\nSearching for any Webflow V2 API documentation or constants:"
rg "webflow.*v2.*api" -i --type js

# Search for date handling patterns in similar components
echo "\nSearching for date handling patterns:"
rg "Date\.parse|new Date|toISOString" --type js components/webflow_v2/

#!/bin/bash
# Let's check the test event and common code for more context

echo "Checking test event data structure:"
cat components/webflow_v2/sources/new-form-submission/test-event.mjs

echo "\nChecking common code for webhook handling:"
cat components/webflow_v2/common/common.mjs

echo "\nChecking Webflow V2 app implementation:"
cat components/webflow_v2/webflow_v2.app.mjs

echo "\nSearching for any documentation links:"
rg -i "webflow.*docs|developers\.webflow\.com" --type js

#!/bin/bash
# Description: Search for any V2-specific webhook documentation or constants
# Look for webhook-related files or documentation
fd -t f -e md -e txt . | xargs rg -i "webhook.*v2|ecomm_order_changed"

# Look for webhook event definitions in code
ast-grep --pattern 'ecomm_order_changed'

#!/bin/bash
# Let's try a broader search for webhook-related files and documentation
fd -t f . | rg -l "webflow.*webhook|webhook.*webflow" -i

# Search for any references to ecommerce orders or webhooks in Webflow V2 files
fd -t f . | rg -l "webflow.*v2.*order|webflow.*v2.*webhook" -i

# Look for webhook event type definitions or constants
rg -i "const.*webhook|type.*webhook|enum.*webhook" -A 5 -B 5

# Search specifically in the Webflow V2 directory for order-related webhooks
fd . components/webflow_v2 | xargs rg "order.*webhook|webhook.*order" -i

#!/bin/bash
# Let's search specifically for Webflow V2 webhook trigger types and order-related events
rg -i "ecomm_order|order.*changed|webhook.*trigger.*type" components/webflow_v2 -A 5 -B 5

# Look for Webflow V2 API documentation or configuration files
fd -t f -e md -e js -e mjs -e json . components/webflow_v2 | xargs rg -i "trigger.*type|webhook.*event|order.*event"

# Search for webhook trigger type definitions or enums in Webflow V2 code
ast-grep --pattern 'getWebhookTriggerType() {
  $$$
}'

#!/bin/bash
# Description: Search for webhook payload handling patterns across v2 components

# Look for field access patterns in webhook handlers
rg -A 5 "data\[\"updated-on\"\]|data\._id|data\.slug" --type js

# Search for webhook payload transformations
ast-grep --pattern 'generateMeta($data) {
  $$$
}'

#!/bin/bash
# Let's try a different approach to search for webhook payload handling

# Search for files containing webhook-related code in webflow v2 components
fd . components/webflow_v2 -t f -e mjs -e js

# Look for webhook documentation or schema files
fd . components/webflow_v2 -t f -e json -e md

# Search for collection item related patterns with more context
rg -A 10 "collection.*item" components/webflow_v2

#!/bin/bash
# Description: Check for any inconsistencies in webhook registration across v2 components

# Search for webhook registration patterns
rg -A 5 "collection_item_changed|registerWebhook" --type js

# Look for webhook-related configurations
ast-grep --pattern 'getWebhookTriggerType() {
  return $_;
}'

#!/bin/bash
# Let's try a broader search for webhook-related code in the Webflow v2 components

# Search for webhook-related code in the specific component
rg -l "webhook" components/webflow_v2/sources/changed-collection-item/

# Search for common webhook patterns in v2 components
rg -A 5 "webhook|triggerType|collection.*changed" components/webflow_v2/ --type js

# List all files in the v2 component directory to understand structure
fd . components/webflow_v2/sources/changed-collection-item/

#!/bin/bash
# Let's examine the actual implementation of the changed-collection-item component

# Display the content of the component file
cat components/webflow_v2/sources/changed-collection-item/changed-collection-item.mjs

# Search for any common files that might contain shared webhook logic
fd -e mjs "common|base|webhook" components/webflow_v2/

#!/bin/bash
# Let's examine the common code that's being imported and extended

# Check the collection-common.mjs content
cat components/webflow_v2/sources/common/collection-common.mjs

# Also check the base common.mjs for any webhook-related logic
cat components/webflow_v2/sources/common/common.mjs

#!/bin/bash
# Let's check the app implementation for webhook methods and V2 API compatibility

# Check the Webflow V2 app implementation
cat components/webflow_v2/webflow_v2.app.mjs

# Check if there are any V2-specific constants
cat components/webflow_v2/common/constants.mjs

#!/bin/bash
# Description: Verify consistent naming pattern across V2 modules
# Expected: All V2 modules should use the "webflow_v2-" prefix

# Check for any inconsistencies in module key naming
fd . components/webflow_v2 -e mjs -x grep -l "key:" {} \; | xargs grep "key:" | grep -v "webflow_v2-"

# List all V2 module keys for review
echo "=== All V2 module keys ==="
fd . components/webflow_v2 -e mjs -x grep -l "key:" {} \; | xargs grep "key:"

#!/bin/bash
# Description: Search for any V2-specific metadata requirements
# Expected: Find metadata structure definitions or examples

# Search for similar metadata structures in V2 components
ast-grep --pattern 'generateMeta(data) {
  $$$
  return {
    id: $$$,
    summary: $$$,
    ts: $$$
  };
}'

# Search for any V2 metadata documentation
rg -l "metadata" components/webflow_v2

#!/bin/bash
# Let's try a broader search for metadata patterns in V2 components

# Search for any metadata-related patterns in V2 components
rg -A 5 "generateMeta" components/webflow_v2/

# Look for common.mjs or similar base files that might define metadata structure
fd common.mjs components/webflow_v2/

# Search for any documentation about metadata in markdown files
rg -l "metadata" components/webflow_v2/ -g "*.md"

# Search for other components' metadata structure
rg -A 5 "return \{(\s+)?id:" components/webflow_v2/

#!/bin/bash
# Description: Search for documentation or references about V2 webhook events
# Expected: Find confirmation that this event type is supported in V2

# Search for webhook documentation or type definitions
rg -A 5 "ecomm_inventory_changed" components/webflow_v2

# Search for any V2 API documentation references
fd . -e md -e txt | xargs grep -l "Webflow.*V2.*webhook" || echo "No direct documentation found"

#!/bin/bash
# Search for webhook registration or configuration code
ast-grep --pattern 'webhook$$$' components/webflow_v2

# Look for API version references in the component
rg -i "v2.*api|api.*v2" components/webflow_v2/sources/changed-ecommerce-inventory

# Check the base component or common files for webhook configurations
fd base.mjs -t f components/webflow_v2 -x cat {}

# Search for test files that might validate webhook functionality
fd test -e js -e mjs components/webflow_v2/sources/changed-ecommerce-inventory -x cat {}

#!/bin/bash
# Check the component's implementation for webhook handling
cat components/webflow_v2/sources/changed-ecommerce-inventory/changed-ecommerce-inventory.mjs

# Look for any API documentation or type definitions
fd . components/webflow_v2/common -x cat {}

# Search for webhook-related code in the parent directory
rg -A 5 "webhook" components/webflow_v2

#!/bin/bash
# Search for webhook trigger type definitions or constants
rg "site_publish" --type js
rg "webhook.*trigger.*type" --type js

# Look for webhook-related configuration files
fd -g "*webhook*.{js,mjs,json}" -x grep -l "trigger"

#!/bin/bash
# Let's check the Webflow V2 source files for webhook trigger types and related configurations
fd -e mjs -e js webflow.*v2 -x grep -l "trigger"

# Search for site publish related constants or configurations in Webflow V2 files
rg -t js "site.*publish" components/webflow_v2/

# Look at the implementation of getWebhookTriggerType in the specific file
cat components/webflow_v2/sources/new-site-published/new-site-published.mjs

#!/bin/bash
# Let's check the Webflow documentation reference in the component
cat components/webflow_v2/common/constants.mjs

# Check the common methods implementation
cat components/webflow_v2/sources/common/common.mjs

# Look for any test files that might validate the webhook trigger type
fd -e test.mjs -e spec.mjs webflow.*v2 -x cat {}

#!/bin/bash
# Let's check the app implementation for webhook creation and API documentation references
cat components/webflow_v2/webflow_v2.app.mjs

# Look for any other site publish related components or documentation
fd -g "*.md" -g "*.mjs" -x grep -l "site.*publish" {} \; 2>/dev/null

#!/bin/bash
# Description: Verify the common module structure and its usage across V2 components

# Check if the common module exists and examine its exports
echo "Checking common module structure:"
cat components/webflow_v2/sources/common/common.mjs

# Verify consistent usage of the common module across V2 components
echo "\nChecking common module usage patterns:"
rg -l "import common from.*common\.mjs" components/webflow_v2/

#!/bin/bash
# Description: Verify V2 API compatibility across the codebase

# Check for any remaining V1 API references
echo "Checking for V1 API references:"
rg -i "webflow.*v1|webflow.*api.*1\.0" components/webflow_v2/

# Verify consistent webhook trigger types
echo "\nChecking webhook trigger types:"
rg "getWebhookTriggerType.*collection_item" components/webflow_v2/

# Verify collection item field usage
echo "\nChecking collection item field references:"
rg -A 2 "data\._id|data\.slug|data\['created-on'\]" components/webflow_v2/

#!/bin/bash
# Check webhook trigger configuration in common code
echo "Checking common webhook configuration:"
cat components/webflow_v2/common/common.mjs

# Check V2 API base URL and version headers
echo "\nChecking API configuration:"
rg -A 5 "baseUrl|_makeRequest" components/webflow_v2/common/

# Check collection item webhook triggers specifically
echo "\nChecking collection item webhook configuration:"
ast-grep --pattern 'getWebhookTriggerType() {
  return $_;
}'

#!/bin/bash
# Check common code and API configuration
echo "Checking common code configuration:"
cat components/webflow_v2/sources/common/common.mjs

# Check webhook trigger implementations
echo "\nChecking webhook implementations:"
rg -A 2 "getWebhookTriggerType|_makeRequest" components/webflow_v2/sources/new-collection-item/

# Check API version headers
echo "\nChecking API version headers:"
rg -A 2 "accept.*application/json" components/webflow_v2/

#!/bin/bash
# Check app configuration for API version
echo "Checking app configuration:"
cat components/webflow_v2/webflow_v2.app.mjs

# Check constants for API configuration
echo "\nChecking constants:"
cat components/webflow_v2/common/constants.mjs

#!/bin/bash
# Description: Search for webhook trigger type definitions
# Expected: Find V2 webhook configuration that confirms the correct trigger type

# Search for webhook trigger type definitions
echo "Searching for webhook trigger type definitions..."
rg "ecomm_new_order" --type js

# Search for V2 webhook configuration
echo "Searching for V2 webhook configuration..."
rg "webhook.*?trigger.*?type" --type js

#!/bin/bash
# Let's try a broader search to understand webhook configurations in V2

# Search for webhook-related configurations in the current file
echo "Searching current file for webhook configurations..."
cat components/webflow_v2/sources/new-ecommerce-order/new-ecommerce-order.mjs

# Search for webhook configurations in V2 components
echo -e "\nSearching V2 components for webhook configurations..."
fd . components/webflow_v2 -t f -e mjs -x grep -l "webhook" {} \;

# Search for documentation or configuration files
echo -e "\nSearching for documentation or configuration..."
fd . components/webflow_v2 -t f -e json -x cat {} \;

#!/bin/bash
# Let's examine the common file and app file for webhook configurations

# Check the common implementation
echo "Checking common implementation..."
cat components/webflow_v2/sources/common/common.mjs

# Check the app implementation
echo -e "\nChecking app implementation..."
cat components/webflow_v2/webflow_v2.app.mjs

#!/bin/bash
# Description: Search for V2 API endpoint definitions and usage
# Expected: Find endpoint definitions that confirm the correct V2 path

# Search for API endpoint definitions
echo "Searching for API endpoint definitions..."
rg -l "sites/.*?/orders" --type js

# Search for V2 API client configuration
echo "Searching for V2 API client configuration..."
rg "webflow.*?v2.*?client" --type js

#!/bin/bash
# Let's try a different approach to search for API-related patterns

# Search for API endpoint patterns in the component
echo "Searching for API endpoint patterns in the component..."
rg -A 5 "sites.*?orders" components/webflow_v2/sources/new-ecommerce-order/

# Look for API documentation or configuration
echo "Searching for API documentation or configuration..."
fd -t f "README|config" components/webflow_v2/

# Search for base URL or API version configuration
echo "Searching for API version or base URL configuration..."
rg -A 3 "baseURL|apiVersion" components/webflow_v2/

#!/bin/bash
# Let's examine the API client implementation and base class

# Search for the API client class implementation
echo "Searching for API client implementation..."
rg -A 10 "class.*Webflow.*Client" components/webflow_v2/

# Look for HTTP client configuration or base URL setup
echo "Searching for HTTP client configuration..."
ast-grep --pattern 'class $_ {
  $$$
  constructor($_) {
    $$$
  }
  $$$
}'  components/webflow_v2/sources/new-ecommerce-order/new-ecommerce-order.mjs

# Check for any API version constants or configurations
echo "Checking for API version configurations..."
rg "v2|version" components/webflow_v2/common

#!/bin/bash
# Let's examine the component file directly for API implementation details

# Display the content of the component file
echo "Examining the component implementation..."
cat components/webflow_v2/sources/new-ecommerce-order/new-ecommerce-order.mjs

# Look for any app configuration files
echo "Checking for app configuration..."
fd -t f "app.mjs|app.js" components/webflow_v2/

# Search for any API-related constants
echo "Searching for API constants..."
rg -A 3 "const.*API|const.*URL" components/webflow_v2/

#!/bin/bash
# Let's examine the app configuration file and common module

# Display the app configuration
echo "Examining the app configuration..."
cat components/webflow_v2/webflow_v2.app.mjs

# Display the common module
echo "Examining the common module..."
cat components/webflow_v2/common/common.mjs

# Search for HTTP client setup
echo "Searching for HTTP client setup..."
rg -A 5 "_makeRequest|baseUrl" components/webflow_v2/