@hed-hog/core 0.0.399 → 0.0.401

package/src/integration-profile/integration-profile.utils.ts

@@ -27,7 +27,7 @@ export function buildMailConfigFromIntegration(
         clientId: String(cfg.client_id ?? ''),
         clientSecret: String(cfg.client_secret ?? ''),
         refreshToken: String(cfg.refresh_token ?? ''),
-        from: String(cfg.from_email ?? ''),
+        from: String(cfg.from_email ?? '').trim(),
       };
     case 'ses':
       return {
@@ -36,7 +36,7 @@ export function buildMailConfigFromIntegration(
         region: String(cfg.region ?? ''),
         accessKeyId: String(cfg.access_key_id ?? ''),
         secretAccessKey: String(cfg.secret_access_key ?? ''),
-        from: String(cfg.from_email ?? ''),
+        from: String(cfg.from_email ?? '').trim(),
       };
     case 'resend':
       // Resend usa a API HTTP própria (não nodemailer). Retornamos um marcador
@@ -48,7 +48,7 @@ export function buildMailConfigFromIntegration(
         apiToken: String(cfg.api_token ?? ''),
         domain: String(cfg.domain ?? ''),
         region: String(cfg.region ?? ''),
-        from: String(cfg.from_email ?? ''),
+        from: String(cfg.from_email ?? '').trim(),
       };
     case 'imap':
       // Sem este caso o operador que apontasse o perfil de envio para uma caixa
@@ -123,8 +123,8 @@ export function buildResendConfigFromIntegration(
 
 export function getFromAddress(config: unknown): string {
   const cfg = (config as Cfg) ?? {};
-  const fromEmail = String(cfg.from_email ?? '');
-  const fromName = String(cfg.from_name ?? '');
+  const fromEmail = String(cfg.from_email ?? '').trim();
+  const fromName = String(cfg.from_name ?? '').trim();
   return fromName ? `${fromName} <${fromEmail}>` : fromEmail;
 }
 

package/src/integration-profile/testers/ai.testers.ts

@@ -3,11 +3,45 @@ import {
   fail,
   pass,
   probeJson,
+  redactSecrets,
   requireFields,
   str,
+  type ProbeResult,
 } from './http-probe';
 import { IntegrationTester } from './integration-tester.types';
 
+/**
+ * A frase do veredito mais o que o provider de fato respondeu.
+ *
+ * Sem isso todo 401 virava a mesma sentenca fixa e a resposta do provider —
+ * que o `probeJson` ja captura — era jogada fora. Foi o que fez um header de
+ * organizacao errado ser reportado como "chave invalida", mandando conferir o
+ * campo que estava certo.
+ *
+ * O resultado de um tester NAO passa por `sanitizeTesterError` (esse so cobre o
+ * caminho de excecao), entao a redacao dos segredos acontece aqui.
+ */
+function withProviderDetail(
+  base: string,
+  result: ProbeResult,
+  secretValues: string[],
+): string {
+  const raw = String(result.body?.error?.message ?? '').trim();
+  if (!raw) return base;
+
+  const detail = redactSecrets(raw, secretValues).trim();
+  return detail ? `${base} ${detail}` : base;
+}
+
+/** O 401 da OpenAI culpa a chave ou a organizacao? A resposta dela ja diz. */
+function isOpenAiOrganizationProblem(result: ProbeResult): boolean {
+  const code = String(result.body?.error?.code ?? '');
+  const message = String(result.body?.error?.message ?? '');
+  return (
+    code === 'invalid_organization' || /no such organization/i.test(message)
+  );
+}
+
 /**
  * Testadores dos providers de IA e geração de vídeo.
  *
@@ -33,7 +67,26 @@ const openAiTester: IntegrationTester = {
       ctx.signal,
     );
 
-    if (result.status === 401) return fail('Invalid OpenAI API key.');
+    if (result.status === 401) {
+      // O header de organizacao e opcional e so este testador o envia: o chat
+      // real nunca manda. Apontar o campo certo evita trocar uma chave boa.
+      if (isOpenAiOrganizationProblem(result)) {
+        return fail(
+          withProviderDetail(
+            organization
+              ? `OpenAI rejected the organization "${organization}". ` +
+                'Check the Organization ID field (it looks like "org-..."), ' +
+                'or leave it empty.'
+              : 'OpenAI rejected the organization.',
+            result,
+            ctx.secretValues,
+          ),
+        );
+      }
+      return fail(
+        withProviderDetail('Invalid OpenAI API key.', result, ctx.secretValues),
+      );
+    }
     if (result.status === 403) {
       return fail('This API key has no permission to list models.');
     }
@@ -72,7 +125,9 @@ const geminiTester: IntegrationTester = {
     const result = await probeJson(url, {}, ctx.signal);
 
     if (result.status === 400 || result.status === 401 || result.status === 403) {
-      return fail('Invalid Gemini API key.');
+      return fail(
+        withProviderDetail('Invalid Gemini API key.', result, ctx.secretValues),
+      );
     }
     if (!result.ok) {
       return fail(describeHttpError(result, 'Google rejected the credentials.'));
@@ -102,7 +157,11 @@ const claudeTester: IntegrationTester = {
       ctx.signal,
     );
 
-    if (result.status === 401) return fail('Invalid Anthropic API key.');
+    if (result.status === 401) {
+      return fail(
+        withProviderDetail('Invalid Anthropic API key.', result, ctx.secretValues),
+      );
+    }
     if (!result.ok) {
       return fail(describeHttpError(result, 'Anthropic rejected the credentials.'));
     }
@@ -124,7 +183,11 @@ const deepseekTester: IntegrationTester = {
       ctx.signal,
     );
 
-    if (result.status === 401) return fail('Invalid DeepSeek API key.');
+    if (result.status === 401) {
+      return fail(
+        withProviderDetail('Invalid DeepSeek API key.', result, ctx.secretValues),
+      );
+    }
     if (!result.ok) {
       return fail(describeHttpError(result, 'DeepSeek rejected the credentials.'));
     }
@@ -147,7 +210,9 @@ const lumaTester: IntegrationTester = {
     );
 
     if (result.status === 401 || result.status === 403) {
-      return fail('Invalid Luma API key.');
+      return fail(
+        withProviderDetail('Invalid Luma API key.', result, ctx.secretValues),
+      );
     }
     if (!result.ok) {
       return fail(describeHttpError(result, 'Luma rejected the credentials.'));

package/src/integration-profile/testers/index.ts

@@ -6,6 +6,7 @@ import { IntegrationTester } from './integration-tester.types';
 import { MESSAGING_TESTERS } from './messaging.testers';
 import { OAUTH_TESTERS } from './oauth.testers';
 import { PAYMENT_TESTERS } from './payment.testers';
+import { SHIPPING_TESTERS } from './shipping.testers';
 import { STORAGE_TESTERS } from './storage.testers';
 
 /**
@@ -23,6 +24,7 @@ export const BUILTIN_INTEGRATION_TESTERS: IntegrationTester[] = [
   ...PAYMENT_TESTERS,
   ...CAPTCHA_TESTERS,
   ...INFRASTRUCTURE_TESTERS,
+  ...SHIPPING_TESTERS,
 ];
 
 export * from './http-probe';

package/src/integration-profile/testers/remaining.testers.spec.ts

@@ -5,6 +5,7 @@ import { EMAIL_TESTERS } from './email.testers';
 import { INFRASTRUCTURE_TESTERS } from './infrastructure.testers';
 import { MESSAGING_TESTERS } from './messaging.testers';
 import { PAYMENT_TESTERS } from './payment.testers';
+import { SHIPPING_TESTERS } from './shipping.testers';
 import { IntegrationTestContext, IntegrationTester } from './integration-tester.types';
 
 /**
@@ -19,16 +20,20 @@ const all = [
   ...AI_TESTERS,
   ...PAYMENT_TESTERS,
   ...INFRASTRUCTURE_TESTERS,
+  ...SHIPPING_TESTERS,
 ];
 
 const bySlug = (slug: string): IntegrationTester =>
   all.find((tester) => tester.providerSlug === slug)!;
 
-const ctx = (): IntegrationTestContext => ({
+const ctx = (
+  overrides: Partial<IntegrationTestContext> = {},
+): IntegrationTestContext => ({
   signal: AbortSignal.timeout(5_000),
   typeSlug: 'test',
   providerSlug: 'test',
   secretValues: [],
+  ...overrides,
 });
 
 function jsonResponse(body: unknown, status = 200) {
@@ -250,6 +255,67 @@ describe('openai tester', () => {
       error: 'Invalid OpenAI API key.',
     });
   });
+
+  // O header de organização é opcional e só este testador o envia. Um `org-...`
+  // errado devolve 401, e a mensagem fixa de "chave inválida" mandava conferir
+  // justamente o campo que estava certo.
+  it('culpa a organização, e não a chave, quando é ela que a OpenAI recusa', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse(
+        {
+          error: {
+            message: 'No such organization: org-errada.',
+            code: 'invalid_organization',
+          },
+        },
+        401,
+      ),
+    );
+
+    const outcome = await tester.test(
+      { api_key: 'sk-test', organization: 'org-errada' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('organization');
+    expect(outcome.error).toContain('org-errada');
+    expect(outcome.error).not.toContain('Invalid OpenAI API key');
+  });
+
+  it('acrescenta o motivo que a OpenAI deu quando a chave é mesmo o problema', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse(
+        { error: { message: 'Incorrect API key provided.', code: 'invalid_api_key' } },
+        401,
+      ),
+    );
+
+    const outcome = await tester.test({ api_key: 'sk-bad' }, ctx());
+
+    expect(outcome.error).toBe(
+      'Invalid OpenAI API key. Incorrect API key provided.',
+    );
+  });
+
+  // O resultado de um tester não passa por `sanitizeTesterError`, então a
+  // redação do segredo tem de acontecer dentro do próprio testador.
+  it('não deixa a chave vazar pela mensagem do provider', async () => {
+    fetchMock.mockResolvedValue(
+      jsonResponse(
+        { error: { message: 'Incorrect API key provided: sk-supersecreta.' } },
+        401,
+      ),
+    );
+
+    const outcome = await tester.test(
+      { api_key: 'sk-supersecreta' },
+      ctx({ secretValues: ['sk-supersecreta'] }),
+    );
+
+    expect(outcome.error).not.toContain('sk-supersecreta');
+    expect(outcome.error).toContain('***');
+  });
 });
 
 describe('claude tester', () => {
@@ -444,3 +510,80 @@ describe('digitalocean tester', () => {
     });
   });
 });
+
+describe('melhor-envio tester', () => {
+  const tester = bySlug('melhor-envio');
+  const account = { firstname: 'Ana', lastname: 'Souza', email: 'ana@acme.com' };
+
+  it('identifica a conta e o ambiente de produção', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(account));
+
+    await expect(tester.test({ access_token: 'tok' }, ctx())).resolves.toEqual({
+      ok: true,
+      info: 'Ana Souza — ana@acme.com (production)',
+    });
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://melhorenvio.com.br/api/v2/me');
+    const headers = init.headers as Record<string, string>;
+    expect(headers.Authorization).toBe('Bearer tok');
+    // Sem User-Agent identificável o Melhor Envio recusa a requisição.
+    expect(headers['User-Agent']).toBe('HedHog Commerce');
+  });
+
+  it('usa a base de sandbox e avisa que o preço não é real', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(account));
+
+    const outcome = await tester.test(
+      { access_token: 'tok', sandbox: true, user_agent: 'Loja (contato@acme.com)' },
+      ctx(),
+    );
+
+    expect(outcome.ok).toBe(true);
+    expect(outcome.info).toContain('(sandbox)');
+    expect(outcome.warning).toContain('not real prices');
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toBe('https://sandbox.melhorenvio.com.br/api/v2/me');
+    expect((init.headers as Record<string, string>)['User-Agent']).toBe(
+      'Loja (contato@acme.com)',
+    );
+  });
+
+  it('aceita a string "true" que o formulário do admin grava', async () => {
+    fetchMock.mockResolvedValue(jsonResponse(account));
+
+    await tester.test({ access_token: 'tok', sandbox: 'true' }, ctx());
+
+    const [url] = fetchMock.mock.calls[0] as [string];
+    expect(url).toBe('https://sandbox.melhorenvio.com.br/api/v2/me');
+  });
+
+  it('aponta o switch de sandbox no 401, que é o erro mais comum', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({}, 401));
+
+    const outcome = await tester.test({ access_token: 'tok' }, ctx());
+
+    expect(outcome.ok).toBe(false);
+    expect(outcome.error).toContain('in production');
+    expect(outcome.error).toContain('sandbox switch');
+  });
+
+  it('distingue falta de escopo (403) de token inválido', async () => {
+    fetchMock.mockResolvedValue(jsonResponse({}, 403));
+
+    await expect(tester.test({ access_token: 'tok' }, ctx())).resolves.toEqual({
+      ok: false,
+      error:
+        'The Melhor Envio token has no permission to read the account. Reissue it including the shipping scopes.',
+    });
+  });
+
+  it('exige o token antes de ir à rede', async () => {
+    await expect(tester.test({}, ctx())).resolves.toEqual({
+      ok: false,
+      error: 'Access token is required.',
+    });
+    expect(fetchMock).not.toHaveBeenCalled();
+  });
+});

package/src/integration-profile/testers/shipping.testers.ts

@@ -0,0 +1,94 @@
+import {
+  describeHttpError,
+  fail,
+  pass,
+  probeJson,
+  requireFields,
+  str,
+} from './http-probe';
+import { IntegrationTester } from './integration-tester.types';
+
+/**
+ * Testadores das transportadoras / intermediadores de frete.
+ *
+ * Só leitura da conta: nada aqui gera etiqueta, compra postagem ou mexe no saldo
+ * da carteira — mesmo princípio dos testers de pagamento.
+ */
+
+/**
+ * Sandbox e produção são contas SEPARADAS no Melhor Envio, cada uma com o seu
+ * token. Trocar o switch sem trocar o token devolve 401, então a resolução da
+ * base tem que ser idêntica à do consumidor
+ * (libraries/commerce/src/commerce-shipping/melhor-envio.provider.ts) — senão o
+ * teste valida um ambiente e a loja cota no outro.
+ */
+function resolveBaseUrl(config: Record<string, unknown>): {
+  baseUrl: string;
+  sandbox: boolean;
+} {
+  // Aceita boolean do JSON e a string do formulário do admin.
+  const sandbox = config.sandbox === true || String(config.sandbox ?? '') === 'true';
+  return {
+    sandbox,
+    baseUrl: sandbox
+      ? 'https://sandbox.melhorenvio.com.br'
+      : 'https://melhorenvio.com.br',
+  };
+}
+
+const melhorEnvioTester: IntegrationTester = {
+  providerSlug: 'melhor-envio',
+  test: async (config, ctx) => {
+    const missing = requireFields(config, [['access_token', 'Access token']]);
+    if (missing) return missing;
+
+    const { baseUrl, sandbox } = resolveBaseUrl(config);
+    const environment = sandbox ? 'sandbox' : 'production';
+
+    const result = await probeJson(
+      `${baseUrl}/api/v2/me`,
+      {
+        headers: {
+          Authorization: `Bearer ${str(config, 'access_token')}`,
+          Accept: 'application/json',
+          // Sem User-Agent identificável o Melhor Envio recusa a requisição, e o
+          // teste falharia por etiqueta faltando em vez de credencial errada.
+          'User-Agent': str(config, 'user_agent') || 'HedHog Commerce',
+        },
+      },
+      ctx.signal,
+    );
+
+    if (result.status === 401) {
+      // O erro mais comum não é token digitado errado: é token de sandbox num
+      // perfil de produção (ou o contrário), porque são contas diferentes.
+      return fail(
+        `Melhor Envio rejected the access token in ${environment}. Check the token and the sandbox switch — sandbox and production are separate accounts.`,
+      );
+    }
+    if (result.status === 403) {
+      return fail(
+        'The Melhor Envio token has no permission to read the account. Reissue it including the shipping scopes.',
+      );
+    }
+    if (!result.ok) {
+      return fail(describeHttpError(result, 'Melhor Envio rejected the credentials.'));
+    }
+
+    const name = [result.body?.firstname, result.body?.lastname]
+      .map((part) => String(part ?? '').trim())
+      .filter(Boolean)
+      .join(' ');
+    const email = String(result.body?.email ?? '').trim();
+    const account = [name, email].filter(Boolean).join(' — ') || 'Melhor Envio account';
+
+    return pass(
+      `${account} (${environment})`,
+      // Cotação de sandbox tem preço fictício: passar despercebido significa loja
+      // no ar vendendo frete que não existe.
+      sandbox ? 'This profile points to the sandbox, so quotes are not real prices.' : undefined,
+    );
+  },
+};
+
+export const SHIPPING_TESTERS: IntegrationTester[] = [melhorEnvioTester];

package/src/integration-profile/testers/tester-coverage.spec.ts

@@ -15,6 +15,16 @@ const EXTERNAL_PROVIDERS = new Set([
   // Abrir o certificado A1 é código do domínio fiscal: o tester se registra pelo
   // NfseNationalModule (libraries/fiscal).
   'nfse-national',
+  // App da Meta para redes sociais: o tester se registra pelo SocialModule
+  // (libraries/social), junto do client da Graph API.
+  'meta-social',
+  // App do Instagram (Instagram Login): o tester vive em libraries/social.
+  'instagram-social',
+  // Apps do Google do modulo social: os testers vivem em libraries/social.
+  'youtube-social',
+  'google-business-social',
+  // App do LinkedIn (paginas de empresa): o tester vive em libraries/social.
+  'linkedin-social',
 ]);
 
 /** Providers legítimos sem nenhum campo secreto. */

package/src/mail/dto/send.dto.ts

@@ -10,8 +10,13 @@ export class SendTemplatedMailDTO {
   @IsNotEmpty({ message: (args) => getLocaleText('validation.fieldRequired', args.value) })
   slug: string;
 
+  /**
+   * Contexto do Handlebars. Nao e so string: o corpo do e-mail e compilado com
+   * Handlebars de verdade, entao um array aqui alimenta `{{#each}}` no template
+   * (e o resumo do aluno usa isso para a grade de sequencia da semana).
+   */
   @IsObject({ message: (args) => getLocaleText('validation.objectRequired', args.value) })
-  variables: Record<string, string>;
+  variables: Record<string, unknown>;
 
   /**
    * Slug do perfil de integração de e-mail a usar neste envio.

package/src/mail/mail-template.spec.ts

@@ -1,5 +1,10 @@
 import { describe, it, expect } from '@jest/globals';
-import { DEFAULT_MAIL_LAYOUT, renderMailTemplate, resolveMailAssetUrl } from '@hed-hog/api-mail';
+import {
+  DEFAULT_MAIL_LAYOUT,
+  renderMailTemplate,
+  resolveMailAssetUrl,
+  sanitizeAccentColor,
+} from '@hed-hog/api-mail';
 
 // Testes do renderizador de e-mail moram aqui (e nao em packages/api-mail)
 // porque o api-mail nao tem jest configurado; o jest do core resolve o pacote.
@@ -249,6 +254,58 @@ describe('renderMailTemplate', () => {
   });
 });
 
+describe('cor da etapa (accentColor)', () => {
+  // O commerce manda uma cor por etapa da compra; as demais libraries nao
+  // mandam nada e precisam continuar exatamente como estavam.
+  it('pinta a barra de destaque com a cor da etapa', () => {
+    const html = renderMailTemplate({
+      subject: 'Pagamento confirmado',
+      body: '<p>Ola</p>',
+      primaryColor: '#111827',
+      accentColor: '#16a34a',
+    });
+
+    expect(html).toContain('background:#16a34a;');
+    expect(html).toContain('background: #16a34a;');
+  });
+
+  it('cai na cor da marca quando nenhuma etapa e informada', () => {
+    const html = renderMailTemplate({
+      subject: 'Recuperar senha',
+      body: '<p>Ola</p>',
+      primaryColor: '#1465b8',
+    });
+
+    expect(html).toContain('background:#1465b8;');
+    expect(html).not.toContain('{{accentColor}}');
+  });
+
+  // O valor e interpolado dentro do bloco <style> do wrapper: string livre ali
+  // fecharia a regra e reescreveria o layout inteiro.
+  it('ignora cor fora do formato #rrggbb', () => {
+    const html = renderMailTemplate({
+      subject: 'Oi',
+      body: '<p>Ola</p>',
+      primaryColor: '#1465b8',
+      accentColor: 'red;} body { display:none } .x {',
+    });
+
+    expect(html).not.toContain('display:none');
+    expect(html).toContain('background:#1465b8;');
+  });
+
+  it('sanitizeAccentColor aceita so hexadecimal de 6 digitos', () => {
+    expect(sanitizeAccentColor('#16a34a')).toBe('#16a34a');
+    expect(sanitizeAccentColor('  #ABCDEF  ')).toBe('#ABCDEF');
+    expect(sanitizeAccentColor('#abc')).toBeUndefined();
+    expect(sanitizeAccentColor('green')).toBeUndefined();
+    expect(sanitizeAccentColor('#16a34a;')).toBeUndefined();
+    expect(sanitizeAccentColor('')).toBeUndefined();
+    expect(sanitizeAccentColor(undefined)).toBeUndefined();
+    expect(sanitizeAccentColor(null)).toBeUndefined();
+  });
+});
+
 describe('resolveMailAssetUrl', () => {
   it('mantem URLs ja absolutas ou data: intactas', () => {
     expect(resolveMailAssetUrl('https://cdn.example.com/logo.svg', 'http://localhost:3100')).toBe(