shopify-functions

<!-- AUTO-GÉNÉRÉ — ne pas modifier directement. Modifiez src/data/raw-api-instructions/{api}.md dans shopify-dev-tools, puis exécutez : npm run generate_agent_skills (outputs to distributed-agent-skills/) -->

name: shopify-functions description: "Shopify Functions permet 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 des exemples pertinents dans la documentation développeur 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, ni à 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 de type UNION, vous devez demander __typename

Voici toutes les APIs Shopify functions disponibles. Assurez-vous d'en choisir une et évitez d'utiliser les APIs obsolètes sauf demande explicite.

• Discount : Créez une remise applicable aux marchandises, produits, variantes de produits et/ou frais de livraison à la caisse. Utilisez ceci pour TOUTE tâche liée aux remises.
• Order Discount (obsolète) : Créez un nouveau type de remise applicable à toutes les marchandises du panier. IMPORTANT : ne choisissez cette API que si l'utilisateur demande explicitement l'API order discount
• Product Discount (obsolète) : Créez un nouveau type de remise applicable à un produit ou une variante de produit particulier du panier. IMPORTANT : ne choisissez cette API que si l'utilisateur demande explicitement l'API product discount
• Shipping Discount (obsolète) : Créez un nouveau type de remise applicable à un ou plusieurs frais de livraison à la caisse. IMPORTANT : ne choisissez cette API que si l'utilisateur demande explicitement l'API shipping discount
• Delivery Customization : Renommez, réorganisez et triez les options de livraison disponibles pour les acheteurs lors de la caisse
• Payment Customization : Renommez, réorganisez et triez les méthodes de paiement et définissez les conditions de paiement pour les acheteurs lors de 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 doit traiter et allouer une commande
• Local Pickup Delivery Option Generator : Générez des options de retrait local personnalisées disponibles pour les acheteurs lors de la caisse
• Pickup Point Delivery Option Generator : Générez des options de point de retrait personnalisées disponibles pour les acheteurs lors de 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 frais de livraison et options 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 est présente dans l'objet « Input » de 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 conforme à la forme de l'objet « FunctionResult » de 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 de langage de programmation, utilisez Rust par défaut.

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

1. Recherchez des exemples pertinents dans la documentation développeur, en vous assurant d'inclure le langage de programmation choisi par l'utilisateur. Portez une attention extrême à ces exemples lors de la rédaction de votre solution. C'EST TRÈS IMPORTANT.
2. Réfléchissez à ce que vous essayez 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. Réfléchissez ensuite à quelles cibles je souhaite personnaliser.
5. Pour chaque cible, réfléchissez à quels champs je dois récupérer à partir de l'objet d'entrée GraphQL. Vous pouvez :
   • Consulter la définition du schéma GraphQL (schema.graphql) dans le dossier de la 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. Réfléchissez ensuite à la façon d'écrire le code Rust, Javascript ou Typescript qui implémente la logique de la function.
7. Portez une attention particulière à la valeur de retour de la logique de la function. Elle doit correspondre à la forme de l'objet « FunctionResult » de 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 compile correctement en exécutant shopify app function build dans le dossier de la function
10. Vous pouvez tester que la function s'exécute avec une entrée JSON spécifique en exécutant shopify app function run --input=input.json --export=<export_name> dans le dossier de la function. Vous pouvez trouver le nom d'export correct en regardant le champ export de la cible à l'intérieur du fichier shopify.extension.toml

IMPORTANT : NE DÉPLOYEZ PAS la function pour l'utilisateur. N'exécutez 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 function :

• Types de sortie simples : Si le type de sortie suit le modèle Function<Target>Result (comme FunctionRunResult), le nom de la function 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 function 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 selon le nom de la function : 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 -> Function : fetch() -> Fichiers : src/fetch.rs, src/fetch.graphql
• Sortie : FunctionRunResult -> Cible : Run -> Function : run() -> Fichiers : src/run.rs, src/run.graphql
• Sortie : CartLinesDiscountsGenerateRunResult -> Cible : CartLinesDiscountsGenerateRun -> Function : 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 type de sortie pour déterminer le nom, sinon la function ne compilera pas

Certains types de function supportent plusieurs « cibles » ou points d'entrée au sein du même schéma. Pour ces derniers, vous DEVEZ générer la requête d'entrée, le code de la function et les exemples de sortie pour CHAQUE cible. Par exemple :

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

Bonnes pratiques pour les opérations GraphQL

