@ecomiq/storefront 2.0.16 → 2.0.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ecomiq/storefront",
-  "version": "2.0.16",
+  "version": "2.0.18",
   "description": "Micro framework SSR de Ecomiq para storefronts. Páginas, datos y deploy sin configurar nada.",
   "type": "module",
   "license": "MIT",
@@ -36,6 +36,7 @@
     "./internal/page": "./src/runtime/page.tsx",
     "./internal/context": "./src/runtime/context.ts",
     "./internal/server-config": "./src/server-config-store.ts",
+    "./internal/health": "./src/health.ts",
     "./internal/head": "./src/runtime/head.ts",
     "./internal/default-layout": "./src/runtime/default-layout.tsx",
     "./internal/checkout": "./src/pages/checkout.tsx",
@@ -78,7 +79,7 @@
     "vite": "^8.1.0",
     "wrangler": "^4.100.0",
     "zod": "^3.25.0",
-    "@ecomiq/core": "^0.1.5"
+    "@ecomiq/core": "^0.1.6"
   },
   "peerDependencies": {
     "react": "^19.0.0",

package/src/codegen.mjs

@@ -155,15 +155,18 @@ export async function generateApp({ cwd, appDir, frameworkRoot, config }) {
     HEADER +
       `import startServer, { createServerEntry } from '@tanstack/react-start/server-entry'\n` +
       `import config from '../../ecomiq.config.js'\n` +
-      `import { registerServerConfig } from '@ecomiq/storefront/internal/server-config'\n\n` +
+      `import { registerServerConfig } from '@ecomiq/storefront/internal/server-config'\n` +
+      `import { handleEcomiqHealth } from '@ecomiq/storefront/internal/health'\n\n` +
       `export default createServerEntry({\n` +
-      `  async fetch(...args) {\n` +
+      `  async fetch(request, ...rest) {\n` +
       `    let api = config.api\n` +
       `    if (import.meta.env.DEV && config.dev?.apiBaseUrl) {\n` +
       `      api = { ...api, baseUrl: config.dev.apiBaseUrl }\n` +
       `    }\n` +
       `    registerServerConfig({ domain: config.domain, api })\n` +
-      `    return startServer.fetch(...args)\n` +
+      `    const health = await handleEcomiqHealth(request)\n` +
+      `    if (health) return health\n` +
+      `    return startServer.fetch(request, ...rest)\n` +
       `  },\n` +
       `})\n`,
   )

package/src/health.ts

@@ -0,0 +1,90 @@
+/**
+ * Health interno del runtime storefront.
+ * GET /ping            → liveness puro: "ok" 200 (target del probe de vm-manager).
+ * GET /__ecomiq/health → proceso up + estado de /v1/settings (sin SSR de páginas).
+ */
+import { getStorefrontClient } from './client'
+
+export const ECOMIQ_HEALTH_PATH = '/__ecomiq/health'
+export const ECOMIQ_PING_PATH = '/ping'
+
+export type EcomiqHealthSettingsStatus = {
+  ok: boolean
+  latencyMs: number
+  storeId?: string
+  domain?: string | null
+  error?: string
+}
+
+export type EcomiqHealthResponse = {
+  ok: true
+  settings: EcomiqHealthSettingsStatus
+}
+
+async function probeSettings(): Promise<EcomiqHealthSettingsStatus> {
+  const started = Date.now()
+  try {
+    const settings = await getStorefrontClient().getSettings()
+    return {
+      ok: true,
+      latencyMs: Date.now() - started,
+      storeId: settings.store.id,
+      domain: settings.store.domain ?? settings.store.slug,
+    }
+  } catch (error) {
+    return {
+      ok: false,
+      latencyMs: Date.now() - started,
+      error: error instanceof Error ? error.message : String(error),
+    }
+  }
+}
+
+/**
+ * Si el request es al health interno, responde JSON.
+ * Si no, `null` para que el caller siga con el fetch normal de TanStack.
+ */
+export async function handleEcomiqHealth(
+  request: Request,
+): Promise<Response | null> {
+  const { pathname } = new URL(request.url)
+  if (pathname !== ECOMIQ_HEALTH_PATH && pathname !== ECOMIQ_PING_PATH) {
+    return null
+  }
+
+  if (request.method !== 'GET' && request.method !== 'HEAD') {
+    return new Response(null, {
+      status: 405,
+      headers: { allow: 'GET, HEAD' },
+    })
+  }
+
+  if (pathname === ECOMIQ_PING_PATH) {
+    return new Response(request.method === 'HEAD' ? null : 'ok', {
+      status: 200,
+      headers: {
+        'content-type': 'text/plain; charset=utf-8',
+        'cache-control': 'no-store',
+      },
+    })
+  }
+
+  const body: EcomiqHealthResponse = {
+    ok: true,
+    settings: await probeSettings(),
+  }
+
+  if (request.method === 'HEAD') {
+    return new Response(null, {
+      status: 200,
+      headers: { 'content-type': 'application/json; charset=utf-8' },
+    })
+  }
+
+  return Response.json(body, {
+    status: 200,
+    headers: {
+      'cache-control': 'no-store',
+    },
+  })
+}

package/src/providers/auth.tsx

@@ -17,7 +17,7 @@ import {
   signInWithEcomiqCredentials,
   type EcomiqSignInCredentials,
 } from '../auth/ecomiq-storefront-sign-in'
-import { useSettings } from './ecomiq'
+import { AppEcomiqContext } from './ecomiq'
 
 export type CreateStorefrontAuthClientOptions = {
   baseURL?: string
@@ -55,7 +55,9 @@ export function useAuth() {
   if (!client) throw new Error('useAuth debe usarse dentro de AuthProvider')
 
   const sessionQuery = client.useSession()
-  const settings = useSettings()
+  // Mismo módulo que AppEcomiqProvider (no useSettings del barrel) + soft read
+  // para no tumbar el árbol si hay re-render concurrente post-sesión.
+  const ecomiq = useContext(AppEcomiqContext)
 
   return {
     client,
@@ -63,7 +65,10 @@ export function useAuth() {
     isPending: sessionQuery.isPending,
     error: sessionQuery.error,
     signIn: async (credentials: EcomiqSignInCredentials) => {
-      await signInWithEcomiqCredentials(client, settings, credentials)
+      if (!ecomiq) {
+        throw new Error('signIn requiere AppEcomiqProvider')
+      }
+      await signInWithEcomiqCredentials(client, ecomiq.settings, credentials)
       const result = await client.getSession()
       const session = (result as { data?: StorefrontSession | null })?.data ?? null
       if (!session?.user) {

package/src/runtime/page.tsx

@@ -1,14 +1,25 @@
 /**
- * Runtime interno de Ecomiq (solo lo importa el código generado en .ecomiq).
+ * Runtime interno de Ecomiq (solo lo importa el código generado en `.ecomiq`).
  * Traduce el contrato público `definePage` a las opciones del router interno.
  */
+import { useContext } from 'react'
+import { useRouterState } from '@tanstack/react-router'
 import type { StorefrontSettings } from '@ecomiq/core'
 import type { EcomiqPage, PublicEcomiqConfig } from '../index'
-import { useSettings } from '../providers'
+import { AppEcomiqContext } from '../providers/ecomiq'
 import { serverApi } from '../server'
 import { StorefrontError } from '../ui/storefront-error'
 import { buildPageHead } from './head'
 
+function isSettings(value: unknown): value is StorefrontSettings {
+  return Boolean(
+    value &&
+      typeof value === 'object' &&
+      value !== null &&
+      'store' in value,
+  )
+}
+
 async function resolveSettingsForMeta(
   matches?: Array<{ loaderData?: unknown }>,
 ): Promise<StorefrontSettings | undefined> {
@@ -16,8 +27,8 @@ async function resolveSettingsForMeta(
   // En SSR `matches` suele venir stale (updateMatch no muta el array), así que
   // caemos a serverApi: el cliente core cachea settings y no hay HTTP extra.
   const fromRoot = matches?.[0]?.loaderData
-  if (fromRoot && typeof fromRoot === 'object' && fromRoot !== null && 'store' in fromRoot) {
-    return fromRoot as StorefrontSettings
+  if (isSettings(fromRoot)) {
+    return fromRoot
   }
   try {
     return await serverApi.getSettings()
@@ -26,6 +37,18 @@ async function resolveSettingsForMeta(
   }
 }
 
+function usePageSettings(): StorefrontSettings | undefined {
+  // Mismo módulo que AppEcomiqProvider (no el barrel) para evitar contextos duplicados.
+  const fromProvider = useContext(AppEcomiqContext)?.settings
+  const fromRootLoader = useRouterState({
+    select: (state) => {
+      const data = state.matches[0]?.loaderData
+      return isSettings(data) ? data : undefined
+    },
+  })
+  return fromProvider ?? fromRootLoader
+}
+
 export function pageToRouteOptions<
   TData,
   TParams extends Record<string, string>,
@@ -108,7 +131,13 @@ export function PageBoundary<
   params: TParams
   search: TSearch
 }) {
-  const settings = useSettings()
+  const settings = usePageSettings()
+  // Concurrent render / contexto duplicado: no tumbar el root.
+  // El re-render sync con provider o el loader del root suelen recuperar.
+  if (!settings) {
+    const Loading = page.loading
+    return Loading ? <Loading /> : null
+  }
   const Component = page.component
   return <Component data={data} params={params} search={search} settings={settings} />
 }

package/src/vite-inline.mjs

@@ -198,12 +198,20 @@ export function createViteConfig({ appDir, config, projectRoot, runtime }) {
     configFile: false,
     publicDir: resolve(appDir, '../public'),
     resolve: {
+      // Evita dos copias de React/context: el template resuelve desde
+      // node_modules del proyecto y `.ecomiq` desde symlinks — sin dedupe,
+      // AppEcomiqProvider y useSettings no comparten el mismo createContext
+      // (falla al re-render post useSession de Better Auth).
+      // No aliasar `@ecomiq/storefront` → rompe subpaths (`/internal/*`).
       dedupe: [
         'react',
         'react-dom',
+        '@ecomiq/storefront',
+        '@ecomiq/core',
         '@tanstack/react-router',
         '@tanstack/react-start',
         '@tanstack/react-query',
+        'better-auth',
       ],
     },
     plugins,