@central-ticket/queue-sdk 0.0.2 → 0.0.4

package/dist/index.js

@@ -68,6 +68,11 @@ var init_queue_element = __esm({
                   Por favor, no cierres esta ventana.
                 </p>
               ` : ""}
+          ${this.status === "PAUSED" ? import_lit.html`
+                <h2>La fila está temporalmente cerrada</h2>
+                <p>Volveremos a intentar automáticamente.</p>
+                <div class="spinner"></div>
+              ` : ""}
           ${this.status === "EXPIRED" ? import_lit.html`
                 <h2 style="color: #f59e0b;">Tu sesión ha expirado</h2>
                 <p>El tiempo para completar la compra terminó.</p>
@@ -149,9 +154,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);
 
@@ -195,6 +205,30 @@ var QueueHttpClient = class {
     }
     return res.json();
   }
+  /**
+   * Canjea un código de bypass por un token de acceso activo.
+   * El worker descuenta un uso únicamente cuando el canje es exitoso.
+   */
+  async redeemBypassCode(eventId, code, userId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/bypass`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ code, userId })
+      }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al canjear c\xF3digo bypass`
+      );
+    }
+    if (body.status !== "ACTIVE" || !body.token || !body.expiresAt || body.bypass !== true) {
+      throw new Error("Respuesta inv\xE1lida al canjear c\xF3digo bypass");
+    }
+    return body;
+  }
   /**
    * Envía un heartbeat para mantener vivo el slot (waiting o active).
    * El SDK lo llama cada 10s automáticamente.
@@ -264,6 +298,7 @@ var QueueHttpClient = class {
       configured: body.configured === true,
       protected: body.protected === true,
       isActive: body.isActive === true,
+      isPaused: body.isPaused === true,
       admissionMode: body.admissionMode ?? "PUBLIC",
       challengeRequired: body.challengeRequired === true
     };
@@ -581,6 +616,24 @@ var CentralQ = class _CentralQ {
             this.pollInterval
           );
         }
+      } else if (res.status === "PAUSED") {
+        this.updateUI("PAUSED");
+        this.emit("paused", {
+          message: res.message,
+          retryAfterSeconds: res.retryAfterSeconds,
+          userId: this.userId,
+          eventId: this.eventId
+        });
+        if (!this.pollingTimer) {
+          const retryInterval = Math.max(
+            this.pollInterval,
+            res.retryAfterSeconds * 1e3
+          );
+          this.pollingTimer = setInterval(
+            () => this.checkQueue(),
+            retryInterval
+          );
+        }
       }
     } catch {
       this.updateUI("ERROR");
@@ -596,6 +649,13 @@ var CentralQClient = class {
   constructor(defaults) {
     this.defaults = defaults;
   }
+  redeemBypassCode(eventId, code, userId) {
+    const client = new QueueHttpClient(
+      this.defaults.apiUrl,
+      this.defaults.apiKey
+    );
+    return client.redeemBypassCode(eventId, code, userId);
+  }
   issueQueueInitToken(eventId, userId) {
     const client = new QueueHttpClient(
       this.defaults.apiUrl,
@@ -638,34 +698,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/queue/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-JJ33EJ65.mjs";
+  CentralQServerClient,
+  CentralQServerRequestError,
+  completeQueueAccessServer,
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
+} from "./chunk-CFWLZCAR.mjs";
 import {
   CentralQ,
   CentralQClient,
   createCentralQClient
-} from "./chunk-BVCZFNM3.mjs";
+} from "./chunk-OVV3CIZZ.mjs";
 import {
   CENTRALQ_DEFAULT_API_URL,
   QueueHttpClient
-} from "./chunk-P73Q2ZIO.mjs";
+} from "./chunk-OR3GGW4J.mjs";
 import "./chunk-XRJFNASX.mjs";
 export {
   CENTRALQ_DEFAULT_API_URL,
   CentralQ,
   CentralQClient,
+  CentralQServerClient,
+  CentralQServerRequestError,
   QueueHttpClient,
+  completeQueueAccessServer,
   createCentralQClient,
-  validateQueueTokenServer
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
 };

package/dist/{queue-element-DXBW64U2.mjs → queue-element-QDDGTF6K.mjs}

@@ -34,6 +34,11 @@ var CentralQElement = class extends LitElement {
                   Por favor, no cierres esta ventana.
                 </p>
               ` : ""}
+          ${this.status === "PAUSED" ? html`
+                <h2>La fila está temporalmente cerrada</h2>
+                <p>Volveremos a intentar automáticamente.</p>
+                <div class="spinner"></div>
+              ` : ""}
           ${this.status === "EXPIRED" ? html`
                 <h2 style="color: #f59e0b;">Tu sesión ha expirado</h2>
                 <p>El tiempo para completar la compra terminó.</p>

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-C3ukDo0x.mjs';
+import { b as CentralQ, e as CentralQCreateOptions, c as CentralQClient, m as QueueStatus, f as CentralQOptions } from './centralq-CCw_Cqam.mjs';
 
 interface UseCentralQReturn {
     /** Token JWT si el usuario fue admitido, null si no */
