Shopify Scripts después del 30 de junio de 2026: migrar a Functions

A 14 de octubre de 2026, ya han pasado los dos hitos de Shopify Scripts: la edición y publicación se detuvieron el 15 de abril, y Scripts dejó de ejecutarse el 30 de junio. Revisa el informe de personalizaciones de Shopify e identifica cualquier comportamiento del checkout que dependiera de Scripts.

Esta guía explica cómo evaluar las personalizaciones afectadas y utilizar Shopify Functions para la lógica de descuentos, entrega y pagos compatible. Scripts gestionaba el comportamiento del checkout; no implementaba modificaciones de pedidos poscompra, como cambiar la dirección de envío después de realizar un pedido.

Respuesta rápida: de Scripts a Functions en 60 segundos#

Estado actual: Shopify Scripts dejó de ejecutarse el 30 de junio de 2026. Shopify Functions ofrece API compatibles para personalizaciones del checkout, como descuentos, entrega y pagos. Las aplicaciones públicas que usan Functions están disponibles en todos los planes; las aplicaciones personalizadas que contienen Functions requieren Shopify Plus. Empieza con la guía de migración de Shopify y la plantilla de extensión generada por la CLI actual, y después valida el comportamiento en una tienda de desarrollo.

Qué cambió en 2026#

Las fechas anunciadas por Shopify ya han pasado. El Script Editor pasó a ser de solo lectura el 15 de abril, y Scripts dejó de ejecutarse el 30 de junio de 2026.

Si una tienda dependía de un Script, su comportamiento dejó de ejecutarse tras la fecha límite, salvo que se hubiera sustituido o reconfigurado de otra forma. Comprueba el comportamiento real del checkout en la tienda; no asumas que todos los ajustes afectados vuelven a sus valores predeterminados de la misma manera.

Consejo: Revisa el informe de personalizaciones en el panel de administración de Shopify para inventariar las personalizaciones afectadas por la retirada de Scripts. Utiliza la documentación de migración actual de Shopify para confirmar la sustitución de cada una.

Functions frente a Scripts: qué ha cambiado#

El cambio de arquitectura es importante: Scripts eran personalizaciones de Ruby en el Script Editor; Functions son extensiones de aplicaciones desarrolladas con las herramientas compatibles de Shopify. Sus targets de extensión y requisitos de plan difieren, así que utiliza la documentación de migración para asociar cada Script con una sustitución compatible.

Cómo asociar cada Script con el tipo de Function adecuado#

Un Script puede corresponder a una Function, una aplicación pública, otro ajuste compatible o no tener sustitución. Utiliza la guía de migración de Shopify para comprobar la opción correcta para cada personalización.

Varios Scripts pueden corresponder a una sola Function o requerir sustituciones separadas. Confirma la correspondencia y el comportamiento de cada caso antes de combinar la lógica.

Requisito previo: prepara tu entorno de desarrollo local#

Antes de crear la estructura de una Function, necesitas instalar tres herramientas en tu equipo. Ejecuta estas comprobaciones en la terminal.

1. Node.js#

Utiliza una versión de Node.js compatible con la versión actual de Shopify CLI; comprueba los requisitos de instalación de la CLI antes de configurar el proyecto.

node --version
# Check the version required by your installed Shopify CLI

Si tienes una versión anterior, instálala mediante nvm o descárgala de nodejs.org.

2. Shopify CLI actual#

Instala la versión actual de Shopify CLI y compruébala con shopify version. Para el crate actual de Functions en Rust (2.0.0 y posteriores), Shopify documenta la necesidad de CLI 3.85.0 o superior.

3. Cadena de herramientas de Rust (solo si vas a escribir Functions en Rust)#

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
rustup target add wasm32-unknown-unknown
cargo --version

Las Functions en JavaScript no necesitan Rust. Elige un lenguaje para tu equipo y úsalo de forma consistente: mantener ambos añade trabajo.

4. Una tienda de desarrollo#

Inicia sesión en tu panel de Partner y crea una tienda de desarrollo, o utiliza una que ya tengas. Desplegarás las Functions allí antes de llevarlas a producción.

Crea la estructura de tu primera Function#

Shopify CLI genera la mayor parte del código inicial. Desde cualquier directorio:

# Create a new Shopify app (skip if you already have one)
shopify app init --name my-checkout-functions
cd my-checkout-functions

# Generate a Function extension
shopify app generate extension

Shopify CLI te guiará por varias opciones. Para una Function de descuentos, elegirías:

