@tiquo/dom-package 1.0.0

package/dist/index.js

@@ -0,0 +1,637 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  TiquoAuth: () => TiquoAuth,
+  TiquoAuthError: () => TiquoAuthError,
+  default: () => index_default,
+  useTiquoAuth: () => useTiquoAuth
+});
+module.exports = __toCommonJS(index_exports);
+var TiquoAuthError = class extends Error {
+  constructor(message, code, statusCode) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.name = "TiquoAuthError";
+  }
+};
+var TiquoAuth = class {
+  constructor(config) {
+    this.sessionToken = null;
+    this.session = null;
+    this.listeners = /* @__PURE__ */ new Set();
+    this.refreshTimer = null;
+    // Multi-tab sync
+    this.broadcastChannel = null;
+    this.isProcessingTabSync = false;
+    if (!config.publicKey) {
+      throw new TiquoAuthError("publicKey is required", "MISSING_PUBLIC_KEY");
+    }
+    if (!config.publicKey.startsWith("pk_dom_")) {
+      throw new TiquoAuthError(
+        "Invalid public key format. Expected pk_dom_xxx",
+        "INVALID_PUBLIC_KEY"
+      );
+    }
+    this.config = {
+      publicKey: config.publicKey,
+      apiEndpoint: config.apiEndpoint || "https://edge.tiquo.app",
+      storagePrefix: config.storagePrefix || "tiquo_auth_",
+      debug: config.debug || false,
+      enableTabSync: config.enableTabSync !== false
+      // Default true
+    };
+    this.tabId = this.generateTabId();
+    if (this.config.enableTabSync) {
+      this.initTabSync();
+    }
+    this.restoreSession();
+  }
+  // ============================================
+  // PUBLIC METHODS
+  // ============================================
+  /**
+   * Send an OTP verification code to the user's email
+   */
+  async sendOTP(email) {
+    this.log("Sending OTP to:", email);
+    const response = await this.request("/api/auth-dom/otp/send", {
+      method: "POST",
+      body: JSON.stringify({
+        publicKey: this.config.publicKey,
+        email
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to send OTP" }));
+      throw new TiquoAuthError(error.error || "Failed to send OTP", "OTP_SEND_FAILED", response.status);
+    }
+    const result = await response.json();
+    return {
+      success: true,
+      message: result.message || "OTP sent"
+    };
+  }
+  /**
+   * Verify an OTP code and authenticate the user
+   */
+  async verifyOTP(email, otp) {
+    this.log("Verifying OTP for:", email);
+    const response = await this.request("/api/auth-dom/otp/verify", {
+      method: "POST",
+      body: JSON.stringify({
+        publicKey: this.config.publicKey,
+        email,
+        otp
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Invalid OTP" }));
+      throw new TiquoAuthError(error.error || "Invalid OTP", "OTP_VERIFY_FAILED", response.status);
+    }
+    const result = await response.json();
+    this.sessionToken = result.sessionToken;
+    this.saveSession();
+    await this.refreshSession();
+    this.broadcastTabSync("LOGIN");
+    return {
+      success: true,
+      sessionToken: result.sessionToken,
+      expiresAt: result.expiresAt,
+      isNewUser: result.isNewUser,
+      hasCustomer: result.hasCustomer
+    };
+  }
+  /**
+   * Get the current authenticated user and customer data
+   */
+  async getUser() {
+    if (!this.sessionToken) {
+      return null;
+    }
+    if (this.session && this.session.expiresAt > Date.now()) {
+      return this.session;
+    }
+    return this.refreshSession();
+  }
+  /**
+   * Check if user is currently authenticated
+   */
+  isAuthenticated() {
+    return !!this.sessionToken && (!this.session || this.session.expiresAt > Date.now());
+  }
+  /**
+   * Update the authenticated customer's profile
+   * Only allows updating the logged-in customer's own data
+   */
+  async updateProfile(updates) {
+    if (!this.sessionToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+    this.log("Updating customer profile:", updates);
+    const response = await this.request("/api/auth-dom/profile", {
+      method: "PATCH",
+      body: JSON.stringify({
+        publicKey: this.config.publicKey,
+        sessionToken: this.sessionToken,
+        updates
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to update profile" }));
+      throw new TiquoAuthError(error.error || "Failed to update profile", "PROFILE_UPDATE_FAILED", response.status);
+    }
+    const result = await response.json();
+    if (this.session && result.customer) {
+      this.session = {
+        ...this.session,
+        customer: {
+          id: result.customer.id,
+          firstName: result.customer.firstName,
+          lastName: result.customer.lastName,
+          displayName: result.customer.displayName,
+          customerNumber: result.customer.customerNumber,
+          email: result.customer.email,
+          phone: result.customer.phone
+        }
+      };
+      this.notifyListeners();
+      this.broadcastTabSync("SESSION_UPDATE");
+    }
+    return result;
+  }
+  /**
+   * Log out the current user
+   */
+  async logout() {
+    this.log("Logging out");
+    if (this.sessionToken) {
+      try {
+        await this.request("/api/auth-dom/logout", {
+          method: "POST",
+          body: JSON.stringify({
+            publicKey: this.config.publicKey,
+            sessionToken: this.sessionToken
+          })
+        });
+      } catch (error) {
+        this.log("Logout API error:", error);
+      }
+    }
+    this.broadcastTabSync("LOGOUT");
+    this.clearSession();
+  }
+  /**
+   * Subscribe to authentication state changes
+   */
+  onAuthStateChange(callback) {
+    this.listeners.add(callback);
+    callback(this.session);
+    return () => {
+      this.listeners.delete(callback);
+    };
+  }
+  /**
+   * Get the authenticated customer's order history
+   * Only returns orders for the logged-in customer
+   */
+  async getOrders(options) {
+    if (!this.sessionToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+    this.log("Fetching customer orders:", options);
+    const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/orders`);
+    url.searchParams.set("publicKey", this.config.publicKey);
+    if (options?.limit) {
+      url.searchParams.set("limit", options.limit.toString());
+    }
+    if (options?.cursor) {
+      url.searchParams.set("cursor", options.cursor);
+    }
+    if (options?.status) {
+      url.searchParams.set("status", options.status);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.sessionToken}`
+      },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to get orders" }));
+      throw new TiquoAuthError(error.error || "Failed to get orders", "GET_ORDERS_FAILED", response.status);
+    }
+    return response.json();
+  }
+  /**
+   * Get the authenticated customer's booking history
+   * Only returns bookings for the logged-in customer
+   */
+  async getBookings(options) {
+    if (!this.sessionToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+    this.log("Fetching customer bookings:", options);
+    const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/bookings`);
+    url.searchParams.set("publicKey", this.config.publicKey);
+    if (options?.limit) {
+      url.searchParams.set("limit", options.limit.toString());
+    }
+    if (options?.cursor) {
+      url.searchParams.set("cursor", options.cursor);
+    }
+    if (options?.status) {
+      url.searchParams.set("status", options.status);
+    }
+    if (options?.upcoming) {
+      url.searchParams.set("upcoming", "true");
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.sessionToken}`
+      },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to get bookings" }));
+      throw new TiquoAuthError(error.error || "Failed to get bookings", "GET_BOOKINGS_FAILED", response.status);
+    }
+    return response.json();
+  }
+  /**
+   * Get the authenticated customer's enquiry history
+   * Only returns enquiries for the logged-in customer
+   */
+  async getEnquiries(options) {
+    if (!this.sessionToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+    this.log("Fetching customer enquiries:", options);
+    const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/enquiries`);
+    url.searchParams.set("publicKey", this.config.publicKey);
+    if (options?.limit) {
+      url.searchParams.set("limit", options.limit.toString());
+    }
+    if (options?.cursor) {
+      url.searchParams.set("cursor", options.cursor);
+    }
+    if (options?.status) {
+      url.searchParams.set("status", options.status);
+    }
+    const response = await fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Authorization": `Bearer ${this.sessionToken}`
+      },
+      credentials: "include"
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to get enquiries" }));
+      throw new TiquoAuthError(error.error || "Failed to get enquiries", "GET_ENQUIRIES_FAILED", response.status);
+    }
+    return response.json();
+  }
+  /**
+   * Generate a short-lived token for customer flow iframe authentication
+   */
+  async getIframeToken(customerFlowId) {
+    if (!this.sessionToken) {
+      throw new TiquoAuthError("Not authenticated", "NOT_AUTHENTICATED");
+    }
+    this.log("Generating iframe token");
+    const response = await this.request("/api/auth-dom/iframe-token", {
+      method: "POST",
+      body: JSON.stringify({
+        publicKey: this.config.publicKey,
+        sessionToken: this.sessionToken,
+        customerFlowId
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Failed to generate token" }));
+      throw new TiquoAuthError(error.error || "Failed to generate token", "IFRAME_TOKEN_FAILED", response.status);
+    }
+    return response.json();
+  }
+  /**
+   * Embed a customer flow with automatic authentication
+   * 
+   * @param flowUrl - The URL of the customer flow (book.tiquo.app/...)
+   * @param container - Container element or selector
+   * @param options - Optional iframe configuration
+   */
+  async embedCustomerFlow(flowUrl, container, options) {
+    const containerEl = typeof container === "string" ? document.querySelector(container) : container;
+    if (!containerEl) {
+      throw new TiquoAuthError("Container element not found", "CONTAINER_NOT_FOUND");
+    }
+    let authToken;
+    if (this.sessionToken) {
+      try {
+        const { token } = await this.getIframeToken();
+        authToken = token;
+      } catch (error) {
+        this.log("Failed to get iframe token:", error);
+      }
+    }
+    const url = new URL(flowUrl);
+    if (authToken) {
+      url.searchParams.set("_auth_token", authToken);
+    }
+    const iframe = document.createElement("iframe");
+    iframe.src = url.toString();
+    iframe.style.width = options?.width || "100%";
+    iframe.style.height = options?.height || "600px";
+    iframe.style.border = "none";
+    iframe.setAttribute("allow", "payment");
+    iframe.setAttribute("loading", "lazy");
+    if (options?.onLoad) {
+      iframe.addEventListener("load", options.onLoad);
+    }
+    if (options?.onError) {
+      iframe.addEventListener("error", () => options.onError(new Error("Failed to load iframe")));
+    }
+    containerEl.innerHTML = "";
+    containerEl.appendChild(iframe);
+    return iframe;
+  }
+  /**
+   * Get the current session token (for advanced use cases)
+   */
+  getSessionToken() {
+    return this.sessionToken;
+  }
+  // ============================================
+  // PRIVATE METHODS
+  // ============================================
+  async request(path, options) {
+    const url = `${this.config.apiEndpoint}${path}`;
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    if (this.sessionToken && !(typeof options.body === "string" && options.body.includes("sessionToken"))) {
+      headers["Authorization"] = `Bearer ${this.sessionToken}`;
+    }
+    return fetch(url, {
+      ...options,
+      headers,
+      credentials: "include"
+    });
+  }
+  async refreshSession() {
+    if (!this.sessionToken) {
+      return null;
+    }
+    try {
+      const url = new URL(`${this.config.apiEndpoint}/api/auth-dom/session`);
+      url.searchParams.set("publicKey", this.config.publicKey);
+      const response = await fetch(url.toString(), {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${this.sessionToken}`
+        },
+        credentials: "include"
+      });
+      if (!response.ok) {
+        this.log("Session invalid, clearing");
+        this.clearSession();
+        return null;
+      }
+      const data = await response.json();
+      this.session = {
+        user: data.user,
+        customer: data.customer,
+        expiresAt: data.session.expiresAt
+      };
+      this.notifyListeners();
+      this.scheduleRefresh();
+      return this.session;
+    } catch (error) {
+      this.log("Session refresh error:", error);
+      return null;
+    }
+  }
+  saveSession() {
+    if (this.sessionToken) {
+      try {
+        localStorage.setItem(
+          `${this.config.storagePrefix}session`,
+          this.sessionToken
+        );
+      } catch (error) {
+        this.log("Failed to save session to storage:", error);
+      }
+    }
+  }
+  restoreSession() {
+    try {
+      const token = localStorage.getItem(`${this.config.storagePrefix}session`);
+      if (token) {
+        this.sessionToken = token;
+        this.refreshSession();
+      }
+    } catch (error) {
+      this.log("Failed to restore session from storage:", error);
+    }
+  }
+  clearSession() {
+    this.sessionToken = null;
+    this.session = null;
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    try {
+      localStorage.removeItem(`${this.config.storagePrefix}session`);
+    } catch (error) {
+      this.log("Failed to clear session from storage:", error);
+    }
+    this.notifyListeners();
+  }
+  notifyListeners() {
+    for (const listener of this.listeners) {
+      try {
+        listener(this.session);
+      } catch (error) {
+        this.log("Listener error:", error);
+      }
+    }
+  }
+  scheduleRefresh() {
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+    }
+    if (!this.session) return;
+    const refreshIn = this.session.expiresAt - Date.now() - 5 * 60 * 1e3;
+    if (refreshIn > 0) {
+      this.refreshTimer = setTimeout(() => {
+        this.refreshSession();
+      }, refreshIn);
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[TiquoAuth]", ...args);
+    }
+  }
+  // ============================================
+  // MULTI-TAB SYNC METHODS
+  // ============================================
+  generateTabId() {
+    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+  }
+  initTabSync() {
+    if (typeof BroadcastChannel === "undefined") {
+      this.log("BroadcastChannel not supported, tab sync disabled");
+      return;
+    }
+    try {
+      const channelName = `tiquo_auth_${this.config.publicKey}`;
+      this.broadcastChannel = new BroadcastChannel(channelName);
+      this.broadcastChannel.onmessage = (event) => {
+        this.handleTabSyncMessage(event.data);
+      };
+      this.log("Tab sync initialized, channel:", channelName);
+    } catch (error) {
+      this.log("Failed to initialize tab sync:", error);
+    }
+  }
+  broadcastTabSync(type) {
+    if (!this.broadcastChannel) return;
+    const message = {
+      type,
+      tabId: this.tabId,
+      timestamp: Date.now(),
+      sessionToken: type === "LOGOUT" ? null : this.sessionToken,
+      session: type === "LOGOUT" ? null : this.session
+    };
+    try {
+      this.broadcastChannel.postMessage(message);
+      this.log("Broadcasted tab sync message:", type);
+    } catch (error) {
+      this.log("Failed to broadcast tab sync:", error);
+    }
+  }
+  handleTabSyncMessage(message) {
+    if (message.tabId === this.tabId) return;
+    if (this.isProcessingTabSync) return;
+    this.isProcessingTabSync = true;
+    this.log("Received tab sync message:", message.type, "from tab:", message.tabId);
+    try {
+      switch (message.type) {
+        case "LOGIN":
+          if (message.sessionToken && message.session) {
+            this.sessionToken = message.sessionToken;
+            this.session = message.session;
+            this.saveSession();
+            this.scheduleRefresh();
+            this.notifyListeners();
+            this.log("Session synced from another tab (login)");
+          }
+          break;
+        case "LOGOUT":
+          this.sessionToken = null;
+          this.session = null;
+          if (this.refreshTimer) {
+            clearTimeout(this.refreshTimer);
+            this.refreshTimer = null;
+          }
+          try {
+            localStorage.removeItem(`${this.config.storagePrefix}session`);
+          } catch {
+          }
+          this.notifyListeners();
+          this.log("Session cleared from another tab (logout)");
+          break;
+        case "SESSION_UPDATE":
+          if (message.session) {
+            this.session = message.session;
+            this.notifyListeners();
+            this.log("Session synced from another tab (update)");
+          }
+          break;
+      }
+    } finally {
+      this.isProcessingTabSync = false;
+    }
+  }
+  /**
+   * Clean up resources (call when destroying the auth instance)
+   */
+  destroy() {
+    this.log("Destroying TiquoAuth instance");
+    if (this.refreshTimer) {
+      clearTimeout(this.refreshTimer);
+      this.refreshTimer = null;
+    }
+    if (this.broadcastChannel) {
+      this.broadcastChannel.close();
+      this.broadcastChannel = null;
+    }
+    this.listeners.clear();
+  }
+};
+function useTiquoAuth(auth) {
+  let session = null;
+  let isLoading = true;
+  auth.getUser().then((s) => {
+    session = s;
+    isLoading = false;
+  });
+  return {
+    get user() {
+      return session?.user || null;
+    },
+    get customer() {
+      return session?.customer || null;
+    },
+    get session() {
+      return session;
+    },
+    get isLoading() {
+      return isLoading;
+    },
+    get isAuthenticated() {
+      return auth.isAuthenticated();
+    },
+    sendOTP: (email) => auth.sendOTP(email),
+    verifyOTP: (email, otp) => auth.verifyOTP(email, otp),
+    logout: () => auth.logout(),
+    updateProfile: (updates) => auth.updateProfile(updates),
+    getOrders: (options) => auth.getOrders(options),
+    getBookings: (options) => auth.getBookings(options),
+    getEnquiries: (options) => auth.getEnquiries(options),
+    getIframeToken: (flowId) => auth.getIframeToken(flowId),
+    embedCustomerFlow: auth.embedCustomerFlow.bind(auth),
+    onAuthStateChange: (cb) => auth.onAuthStateChange(cb)
+  };
+}
+var index_default = TiquoAuth;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TiquoAuth,
+  TiquoAuthError,
+  useTiquoAuth
+});