@central-ticket/queue-sdk 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-export { C as CentralQ, a as CentralQClient, b as CentralQClientOptions, c as CentralQCreateOptions, d as CentralQOptions, E as ErrorDetail, e as ExpiredDetail, P as PassedDetail, f as PositionDetail, Q as QueueStatus, g as createCentralQClient } from './centralq-I9tdL_Xr.js';
-export { QueueTokenValidationResult, ValidateQueueTokenServerOptions, validateQueueTokenServer } from './server.js';
+export { C as CentralQ, a as CentralQClient, b as CentralQClientOptions, c as CentralQCreateOptions, d as CentralQOptions, E as ErrorDetail, e as ExpiredDetail, P as PassedDetail, f as PositionDetail, Q as QueueStatus, g as createCentralQClient } from './centralq-C3ukDo0x.js';
+export { CentralQServerClient, CentralQServerClientOptions, CentralQServerRequestError, CentralQServerRequestErrorCode, CompleteQueueAccessServerOptions, QueueAccessCompletionResult, QueueAccessValidationResult, QueueTokenValidationResult, ValidateQueueTokenServerOptions, VerifyQueueAccessServerOptions, completeQueueAccessServer, createCentralQServerClient, validateQueueTokenServer, verifyQueueAccessServer } from './server.js';
 import * as lit from 'lit';
 import { LitElement } from 'lit';
 
@@ -20,6 +20,31 @@ interface QueueInitResponse {
     queueInitToken: string;
     expiresAt: number;
 }
