@central-ticket/queue-sdk 0.0.1 → 0.0.3

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/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-JR7BCYB5.mjs";
-import "./chunk-42RGFZKP.mjs";
+  CentralQServerClient,
+  CentralQServerRequestError,
+  completeQueueAccessServer,
+  createCentralQServerClient,
+  validateQueueTokenServer,
+  verifyQueueAccessServer
+} from "./chunk-FAJWYFUK.mjs";
+import "./chunk-P73Q2ZIO.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-I9tdL_Xr.mjs';
+import { Q as QueueStatus, C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, d as CentralQOptions } from './centralq-C3ukDo0x.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-I9tdL_Xr.js';
+import { Q as QueueStatus, C as CentralQ, c as CentralQCreateOptions, a as CentralQClient, d as CentralQOptions } from './centralq-C3ukDo0x.js';
 
 interface CentralQStores {
     /** Store con el token JWT si el usuario fue admitido */

package/dist/svelte.js

@@ -221,13 +221,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(() => ({}));
@@ -246,6 +246,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/svelte.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/svelte.ts

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-I9tdL_Xr.mjs';
+import { c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, C as CentralQ } from './centralq-C3ukDo0x.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-I9tdL_Xr.js';
+import { c as CentralQCreateOptions, a as CentralQClient, Q as QueueStatus, C as CentralQ } from './centralq-C3ukDo0x.js';
 
 interface QueueData {
     token: string | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@central-ticket/queue-sdk",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "keywords": [
     "virtual-queue",
     "waiting-room",
@@ -87,4 +87,4 @@
   "dependencies": {
     "lit": "^3.3.2"
   }
-}
+}