@buenojs/bueno 0.8.4 → 0.8.6

package/dist/rpc/index.js

@@ -0,0 +1,691 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __legacyDecorateClassTS = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1;i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __legacyMetadataTS = (k, v) => {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/rpc/index.ts
+class DeduplicationStore {
+  defaultTTL;
+  pending = new Map;
+  cache = new Map;
+  cleanupInterval;
+  constructor(defaultTTL = 5000) {
+    this.defaultTTL = defaultTTL;
+    this.cleanupInterval = setInterval(() => this.cleanup(), 1e4);
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.cache.entries()) {
+      if (now - entry.timestamp > entry.ttl) {
+        this.cache.delete(key);
+      }
+    }
+    for (const [key, entry] of this.pending.entries()) {
+      if (now - entry.timestamp > 60000) {
+        this.pending.delete(key);
+      }
+    }
+  }
+  getPending(key, body) {
+    const pending = this.pending.get(key);
+    if (pending && (body === undefined || pending.body === body)) {
+      return pending;
+    }
+    return;
+  }
+  setPending(key, promise, body) {
+    this.pending.set(key, { promise, timestamp: Date.now(), body });
+  }
+  removePending(key) {
+    this.pending.delete(key);
+  }
+  getCached(key, ttl) {
+    const cached = this.cache.get(key);
+    if (cached && Date.now() - cached.timestamp < ttl) {
+      return cached.response.clone();
+    }
+    return;
+  }
+  setCached(key, response, ttl) {
+    this.cache.set(key, {
+      response: response.clone(),
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+  getCachedData(key) {
+    return this.cache.get(key)?.data;
+  }
+  setCachedData(key, data, ttl) {
+    this.cache.set(key, {
+      response: new Response(JSON.stringify(data)),
+      timestamp: Date.now(),
+      ttl
+    });
+  }
+  invalidate(key) {
+    this.cache.delete(key);
+  }
+  clear() {
+    this.pending.clear();
+    this.cache.clear();
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+    }
+    this.clear();
+  }
+  getStats() {
+    return {
+      pending: this.pending.size,
+      cached: this.cache.size
+    };
+  }
+}
+
+class OptimisticStore {
+  pending = new Map;
+  idCounter = 0;
+  create(cacheKey, optimisticData, previousData, callbacks) {
+    const id = `optimistic-${++this.idCounter}`;
+    this.pending.set(id, {
+      id,
+      cacheKey,
+      optimisticData,
+      previousData,
+      timestamp: Date.now(),
+      status: "pending",
+      onRollback: callbacks?.onRollback,
+      onConfirm: callbacks?.onConfirm
+    });
+    return id;
+  }
+  confirm(id, serverData) {
+    const update = this.pending.get(id);
+    if (update) {
+      update.status = "confirmed";
+      if (update.onConfirm && serverData !== undefined) {
+        update.onConfirm(serverData);
+      }
+      this.pending.delete(id);
+    }
+  }
+  rollback(id) {
+    const update = this.pending.get(id);
+    if (update) {
+      update.status = "rolled_back";
+      const previousData = update.previousData;
+      if (update.onRollback) {
+        update.onRollback(previousData);
+      }
+      this.pending.delete(id);
+      return previousData;
+    }
+    return;
+  }
+  get(id) {
+    return this.pending.get(id);
+  }
+  getByCacheKey(cacheKey) {
+    for (const update of this.pending.values()) {
+      if (update.cacheKey === cacheKey) {
+        return update;
+      }
+    }
+    return;
+  }
+  hasPending(cacheKey) {
+    for (const update of this.pending.values()) {
+      if (update.cacheKey === cacheKey && update.status === "pending") {
+        return true;
+      }
+    }
+    return false;
+  }
+  getOptimisticData(cacheKey) {
+    const update = this.getByCacheKey(cacheKey);
+    if (update && update.status === "pending") {
+      return update.optimisticData;
+    }
+    return;
+  }
+  clear() {
+    this.pending.clear();
+  }
+  getStats() {
+    return { pending: this.pending.size };
+  }
+}
+function defaultKeyGenerator(method, url, body) {
+  const bodyHash = body ? JSON.stringify(body) : "";
+  return `${method}:${url}:${bodyHash}`;
+}
+var DEFAULT_RETRYABLE_STATUS_CODES = [408, 429, 500, 502, 503, 504];
+var DEFAULT_RETRYABLE_ERRORS = [
+  "ECONNRESET",
+  "ETIMEDOUT",
+  "ENOTFOUND",
+  "EAI_AGAIN"
+];
+function defaultShouldRetry(response, error, attempt, config) {
+  const maxAttempts = config?.maxAttempts ?? 3;
+  const retryableStatusCodes = config?.retryableStatusCodes ?? DEFAULT_RETRYABLE_STATUS_CODES;
+  const retryableErrors = config?.retryableErrors ?? DEFAULT_RETRYABLE_ERRORS;
+  if (attempt >= maxAttempts) {
+    return false;
+  }
+  if (error) {
+    if (retryableErrors.length > 0) {
+      return retryableErrors.some((code) => error.message.includes(code) || error.name === code);
+    }
+    return DEFAULT_RETRYABLE_ERRORS.some((code) => error.message.includes(code) || error.name === code);
+  }
+  if (response) {
+    if (retryableStatusCodes.length > 0) {
+      return retryableStatusCodes.includes(response.status);
+    }
+    return DEFAULT_RETRYABLE_STATUS_CODES.includes(response.status);
+  }
+  return false;
+}
+function calculateDelay(attempt, config) {
+  const delay = config.initialDelay * config.backoffMultiplier ** (attempt - 1);
+  return Math.min(delay, config.maxDelay);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+class RPCClient {
+  baseUrl;
+  defaultHeaders;
+  defaultTimeout;
+  requestInterceptors = [];
+  responseInterceptors = [];
+  errorInterceptors = [];
+  deduplicationConfig;
+  optimisticConfig;
+  retryConfig;
+  deduplicationStore;
+  optimisticStore;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/$/, "");
+    this.defaultHeaders = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    this.defaultTimeout = options.timeout ?? 30000;
+    if (options.interceptors?.request) {
+      this.requestInterceptors = Array.isArray(options.interceptors.request) ? options.interceptors.request : [options.interceptors.request];
+    }
+    if (options.interceptors?.response) {
+      this.responseInterceptors = Array.isArray(options.interceptors.response) ? options.interceptors.response : [options.interceptors.response];
+    }
+    if (options.interceptors?.error) {
+      this.errorInterceptors = Array.isArray(options.interceptors.error) ? options.interceptors.error : [options.interceptors.error];
+    }
+    this.deduplicationConfig = {
+      enabled: options.deduplication?.enabled ?? true,
+      ttl: options.deduplication?.ttl ?? 5000,
+      keyGenerator: options.deduplication?.keyGenerator ?? defaultKeyGenerator
+    };
+    this.optimisticConfig = {
+      enabled: options.optimisticUpdates?.enabled ?? true,
+      autoRollback: options.optimisticUpdates?.autoRollback ?? true,
+      onConflict: options.optimisticUpdates?.onConflict ?? "rollback"
+    };
+    this.retryConfig = {
+      enabled: options.retry?.enabled ?? true,
+      maxAttempts: options.retry?.maxAttempts ?? 3,
+      initialDelay: options.retry?.initialDelay ?? 1000,
+      maxDelay: options.retry?.maxDelay ?? 30000,
+      backoffMultiplier: options.retry?.backoffMultiplier ?? 2,
+      retryableStatusCodes: options.retry?.retryableStatusCodes ?? [
+        ...DEFAULT_RETRYABLE_STATUS_CODES
+      ],
+      retryableErrors: options.retry?.retryableErrors ?? [
+        ...DEFAULT_RETRYABLE_ERRORS
+      ],
+      onRetry: options.retry?.onRetry ?? (() => {}),
+      shouldRetry: options.retry?.shouldRetry ?? ((response, error, attempt) => defaultShouldRetry(response, error, attempt, undefined))
+    };
+    this.deduplicationStore = new DeduplicationStore(this.deduplicationConfig.ttl);
+    this.optimisticStore = new OptimisticStore;
+  }
+  async get(path, options) {
+    return this.request("GET", path, undefined, options);
+  }
+  async post(path, body, options) {
+    return this.request("POST", path, body, options);
+  }
+  async put(path, body, options) {
+    return this.request("PUT", path, body, options);
+  }
+  async patch(path, body, options) {
+    return this.request("PATCH", path, body, options);
+  }
+  async delete(path, options) {
+    return this.request("DELETE", path, undefined, options);
+  }
+  async head(path, options) {
+    return this.request("HEAD", path, undefined, options);
+  }
+  async options(path, options) {
+    return this.request("OPTIONS", path, undefined, options);
+  }
+  async request(method, path, body, options) {
+    let url = `${this.baseUrl}${path.startsWith("/") ? path : `/${path}`}`;
+    if (options?.query) {
+      const searchParams = new URLSearchParams(options.query);
+      url += `?${searchParams.toString()}`;
+    }
+    const skipDeduplication = options?.skipDeduplication || options?.retry?.skipRetry;
+    if (this.deduplicationConfig.enabled && method === "GET" && !skipDeduplication) {
+      const cacheKey = this.deduplicationConfig.keyGenerator(method, url);
+      const cached = this.deduplicationStore.getCached(cacheKey, this.deduplicationConfig.ttl);
+      if (cached) {
+        return cached;
+      }
+    }
+    if (this.deduplicationConfig.enabled && !skipDeduplication) {
+      const bodyStr = body ? JSON.stringify(body) : undefined;
+      const dedupeKey = this.deduplicationConfig.keyGenerator(method, url, body);
+      const pending = this.deduplicationStore.getPending(dedupeKey, bodyStr);
+      if (pending) {
+        return pending.promise;
+      }
+      const requestPromise = this.executeWithRetry(method, url, body, options, dedupeKey);
+      this.deduplicationStore.setPending(dedupeKey, requestPromise, bodyStr);
+      try {
+        const response = await requestPromise;
+        return response;
+      } finally {
+        this.deduplicationStore.removePending(dedupeKey);
+      }
+    }
+    return this.executeWithRetry(method, url, body, options);
+  }
+  async executeWithRetry(method, url, body, options, cacheKey) {
+    const retryOptions = options?.retry;
+    const retryEnabled = retryOptions?.enabled ?? this.retryConfig.enabled;
+    const skipRetry = retryOptions?.skipRetry ?? false;
+    if (!retryEnabled || skipRetry) {
+      return this.executeRequest(method, url, body, options, cacheKey);
+    }
+    const maxAttempts = retryOptions?.maxAttempts ?? this.retryConfig.maxAttempts;
+    const initialDelay = retryOptions?.initialDelay ?? this.retryConfig.initialDelay;
+    const state = {
+      attempt: 0,
+      lastError: null,
+      totalDelay: 0
+    };
+    while (state.attempt < maxAttempts) {
+      state.attempt++;
+      try {
+        const response = await this.executeRequest(method, url, body, options, cacheKey);
+        if (response.ok || !this.shouldRetryResponse(response, null, state.attempt, maxAttempts)) {
+          return response;
+        }
+        if (state.attempt < maxAttempts) {
+          const delay = calculateDelay(state.attempt, {
+            ...this.retryConfig,
+            initialDelay,
+            maxAttempts
+          });
+          this.retryConfig.onRetry(state.attempt, null, delay);
+          await sleep(delay);
+          state.totalDelay += delay;
+        } else {
+          return response;
+        }
+      } catch (error) {
+        state.lastError = error instanceof Error ? error : new Error(String(error));
+        if (state.attempt < maxAttempts && this.shouldRetryError(state.lastError, state.attempt, maxAttempts)) {
+          const delay = calculateDelay(state.attempt, {
+            ...this.retryConfig,
+            initialDelay,
+            maxAttempts
+          });
+          this.retryConfig.onRetry(state.attempt, state.lastError, delay);
+          await sleep(delay);
+          state.totalDelay += delay;
+        } else {
+          throw state.lastError;
+        }
+      }
+    }
+    throw state.lastError || new Error("Max retry attempts exceeded");
+  }
+  shouldRetryResponse(response, error, attempt, maxAttempts) {
+    if (attempt >= maxAttempts) {
+      return false;
+    }
+    return this.retryConfig.shouldRetry(response, error, attempt);
+  }
+  shouldRetryError(error, attempt, maxAttempts) {
+    if (attempt >= maxAttempts) {
+      return false;
+    }
+    return this.retryConfig.shouldRetry(null, error, attempt);
+  }
+  async executeRequest(method, url, body, options, cacheKey) {
+    let config = {
+      method,
+      headers: {
+        ...this.defaultHeaders,
+        ...options?.headers
+      }
+    };
+    if (body && !["GET", "HEAD", "OPTIONS"].includes(method)) {
+      config.body = JSON.stringify(body);
+    }
+    const context = { url, method, requestInit: config };
+    for (const interceptor of this.requestInterceptors) {
+      const interceptorContext = {
+        ...config,
+        url,
+        method
+      };
+      const result = await interceptor(interceptorContext);
+      config = result;
+      context.requestInit = config;
+    }
+    const controller = new AbortController;
+    const timeout = options?.timeout ?? this.defaultTimeout;
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    config.signal = controller.signal;
+    try {
+      let response = await fetch(url, config);
+      if (cacheKey && method === "GET" && response.ok) {
+        this.deduplicationStore.setCached(cacheKey, response, this.deduplicationConfig.ttl);
+      }
+      for (const interceptor of this.responseInterceptors) {
+        response = await interceptor(response, context);
+      }
+      return response;
+    } catch (error) {
+      const processedError = error instanceof Error ? error : new Error(String(error));
+      for (const interceptor of this.errorInterceptors) {
+        const result = await interceptor(processedError, context);
+        if (result instanceof Response) {
+          return result;
+        }
+      }
+      if (processedError.name === "AbortError") {
+        throw new Error(`Request timeout after ${timeout}ms`);
+      }
+      throw processedError;
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  async optimistic(method, path, options) {
+    if (!this.optimisticConfig.enabled) {
+      const response = await this.request(method, path, options?.body, options);
+      return { response };
+    }
+    const cacheKey = options?.cacheKey ?? path;
+    const previousData = this.deduplicationStore.getCachedData(cacheKey);
+    const optimisticData = options?.optimisticData;
+    let rollbackId;
+    if (optimisticData !== undefined) {
+      rollbackId = this.optimisticStore.create(cacheKey, optimisticData, previousData, { onRollback: options?.onRollback, onConfirm: options?.onConfirm });
+      this.deduplicationStore.setCachedData(cacheKey, optimisticData, this.deduplicationConfig.ttl);
+    }
+    try {
+      const response = await this.request(method, path, options?.body, {
+        query: options?.query,
+        headers: options?.headers,
+        skipDeduplication: true
+      });
+      if (response.ok) {
+        if (rollbackId) {
+          const responseData = await response.clone().json().catch(() => {
+            return;
+          });
+          this.optimisticStore.confirm(rollbackId, responseData);
+        }
+        return { response, rollbackId };
+      }
+      if (rollbackId && this.optimisticConfig.autoRollback) {
+        this.rollback(rollbackId);
+      }
+      return { response, rollbackId };
+    } catch (error) {
+      if (rollbackId && this.optimisticConfig.autoRollback) {
+        this.rollback(rollbackId);
+      }
+      throw error;
+    }
+  }
+  async optimisticPost(path, body, options) {
+    return this.optimistic("POST", path, { body, ...options });
+  }
+  async optimisticPut(path, body, options) {
+    return this.optimistic("PUT", path, { body, ...options });
+  }
+  async optimisticPatch(path, body, options) {
+    return this.optimistic("PATCH", path, { body, ...options });
+  }
+  async optimisticDelete(path, options) {
+    return this.optimistic("DELETE", path, options);
+  }
+  rollback(rollbackId) {
+    const previousData = this.optimisticStore.rollback(rollbackId);
+    if (previousData !== undefined) {
+      const update = this.optimisticStore.get(rollbackId);
+      if (update) {
+        this.deduplicationStore.setCachedData(update.cacheKey, previousData, this.deduplicationConfig.ttl);
+      }
+    }
+    return previousData;
+  }
+  confirm(rollbackId, serverData) {
+    this.optimisticStore.confirm(rollbackId, serverData);
+  }
+  hasPendingOptimisticUpdate(cacheKey) {
+    return this.optimisticStore.hasPending(cacheKey);
+  }
+  getOptimisticData(cacheKey) {
+    return this.optimisticStore.getOptimisticData(cacheKey);
+  }
+  getPendingOptimisticCount() {
+    return this.optimisticStore.getStats().pending;
+  }
+  clearOptimisticUpdates() {
+    this.optimisticStore.clear();
+  }
+  async withRetry(method, path, body, retryOptions) {
+    return this.request(method, path, body, { retry: retryOptions });
+  }
+  isRetryEnabled() {
+    return this.retryConfig.enabled;
+  }
+  getMaxRetryAttempts() {
+    return this.retryConfig.maxAttempts;
+  }
+  getRetryConfig() {
+    return { ...this.retryConfig };
+  }
+  addRequestInterceptor(interceptor) {
+    this.requestInterceptors.push(interceptor);
+  }
+  addResponseInterceptor(interceptor) {
+    this.responseInterceptors.push(interceptor);
+  }
+  addErrorInterceptor(interceptor) {
+    this.errorInterceptors.push(interceptor);
+  }
+  removeRequestInterceptor(interceptor) {
+    const index = this.requestInterceptors.indexOf(interceptor);
+    if (index > -1) {
+      this.requestInterceptors.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  removeResponseInterceptor(interceptor) {
+    const index = this.responseInterceptors.indexOf(interceptor);
+    if (index > -1) {
+      this.responseInterceptors.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  removeErrorInterceptor(interceptor) {
+    const index = this.errorInterceptors.indexOf(interceptor);
+    if (index > -1) {
+      this.errorInterceptors.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+  clearInterceptors() {
+    this.requestInterceptors = [];
+    this.responseInterceptors = [];
+    this.errorInterceptors = [];
+  }
+  getInterceptorStats() {
+    return {
+      request: this.requestInterceptors.length,
+      response: this.responseInterceptors.length,
+      error: this.errorInterceptors.length
+    };
+  }
+  withInterceptors(interceptors) {
+    return new RPCClient({
+      baseUrl: this.baseUrl,
+      headers: this.defaultHeaders,
+      timeout: this.defaultTimeout,
+      deduplication: this.deduplicationConfig,
+      optimisticUpdates: this.optimisticConfig,
+      retry: this.retryConfig,
+      interceptors
+    });
+  }
+  withBaseUrl(baseUrl) {
+    const interceptors = {};
+    if (this.requestInterceptors.length > 0)
+      interceptors.request = this.requestInterceptors;
+    if (this.responseInterceptors.length > 0)
+      interceptors.response = this.responseInterceptors;
+    if (this.errorInterceptors.length > 0)
+      interceptors.error = this.errorInterceptors;
+    return new RPCClient({
+      baseUrl,
+      headers: this.defaultHeaders,
+      timeout: this.defaultTimeout,
+      deduplication: this.deduplicationConfig,
+      optimisticUpdates: this.optimisticConfig,
+      retry: this.retryConfig,
+      interceptors
+    });
+  }
+  withHeaders(headers) {
+    const interceptors = {};
+    if (this.requestInterceptors.length > 0)
+      interceptors.request = this.requestInterceptors;
+    if (this.responseInterceptors.length > 0)
+      interceptors.response = this.responseInterceptors;
+    if (this.errorInterceptors.length > 0)
+      interceptors.error = this.errorInterceptors;
+    return new RPCClient({
+      baseUrl: this.baseUrl,
+      headers: { ...this.defaultHeaders, ...headers },
+      timeout: this.defaultTimeout,
+      deduplication: this.deduplicationConfig,
+      optimisticUpdates: this.optimisticConfig,
+      retry: this.retryConfig,
+      interceptors
+    });
+  }
+  clearCache() {
+    this.deduplicationStore.clear();
+  }
+  clearAllCaches() {
+    this.deduplicationStore.clear();
+    this.optimisticStore.clear();
+  }
+  invalidateCache(cacheKey) {
+    this.deduplicationStore.invalidate(cacheKey);
+  }
+  getDeduplicationStats() {
+    return this.deduplicationStore.getStats();
+  }
+  isDeduplicationEnabled() {
+    return this.deduplicationConfig.enabled;
+  }
+  getDeduplicationTTL() {
+    return this.deduplicationConfig.ttl;
+  }
+  isOptimisticUpdatesEnabled() {
+    return this.optimisticConfig.enabled;
+  }
+}
+function createRPClient(options) {
+  return new RPCClient(options);
+}
+function bc(options) {
+  return createRPClient(options);
+}
+function extractRouteTypes(router) {
+  const routes = router.getRoutes();
+  return routes.map((r) => ({
+    method: r.method,
+    path: r.pattern
+  }));
+}
+async function parseJSON(response) {
+  return response.json();
+}
+async function parseText(response) {
+  return response.text();
+}
+function isOK(response) {
+  return response.ok;
+}
+function isStatus(response, status) {
+  return response.status === status;
+}
+async function throwIfNotOK(response) {
+  if (!response.ok) {
+    const error = await response.text();
+    throw new Error(`HTTP ${response.status}: ${error}`);
+  }
+  return response;
+}
+export {
+  throwIfNotOK,
+  parseText,
+  parseJSON,
+  isStatus,
+  isOK,
+  extractRouteTypes,
+  createRPClient,
+  bc,
+  RPCClient
+};