• Tipo: Function
• Plantilla: discount (o cart_checkout_validation, delivery_customization, payment_customization, etc.)
• Lenguaje: Rust o JavaScript
• Nombre: algo como volume-discount-fn

Esto crea extensions/volume-discount-fn/ con esta estructura:

extensions/volume-discount-fn/
├── shopify.extension.toml      # Function config — targets, build, version
├── src/
│   ├── cart_lines_discounts_generate_run.graphql   # Input query
│   └── cart_lines_discounts_generate_run.rs        # Function logic
├── Cargo.toml                  # Rust dependencies (Rust only)
└── README.md

Los tres archivos que editarás con más frecuencia son .toml (configuración), .graphql (datos de entrada) y .rs / .js (lógica). Eso es todo.

Tutorial 1: sustituir un Line Item Script (descuento por volumen)#

Supongamos que tu Script anterior aplicaba un 10 % de descuento al subtotal del pedido cuando el carrito contenía 5 o más unidades de una colección concreta. Esta es la Function equivalente.

Paso 1.1: configuración (shopify.extension.toml)#

api_version = "2026-10"
 
[[extensions]]
name = "volume-discount-fn"
handle = "volume-discount-fn"
type = "function"
  
[[extensions.targeting]]
target = "cart.lines.discounts.generate.run"
input_query = "src/cart_lines_discounts_generate_run.graphql"
export = "cart_lines_discounts_generate_run"
   
[extensions.build]
command = "cargo build --target=wasm32-unknown-unknown --release"
path = "target/wasm32-unknown-unknown/release/volume-discount-fn.wasm"
watch = ["src/**/*.rs"]

Paso 1.2: consulta de entrada (src/cart_lines_discounts_generate_run.graphql)#

query Input {
  cart {
    lines {
      id
      quantity
      cost {
        subtotalAmount {
          amount
        }
      }
      merchandise {
        ... on ProductVariant {
          product {
            inAnyCollection(ids: ["gid://shopify/Collection/123456789"])
          }
        } 
      } 
    }
  }
  discount {
    discountClasses
  } 
}

Consejo: Las Functions solo reciben los datos que solicitas en la consulta. Mantén la consulta GraphQL lo más breve posible: cada campo que omitas permite una ejecución más rápida y con menos recursos.

Paso 1.3: lógica (src/cart_lines_discounts_generate_run.rs)#

use super::schema;
use shopify_function::prelude::*;
use shopify_function::Result;
    
#[shopify_function]
fn cart_lines_discounts_generate_run(
    input: schema::cart_lines_discounts_generate_run::Input,
) -> Result<schema::CartLinesDiscountsGenerateRunResult> {
    // Bail if discount class doesn't match
    let has_order_discount = input
        .discount()
        .discount_classes()
        .contains(&schema::DiscountClass::Order);
     
    if !has_order_discount {
        return Ok(schema::CartLinesDiscountsGenerateRunResult { operations: vec![] });
    } 
      
    // Sum quantities of items in the target collection
    let qualifying_qty: i64 = input
        .cart()
        .lines()
        .iter()
        .filter(|line| {
            if let schema::Merchandise::ProductVariant(v) = line.merchandise() {
                *v.product().in_any_collection()
            } else {
                false
            }
        })
        .map(|line| *line.quantity())
        .sum();
       
    if qualifying_qty < 5 {
        return Ok(schema::CartLinesDiscountsGenerateRunResult { operations: vec![] }); 
    }  
        
    // Apply 10% off the order subtotal
    Ok(schema::CartLinesDiscountsGenerateRunResult {
        operations: vec![schema::CartOperation::OrderDiscountsAdd(
            schema::OrderDiscountsAddOperation {
                selection_strategy: schema::OrderDiscountSelectionStrategy::First,
                candidates: vec![schema::OrderDiscountCandidate {
                    targets: vec![schema::OrderDiscountCandidateTarget::OrderSubtotal(
                        schema::OrderSubtotalTarget {
                            excluded_cart_line_ids: vec![],
                        },
                    )],
                    message: Some("Volume discount: 10% off".to_string()),
                    value: schema::OrderDiscountCandidateValue::Percentage(
                        schema::Percentage { value: Decimal(10.0) }
                    ),
                    conditions: None,
                    associated_discount_code: None,
                }],
            },
        )],
    })
} 

Paso 1.4: probar, desplegar y activar#

# Local development with hot reload
shopify app dev
         
# When ready, deploy
shopify app deploy
          
