fetchguard 1.0.0

package/dist/index.js

@@ -0,0 +1,706 @@
+// src/client.ts
+import { fromJSON, ok, err } from "ts-micro-result";
+
+// src/messages.ts
+var MSG = Object.freeze({
+  ...Object.fromEntries(
+    Object.keys({}).map((k) => [k, k])
+  ),
+  ...Object.fromEntries(
+    Object.keys({}).map((k) => [k, k])
+  )
+});
+
+// src/constants.ts
+var DEFAULT_REFRESH_EARLY_MS = 6e4;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_RETRY_COUNT = 3;
+var DEFAULT_RETRY_DELAY_MS = 1e3;
+
+// src/errors.ts
+import { defineError, defineErrorAdvanced } from "ts-micro-result";
+var GeneralErrors = {
+  Unexpected: defineError("UNEXPECTED", "Unexpected error", 500),
+  UnknownMessage: defineError("UNKNOWN_MESSAGE", "Unknown message type", 400),
+  ResultParse: defineError("RESULT_PARSE_ERROR", "Failed to parse result", 500)
+};
+var InitErrors = {
+  NotInitialized: defineError("INIT_ERROR", "Worker not initialized", 500),
+  ProviderInitFailed: defineError("PROVIDER_INIT_FAILED", "Failed to initialize provider", 500),
+  InitFailed: defineError("INIT_FAILED", "Initialization failed", 500)
+};
+var AuthErrors = {
+  TokenRefreshFailed: defineError("TOKEN_REFRESH_FAILED", "Token refresh failed", 401),
+  LoginFailed: defineError("LOGIN_FAILED", "Login failed", 401),
+  LogoutFailed: defineError("LOGOUT_FAILED", "Logout failed", 500),
+  NotAuthenticated: defineError("NOT_AUTHENTICATED", "User is not authenticated", 401)
+};
+var DomainErrors = {
+  NotAllowed: defineErrorAdvanced("DOMAIN_NOT_ALLOWED", "Domain not allowed: {url}", 403)
+};
+var NetworkErrors = {
+  NetworkError: defineError("NETWORK_ERROR", "Network error", 500),
+  HttpError: defineError("HTTP_ERROR", "HTTP error", 500),
+  FetchError: defineError("FETCH_ERROR", "Fetch error", 500)
+};
+var RequestErrors = {
+  Cancelled: defineError("REQUEST_CANCELLED", "Request was cancelled", 499),
+  Timeout: defineError("REQUEST_TIMEOUT", "Request timeout", 408)
+};
+
+// src/client.ts
+var FetchGuardClient = class {
+  worker;
+  messageId = 0;
+  pendingRequests = /* @__PURE__ */ new Map();
+  authListeners = /* @__PURE__ */ new Set();
+  requestQueue = [];
+  isProcessingQueue = false;
+  queueTimeout = 3e4;
+  // 30 seconds
+  setupResolve;
+  setupReject;
+  constructor(options) {
+    this.worker = new Worker(new URL("./worker.js", import.meta.url), {
+      type: "module"
+    });
+    this.worker.onmessage = this.handleWorkerMessage.bind(this);
+    this.worker.onerror = this.handleWorkerError.bind(this);
+    this.initializeWorker(options);
+  }
+  /**
+   * Initialize worker with config and provider
+   */
+  async initializeWorker(options) {
+    const config = {
+      allowedDomains: options.allowedDomains || [],
+      debug: options.debug || false,
+      refreshEarlyMs: options.refreshEarlyMs ?? DEFAULT_REFRESH_EARLY_MS,
+      defaultTimeoutMs: options.defaultTimeoutMs ?? DEFAULT_TIMEOUT_MS,
+      retryCount: options.retryCount ?? DEFAULT_RETRY_COUNT,
+      retryDelayMs: options.retryDelayMs ?? DEFAULT_RETRY_DELAY_MS
+    };
+    let providerConfig = null;
+    if (typeof options.provider === "string") {
+      providerConfig = options.provider;
+    } else if ("type" in options.provider && options.provider.type) {
+      providerConfig = options.provider;
+    } else {
+      throw new Error(
+        'Direct TokenProvider instance is not supported. Use ProviderPresetConfig instead:\n  { type: "cookie-auth", refreshUrl: "...", loginUrl: "...", logoutUrl: "..." }\nOr for custom providers, register in worker code and use string name.'
+      );
+    }
+    const message = {
+      id: this.generateMessageId(),
+      type: MSG.SETUP,
+      payload: {
+        config,
+        providerConfig
+      }
+    };
+    return new Promise((resolve, reject) => {
+      this.setupResolve = resolve;
+      this.setupReject = reject;
+      this.worker.postMessage(message);
+      setTimeout(() => {
+        if (this.setupReject) {
+          this.setupReject(new Error("Worker setup timeout"));
+          this.setupResolve = void 0;
+          this.setupReject = void 0;
+        }
+      }, 1e4);
+    });
+  }
+  /**
+   * Handle worker messages
+   */
+  handleWorkerMessage(event) {
+    const { id, type, payload } = event.data;
+    if (type === MSG.FETCH_RESULT || type === MSG.FETCH_ERROR) {
+      const request = this.pendingRequests.get(id);
+      if (!request) return;
+      this.pendingRequests.delete(id);
+      if (type === MSG.FETCH_RESULT) {
+        const status = payload?.status ?? 200;
+        const headers = payload?.headers ?? {};
+        const body = String(payload?.body ?? "");
+        let data;
+        try {
+          data = JSON.parse(body);
+        } catch {
+          data = body;
+        }
+        request.resolve(ok({ data, status, headers }));
+        return;
+      }
+      if (type === MSG.FETCH_ERROR) {
+        const status = typeof payload?.status === "number" ? payload.status : void 0;
+        if (typeof status === "number") {
+          request.resolve(err(NetworkErrors.HttpError({ message: String(payload?.error || "HTTP error") }), void 0, status));
+        } else {
+          request.resolve(err(NetworkErrors.NetworkError({ message: String(payload?.error || "Network error") })));
+        }
+        return;
+      }
+    }
+    if (type === MSG.RESULT) {
+      const request = this.pendingRequests.get(id);
+      if (!request) return;
+      this.pendingRequests.delete(id);
+      if (payload && payload.result) {
+        try {
+          const result = fromJSON(JSON.stringify(payload.result));
+          request.resolve(result);
+        } catch (e) {
+          request.resolve(err(GeneralErrors.ResultParse({ message: String(e) })));
+        }
+      }
+      return;
+    }
+    if (type === MSG.READY) {
+      if (this.setupResolve) {
+        this.setupResolve();
+        this.setupResolve = void 0;
+        this.setupReject = void 0;
+      }
+      return;
+    }
+    if (type === MSG.PONG) {
+      const request = this.pendingRequests.get(id);
+      if (request) {
+        this.pendingRequests.delete(id);
+        request.resolve(ok({ timestamp: payload?.timestamp }));
+      }
+      return;
+    }
+    if (type === MSG.AUTH_STATE_CHANGED) {
+      for (const cb of this.authListeners) cb(payload);
+      return;
+    }
+  }
+  /**
+   * Handle worker errors
+   */
+  handleWorkerError(error) {
+    console.error("Worker error:", error);
+    for (const [id, request] of this.pendingRequests) {
+      request.reject(new Error(`Worker error: ${error.message}`));
+    }
+    this.pendingRequests.clear();
+  }
+  /**
+   * Generate unique message ID
+   */
+  generateMessageId() {
+    return `msg_${++this.messageId}_${Date.now()}`;
+  }
+  /**
+   * Make API request
+   */
+  async fetch(url, options = {}) {
+    const { result } = this.fetchWithId(url, options);
+    return result;
+  }
+  /**
+   * Fetch with id for external cancellation
+   * Returns { id, result, cancel } 
+   * Now uses queue system for sequential processing
+   */
+  fetchWithId(url, options = {}) {
+    const id = this.generateMessageId();
+    const message = { id, type: MSG.FETCH, payload: { url, options } };
+    const result = new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, {
+        resolve: (response) => resolve(response),
+        reject: (error) => reject(error)
+      });
+    });
+    this.sendMessageQueued(message, 3e4).catch((error) => {
+      const request = this.pendingRequests.get(id);
+      if (request) {
+        this.pendingRequests.delete(id);
+        request.reject(error);
+      }
+    });
+    const cancel = () => this.cancel(id);
+    return { id, result, cancel };
+  }
+  /**
+   * Cancel a pending request by ID
+   */
+  cancel(id) {
+    const request = this.pendingRequests.get(id);
+    if (request) {
+      this.pendingRequests.delete(id);
+      this.worker.postMessage({ id, type: MSG.CANCEL });
+      request.reject(new Error("Request cancelled"));
+    }
+  }
+  /**
+   * Convenience methods
+   */
+  async get(url, options = {}) {
+    return this.fetch(url, { ...options, method: "GET" });
+  }
+  async post(url, body, options = {}) {
+    const headers = new Headers(options.headers);
+    if (body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    return this.fetch(url, {
+      ...options,
+      headers,
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(url, body, options = {}) {
+    const headers = new Headers(options.headers);
+    if (body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    return this.fetch(url, {
+      ...options,
+      headers,
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(url, options = {}) {
+    return this.fetch(url, { ...options, method: "DELETE" });
+  }
+  async patch(url, body, options = {}) {
+    const headers = new Headers(options.headers);
+    if (body && !headers.has("Content-Type")) {
+      headers.set("Content-Type", "application/json");
+    }
+    return this.fetch(url, {
+      ...options,
+      headers,
+      method: "PATCH",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  /**
+   * Generic method to call any auth method on provider
+   * @param method - Method name (login, logout, loginWithPhone, etc.)
+   * @param args - Arguments to pass to the method
+   * @returns Result with success (auth state changes emitted via AUTH_STATE_CHANGED event)
+   */
+  async call(method, ...args) {
+    const id = this.generateMessageId();
+    const message = { id, type: MSG.AUTH_CALL, payload: { method, args } };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, {
+        resolve: (r) => resolve(r),
+        reject: (e) => reject(e)
+      });
+      this.sendMessageQueued(message, 15e3).catch((error) => {
+        const request = this.pendingRequests.get(id);
+        if (request) {
+          this.pendingRequests.delete(id);
+          request.reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * Convenience wrapper for login
+   * Note: Auth state changes are emitted via onAuthStateChanged event
+   */
+  async login(payload) {
+    return this.call("login", payload);
+  }
+  /**
+   * Convenience wrapper for logout
+   * Note: Auth state changes are emitted via onAuthStateChanged event
+   */
+  async logout(payload) {
+    return this.call("logout", payload);
+  }
+  onAuthStateChanged(cb) {
+    this.authListeners.add(cb);
+    return () => this.authListeners.delete(cb);
+  }
+  /** Send PING and await PONG */
+  async ping() {
+    const id = this.generateMessageId();
+    const message = { id, type: MSG.PING, payload: { timestamp: Date.now() } };
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(id, {
+        resolve: (r) => resolve(r),
+        reject: (e) => reject(e)
+      });
+      this.sendMessageQueued(message, 5e3).catch((error) => {
+        const request = this.pendingRequests.get(id);
+        if (request) {
+          this.pendingRequests.delete(id);
+          request.reject(error);
+        }
+      });
+    });
+  }
+  /**
+   * Send message through queue system
+   * All messages go through queue for sequential processing
+   */
+  sendMessageQueued(message, timeoutMs = this.queueTimeout) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        const index = this.requestQueue.findIndex((item) => item.id === message.id);
+        if (index !== -1) {
+          this.requestQueue.splice(index, 1);
+        }
+        this.pendingRequests.delete(message.id);
+        reject(new Error("Request timeout"));
+      }, timeoutMs);
+      const queueItem = {
+        id: message.id,
+        message,
+        resolve,
+        reject,
+        timeout
+      };
+      this.requestQueue.push(queueItem);
+      this.processQueue();
+    });
+  }
+  /**
+   * Process message queue sequentially
+   * Benefits:
+   * - Sequential processing prevents worker overload
+   * - Better error isolation (one failure doesn't affect others)
+   * - 50ms delay between requests for backpressure
+   */
+  async processQueue() {
+    if (this.isProcessingQueue || this.requestQueue.length === 0) {
+      return;
+    }
+    this.isProcessingQueue = true;
+    while (this.requestQueue.length > 0) {
+      const item = this.requestQueue.shift();
+      if (!item) continue;
+      try {
+        this.worker.postMessage(item.message);
+        await new Promise((resolve) => setTimeout(resolve, 50));
+      } catch (error) {
+        clearTimeout(item.timeout);
+        item.reject(error instanceof Error ? error : new Error(String(error)));
+      }
+    }
+    this.isProcessingQueue = false;
+  }
+  /**
+   * Cleanup - terminate worker
+   */
+  destroy() {
+    this.worker.terminate();
+    this.pendingRequests.clear();
+    for (const item of this.requestQueue) {
+      clearTimeout(item.timeout);
+      item.reject(new Error("Client destroyed"));
+    }
+    this.requestQueue = [];
+  }
+};
+function createClient(options) {
+  return new FetchGuardClient(options);
+}
+
+// src/utils/registry.ts
+var registry = /* @__PURE__ */ new Map();
+function registerProvider(name, provider) {
+  if (typeof name !== "string" || !name.trim()) {
+    throw new Error("Provider name must be a non-empty string");
+  }
+  if (!provider || typeof provider.refreshToken !== "function") {
+    throw new Error("Provider must implement TokenProvider interface");
+  }
+  registry.set(name, provider);
+}
+function getProvider(name) {
+  const provider = registry.get(name);
+  if (!provider) {
+    throw new Error(`Provider '${name}' not found. Available providers: ${Array.from(registry.keys()).join(", ")}`);
+  }
+  return provider;
+}
+function hasProvider(name) {
+  return registry.has(name);
+}
+function listProviders() {
+  return Array.from(registry.keys());
+}
+function unregisterProvider(name) {
+  return registry.delete(name);
+}
+function clearProviders() {
+  registry.clear();
+}
+
+// src/provider/create-provider.ts
+import { ok as ok2, err as err2 } from "ts-micro-result";
+function createProvider(config) {
+  const baseProvider = {
+    async refreshToken(refreshToken) {
+      let currentRefreshToken = refreshToken;
+      if (currentRefreshToken === null && config.refreshStorage) {
+        currentRefreshToken = await config.refreshStorage.get();
+      }
+      try {
+        const response = await config.strategy.refresh(currentRefreshToken);
+        if (!response.ok) {
+          return err2(AuthErrors.TokenRefreshFailed({ message: `HTTP ${response.status}` }));
+        }
+        const tokenInfo = await config.parser.parse(response);
+        if (!tokenInfo.token) {
+          return err2(AuthErrors.TokenRefreshFailed({ message: "No access token in response" }));
+        }
+        if (config.refreshStorage && tokenInfo.refreshToken) {
+          await config.refreshStorage.set(tokenInfo.refreshToken);
+        }
+        return ok2(tokenInfo);
+      } catch (error) {
+        return err2(NetworkErrors.NetworkError({ message: String(error) }));
+      }
+    },
+    async login(payload) {
+      try {
+        const response = await config.strategy.login(payload);
+        if (!response.ok) {
+          return err2(AuthErrors.LoginFailed({ message: `HTTP ${response.status}` }));
+        }
+        const tokenInfo = await config.parser.parse(response);
+        if (!tokenInfo.token) {
+          return err2(AuthErrors.LoginFailed({ message: "No access token in response" }));
+        }
+        if (config.refreshStorage && tokenInfo.refreshToken) {
+          await config.refreshStorage.set(tokenInfo.refreshToken);
+        }
+        return ok2(tokenInfo);
+      } catch (error) {
+        return err2(NetworkErrors.NetworkError({ message: String(error) }));
+      }
+    },
+    async logout(payload) {
+      try {
+        const response = await config.strategy.logout(payload);
+        if (!response.ok) {
+          return err2(AuthErrors.LogoutFailed({ message: `HTTP ${response.status}` }));
+        }
+        if (config.refreshStorage) {
+          await config.refreshStorage.set(null);
+        }
+        return ok2({
+          token: "",
+          refreshToken: void 0,
+          expiresAt: void 0,
+          user: void 0
+        });
+      } catch (error) {
+        return err2(NetworkErrors.NetworkError({ message: String(error) }));
+      }
+    }
+  };
+  if (config.customMethods) {
+    return {
+      ...baseProvider,
+      ...config.customMethods
+    };
+  }
+  return baseProvider;
+}
+
+// src/provider/storage/indexeddb.ts
+function createIndexedDBStorage(dbName = "FetchGuardDB", refreshTokenKey = "refreshToken") {
+  const storeName = "tokens";
+  const openDB = () => {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(dbName, 1);
+      request.onerror = () => reject(request.error);
+      request.onsuccess = () => resolve(request.result);
+      request.onupgradeneeded = (event) => {
+        const db = event.target.result;
+        if (!db.objectStoreNames.contains(storeName)) {
+          const store = db.createObjectStore(storeName, { keyPath: "key" });
+          store.createIndex("timestamp", "timestamp", { unique: false });
+        }
+      };
+    });
+  };
+  const promisifyRequest = (request) => {
+    return new Promise((resolve, reject) => {
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  };
+  return {
+    async get() {
+      try {
+        const db = await openDB();
+        const transaction = db.transaction([storeName], "readonly");
+        const store = transaction.objectStore(storeName);
+        const result = await promisifyRequest(store.get(refreshTokenKey));
+        return result?.value || null;
+      } catch (error) {
+        console.warn("Failed to get refresh token from IndexedDB:", error);
+        return null;
+      }
+    },
+    async set(token) {
+      try {
+        const db = await openDB();
+        const transaction = db.transaction([storeName], "readwrite");
+        const store = transaction.objectStore(storeName);
+        if (token) {
+          await promisifyRequest(store.put({ key: refreshTokenKey, value: token, timestamp: Date.now() }));
+        } else {
+          await promisifyRequest(store.delete(refreshTokenKey));
+        }
+      } catch (error) {
+        console.warn("Failed to save refresh token to IndexedDB:", error);
+      }
+    }
+  };
+}
+
+// src/provider/parser/body.ts
+var bodyParser = {
+  async parse(response) {
+    const json = await response.clone().json();
+    return {
+      token: json.data.accessToken,
+      refreshToken: json.data.refreshToken,
+      expiresAt: json.data.expiresAt,
+      user: json.data.user
+    };
+  }
+};
+
+// src/provider/parser/cookie.ts
+var cookieParser = {
+  async parse(response) {
+    const json = await response.clone().json();
+    return {
+      token: json.data.accessToken,
+      expiresAt: json.data.expiresAt,
+      user: json.data.user
+    };
+  }
+};
+
+// src/provider/strategy/cookie.ts
+function createCookieStrategy(config) {
+  return {
+    async refresh() {
+      return fetch(config.refreshUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "include"
+      });
+    },
+    async login(payload) {
+      return fetch(config.loginUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        credentials: "include"
+      });
+    },
+    async logout(payload) {
+      return fetch(config.logoutUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: payload ? JSON.stringify(payload) : void 0,
+        credentials: "include"
+      });
+    }
+  };
+}
+var cookieStrategy = createCookieStrategy({
+  refreshUrl: "/auth/refresh",
+  loginUrl: "/auth/login",
+  logoutUrl: "/auth/logout"
+});
+
+// src/provider/strategy/body.ts
+function createBodyStrategy(config) {
+  return {
+    async refresh(refreshToken) {
+      if (!refreshToken) {
+        throw new Error("No refresh token available");
+      }
+      return fetch(config.refreshUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ refreshToken }),
+        credentials: "include"
+      });
+    },
+    async login(payload) {
+      return fetch(config.loginUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+        credentials: "include"
+      });
+    },
+    async logout(payload) {
+      return fetch(config.logoutUrl, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: payload ? JSON.stringify(payload) : void 0,
+        credentials: "include"
+      });
+    }
+  };
+}
+var bodyStrategy = createBodyStrategy({
+  refreshUrl: "/auth/refresh",
+  loginUrl: "/auth/login",
+  logoutUrl: "/auth/logout"
+});
+
+// src/provider/presets.ts
+function createCookieProvider(config) {
+  return createProvider({
+    refreshStorage: void 0,
+    parser: cookieParser,
+    strategy: createCookieStrategy(config)
+  });
+}
+function createBodyProvider(config) {
+  return createProvider({
+    refreshStorage: createIndexedDBStorage("FetchGuardDB", config.refreshTokenKey || "refreshToken"),
+    parser: bodyParser,
+    strategy: createBodyStrategy(config)
+  });
+}
+export {
+  AuthErrors,
+  DomainErrors,
+  FetchGuardClient,
+  GeneralErrors,
+  InitErrors,
+  MSG,
+  NetworkErrors,
+  RequestErrors,
+  bodyParser,
+  bodyStrategy,
+  clearProviders,
+  cookieParser,
+  cookieStrategy,
+  createBodyProvider,
+  createBodyStrategy,
+  createClient,
+  createCookieProvider,
+  createCookieStrategy,
+  createIndexedDBStorage,
+  createProvider,
+  getProvider,
+  hasProvider,
+  listProviders,
+  registerProvider,
+  unregisterProvider
+};
+//# sourceMappingURL=index.js.map