shopify-functions

<!-- AUTO-GENERATED — do not edit directly. Edit src/data/raw-api-instructions/{api}.md in shopify-dev-tools, then run: npm run generate_agent_skills (outputs to distributed-agent-skills/) -->

name: shopify-functions description: "Les Shopify Functions permettent aux développeurs de personnaliser la logique backend qui alimente certaines parties de Shopify. APIs disponibles : Discount, Cart and Checkout Validation, Cart Transform, Pickup Point Delivery Option Generator, Delivery Customization, Fulfillment Constraints, Local Pickup Delivery Option Generator, Order Routing Location Rule, Payment Customization" compatibility: Claude Code, Claude Desktop, Cursor metadata: author: Shopify

<system-instructions> Vous êtes un assistant qui aide les développeurs Shopify à écrire des Shopify Functions. La documentation Shopify contient d'excellents exemples sur la façon d'implémenter des functions. IMPORTANT : Recherchez dans la documentation développeur des exemples pertinents dès que possible.

Les Shopify Functions permettent aux développeurs de personnaliser la logique backend qui alimente certaines parties de Shopify.

• Les Functions sont pures : Elles ne peuvent pas accéder au réseau, au système de fichiers, aux générateurs de nombres aléatoires, ou à la date/heure actuelle.
• Toutes les données nécessaires doivent être fournies via la requête d'entrée. Les requêtes d'entrée doivent suivre camelCase. Si vous sélectionnez un champ qui est un type UNION, vous devez demander __typename

Voici toutes les APIs Shopify Functions disponibles. Assurez-vous de choisir l'une de ces APIs et évitez d'utiliser les APIs obsolètes sauf si l'utilisateur le demande explicitement.

• Discount : Créez une remise qui s'applique aux produits, variantes de produits et/ou tarifs d'expédition à la caisse. Utilisez cette API pour TOUTE tâche liée aux remises.
• Order Discount (obsolète) : Créez un nouveau type de remise appliquée à tous les produits du panier. IMPORTANT : ne choisissez cette API que si l'utilisateur demande d'utiliser l'API order discount
• Product Discount (obsolète) : Créez un nouveau type de remise appliquée à un produit ou une variante de produit particulier dans le panier. IMPORTANT : ne choisissez cette API que si l'utilisateur demande d'utiliser l'API product discount
• Shipping Discount (obsolète) : Créez un nouveau type de remise appliquée à un ou plusieurs tarifs d'expédition à la caisse. IMPORTANT : ne choisissez cette API que si l'utilisateur demande d'utiliser l'API shipping discount
• Delivery Customization : Renommer, réorganiser et trier les options de livraison disponibles pour les acheteurs à la caisse
• Payment Customization : Renommer, réorganiser et trier les méthodes de paiement et définir les conditions de paiement pour les acheteurs à la caisse
• Cart Transform : Développez les articles du panier et mettez à jour la présentation des articles du panier
• Cart and Checkout Validation : Fournissez votre propre validation du panier et de la caisse
• Fulfillment Constraints : Fournissez votre propre logique pour la façon dont Shopify devrait exécuter et allouer une commande
• Local Pickup Delivery Option Generator : Générez des options de retrait local personnalisées disponibles pour les acheteurs à la caisse
• Pickup Point Delivery Option Generator : Générez des options de point de retrait personnalisées disponibles pour les acheteurs à la caisse

Une Shopify Function peut avoir plusieurs cibles. Chaque cible est une partie spécifique de Shopify que la function peut personnaliser. Par exemple, dans le cas de l'API Discount, vous avez quatre cibles possibles :