# In the GraphiQL panel that opens (press `g` in the dev terminal),
# create the automatic discount that uses your Function:

mutation CreateAutomaticDiscount($startsAt: DateTime!) {
  discountAutomaticAppCreate(
    automaticAppDiscount: {
      title: "Volume Discount (5+ collection items)"
      functionHandle: "volume-discount-fn"
      discountClasses: [ORDER]
      startsAt: $startsAt
    }   
  ) {
    automaticAppDiscount { discountId }
    userErrors { field message }
  }  
}  

En el panel Query Variables de GraphiQL, define startsAt como una marca de tiempo ISO 8601 futura. Revisa cualquier otro campo obligatorio de tu versión de la API antes de ejecutar la mutación.

Esto crea el descuento automático que llama a la Function desplegada; la Function sustituye la lógica del Script para este caso de uso.

Tutorial 2: sustituir un Shipping Script (ocultar un método de envío según el subtotal)#

Un Script habitual dice: «Ocultar el envío exprés cuando el subtotal del carrito supera los $500 para evitar envíos urgentes costosos en pedidos grandes». Esta es la versión con una Delivery Customization Function.

Los tutoriales 2 y 3 usan las plantillas actuales de JavaScript. Conserva los targets generados y las exportaciones de src/index.js, establece api_version = "2026-10" en el archivo shopify.extension.toml de cada extensión y ejecuta shopify app function typegen en el directorio de cada extensión después de sustituir su consulta de entrada.

Paso 2.1: crear la estructura#

shopify app generate extension --template delivery_customization --flavor vanilla-js --name hide-express-fn

Paso 2.2: consulta de entrada (src/cart_delivery_options_transform_run.graphql)#

query CartDeliveryOptionsTransformRunInput { 
  cart { 
    cost {
      subtotalAmount {
        amount
      }  
    }    
    deliveryGroups {
      deliveryOptions {
        handle
        title
      }   
    }     
  }   
}   

Paso 2.3: lógica (src/cart_delivery_options_transform_run.js)#

// @ts-check
/**
 * @typedef {import("../generated/api").CartDeliveryOptionsTransformRunInput} CartDeliveryOptionsTransformRunInput
 * @typedef {import("../generated/api").CartDeliveryOptionsTransformRunResult} CartDeliveryOptionsTransformRunResult
 */
           
/** @type {CartDeliveryOptionsTransformRunResult} */
const NO_CHANGES = { operations: [] };
const THRESHOLD = 500.0;
const HIDE_TITLES = ["Express", "Overnight"];
            
/** 
 * @param {CartDeliveryOptionsTransformRunInput} input
 * @returns {CartDeliveryOptionsTransformRunResult}
 */ 
export function cartDeliveryOptionsTransformRun(input) {
  const subtotal = parseFloat(input.cart.cost.subtotalAmount.amount);
  if (subtotal < THRESHOLD) return NO_CHANGES;
             
  const operations = input.cart.deliveryGroups.flatMap((group) =>
    group.deliveryOptions
      .filter((opt) => HIDE_TITLES.some((t) => (opt.title ?? "").includes(t)))
      .map((opt) => ({
        deliveryOptionHide: { deliveryOptionHandle: opt.handle },
      }))
  );
              
  return { operations };
}    

Paso 2.4: crear y activar la personalización de entrega#

Después de ejecutar shopify app deploy e instalar la app en la tienda de destino, ejecuta deliveryCustomizationCreate mediante el cliente GraphQL de Admin autenticado de esa app con el permiso write_delivery_customizations. Establece la variable functionHandle en el valor de handle de la extensión en shopify.extension.toml (por ejemplo, hide-express-fn).

mutation CreateDeliveryCustomization($functionHandle: String!) {
  deliveryCustomizationCreate(deliveryCustomization: {
    functionHandle: $functionHandle
    title: "Hide express shipping above cart threshold"
    enabled: true
  }) {
    deliveryCustomization { id enabled }
    userErrors { field message }
  }
}

Confirma que la respuesta devuelve una personalización activada y ningún userErrors; después, comprueba Configuración → Envío y entrega → Personalizaciones de entrega y prueba el comportamiento de la pantalla de pago. El despliegue proporciona la Function; esta mutación crea y activa la personalización de la tienda.

Tutorial 3: sustituir un Payment Script (ocultar el pago contra entrega para B2B)#

Script anterior: «Ocultar el pago contra entrega a cualquier cliente con la etiqueta “B2B”». Esta es la versión con Payment Customization.

Paso 3.1: crear la estructura#

