godeep-states 1.0.0

package/README.md

@@ -0,0 +1,158 @@
+# godeep-states
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+Módulo Nuxt que fornece stores Pinia e rotas de servidor para integração com a API GoDeep, removendo a responsabilidade de gerenciamento de estado do front-end do cliente.
+
+- [✨  Release Notes](/CHANGELOG.md)
+
+## Features
+
+- 🗄️  Stores Pinia pré-configurados para todas as funcionalidades do GoDeep
+- 🔌  Rotas de servidor para proxy de API
+- 🔄  Persistência de estado com sessionStorage
+- 📦  Integração completa com godeep-types
+- 🚀  Auto-descoberta de stores pelo Nuxt
+
+## Quick Setup
+
+Instale o módulo na sua aplicação Nuxt:
+
+```bash
+npm install godeep-states
+# ou
+bun add godeep-states
+```
+
+Adicione o módulo ao seu `nuxt.config.ts`:
+
+```typescript
+export default defineNuxtConfig({
+  modules: ['godeep-states'],
+  
+  // Configure as variáveis de ambiente necessárias
+  runtimeConfig: {
+    public: {
+      urlApi: process.env.URL_API,
+      token: process.env.TOKEN_API,
+    },
+  },
+})
+```
+
+Configure as variáveis de ambiente no seu `.env`:
+
+```env
+URL_API=https://sua-api-godeep.com
+TOKEN_API=seu-token-aqui
+```
+
+Pronto! Os stores estarão disponíveis automaticamente na sua aplicação ✨
+
+
+## Stores Disponíveis
+
+O módulo fornece os seguintes stores Pinia:
+
+- `storeCarrinho` - Gerenciamento de carrinho de compras
+- `storeHome` - Dados da página inicial
+- `storeProduto` - Detalhes e informações de produtos
+- `storeVitrine` - Listagens e vitrines de produtos
+- `storeCategoria` - Categorias de produtos
+- `storeBusca` - Resultados de busca
+- `storeFavoritos` - Lista de favoritos
+- `storeLogin` - Autenticação e login
+- `storeCadastro` - Cadastro de usuários
+- `storePedidos` - Histórico de pedidos
+- `storeEnderecos` - Gerenciamento de endereços
+- `storePagamentos` - Métodos de pagamento
+- `storeConfiguracoes` - Configurações da loja
+- `storeMenus` - Menus de navegação
+- `storeBanner` - Banners promocionais
+- `storeNewsletter` - Inscrições em newsletter
+- `storePaginas` - Páginas estáticas
+- `storeRedesSociais` - Links de redes sociais
+- `storeAvaliacoes` - Avaliações de produtos
+- `storeFiltros` - Filtros de busca
+- `storeDadosCadastrais` - Dados cadastrais do usuário
+
+## Uso
+
+Os stores são auto-importados pelo Nuxt. Você pode usá-los diretamente nos seus componentes:
+
+```vue
+<script setup lang="ts">
+const carrinhoStore = storeCarrinho()
+const homeStore = storeHome()
+
+// Usar os stores
+await homeStore.buscarHome()
+await carrinhoStore.adicionarProdutosCarrinho([...])
+</script>
+```
+
+## Rotas de Servidor
+
+O módulo também fornece rotas de servidor:
+
+- `/api/front-api/**` - Proxy para a API GoDeep
+- `/robots` - Endpoint para robots.txt
+- `/robots.txt` - Endpoint alternativo para robots.txt
+
+## Dependências
+
+Este módulo requer:
+- `godeep-types` - Tipos TypeScript e funções de tradução
+- `pinia` - Gerenciamento de estado
+- `pinia-plugin-persistedstate` - Persistência de estado
+
+## Contribution
+
+<details>
+  <summary>Desenvolvimento local</summary>
+  
+  ```bash
+  # Instalar dependências
+  npm install
+  
+  # Gerar stubs de tipos
+  npm run dev:prepare
+  
+  # Desenvolver com o playground
+  npm run dev
+  
+  # Build do playground
+  npm run dev:build
+  
+  # Executar ESLint
+  npm run lint
+  npm run lint:fix
+  
+  # Executar testes
+  npm run test
+  npm run test:watch
+  
+  # Verificar tipos
+  npm run typecheck
+  
+  # Publicar nova versão
+  npm run release
+  ```
+
+</details>
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/godeep-states/latest.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-version-href]: https://npmjs.com/package/godeep-states
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/godeep-states.svg?style=flat&colorA=020420&colorB=00DC82
+[npm-downloads-href]: https://npm.chart.dev/godeep-states
+
+[license-src]: https://img.shields.io/npm/l/godeep-states.svg?style=flat&colorA=020420&colorB=00DC82
+[license-href]: https://npmjs.com/package/godeep-states
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-020420?logo=nuxt
+[nuxt-href]: https://nuxt.com