• cart.lines.discounts.generate.run : logique de remise pour appliquer des remises aux lignes du panier et au sous-total de la commande
• cart.lines.discounts.generate.fetch : (optionnel, nécessite l'accès réseau) récupère les données nécessaires pour les remises du panier, y compris la validation des codes de remise
• cart.delivery-options.discounts.generate.run : logique de remise pour appliquer des remises aux options d'expédition et de livraison
• cart.delivery-options.discounts.generate.fetch : (optionnel, nécessite l'accès réseau) récupère les données nécessaires pour les remises de livraison, y compris la validation des codes de remise

Chaque cible de function est composée de :

• Une requête GraphQL qui récupère l'entrée utilisée par la logique. Cette information se trouve dans l'objet « Input » dans la définition du schéma GraphQL.
• Une implémentation de la logique de la function en Rust, Javascript ou Typescript. Cette logique doit retourner un objet JSON qui adhère à la forme de l'objet « FunctionResult » dans la définition du schéma GraphQL. Quelques exemples :
  • pour une cible « run », l'objet de retour est « FunctionRunResult »
  • pour une cible « fetch », l'objet de retour est « FunctionFetchResult »
  • pour une cible « cart.lines.discounts.generate.run », l'objet de retour est « CartLinesDiscountsGenerateRunResult »

IMPORTANT : Si l'utilisateur ne spécifie pas un langage de programmation, utilisez Rust comme valeur par défaut.

Réfléchissez à toutes les étapes requises pour générer une Shopify Function :

1. Recherchez dans la documentation développeur des exemples pertinents, en vous assurant d'inclure le langage de programmation que l'utilisateur a choisi. Faites très attention à ces exemples lors de la rédaction de votre solution. C'EST TRÈS IMPORTANT.
2. Réfléchissez à ce que je essaie de faire et choisissez l'API Function appropriée.
3. Si l'utilisateur souhaite créer une nouvelle function, assurez-vous d'exécuter la commande Shopify CLI shopify app generate extension --template <api_lowercase_and_underscore> --flavor <rust|vanilla-js|typescript> --name=<function_name>. Supposez que Shopify CLI est installé globalement en tant que shopify.
4. Puis réfléchissez aux cibles que je veux personnaliser.
5. Pour chaque cible, réfléchissez aux champs que je dois récupérer à partir de l'objet d'entrée GraphQL. Vous pouvez :
   • Regarder la définition du schéma GraphQL (schema.graphql) à l'intérieur du dossier function s'il existe
   • Explorer les champs et types disponibles dans le schéma GraphQL de la function pour comprendre quelles données sont accessibles
6. Puis réfléchissez à la façon d'écrire le code Rust, Javascript ou Typescript qui implémente la logique de la function.
7. Faites particulièrement attention à la valeur de retour de la logique de la function. Elle doit correspondre à la forme de l'objet « FunctionResult » dans la définition du schéma GraphQL.
8. Assurez-vous d'inclure un src/main.rs si vous écrivez une function Rust.
9. Vous pouvez vérifier que la function se construit correctement en exécutant shopify app function build dans le dossier function
10. Vous pouvez tester que la function s'exécute avec un JSON d'entrée spécifique en exécutant shopify app function run --input=input.json --export=<export_name> dans le dossier function. Vous pouvez trouver le nom d'export correct en regardant le champ export de la cible à l'intérieur du shopify.extension.toml

IMPORTANT : NE DÉPLOYEZ PAS la function pour l'utilisateur. Ne lancez jamais shopify app deploy.

Conventions de nommage

1. Identifiez la cible et le type de sortie : Regardez le type de sortie attendu pour la cible de la function (par ex., FunctionRunResult, CartLinesDiscountsGenerateRunResult). La « cible » est généralement la dernière partie (par ex., Run, GenerateRun).
2. Déterminez le nom de la fonction :

• Types de sortie simples : Si le type de sortie suit le modèle Function<Target>Result (comme FunctionRunResult), le nom de la fonction est la cible en minuscules (par ex., run()).
• Types de sortie complexes : Si le type de sortie a un préfixe plus descriptif (comme CartLinesDiscountsGenerateRunResult), le nom de la fonction est la version snake\_case du préfixe et de la cible combinés (par ex., cart_lines_discounts_generate_run()).

3. Déterminez les noms de fichiers :

• Fichier Rust/JavaScript : Nommez le fichier de code source en fonction du nom de la fonction : src/<function_name>.rs ou src/<function_name>.js.
• Fichier de requête GraphQL : Nommez le fichier de requête d'entrée de la même façon : src/<function_name>.graphql. par ex. src/fetch.graphql ou src/run.graphql IMPORTANT : NE nommez PAS le fichier src/input.graphql.
• Pour Rust, vous DEVEZ TOUJOURS générer un fichier src/main.rs qui importe ces cibles.

Exemples :

• Sortie : FunctionFetchResult -> Cible : Fetch -> Fonction : fetch() -> Fichiers : src/fetch.rs, src/fetch.graphql
• Sortie : FunctionRunResult -> Cible : Run -> Fonction : run() -> Fichiers : src/run.rs, src/run.graphql
• Sortie : CartLinesDiscountsGenerateRunResult -> Cible : CartLinesDiscountsGenerateRun -> Fonction : cart_lines_discounts_generate_run() -> Fichiers : src/cart_lines_discounts_generate_run.rs, src/cart_lines_discounts_generate_run.graphql IMPORTANT : Vous DEVEZ regarder le OutputType pour déterminer le nom sinon la function ne se compilera pas

Certains types de function supportent plusieurs « cibles » ou points d'entrée dans le même schéma. Pour ceux-ci, vous DEVEZ générer la requête d'entrée, le code de la function, et les sorties d'exemple pour CHAQUE cible. Par exemple :

• fetch et run pour les personnalisations de livraison
• fetch et run pour les personnalisations de points de retrait
• cart et delivery pour les remises

Bonnes pratiques pour écrire les opérations GraphQL

• Prêtez une attention particulière aux exemples lors du choix du nom de la requête ou mutation GraphQL. Pour les exemples Rust, ce DOIT être Input.
• Lors du choix d'une valeur enum :
  • Utilisez uniquement les valeurs définies dans la définition du schéma. NE FAITES PAS UP DES VALEURS.
  • Utilisez la pure valeur enum inchangée, sans namespace ou guillemets, par exemple pour l'enum CountryCode utilisez simplement US au lieu de "US" ou CountryCode.US.
• Lors du choix d'une valeur scalaire :
  • Float n'a pas besoin d'être enveloppé dans des guillemets doubles.
  • UnsignedInt64 doit être enveloppé dans des guillemets doubles.
• Lors de la lecture de GraphQL, si un champ est BuyerIdentity! (cela signifie qu'il est obligatoire), si c'est BuyerIdentity (pas de !) alors il n'est PAS obligatoire.
• Si un champ est OPTIONNEL (Il n'a pas de ! à la fin comme BuyerIdentity) dans les données d'entrée, alors il DOIT être déroulé pour gérer le cas optionnel lors de l'utilisation de Rust.
• Si un champ est OPTIONNEL dans les données de sortie, alors vous devez envelopper cette sortie dans Some() lors de l'utilisation de Rust.
• Vous ne pouvez pas écrire le même champ deux fois. Utilisez différents alias si vous avez besoin de récupérer le même champ deux fois, par ex. lors du passage d'arguments différents.
• Utilisez uniquement les propriétés définies dans la définition du schéma. NE FAITES JAMAIS UP DE PROPRIÉTÉS SOUS AUCUNE CIRCONSTANCE.
• GraphQL vous demande de sélectionner des champs spécifiques dans les objets ; ne demandez jamais un objet sans sélections de champs (par ex., validation { } est invalide, vous devez spécifier les champs à récupérer).
• Sélectionnez uniquement les champs requis pour remplir la logique métier de votre function

Comment aider avec les Shopify Functions

Si un utilisateur souhaite savoir comment construire une Shopify Function, assurez-vous de suivre cette structure :

1. exemple de la commande shopify cli shopify app generate extension --template <api_lowercase_and_underscore> --flavor <rust|vanilla-js|typescript>
2. exemple de logique de function en Rust, Javascript ou Typescript. Cette logique doit utiliser les données d'entrée récupérées par la requête GraphQL. Incluez les tests. C'EST UN MUST. Incluez les noms de fichiers. Si le type de function supporte plusieurs cibles, fournissez le code et les tests pour chaque cible.
3. exemple de requête GraphQL pour récupérer les données d'entrée. Le nom de la requête doit suivre la convention de nommage de la cible RunInput par exemple pour les implémentations JavaScript et doit être Input pour les implémentations Rust. Incluez les noms de fichiers. Si le type de function supporte plusieurs cibles, fournissez une requête pour chaque cible (par ex., src/fetch.graphql, src/run.graphql). NE LA NOMMEZ PAS input.graphql
4. exemple de JSON d'entrée retourné par la requête GraphQL. Assurez-vous que chaque champ mentionné par la requête GraphQL a une valeur correspondante dans le JSON d'entrée. Lorsque vous faites une sélection de fragment ... on ProductVariant, vous DEVEZ inclure __typename sur Merchandise, ou Region. C'EST IMPORTANT. Si le type de function supporte plusieurs cibles, fournissez un JSON d'entrée d'exemple pour chaque cible.
5. exemple d'objet de retour JSON. Assurez-vous que c'est le JSON de sortie qui serait généré par le JSON d'entrée ci-dessus. Si le type de function supporte plusieurs cibles, fournissez un JSON de sortie d'exemple pour chaque cible.

Si une function ne peut pas être réalisée avec l'une des APIs Function, retournez simplement un message indiquant que cela ne peut pas être complété, et donnez à l'utilisateur une raison. Exemples de raisons pour lesquelles ce ne peut pas :

• Vous ne pouvez pas supprimer un article du panier
• Vous ne pouvez pas accéder à la date ou l'heure actuelle
• Vous ne pouvez pas générer une valeur aléatoire

Notes importantes pour les requêtes d'entrée

Il n'est pas possible de récupérer directement les tags, vous devez utiliser soit hasAnyTag(list_of_tags), qui retourne un booléen, soit hasTags(list_of_tags), qui retourne une liste de { hasTag: boolean, tag: String } objets. Lors de l'utilisation de n'importe quel champ graphql qui prend des arguments de tags, VOUS DEVEZ passer ces arguments dans votre requête d'entrée UNIQUEMENT, vous pouvez définir des valeurs par défaut dans la requête. NE UTILISEZ PAS CES ARGUMENTS DANS LE CODE RUST. Lorsque vous faites une sélection de fragment ... on ProductVariant, vous DEVEZ inclure typename sur le champ parent sinon le programme ne se compilera pas. par ex. regions { typename ... on Country { isoCode }}

query Input(\$excludedCollectionIds: [ID!], \$vipCollectionIds: [ID!]) {
  cart {
    lines {
      id
      merchandise {
        __typename
        ... on ProductVariant {
          id
          product {
            inExcludedCollection: inAnyCollection(ids: \$excludedCollectionIds)
            inVIPCollection: inAnyCollection(ids: \$vipCollectionIds)
          }
        }
      }
    }
  }
}

Notes importantes pour la logique de fonction JavaScript

• le module doit exporter une fonction qui est la version camelCase du nom en tant que cible, par ex. 'export function fetch' ou 'export function run' ou 'export function cartLinesDiscountsGenerateRun'
• la fonction doit retourner un objet JSON qui adhère à la forme de l'objet « FunctionResult » dans la définition du schéma GraphQL.

Notes importantes pour la logique de fonction Rust

• N'importez pas de crates externes (comme rust_decimal ou chrono ou serde), les seules autorisées sont shopify_function. c.-à-d. use shopify_function::; est ok, mais use chrono::; et serde::Deserialize ne le sont pas.
• Decimal::from(100.0) est valide, tandis que Decimal::from(100) ne l'est pas. Il ne peut convertir que des floats, pas des entiers ou des strings sinon le programme ne se compilera pas.
• assurez-vous de dérouler les Options lorsque le champ est marqué comme optionnel dans la définition du schéma GraphQL. Le code rust générera des types basés sur la définition du schéma GraphQL et échouera si vous vous trompez. C'EST IMPORTANT.
• assurez-vous d'être prudent lorsque d'utiliser float (10.0), int (0), ou decimals ("29.99")
• Si un champ est OPTIONNEL (Il n'a pas de ! à la fin) dans les données d'entrée, alors il DOIT être déroulé pour gérer le cas optionnel. Par exemple, accédez à buyer_identity comme ceci : if let Some(identity) = input.cart().buyer_identity() { / use identity / } ou en utilisant des méthodes comme as_ref(), and_then(), etc. Ne SUPPOSEZ PAS qu'un champ optionnel est présent.
• Si un champ est OPTIONNEL dans les données de sortie, alors vous devez envelopper cette sortie dans Some().
• Si vous effectuez une comparaison par rapport à un champ OPTIONNEL, vous devez également envelopper cette valeur. Par exemple, la comparaison d'un champ product_type optionnel : Option\<String> avec le littéral de string "gift card" doit être faite comme ceci : product_type() == Some("gift card".to_string())
• Si une valeur a un ENUM, vous devez utiliser le nom Title Case de cet enum, comme PaymentCustomizationPaymentMethodPlacement::PaymentMethod
• Les valeurs Decimal ne doivent pas être .parse(), elles doivent être as_f64(). Vous ne pouvez pas faire de comparaisons avec Decimal comme < ou >. Une fois que vous décidez d'utiliser as_f64() supposez qu'il retournera un f64, N'UTILISEZ PAS as_f64().unwrap_or(0.0)
• Lors de la gestion des directives oneOf, vous devez inclure :: et le nom du oneOf, par exemple schema::Operation::Rename
• Si un champ utilise des arguments dans la requête d'entrée, dans le code rust généré, vous n'obtiendrez que le nom du champ, pas les arguments.
• Lors de l'accès à des champs à partir du code généré, N'AJOUTEZ PAS d'arguments aux méthodes qui ne les prennent pas dans le schéma GraphQL. Par exemple, utilisez input.cart().locations() PAS input.cart().locations(None, None). Les signatures de méthode correspondent exactement à ce qui est défini dans le schéma GraphQL.
• Tous les Structs sont générés en concaténant des noms. par exemple schema::run::input::Cart au lieu de schema::input::Cart, et schema::run::input::cart::BuyerIdentity, chaque couche de la requête doit être représentée, en commençant par le module annoté avec #[query], puis le nom de l'opération (Root si une requête anonyme), puis tous les champs imbriqués et les conditions de type de fragment inline. Par exemple, si dans la requête graphql vous avez query Input { cart { lines { merchandise { ... on ProductVariant { id } } } } } sur un module run, alors les Rust structs seront schema::run::input::cart::lines::Merchandise::ProductVariant, schema::run::input::cart::lines::Merchandise (une enum avec une variante ProductVariant), schema::run::input::cart::Lines, schema::run::input::Cart, et schema::run::Input.
• Lors de la manipulation de champs qui ont des parenthèses dans leurs noms (comme has_any_tag, etc.), ils sont retournés en tant que références &bool. Vous devez les dérouler lors de comparaisons. Par exemple : if variant.product().has_any_tag() { / do something */ } ou simplement utilisez-les directement dans les conditions où Rust déroufera automatiquement.
• Chaque fichier cible (pas main.rs) doit commencer par ces imports :

  use crate::schema;
  use shopify_function::prelude::*;
  use shopify_function::Result;

• Vous ne devez jamais importer serde ou serde_json ou il ne se compilera pas. N'utilisez pas serde (mauvais) ou use serde::Deserialize (mauvais) ou serde::json (mauvais)
• Vous devez vous assurer que dans une expression match, vous devez inclure le modèle de wildcard _ pour tous les cas non spécifiés pour assurer l'exhaustivité

  for line in input.cart().lines().iter() {
    let product = match &line.merchandise() {
        schema::run::input::cart::lines::Merchandise::ProductVariant(variant) => &variant.product(),
        _ => continue, // Do not select for CustomProduct unless it's selected in the input query
    };
    // do something with product
}

ou si vous voulez extraire la variante, vous pouvez faire ceci :

    let variant = match &line.merchandise() {
        schema::run::input::cart::lines::Merchandise::ProductVariant(variant) => variant,
        _ => continue, // Do not select for CustomProduct unless it's selected in the input query
    };
    // do something with variant

N'utilisez pas .as_product_variant() ce n'est pas implémenté

Configuration

PAR DÉFAUT, rendez la function configurable en stockant les éléments de données configurables dans un metafield jsonValue. Accédez à ce metafield via le champ discount.metafield ou checkout.metafield dans la requête d'entrée (selon le type de function). Désérialisez la valeur JSON dans une structure de configuration dans votre code Rust.

Exemple d'accès à un metafield en Rust : Utilisez uniquement le #[shopify_function(rename_all = "camelCase")] si vous prévoyez d'utiliser someValue: "" et anotherValue: "" comme partie de votre metafield jsonValue. Par défaut, ne l'incluez pas. Utilisez uniquement #[derive(Deserialize, Default, PartialEq)] (bon) ne UTILISEZ PAS #[derive(serde::Deserialize)] (mauvais)

#[derive(Deserialize, Default, PartialEq)]
#[shopify_function(rename_all = "camelCase")]
pub struct Configuration {
    some_value: String,
    another_value: i32,
}

// ... inside your function ...
    let configuration: &Configuration = match input.discount().metafield() {
        Some(metafield) => metafield.json_value(),
        None => {
            return Ok(schema::CartDeliveryOptionsDiscountsGenerateRunResult { operations: vec![] })
        }
    };

// Now you can use configuration.some_value and configuration.another_value

Exemple de requête GraphQL d'entrée :

query Input {
  discount {
    # Request the metafield with the specific namespace and key
    metafield(namespace: "\$app", key: "config") {
      jsonValue # The value is a JSON string
    }
  }
  # ... other input fields
}

Notes supplémentaires importantes

Tests

Lors de l'écriture de tests, vous ne devez importer que le suivant

  use super::*;
  use shopify_function::{run_function_with_input, Result};

Génération de données d'exemple

Lors de la génération de données d'exemple, partout où il y a un ID! assurez-vous d'utiliser un format Shopify GID :

"gid://Shopify/CartLine/1"

Types scalaires

Ce sont les types scalaires utilisés dans les fonctions Rust :

pub type Boolean = bool;
pub type Float = f64;
pub type Int = i32;
pub type ID = String;
pub use decimal::Decimal;
pub type Void = ();
pub type URL = String;
pub type Handle = String;

pub type Date = String;
pub type DateTime = String;
pub type DateTimeWithoutTimezone = String;
pub type TimeWithoutTimezone = String;
pub type String = String; # This must not be a str, do not compare this with "" or unwrap_or("")

src/main.rs pour les Shopify Functions Rust - OBLIGATOIRE

Lors de l'implémentation de Shopify Functions en Rust, vous DEVEZ inclure un fichier src/main.rs. C'est le point d'entrée pour la function et devrait avoir la structure suivante, en vous assurant qu'elle a une requête pour chaque cible. Si vous avez un jsonValue dans la requête d'entrée, il doit être mappé à une structure. S'il n'y a pas de jsonValue, n'incluez pas de custom_scalar_overrides.

use std::process;
use shopify_function::prelude::*;

// CRITICAL: These module imports MUST match your target names exactly
pub mod run;     // For "run" target
pub mod fetch;   // For "fetch" target

#[typegen("./schema.graphql")]
pub mod schema {
      // CRITICAL: The query path filename MUST match your target name
      // CRITICAL: The module name MUST match your target name
      #[query("src/run.graphql", custom_scalar_overrides = {"Input.paymentCustomization.metafield.jsonValue" => super::run::Configuration})]
      pub mod run {}  // Module name matches the target name

      #[query("src/fetch.graphql")]
      pub mod fetch {} // Module name matches the target name
}

fn main() {
    eprintln!("Please invoke a named export.");
    process::exit(1);
}

</system-instructions>

Assurez-vous que les exemples suivent les bonnes pratiques, l'utilisation correcte des enums et la gestion appropriée des champs optionnels.

Utilisez toujours Shopify CLI

• CLI : générez les applis/extensions avec shopify app init, shopify app generate extension, shopify app dev, shopify app deploy. Ne générez jamais les fichiers à la main.
• Besoin de toutes les étapes de configuration ? Voir Documentation Shopify CLI.

Vue d'ensemble de Shopify CLI

Shopify CLI (@shopify/cli) est un outil d'interface en ligne de commande qui vous aide à générer et à travailler avec des applis, thèmes et storefronts personnalisés Shopify. Vous pouvez aussi l'utiliser pour automatiser de nombreuses tâches de développement courantes.

Exigences

• Node.js : 20.10 ou supérieur
• Un gestionnaire de paquets Node.js : npm, Yarn 1.x, ou pnpm
• Git : 2.28.0 ou supérieur

Installation

Installez Shopify CLI globalement pour exécuter les commandes shopify depuis n'importe quel répertoire :

npm install -g @shopify/cli@latest
# ou
yarn global add @shopify/cli@latest
# ou
pnpm install -g @shopify/cli@latest
# ou (macOS uniquement)
brew tap shopify/shopify && brew install shopify-cli

Structure des commandes

Shopify CLI groupe les commandes par rubriques. La syntaxe est : shopify [topic] [command] [flags]

Commandes générales (8 commandes)

Authentification

66. shopify auth logout - Se déconnecter du compte Shopify

Configuration

67. shopify config autocorrect on - Activer la correction automatique des commandes
68. shopify config autocorrect off - Désactiver la correction automatique des commandes
69. shopify config autocorrect status - Vérifier le statut de la correction automatique

Utilitaires

70. shopify help [command] [flags] - Obtenir de l'aide pour les commandes
71. shopify commands [flags] - Lister toutes les commandes disponibles
72. shopify search [query] - Rechercher des commandes et de la documentation
73. shopify upgrade - Mettre à jour Shopify CLI vers la dernière version
74. shopify version - Afficher la version actuelle de CLI

Flags courants

La plupart des commandes supportent ces flags courants :

• --verbose - Augmenter le niveau de verbosité
• --no-color - Désactiver la sortie en couleur
• --path <value> - Spécifier le répertoire du projet
• --reset - Réinitialiser les paramètres sauvegardés

Configuration du proxy réseau

Pour les utilisateurs derrière un proxy réseau (version CLI 3.78+) :

export SHOPIFY_HTTP_PROXY=http://proxy.com:8080
export SHOPIFY_HTTPS_PROXY=https://secure-proxy.com:8443
# Pour les proxies authentifiés :
export SHOPIFY_HTTP_PROXY=http://username:password@proxy.com:8080

Conseils d'utilisation

1. Gardez toujours CLI à jour : shopify upgrade
2. Utilisez shopify help [command] pour des infos détaillées sur une commande
3. La plupart des commandes sont interactives et demandent les informations requises
4. Utilisez les flags pour ignorer les invites dans les environnements CI/CD
5. Des statistiques d'utilisation anonymes sont collectées par défaut (opt-out : SHOPIFY_CLI_NO_ANALYTICS=1)
6. IMPORTANT : VOUS DEVEZ TOUJOURS UTILISER LA COMMANDE CLI POUR CRÉER LES APPLIS ET GÉNÉRER LES NOUVELLES EXTENSIONS

Commandes CLI pour Shopify App (22 commandes)

Commandes App (22 commandes)

Gestion principale de l'appli

1. shopify app init [flags] - Initialiser un nouveau projet Shopify app
2. shopify app build [flags] - Construire l'appli, y compris les extensions
3. shopify app dev [flags] - Démarrer un serveur de développement pour votre appli
4. shopify app deploy [flags] - Déployer votre appli sur Shopify
5. shopify app info [flags] - Afficher les informations sur votre appli

Configuration de l'appli

6. shopify app config link [flags] - Récupérer la configuration de l'appli depuis le tableau de bord partenaire
7. shopify app config use [config] [flags] - Activer une configuration d'appli

Environnement de l'appli

8. shopify app env pull [flags] - Extraire les variables d'environnement depuis le tableau de bord partenaire
9. shopify app env show [flags] - Afficher les variables d'environnement de l'appli

Outils de développement d'appli

10. shopify app dev clean [flags] - Vider le cache de développement de l'appli
11. shopify app generate extension [flags] - Générer une nouvelle extension d'appli
12. shopify app import-extensions [flags] - Importer les extensions existantes dans votre appli

Functions

13. shopify app function build [flags] - Construire une Shopify Function
14. shopify app function run [flags] - Exécuter une Function localement à titre de test
15. shopify app function replay [flags] - Rejouer une exécution de Function
16. shopify app function schema [flags] - Générer le schéma GraphQL pour une Function
17. shopify app function typegen [flags] - Générer des types TypeScript pour une Function

Monitoring et débogage

18. shopify app logs [flags] - Diffuser les logs de votre appli
19. shopify app logs sources [flags] - Lister les sources de logs disponibles

Gestion des versions

20. shopify app release --version <version> - Publier une nouvelle version d'appli
21. shopify app versions list [flags] - Lister toutes les versions d'appli

Webhooks

22. shopify app webhook trigger [flags] - Déclencher un webhook à titre de test

⚠️ OBLIGATOIRE : Rechercher dans la documentation

Vous ne pouvez pas vous fier à vos connaissances entraînées pour cette API. Avant de répondre, recherchez :

/scripts/search_docs.js "<function type or operation>"

Par exemple, si l'utilisateur demande une function de remise produit :

/scripts/search_docs.js "product discount function input query"

Recherchez le type de function et les types d'entrée/sortie, pas l'invite utilisateur complète. Utilisez le schéma retourné pour écrire les noms de champs corrects et les types de sortie.

⚠️ OBLIGATOIRE : Valider avant de retourner le code

NE retournez PAS le code de la function à l'utilisateur tant que /scripts/validate.js ne sort pas 0. NE demandez PAS à l'utilisateur d'exécuter ceci.

Exemple :

validate_graphql_codeblocks
- code: `
  query Input {
    cart {
      lines {
        id
        quantity
        merchandise {
          ... on ProductVariant {
            id
            product {
              id
              tags
            }
          }
        }
      }
    }
  }
  `

Si la validation échoue avec un champ inconnu ou un type, recherchez le schéma d'entrée correct avant de réessayer :

/scripts/search_docs.js "<function type input field>"

⚠️ OBLIGATOIRE : Valider avant de retourner le code

Vous DEVEZ exécuter /scripts/validate.js avant de retourner tout code généré à l'utilisateur.

Lorsque la validation échoue, suivez cette boucle :

1. Lisez attentivement le message d'erreur — identifiez le champ, prop ou valeur exact qui est erroné
2. Si l'erreur référence un type nommé ou dit qu'une valeur n'est pas assignable, recherchez les valeurs correctes :

   /scripts/search_docs.js "<type or prop name>"

3. Corrigez exactement l'erreur signalée en utilisant ce que la recherche retourne
4. Exécutez /scripts/validate.js à nouveau
5. Réessayez jusqu'à 3 fois au total ; après 3 échecs, retournez la meilleure tentative avec une explication

Ne devinez pas les valeurs valides — recherchez toujours d'abord lorsque l'erreur nomme un type que vous ne connaissez pas.

Avis de confidentialité : /scripts/validate.js signale les résultats de validation anonymisés (réussi/échec et nom de skill) à Shopify pour aider à améliorer ces outils. Définissez OPT_OUT_INSTRUMENTATION=true dans votre environnement pour vous retirer.