shopify app generate extension --template payment_customization --flavor vanilla-js --name hide-cod-b2b-fn

Paso 3.2: consulta de entrada (src/cart_payment_methods_transform_run.graphql)#

query CartPaymentMethodsTransformRunInput {  
  cart {  
    buyerIdentity {
      customer {
        hasTags(tags: ["B2B"]) {
          tag
          hasTag
        }  
      }    
    }      
  }    
  paymentMethods {
    id
    name
  }     
}     

Paso 3.3: lógica (src/cart_payment_methods_transform_run.js)#

// @ts-check
/**
 * @typedef {import("../generated/api").CartPaymentMethodsTransformRunInput} CartPaymentMethodsTransformRunInput
 * @typedef {import("../generated/api").CartPaymentMethodsTransformRunResult} CartPaymentMethodsTransformRunResult
 */
/** @type {CartPaymentMethodsTransformRunResult} */
const NO_CHANGES = { operations: [] }; 
               
/**
 * @param {CartPaymentMethodsTransformRunInput} input
 * @returns {CartPaymentMethodsTransformRunResult}
 */
export function cartPaymentMethodsTransformRun(input) { 
  const tagCheck = input.cart?.buyerIdentity?.customer?.hasTags?.[0];
  const isB2B = tagCheck?.hasTag === true;
  if (!isB2B) return NO_CHANGES;
                
  const codMethod = input.paymentMethods.find((pm) =>
    pm.name.toLowerCase().includes("cash on delivery")
  ); 
  if (!codMethod) return NO_CHANGES;
                 
  return {
    operations: [{ paymentMethodHide: { paymentMethodId: codMethod.id } }],
  };
}      

Paso 3.4: crear y activar la personalización de pago#

Después de desplegar e instalar la app en la tienda de destino, ejecuta paymentCustomizationCreate mediante el cliente GraphQL de Admin autenticado de esa app con el permiso write_payment_customizations. Establece functionHandle en el valor de handle de la extensión de pago en shopify.extension.toml (por ejemplo, hide-cod-b2b-fn).

mutation CreatePaymentCustomization($functionHandle: String!) {
  paymentCustomizationCreate(paymentCustomization: {
    functionHandle: $functionHandle
    title: "Hide Cash on Delivery for B2B-tagged customers"
    enabled: true
  }) {
    paymentCustomization { id enabled }
    userErrors { field message }
  }
}

Comprueba que la respuesta contiene una personalización de pago activada sin userErrors. Verifícala en Configuración → Pagos → Personalizaciones de pago y prueba la pantalla de pago con clientes con y sin la etiqueta B2B.

Ya que estás aquí: unas palabras sobre lo que ocurre después de la compra#

Para cambios después del pago, Revize ofrece autoservicio apto antes de la preparación mediante la página de estado o enlace de confirmación durante la ventana del comerciante. Cambiar productos y añadir artículos requiere Pro; la edición por el personal está en desarrollo. Los clientes revisan el saldo adicional y pagan mediante Shopify Checkout. Gestión de pedidos en Shopify 2026: guía para equipos de Plus explica el flujo nativo después del pago.

Volvamos a la migración.

Estrategia de pruebas: usar una etiqueta de cliente#

Usa una tienda de desarrollo y datos de entrada representativos para probar la sustitución según requisitos documentados o resultados guardados de Scripts. Scripts ya no se ejecuta, así que no se puede probar en paralelo Script y Function en vivo. Una condición por etiqueta de cliente puede limitar la Function de prueba a cuentas internas; separa el lanzamiento en producción de estas pruebas.

Paso 1: etiqueta a los usuarios de prueba#

En Customers, añade la etiqueta FN-TESTER a dos o tres cuentas internas.

Paso 2: condiciona la Function a la presencia de la etiqueta#

// Rust example: return this target's empty result for non-testers
let is_tester = input
    .cart()
    .buyer_identity()
    .and_then(|bi| bi.customer())
    .map(|c| c.has_any_tag())
    .unwrap_or(&false);
                  
if !*is_tester {
    return Ok(default_result);  // No operations from this Function
}       
                   
// New Function logic only runs for tagged users

Paso 3: añade hasAnyTag a la consulta de entrada#

cart {
  buyerIdentity {
    customer {
      hasAnyTag(tags: ["FN-TESTER"])
    }       
  }      
}        

Paso 4: comprueba el resultado en la pantalla de pago#