package/dist/module.d.mts

@@ -0,0 +1,8 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
+
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -0,0 +1,9 @@
+{
+  "name": "godeep-states",
+  "configKey": "godeepStates",
+  "version": "1.0.0",
+  "builder": {
+    "@nuxt/module-builder": "1.0.2",
+    "unbuild": "3.6.1"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,28 @@
+import { defineNuxtModule, createResolver, addPlugin, addServerHandler } from '@nuxt/kit';
+
+const module$1 = defineNuxtModule({
+  meta: {
+    name: "godeep-states",
+    configKey: "godeepStates"
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {},
+  setup(_options, _nuxt) {
+    const resolver = createResolver(import.meta.url);
+    addPlugin(resolver.resolve("./runtime/plugin"));
+    addServerHandler({
+      route: "/api/front-api/**",
+      handler: resolver.resolve("./runtime/server/api/[...slug]")
+    });
+    addServerHandler({
+      route: "/robots",
+      handler: resolver.resolve("./runtime/server/routes/robots")
+    });
+    addServerHandler({
+      route: "/robots.txt",
+      handler: resolver.resolve("./runtime/server/routes/robots.txt")
+    });
+  }
+});
+
+export { module$1 as default };

package/dist/runtime/composables/useHeader.d.ts

@@ -0,0 +1,2 @@
+import type { H3Event } from 'h3';
+export default function useHeader(event: H3Event, token: string): Promise<Record<string, string>>;

package/dist/runtime/composables/useHeader.js

@@ -0,0 +1,33 @@
+import { getHeader, getCookie } from "h3";
+export default async function useHeader(event, token) {
+  const headers = {
+    "Content-Type": "application/json",
+    "Accept": "application/json"
+  };
+  if (token) {
+    headers.Authorization = `Bearer ${token}`;
+  }
+  if (!token) {
+    const cookieToken = getCookie(event, "token");
+    if (cookieToken) {
+      headers.Authorization = `Bearer ${cookieToken}`;
+    }
+  }
+  const cartId = getHeader(event, "cart-id") || getCookie(event, "cart.id");
+  if (cartId) {
+    headers["cart-id"] = cartId;
+  }
+  const userAgent = getHeader(event, "user-agent");
+  if (userAgent) {
+    headers["User-Agent"] = userAgent;
+  }
+  const referer = getHeader(event, "referer");
+  if (referer) {
+    headers.Referer = referer;
+  }
+  const origin = getHeader(event, "origin");
+  if (origin) {
+    headers.Origin = origin;
+  }
+  return headers;
+}

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugin.js

@@ -0,0 +1,3 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((_nuxtApp) => {
+});

package/dist/runtime/server/api/[...slug].d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/api/[...slug].js

@@ -0,0 +1,66 @@
+import {
+  getRequestURL,
+  getQuery,
+  readBody,
+  createError,
+  defineEventHandler
+} from "h3";
+import useHeader from "../../composables/useHeader.js";
+import { extrairMensagensErro } from "../../utils/erros.js";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const urlApi = config.public.urlApi || config.urlApi || process.env.URL_API || "";
+  const token = config.public.token || config.token || process.env.TOKEN_API || "";
+  if (!urlApi) {
+    throw createError({
+      statusCode: 500,
+      message: "URL_API n\xE3o configurada"
+    });
+  }
+  const requestUrl = getRequestURL(event);
+  const fullPath = requestUrl.pathname;
+  const targetUrl = `${urlApi}${fullPath}`;
+  const method = event.method;
+  const clientHeaders = await useHeader(event, token);
+  const query = getQuery(event);
+  const queryString = new URLSearchParams(
+    query
+  ).toString();
+  const finalUrl = queryString ? `${targetUrl}?${queryString}` : targetUrl;
+  const options = {
+    method,
+    headers: clientHeaders,
+    body: null
+  };
+  try {
+    console.log("finalUrl", finalUrl);
+    console.log("method", method);
+    if (method === "POST" || method === "PUT" || method === "PATCH") {
+      const body = await readBody(event);
+      if (body && Object.keys(body).length > 0) {
+        options.body = JSON.stringify(body);
+      }
+    }
+    const response = await fetch(finalUrl, options);
+    if (!response.ok) {
+      const errorData = await response.json().catch(() => ({}));
+      const { mensagemGeral, mensagensErro } = extrairMensagensErro(
+        errorData,
+        "Erro ao conectar com a API externa"
+      );
+      throw createError({
+        status: response.status,
+        message: mensagemGeral,
+        data: mensagensErro
+      });
+    }
+    return await response.json();
+  } catch (error) {
+    const errorObject = error;
+    return createError({
+      status: 500,
+      message: errorObject?.message ?? "Erro ao conectar com a API externa",
+      data: errorObject?.data ?? {}
+    });
+  }
+});

package/dist/runtime/server/routes/robots.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/routes/robots.js

@@ -0,0 +1,37 @@
+import { defineEventHandler, setHeader } from "h3";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const urlApi = config.urlApi;
+  const token = config.token;
+  try {
+    const response = await fetch(`${urlApi}/api/front-api/robots`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`API retornou status ${response.status}`);
+    }
+    const data = await response.json();
+    let robotsContent = "User-agent: *\nAllow: /";
+    if (data.dados && Array.isArray(data.dados) && data.dados.length > 0) {
+      robotsContent = data.dados[0];
+    } else if (typeof data.dados === "string") {
+      robotsContent = data.dados;
+    } else if (data.dados) {
+      robotsContent = String(data.dados);
+    }
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    setHeader(event, "Cache-Control", "public, max-age=3600, s-maxage=3600");
+    return robotsContent;
+  } catch (error) {
+    console.error("Erro ao buscar robots.txt da API:", error);
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    setHeader(event, "Cache-Control", "public, max-age=300");
+    return "User-agent: *\nAllow: /";
+  }
+});

