@eva_solutions/auth-sdk 0.0.0-stage → 3.0.0-dev-20261107051125

package/dist/http-client-Da0-OMfc.js

@@ -0,0 +1,206 @@
+import { a as HEADERS } from "./constants-rNuD5qJn.js";
+import { d as SESSION_ROUTES, f as USER_ROUTES, i as DIRECTORIO_ROUTES, r as AUTH_ROUTES } from "./routes-F1g5aVqP.js";
+import { t as apiPath } from "./api-path-B-vSkL2H.js";
+import { c as isEvaAuthConfigError, s as getProduct, t as parseErrorResponse } from "./parse-error-response-BM9-kjs0.js";
+import { r as getAuthServiceUrl } from "./constants-BY7QZokc.js";
+import { z } from "zod";
+// src/http-client.ts
+const AuthServiceResponseSchema = z.object({ data: z.unknown() });
+const AUTH_SERVICE_TIMEOUT = 1e4;
+const extractTokens = (headers) => {
+	const accessToken = headers.get(HEADERS.NEW_ACCESS_TOKEN);
+	const refreshToken = headers.get(HEADERS.NEW_REFRESH_TOKEN);
+	if (!accessToken || !refreshToken) return void 0;
+	return {
+		accessToken,
+		refreshToken
+	};
+};
+const authFetch = async (path, options = {}) => {
+	const { method = "GET", accessToken, refreshToken, body } = options;
+	const headers = { "content-type": "application/json" };
+	if (accessToken) headers[HEADERS.AUTHORIZATION] = `Bearer ${accessToken}`;
+	if (refreshToken) headers[HEADERS.REFRESH_TOKEN] = refreshToken;
+	try {
+		const res = await fetch(`${getAuthServiceUrl()}${path}`, {
+			method,
+			headers,
+			signal: AbortSignal.timeout(AUTH_SERVICE_TIMEOUT),
+			...body ? { body: JSON.stringify(body) } : {}
+		});
+		if (!res.ok) {
+			const body = await res.json().catch(() => null);
+			return {
+				ok: false,
+				error: parseErrorResponse(res.status, body)
+			};
+		}
+		const json = await res.json();
+		const parsed = AuthServiceResponseSchema.safeParse(json);
+		if (!parsed.success) return {
+			ok: false,
+			error: {
+				kind: "sdk",
+				reason: "malformed",
+				message: "Estructura de respuesta inválida",
+				status: 502
+			}
+		};
+		const data = parsed.data.data;
+		if (Array.isArray(data)) return {
+			ok: true,
+			data
+		};
+		if (options.reissuesAccessTokenOnly) {
+			const accessToken = res.headers.get(HEADERS.NEW_ACCESS_TOKEN);
+			return {
+				ok: true,
+				data: {
+					...data,
+					...accessToken ? { accessToken } : {}
+				}
+			};
+		}
+		const tokens = extractTokens(res.headers);
+		return {
+			ok: true,
+			data: {
+				...data,
+				...tokens ? { tokens } : {}
+			}
+		};
+	} catch (err) {
+		if (isEvaAuthConfigError(err)) throw err;
+		return {
+			ok: false,
+			error: {
+				kind: "sdk",
+				reason: "network",
+				message: err instanceof Error ? err.message : "Error de red",
+				status: 0
+			}
+		};
+	}
+};
+/**
+* Solicita un código OTP. En éxito devuelve `{ message, challengeId }`:
+* `challengeId` es opaco, el caller debe conservarlo (en memoria) y enviarlo a
+* `login`; cada `getCode` nuevo invalida el `challengeId` anterior.
+* El tipo es un cast: la respuesta del Auth Service no se parsea en runtime.
+*/
+const getCode = (params) => authFetch(apiPath(AUTH_ROUTES.getCode), {
+	method: "POST",
+	body: { phone: params.phone }
+});
+/**
+* Verifica el código OTP. `challengeId` es obligatorio: debe ser el que
+* devolvió el `getCode` que originó el código; sin el desafío vigente el Auth
+* Service responde 401 sin consumir intentos.
+*
+* El `producto` del login sale SIEMPRE de `configureEvaAuth({ product })`, nunca del llamador: el
+* access token queda emitido para ese producto. `empresaId` (opcional) deja esa empresa activa en
+* la sesión si la persona pertenece a ella.
+*
+* @throws Error de configuración (`EvaAuthConfigError`) si falta `configureEvaAuth({ product })`.
+*/
+const login = (params) => {
+	const { phone, code, challengeId, empresaId, deviceType, os, browser, userAgent } = params;
+	return authFetch(apiPath(AUTH_ROUTES.login), {
+		method: "POST",
+		body: {
+			phone,
+			code,
+			challengeId,
+			producto: getProduct(),
+			...empresaId !== void 0 && { empresaId },
+			deviceType,
+			os,
+			browser,
+			userAgent
+		}
+	});
+};
+/**
+* Cambia la empresa activa de la sesión (`null` la deja sin empresa). Auth reemite SOLO el access
+* token (`x-eva-new-access-token`; el refresh no rota): llega en `accessToken`. Auth valida la
+* pertenencia; si la persona no pertenece, responde error.
+*/
+const setActiveEmpresa = (params) => authFetch(apiPath(AUTH_ROUTES.setActiveEmpresa), {
+	method: "POST",
+	accessToken: params.accessToken,
+	body: { empresaId: params.empresaId },
+	reissuesAccessTokenOnly: true
+});
+const refresh = (params) => authFetch(apiPath(AUTH_ROUTES.refresh), {
+	method: "POST",
+	refreshToken: params.refreshToken
+});
+const logout = (params) => authFetch(apiPath(AUTH_ROUTES.logout), {
+	method: "POST",
+	refreshToken: params.refreshToken
+});
+const getUser = (params) => authFetch(apiPath(USER_ROUTES.get), { accessToken: params.accessToken });
+const updateUser = (params) => authFetch(apiPath(USER_ROUTES.update), {
+	method: "PATCH",
+	accessToken: params.accessToken,
+	body: params.data
+});
+const deleteUser = (params) => authFetch(apiPath(USER_ROUTES.deactivate), {
+	method: "DELETE",
+	accessToken: params.accessToken
+});
+const getUserEmpresas = (params) => authFetch(apiPath(USER_ROUTES.listCompanies), { accessToken: params.accessToken });
+/**
+* Busca en el directorio de empresas (solo las activas que optaron por aparecer; solo campos de
+* perfil público; 50 por página). Basta el access token de usuario de CUALQUIER producto habilitado:
+* Auth limita los pedidos por usuario. La siguiente página se pide con el `nextCursor` recibido.
+*/
+const getDirectorio = (params) => {
+	const { accessToken, ...filters } = params;
+	const query = new URLSearchParams();
+	for (const [key, value] of Object.entries(filters)) if (value !== void 0) query.set(key, String(value));
+	const qs = query.toString();
+	return authFetch(`${apiPath(DIRECTORIO_ROUTES.search)}${qs === "" ? "" : `?${qs}`}`, { accessToken });
+};
+const getSessions = (params) => authFetch(apiPath(SESSION_ROUTES.list), { accessToken: params.accessToken });
+const deleteSession = (params) => {
+	if (!/^[\w-]+$/.test(params.sessionId)) return Promise.resolve({
+		ok: false,
+		error: {
+			kind: "sdk",
+			reason: "malformed",
+			message: "ID de sesión inválido",
+			status: 400
+		}
+	});
+	return authFetch(apiPath(SESSION_ROUTES.deleteOne, { id: params.sessionId }), {
+		method: "DELETE",
+		accessToken: params.accessToken
+	});
+};
+const deleteAllSessions = (params) => authFetch(apiPath(SESSION_ROUTES.deleteAll), {
+	method: "DELETE",
+	refreshToken: params.refreshToken
+});
+const health = () => authFetch("/health");
+function createHttpClient() {
+	return {
+		getCode,
+		login,
+		setActiveEmpresa,
+		refresh,
+		logout,
+		getUser,
+		updateUser,
+		deleteUser,
+		getUserEmpresas,
+		getDirectorio,
+		getSessions,
+		deleteSession,
+		deleteAllSessions,
+		health
+	};
+}
+export { createHttpClient as t };
+
+//# sourceMappingURL=http-client-Da0-OMfc.js.map