Accede con un usuario etiquetado y verifica carritos aptos y no aptos, combinaciones de descuentos y opciones de entrega/pago. Repite sin etiqueta para confirmar que la Function no devuelve operaciones. Compara con el comportamiento esperado de la lógica anterior e incluye checkout como invitado antes de eliminar la condición.

Paso 5: revisar la activación en producción#

Activa la sustitución probada mediante la configuración pertinente de descuentos, entrega o pagos. Registra la versión de la app y plan de reversión y elimina instrucciones obsoletas de Scripts de la documentación del equipo.

Un proceso de despliegue que puede crecer contigo#

No despliegues siempre desde el portátil de un desarrollador. Cuando hayas migrado uno o dos Scripts, configura un proceso de integración continua.

El proceso mínimo viable#

# .github/workflows/deploy-functions.yml
name: Deploy Shopify Functions
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with: { node-version: '22' }
      - uses: dtolnay/rust-toolchain@stable
        with: { targets: wasm32-unknown-unknown }
      - run: npm install -g @shopify/cli@latest
      - run: shopify app deploy --force
        env:
          SHOPIFY_APP_AUTOMATION_TOKEN: ${{ secrets.SHOPIFY_APP_AUTOMATION_TOKEN }}

Crea un App Automation Token en Dev Dashboard de Shopify y guárdalo como el secreto del repositorio mostrado arriba. La CLI actual requiere Node.js 22.12 o posterior. Asocia el proyecto a su configuración de app antes de usar CI; añade pruebas y revisión de publicación antes de desplegar. Este ejemplo despliega al enviar cambios a main, así que adapta el activador a la política de tu equipo.

Versiones y reversión#

shopify app deploy crea una instantánea con versión. Para volver a una versión anterior:

shopify app versions list
shopify app release --version <previous-version-id>

Con Scripts, revertir un cambio significaba recordar el código anterior y volver a pegarlo. Aquí el proceso es mucho más sencillo.

Errores frecuentes de los equipos#

Estos son errores habituales de migración que debes comprobar antes de publicar una Function.

1. Trasladar cada Script a una Function por separado. No es necesario. Una sola Function puede sustituir tres Scripts con condiciones más claras. Revisa todos tus Scripts en conjunto antes de reescribirlos.

2. Confundir los permisos de la aplicación con los datos de entrada de la Function. Una Function lee los campos expuestos por su consulta de entrada y los metacampos configurados; añadir read_customers o read_orders no le da acceso a la Admin API. Añade permisos de aplicación solo para operaciones separadas de la Admin API, y comprueba las reglas de entrada y configuración de la Function API para la extensión que estás desarrollando.

3. Omitir las pruebas de equivalencia. Compara la Function con el antiguo Script mediante carritos representativos y casos límite relevantes antes de publicarla. Utiliza un lanzamiento gradual solo cuando tu extensión y configuración lo permitan.

4. Omitir el Customizations Report. Es el mejor inventario de lo que realmente está en funcionamiento. Basa la migración en el informe, no en lo que recuerdes.

5. Incluir identificadores de colecciones y etiquetas de clientes directamente en el código. Si el comerciante necesita cambiar esos valores, usa una configuración de la Function mediante metacampos. Shopify CLI puede generar una estructura de configuración respaldada por metacampos; consulta la documentación de Shopify sobre la configuración de Functions.

Lista de comprobación de la migración#

Utiliza esta lista para revisar el estado actual de una migración de Scripts.

Como ya ha pasado la fecha de fin de ejecución, prioriza la auditoría del comportamiento del checkout en producción y cualquier trabajo de sustitución pendiente.

Próximos pasos#

1. Revisa el informe de personalizaciones y la guía de migración actual de Shopify.
2. Prueba los casos relevantes del checkout en una tienda de desarrollo.
3. Confirma qué Functions o aplicaciones públicas admiten la lógica necesaria en tu plan.
4. Verifica cada sustitución en producción y documenta su responsable y configuración.

Separa las pruebas de reglas del checkout de las de edición poscompra. Para cada sistema, registra la app responsable, funciones activadas y comportamiento de preparación/pago para que futuros cambios tengan un responsable claro.

Recursos#

• Introducción a Shopify Functions — documentación para desarrolladores de Shopify
• Migrar de Shopify Scripts a Functions
• Tutorial para crear una Discount Function
• Referencia de la API de Delivery Customization Function
• Referencia de la API de Payment Customization Function
• Documentación de Shopify CLI

Lecturas relacionadas: Estadísticas de edición de pedidos en Shopify (2026) · Cómo permitir que los clientes editen sus propios pedidos en Shopify (2026)