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

package/dist/index-DU9wJ-P2.d.cts

@@ -0,0 +1,312 @@
+import { d as Result } from "./types-Ci0Jq0xB.cjs";
+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-Ai3iIFlB.cjs";
+import { a as WebhookSubscriptionWithSecret, i as WebhookSubscription, n as WebhookDelivery, t as RotateWebhookSecretResult } from "./types-Bxg4hCMc.cjs";
+import "./index-CZru7c5T.cjs";
+/**
+ * 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-DU9wJ-P2.d.cts.map

package/dist/index-DU9wJ-P2.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DU9wJ-P2.d.cts","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-DbiXllNy.d.cts

@@ -0,0 +1,66 @@
+import "./index-CZru7c5T.cjs";
+import "./types-Bxg4hCMc.cjs";
+/**
+ * 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-DbiXllNy.d.cts.map

package/dist/index-DbiXllNy.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-DbiXllNy.d.cts","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"}

package/dist/index-z9r98qlk.d.ts

@@ -0,0 +1,66 @@
+import "./index-CZru7c5T.js";
+import "./types-DXg8BvEh.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-z9r98qlk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-z9r98qlk.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"}

package/dist/index.cjs

@@ -0,0 +1,89 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_http_client = require("./http-client-BVF3iktR.cjs");
+const require_jwt = require("./jwt-BBNqk0TV.cjs");
+const require_parse_error_response = require("./parse-error-response-6qOQS5y9.cjs");
+const require_constants = require("./constants-BE1_9Tod.cjs");
+const require_constants$1 = require("./constants-CcbhOaAP.cjs");
+const require_cookies = require("./cookies-DCIcr7uy.cjs");
+const require_error_helpers = require("./error-helpers-XCh4ZJ-g.cjs");
+const require_webhooks = require("./webhooks-Cx11psg1.cjs");
+const require_event_codes = require("./event-codes-BBJHon-I.cjs");
+const require_admin = require("./admin-Q6lbWqLM.cjs");
+const require_s2s = require("./s2s-6wbotr78.cjs");
+const require_sign = require("./sign-C7y6xdvT.cjs");
+const require_delegated_token = require("./delegated-token-DHSK4rHI.cjs");
+// src/client.ts
+function createEvaAuth() {
+	return { client: require_http_client.createHttpClient() };
+}
+// src/get-message.ts
+/**
+* Retorna el mensaje del EvaError independientemente de su kind.
+* Equivalente a `err.message` — helper para migración gradual desde 0.x.
+*/
+function getMessage(err) {
+	return err.message;
+}
+exports.ACCOUNT_STATES = require_constants$1.ACCOUNT_STATES;
+exports.ADMIN_ERROR_CODES = require_admin.ADMIN_ERROR_CODES;
+exports.AUTORIZACION_CACHE_TTL_MS = require_sign.AUTORIZACION_CACHE_TTL_MS;
+exports.COOKIE_MAX_AGE = require_constants.COOKIE_MAX_AGE;
+exports.DEFAULT_ERROR_MESSAGES = require_parse_error_response.DEFAULT_ERROR_MESSAGES;
+exports.EMPTY_BODY_SHA256_HEX = require_sign.EMPTY_BODY_SHA256_HEX;
+exports.ERROR_CODES = require_constants$1.ERROR_CODES;
+exports.EVENT_CODES = require_event_codes.EVENT_CODES;
+exports.HEADERS = require_constants$1.HEADERS;
+exports.JWT_CONFIG = require_constants.JWT_CONFIG;
+exports.S2S_ERROR_CODES = require_s2s.S2S_ERROR_CODES;
+exports.S2S_RESPONSE_HEADERS = require_sign.S2S_RESPONSE_HEADERS;
+exports.S2S_SCOPES = require_sign.S2S_SCOPES;
+exports.S2S_TIMESTAMP_WINDOW_SECONDS = require_sign.S2S_TIMESTAMP_WINDOW_SECONDS;
+exports.SDK_ERROR_REASONS = require_error_helpers.SDK_ERROR_REASONS;
+exports.ServiceTokenRequestError = require_s2s.ServiceTokenRequestError;
+exports.USERS_BATCH_MAX_IDS = require_constants$1.USERS_BATCH_MAX_IDS;
+exports.WEBHOOK_HEADERS = require_constants$1.WEBHOOK_HEADERS;
+exports.WEBHOOK_TIMESTAMP_WINDOW_SECONDS = require_constants$1.WEBHOOK_TIMESTAMP_WINDOW_SECONDS;
+exports.buildS2SCanonicalString = require_sign.buildS2SCanonicalString;
+exports.configureEvaAuth = require_parse_error_response.configureEvaAuth;
+exports.createAdminClient = require_admin.createAdminClient;
+exports.createEvaAuth = createEvaAuth;
+exports.createHttpClient = require_http_client.createHttpClient;
+exports.createS2SClient = require_s2s.createS2SClient;
+exports.createServiceTokenProvider = require_s2s.createServiceTokenProvider;
+exports.generateS2SNonce = require_sign.generateS2SNonce;
+exports.getAuthUrl = require_parse_error_response.getAuthUrl;
+exports.getCookieDomain = require_parse_error_response.getCookieDomain;
+exports.getCookieNames = require_constants.getCookieNames;
+exports.getMessage = getMessage;
+exports.isAccountStateLocked = require_error_helpers.isAccountStateLocked;
+exports.isApiError = require_error_helpers.isApiError;
+exports.isAuthRequired = require_error_helpers.isAuthRequired;
+exports.isBadRequest = require_error_helpers.isBadRequest;
+exports.isConflict = require_error_helpers.isConflict;
+exports.isForbidden = require_error_helpers.isForbidden;
+exports.isGone = require_error_helpers.isGone;
+exports.isInternalError = require_error_helpers.isInternalError;
+exports.isMalformed = require_error_helpers.isMalformed;
+exports.isNetworkError = require_error_helpers.isNetworkError;
+exports.isNotFound = require_error_helpers.isNotFound;
+exports.isRateLimited = require_error_helpers.isRateLimited;
+exports.isRefreshNoTokens = require_error_helpers.isRefreshNoTokens;
+exports.isSdkError = require_error_helpers.isSdkError;
+exports.isServiceUnavailable = require_error_helpers.isServiceUnavailable;
+exports.isTokenInvalid = require_error_helpers.isTokenInvalid;
+exports.isUnauthorized = require_error_helpers.isUnauthorized;
+exports.isUnprocessableEntity = require_error_helpers.isUnprocessableEntity;
+exports.isValidationError = require_error_helpers.isValidationError;
+exports.isVerifyFailed = require_error_helpers.isVerifyFailed;
+exports.matchError = require_error_helpers.matchError;
+exports.matchSdkReason = require_error_helpers.matchSdkReason;
+exports.readTokensFromCookies = require_cookies.readTokensFromCookies;
+exports.signS2SHeaders = require_sign.signS2SHeaders;
+exports.signS2SRequest = require_sign.signS2SRequest;
+exports.verifyAccessToken = require_jwt.verifyAccessToken;
+exports.verifyDelegatedToken = require_delegated_token.verifyDelegatedToken;
+exports.verifyS2SRequest = require_delegated_token.verifyS2SRequest;
+exports.verifyServiceToken = require_delegated_token.verifyServiceToken;
+exports.verifyWebhookSignature = require_webhooks.verifyWebhookSignature;
+
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["createHttpClient"],"sources":["../src/client.ts","../src/get-message.ts"],"sourcesContent":["import { createHttpClient, type EvaHttpClient } from './http-client'\n\ntype EvaAuth = {\n  client: EvaHttpClient\n}\n\nexport function createEvaAuth(): EvaAuth {\n  return {\n    client: createHttpClient(),\n  }\n}\n","/**\n * Helper de conveniencia para extraer el mensaje de un EvaError.\n * Útil para migración gradual de 0.x → 1.0.0 donde result.error era string.\n *\n * Uso:\n *   import { getMessage } from '@eva_solutions/auth-sdk'\n *   if (!result.ok) {\n *     console.error(getMessage(result.error))  // equivale a result.error.message\n *   }\n */\nimport type { EvaError } from './types'\n\n/**\n * Retorna el mensaje del EvaError independientemente de su kind.\n * Equivalente a `err.message` — helper para migración gradual desde 0.x.\n */\nexport function getMessage(err: EvaError): string {\n  return err.message\n}\n"],"mappings":";;;;;;;;;;;;;;;AAMA,SAAgB,gBAAyB;CACvC,OAAO,EACL,QAAQA,oBAAAA,iBAAiB,EAC3B;AACF;;;;;;ACMA,SAAgB,WAAW,KAAuB;CAChD,OAAO,IAAI;AACb"}