package/dist/http-client-Da0-OMfc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"http-client-Da0-OMfc.js","names":[],"sources":["../src/http-client.ts"],"sourcesContent":["import { z } from 'zod'\nimport {\n  AUTH_ROUTES,\n  DIRECTORIO_ROUTES,\n  SESSION_ROUTES,\n  USER_ROUTES,\n} from '@eva_solutions/auth-contracts'\nimport type {\n  DirectorioQuery,\n  DirectorioResponse,\n} from '@eva_solutions/auth-contracts'\nimport { apiPath } from './api-path'\nimport { getProduct, isEvaAuthConfigError } from './config'\nimport { HEADERS, getAuthServiceUrl } from './constants'\nimport { parseErrorResponse } from './parse-error-response'\nimport type {\n  EvaUser,\n  EvaSession,\n  EvaEmpresa,\n  Result,\n  TokenPair,\n  DeviceInfo,\n} from './types'\n\nconst AuthServiceResponseSchema = z.object({\n  data: z.unknown(),\n})\n\nconst AUTH_SERVICE_TIMEOUT = 10_000\n\ntype FetchOptions = {\n  method?: string\n  accessToken?: string\n  refreshToken?: string\n  body?: unknown\n  /** La respuesta reemite solo el access token (`x-eva-new-access-token`); el refresh no rota. */\n  reissuesAccessTokenOnly?: boolean\n}\n\nconst extractTokens = (headers: Headers): TokenPair | undefined => {\n  const accessToken = headers.get(HEADERS.NEW_ACCESS_TOKEN)\n  const refreshToken = headers.get(HEADERS.NEW_REFRESH_TOKEN)\n  if (!accessToken || !refreshToken) return undefined\n  return { accessToken, refreshToken }\n}\n\nconst authFetch = async <T>(\n  path: string,\n  options: FetchOptions = {},\n): Promise<Result<T & { tokens?: TokenPair }>> => {\n  const { method = 'GET', accessToken, refreshToken, body } = options\n\n  const headers: Record<string, string> = {\n    'content-type': 'application/json',\n  }\n\n  if (accessToken) headers[HEADERS.AUTHORIZATION] = `Bearer ${accessToken}`\n  if (refreshToken) headers[HEADERS.REFRESH_TOKEN] = refreshToken\n\n  try {\n    const res = await fetch(`${getAuthServiceUrl()}${path}`, {\n      method,\n      headers,\n      signal: AbortSignal.timeout(AUTH_SERVICE_TIMEOUT),\n      ...(body ? { body: JSON.stringify(body) } : {}),\n    })\n\n    if (!res.ok) {\n      const body = await res.json().catch(() => null)\n      return { ok: false, error: parseErrorResponse(res.status, body) }\n    }\n\n    const json: unknown = await res.json()\n    const parsed = AuthServiceResponseSchema.safeParse(json)\n    if (!parsed.success) {\n      return {\n        ok: false,\n        error: {\n          kind: 'sdk',\n          reason: 'malformed',\n          message: 'Estructura de respuesta inválida',\n          status: 502,\n        },\n      }\n    }\n    const data = parsed.data.data as T\n    // Un array (`/sessions`, `/user/empresas`) se devuelve intacto: esparcirlo en un objeto lo\n    // convertiria en `{ \"0\": …, \"1\": … }`. Esos endpoints se piden solo con access token, asi que\n    // no hay tokens nuevos que adjuntar.\n    if (Array.isArray(data))\n      return { ok: true, data: data as T & { tokens?: TokenPair } }\n\n    if (options.reissuesAccessTokenOnly) {\n      const accessToken = res.headers.get(HEADERS.NEW_ACCESS_TOKEN)\n      return {\n        ok: true,\n        data: { ...data, ...(accessToken ? { accessToken } : {}) },\n      }\n    }\n\n    const tokens = extractTokens(res.headers)\n\n    return { ok: true, data: { ...data, ...(tokens ? { tokens } : {}) } }\n  } catch (err) {\n    // Falta de configuración (authUrl): error del consumidor, no una falla de red.\n    if (isEvaAuthConfigError(err)) throw err\n    const message = err instanceof Error ? err.message : 'Error de red'\n    return {\n      ok: false,\n      error: { kind: 'sdk', reason: 'network', message, status: 0 },\n    }\n  }\n}\n\n/**\n * Solicita un código OTP. En éxito devuelve `{ message, challengeId }`:\n * `challengeId` es opaco, el caller debe conservarlo (en memoria) y enviarlo a\n * `login`; cada `getCode` nuevo invalida el `challengeId` anterior.\n * El tipo es un cast: la respuesta del Auth Service no se parsea en runtime.\n */\nconst getCode = (params: {\n  phone: string\n}): Promise<Result<{ message: string; challengeId: string }>> =>\n  authFetch(apiPath(AUTH_ROUTES.getCode), {\n    method: 'POST',\n    body: { phone: params.phone },\n  })\n\n/**\n * Verifica el código OTP. `challengeId` es obligatorio: debe ser el que\n * devolvió el `getCode` que originó el código; sin el desafío vigente el Auth\n * Service responde 401 sin consumir intentos.\n *\n * El `producto` del login sale SIEMPRE de `configureEvaAuth({ product })`, nunca del llamador: el\n * access token queda emitido para ese producto. `empresaId` (opcional) deja esa empresa activa en\n * la sesión si la persona pertenece a ella.\n *\n * @throws Error de configuración (`EvaAuthConfigError`) si falta `configureEvaAuth({ product })`.\n */\nconst login = (\n  params: {\n    phone: string\n    code: string\n    challengeId: string\n    empresaId?: string\n  } & DeviceInfo,\n): Promise<Result<{ user: { id: string }; tokens?: TokenPair }>> => {\n  const {\n    phone,\n    code,\n    challengeId,\n    empresaId,\n    deviceType,\n    os,\n    browser,\n    userAgent,\n  } = params\n  return authFetch(apiPath(AUTH_ROUTES.login), {\n    method: 'POST',\n    body: {\n      phone,\n      code,\n      challengeId,\n      producto: getProduct(),\n      ...(empresaId !== undefined && { empresaId }),\n      deviceType,\n      os,\n      browser,\n      userAgent,\n    },\n  })\n}\n\n/**\n * Cambia la empresa activa de la sesión (`null` la deja sin empresa). Auth reemite SOLO el access\n * token (`x-eva-new-access-token`; el refresh no rota): llega en `accessToken`. Auth valida la\n * pertenencia; si la persona no pertenece, responde error.\n */\nconst setActiveEmpresa = (params: {\n  accessToken: string\n  empresaId: string | null\n}): Promise<Result<{ empresaId: string | null; accessToken?: string }>> =>\n  authFetch(apiPath(AUTH_ROUTES.setActiveEmpresa), {\n    method: 'POST',\n    accessToken: params.accessToken,\n    body: { empresaId: params.empresaId },\n    reissuesAccessTokenOnly: true,\n  })\n\nconst refresh = (params: {\n  refreshToken: string\n}): Promise<Result<{ user: { id: string }; tokens?: TokenPair }>> =>\n  authFetch(apiPath(AUTH_ROUTES.refresh), {\n    method: 'POST',\n    refreshToken: params.refreshToken,\n  })\n\nconst logout = (params: {\n  refreshToken: string\n}): Promise<Result<{ message: string }>> =>\n  authFetch(apiPath(AUTH_ROUTES.logout), {\n    method: 'POST',\n    refreshToken: params.refreshToken,\n  })\n\nconst getUser = (params: { accessToken: string }): Promise<Result<EvaUser>> =>\n  authFetch(apiPath(USER_ROUTES.get), { accessToken: params.accessToken })\n\nconst updateUser = (params: {\n  accessToken: string\n  data: Record<string, unknown>\n}): Promise<Result<EvaUser>> =>\n  authFetch(apiPath(USER_ROUTES.update), {\n    method: 'PATCH',\n    accessToken: params.accessToken,\n    body: params.data,\n  })\n\nconst deleteUser = (params: {\n  accessToken: string\n}): Promise<Result<{ message: string }>> =>\n  authFetch(apiPath(USER_ROUTES.deactivate), {\n    method: 'DELETE',\n    accessToken: params.accessToken,\n  })\n\nconst getUserEmpresas = (params: {\n  accessToken: string\n}): Promise<Result<EvaEmpresa[]>> =>\n  authFetch(apiPath(USER_ROUTES.listCompanies), {\n    accessToken: params.accessToken,\n  })\n\n/**\n * Busca en el directorio de empresas (solo las activas que optaron por aparecer; solo campos de\n * perfil público; 50 por página). Basta el access token de usuario de CUALQUIER producto habilitado:\n * Auth limita los pedidos por usuario. La siguiente página se pide con el `nextCursor` recibido.\n */\nconst getDirectorio = (\n  params: { accessToken: string } & DirectorioQuery,\n): Promise<Result<DirectorioResponse['data']>> => {\n  const { accessToken, ...filters } = params\n  const query = new URLSearchParams()\n  for (const [key, value] of Object.entries(filters)) {\n    if (value !== undefined) query.set(key, String(value))\n  }\n  const qs = query.toString()\n  return authFetch(\n    `${apiPath(DIRECTORIO_ROUTES.search)}${qs === '' ? '' : `?${qs}`}`,\n    { accessToken },\n  )\n}\n\nconst getSessions = (params: {\n  accessToken: string\n}): Promise<Result<EvaSession[]>> =>\n  authFetch(apiPath(SESSION_ROUTES.list), { accessToken: params.accessToken })\n\nconst deleteSession = (params: {\n  accessToken: string\n  sessionId: string\n}): Promise<Result<{ message: string }>> => {\n  if (!/^[\\w-]+$/.test(params.sessionId)) {\n    return Promise.resolve({\n      ok: false,\n      error: {\n        kind: 'sdk',\n        reason: 'malformed',\n        message: 'ID de sesión inválido',\n        status: 400,\n      },\n    })\n  }\n  return authFetch(\n    apiPath(SESSION_ROUTES.deleteOne, { id: params.sessionId }),\n    {\n      method: 'DELETE',\n      accessToken: params.accessToken,\n    },\n  )\n}\n\nconst deleteAllSessions = (params: {\n  refreshToken: string\n}): Promise<Result<{ message: string; count: number }>> =>\n  authFetch(apiPath(SESSION_ROUTES.deleteAll), {\n    method: 'DELETE',\n    refreshToken: params.refreshToken,\n  })\n\n// Every other route is built with `apiPath` (`API_PREFIX + path`); health is an operational probe\n// that the API serves at the root, outside the versioned prefix.\nconst health = (): Promise<Result<{ status: string }>> => authFetch('/health')\n\nexport function createHttpClient() {\n  return {\n    getCode,\n    login,\n    setActiveEmpresa,\n    refresh,\n    logout,\n    getUser,\n    updateUser,\n    deleteUser,\n    getUserEmpresas,\n    getDirectorio,\n    getSessions,\n    deleteSession,\n    deleteAllSessions,\n    health,\n  }\n}\n\nexport type EvaHttpClient = ReturnType<typeof createHttpClient>\n"],"mappings":"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"}

