@ecomiq/storefront 1.1.5 → 2.0.0

package/src/auth/ecomiq-oauth-password-plugin.ts

@@ -0,0 +1,299 @@
+import {
+  createAuthEndpoint,
+  createAuthMiddleware,
+  formCsrfMiddleware,
+} from "better-auth/api";
+import { APIError, type BetterAuthPlugin } from "better-auth";
+import { setSessionCookie } from "better-auth/cookies";
+import { parseUserOutput } from "better-auth/db";
+
+import { readProcessEnv } from "./env";
+import {
+  DEFAULT_STOREFRONT_API_URL,
+  PLUGIN_ID,
+  STOREFRONT_API_PATH_PREFIX,
+  STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME,
+  STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH,
+  STOREFRONT_HEADERS,
+} from "./ecomiq-oauth-password-constants";
+import {
+  customerLoginResponseSchema,
+  signInBody,
+} from "./ecomiq-oauth-password-types";
+
+type StoreIdentityContext = {
+  identityScope?: string | null;
+  tenantId?: string | null;
+  storeId?: string | null;
+};
+
+/**
+ * Inicia sesión contra `POST /v1/customer/login` del storefront Ecomiq,
+ * crea/actualiza el usuario en Better Auth y guarda el bearer en cookie HttpOnly
+ * acotada a `/api/store` (proxy BFF).
+ */
+export function ecomiqOAuthPassword(): BetterAuthPlugin {
+  const secureCookie = true;
+  const clearStorefrontOAuthCookieMiddleware = createAuthMiddleware(async (ctx) => {
+    ctx.setCookie(STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME, "", {
+      path: STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH,
+      httpOnly: true,
+      sameSite: "lax",
+      secure: secureCookie,
+      maxAge: 0,
+    });
+  });
+
+  return {
+    id: PLUGIN_ID,
+    schema: {
+      user: {
+        fields: {
+          firstName: { type: "string", required: false },
+          lastName: { type: "string", required: false },
+          phone: { type: "string", required: false },
+        },
+      },
+    },
+    hooks: {
+      after: [
+        {
+          matcher: (hookCtx) => hookCtx.path === "/sign-out",
+          handler: clearStorefrontOAuthCookieMiddleware,
+        },
+      ],
+    },
+    endpoints: {
+      signIn: createAuthEndpoint(
+        "/ecomiq-oauth/sign-in",
+        {
+          method: "POST",
+          use: [formCsrfMiddleware],
+          body: signInBody,
+        },
+        async (ctx) => {
+          const { email: loginEmail, password, callbackURL, rememberMe } = ctx.body;
+
+          const login = await customerPasswordLogin(loginEmail, password, {
+            identityScope: ctx.getHeader(STOREFRONT_HEADERS.identityScope),
+            tenantId: ctx.getHeader(STOREFRONT_HEADERS.tenantId),
+            storeId: ctx.getHeader(STOREFRONT_HEADERS.storeId),
+          });
+
+          const canonicalEmail = loginEmail.toLowerCase().trim();
+          const displayName = canonicalEmail.split("@")[0] || "Cliente";
+
+          const existing = await ctx.context.internalAdapter.findUserByEmail(canonicalEmail);
+          let user = existing?.user;
+          if (!user) {
+            user = await ctx.context.internalAdapter.createUser({
+              email: canonicalEmail,
+              name: displayName,
+              emailVerified: login.customer.isVerified,
+            });
+          } else if (user.name !== displayName) {
+            await ctx.context.internalAdapter.updateUser(user.id, { name: displayName });
+            user = { ...user, name: displayName };
+          }
+
+          const oauthSessionExpires =
+            login.expiresIn !== undefined && login.expiresIn > 0
+              ? new Date(Date.now() + login.expiresIn * 1000)
+              : undefined;
+
+          const session = await ctx.context.internalAdapter.createSession(
+            user.id,
+            rememberMe === false,
+            oauthSessionExpires ? { expiresAt: oauthSessionExpires } : {},
+            Boolean(oauthSessionExpires),
+          );
+
+          if (!session) {
+            throw APIError.from("INTERNAL_SERVER_ERROR", {
+              code: "ECOMIQ_SESSION_FAILED",
+              message: "No se pudo crear la sesión",
+            });
+          }
+
+          await setSessionCookie(ctx, { session, user }, rememberMe === false);
+
+          const oauthMaxAgeSec =
+            oauthSessionExpires !== undefined
+              ? Math.max(60, Math.ceil((oauthSessionExpires.getTime() - Date.now()) / 1000))
+              : login.expiresIn !== undefined && login.expiresIn > 0
+                ? login.expiresIn
+                : 60 * 60 * 24;
+
+          await ctx.setCookie(STOREFRONT_ECOMIQ_OAUTH_COOKIE_NAME, login.accessToken, {
+            path: STOREFRONT_ECOMIQ_OAUTH_COOKIE_PATH,
+            httpOnly: true,
+            sameSite: "lax",
+            secure: secureCookie,
+            maxAge: oauthMaxAgeSec,
+          });
+
+          if (callbackURL) ctx.setHeader("Location", callbackURL);
+
+          return ctx.json({
+            redirect: !!callbackURL,
+            token: session.token,
+            url: callbackURL,
+            user: parseUserOutput(ctx.context.options, user),
+          });
+        },
+      ),
+    },
+  } satisfies BetterAuthPlugin;
+}
+
+function resolveCustomerLoginUrl(): string {
+  const base = (readProcessEnv("STOREFRONT_API_URL") ?? DEFAULT_STOREFRONT_API_URL).replace(
+    /\/$/,
+    "",
+  );
+  return `${base}/${STOREFRONT_API_PATH_PREFIX}/customer/login`;
+}
+
+type ApiErrorBody = {
+  error?: string;
+  message?: string;
+  title?: string;
+  detail?: string;
+};
+
+async function customerPasswordLogin(
+  email: string,
+  password: string,
+  context: StoreIdentityContext,
+): Promise<ReturnType<typeof customerLoginResponseSchema.parse>> {
+  const headers = new Headers({
+    "content-type": "application/json",
+    accept: "application/json",
+  });
+
+  const identityScope = context.identityScope?.trim();
+  const tenantId = context.tenantId?.trim();
+  const storeId = context.storeId?.trim();
+
+  if (identityScope) {
+    headers.set(STOREFRONT_HEADERS.identityScope, identityScope);
+  }
+  if (tenantId) {
+    headers.set(STOREFRONT_HEADERS.tenantId, tenantId);
+  }
+  if (storeId) {
+    headers.set(STOREFRONT_HEADERS.storeId, storeId);
+  }
+
+  let res: Response;
+  let text: string;
+  try {
+    res = await fetch(resolveCustomerLoginUrl(), {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ email, password }),
+    });
+    text = await res.text();
+  } catch (e) {
+    throw mapCustomerLoginFetchFailure(e);
+  }
+
+  const json = safeParseJson(text);
+  if (!res.ok) {
+    throwBadRequestFromLoginApi(json, res.statusText || text || `HTTP ${res.status}`);
+  }
+
+  const parsed = customerLoginResponseSchema.safeParse(json);
+  if (!parsed.success) {
+    throw APIError.from("UNAUTHORIZED", {
+      code: "ECOMIQ_LOGIN_SHAPE",
+      message: "Respuesta de login con formato inválido",
+    });
+  }
+
+  if (parsed.data.customer.status !== "active") {
+    throw APIError.from("UNAUTHORIZED", {
+      code: "ECOMIQ_CUSTOMER_INACTIVE",
+      message: "La cuenta del cliente no está activa",
+    });
+  }
+
+  return parsed.data;
+}
+
+function safeParseJson(text: string): unknown {
+  try {
+    return text ? JSON.parse(text) : {};
+  } catch {
+    return {};
+  }
+}
+
+function throwBadRequestFromLoginApi(payload: unknown, fallbackMessage: string): never {
+  const err = payload as ApiErrorBody;
+  const errorCode =
+    typeof err.error === "string" && err.error.trim() ? err.error.trim() : "invalid_credentials";
+  const errorMessage =
+    (typeof err.message === "string" && err.message.trim()) ||
+    (typeof err.detail === "string" && err.detail.trim()) ||
+    (typeof err.title === "string" && err.title.trim()) ||
+    (typeof err.error === "string" && err.error.trim()) ||
+    fallbackMessage.trim() ||
+    "Credenciales inválidas.";
+  throw APIError.from("BAD_REQUEST", {
+    code: errorCode,
+    message: errorMessage.slice(0, 500),
+  });
+}
+
+function mapCustomerLoginFetchFailure(e: unknown): never {
+  const codes = collectNetworkErrorCodes(e);
+  const msg = e instanceof Error ? e.message : String(e);
+
+  const isDnsError = codes.some((c) => c === "ENOTFOUND" || c === "EAI_AGAIN");
+  if (isDnsError) {
+    throw APIError.from("BAD_GATEWAY", {
+      code: "ECOMIQ_LOGIN_DNS",
+      message: "No se pudo resolver el servidor de la tienda.",
+    });
+  }
+
+  const isConnectionRefused = codes.includes("ECONNREFUSED");
+  if (isConnectionRefused) {
+    throw APIError.from("BAD_GATEWAY", {
+      code: "ECOMIQ_LOGIN_REFUSED",
+      message: "Conexión rechazada al servidor de la tienda.",
+    });
+  }
+
+  const looksLikeAbortOrSocketClose =
+    codes.some((c) =>
+      ["UND_ERR_SOCKET", "ECONNRESET", "EPIPE", "ECONNABORTED"].includes(c),
+    ) || /terminated|abort|closed|FIN|socket/i.test(msg);
+
+  if (looksLikeAbortOrSocketClose) {
+    throwBadRequestFromLoginApi({}, "Credenciales inválidas o conexión cerrada por el servidor.");
+  }
+
+  throw APIError.from("INTERNAL_SERVER_ERROR", {
+    code: "ECOMIQ_LOGIN_REQUEST_FAILED",
+    message: msg.slice(0, 280) || "Error al contactar el servidor de la tienda.",
+  });
+}
+
+function collectNetworkErrorCodes(e: unknown): string[] {
+  const out: string[] = [];
+  const visit = (x: unknown): void => {
+    if (!x || typeof x !== "object") return;
+    const code =
+      "code" in x && typeof (x as { code?: unknown }).code === "string"
+        ? (x as { code: string }).code
+        : undefined;
+    if (code) out.push(code);
+    if ("cause" in x && (x as { cause?: unknown }).cause) {
+      visit((x as { cause: unknown }).cause);
+    }
+  };
+  visit(e);
+  return out;
+}

