Olá, pessoal! 👋 Sejam muito bem-vindos à Aula 72 do nosso curso “Shopify do Zero ao Avançado”!

Que jornada incrível estamos fazendo juntos, não é mesmo? Já passamos por muita coisa, desde a criação da loja, temas, Liquid, personalizações frontend com HTML, CSS e JavaScript, integrações básicas, até otimizações. Agora, vamos elevar o nível e mergulhar em um território que abre portas para possibilidades quase infinitas: o desenvolvimento de apps privados para sua loja Shopify.

Este é um tópico avançado, mas extremamente poderoso. Se vocês chegaram até aqui, significa que estão prontos para desvendar os segredos da API do Shopify e criar soluções customizadas que se encaixam perfeitamente às necessidades da sua loja ou do seu cliente. Preparem-se para colocar a mão na massa e transformar suas ideias em realidade!

—

Aula 72 – Loja Shopify do Zero ao Avançado: Desenvolvendo apps privados para sua loja

📚 O que você vai aprender nesta aula

Nesta aula super completa, vamos desvendar o mundo dos apps privados do Shopify. Ao final, você será capaz de:

• Compreender o conceito e a finalidade dos apps privados: Entender quando e por que utilizá-los, e qual a diferença para os apps públicos da App Store.
• Configurar e gerenciar um app privado: Aprender o passo a passo para criar um app privado no painel administrativo do Shopify, definindo permissões e obtendo as credenciais necessárias.
• Entender a API REST do Shopify: Navegar pela estrutura básica da API, seus endpoints, versões e métodos de autenticação.
• Realizar requisições à API REST: Fazer chamadas GET, POST, PUT e DELETE para interagir com os dados da sua loja (produtos, pedidos, clientes, etc.).
• Aplicar boas práticas de segurança e desenvolvimento: Garantir que seus apps privados sejam seguros, eficientes e robustos.
• Identificar cenários de uso: Conhecer exemplos práticos de como apps privados podem automatizar tarefas e adicionar funcionalidades únicas à sua loja.

🔗 Conectando com aulas anteriores

Até agora, exploramos diversas formas de personalizar e otimizar uma loja Shopify. Nas aulas de personalização de temas, aprendemos a manipular o layout e a funcionalidade do frontend usando Liquid, HTML, CSS e JavaScript. Também falamos sobre como integrar serviços externos usando JavaScript ou até mesmo scripts simples no backend.

Lembram-se de quando mencionamos que alguns dados eram acessíveis apenas pelo backend ou que certas automatizações precisariam de uma “ajuda extra”? Pois bem, os apps privados são essa “ajuda extra”!

Enquanto os temas e o JavaScript no frontend interagem principalmente com os dados disponíveis para o cliente (como informações de produtos na página, carrinho, etc.), e com algumas APIs públicas do Shopify (como a Storefront API para o checkout ou a busca), os apps privados nos dão acesso total e programático aos dados administrativos da loja: produtos, pedidos, clientes, inventário, relatórios, configurações e muito mais!

É a ferramenta ideal quando você precisa:

• Realizar integrações complexas com sistemas externos (ERP, CRM, sistemas de estoque).
• Automatizar tarefas administrativas que não são nativas do Shopify.
• Criar relatórios personalizados que combinam dados de diferentes fontes.
• Desenvolver funcionalidades muito específicas que não se encaixam em apps públicos ou que não justificam o custo de um.

Então, pensem nos apps privados como a chave mestra que abre os bastidores da sua loja, permitindo que você construa soluções realmente sob medida! 🔑

📖 Conteúdo Principal

1. O que são Apps Privados no Shopify?

No universo Shopify, existem dois tipos principais de aplicativos:

Apps Públicos (Public Apps): São aplicativos desenvolvidos por terceiros e disponíveis na Shopify App Store. Eles são projetados para serem instalados por qualquer* lojista Shopify, geralmente através de um modelo de assinatura. Exemplos incluem apps de marketing, SEO, reviews, upsell, etc.

Apps Privados (Private Apps): São aplicativos desenvolvidos exclusivamente para uma única loja Shopify*. Eles não são listados na App Store e são acessados diretamente através das credenciais geradas no painel administrativo da loja. São perfeitos para soluções muito específicas, automações internas ou integrações com sistemas já existentes do lojista.

Quando usar um App Privado?