package/dist/index-BYzDaMR9.d.ts

@@ -0,0 +1,312 @@
+import { d as Result } from "./types-CLOIHzRu.js";
+import { A as RenameGrupoInput, B as SearchDirectorioInput, C as ListAutorizacionesInput, D as ListWebhookDeliveriesQuery, E as ListEmpresasResult, F as S2SGetUserResult, G as UpdateEmpresaMemberInput, H as SubjectTokenInput, K as UpdateSucursalInput, L as S2SVerifyOptions, M as S2SBatchUsersResult, N as S2SCanonicalParts, O as RemoveEmpresaMemberInput, P as S2SClientConfig, S as GrupoResult, T as ListEmpresasInput, U as SucursalResult, V as SetContratacionInput, W as UpdateEmpresaInput, _ as EmpresaEstadoResult, a as CheckAutorizacionResult, b as EmpresaResult, c as CreateAutorizacionInput, d as CreateSucursalInput, f as CreateWebhookSubscriptionInput, h as DirectorioResult, i as CheckAutorizacionInput, j as S2SBatchUsersInput, k as RemoveGrupoEmpresaInput, l as CreateEmpresaInput, m as DeleteAutorizacionInput, n as AddGrupoEmpresaInput, o as ContratacionResult, p as DeactivateSucursalInput, q as UpdateWebhookSubscriptionInput, r as AutorizacionResult, s as ContratadoResult, t as AddEmpresaMemberInput, u as CreateGrupoInput, v as EmpresaMemberResult, w as ListAutorizacionesResult, x as GetEmpresaResult, z as S2SVerifyResult } from "./types-DIUWza9-.js";
+import { a as WebhookSubscriptionWithSecret, i as WebhookSubscription, n as WebhookDelivery, t as RotateWebhookSecretResult } from "./types-CQTZdZIF.js";
+import "./index-Dold-Ycb.js";
+/**
+ * Tipo del cliente S2S retornado por `createS2SClient`.
+ */
+type S2SClient = {
+  getUser(userId: string): Promise<Result<S2SGetUserResult>>;
+  batchUsers(input: S2SBatchUsersInput): Promise<Result<S2SBatchUsersResult>>;
+  createWebhookSubscription(input: CreateWebhookSubscriptionInput): Promise<Result<WebhookSubscriptionWithSecret>>;
+  listWebhookSubscriptions(): Promise<Result<{
+    subscriptions: WebhookSubscription[];
+  }>>;
+  getWebhookSubscription(id: string): Promise<Result<WebhookSubscription>>;
+  updateWebhookSubscription(id: string, input: UpdateWebhookSubscriptionInput): Promise<Result<WebhookSubscription>>;
+  deleteWebhookSubscription(id: string): Promise<Result<void>>;
+  rotateWebhookSubscriptionSecret(id: string): Promise<Result<RotateWebhookSecretResult>>;
+  listWebhookDeliveries(query?: ListWebhookDeliveriesQuery): Promise<Result<{
+    deliveries: WebhookDelivery[];
+  }>>;
+  /**
+   * Crea una empresa (`empresas:escribir`, el actor necesita `producto`). La persona del
+   * `subjectToken` queda como titular y el producto del actor en `prueba`. 409 si el RUC, la razón
+   * social o el slug ya existen; 429 si la persona superó el límite de altas.
+   */
+  createEmpresa(input: CreateEmpresaInput): Promise<Result<EmpresaResult>>;
+  /** Edita datos maestros, perfil y visibilidad en el directorio (administrador o titular; `empresas:escribir`). */
+  updateEmpresa(empresaId: string, input: UpdateEmpresaInput): Promise<Result<EmpresaResult>>;
+  /** Empresas que contrataron el producto del actor, paginadas con `cursor` (`empresas:leer`). */
+  listEmpresas(query?: ListEmpresasInput): Promise<Result<ListEmpresasResult>>;
+  /**
+   * Una empresa (`empresas:leer`): vista completa (`vista: 'completa'`) si el actor tiene producto y
+   * la empresa lo contrató; recortada (`vista: 'recortada'`, sin contacto ni miembros) si el actor
+   * no tiene producto (servicio compartido). 404 si no existe o no la contrató.
+   */
+  getEmpresa(empresaId: string): Promise<Result<GetEmpresaResult>>;
+  /** Da de baja una empresa (solo facturación, permiso `empresas:baja`; no lleva persona). */
+  bajaEmpresa(empresaId: string): Promise<Result<EmpresaEstadoResult>>;
+  /** Reactiva una empresa de baja (solo facturación, permiso `empresas:baja`). */
+  reactivarEmpresa(empresaId: string): Promise<Result<EmpresaEstadoResult>>;
+  /** Agrega un miembro como `miembro`; si ya lo es, 409 `conflict` (administrador o titular; `empresas:escribir`). */
+  addEmpresaMember(empresaId: string, input: AddEmpresaMemberInput): Promise<Result<EmpresaMemberResult>>;
+  /** Cambia el rol de un miembro (solo titular; `empresas:escribir`). */
+  setEmpresaMemberRole(empresaId: string, userId: string, input: UpdateEmpresaMemberInput): Promise<Result<EmpresaMemberResult>>;
+  /**
+   * Quita un miembro (`empresas:escribir`); si no lo es, 404 `not_found`. Con `userId` igual a la
+   * persona del token es salir por cuenta propia (cualquier rol, salvo el último titular).
+   */
+  removeEmpresaMember(empresaId: string, userId: string, input: RemoveEmpresaMemberInput): Promise<Result<void>>;
+  /** Crea una sucursal de la empresa (administrador o titular; `empresas:escribir`). */
+  createSucursal(empresaId: string, input: CreateSucursalInput): Promise<Result<SucursalResult>>;
+  /** Edita una sucursal (administrador o titular; `empresas:escribir`). */
+  updateSucursal(empresaId: string, sucursalId: string, input: UpdateSucursalInput): Promise<Result<SucursalResult>>;
+  /** Baja lógica de una sucursal, `activa = false` (administrador o titular; `empresas:escribir`). */
+  deactivateSucursal(empresaId: string, sucursalId: string, input: DeactivateSucursalInput): Promise<Result<void>>;
+  /**
+   * Pide la contratación del PROPIO producto del actor para una empresa existente
+   * (`pendiente_pago`; `contrataciones:pedir`). La persona del `subjectToken` debe ser titular:
+   * 404 igual si la empresa no existe o no es titular. Solo si no hay fila o está `cancelado`.
+   */
+  requestContratacion(empresaId: string, input: SubjectTokenInput): Promise<Result<ContratacionResult>>;
+  /** Cancela la contratación del propio producto (`cancelado`, desde cualquier estado; solo titular). */
+  cancelContratacion(empresaId: string, input: SubjectTokenInput): Promise<Result<void>>;
+  /**
+   * ¿La empresa tiene contratado ese producto? (`contrataciones:leer`). Para servicios compartidos
+   * que atienden llamadas de servicio donde no hay token delegado.
+   */
+  getContratacion(empresaId: string, producto: string): Promise<Result<ContratadoResult>>;
+  /** Facturación: escribe el estado y el vencimiento de cualquier fila (`contrataciones:escribir`, actor sin producto). */
+  setContratacion(empresaId: string, producto: string, input: SetContratacionInput): Promise<Result<ContratacionResult>>;
+  /** Crea un grupo con una empresa de la persona. */
+  createGrupo(input: CreateGrupoInput): Promise<Result<GrupoResult>>;
+  /** Renombra el grupo (titular de alguna de sus empresas). */
+  renameGrupo(grupoId: string, input: RenameGrupoInput): Promise<Result<GrupoResult>>;
+  /** Agrega una empresa de la que la persona es titular. */
+  addGrupoEmpresa(grupoId: string, input: AddGrupoEmpresaInput): Promise<Result<GrupoResult>>;
+  /** Quita una empresa del grupo; un grupo que queda vacío se borra solo. */
+  removeGrupoEmpresa(grupoId: string, empresaId: string, input: RemoveGrupoEmpresaInput): Promise<Result<void>>;
+  /** Busca en el directorio de empresas visibles (`directorio:leer`). Solo campos de perfil público; 50 por página. */
+  searchDirectorio(query?: SearchDirectorioInput): Promise<Result<DirectorioResult>>;
+  /** Concede un permiso del catálogo entre empresas a otra empresa (administrador o titular de la otorgante; `autorizaciones:escribir`). 409 si ya está vigente. */
+  createAutorizacion(otorganteId: string, input: CreateAutorizacionInput): Promise<Result<AutorizacionResult>>;
+  /** Revoca (otorgante) o renuncia a (beneficiaria) una autorización; administrador o titular (`autorizaciones:escribir`). */
+  deleteAutorizacion(empresaId: string, autorizacionId: string, input: DeleteAutorizacionInput): Promise<Result<void>>;
+  /** Autorizaciones vigentes de la empresa, `otorgadas` o `recibidas` (administrador o titular; `autorizaciones:leer`). La persona viaja en el header `x-eva-subject-token`. */
+  listAutorizaciones(empresaId: string, input: ListAutorizacionesInput): Promise<Result<ListAutorizacionesResult>>;
+  /**
+   * ¿La otorgante autorizó ese permiso a la beneficiaria? (`autorizaciones:leer`, solo actores cuya
+   * audiencia es dueña del permiso; puede tener además `producto`). Vale solo si las dos empresas están activas.
+   *
+   * Guarda el resultado 30 s (`AUTORIZACION_CACHE_TTL_MS`) por cliente: una revocación o una baja
+   * tardan como máximo eso en notarse. Los errores no se guardan.
+   */
+  checkAutorizacion(input: CheckAutorizacionInput): Promise<Result<CheckAutorizacionResult>>;
+};
+/**
+ * Crea un cliente S2S autenticado para comunicarse con la API interna del Auth Service.
+ *
+ * @example
+ * ```ts
+ * const tokenProvider = createServiceTokenProvider({
+ *   authUrl: 'https://auth.miapp.com',
+ *   clientId: 'mi-servicio',
+ *   secretHex: env.AUTH_CLIENT_SECRET_HEX,
+ *   audience: 'auth-api',
+ * })
+ * const s2s = createS2SClient({ baseUrl: 'https://auth.miapp.com', tokenProvider })
+ * const result = await s2s.getUser(userId)
+ * if (!result.ok) return handleError(result.error)
+ * return result.data // perfil del usuario
+ * ```
+ */
+declare function createS2SClient(config: S2SClientConfig): S2SClient;
+/**
+ * SHA-256 hex de string vacío (precomputado).
+ * Constante usada cuando el body es vacío — evita hash innecesario.
+ * Exportado para uso externo (REQ-S2S-02 LOCKED).
+ */
+declare const EMPTY_BODY_SHA256_HEX = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+/**
+ * Genera un nonce S2S: 16 bytes de `crypto.getRandomValues` como 32 hex en minúsculas.
+ * Es el valor del header `x-eva-nonce`; cada request debe llevar uno nuevo.
+ */
+declare function generateS2SNonce(): string;
+/**
+ * Construye el canonical string de 7 líneas (SigV4-style).
+ *
+ * Formato EXACTO:
+ *   {METHOD}\n{PATH}\n{CANONICAL_QUERY}\n{TIMESTAMP}\n{NONCE}\n{CLIENT_ID}\n{BODY_HASH}
+ *
+ * @param parts - Componentes del request a firmar.
+ */
+declare function buildS2SCanonicalString(parts: S2SCanonicalParts): Promise<string>;
+/**
+ * Genera la firma HMAC-SHA-256 del canonical string.
+ *
+ * @returns String con formato `"sha256=${hexLowercase}"`.
+ * @throws Si `secretHex` tiene formato inválido (longitud impar o chars no-hex).
+ * @throws Si `parts.nonce` no es un nonce canónico (32 hex en minúsculas).
+ */
+declare function signS2SRequest({ parts, secretHex }: {
+  parts: S2SCanonicalParts;
+  secretHex: string;
+}): Promise<string>;
+/**
+ * Genera los 4 headers de autenticación S2S para un request: client id, timestamp (segundos),
+ * nonce y firma. Es el único punto que genera timestamp + nonce y firma; `createS2SClient` lo
+ * usa y los firmantes manuales deben usarlo en vez de armar los headers a mano.
+ *
+ * El nonce es nuevo en cada llamada: no reutilices los headers devueltos en otro request.
+ *
+ * @param rawQuery - Query string crudo sin `?`. Default `''`.
+ * @param bodyBytes - Bytes EXACTOS que se enviarán como body. Default: vacío.
+ * @throws Si `secretHex` tiene formato inválido.
+ */
+declare function signS2SHeaders({ method, path, rawQuery, bodyBytes, clientId, secretHex }: {
+  method: string;
+  path: string;
+  rawQuery?: string;
+  bodyBytes?: Uint8Array;
+  clientId: string;
+  secretHex: string;
+}): Promise<Record<string, string>>;
+/**
+ * Constantes del módulo S2S (service-to-service).
+ *
+ * REQ-S2S-05 LOCKED: la ventana de tiempo para el timestamp S2S es de 120 segundos.
+ */
+/**
+ * Ventana máxima (en segundos) para aceptar un request S2S.
+ * Si |serverTime - timestamp| > S2S_TIMESTAMP_WINDOW_SECONDS → firma rechazada.
+ */
+declare const S2S_TIMESTAMP_WINDOW_SECONDS = 120;
+/**
+ * Permisos de la audiencia `auth-api`, tal como los concede el Auth Service a un service client.
+ *
+ * Se mantiene como objeto del SDK (`S2S_SCOPES.USERS_READ`) pero sus valores deben ser miembros del
+ * catálogo `SERVICE_AUDIENCE_SCOPES['auth-api']` del contrato: `satisfies` lo comprueba en
+ * compilación. `admin` no está: la superficie `/admin` de Auth se firma, no usa tokens.
+ *
+ * @example
+ * ```ts
+ * import { S2S_SCOPES } from '@eva_solutions/auth-sdk/s2s'
+ *
+ * const scope = [S2S_SCOPES.USERS_READ, S2S_SCOPES.EMPRESAS_ESCRIBIR].join(' ')
+ * ```
+ */
+declare const S2S_SCOPES: {
+  readonly USERS_READ: "users:read";
+  readonly WEBHOOKS_READ: "webhooks:read";
+  readonly WEBHOOKS_WRITE: "webhooks:write";
+  readonly EMPRESAS_LEER: "empresas:leer";
+  readonly EMPRESAS_ESCRIBIR: "empresas:escribir";
+  readonly TOKENS_EXCHANGE: "tokens:exchange";
+  readonly CONTRATACIONES_PEDIR: "contrataciones:pedir";
+  readonly CONTRATACIONES_ESCRIBIR: "contrataciones:escribir";
+  readonly CONTRATACIONES_LEER: "contrataciones:leer";
+  readonly EMPRESAS_BAJA: "empresas:baja";
+  readonly AUTORIZACIONES_ESCRIBIR: "autorizaciones:escribir";
+  readonly AUTORIZACIONES_LEER: "autorizaciones:leer";
+  readonly DIRECTORIO_LEER: "directorio:leer";
+};
+/** Unión de literales de todos los permisos de la audiencia `auth-api`. */
+type S2SScope = (typeof S2S_SCOPES)[keyof typeof S2S_SCOPES];
+/**
+ * Header de respuesta que el Auth Service incluye en cada respuesta S2S
+ * con la hora del servidor (Unix timestamp en segundos como string).
+ *
+ * @example
+ * ```ts
+ * import { S2S_RESPONSE_HEADERS } from '@eva_solutions/auth-sdk/s2s'
+ *
+ * const serverTime = response.headers.get(S2S_RESPONSE_HEADERS.SERVER_TIME)
+ * ```
+ */
+declare const S2S_RESPONSE_HEADERS: {
+  readonly SERVER_TIME: "x-eva-server-time";
+};
+/**
+ * Vida en milisegundos del caché de `checkAutorizacion` en el cliente S2S (30 s). Una revocación o
+ * la baja de una empresa tardan como máximo esto en notarse en un servicio que verifica; así
+ * está declarado en el diseño.
+ */
+declare const AUTORIZACION_CACHE_TTL_MS = 30000;
+/**
+ * Códigos de error específicos del módulo S2S.
+ *
+ * Complementan a `ERROR_CODES` (core) para los errores propios de los endpoints
+ * `/api/v1/internal/*` que consume `createS2SClient`: usuarios y subscriptions de webhooks.
+ *
+ * @example
+ * ```ts
+ * import { S2S_ERROR_CODES } from '@eva_solutions/auth-sdk/s2s'
+ *
+ * const r = await s2s.rotateWebhookSubscriptionSecret(id)
+ * if (!r.ok && r.error.kind === 'api' && r.error.code === S2S_ERROR_CODES.webhook_secret_rotation_conflict) {
+ *   // otra rotación concurrente ganó; esta llamada no recibió clave. Reintenta.
+ * }
+ * ```
+ */
+declare const S2S_ERROR_CODES: {
+  /** `GET /internal/users/{id}`: el usuario no existe o está soft-deleted (404). */
+  readonly user_not_found: "user_not_found";
+  /** Ya existe una subscription del mismo service client con la misma URL y los mismos eventCodes (409). */
+  readonly webhook_subscription_duplicate: "webhook_subscription_duplicate";
+  /** La subscription no existe o pertenece a otro service client (404). */
+  readonly webhook_subscription_not_found: "webhook_subscription_not_found";
+  /**
+   * `rotate-secret` perdió contra otra rotación concurrente de la misma subscription (409).
+   * El perdedor no recibe clave; es reintentable.
+   */
+  readonly webhook_secret_rotation_conflict: "webhook_secret_rotation_conflict";
+  /** URL de webhook inválida: reglas estáticas, IP privada o host sin direcciones (400). */
+  readonly webhook_url_invalid: "webhook_url_invalid";
+  /** `eventCodes` vacío al crear o actualizar (400). */
+  readonly webhook_event_codes_empty: "webhook_event_codes_empty";
+};
+/** Unión de literales de los error codes específicos del módulo S2S. */
+type S2SErrorCode = (typeof S2S_ERROR_CODES)[keyof typeof S2S_ERROR_CODES];
+/**
+ * Verify an inbound S2S request signed with HMAC-SHA-256.
+ *
+ * The function reads the body into memory exactly once (via `request.arrayBuffer()`).
+ * Callers that need to read the body again after calling this function MUST clone the
+ * request before passing it here (e.g., Hono's `s2sAuth` uses `cloneRawRequest`).
+ *
+ * @param request - Web API `Request` to verify. Body is read and buffered internally.
+ * @param opts.secretStore - Callback returning the plaintext secret (64 hex chars) for
+ *   the given clientId, or null if unknown. Return null — do NOT throw — for unknown clients.
+ * @param opts.timestampWindowSeconds - Override timestamp window (default: 120 s).
+ *
+ * @throws If `secretStore` returns a non-null value that is not valid hex (empty, odd length
+ *   or non-hex chars). This is a server misconfiguration, so it is NOT mapped to a 401; the
+ *   error message never contains the secret.
+ *
+ * @remarks A query string with malformed percent-encoding (e.g. `?a=%ZZ`) cannot be
+ *   canonicalized; it fails closed with `signature_invalid`, following the same path as an
+ *   invalid signature (secret lookup and HMAC included, `replayCache` not touched).
+ *
+ * @returns `S2SVerifyResult<{ clientId: string }>` — discriminated union.
+ *   `ok: true`  → `data.clientId` is the authenticated service client slug.
+ *   `ok: false` → `error.reason` narrows the failure; `error.message` is human-readable.
+ *
+ * @security Timing-safe: whether `secretStore` returns null (client_unknown path) or a
+ *   valid secret with an invalid signature (signature_invalid path), this function
+ *   ALWAYS reaches `crypto.subtle.verify` with the same execution path — using
+ *   `DUMMY_HMAC_KEY_HEX` when the secret is null. The verify result is discarded in
+ *   the client_unknown path, but the operation always executes. See AC-10.
+ *
+ * @example
+ * ```ts
+ * const result = await verifyS2SRequest(request, {
+ *   secretStore: async (clientId) => {
+ *     const client = await db.serviceClients.findById(clientId)
+ *     return client?.secret ?? null
+ *   },
+ * })
+ * if (!result.ok) {
+ *   return new Response(
+ *     JSON.stringify({ error: result.error }),
+ *     { status: 401, headers: { 'Content-Type': 'application/json' } },
+ *   )
+ * }
+ * const { clientId } = result.data
+ * ```
+ */
+declare function verifyS2SRequest(request: Request, opts: S2SVerifyOptions): Promise<S2SVerifyResult<{
+  clientId: string;
+}>>;
+export { S2SScope as a, S2S_TIMESTAMP_WINDOW_SECONDS as c, generateS2SNonce as d, signS2SHeaders as f, createS2SClient as h, AUTORIZACION_CACHE_TTL_MS as i, EMPTY_BODY_SHA256_HEX as l, S2SClient as m, S2SErrorCode as n, S2S_RESPONSE_HEADERS as o, signS2SRequest as p, S2S_ERROR_CODES as r, S2S_SCOPES as s, verifyS2SRequest as t, buildS2SCanonicalString as u };
+//# sourceMappingURL=index-BYzDaMR9.d.ts.map