package/src/auth/ecomiq-oauth-password-types.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+
+export const customerLoginCustomerSchema = z.object({
+  id: z.coerce.number(),
+  publicId: z.union([z.coerce.number(), z.string()]),
+  status: z.string(),
+  isVerified: z.boolean(),
+});
+
+/** Respuesta de `POST /v1/customer/login`. */
+export const customerLoginResponseSchema = z.object({
+  accessToken: z.string().min(1),
+  refreshToken: z.string().optional(),
+  /** Segundos hasta expiración (ej. `86399`). Sincroniza la sesión Better Auth con el bearer. */
+  expiresIn: z.coerce.number().int().positive().optional(),
+  tokenType: z.string().optional(),
+  customer: customerLoginCustomerSchema,
+});
+
+export const signInBody = z.object({
+  email: z.string().email(),
+  password: z.string().min(1),
+  callbackURL: z.string().optional(),
+  rememberMe: z.boolean().optional().default(true),
+});

package/src/auth/ecomiq-storefront-sign-in.ts

@@ -0,0 +1,47 @@
+import type { StorefrontSettings } from '@ecomiq/core'
+import { STOREFRONT_HEADERS } from './ecomiq-oauth-password-constants'
+
+export type EcomiqSignInCredentials = {
+  email: string
+  password: string
+}
+
+/** Cliente Better Auth con `$fetch` (p. ej. resultado de `createStorefrontAuthClient`). */
+export type StorefrontAuthFetchClient = {
+  $fetch: (
+    path: string,
+    init: {
+      method: string
+      headers: Record<string, string | undefined>
+      body: EcomiqSignInCredentials
+    },
+  ) => Promise<{ error?: { message?: string } | null }>
+}
+
+/**
+ * Inicia sesión con email/contraseña vía plugin `ecomiqOAuthPassword`
+ * (Better Auth → `/v1/customer/login`).
+ */
+export async function signInWithEcomiqCredentials(
+  authClient: StorefrontAuthFetchClient,
+  settings: StorefrontSettings | null | undefined,
+  credentials: EcomiqSignInCredentials,
+) {
+  const response = await authClient.$fetch('/ecomiq-oauth/sign-in', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      [STOREFRONT_HEADERS.storeId]: settings?.store.id,
+      [STOREFRONT_HEADERS.tenantId]: settings?.store.tenantId,
+      [STOREFRONT_HEADERS.identityScope]:
+        settings?.store.checkoutSettings.general.identityScope,
+    },
+    body: credentials,
+  })
+
+  if (response.error) {
+    throw new Error(response.error.message ?? 'Error al iniciar sesión')
+  }
+
+  return response
+}