• Integração com sistemas legados: Conectar sua loja Shopify a um sistema ERP, CRM ou de gestão de estoque que sua empresa já utiliza.
• Automação de tarefas: Criar scripts para automatizar a criação de produtos, atualização de preços em massa, gerenciamento de pedidos complexos, etc.
• Relatórios e análises customizadas: Extrair dados específicos da loja para gerar relatórios que não são oferecidos nativamente pelo Shopify.
• Funcionalidades muito nichadas: Desenvolver uma feature única que é crucial para o seu negócio e não existe como app público.
• Segurança e controle: Ter controle total sobre o código e os dados acessados, sem depender de terceiros.

2. Configurando seu Primeiro App Privado

Vamos ao passo a passo para criar um app privado no seu painel administrativo do Shopify.

2.1. Acessando a Área de Desenvolvimento de Apps

1. Acesse o painel administrativo da sua loja Shopify.

2. Vá em Configurações (o ícone de engrenagem no canto inferior esquerdo).

3. No menu lateral, clique em Apps e canais de vendas.

4. No canto superior direito da página, clique em Desenvolver apps.

Screenshot Conceitual: Painel Admin > Configurações > Apps e Canais de Vendas > Desenvolver Apps

(Imagine aqui uma imagem mostrando a navegação no painel Shopify)

2.2. Criando um Novo App Privado

1. Na página “Desenvolver apps”, clique em Criar um app personalizado.

2. Dê um Nome ao app personalizado. Escolha um nome descritivo para que você saiba sua função. Ex: “Integração ERP”, “Gerenciador de Pedidos Customizado”.

3. Selecione um Desenvolvedor do app personalizado. Este será o proprietário do app dentro da loja.

4. Clique em Criar app personalizado.

Screenshot Conceitual: Formulário de Criação de App Personalizado

(Imagine aqui um formulário simples com campos para Nome e Desenvolvedor)

2.3. Configurando Permissões da API (API Scopes)

Esta é a parte MAIS IMPORTANTE! As permissões da API definem quais recursos do Shopify seu app poderá acessar e quais ações poderá realizar (ler, escrever, apagar).

1. Após criar o app, você será direcionado para a página de detalhes do app.

2. Clique na aba Credenciais da API.

3. Role para baixo até a seção Permissões da API de acesso de administrador.

4. Clique em Configurar escopos de API de acesso de administrador.

5. Marque as caixas de seleção apenas para os recursos que seu app realmente precisa acessar.

• Exemplos:
• Se seu app precisa ler informações de produtos: marque read_products.
• Se precisa criar ou atualizar produtos: marque write_products.
• Se precisa ler pedidos: read_orders.
• Se precisa criar pedidos: write_orders.
• … e assim por diante para clientes, inventário, etc.

Dica de Ouro! 💡: Sempre use o princípio do menor privilégio. Conceda apenas as permissões ABSOLUTAMENTE necessárias. Isso minimiza riscos de segurança caso seu app seja comprometido.

Screenshot Conceitual: Lista de Permissões da API com Checkboxes

(Imagine aqui uma lista com categorias como “Pedidos”, “Produtos”, “Clientes” e checkboxes para read_, write_)

6. Após selecionar as permissões, clique em Salvar.

2.4. Obtendo as Credenciais do App

Uma vez que as permissões são salvas, as credenciais do seu app privado serão geradas e exibidas na aba Credenciais da API.

Você precisará das seguintes informações:

Token de acesso de API (API Access Token): Este é o “código” principal que seu app usará para autenticar as requisições. Ele é exibido apenas uma vez* no momento da criação. Copie-o imediatamente e guarde-o em um local seguro. Se você perdê-lo, terá que gerar um novo token.

• Chave da API (API Key): Um identificador único para o seu app.
• Chave secreta compartilhada (Shared Secret Key): Usada principalmente para verificar a autenticidade de Webhooks (tópico da próxima aula!).

Screenshot Conceitual: Seção de Credenciais da API com Token visível

(Imagine aqui uma caixa mostrando o Token de Acesso, API Key e Shared Secret, com botões para copiar)

Segurança é tudo! 🔒:

• NUNCA exponha seu Token de Acesso da API em código frontend (JavaScript no navegador), repositórios públicos (GitHub), ou em logs não protegidos.
• Sempre use variáveis de ambiente ou um sistema de gerenciamento de segredos para armazenar essas credenciais em seus scripts de backend.

3. Entendendo a API REST do Shopify

A API REST do Shopify permite que seu app interaja com os dados da loja usando requisições HTTP padrão.

3.1. Endpoint Base da API

Todas as requisições à API REST do Shopify começam com um endpoint base no seguinte formato:

https://{nomedaloja}.myshopify.com/admin/api/{versao}/

• {nomedaloja}: O subdomínio da sua loja Shopify (ex: minhalojateste).
• {versao}: A versão da API que você deseja usar. O Shopify atualiza sua API trimestralmente. É crucial usar uma versão estável e manter-se atualizado. As versões são datadas (ex: 2024-04, 2023-10). Sempre consulte a documentação oficial para a versão mais recente recomendada.

Exemplo de Endpoint Base:

https://minhalojateste.myshopify.com/admin/api/2024-04/

3.2. Autenticação

Para se autenticar, você usará o Token de acesso de API que você copiou anteriormente. Existem duas formas principais de enviá-lo:

1. Header X-Shopify-Access-Token (Recomendado):

Envie o token no cabeçalho X-Shopify-Access-Token de cada requisição.

X-Shopify-Access-Token: shpat_SEU_TOKEN_DE_ACESSO_AQUI

2. Basic Authentication (Deprecado para Private Apps com senha):

Antigamente, usava-se a API Key como username e o Token de acesso como password. Embora ainda possa funcionar em alguns cenários legados, o método do header é o padrão e mais recomendado para apps privados atuais.

3.3. Recursos da API

Após o endpoint base e a versão, você especifica o recurso com o qual deseja interagir. Os dados são geralmente retornados ou esperados em formato JSON.

• Produtos: /products.json
• Pedidos: /orders.json
• Clientes: /customers.json
• Inventário: /inventory_levels.json
• Webhooks: /webhooks.json

Exemplo de Endpoint Completo para Produtos:

https://minhalojateste.myshopify.com/admin/api/2024-04/products.json

4. Realizando Requisições à API REST do Shopify

Vamos explorar os principais verbos HTTP (GET, POST, PUT, DELETE) e como usá-los com a API do Shopify. Para os exemplos práticos, vamos usar cURL (ferramenta de linha de comando para fazer requisições HTTP) e um pouco de JavaScript (Node.js) para simular um ambiente de backend.

4.1. Requisições GET (Ler Dados)

Usado para obter recursos (listar, buscar por ID).

Exemplo: Listar todos os produtos

bash

curl -X GET 
'https://SUA_LOJA.myshopify.com/admin/api/2024-04/products.json' 
-H 'X-Shopify-Access-Token: SEU_TOKEN_DE_ACESSO' 
-H 'Content-Type: application/json'

Substitua SUA_LOJA pelo nome da sua loja e SEU_TOKEN_DE_ACESSO pelo token do seu app.

A resposta será um JSON contendo uma lista de produtos, algo como:

json

{
"products": [
{
"id": 1234567890,
"title": "Minha Camiseta Incrível",
"body_html": "
Esta é uma camiseta muito legal.
",

"vendor": "Minha Marca",
"product_type": "Vestuário",
"created_at": "2024-01-01T10:00:00-03:00",
"handle": "minha-camiseta-incrivel",
"updated_at": "2024-01-01T11:30:00-03:00",
"published_at": "2024-01-01T10:00:00-03:00",
"template_suffix": null,
"status": "active",
"published_scope": "web",
"tags": "camisa, moda",
"variants": [
{
"id": 9876543210,
"product_id": 1234567890,
"title": "P / Vermelho",
"price": "29.99",
"sku": "CAMI-P-VM",
"position": 1,
"inventory_quantity": 10
// ... outras propriedades da variante
}
],
"options": [
// ... opções do produto (tamanho, cor)
],
"images": [
// ... imagens do produto
],
"image": null
}
// ... mais produtos
]
}

Exemplo: Buscar um produto específico por ID

bash

curl -X GET 
'https://SUA_LOJA.myshopify.com/admin/api/2024-04/products/1234567890.json' 
-H 'X-Shopify-Access-Token: SEU_TOKEN_DE_ACESSO' 
-H 'Content-Type: application/json'

Substitua 1234567890 pelo ID de um produto existente na sua loja.

4.2. Requisições POST (Criar Dados)

Usado para criar um novo recurso. O corpo da requisição (--data no cURL) deve ser um JSON com os dados do recurso a ser criado.

Exemplo: Criar um novo produto simples

bash

curl -X POST 
'https://SUA_LOJA.myshopify.com/admin/api/2024-04/products.json' 
-H 'X-Shopify-Access-Token: SEU_TOKEN_DE_ACESSO' 
-H 'Content-Type: application/json' 
-d '{
"product": {
"title": "Meu Produto API Incrível",
"body_html": "Este produto foi criado via API!",
"vendor": "Minha API Store",
"product_type": "Digital",
"status": "active"
}
}'