package/dist/index-BYzDaMR9.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BYzDaMR9.d.ts","names":[],"sources":["../src/s2s/client.ts","../src/s2s/sign.ts","../src/s2s/constants.ts","../src/s2s/error-codes.ts","../src/s2s/verify.ts"],"mappings":";;;;;;;KAoGY;EACV,QAAQ,iBAAiB,QAAQ,OAAO;EACxC,WAAW,OAAO,qBAAqB,QAAQ,OAAO;EACtD,0BACE,OAAO,iCACN,QAAQ,OAAO;EAClB,4BAA4B,QAC1B;IAAS,eAAe;;EAE1B,uBAAuB,aAAa,QAAQ,OAAO;EACnD,0BACE,YACA,OAAO,iCACN,QAAQ,OAAO;EAClB,0BAA0B,aAAa,QAAQ;EAC/C,gCACE,aACC,QAAQ,OAAO;EAClB,sBACE,QAAQ,6BACP,QAAQ;IAAS,YAAY;;;;;;;EAQhC,cAAc,OAAO,qBAAqB,QAAQ,OAAO;;EAEzD,cACE,mBACA,OAAO,qBACN,QAAQ,OAAO;;EAElB,aAAa,QAAQ,oBAAoB,QAAQ,OAAO;;;;;;EAMxD,WAAW,oBAAoB,QAAQ,OAAO;;EAE9C,YAAY,oBAAoB,QAAQ,OAAO;;EAE/C,iBAAiB,oBAAoB,QAAQ,OAAO;;EAEpD,iBACE,mBACA,OAAO,wBACN,QAAQ,OAAO;;EAElB,qBACE,mBACA,gBACA,OAAO,2BACN,QAAQ,OAAO;;;;;EAKlB,oBACE,mBACA,gBACA,OAAO,2BACN,QAAQ;;EAEX,eACE,mBACA,OAAO,sBACN,QAAQ,OAAO;;EAElB,eACE,mBACA,oBACA,OAAO,sBACN,QAAQ,OAAO;;EAElB,mBACE,mBACA,oBACA,OAAO,0BACN,QAAQ;;;;;;EASX,oBACE,mBACA,OAAO,oBACN,QAAQ,OAAO;;EAElB,mBACE,mBACA,OAAO,oBACN,QAAQ;;;;;EAKX,gBACE,mBACA,mBACC,QAAQ,OAAO;;EAElB,gBACE,mBACA,kBACA,OAAO,uBACN,QAAQ,OAAO;;EAKlB,YAAY,OAAO,mBAAmB,QAAQ,OAAO;;EAErD,YACE,iBACA,OAAO,mBACN,QAAQ,OAAO;;EAElB,gBACE,iBACA,OAAO,uBACN,QAAQ,OAAO;;EAElB,mBACE,iBACA,mBACA,OAAO,0BACN,QAAQ;;EAKX,iBACE,QAAQ,wBACP,QAAQ,OAAO;;EAKlB,mBACE,qBACA,OAAO,0BACN,QAAQ,OAAO;;EAElB,mBACE,mBACA,wBACA,OAAO,0BACN,QAAQ;;EAEX,mBACE,mBACA,OAAO,0BACN,QAAQ,OAAO;;;;;;;;EAQlB,kBACE,OAAO,yBACN,QAAQ,OAAO;;;;;;;;;;;;;;;;;;;iBAsLJ,gBAAgB,QAAQ,kBAAkB;;;;;;cCjV7C;;;;;iBAOG;;;;;;;;;iBAaM,wBACpB,OAAO,oBACN;;;;;;;;iBAwCmB,iBACpB,OACA;EAEA,OAAO;EACP;IACE;;;;;;;;;;;;iBAgDkB,iBACpB,QACA,MACA,UACA,WACA,UACA;EAEA;EACA;EACA;EACA,YAAY;EACZ;EACA;IACE,QAAQ;;;;;;;;;;cCxOC;;;;;;;;;;;;;;;cAmCA;;;;;;;;;;;;;;;;KAiBD,mBAAmB,yBAAyB;;;;;;;;;;;;cAa3C;;;;;;;;cASA;;;;;;;;;;;;;;;;;cCvEA;;;;;;;;;;;;;;;;;;KAmBD,uBACF,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBCoHlB,iBACpB,SAAS,SACT,MAAM,mBACL,QAAQ;EAAkB"}