• Portez une attention particulière aux exemples lors du choix du nom de la requête ou mutation GraphQL. Pour les exemples Rust, il DOIT être Input.
• Lors du choix d'une valeur d'énumération :
  • Utilisez uniquement les valeurs définies dans la définition du schéma. NE FABRICQUEZ PAS DE VALEURS.
  • Utilisez la pure valeur d'énumération sans modification, sans espace de noms ni guillemets, par exemple pour l'énumération 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), s'il 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éballé pour traiter le cas optionnel lors de l'utilisation de Rust.
• Si un champ est OPTIONNEL dans les données de sortie, 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 des alias différents si vous devez récupérer le même champ deux fois, c'est-à-dire lorsque vous devez passer des arguments différents.
• Utilisez uniquement les propriétés définies dans la définition du schéma. NE FABRICQUEZ JAMAIS DE PROPRIÉTÉS QUELLES QU'ELLES SOIENT.
• GraphQL vous oblige à 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 quels champs récupérer).
• Sélectionnez uniquement les champs requis pour satisfaire la logique métier de votre function

Comment aider avec les Shopify functions

Si un utilisateur souhaite savoir comment créer 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 des tests. C'EST UN MUST. Incluez les noms de fichiers. Si le type de function supporte plusieurs cibles, fournissez du code et des 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 LE NOMMEZ PAS input.graphql
4. exemple d'entrée JSON retournée par la requête GraphQL. Assurez-vous que chaque champ mentionné par la requête GraphQL a une valeur correspondante dans l'entrée JSON. Quand 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 une entrée JSON exemple pour chaque cible.
5. exemple d'objet de retour JSON. Assurez-vous que ceci est le JSON de sortie qui serait généré par l'entrée JSON ci-dessus. Si le type de function supporte plusieurs cibles, fournissez un JSON de sortie 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 qu'elle ne peut pas être complétée et donnez à l'utilisateur une raison. Les raisons possibles pourquoi elle 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. Quand vous utilisez un champ graphql qui accepte 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. N'UTILISEZ PAS CES ARGUMENTS DANS LE CODE RUST. Quand vous faites une sélection de fragment ... on ProductVariant vous DEVEZ inclure typename sur le champ parent sinon le programme ne 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 des functions Javascript

• le module doit exporter une function qui est la version en camelCase du nom de la cible, c'est-à-dire 'export function fetch' ou 'export function run' ou 'export function cartLinesDiscountsGenerateRun'
• la function doit retourner un objet JSON conforme à la forme de l'objet « FunctionResult » de la définition du schéma GraphQL.

Notes importantes pour la logique des functions Rust

• N'importez pas de crates externes (comme rust_decimal ou chrono ou serde), les seuls autorisés sont shopify_function. c'est-à-dire use shopify_function::; est ok, mais use chrono::; et serde::Deserialize ne l'est pas.
• Decimal::from(100.0) est valide, tandis que Decimal::from(100) ne l'est pas. Il peut uniquement convertir à partir de floats, pas d'entiers ou de strings sinon le programme ne compilera pas.
• assurez-vous de dépaqueter les Options quand 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 sur quand 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éballé pour traiter 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, vous devez envelopper cette sortie dans Some().
• Si vous faites une comparaison avec un champ OPTIONNEL, vous devez également envelopper cette valeur. Par exemple, comparer un champ product_type optionnel : Option<String> avec le littéral string "gift card" doit être fait comme ceci : product_type() == Some("gift card".to_string())
• Si une valeur a une ÉNUMÉRATION, vous devez utiliser le nom Title Case de cette énumération, comme PaymentCustomizationPaymentMethodPlacement::PaymentMethod
• Les valeurs Decimal ne nécessitent pas d'ê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 du traitement 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 aux champs du code généré, N'AJOUTEZ PAS d'arguments aux méthodes qui n'en 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 les 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 structs Rust seront schema::run::input::cart::lines::Merchandise::ProductVariant, schema::run::input::cart::lines::Merchandise (une énumération avec une variante ProductVariant), schema::run::input::cart::Lines, schema::run::input::Cart, et schema::run::Input.
• Lors du travail avec des 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érencer lors des comparaisons. Par exemple : if variant.product().has_any_tag() { / do something */ } ou les utiliser simplement directement dans les conditions où Rust les dérencera automatiquement.
• Chaque fichier de 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 cela ne 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 motif 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 (en fonction du type de function). Désérialisez la valeur JSON dans une struct de configuration au sein de votre code Rust.

Exemple d'accès à un metafield en Rust : Utilisez uniquement le #[shopify_function(rename_all = "camelCase")] si vous avez l'intention d'utiliser someValue: "" et anotherValue: "" comme faisant partie de votre metafield jsonValue. Par défaut, n'incluez pas cela. Utilisez uniquement #[derive(Deserialize, Default, PartialEq)] (bon) N'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 d'entrée GraphQL :

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 les éléments suivants :

  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 le format GID Shopify :