package/src/auth/env.ts

@@ -0,0 +1,7 @@
+/** Lee una variable de entorno sin depender de `@types/node`. */
+export function readProcessEnv(name: string): string | undefined {
+  const env = (globalThis as { process?: { env?: Record<string, string | undefined> } })
+    .process?.env
+  const value = env?.[name]
+  return typeof value === 'string' && value.length > 0 ? value : undefined
+}

package/src/cart-session.ts

@@ -0,0 +1,241 @@
+import {
+  ApiError,
+  cartVariantIdFromProduct,
+  type RemoveCartItemParams,
+  type StorefrontCart,
+  type StorefrontClient,
+  type UpdateCartItemQuantityParams,
+} from '@ecomiq/core'
+import { z } from 'zod'
+
+type CartClient = Pick<StorefrontClient, 'getCart' | 'createCart' | 'addCartItem'>
+
+export interface LoadActiveCartInput {
+  cartId: string
+}
+
+export type ActiveCartLoadResult =
+  | { ok: true; value: StorefrontCart | null }
+  | {
+      ok: false
+      error: {
+        kind: 'failed'
+        message: string
+      }
+    }
+
+export type CartItemMutationResult =
+  | { ok: true; value: StorefrontCart }
+  | {
+      ok: false
+      error: {
+        kind: 'cart-unavailable' | 'unavailable' | 'failed'
+        message: string
+      }
+    }
+
+export interface AddProductToCartInput {
+  cartId?: string
+  currencyCode: string
+  variantId: string
+  quantity: number
+}
+
+export interface AddProductToCartResult {
+  cartId: string
+  cart: StorefrontCart
+  created: boolean
+}
+
+export type ProductCartMutationResult =
+  | { ok: true; value: AddProductToCartResult }
+  | {
+      ok: false
+      error: {
+        kind: 'unavailable' | 'failed'
+        message: string
+      }
+    }
+
+const StorefrontProblemSchema = z.object({
+  code: z.string().optional(),
+}).passthrough()
+
+function cartIsUnavailable(error: unknown) {
+  if (!(error instanceof ApiError)) return false
+  const problem = StorefrontProblemSchema.safeParse(error.body)
+  if (!problem.success) return false
+  if (error.status === 404 && problem.data.code === 'Carts.NotFound') return true
+  return error.status === 400 && problem.data.code === 'Carts.NotActive'
+}
+
+function cartIsActive(cart: StorefrontCart) {
+  return cart.status === 'inProgress' || cart.status === 'pending'
+}
+
+function cartItemMutationFailure(error: ApiError): CartItemMutationResult {
+  if (cartIsUnavailable(error)) {
+    return {
+      ok: false,
+      error: {
+        kind: 'cart-unavailable',
+        message: 'Este carrito ya no está disponible.',
+      },
+    }
+  }
+
+  const problem = StorefrontProblemSchema.safeParse(error.body)
+  if (problem.success && problem.data.code === 'Catalog.InsufficientStock') {
+    return {
+      ok: false,
+      error: {
+        kind: 'unavailable',
+        message: 'No hay stock suficiente para esa cantidad.',
+      },
+    }
+  }
+  if (problem.success && problem.data.code === 'Carts.ItemNotFound') {
+    return {
+      ok: false,
+      error: {
+        kind: 'unavailable',
+        message: 'Este producto ya no está en el carrito.',
+      },
+    }
+  }
+
+  return {
+    ok: false,
+    error: {
+      kind: 'failed',
+      message: 'No pudimos actualizar el carrito. Inténtalo nuevamente.',
+    },
+  }
+}
+
+export async function loadActiveCart(
+  client: Pick<StorefrontClient, 'getCart'>,
+  input: LoadActiveCartInput,
+): Promise<ActiveCartLoadResult> {
+  try {
+    const cart = await client.getCart({ cartId: input.cartId })
+    return { ok: true as const, value: cartIsActive(cart) ? cart : null }
+  } catch (error) {
+    if (cartIsUnavailable(error)) return { ok: true as const, value: null }
+    if (error instanceof ApiError) {
+      return {
+        ok: false,
+        error: {
+          kind: 'failed',
+          message: 'No pudimos cargar el carrito. Inténtalo nuevamente.',
+        },
+      }
+    }
+    throw error
+  }
+}
+
+export async function submitCartItemQuantity(
+  client: Pick<StorefrontClient, 'updateCartItemQuantity'>,
+  input: UpdateCartItemQuantityParams,
+): Promise<CartItemMutationResult> {
+  try {
+    const cart = await client.updateCartItemQuantity(input)
+    return { ok: true, value: cart }
+  } catch (error) {
+    if (!(error instanceof ApiError)) throw error
+    return cartItemMutationFailure(error)
+  }
+}
+
+export async function submitCartItemRemoval(
+  client: Pick<StorefrontClient, 'updateCartItemQuantity'>,
+  input: RemoveCartItemParams,
+): Promise<CartItemMutationResult> {
+  try {
+    const cart = await client.updateCartItemQuantity({ ...input, quantity: 0 })
+    return { ok: true, value: cart }
+  } catch (error) {
+    if (!(error instanceof ApiError)) throw error
+    return cartItemMutationFailure(error)
+  }
+}
+
+export async function addProductToCart(
+  client: CartClient,
+  input: AddProductToCartInput,
+): Promise<AddProductToCartResult> {
+  const variantId = cartVariantIdFromProduct(input.variantId)
+  let current: StorefrontCart | undefined
+  let created = false
+
+  if (input.cartId) {
+    try {
+      const persisted = await client.getCart({ cartId: input.cartId })
+      if (cartIsActive(persisted)) current = persisted
+    } catch (error) {
+      if (!cartIsUnavailable(error)) throw error
+    }
+  }
+
+  if (!current) {
+    current = await client.createCart({ currencyCode: input.currencyCode })
+    created = true
+  }
+
+  const add = (cartId: string) => client.addCartItem({
+    cartId,
+    variantId,
+    quantity: input.quantity,
+  })
+
+  try {
+    const cart = await add(current.id)
+    return { cartId: cart.id, cart, created }
+  } catch (error) {
+    if (!cartIsUnavailable(error)) throw error
+    const replacement = await client.createCart({ currencyCode: input.currencyCode })
+    const cart = await add(replacement.id)
+    return { cartId: cart.id, cart, created: true }
+  }
+}
+
+export async function submitProductToCart(
+  client: CartClient,
+  input: AddProductToCartInput,
+): Promise<ProductCartMutationResult> {
+  try {
+    return { ok: true, value: await addProductToCart(client, input) }
+  } catch (error) {
+    if (!(error instanceof ApiError)) throw error
+
+    const problem = StorefrontProblemSchema.safeParse(error.body)
+    const code = problem.success ? problem.data.code : undefined
+    if (code === 'Catalog.InsufficientStock') {
+      return {
+        ok: false,
+        error: {
+          kind: 'unavailable',
+          message: 'No hay stock suficiente para esa cantidad.',
+        },
+      }
+    }
+    if (code === 'Catalog.VariantNotFound') {
+      return {
+        ok: false,
+        error: {
+          kind: 'unavailable',
+          message: 'Esta variante ya no está disponible.',
+        },
+      }
+    }
+
+    return {
+      ok: false,
+      error: {
+        kind: 'failed',
+        message: 'No pudimos actualizar el carrito. Inténtalo nuevamente.',
+      },
+    }
+  }
+}