package/dist/runtime/server/routes/robots.txt.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<string>>;
+export default _default;

package/dist/runtime/server/routes/robots.txt.js

@@ -0,0 +1,37 @@
+import { defineEventHandler, setHeader } from "h3";
+import { useRuntimeConfig } from "#imports";
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const urlApi = config.urlApi;
+  const token = config.token;
+  try {
+    const response = await fetch(`${urlApi}/api/front-api/robots`, {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "Accept": "application/json"
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`API retornou status ${response.status}`);
+    }
+    const data = await response.json();
+    let robotsContent = "User-agent: *\nAllow: /";
+    if (data.dados && Array.isArray(data.dados) && data.dados.length > 0) {
+      robotsContent = data.dados[0];
+    } else if (typeof data.dados === "string") {
+      robotsContent = data.dados;
+    } else if (data.dados) {
+      robotsContent = String(data.dados);
+    }
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    setHeader(event, "Cache-Control", "public, max-age=3600, s-maxage=3600");
+    return robotsContent;
+  } catch (error) {
+    console.error("Erro ao buscar robots.txt da API:", error);
+    setHeader(event, "Content-Type", "text/plain; charset=utf-8");
+    setHeader(event, "Cache-Control", "public, max-age=300");
+    return "User-agent: *\nAllow: /";
+  }
+});

package/dist/runtime/server/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "../../../.nuxt/tsconfig.server.json",
+}

package/dist/runtime/stores/.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "nuxt.isNuxtApp": false
+}

package/dist/runtime/stores/avaliacoes.d.ts