A resposta retornará o objeto do produto recém-criado, incluindo seu id.

4.3. Requisições PUT (Atualizar Dados)

Usado para atualizar um recurso existente. Você precisa especificar o ID do recurso na URL e fornecer os dados atualizados no corpo da requisição.

Exemplo: Atualizar o preço de um produto existente (e sua variante)

Primeiro, você precisa do ID do produto e do ID da variante. Vamos supor que queremos atualizar o produto que criamos no exemplo POST (ou um que você buscou com GET).

bash

curl -X PUT 
'https://SUA_LOJA.myshopify.com/admin/api/2024-04/products/1234567890.json' 
-H 'X-Shopify-Access-Token: SEU_TOKEN_DE_ACESSO' 
-H 'Content-Type: application/json' 
-d '{
"product": {
"id": 1234567890,
"title": "Meu Produto API Incrível - Preço Atualizado!",
"variants": [
{
"id": 9876543210, // ID da variante a ser atualizada
"price": "49.99"
}
]
}
}'

Substitua 1234567890 pelo ID do seu produto e 9876543210 pelo ID de uma variante existente.

4.4. Requisições DELETE (Apagar Dados)

Usado para remover um recurso. É uma operação irreversível, use com extrema cautela!

Exemplo: Apagar um rascunho de pedido (Draft Order)

Para apagar um produto, você precisaria da permissão delete_products (raramente concedida). Vamos usar um rascunho de pedido, que é mais comum de ser gerenciado via API.

bash

curl -X DELETE 
'https://SUA_LOJA.myshopify.com/admin/api/2024-04/draft_orders/123456789.json' 
-H 'X-Shopify-Access-Token: SEU_TOKEN_DE_ACESSO' 
-H 'Content-Type: application/json'

Substitua 123456789 pelo ID de um rascunho de pedido que você deseja apagar. Tenha certeza que é um rascunho e não um pedido real!

5. Boas Práticas e Considerações

• Rate Limits: O Shopify impõe limites de taxa no número de requisições que seu app pode fazer por um determinado período. Se você exceder esses limites, suas requisições começarão a falhar. Planeje seus scripts para fazer requisições em lotes, com pausas, ou utilize mecanismos de “backoff” em caso de erro. Consulte a documentação para os limites específicos da sua versão de API.
• Tratamento de Erros: Sempre implemente tratamento de erros em seu código. Verifique os códigos de status HTTP (2xx para sucesso, 4xx para erros do cliente, 5xx para erros do servidor) e as mensagens de erro retornadas no corpo da resposta JSON.
• Armazenamento de Credenciais: Já mencionei, mas vale repetir: NUNCA deixe seu token de acesso em código aberto ou frontend. Use variáveis de ambiente (ex: .env com Node.js) ou um serviço de gerenciamento de segredos.
• Versões da API: Sempre especifique a versão da API na URL. Mantenha seu app atualizado com as versões mais recentes para aproveitar novos recursos e correções de segurança.
• Documentação Oficial: A documentação da API do Shopify é a sua Bíblia! Consulte-a sempre para detalhes sobre endpoints, parâmetros, campos esperados e possíveis erros.
• Shopify API Reference
• Linguagem de Desenvolvimento: Embora tenhamos usado cURL para exemplos, na prática, você desenvolverá seu app em uma linguagem de programação como Node.js (com fetch ou axios), Python (com requests), PHP (com guzzle) ou Ruby.

💻 Exemplos Práticos

Vamos criar um pequeno script Node.js para exemplificar como um app privado pode interagir com a API do Shopify.

Pré-requisitos:

• Node.js instalado na sua máquina.
• Um app privado configurado na sua loja Shopify com permissões de read_products e write_products.
• O Token de Acesso da API do seu app.

Passo 1: Crie um novo projeto Node.js

Crie uma pasta para seu projeto e inicialize o npm:

bash

mkdir my-shopify-private-app
cd my-shopify-private-app
npm init -y
npm install axios dotenv

• axios: Um cliente HTTP popular para fazer requisições.
• dotenv: Para gerenciar variáveis de ambiente (super importante para suas credenciais!).

Passo 2: Configure suas variáveis de ambiente

Crie um arquivo .env na raiz do seu projeto my-shopify-private-app com o seguinte conteúdo:

SHOPIFY_STORE_NAME=SUA_LOJA_AQUI
SHOPIFY_API_VERSION=2024-04
SHOPIFY_ACCESS_TOKEN=SEU_TOKEN_DE_ACESSO_AQUI

Lembre-se de substituir SUA_LOJA_AQUI pelo nome da sua loja (ex: minhalojateste) e SEU_TOKEN_DE_ACESSO_AQUI pelo token do seu app privado.

Passo 3: Crie o script app.js

Crie um arquivo app.js na raiz do seu projeto com o seguinte código:

javascript

// app.js
require('dotenv').config(); // Carrega as variáveis de ambiente do arquivo .env
const axios = require('axios'); // Importa a biblioteca axios
// Credenciais do app privado
const STORE_NAME = process.env.SHOPIFY_STORE_NAME;
const API_VERSION = process.env.SHOPIFY_API_VERSION;
const ACCESS_TOKEN = process.env.SHOPIFY_ACCESS_TOKEN;
// Verificação básica das credenciais
if (!STORE_NAME || !API_VERSION || !ACCESS_TOKEN) {
console.error("Erro: Por favor, configure SHOPIFY_STORE_NAME, SHOPIFY_API_VERSION e SHOPIFY_ACCESS_TOKEN no seu arquivo .env");
process.exit(1);
}
const SHOPIFY_API_URL = https://${STORE_NAME}.myshopify.com/admin/api/${API_VERSION};
// Configuração do Axios para incluir o token de acesso em todas as requisições
const shopifyAxios = axios.create({
baseURL: SHOPIFY_API_URL,
headers: {
'X-Shopify-Access-Token': ACCESS_TOKEN,
'Content-Type': 'application/json'
}
});
/**

Função para listar produtos

*/
async function listProducts() {
console.log('📦 Buscando produtos...');
try {
const response = await shopifyAxios.get('/products.json');
console.log('✅ Produtos encontrados:', response.data.products.map(p => ({
id: p.id,
title: p.title,
price: p.variants[0]?.price || 'N/A' // Pega o preço da primeira variante
})));
return response.data.products;
} catch (error) {
console.error('❌ Erro ao listar produtos:', error.response ? error.response.data : error.message);
return [];
}
}
/**

Função para criar um novo produto
@param {string} title
@param {string} description
@param {string} price
@returns {object|null} O produto criado ou null em caso de erro.

*/
async function createProduct(title, description, price) {
console.log(➕ Criando produto: "${title}" com preço ${price}...);
try {
const productData = {
product: {
title: title,
body_html: description,
vendor: "Minha API Store",
product_type: "API Product",
status: "active",
variants: [{
price: price,
sku: SKU-${title.toUpperCase().replace(/s/g, '-')}-${Date.now()}
}]
}
};
const response = await shopifyAxios.post('/products.json', productData);
console.log('✅ Produto criado com sucesso:', {
id: response.data.product.id,
title: response.data.product.title,
price: response.data.product.variants[0].price
});
return response.data.product;
} catch (error) {
console.error('❌ Erro ao criar produto:', error.response ? error.response.data : error.message);
return null;
}
}
/**

Função para atualizar o preço de um produto existente
@param {number} productId
@param {number} variantId
@param {string} newPrice
@returns {object|null} O produto atualizado ou null em caso de erro.

*/
async function updateProductPrice(productId, variantId, newPrice) {
console.log(✏️ Atualizando preço do produto ID ${productId} (variante ${variantId}) para ${newPrice}...);
try {
const productData = {
product: {
id: productId,
variants: [{
id: variantId,
price: newPrice
}]
}
};
const response = await shopifyAxios.put(/products/${productId}.json, productData);
console.log('✅ Preço do produto atualizado com sucesso:', {
id: response.data.product.id,
title: response.data.product.title,
newPrice: response.data.product.variants.find(v => v.id === variantId)?.price
});
return response.data.product;
} catch (error) {
console.error('❌ Erro ao atualizar preço do produto:', error.response ? error.response.data : error.message);
return null;
}
}
// --- Execução do Script ---
async function main() {
console.log('n--- Shopify Private App Demo ---n');
// 1. Listar produtos
const products = await listProducts();
// 2. Criar um novo produto
const newProduct = await createProduct(
"Caneca Mágica do Professor",
"Uma caneca que transforma café em código Liquid perfeito!",
"35.00"
);
// 3. Atualizar o preço do produto recém-criado
if (newProduct) {
const productId = newProduct.id;
const variantId = newProduct.variants[0].id; // Pega o ID da primeira variante
await updateProductPrice(productId, variantId, "45.00");
}
console.log('n--- Demonstração Concluída ---n');
}
main();