package/src/client.ts

@@ -0,0 +1,48 @@
+import {
+  createClient as createCoreClient,
+  type CreateApiOptions,
+  type StorefrontClient,
+} from '@ecomiq/core'
+import { getServerConfig } from './server-config-store'
+
+let sharedClient: StorefrontClient | null = null
+
+/** Cliente storefront compartido (cache de settings incluido). */
+export function getStorefrontClient(options: CreateApiOptions = {}): StorefrontClient {
+  if (!sharedClient) {
+    const config = getServerConfig()
+    const headers = {
+      ...config.api?.headers,
+      ...options.headers,
+    }
+    for (const key of Object.keys(headers)) {
+      const lower = key.toLowerCase()
+      if (lower === 'x-store-id' || lower === 'x-store-domain') delete headers[key]
+    }
+    sharedClient = createCoreClient({
+      slug: config.slug,
+      ...config.api,
+      ...options,
+      headers,
+    })
+  }
+  return sharedClient
+}
+
+/** Invalida el singleton (tests / hot reload). */
+export function resetStorefrontClient(): void {
+  sharedClient?.clearCache()
+  sharedClient = null
+}
+
+/**
+ * Cliente storefront. Slug y defaults de API salen del config de la tienda.
+ *
+ * ```ts
+ * export const api = createClient()
+ * const collections = await api.getCollections()
+ * ```
+ */
+export function createClient(_options: CreateApiOptions = {}): StorefrontClient {
+  return getStorefrontClient(_options)
+}