@@ -0,0 +1,53 @@
+import type { StorefrontFormularioAvaliacao } from 'godeep-types/types';
+export declare const storeAvaliacoes: import("pinia").StoreDefinition<"avaliacoes", {
+    carregando: boolean;
+    formularioAvaliacao: StorefrontFormularioAvaliacao;
+}, {
+    recuperarFormularioAvaliacao: (state: {
+        carregando: boolean;
+        formularioAvaliacao: {
+            idProduto?: number | undefined;
+            nota?: number | undefined;
+            nome?: string | undefined;
+            ip?: string | undefined;
+            email?: string | undefined;
+            titulo?: string | undefined;
+            comentario?: string | undefined;
+            cidade?: string | undefined;
+            dataAvaliacao?: string | undefined;
+        };
+    } & import("pinia").PiniaCustomStateProperties<{
+        carregando: boolean;
+        formularioAvaliacao: StorefrontFormularioAvaliacao;
+    }>) => {
+        idProduto?: number | undefined;
+        nota?: number | undefined;
+        nome?: string | undefined;
+        ip?: string | undefined;
+        email?: string | undefined;
+        titulo?: string | undefined;
+        comentario?: string | undefined;
+        cidade?: string | undefined;
+        dataAvaliacao?: string | undefined;
+    };
+    formularioAvaliacaoCarregando: (state: {
+        carregando: boolean;
+        formularioAvaliacao: {
+            idProduto?: number | undefined;
+            nota?: number | undefined;
+            nome?: string | undefined;
+            ip?: string | undefined;
+            email?: string | undefined;
+            titulo?: string | undefined;
+            comentario?: string | undefined;
+            cidade?: string | undefined;
+            dataAvaliacao?: string | undefined;
+        };
+    } & import("pinia").PiniaCustomStateProperties<{
+        carregando: boolean;
+        formularioAvaliacao: StorefrontFormularioAvaliacao;
+    }>) => boolean;
+}, {
+    resetarFormularioAvaliacao(): Promise<void>;
+    enviarAvaliacao(avaliacao: StorefrontFormularioAvaliacao): Promise<void>;
+}>;

package/dist/runtime/stores/avaliacoes.js