Passo 4: Execute o script

No terminal, na pasta do seu projeto:

bash

node app.js

Você verá os logs no console, mostrando os produtos listados, o novo produto sendo criado e seu preço sendo atualizado. Vá até o painel administrativo da sua loja Shopify para confirmar que o produto foi criado e atualizado!

Este é um exemplo básico, mas mostra o poder de interagir com sua loja de forma programática. As possibilidades são realmente vastas!

🎯 Exercícios e Desafios

Para solidificar o conhecimento adquirido, proponho os seguintes exercícios:

1. Crie seu próprio App Privado: Siga os passos da seção “Configurando seu Primeiro App Privado” para criar um app na sua loja de desenvolvimento Shopify. Dê a ele as permissões de read_customers e write_customers.

2. Liste Clientes: Modifique o script app.js (ou crie um novo) para usar a API de customers. Seu objetivo é listar os 5 primeiros clientes da sua loja, exibindo seus nomes e emails.

• Dica: O endpoint é /customers.json. Você pode usar o parâmetro ?limit=5 na URL para limitar os resultados.

3. Crie um Cliente: Adicione uma função ao seu script que crie um novo cliente na sua loja com nome, sobrenome e email fictícios.

4. Desafio Extra (Opcional): Implemente uma função para apagar o cliente que você acabou de criar. Lembre-se que para isso, você precisará adicionar a permissão delete_customers ao seu app privado no painel Shopify. Use com extrema cautela em lojas reais!

📝 Resumo da Aula

Ufa! Que aula intensa e cheia de poder! Hoje, demos um salto gigante no desenvolvimento Shopify, aprendendo sobre os apps privados:

• Entendemos que apps privados são soluções sob medida para uma única loja, ideais para integrações complexas e automação interna.
• Vimos como configurar um app privado no painel Shopify, crucialmente definindo suas permissões de API (scopes) com o princípio do menor privilégio.
• Exploramos a API REST do Shopify, seu endpoint base, versões e o método de autenticação via X-Shopify-Access-Token.
• Praticamos os verbos HTTP GET, POST, PUT e DELETE para ler, criar, atualizar e apagar recursos como produtos.
• Revisamos boas práticas essenciais, como lidar com rate limits, tratamento de erros e a importância vital de proteger suas credenciais de API.

Com este conhecimento, vocês têm agora a capacidade de ir muito além das funcionalidades padrão do Shopify e criar soluções verdadeiramente personalizadas e automatizadas para qualquer necessidade da loja! O céu é o limite para a criatividade e a otimização! ✨

🚀 Preparação para próxima aula

Na próxima aula, vamos aprofundar ainda mais no mundo dos apps privados, focando em um conceito crucial para qualquer automação em tempo real: os Webhooks do Shopify.

Vamos aprender:

• O que são webhooks e como eles funcionam.
• Como configurar webhooks no seu app privado para que o Shopify notifique seu script sobre eventos específicos (ex: novo pedido, atualização de produto, novo cliente).
• Como criar um servidor simples para “ouvir” esses webhooks e processar os dados em tempo real.
• A importância da Shared Secret Key para verificar a autenticidade dos webhooks.

Preparem-se para criar apps ainda mais dinâmicos e reativos! Leiam sobre o conceito de “event-driven architecture” para ter uma ideia do que vem por aí.

📚 Recursos Adicionais

• Documentação Oficial da API Admin REST do Shopify: Sua fonte definitiva de informação sobre todos os endpoints e detalhes da API.
• https://shopify.dev/docs/api/admin-rest
• Guia de Autenticação para Apps Personalizados:
• https://shopify.dev/docs/apps/auth/admin-app-access-tokens
• Axios (Cliente HTTP para JavaScript):
• https://axios-http.com/docs/intro
• Dotenv (Gerenciador de Variáveis de Ambiente para Node.js):
• https://www.npmjs.com/package/dotenv
• Postman: Ferramenta gráfica para testar APIs. Útil para entender como as requisições e respostas funcionam antes de codificar.
• https://www.postman.com/
• Insomnia: Outra excelente alternativa ao Postman.
• https://insomnia.rest/

Estudem bastante, pratiquem os exercícios e experimentem. A prática leva à perfeição neste mundo de desenvolvimento! Até a próxima aula! 👋🚀