Autenticação

https://whitelabel.meaple.app/oauth/sign-in
  ?response_type=code
  &client_id=cmkeg9fpq001cmm0mu61qa6ks
  &redirect_uri=https://seu-app.com/api/auth/callback
  &state=OaQi-xy2CBAvzrNv_ed7gMuglH5NaoYp
  &scope=profile+email
  &code_challenge_method=S256
  &code_challenge=1CZBq_T9lnVeGFc44Ph6voMwJj_gLlwp3ECFWjeaGLc
  &theme=dark
  &preferred_color=%23fb923c

const clientId = process.env.MEAPLE_CLIENT_ID;
const redirectUri = 'https://seu-app.com/api/auth/callback';
 
// Gerar PKCE
const verifier = await generateCodeVerifier();
const challenge = await generateCodeChallenge(verifier);
 
// Armazenar verifier para usar na próxima etapa
sessionStorage.setItem('code_verifier', verifier);
 
// Gerar state para proteção CSRF
const state = generateState();
sessionStorage.setItem('oauth_state', state);
 
// Construir URL de autorização
const authorizationUrl = new URL('https://whitelabel.meaple.app/oauth/sign-in');
 
authorizationUrl.searchParams.append('response_type', 'code');
authorizationUrl.searchParams.append('client_id', clientId);
authorizationUrl.searchParams.append('redirect_uri', redirectUri);
authorizationUrl.searchParams.append('state', state);
authorizationUrl.searchParams.append('scope', 'profile email');
authorizationUrl.searchParams.append('code_challenge_method', 'S256');
authorizationUrl.searchParams.append('code_challenge', challenge);
 
// Parâmetros opcionais de customização
authorizationUrl.searchParams.append('theme', 'dark');
authorizationUrl.searchParams.append('preferred_color', '#fb923c');
 
// Redirecionar usuário
window.location.href = authorizationUrl.toString();

https://seu-app.com/api/auth/callback?code=AUTH_CODE&state=OaQi-xy2CBAvzrNv_ed7gMuglH5NaoYp

const urlParams = new URLSearchParams(window.location.search);
const code = urlParams.get('code');
const returnedState = urlParams.get('state');
const savedState = sessionStorage.getItem('oauth_state');
 
if (returnedState !== savedState) {
  throw new Error('State mismatch - possível ataque CSRF');
}
 
// State válido, prosseguir com a troca do código

const tokenUrl = 'https://whitelabel.meaple.app/api/oauth/token';
const codeVerifier = sessionStorage.getItem('code_verifier');
 
const body = new URLSearchParams();
body.append('grant_type', 'authorization_code');
body.append('client_id', clientId);
body.append('redirect_uri', redirectUri);
body.append('code', code);
body.append('code_verifier', codeVerifier); // PKCE
 
const response = await fetch(tokenUrl, {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body,
});
 
const tokens = await response.json();

{
  "access_token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
  "token_type": "Bearer",
  "expires_in": 3600,
  "refresh_token": "dGhpcyBpcyBhIHJlZnJlc2ggdG9rZW4..."
}

const body = new URLSearchParams();
body.append('grant_type', 'refresh_token');
body.append('client_id', clientId);
body.append('refresh_token', refreshToken);
 
const response = await fetch('https://whitelabel.meaple.app/api/oauth/token', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/x-www-form-urlencoded',
  },
  body,
});
 
const { access_token, expires_in, refresh_token } = await response.json();

const response = await fetch('https://api.meaple.com.br/v1/users/me', {
  headers: {
    Authorization: `Bearer ${accessToken}`,
    'X-Channel-Id': clientId,
  },
});
 
const { user } = await response.json();

{
  "user": {
    "id": "cml5kizep000b0vr1uxdq1tte",
    "name": "John Doe",
    "email": "johndoe@meaple.com.br",
    "document": "11111111111",
    "phoneNumber": "+5511999999999",
    "birthdate": "2001-01-01T00:00:00.000Z",
    "role": "ADMIN",
    "avatar": {
      "url": "http://localhost:3333/a58de3cb-89b7-423e-bfbd-b95f45de2c5b.png"
    }
  }
}

export async function generateCodeVerifier(): Promise<string> {
  const randomBytes = crypto.getRandomValues(new Uint8Array(32));
  return base64UrlEncode(String.fromCharCode(...randomBytes));
}
 
export async function generateCodeChallenge(
  codeVerifier: string
): Promise<string> {
  const encoder = new TextEncoder();
  const data = encoder.encode(codeVerifier);
  const digest = await crypto.subtle.digest('SHA-256', data);
  return base64UrlEncode(String.fromCharCode(...new Uint8Array(digest)));
}
 
function base64UrlEncode(str: string): string {
  const base64 = btoa(str);
  return base64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=/g, '');
}

export function generateState(): string {
  const timestamp = Date.now().toString();
  const randomString = Math.random().toString(36).substring(2);
  return timestamp + randomString;
}

import { MeapleSDK } from '@meaple-com/core';
 
const sdk = new MeapleSDK({
  publicKey: 'pk_seu_channel_id',
  baseURL: 'https://api.meaple.com.br',
});
 
// Configurar token global
sdk.setGlobalToken(accessToken);
 
// Agora você pode usar rotas autenticadas
const user = await sdk.users.getMe();
const orders = await sdk.users.getOrders();
const events = await sdk.users.getEvents();

// Buscar eventos
const { events } = await sdk.events.find();
 
// Buscar evento por slug
const event = await sdk.events.getBySlug('event-slug');
 
// Buscar categorias
const { categories } = await sdk.categories.find();
 
// Buscar ingressos de um evento
const { tickets } = await sdk.events.getTickets(eventId);

// Configurar token primeiro
sdk.setGlobalToken('seu_access_token');
 
// Perfil do usuário
const user = await sdk.users.getMe();
 
// Pedidos do usuário
const orders = await sdk.users.getOrders();
 
// Eventos com ingressos do usuário
const events = await sdk.users.getEvents();

GET https://whitelabel.meaple.app/api/oauth/logout
  ?client_id={CHANNEL_ID}
  &post_logout_redirect_uri=https://seu-app.com/logged-out

import { betterAuth } from 'better-auth';
import { genericOAuth } from 'better-auth/plugins';
 
export const auth = betterAuth({
  plugins: [
    genericOAuth({
      config: [
        {
          providerId: 'meaple',
          clientId: process.env.MEAPLE_CLIENT_ID!,
          authorizationUrl: (() => {
            const params = new URLSearchParams({
              theme: 'dark',
              preferred_color: '#fb923c',
            });
            return `https://whitelabel.meaple.app/oauth/sign-in?${params.toString()}`;
          })(),
          tokenUrl: 'https://whitelabel.meaple.app/api/oauth/token',
          getUserInfo: async tokens => {
            const response = await fetch(
              'https://api.meaple.com.br/v1/users/me',
              {
                headers: {
                  Authorization: `Bearer ${tokens.accessToken}`,
                  'X-Channel-Id': process.env.MEAPLE_CLIENT_ID!,
                },
              }
            );
 
            const { user } = await response.json();
 
            return {
              id: user.id,
              name: user.name,
              email: user.email,
              emailVerified: true,
            };
          },
          scopes: ['profile', 'email'],
          responseType: 'code',
          pkce: true,
        },
      ],
    }),
  ],
});