@@ -0,0 +1,63 @@
+import { traduzirEnviarAvaliacao } from "godeep-types/translate";
+import { defineStore } from "pinia";
+import { alerta } from "../utils/alerta.js";
+const formularioAvaliacaoDefault = {
+  idProduto: 0,
+  nota: 0,
+  nome: "",
+  ip: "",
+  email: "",
+  titulo: "",
+  comentario: ""
+};
+export const storeAvaliacoes = defineStore("avaliacoes", {
+  state: () => ({
+    carregando: false,
+    formularioAvaliacao: formularioAvaliacaoDefault
+  }),
+  getters: {
+    recuperarFormularioAvaliacao: (state) => state.formularioAvaliacao,
+    formularioAvaliacaoCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarFormularioAvaliacao() {
+      this.formularioAvaliacao = formularioAvaliacaoDefault;
+      this.carregando = false;
+    },
+    async enviarAvaliacao(avaliacao) {
+      try {
+        if (this.formularioAvaliacao.idProduto === 0 || this.formularioAvaliacao.nota === 0 || this.formularioAvaliacao.nome === "" || this.formularioAvaliacao.email === "" || this.formularioAvaliacao.titulo === "" || this.formularioAvaliacao.comentario === "") {
+          alerta.adicionar({
+            titulo: "Erro",
+            descricao: "Formul\xE1rio incompleto",
+            cor: "error",
+            variantes: ["dashed", "soft"]
+          });
+          return;
+        }
+        this.carregando = true;
+        await $fetch("/api/front-api/comentarios", {
+          method: "POST",
+          body: traduzirEnviarAvaliacao(avaliacao)
+        });
+        this.carregando = false;
+        alerta.adicionar({
+          titulo: "Avalia\xE7\xE3o enviada com sucesso!",
+          descricao: "Sua avalia\xE7\xE3o ser\xE1 publicada ap\xF3s an\xE1lise.",
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        this.resetarFormularioAvaliacao();
+      } catch {
+        this.carregando = false;
+        alerta.adicionar({
+          titulo: "Erro",
+          descricao: "Erro ao enviar avalia\xE7\xE3o",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        this.resetarFormularioAvaliacao();
+      }
+    }
+  }
+});

package/dist/runtime/stores/banner.d.ts

@@ -0,0 +1,6 @@
+import type { StorefrontBanner } from 'godeep-types/types';
+export declare const storeBanners: import("pinia").StoreDefinition<"banners", {
+    banners: StorefrontBanner[];
+    bannersCache: Record<string, StorefrontBanner[]>;
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/banner.js

@@ -0,0 +1,88 @@
+import { traduzirBanners } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storeBanners = defineStore("banners", {
+  state: () => ({
+    banners: [],
+    bannersCache: {},
+    carregando: false
+  }),
+  getters: {
+    recuperarBanners: (state) => state.banners,
+    bannersCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarBanners() {
+      this.banners = [];
+      this.carregando = false;
+    },
+    async buscarBanners(posicao = "", localizacao = "", local = "", slug = "", usarCache = true) {
+      try {
+        this.carregando = true;
+        const chaveCache = `${posicao}-${localizacao}-${local}-${slug}`;
+        console.log(`Chave do cache: ${chaveCache}`);
+        if (usarCache && this.bannersCache[chaveCache]) {
+          console.log(
+            `Cache encontrado para ${chaveCache}:`,
+            this.bannersCache[chaveCache].length
+          );
+          this.banners = this.bannersCache[chaveCache];
+          this.carregando = false;
+          return;
+        }
+        console.log(`Cache n\xE3o encontrado para ${chaveCache}, buscando...`);
+        const query = new URLSearchParams();
+        if (localizacao) {
+          query.append("localizacao", localizacao);
+        }
+        if (local) {
+          query.append("local", local);
+        }
+        if (posicao) {
+          query.append("posicao", posicao);
+        }
+        let url = `/api/front-api/banners`;
+        if (slug && slug !== "mock") {
+          url = `/mocks/${slug}.json`;
+        } else if (localizacao) {
+          url = `/mocks/${localizacao}.json`;
+        } else if (posicao) {
+          url = `/mocks/${posicao}.json`;
+        }
+        console.log(
+          `Buscando banners: slug=${slug}, localizacao=${localizacao}, posicao=${posicao}, url=${url}`
+        );
+        const resposta = await $fetch(url);
+        const dados = resposta?.dados ?? [];
+        console.log(`Dados recebidos:`, dados.length, dados);
+        const bannersTraduzidos = traduzirBanners(dados);
+        console.log(`Banners traduzidos:`, bannersTraduzidos.length);
+        this.banners = bannersTraduzidos;
+        if (usarCache) {
+          this.bannersCache[chaveCache] = bannersTraduzidos;
+          console.log(
+            `Banners salvos no cache com chave: ${chaveCache}, quantidade: ${bannersTraduzidos.length}`
+          );
+        }
+        console.log(`Banners carregados para ${posicao}:`, this.banners.length);
+      } catch (error) {
+        console.error(`Erro ao buscar banners para ${posicao}:`, error);
+        this.banners = [];
+      } finally {
+        this.carregando = false;
+      }
+    },
+    recuperarBannersDoCache(posicao = "", localizacao = "", local = "", slug = "") {
+      const chaveCache = `${posicao}-${localizacao}-${local}-${slug}`;
+      console.log(
+        `Recuperando do cache: chave=${chaveCache}, cache keys:`,
+        Object.keys(this.bannersCache)
+      );
+      const resultado = this.bannersCache[chaveCache];
+      console.log(`Resultado do cache:`, resultado?.length ?? 0);
+      return resultado;
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/busca.d.ts

@@ -0,0 +1,8 @@
+import type { StorefrontCardItem } from 'godeep-types/types';
+export declare const storeBusca: import("pinia").StoreDefinition<"busca", {
+    resultados: StorefrontCardItem[];
+    carregando: boolean;
+    mostrarResultados: boolean;
+    abrirResultados: boolean;
+    maisBuscados: boolean;
+}, {}, {}>;