@central-ticket/queue-sdk 0.0.2 → 0.0.4

package/dist/server.d.ts

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

package/dist/server.js

@@ -20,7 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server.ts
 var server_exports = {};
 __export(server_exports, {
-  validateQueueTokenServer: () => validateQueueTokenServer
+  CentralQServerClient: () => CentralQServerClient,
+  CentralQServerRequestError: () => CentralQServerRequestError,
+  completeQueueAccessServer: () => completeQueueAccessServer,
+  createCentralQServerClient: () => createCentralQServerClient,
+  validateQueueTokenServer: () => validateQueueTokenServer,
+  verifyQueueAccessServer: () => verifyQueueAccessServer
 });
 module.exports = __toCommonJS(server_exports);
 
@@ -28,29 +33,113 @@ module.exports = __toCommonJS(server_exports);
 var CENTRALQ_DEFAULT_API_URL = "http://localhost:3001";
 
 // 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 normalizeApiUrl(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(
-    `${normalizeApiUrl(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 = normalizeApiUrl(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 = {
-  validateQueueTokenServer
+  CentralQServerClient,
+  CentralQServerRequestError,
+  completeQueueAccessServer,
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
 });

package/dist/server.mjs

@@ -1,8 +1,18 @@
 import {
-  validateQueueTokenServer
-} from "./chunk-JJ33EJ65.mjs";
-import "./chunk-P73Q2ZIO.mjs";
+  CentralQServerClient,
+  CentralQServerRequestError,
+  completeQueueAccessServer,
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
+} from "./chunk-CFWLZCAR.mjs";
+import "./chunk-OR3GGW4J.mjs";
 import "./chunk-XRJFNASX.mjs";
 export {
-  validateQueueTokenServer
+  CentralQServerClient,
+  CentralQServerRequestError,
+  completeQueueAccessServer,
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
 };

package/dist/svelte.d.mts

@@ -1,5 +1,5 @@
 import { Readable } from 'svelte/store';
-import { Q as QueueStatus, C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, d as CentralQOptions } from './centralq-C3ukDo0x.mjs';
+import { m as QueueStatus, b as CentralQ, e as CentralQCreateOptions, c as CentralQClient, f as CentralQOptions } from './centralq-CCw_Cqam.mjs';
 
 interface CentralQStores {
     /** Store con el token JWT si el usuario fue admitido */

package/dist/svelte.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'svelte/store';
-import { Q as QueueStatus, C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, d as CentralQOptions } from './centralq-C3ukDo0x.js';
+import { m as QueueStatus, b as CentralQ, e as CentralQCreateOptions, c as CentralQClient, f as CentralQOptions } from './centralq-CCw_Cqam.js';
 
 interface CentralQStores {
     /** Store con el token JWT si el usuario fue admitido */

package/dist/svelte.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>
@@ -193,6 +198,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.
@@ -262,6 +291,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
     };
@@ -500,6 +530,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");
@@ -533,6 +581,11 @@ function createCentralQ(options) {
       _position.set(detail.position);
       _ahead.set(detail.ahead);
     });
+    queue.on("paused", () => {
+      _position.set(null);
+      _ahead.set(null);
+      _error.set(false);
+    });
     queue.on("expired", () => {
       _token.set(null);
       _expired.set(true);
@@ -643,6 +696,17 @@ function useQueue(optionsInput) {
           status.set("waiting");
           isPending.set(false);
         });
+        queue.on("paused", (_detail) => {
+          data.set({
+            token: null,
+            position: null,
+            ahead: null,
+            expiresAt: null
+          });
+          status.set("paused");
+          error.set(null);
+          isPending.set(false);
+        });
         queue.on("expired", () => {
           data.set({
             token: null,

package/dist/svelte.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/svelte.ts
@@ -27,6 +27,11 @@ function createCentralQ(options) {
       _position.set(detail.position);
       _ahead.set(detail.ahead);
     });
+    queue.on("paused", () => {
+      _position.set(null);
+      _ahead.set(null);
+      _error.set(false);
+    });
     queue.on("expired", () => {
       _token.set(null);
       _expired.set(true);
@@ -137,6 +142,17 @@ function useQueue(optionsInput) {
           status.set("waiting");
           isPending.set(false);
         });
+        queue.on("paused", (_detail) => {
+          data.set({
+            token: null,
+            position: null,
+            ahead: null,
+            expiresAt: null
+          });
+          status.set("paused");
+          error.set(null);
+          isPending.set(false);
+        });
         queue.on("expired", () => {
           data.set({
             token: null,

package/dist/vue.d.mts

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, C as CentralQ } from './centralq-C3ukDo0x.mjs';
+import { e as CentralQCreateOptions, c as CentralQClient, m as QueueStatus, b as CentralQ } from './centralq-CCw_Cqam.mjs';
 
 interface QueueData {
     token: string | null;

package/dist/vue.d.ts

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, C as CentralQ } from './centralq-C3ukDo0x.js';
+import { e as CentralQCreateOptions, c as CentralQClient, m as QueueStatus, b as CentralQ } from './centralq-CCw_Cqam.js';
 
 interface QueueData {
     token: string | null;

package/dist/vue.js

@@ -71,6 +71,15 @@ function useQueue(optionsInput) {
       status.value = "waiting";
       isPending.value = false;
     });
+    queue.on("paused", (_detail) => {
+      token.value = null;
+      position.value = null;
+      ahead.value = null;
+      expiresAt.value = null;
+      status.value = "paused";
+      isPending.value = false;
+      error.value = null;
+    });
     queue.on("expired", () => {
       token.value = null;
       position.value = null;

package/dist/vue.mjs

@@ -56,6 +56,15 @@ function useQueue(optionsInput) {
       status.value = "waiting";
       isPending.value = false;
     });
+    queue.on("paused", (_detail) => {
+      token.value = null;
+      position.value = null;
+      ahead.value = null;
+      expiresAt.value = null;
+      status.value = "paused";
+      isPending.value = false;
+      error.value = null;
+    });
     queue.on("expired", () => {
       token.value = null;
       position.value = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@central-ticket/queue-sdk",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "keywords": [
     "virtual-queue",
     "waiting-room",
@@ -53,7 +53,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "tsup src/index.ts src/react.ts src/svelte.ts src/vue.ts src/server.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts src/react.ts src/svelte.ts src/vue.ts src/server.ts --format cjs,esm --dts --clean",
     "dev": "tsup src/index.ts src/react.ts src/svelte.ts src/vue.ts src/server.ts --format cjs,esm --dts --watch",
     "check-types": "tsc --noEmit",
     "test": "vitest run",

package/dist/centralq-I9tdL_Xr.d.mts

@@ -1,133 +0,0 @@
-interface CentralQOptions {
-    /** URL del queue worker. */
-    apiUrl?: string;
-    /** Publishable API key (ctq_pub_xxx) */
-    apiKey: string;
-    /** ID del evento/recurso a proteger */
-    eventId: string;
-    /** ID de usuario externo. Si no se provee, se autogenera y persiste en sessionStorage */
-    userId?: string;
-    /** Init token corto emitido por backend (recomendado para producción) */
-    queueInitToken?: string;
-    /** Intervalo de polling en ms (default: 10000) */
-    pollInterval?: number;
-    /** Contenedor donde montar el overlay. Default: document.body */
-    container?: HTMLElement;
-}
-interface CentralQClientOptions {
-    /** URL del queue worker */
-    apiUrl?: string;
-    /** Publishable API key (ctq_pub_xxx) */
-    apiKey: string;
-    /** ID de usuario externo por defecto para todas las colas creadas por el client */
-    userId?: string;
-    /** Init token corto por defecto para colas creadas por el client */
-    queueInitToken?: string;
-    /** Intervalo de polling por defecto en ms */
-    pollInterval?: number;
-    /** Contenedor por defecto donde montar el overlay */
-    container?: HTMLElement;
-}
-interface CentralQCreateOptions {
-    /** ID del evento/recurso a proteger */
-    eventId: string;
-    /** Override opcional del userId por cola */
-    userId?: string;
-    /** Override opcional del queue init token por cola */
-    queueInitToken?: string;
-    /** Override opcional del poll interval por cola */
-    pollInterval?: number;
-    /** Override opcional del contenedor por cola */
-    container?: HTMLElement;
-    /** Override opcional del apiUrl por cola */
-    apiUrl?: string;
-    /** Override opcional del apiKey por cola */
-    apiKey?: string;
-}
-interface PassedDetail {
-    token: string;
-    expiresAt: number;
-    userId: string;
-    eventId: string;
-}
-interface PositionDetail {
-    position: number;
-    ahead: number;
-    userId: string;
-    eventId: string;
-}
-interface ExpiredDetail {
-    userId: string;
-    eventId: string;
-}
-interface ErrorDetail {
-    userId: string;
-    eventId: string;
-}
-type EventMap = {
-    passed: PassedDetail;
-    expired: ExpiredDetail;
-    position: PositionDetail;
-    error: ErrorDetail;
-};
-type EventName = keyof EventMap;
-type Listener<T> = (detail: T) => void;
-type QueueStatus = "idle" | "joining" | "waiting" | "passed" | "expired" | "error";
-declare class CentralQ {
-    private client;
-    private element;
-    private userId;
-    private eventId;
-    private pollInterval;
-    private container;
-    private pollingTimer?;
-    private heartbeatTimer?;
-    private expiryTimer?;
-    private destroyed;
-    private listeners;
-    private constructor();
-    /**
-     * Inicializa CentralQ y comienza el flujo de cola automáticamente.
-     * Monta el overlay de UI y empieza a hacer polling.
-     */
-    static init(options: CentralQOptions): CentralQ;
-    /** Suscribirse a un evento del ciclo de vida de la cola */
-    on<K extends EventName>(event: K, listener: Listener<EventMap[K]>): this;
-    /** Desuscribirse de un evento */
-    off<K extends EventName>(event: K, listener: Listener<EventMap[K]>): this;
-    private emit;
-    /**
-     * Libera el slot del usuario inmediatamente.
-     * Llamar cuando el usuario completa la compra.
-     */
-    leave(): void;
-    /**
-     * Destruye la instancia: para todos los timers, desmonta el overlay,
-     * y libera el slot en el servidor.
-     */
-    destroy(): void;
-    /** Retorna el userId resuelto (externo o autogenerado) */
-    getUserId(): string;
-    private resolveUserId;
-    private mount;
-    private unmount;
-    private updateUI;
-    private stopTimers;
-    private startHeartbeat;
-    private scheduleExpiry;
-    private handleExpired;
-    private checkQueue;
-}
-declare class CentralQClient {
-    private defaults;
-    constructor(defaults: CentralQClientOptions);
-    issueQueueInitToken(eventId: string, userId?: string): Promise<{
-        userId: string;
-        queueInitToken: string;
-        expiresAt: number;
-    }>;
-    createQueue(options: CentralQCreateOptions): CentralQ;
-}
-declare function createCentralQClient(options: CentralQClientOptions): CentralQClient;
-
-export { CentralQ as C, type ErrorDetail as E, type PassedDetail as P, type QueueStatus as Q, CentralQClient as a, type CentralQClientOptions as b, type CentralQCreateOptions as c, type CentralQOptions as d, type ExpiredDetail as e, type PositionDetail as f, createCentralQClient as g };