@@ -11,6 +11,8 @@ interface UseCentralQReturn {
     expired: boolean;
     /** true si hay un error de conexión */
     error: boolean;
+    /** true si la cola no acepta nuevos ingresos temporalmente */
+    paused: boolean;
     /** Libera el slot (llamar después de comprar) */
     leave: () => void;
     /** Instancia CentralQ subyacente (para uso avanzado) */

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-C3ukDo0x.js';
+import { b as CentralQ, e as CentralQCreateOptions, c as CentralQClient, m as QueueStatus, f as CentralQOptions } from './centralq-CCw_Cqam.js';
 
 interface UseCentralQReturn {
     /** Token JWT si el usuario fue admitido, null si no */
@@ -11,6 +11,8 @@ interface UseCentralQReturn {
     expired: boolean;
     /** true si hay un error de conexión */
     error: boolean;
+    /** true si la cola no acepta nuevos ingresos temporalmente */
+    paused: boolean;
     /** Libera el slot (llamar después de comprar) */
     leave: () => void;
     /** Instancia CentralQ subyacente (para uso avanzado) */

package/dist/react.js

@@ -68,6 +68,11 @@ var init_queue_element = __esm({
                   Por favor, no cierres esta ventana.
                 </p>
               ` : ""}
+          ${this.status === "PAUSED" ? import_lit.html`
+                <h2>La fila está temporalmente cerrada</h2>
+                <p>Volveremos a intentar automáticamente.</p>
+                <div class="spinner"></div>
+              ` : ""}
           ${this.status === "EXPIRED" ? import_lit.html`
                 <h2 style="color: #f59e0b;">Tu sesión ha expirado</h2>
                 <p>El tiempo para completar la compra terminó.</p>
@@ -192,6 +197,30 @@ var QueueHttpClient = class {
     }
     return res.json();
   }
+  /**
+   * Canjea un código de bypass por un token de acceso activo.
+   * El worker descuenta un uso únicamente cuando el canje es exitoso.
+   */
+  async redeemBypassCode(eventId, code, userId) {
+    const res = await fetch(
+      `${this.apiUrl}/api/queue/${encodeURIComponent(eventId)}/bypass`,
+      {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify({ code, userId })
+      }
+    );
+    const body = await res.json().catch(() => ({}));
+    if (!res.ok) {
+      throw new Error(
+        body.message ?? `Error ${res.status} al canjear c\xF3digo bypass`
+      );
+    }
+    if (body.status !== "ACTIVE" || !body.token || !body.expiresAt || body.bypass !== true) {
+      throw new Error("Respuesta inv\xE1lida al canjear c\xF3digo bypass");
+    }
+    return body;
+  }
   /**
    * Envía un heartbeat para mantener vivo el slot (waiting o active).
    * El SDK lo llama cada 10s automáticamente.
@@ -261,6 +290,7 @@ var QueueHttpClient = class {
       configured: body.configured === true,
       protected: body.protected === true,
       isActive: body.isActive === true,
+      isPaused: body.isPaused === true,
       admissionMode: body.admissionMode ?? "PUBLIC",
       challengeRequired: body.challengeRequired === true
     };
@@ -499,6 +529,24 @@ var CentralQ = class _CentralQ {
             this.pollInterval
           );
         }
+      } else if (res.status === "PAUSED") {
+        this.updateUI("PAUSED");
+        this.emit("paused", {
+          message: res.message,
+          retryAfterSeconds: res.retryAfterSeconds,
+          userId: this.userId,
+          eventId: this.eventId
+        });
+        if (!this.pollingTimer) {
+          const retryInterval = Math.max(
+            this.pollInterval,
+            res.retryAfterSeconds * 1e3
+          );
+          this.pollingTimer = setInterval(
+            () => this.checkQueue(),
+            retryInterval
+          );
+        }
       }
     } catch {
       this.updateUI("ERROR");
@@ -518,12 +566,14 @@ function useCentralQ(options) {
   const [ahead, setAhead] = (0, import_react.useState)(null);
   const [expired, setExpired] = (0, import_react.useState)(false);
   const [error, setError] = (0, import_react.useState)(false);
+  const [paused, setPaused] = (0, import_react.useState)(false);
   const instanceRef = (0, import_react.useRef)(null);
   const leave = (0, import_react.useCallback)(() => {
     instanceRef.current?.leave();
     setToken(null);
     setPosition(null);
     setAhead(null);
+    setPaused(false);
   }, []);
   (0, import_react.useEffect)(() => {
     const queue = CentralQ.init(options);
@@ -533,17 +583,26 @@ function useCentralQ(options) {
       setAhead(null);
       setExpired(false);
       setError(false);
+      setPaused(false);
     });
     queue.on("position", (detail) => {
       setPosition(detail.position);
       setAhead(detail.ahead);
+      setPaused(false);
+    });
+    queue.on("paused", () => {
+      setPosition(null);
+      setAhead(null);
+      setPaused(true);
     });
     queue.on("expired", () => {
       setToken(null);
       setExpired(true);
+      setPaused(false);
     });
     queue.on("error", () => {
       setError(true);
+      setPaused(false);
     });
     instanceRef.current = queue;
     return () => {
@@ -557,6 +616,7 @@ function useCentralQ(options) {
     ahead,
     expired,
     error,
+    paused,
     leave,
     instance: instanceRef.current
   };
@@ -636,6 +696,16 @@ function useQueue(options) {
           }));
           setStatus("waiting");
         });
+        queue.on("paused", (_detail) => {
+          setData({
+            token: null,
+            position: null,
+            ahead: null,
+            expiresAt: null
+          });
+          setStatus("paused");
+          setError(null);
+        });
         queue.on("expired", () => {
           setData({
             token: null,

package/dist/react.mjs

@@ -1,7 +1,7 @@
 import {
   CentralQ
-} from "./chunk-BVCZFNM3.mjs";
-import "./chunk-P73Q2ZIO.mjs";
+} from "./chunk-OVV3CIZZ.mjs";
+import "./chunk-OR3GGW4J.mjs";
 import "./chunk-XRJFNASX.mjs";
 
 // src/react.ts
@@ -12,12 +12,14 @@ function useCentralQ(options) {
   const [ahead, setAhead] = useState(null);
   const [expired, setExpired] = useState(false);
   const [error, setError] = useState(false);
+  const [paused, setPaused] = useState(false);
   const instanceRef = useRef(null);
   const leave = useCallback(() => {
     instanceRef.current?.leave();
     setToken(null);
     setPosition(null);
     setAhead(null);
+    setPaused(false);
   }, []);
   useEffect(() => {
     const queue = CentralQ.init(options);
@@ -27,17 +29,26 @@ function useCentralQ(options) {
       setAhead(null);
       setExpired(false);
       setError(false);
+      setPaused(false);
     });
     queue.on("position", (detail) => {
       setPosition(detail.position);
       setAhead(detail.ahead);
+      setPaused(false);
+    });
+    queue.on("paused", () => {
+      setPosition(null);
+      setAhead(null);
+      setPaused(true);
     });
     queue.on("expired", () => {
       setToken(null);
       setExpired(true);
+      setPaused(false);
     });
     queue.on("error", () => {
       setError(true);
+      setPaused(false);
     });
     instanceRef.current = queue;
     return () => {
@@ -51,6 +62,7 @@ function useCentralQ(options) {
     ahead,
     expired,
     error,
+    paused,
     leave,
     instance: instanceRef.current
   };
@@ -130,6 +142,16 @@ function useQueue(options) {
           }));
           setStatus("waiting");
         });
+        queue.on("paused", (_detail) => {
+          setData({
+            token: null,
+            position: null,
+            ahead: null,
+            expiresAt: null
+          });
+          setStatus("paused");
+          setError(null);
+        });
         queue.on("expired", () => {
           setData({
             token: null,

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 };