package/dist/index-CNNMCrdl.d.ts

@@ -0,0 +1,66 @@
+import "./index-Dold-Ycb.js";
+import "./types-CQTZdZIF.js";
+/**
+ * Verificación de firma HMAC-SHA-256 de webhooks entrantes del Auth Service.
+ *
+ * REQ-WH-03, REQ-WH-04, REQ-WH-05, REQ-WH-06 LOCKED.
+ *
+ * Algoritmo (espejo del API `firmarWebhook` en webhook-dispatcher.ts):
+ *   canonical = `${timestamp}\n${eventId}\n${sha256Hex(rawBody)}`
+ *   expected  = HMAC-SHA-256(signingKey, canonical)
+ *
+ * Usa Web Crypto API (`crypto.subtle`) — isomorfo (browser + worker + Node 20+).
+ *
+ * D-12 LOCKED: hexToBytes y sha256Hex se duplican aquí (NO se extraen a shared)
+ * para que el entry point ./webhooks sea completamente tree-shakeable.
+ */
+type VerifyWebhookSignatureParams = {
+  /** Body raw del request (string, antes de parsear JSON). */
+  rawBody: string;
+  /**
+   * Signing key del webhook — hex 64 chars (32 bytes).
+   * Es el `signingKey` que devolvió el API al crear/rotar la subscription.
+   * NOTA H3 LOCKED: NO re-hashear — usarlo tal como viene.
+   */
+  signingKey: string;
+  /**
+   * Valor completo del header `X-Eva-Webhook-Signature`.
+   * Debe comenzar con `"sha256="`.
+   */
+  signature: string;
+  /** Valor del header `X-Eva-Webhook-Id` (UUID del evento). */
+  eventId: string;
+  /**
+   * Valor del header `X-Eva-Webhook-Timestamp` parseado a number
+   * (unix seconds).
+   */
+  timestamp: number;
+  /**
+   * Override del tiempo actual (unix seconds) para tests.
+   * Por defecto: `Math.floor(Date.now() / 1000)`.
+   */
+  now?: number;
+};
+/**
+ * Verifica la firma HMAC-SHA-256 de un webhook entrante del Auth Service.
+ *
+ * @returns `true` si la firma es válida y está dentro de la ventana de tiempo;
+ *          `false` en cualquier otro caso (firma inválida, expirada, formato incorrecto).
+ *
+ * La comparación es constant-time via `crypto.subtle.verify` (por spec).
+ *
+ * @example
+ * ```ts
+ * const valid = await verifyWebhookSignature({
+ *   rawBody: await req.text(),
+ *   signingKey: process.env.WEBHOOK_SIGNING_KEY,
+ *   signature: req.headers.get('x-eva-webhook-signature') ?? '',
+ *   eventId: req.headers.get('x-eva-webhook-id') ?? '',
+ *   timestamp: Number(req.headers.get('x-eva-webhook-timestamp')),
+ * })
+ * if (!valid) return new Response('Unauthorized', { status: 401 })
+ * ```
+ */
+declare function verifyWebhookSignature({ rawBody, signingKey, signature, eventId, timestamp, now }: VerifyWebhookSignatureParams): Promise<boolean>;
+export { verifyWebhookSignature as n, VerifyWebhookSignatureParams as t };
+//# sourceMappingURL=index-CNNMCrdl.d.ts.map

package/dist/index-CNNMCrdl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CNNMCrdl.d.ts","names":[],"sources":["../src/webhooks/verify-signature.ts"],"mappings":";;;;;;;;;;;;;;;;KAqDY;;EAEV;;;;;;EAMA;;;;;EAKA;;EAEA;;;;;EAKA;;;;;EAKA;;;;;;;;;;;;;;;;;;;;;;iBAuBoB,yBACpB,SACA,YACA,WACA,SACA,WACA,OACC,+BAA+B"}