+type AdmissionMode = "PUBLIC" | "MANAGED" | "TRUSTED";
+interface QueueProtectionResponse {
+    eventId: string;
+    configured: boolean;
+    protected: boolean;
+    isActive: boolean;
+    admissionMode: AdmissionMode;
+    challengeRequired: boolean;
+}
+type AdmissionChallengeResponse = {
+    required: false;
+} | {
+    required: true;
+    publicKey: string;
+    appearance: "interaction-only";
+};
+type QueueVerifyResponse = {
+    valid: true;
+    userId: string;
+    eventId: string;
+    expiresAt: string;
+} | {
+    valid: false;
+    reason: string;
+};
 declare const CENTRALQ_DEFAULT_API_URL = "http://localhost:3001";
 /** @internal — HTTP client usado internamente por CentralQ */
 declare class QueueHttpClient {
@@ -43,7 +68,10 @@ declare class QueueHttpClient {
      * Llamar al completar la compra o al salir voluntariamente.
      */
     leaveQueue(eventId: string, userId: string): Promise<void>;
-    issueQueueInitToken(eventId: string, userId?: string): Promise<QueueInitResponse>;
+    issueQueueInitToken(eventId: string, userId?: string, admissionProof?: string): Promise<QueueInitResponse>;
+    getProtection(eventId: string): Promise<QueueProtectionResponse>;
+    getAdmissionChallenge(eventId: string): Promise<AdmissionChallengeResponse>;
+    verifyToken(eventId: string, token: string): Promise<QueueVerifyResponse>;
 }
 
 /**
@@ -61,4 +89,4 @@ declare class CentralQElement extends LitElement {
     render(): lit.TemplateResult<1>;
 }
 
-export { CENTRALQ_DEFAULT_API_URL, CentralQElement, QueueHttpClient, type QueueJoinResponse };
+export { type AdmissionChallengeResponse, type AdmissionMode, CENTRALQ_DEFAULT_API_URL, CentralQElement, QueueHttpClient, type QueueJoinResponse, type QueueProtectionResponse, type QueueVerifyResponse };

package/dist/index.js

@@ -149,9 +149,14 @@ __export(index_exports, {
   CENTRALQ_DEFAULT_API_URL: () => CENTRALQ_DEFAULT_API_URL,
   CentralQ: () => CentralQ,
   CentralQClient: () => CentralQClient,
+  CentralQServerClient: () => CentralQServerClient,
+  CentralQServerRequestError: () => CentralQServerRequestError,
   QueueHttpClient: () => QueueHttpClient,
+  completeQueueAccessServer: () => completeQueueAccessServer,
   createCentralQClient: () => createCentralQClient,
-  validateQueueTokenServer: () => validateQueueTokenServer
+  createCentralQServerClient: () => createCentralQServerClient,
+  validateQueueTokenServer: () => validateQueueTokenServer,
+  verifyQueueAccessServer: () => verifyQueueAccessServer
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -223,13 +228,13 @@ var QueueHttpClient = class {
       }
     );
   }
-  async issueQueueInitToken(eventId, userId) {
+  async issueQueueInitToken(eventId, userId, admissionProof) {
     const res = await fetch(
       `${this.apiUrl}/api/queue/init/${encodeURIComponent(eventId)}`,
       {
         method: "POST",
         headers: this.headers,
-        body: JSON.stringify({ userId })
+        body: JSON.stringify({ userId, admissionProof })
       }
     );
     const body = await res.json().catch(() => ({}));
@@ -248,8 +253,155 @@ var QueueHttpClient = class {
       expiresAt: body.expiresAt
     };
   }
+  async getProtection(eventId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/protection`,
+      { headers: this.headers }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al consultar protecci\xF3n`
+      );
+    }
+    return {
+      eventId: body.eventId ?? eventId,
+      configured: body.configured === true,
+      protected: body.protected === true,
+      isActive: body.isActive === true,
+      admissionMode: body.admissionMode ?? "PUBLIC",
+      challengeRequired: body.challengeRequired === true
+    };
+  }
+  async getAdmissionChallenge(eventId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/admission`,
+      { headers: this.headers }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al preparar la admisi\xF3n`
+      );
+    }
+    if (body.required !== true) return { required: false };
+    if (!("publicKey" in body) || !body.publicKey) {
+      throw new Error("Respuesta inv\xE1lida al preparar la admisi\xF3n");
+    }
+    return {
+      required: true,
+      publicKey: body.publicKey,
+      appearance: "interaction-only"
+    };
+  }
+  async verifyToken(eventId, token) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/verify/${encodeURIComponent(eventId)}`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ token })
+      }
+    );
+    const body = await res.json().catch(() => ({
+      valid: false,
+      reason: "Respuesta inv\xE1lida"
+    }));
+    if (body.valid === true && body.userId && body.eventId && body.expiresAt) {
+      return body;
+    }
+    if (body.valid === false) {
+      return { valid: false, reason: body.reason ?? "Token inv\xE1lido" };
+    }
+    if (!res.ok) {
+      return {
+        valid: false,
+        reason: body.message ?? `Error ${res.status} al validar token de cola`
+      };
+    }
+    return { valid: false, reason: "Respuesta inv\xE1lida" };
+  }
 };
 
+// src/admission.ts
+var turnstileScript = null;
+function loadManagedAdmissionDriver() {
+  if (typeof window === "undefined" || typeof document === "undefined") {
+    return Promise.reject(
+      new Error("La admisi\xF3n administrada requiere un navegador")
+    );
+  }
+  if (window.turnstile) return Promise.resolve(window.turnstile);
+  if (turnstileScript) return turnstileScript;
+  turnstileScript = new Promise((resolve, reject) => {
+    const script = document.createElement("script");
+    script.src = "https://challenges.cloudflare.com/turnstile/v0/api.js?render=explicit";
+    script.async = true;
+    script.defer = true;
+    script.onload = () => {
+      if (window.turnstile) resolve(window.turnstile);
+      else {
+        turnstileScript = null;
+        reject(new Error("No se pudo inicializar la admisi\xF3n administrada"));
+      }
+    };
+    script.onerror = () => {
+      turnstileScript = null;
+      reject(new Error("No se pudo cargar la admisi\xF3n administrada"));
+    };
+    document.head.appendChild(script);
+  });
+  return turnstileScript;
+}
+async function acquireManagedAdmissionProof(publicKey) {
+  const driver = await loadManagedAdmissionDriver();
+  const container = document.createElement("div");
+  container.style.position = "fixed";
+  container.style.inset = "0";
+  container.style.zIndex = "2147483647";
+  container.style.display = "grid";
+  container.style.placeItems = "center";
+  container.style.pointerEvents = "auto";
+  document.body.appendChild(container);
+  return new Promise((resolve, reject) => {
+    let widgetId = "";
+    let timeout;
+    const cleanup = () => {
+      clearTimeout(timeout);
+      if (widgetId) driver.remove(widgetId);
+      container.remove();
+    };
+    timeout = setTimeout(() => {
+      cleanup();
+      reject(new Error("La validaci\xF3n de admisi\xF3n agot\xF3 el tiempo de espera"));
+    }, 15e3);
+    try {
+      widgetId = driver.render(container, {
+        sitekey: publicKey,
+        appearance: "interaction-only",
+        execution: "execute",
+        action: "centralq_admission",
+        callback: (token) => {
+          cleanup();
+          resolve(token);
+        },
+        "error-callback": () => {
+          cleanup();
+          reject(new Error("La validaci\xF3n de admisi\xF3n fall\xF3"));
+        },
+        "expired-callback": () => {
+          cleanup();
+          reject(new Error("La validaci\xF3n de admisi\xF3n expir\xF3"));
+        }
+      });
+      driver.execute(widgetId);
+    } catch {
+      cleanup();
+      reject(new Error("No se pudo ejecutar la admisi\xF3n administrada"));
+    }
+  });
+}
+
 // src/centralq.ts
 var CentralQ = class _CentralQ {
   constructor(options) {
@@ -454,7 +606,22 @@ var CentralQClient = class {
       this.defaults.apiUrl,
       this.defaults.apiKey
     );
-    return client.issueQueueInitToken(eventId, userId);
+    return this.issueInitToken(client, eventId, userId);
+  }
+  async issueInitToken(client, eventId, userId) {
+    if (typeof window === "undefined") {
+      return client.issueQueueInitToken(eventId, userId);
+    }
+    const protection = await client.getProtection(eventId);
+    if (!protection.challengeRequired) {
+      return client.issueQueueInitToken(eventId, userId);
+    }
+    const challenge = await client.getAdmissionChallenge(eventId);
+    if (!challenge.required) {
+      throw new Error("El evento requiere admisi\xF3n administrada");
+    }
+    const proof = await acquireManagedAdmissionProof(challenge.publicKey);
+    return client.issueQueueInitToken(eventId, userId, proof);
   }
   createQueue(options) {
     return CentralQ.init({
@@ -476,34 +643,118 @@ function createCentralQClient(options) {
 }
 
 // src/server.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var CentralQServerRequestError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "CentralQServerRequestError";
+    this.code = code;
+  }
+};
 function normalizeApiUrl2(apiUrl) {
-  return apiUrl.replace(/\/+$/, "");
+  const trimmed = apiUrl.trim().replace(/\/+$/, "");
+  return trimmed.endsWith("/api") ? trimmed.slice(0, -4) : trimmed;
 }
-async function validateQueueTokenServer(options) {
-  const apiUrl = options.apiUrl ?? CENTRALQ_DEFAULT_API_URL;
-  const response = await fetch(
-    `${normalizeApiUrl2(apiUrl)}/api/verify/${encodeURIComponent(options.eventId)}`,
-    {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "x-api-key": options.secretKey
+function validateOptions(options) {
+  if (!options.secretKey?.trim()) {
+    throw new TypeError("CentralQ secretKey es requerida");
+  }
+  if (options.timeoutMs !== void 0 && options.timeoutMs <= 0) {
+    throw new TypeError("CentralQ timeoutMs debe ser mayor a cero");
+  }
+}
+var CentralQServerClient = class {
+  constructor(options) {
+    validateOptions(options);
+    this.apiUrl = normalizeApiUrl2(options.apiUrl ?? CENTRALQ_DEFAULT_API_URL);
+    this.secretKey = options.secretKey.trim();
+    this.timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+  }
+  validateToken(input) {
+    return this.post(
+      `/api/queue/verify/${encodeURIComponent(input.eventId)}`,
+      { token: input.token },
+      { valid: false, reason: "Respuesta inv\xE1lida" }
+    );
+  }
+  verifyAccess(input) {
+    return this.post(
+      `/api/queue/verify/${encodeURIComponent(input.eventId)}/access`,
+      { token: input.token ?? null },
+      {
+        allowed: false,
+        reason: "invalid_response",
+        message: "Respuesta inv\xE1lida"
+      }
+    );
+  }
+  completeAccess(input) {
+    return this.post(
+      `/api/queue/verify/${encodeURIComponent(input.eventId)}/complete`,
+      {
+        token: input.token,
+        completionId: input.completionId
       },
-      body: JSON.stringify({ token: options.token })
+      { completed: false, reason: "invalid_response" }
+    );
+  }
+  async post(path, body, fallback) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const response = await this.fetchFn(`${this.apiUrl}${path}`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.secretKey
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      const data = await response.json().catch(() => fallback);
+      return { status: response.status, data };
+    } catch (error) {
+      if (controller.signal.aborted) {
+        throw new CentralQServerRequestError(
+          "timeout",
+          `CentralQ no respondi\xF3 en ${this.timeoutMs}ms`,
+          { cause: error }
+        );
+      }
+      throw new CentralQServerRequestError(
+        "network_error",
+        "No se pudo conectar con CentralQ",
+        { cause: error }
+      );
+    } finally {
+      clearTimeout(timeout);
     }
-  );
-  const data = await response.json().catch(() => ({
-    valid: false,
-    reason: "Respuesta inv\xE1lida"
-  }));
-  return { status: response.status, data };
+  }
+};
+function createCentralQServerClient(options) {
+  return new CentralQServerClient(options);
+}
+function validateQueueTokenServer(options) {
+  return createCentralQServerClient(options).validateToken(options);
+}
+function verifyQueueAccessServer(options) {
+  return createCentralQServerClient(options).verifyAccess(options);
+}
+function completeQueueAccessServer(options) {
+  return createCentralQServerClient(options).completeAccess(options);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   CENTRALQ_DEFAULT_API_URL,
   CentralQ,
   CentralQClient,
+  CentralQServerClient,
+  CentralQServerRequestError,
   QueueHttpClient,
+  completeQueueAccessServer,
   createCentralQClient,
-  validateQueueTokenServer
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
 });

package/dist/index.mjs

@@ -1,21 +1,31 @@
 import {
-  validateQueueTokenServer
-} from "./chunk-JR7BCYB5.mjs";
+  CentralQServerClient,
+  CentralQServerRequestError,
+  completeQueueAccessServer,
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
+} from "./chunk-FAJWYFUK.mjs";
 import {
   CentralQ,
   CentralQClient,
   createCentralQClient
-} from "./chunk-A4HITWM4.mjs";
+} from "./chunk-BVCZFNM3.mjs";
 import {
   CENTRALQ_DEFAULT_API_URL,
   QueueHttpClient
-} from "./chunk-42RGFZKP.mjs";
+} from "./chunk-P73Q2ZIO.mjs";
 import "./chunk-XRJFNASX.mjs";
 export {
   CENTRALQ_DEFAULT_API_URL,
   CentralQ,
   CentralQClient,
+  CentralQServerClient,
+  CentralQServerRequestError,
   QueueHttpClient,
+  completeQueueAccessServer,
   createCentralQClient,
-  validateQueueTokenServer
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
 };

package/dist/react.d.mts

@@ -1,4 +1,4 @@
-import { C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, d as CentralQOptions } from './centralq-I9tdL_Xr.mjs';
+import { C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, d as CentralQOptions } from './centralq-C3ukDo0x.mjs';
 
 interface UseCentralQReturn {
     /** Token JWT si el usuario fue admitido, null si no */

package/dist/react.d.ts

@@ -1,4 +1,4 @@
-import { C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, d as CentralQOptions } from './centralq-I9tdL_Xr.js';
+import { C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, d as CentralQOptions } from './centralq-C3ukDo0x.js';
 
 interface UseCentralQReturn {
     /** Token JWT si el usuario fue admitido, null si no */

package/dist/react.js

@@ -220,13 +220,13 @@ var QueueHttpClient = class {
       }
     );
   }