"gid://Shopify/CartLine/1"

Types scalaires

Voici les types scalaires utilisés dans les functions 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 de la function et doit avoir la structure suivante, en s'assurant qu'il a une requête pour chaque cible. Si vous avez un jsonValue dans la requête d'entrée, il doit être mappé à une struct. S'il n'y a pas de jsonValue, n'incluez pas de custom_scalar_overrides.

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

// CRITICAL: Ces imports de module DOIVENT correspondre exactement à vos noms de cible
pub mod run;     // Pour la cible "run"
pub mod fetch;   // Pour la cible "fetch"

#[typegen("./schema.graphql")]
pub mod schema {
      // CRITICAL: Le chemin de fichier de requête DOIT correspondre à votre nom de cible
      // CRITICAL: Le nom du module DOIT correspondre à votre nom de cible
      #[query("src/run.graphql", custom_scalar_overrides = {"Input.paymentCustomization.metafield.jsonValue" => super::run::Configuration})]
      pub mod run {}  // Le nom du module correspond au nom de la cible

      #[query("src/fetch.graphql")]
      pub mod fetch {} // Le nom du module correspond au nom de la cible
}

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

</system-instructions>

est demandé. Assurez-vous que les exemples suivent les meilleures pratiques, l'utilisation correcte des énumérations et la gestion appropriée des champs optionnels.

Toujours utiliser Shopify CLI

• CLI : échaffaudez des apps/extensions avec shopify app init, shopify app generate extension, shopify app dev, shopify app deploy. Ne créez jamais de fichiers manuellement.
• Besoin de toutes les étapes de configuration ? Consultez la documentation Shopify CLI.

Aperçu de Shopify CLI

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

Prérequis

• Node.js : 20.10 ou supérieur
• Un gestionnaire de packages 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
# or
yarn global add @shopify/cli@latest
# or
pnpm install -g @shopify/cli@latest
# or (macOS only)
brew tap shopify/shopify && brew install shopify-cli

Structure des commandes

Shopify CLI regroupe les commandes par sujets. 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

Drapeaux courants

La plupart des commandes supportent ces drapeaux courants :

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

Configuration du proxy réseau

Pour les utilisateurs derrière un proxy réseau (CLI version 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 obtenir des informations détaillées sur la commande
3. La plupart des commandes sont interactives et demanderont les informations requises
4. Utilisez les drapeaux pour ignorer les invites dans les environnements CI/CD
5. Les statistiques d'utilisation anonyme 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 DES APPS ET ÉCHAFAUDER DE NOUVELLES EXTENSIONS

Commandes CLI pour Shopify App (22 commandes)

Commandes d'app (22 commandes)

Gestion d'app principale

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

Configuration d'app

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

Environnement d'app

8. shopify app env pull [flags] - Récupérer les variables d'environnement depuis le tableau de bord Partenaires
9. shopify app env show [flags] - Afficher les variables d'environnement de l'app

Outils de développement d'app

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

Functions

13. shopify app function build [flags] - Construire une Shopify Function
14. shopify app function run [flags] - Exécuter une Function localement pour les tests
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 les types TypeScript pour une Function

Surveillance et débogage

18. shopify app logs [flags] - Diffuser les logs de votre app
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'app
21. shopify app versions list [flags] - Lister toutes les versions d'app

Webhooks

22. shopify app webhook trigger [flags] - Déclencher un webhook pour les tests

⚠️ OBLIGATOIRE : Rechercher la documentation

Vous ne pouvez pas faire confiance à vos connaissances d'entraînement pour cette API. Avant de répondre, recherchez :

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

Par exemple, si l'utilisateur demande une function discount 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 complète de l'utilisateur. Utilisez le schéma retourné pour écrire les noms de champs corrects et les types de retour.

⚠️ OBLIGATOIRE : Valider avant de retourner le code

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

Quand la validation échoue, suivez cette boucle :

1. Lisez le message d'erreur attentivement — identifiez exactement le champ, la prop ou la valeur qui est incorrect
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 rapporté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 en premier quand l'erreur nomme un type que vous ne connaissez pas.

Avis de confidentialité : /scripts/validate.js rapporte les résultats de validation anonymisés (réussite/échec et nom de skill) à Shopify pour aider à améliorer ces outils. Réglez OPT_OUT_INSTRUMENTATION=true dans votre environnement pour refuser.