Modos de Integração

module.exports = {
  async rewrites() {
    return [
      {
        source: '/api/graphql',
        destination:
          'https://storefront.acessocomercial.com/graphql'
      }
    ];
  }
};

export default {
  async fetch(request) {
    const url = new URL(request.url);

    if (url.pathname.startsWith('/api/graphql')) {
      const target =
        'https://storefront.acessocomercial.com/graphql';

      return fetch(target, {
        method: request.method,
        headers: request.headers,
        body: request.body
      });
    }
  }
};

location /api/graphql {
    proxy_pass https://storefront.acessocomercial.com/graphql;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-Host $host;
    proxy_pass_header Set-Cookie;
}

import { createProxyMiddleware } from 'http-proxy-middleware';

app.use('/api/graphql', createProxyMiddleware({
  target: 'https://storefront.acessocomercial.com',
  changeOrigin: true,
  pathRewrite: {
    '^/api/graphql': '/graphql'
  },
  cookieDomainRewrite: {
    'api.acessocomercial.com': ''
  }
}));

const response = await fetch('/api/graphql', {
  method: 'POST',
  credentials: 'include',
  headers: { 'Content-Type': 'application/json' },
  body: JSON.stringify({
    query: `mutation {
      clientLogin(input: {
        email: "user@example.com"
        password: "secret"
        hostname: "minha-loja"
      }) {
        auth
      }
    }`
  })
});

const API_URL = 'https://storefront.acessocomercial.com/graphql';
const HOSTNAME = 'minha-loja';

// --- Token Storage ---

function getTokens() {
  return {
    jwt: sessionStorage.getItem('jwt'),
    refresh: sessionStorage.getItem('refreshToken')
  };
}

function saveTokens(jwtToken, refreshToken) {
  sessionStorage.setItem('jwt', jwtToken);
  sessionStorage.setItem('refreshToken', refreshToken);
}

function clearTokens() {
  sessionStorage.removeItem('jwt');
  sessionStorage.removeItem('refreshToken');
}

function isLoggedIn() {
  return !!sessionStorage.getItem('jwt');
}

// --- Cart Storage ---

function getCartData() {
  return localStorage.getItem('CartData') || '';
}

function saveCartData(xCookiesHeader) {
  if (!xCookiesHeader) return;
  try {
    const cookies = JSON.parse(xCookiesHeader);
    for (const cookie of cookies) {
      if (cookie.name === 'CartData') {
        localStorage.setItem('CartData', JSON.stringify(cookie.value));
      }
    }
  } catch { /* ignore parse errors */ }
}

// --- GraphQL Client ---

async function graphql(query, variables = {}) {
  const { jwt } = getTokens();
  const cartData = getCartData();

  const headers = {
    'Content-Type': 'application/json',
    'X-Auth-Mode': 'bearer'
  };

  if (jwt) {
    headers['Authorization'] = `Bearer ${jwt}`;
  }

  if (cartData) {
    headers['X-Cart'] = JSON.stringify({
      CartData: JSON.parse(cartData)
    });
  }

  const response = await fetch(API_URL, {
    method: 'POST',
    headers,
    body: JSON.stringify({ query, variables })
  });

  // Save updated cart data from response
  saveCartData(response.headers.get('X-Cart'));

  const result = await response.json();

  // If token expired, try refresh and retry
  const isAuthError = result.errors?.some(
    (e) => e.extensions?.code === 'UNAUTHENTICATED'
  );

  if (isAuthError && getTokens().refresh) {
    const refreshed = await refreshSession();
    if (refreshed) {
      return graphql(query, variables); // retry with new token
    }
  }

  return result;
}

// --- Auth ---

async function login(email, password) {
  const result = await graphql(`
    mutation Login($input: ClientLoginMutationInput!) {
      clientLogin(input: $input) {
        auth
        jwtToken
        refreshToken
      }
    }
  `, {
    input: { email, password, hostname: HOSTNAME }
  });

  const { auth, jwtToken, refreshToken } = result.data.clientLogin;

  if (auth) {
    saveTokens(jwtToken, refreshToken);
  }

  return auth;
}

async function refreshSession() {
  const { refresh } = getTokens();
  if (!refresh) return false;

  const response = await fetch(API_URL, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'X-Auth-Mode': 'bearer'
    },
    body: JSON.stringify({
      query: `mutation {
        refreshSession(input: {
          refreshToken: "${refresh}"
        }) {
          success
          jwtToken
          refreshToken
        }
      }`
    })
  });

  const result = await response.json();
  const data = result.data?.refreshSession;

  if (data?.success) {
    saveTokens(data.jwtToken, data.refreshToken);
    return true;
  }

  clearTokens();
  return false;
}

function logout() {
  clearTokens();
}

// --- Usage ---

// Login
await login('user@example.com', 'secret');

// Authenticated query (token injected automatically)
const cart = await graphql(`
  query { shoppingCart(hostname: "${HOSTNAME}") {
    id totalPrice products { id title quantity }
  }}
`);

// Add to cart
const updated = await graphql(`
  mutation { addShoppingCartItem(input: {
    hostname: "${HOSTNAME}" productId: "abc123" quantity: 1
  }) { shoppingCart { id totalPrice } }}
`);