gatekpr_patterns/

api.rs

//! API-related patterns for Shopify API usage detection
//!
//! Includes patterns for GraphQL vs REST API usage, deprecated endpoints, and API best practices.

use crate::registry::PatternRegistry;
use once_cell::sync::Lazy;

/// Pre-built API pattern registry
pub static API_PATTERNS: Lazy<PatternRegistry> = Lazy::new(|| {
    let mut registry = PatternRegistry::new();

    // GraphQL patterns
    registry
        .register(
            "graphql_query",
            r"(?i)(query\s*\{|mutation\s*\{|gql`|graphql\()",
        )
        .unwrap();

    registry
        .register(
            "graphql_client",
            r"(?i)(GraphQL|AdminGraphqlClient|@shopify/shopify-api.*graphql|shopifyGraphQL)",
        )
        .unwrap();

    registry.register("graphql_file", r"\.graphql$").unwrap();

    registry
        .register("admin_api_graphql", r"(?i)admin/api/\d{4}-\d{2}/graphql")
        .unwrap();

    // REST API patterns (deprecated for new apps)
    registry
        .register(
            "rest_products",
            r"(?i)/admin/(api/)?\d{4}-\d{2}/products\.json",
        )
        .unwrap();

    registry
        .register("rest_orders", r"(?i)/admin/(api/)?\d{4}-\d{2}/orders\.json")
        .unwrap();

    registry
        .register(
            "rest_customers",
            r"(?i)/admin/(api/)?\d{4}-\d{2}/customers\.json",
        )
        .unwrap();

    registry
        .register("rest_generic", r"(?i)/admin/(api/)?\d{4}-\d{2}/\w+\.json")
        .unwrap();

    registry
        .register(
            "rest_client",
            r"(?i)(shopify\.rest\.|RestClient|@shopify/shopify-api.*rest)",
        )
        .unwrap();

    // Deprecated API versions (2021, 2022)
    registry
        .register("deprecated_api_2021", r"(?i)admin/api/2021-\d{2}")
        .unwrap();

    registry
        .register("deprecated_api_2022", r"(?i)admin/api/2022-\d{2}")
        .unwrap();

    registry
        .register("deprecated_api_2023_01", r"(?i)admin/api/2023-01")
        .unwrap();

    // Deprecated endpoints
    registry
        .register("deprecated_shop_json", r"(?i)/admin/shop\.json")
        .unwrap();

    registry
        .register(
            "deprecated_application_charges",
            r"(?i)/admin/application_charges",
        )
        .unwrap();

    // Storefront API
    registry
        .register(
            "storefront_api",
            r"(?i)(storefront|StorefrontAccessToken|X-Shopify-Storefront-Access-Token)",
        )
        .unwrap();

    // API scope patterns
    registry
        .register("read_products_scope", r"(?i)read_products")
        .unwrap();

    registry
        .register("write_products_scope", r"(?i)write_products")
        .unwrap();

    registry
        .register("read_customers_scope", r"(?i)read_customers")
        .unwrap();

    registry
        .register("write_customers_scope", r"(?i)write_customers")
        .unwrap();

    registry
});

/// Pattern keys for GraphQL usage
pub const GRAPHQL_KEYS: &[&str] = &[
    "graphql_query",
    "graphql_client",
    "graphql_file",
    "admin_api_graphql",
];

/// Pattern keys for REST API usage (deprecated)
pub const REST_KEYS: &[&str] = &[
    "rest_products",
    "rest_orders",
    "rest_customers",
    "rest_generic",
    "rest_client",
];

/// Pattern keys for deprecated API versions/endpoints
pub const DEPRECATED_KEYS: &[&str] = &[
    "deprecated_api_2021",
    "deprecated_api_2022",
    "deprecated_api_2023_01",
    "deprecated_shop_json",
    "deprecated_application_charges",
];

/// Check API usage in code
pub fn check_api_usage(text: &str) -> ApiUsageStatus {
    ApiUsageStatus {
        uses_graphql: API_PATTERNS.any_match(GRAPHQL_KEYS, text),
        uses_rest: API_PATTERNS.any_match(REST_KEYS, text),
        deprecated_endpoints: find_deprecated_endpoints(text),
        uses_storefront: API_PATTERNS.is_match("storefront_api", text),
    }
}

/// Find deprecated endpoints in code
fn find_deprecated_endpoints(text: &str) -> Vec<String> {
    let mut deprecated = Vec::new();

    for key in DEPRECATED_KEYS {
        if API_PATTERNS.is_match(key, text) {
            deprecated.push(key.to_string());
        }
    }

    deprecated
}

/// API usage status
#[derive(Debug, Clone, Default)]
pub struct ApiUsageStatus {
    /// Whether GraphQL API is used
    pub uses_graphql: bool,
    /// Whether REST API is used (deprecated for new apps)
    pub uses_rest: bool,
    /// List of deprecated endpoints/versions found
    pub deprecated_endpoints: Vec<String>,
    /// Whether Storefront API is used
    pub uses_storefront: bool,
}

impl ApiUsageStatus {
    /// Check if the app is API compliant (uses GraphQL, no deprecated endpoints)
    pub fn is_compliant(&self) -> bool {
        self.uses_graphql && !self.uses_rest && self.deprecated_endpoints.is_empty()
    }

    /// Get compliance status string
    pub fn status(&self) -> &'static str {
        if self.uses_rest || !self.deprecated_endpoints.is_empty() {
            "fail"
        } else if self.uses_graphql {
            "pass"
        } else {
            "warning"
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_graphql_detection() {
        let code = r#"
            const response = await client.query({
                data: gql`query { shop { name } }`,
            });
        "#;

        let status = check_api_usage(code);
        assert!(status.uses_graphql);
        assert!(!status.uses_rest);
    }

    #[test]
    fn test_rest_detection() {
        let code = r#"
            const response = await fetch('/admin/api/2024-01/products.json');
        "#;

        let status = check_api_usage(code);
        assert!(status.uses_rest);
    }

    #[test]
    fn test_deprecated_api() {
        let code = r#"
            const response = await fetch('/admin/api/2022-01/products.json');
        "#;

        let status = check_api_usage(code);
        assert!(!status.deprecated_endpoints.is_empty());
        assert!(!status.is_compliant());
    }

    #[test]
    fn test_compliant_code() {
        let code = r#"
            const client = new AdminGraphqlClient();
            const result = await client.query({
                data: gql`query { products { edges { node { id title } } } }`,
            });
        "#;

        let status = check_api_usage(code);
        assert!(status.is_compliant());
    }
}