-  async issueQueueInitToken(eventId, userId) {
+  async issueQueueInitToken(eventId, userId, admissionProof) {
     const res = await fetch(
       `${this.apiUrl}/api/queue/init/${encodeURIComponent(eventId)}`,
       {
         method: "POST",
         headers: this.headers,
-        body: JSON.stringify({ userId })
+        body: JSON.stringify({ userId, admissionProof })
       }
     );
     const body = await res.json().catch(() => ({}));
@@ -245,6 +245,74 @@ var QueueHttpClient = class {
       expiresAt: body.expiresAt
     };
   }
+  async getProtection(eventId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/protection`,
+      { headers: this.headers }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al consultar protecci\xF3n`
+      );
+    }
+    return {
+      eventId: body.eventId ?? eventId,
+      configured: body.configured === true,
+      protected: body.protected === true,
+      isActive: body.isActive === true,
+      admissionMode: body.admissionMode ?? "PUBLIC",
+      challengeRequired: body.challengeRequired === true
+    };
+  }
+  async getAdmissionChallenge(eventId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/admission`,
+      { headers: this.headers }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al preparar la admisi\xF3n`
+      );
+    }
+    if (body.required !== true) return { required: false };
+    if (!("publicKey" in body) || !body.publicKey) {
+      throw new Error("Respuesta inv\xE1lida al preparar la admisi\xF3n");
+    }
+    return {
+      required: true,
+      publicKey: body.publicKey,
+      appearance: "interaction-only"
+    };
+  }
+  async verifyToken(eventId, token) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/verify/${encodeURIComponent(eventId)}`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ token })
+      }
+    );
+    const body = await res.json().catch(() => ({
+      valid: false,
+      reason: "Respuesta inv\xE1lida"
+    }));
+    if (body.valid === true && body.userId && body.eventId && body.expiresAt) {
+      return body;
+    }
+    if (body.valid === false) {
+      return { valid: false, reason: body.reason ?? "Token inv\xE1lido" };
+    }
+    if (!res.ok) {
+      return {
+        valid: false,
+        reason: body.message ?? `Error ${res.status} al validar token de cola`
+      };
+    }
+    return { valid: false, reason: "Respuesta inv\xE1lida" };
+  }
 };
 
 // src/centralq.ts

package/dist/react.mjs

@@ -1,7 +1,7 @@
 import {
   CentralQ
-} from "./chunk-A4HITWM4.mjs";
-import "./chunk-42RGFZKP.mjs";
+} from "./chunk-BVCZFNM3.mjs";
+import "./chunk-P73Q2ZIO.mjs";
 import "./chunk-XRJFNASX.mjs";
 
 // src/react.ts

package/dist/server.d.mts

@@ -1,6 +1,10 @@
-interface ValidateQueueTokenServerOptions {
+interface CentralQServerClientOptions {
     apiUrl?: string;
     secretKey: string;
+    timeoutMs?: number;
+    fetch?: typeof fetch;
+}
+interface ValidateQueueTokenServerOptions extends CentralQServerClientOptions {
     eventId: string;
     token: string;
 }
@@ -13,9 +17,85 @@ type QueueTokenValidationResult = {
     valid: false;
     reason: string;
 };
+interface VerifyQueueAccessServerOptions extends CentralQServerClientOptions {
+    eventId: string;
+    token?: string;
+}
+type QueueAccessValidationResult = {
+    allowed: true;
+    eventId: string;
+    protected: boolean;
+    reason?: string;
+    userId?: string;
+    expiresAt?: string;
+} | {
+    allowed: false;
+    eventId?: string;
+    protected?: boolean;
+    reason?: string;
+    message?: string;
+};
+interface CompleteQueueAccessServerOptions extends CentralQServerClientOptions {
+    eventId: string;
+    token: string;
+    completionId: string;
+}
+type QueueAccessCompletionResult = {
+    completed: true;
+    alreadyCompleted: boolean;
+} | {
+    completed: false;
+    reason: string;
+};
+type CentralQServerRequestErrorCode = "network_error" | "timeout";
+declare class CentralQServerRequestError extends Error {
+    readonly code: CentralQServerRequestErrorCode;
+    constructor(code: CentralQServerRequestErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+declare class CentralQServerClient {
+    private readonly apiUrl;
+    private readonly secretKey;
+    private readonly timeoutMs;
+    private readonly fetchFn;
+    constructor(options: CentralQServerClientOptions);
+    validateToken(input: {
+        eventId: string;
+        token: string;
+    }): Promise<{
+        status: number;
+        data: QueueTokenValidationResult;
+    }>;
+    verifyAccess(input: {
+        eventId: string;
+        token?: string;
+    }): Promise<{
+        status: number;
+        data: QueueAccessValidationResult;
+    }>;
+    completeAccess(input: {
+        eventId: string;
+        token: string;
+        completionId: string;
+    }): Promise<{
+        status: number;
+        data: QueueAccessCompletionResult;
+    }>;
+    private post;
+}
+declare function createCentralQServerClient(options: CentralQServerClientOptions): CentralQServerClient;
 declare function validateQueueTokenServer(options: ValidateQueueTokenServerOptions): Promise<{
     status: number;
     data: QueueTokenValidationResult;
 }>;
+declare function verifyQueueAccessServer(options: VerifyQueueAccessServerOptions): Promise<{
+    status: number;
+    data: QueueAccessValidationResult;
+}>;
+declare function completeQueueAccessServer(options: CompleteQueueAccessServerOptions): Promise<{
+    status: number;
+    data: QueueAccessCompletionResult;
+}>;
 
-export { type QueueTokenValidationResult, type ValidateQueueTokenServerOptions, validateQueueTokenServer };
+export { CentralQServerClient, type CentralQServerClientOptions, CentralQServerRequestError, type CentralQServerRequestErrorCode, type CompleteQueueAccessServerOptions, type QueueAccessCompletionResult, type QueueAccessValidationResult, type QueueTokenValidationResult, type ValidateQueueTokenServerOptions, type VerifyQueueAccessServerOptions, completeQueueAccessServer, createCentralQServerClient, validateQueueTokenServer, verifyQueueAccessServer };