@inneropen/marvin-sdk 2.0.0-next.18 → 2.0.0-next.2

package/dist/chunk-WJC4X7TB.js

@@ -1,738 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
-};
-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/core/errors/MarvinError.ts
-var MarvinError, MarvinApiError, MarvinAuthError, MarvinConfigError, MarvinValidationError, MarvinNotFoundError, MarvinNetworkError, MarvinServerError;
-var init_MarvinError = __esm({
-  "src/core/errors/MarvinError.ts"() {
-    "use strict";
-    MarvinError = class _MarvinError extends Error {
-      constructor(message, code, statusCode) {
-        super(message);
-        this.code = code;
-        this.statusCode = statusCode;
-        this.name = "MarvinError";
-        Object.setPrototypeOf(this, _MarvinError.prototype);
-      }
-      code;
-      statusCode;
-    };
-    MarvinApiError = class _MarvinApiError extends MarvinError {
-      constructor(message, statusCode, endpoint, responseBody) {
-        super(message, "API_ERROR", statusCode);
-        this.statusCode = statusCode;
-        this.endpoint = endpoint;
-        this.responseBody = responseBody;
-        this.name = "MarvinApiError";
-        Object.setPrototypeOf(this, _MarvinApiError.prototype);
-      }
-      statusCode;
-      endpoint;
-      responseBody;
-      static fromResponse(status, statusText, endpoint, body) {
-        const message = `Marvin API error: ${status} ${statusText} at ${endpoint}${body ? `
-${body}` : ""}`;
-        return new _MarvinApiError(message, status, endpoint, body);
-      }
-    };
-    MarvinAuthError = class _MarvinAuthError extends MarvinError {
-      constructor(message, statusCode) {
-        super(message, "AUTH_ERROR", statusCode);
-        this.name = "MarvinAuthError";
-        Object.setPrototypeOf(this, _MarvinAuthError.prototype);
-      }
-    };
-    MarvinConfigError = class _MarvinConfigError extends MarvinError {
-      constructor(message) {
-        super(message, "CONFIG_ERROR");
-        this.name = "MarvinConfigError";
-        Object.setPrototypeOf(this, _MarvinConfigError.prototype);
-      }
-    };
-    MarvinValidationError = class _MarvinValidationError extends MarvinError {
-      constructor(message, field) {
-        super(message, "VALIDATION_ERROR");
-        this.field = field;
-        this.name = "MarvinValidationError";
-        Object.setPrototypeOf(this, _MarvinValidationError.prototype);
-      }
-      field;
-    };
-    MarvinNotFoundError = class _MarvinNotFoundError extends MarvinError {
-      constructor(message, endpoint) {
-        super(message, "NOT_FOUND", 404);
-        this.endpoint = endpoint;
-        this.name = "MarvinNotFoundError";
-        Object.setPrototypeOf(this, _MarvinNotFoundError.prototype);
-      }
-      endpoint;
-    };
-    MarvinNetworkError = class _MarvinNetworkError extends MarvinError {
-      constructor(message, originalError) {
-        super(message, "NETWORK_ERROR");
-        this.originalError = originalError;
-        this.name = "MarvinNetworkError";
-        Object.setPrototypeOf(this, _MarvinNetworkError.prototype);
-      }
-      originalError;
-    };
-    MarvinServerError = class _MarvinServerError extends MarvinError {
-      constructor(message, statusCode, endpoint) {
-        super(message, "SERVER_ERROR", statusCode);
-        this.endpoint = endpoint;
-        this.name = "MarvinServerError";
-        Object.setPrototypeOf(this, _MarvinServerError.prototype);
-      }
-      endpoint;
-    };
-  }
-});
-
-// src/core/errors/index.ts
-var init_errors = __esm({
-  "src/core/errors/index.ts"() {
-    "use strict";
-    init_MarvinError();
-  }
-});
-
-// src/core/http/HttpClient.ts
-var HttpClient;
-var init_HttpClient = __esm({
-  "src/core/http/HttpClient.ts"() {
-    "use strict";
-    init_errors();
-    HttpClient = class {
-      baseUrl;
-      auth;
-      defaultHeaders;
-      credentials;
-      timeout;
-      debug;
-      retryConfig;
-      logger;
-      constructor(config) {
-        this.baseUrl = config.baseUrl;
-        this.auth = config.auth;
-        this.defaultHeaders = config.defaultHeaders || {};
-        this.credentials = config.credentials || "same-origin";
-        const MAX_TIMEOUT = 12e4;
-        this.timeout = Math.min(config.timeout || 3e4, MAX_TIMEOUT);
-        this.debug = config.debug ?? false;
-        this.logger = config.logger ?? console;
-        this.retryConfig = {
-          maxRetries: config.retry?.maxRetries ?? 3,
-          initialDelay: config.retry?.initialDelay ?? 1e3,
-          maxDelay: config.retry?.maxDelay ?? 1e4,
-          retryableStatuses: config.retry?.retryableStatuses ?? [408, 429, 500, 502, 503, 504]
-        };
-      }
-      /**
-       * Validate path parameter to prevent path traversal attacks
-       */
-      validatePathParam(param, paramName = "parameter") {
-        if (typeof param === "number") {
-          return String(param);
-        }
-        if (!param || typeof param !== "string") {
-          throw new MarvinValidationError(`Invalid ${paramName}: must be a non-empty string or number`);
-        }
-        if (param.includes("..") || param.includes("/") || param.includes("\\")) {
-          throw new MarvinValidationError(
-            `Invalid ${paramName}: cannot contain path traversal characters (.. / \\)`
-          );
-        }
-        if (param.includes("\0")) {
-          throw new MarvinValidationError(`Invalid ${paramName}: cannot contain null bytes`);
-        }
-        if (param.length > 255) {
-          throw new MarvinValidationError(`Invalid ${paramName}: exceeds maximum length of 255 characters`);
-        }
-        return param;
-      }
-      /**
-       * Build full URL from endpoint
-       */
-      buildUrl(endpoint) {
-        const base = this.baseUrl.replace(/\/$/, "");
-        const path = endpoint.replace(/^\//, "");
-        return `${base}/${path}`;
-      }
-      /**
-       * Build headers for request
-       */
-      buildHeaders(additionalHeaders, isFormData = false) {
-        const headerInit = {};
-        if (!isFormData) {
-          headerInit["Content-Type"] = "application/json";
-        }
-        const headers = new Headers({
-          ...headerInit,
-          ...this.defaultHeaders,
-          ...additionalHeaders
-        });
-        this.auth.injectAuth(headers);
-        return headers;
-      }
-      /**
-       * Build query string from params
-       */
-      buildQueryString(params) {
-        const filtered = Object.entries(params).filter(([_, value]) => value !== void 0).map(([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
-        return filtered.length > 0 ? `?${filtered.join("&")}` : "";
-      }
-      /**
-       * Sanitize data for logging by redacting sensitive fields
-       */
-      sanitizeForLogging(data) {
-        if (!data || typeof data !== "object") {
-          return data;
-        }
-        const sensitiveFields = [
-          "token",
-          "access_token",
-          "refresh_token",
-          "password",
-          "secret",
-          "apiKey",
-          "api_key",
-          "bearer",
-          "authorization",
-          "csrf_token",
-          "session",
-          "cookie"
-        ];
-        const sanitize = (obj) => {
-          const sanitized = {};
-          for (const [key, value] of Object.entries(obj)) {
-            const keyLower = key.toLowerCase();
-            const isSensitive = sensitiveFields.some((field) => keyLower.includes(field));
-            if (isSensitive) {
-              sanitized[key] = "[REDACTED]";
-            } else if (value && typeof value === "object" && !Array.isArray(value)) {
-              sanitized[key] = sanitize(value);
-            } else if (Array.isArray(value)) {
-              sanitized[key] = value.map(
-                (item) => item && typeof item === "object" ? sanitize(item) : item
-              );
-            } else {
-              sanitized[key] = value;
-            }
-          }
-          return sanitized;
-        };
-        if (Array.isArray(data)) {
-          return data.map(
-            (item) => item && typeof item === "object" ? sanitize(item) : item
-          );
-        }
-        return sanitize(data);
-      }
-      /**
-       * Calculate delay for retry with exponential backoff
-       */
-      calculateRetryDelay(attempt) {
-        const delay = this.retryConfig.initialDelay * Math.pow(2, attempt);
-        return Math.min(delay, this.retryConfig.maxDelay);
-      }
-      /**
-       * Sleep for specified milliseconds
-       */
-      sleep(ms) {
-        return new Promise((resolve) => setTimeout(resolve, ms));
-      }
-      /**
-       * Perform HTTP request with automatic retry on transient failures
-       */
-      async request(method, endpoint, options, retryAttempt = 0) {
-        const url = this.buildUrl(endpoint) + (options?.params ? this.buildQueryString(options.params) : "");
-        const isFormData = options?.body instanceof FormData;
-        const headers = this.buildHeaders(options?.headers, isFormData);
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
-        const startTime = Date.now();
-        if (this.debug) {
-          this.logger.log(`[Marvin] ${method} ${url}`);
-        }
-        try {
-          const response = await fetch(url, {
-            method,
-            headers,
-            body: isFormData ? options.body : options?.body ? JSON.stringify(options.body) : void 0,
-            credentials: this.credentials,
-            signal: controller.signal
-          });
-          clearTimeout(timeoutId);
-          const duration = Date.now() - startTime;
-          if (this.debug) {
-            this.logger.log(
-              `[Marvin] ${response.status} ${response.statusText} (${duration}ms)`
-            );
-          }
-          if (response.status === 401 && this.auth.handleUnauthorized) {
-            await this.auth.handleUnauthorized();
-          }
-          if (!response.ok) {
-            const errorText = await response.text().catch(() => "");
-            if (this.debug) {
-              this.logger.error(
-                `[Marvin] Error response: ${response.status} ${response.statusText}`,
-                errorText ? `Body: ${errorText}` : ""
-              );
-            }
-            const isRetryable = this.retryConfig.retryableStatuses.includes(response.status);
-            const canRetry = retryAttempt < this.retryConfig.maxRetries;
-            if (isRetryable && canRetry) {
-              const delay = this.calculateRetryDelay(retryAttempt);
-              if (this.debug) {
-                this.logger.warn(
-                  `[Marvin] Retry ${retryAttempt + 1}/${this.retryConfig.maxRetries} after ${delay}ms (status: ${response.status})`
-                );
-              }
-              await this.sleep(delay);
-              return this.request(method, endpoint, options, retryAttempt + 1);
-            }
-            if (response.status === 404) {
-              throw new MarvinNotFoundError(
-                `Resource not found: ${endpoint}`,
-                endpoint
-              );
-            }
-            if (response.status === 401 || response.status === 403) {
-              throw new MarvinAuthError(
-                `Authentication failed: ${response.statusText}`,
-                response.status
-              );
-            }
-            if (response.status >= 500) {
-              throw new MarvinServerError(
-                `Server error: ${response.status} ${response.statusText}`,
-                response.status,
-                endpoint
-              );
-            }
-            throw MarvinApiError.fromResponse(
-              response.status,
-              response.statusText,
-              endpoint,
-              errorText
-            );
-          }
-          const contentType = response.headers.get("content-type");
-          if (!contentType || !contentType.includes("application/json")) {
-            return void 0;
-          }
-          const data = await response.json();
-          if (this.debug) {
-            const sanitized = this.sanitizeForLogging(data);
-            this.logger.log("[Marvin] Response:", JSON.stringify(sanitized, null, 2));
-          }
-          return data;
-        } catch (error) {
-          clearTimeout(timeoutId);
-          if (error instanceof MarvinApiError || error instanceof MarvinNotFoundError || error instanceof MarvinAuthError || error instanceof MarvinServerError) {
-            throw error;
-          }
-          if (error instanceof Error) {
-            const canRetry = retryAttempt < this.retryConfig.maxRetries;
-            if (canRetry && error.name !== "AbortError") {
-              const delay = this.calculateRetryDelay(retryAttempt);
-              if (this.debug) {
-                this.logger.warn(
-                  `[Marvin] Retry ${retryAttempt + 1}/${this.retryConfig.maxRetries} after ${delay}ms (network error)`
-                );
-              }
-              await this.sleep(delay);
-              return this.request(method, endpoint, options, retryAttempt + 1);
-            }
-            if (error.name === "AbortError") {
-              throw new MarvinNetworkError(
-                `Request timeout after ${this.timeout}ms`,
-                error
-              );
-            }
-            throw new MarvinNetworkError(
-              `Network error: ${error.message}`,
-              error
-            );
-          }
-          throw error;
-        }
-      }
-      /**
-       * GET request
-       */
-      async get(endpoint, params) {
-        return this.request("GET", endpoint, { params });
-      }
-      /**
-       * POST request
-       */
-      async post(endpoint, body) {
-        return this.request("POST", endpoint, { body });
-      }
-      /**
-       * PUT request
-       */
-      async put(endpoint, body) {
-        return this.request("PUT", endpoint, { body });
-      }
-      /**
-       * PATCH request
-       */
-      async patch(endpoint, body) {
-        return this.request("PATCH", endpoint, { body });
-      }
-      /**
-       * DELETE request
-       */
-      async delete(endpoint) {
-        return this.request("DELETE", endpoint);
-      }
-    };
-  }
-});
-
-// src/core/http/index.ts
-var init_http = __esm({
-  "src/core/http/index.ts"() {
-    "use strict";
-    init_HttpClient();
-  }
-});
-
-// src/core/auth/AuthStrategy.ts
-var BearerTokenAuth, SessionAuth, NoAuth;
-var init_AuthStrategy = __esm({
-  "src/core/auth/AuthStrategy.ts"() {
-    "use strict";
-    BearerTokenAuth = class {
-      constructor(token) {
-        this.token = token;
-      }
-      token;
-      injectAuth(headers) {
-        headers.set("Authorization", `Bearer ${this.token}`);
-      }
-      getDescription() {
-        return "Bearer token authentication";
-      }
-    };
-    SessionAuth = class {
-      constructor(sessionToken, onUnauthorized) {
-        this.sessionToken = sessionToken;
-        this.onUnauthorized = onUnauthorized;
-      }
-      sessionToken;
-      onUnauthorized;
-      csrfToken;
-      /**
-       * Set CSRF token for cross-site request forgery protection
-       * The token should be obtained from the server after login
-       */
-      setCsrfToken(token) {
-        this.csrfToken = token;
-      }
-      /**
-       * Get current CSRF token
-       */
-      getCsrfToken() {
-        return this.csrfToken;
-      }
-      injectAuth(headers) {
-        if (this.sessionToken) {
-          headers.set("Authorization", `Bearer ${this.sessionToken}`);
-        }
-        if (this.csrfToken) {
-          headers.set("X-CSRF-Token", this.csrfToken);
-        }
-      }
-      async handleUnauthorized() {
-        if (this.onUnauthorized) {
-          await this.onUnauthorized();
-        }
-      }
-      getDescription() {
-        const auth = this.sessionToken ? "Session authentication (explicit token)" : "Session authentication (cookies)";
-        const csrf = this.csrfToken ? " with CSRF protection" : "";
-        return auth + csrf;
-      }
-    };
-    NoAuth = class {
-      injectAuth(_headers) {
-      }
-      getDescription() {
-        return "No authentication";
-      }
-    };
-  }
-});
-
-// src/core/auth/index.ts
-var init_auth = __esm({
-  "src/core/auth/index.ts"() {
-    "use strict";
-    init_AuthStrategy();
-  }
-});
-
-// src/core/pagination/PaginatedResponse.ts
-function createPaginatedResponse(data, meta) {
-  return { data, meta };
-}
-function extractData(response) {
-  if (Array.isArray(response)) {
-    return response;
-  }
-  return response.data;
-}
-function isPaginatedResponse(response) {
-  return !Array.isArray(response) && "data" in response;
-}
-function pageToOffset(page, limit) {
-  return (page - 1) * limit;
-}
-function offsetToPage(offset, limit) {
-  return Math.floor(offset / limit) + 1;
-}
-var init_PaginatedResponse = __esm({
-  "src/core/pagination/PaginatedResponse.ts"() {
-    "use strict";
-  }
-});
-
-// src/core/pagination/index.ts
-var init_pagination = __esm({
-  "src/core/pagination/index.ts"() {
-    "use strict";
-    init_PaginatedResponse();
-  }
-});
-
-// src/core/cache.ts
-var MarvinCache;
-var init_cache = __esm({
-  "src/core/cache.ts"() {
-    "use strict";
-    MarvinCache = class {
-      constructor(duration = 5 * 60 * 1e3, maxEntries = 1e3) {
-        this.duration = duration;
-        this.maxEntries = maxEntries;
-      }
-      duration;
-      maxEntries;
-      cache = /* @__PURE__ */ new Map();
-      /**
-       * Get cached data by key
-       * Returns undefined if not found or expired
-       */
-      get(key) {
-        const entry = this.cache.get(key);
-        if (!entry) return void 0;
-        const age = Date.now() - entry.timestamp;
-        if (age > this.duration) {
-          this.cache.delete(key);
-          return void 0;
-        }
-        return entry.data;
-      }
-      /**
-       * Set cached data with optional tags for invalidation
-       */
-      set(key, data, tags) {
-        if (this.cache.size >= this.maxEntries) {
-          const oldestKey = this.cache.keys().next().value;
-          if (oldestKey) {
-            this.cache.delete(oldestKey);
-          }
-        }
-        this.cache.set(key, {
-          data,
-          timestamp: Date.now(),
-          tags
-        });
-      }
-      /**
-       * Check if key exists and is not expired
-       */
-      has(key) {
-        return this.get(key) !== void 0;
-      }
-      /**
-       * Clear all cached entries
-       */
-      clear() {
-        this.cache.clear();
-      }
-      /**
-       * Delete a specific cache entry
-       */
-      delete(key) {
-        this.cache.delete(key);
-      }
-      /**
-       * Invalidate all cache entries with a specific tag
-       * Useful for invalidating related data after mutations
-       *
-       * @example
-       * ```typescript
-       * // Cache entries with tags
-       * cache.set('entry:1', data, ['entries', 'entry:1']);
-       * cache.set('entries:list', data, ['entries']);
-       *
-       * // Invalidate all entries
-       * cache.invalidateByTag('entries');
-       * ```
-       */
-      invalidateByTag(tag) {
-        let count = 0;
-        for (const [key, entry] of this.cache.entries()) {
-          if (entry.tags?.includes(tag)) {
-            this.cache.delete(key);
-            count++;
-          }
-        }
-        return count;
-      }
-      /**
-       * Get cache statistics
-       */
-      getStats() {
-        let oldest = null;
-        let newest = null;
-        for (const entry of this.cache.values()) {
-          if (oldest === null || entry.timestamp < oldest) {
-            oldest = entry.timestamp;
-          }
-          if (newest === null || entry.timestamp > newest) {
-            newest = entry.timestamp;
-          }
-        }
-        return {
-          size: this.cache.size,
-          maxEntries: this.maxEntries,
-          oldestEntry: oldest,
-          newestEntry: newest
-        };
-      }
-      /**
-       * Remove expired entries (garbage collection)
-       * Returns number of entries removed
-       */
-      prune() {
-        let count = 0;
-        const now = Date.now();
-        for (const [key, entry] of this.cache.entries()) {
-          const age = now - entry.timestamp;
-          if (age > this.duration) {
-            this.cache.delete(key);
-            count++;
-          }
-        }
-        return count;
-      }
-    };
-  }
-});
-
-// src/core/validation.ts
-function validateEmail(email, fieldName = "Email") {
-  if (!email || typeof email !== "string") {
-    throw new MarvinValidationError(`${fieldName} is required and must be a string`);
-  }
-  const trimmed = email.trim();
-  if (trimmed.length === 0) {
-    throw new MarvinValidationError(`${fieldName} cannot be empty`);
-  }
-  if (trimmed.length < 5) {
-    throw new MarvinValidationError(`${fieldName} is too short`);
-  }
-  if (trimmed.length > 254) {
-    throw new MarvinValidationError(`${fieldName} exceeds maximum length of 254 characters`);
-  }
-  if (!EMAIL_REGEX.test(trimmed)) {
-    throw new MarvinValidationError(
-      `${fieldName} format is invalid. Expected format: user@example.com`
-    );
-  }
-  const [localPart, domain] = trimmed.split("@");
-  if (localPart.length > 64) {
-    throw new MarvinValidationError(`${fieldName} local part exceeds 64 characters`);
-  }
-  if (domain.length > 253) {
-    throw new MarvinValidationError(`${fieldName} domain exceeds 253 characters`);
-  }
-  if (trimmed.includes("..")) {
-    throw new MarvinValidationError(`${fieldName} cannot contain consecutive dots`);
-  }
-  if (localPart.startsWith(".") || localPart.endsWith(".")) {
-    throw new MarvinValidationError(`${fieldName} local part cannot start or end with a dot`);
-  }
-  return trimmed;
-}
-var EMAIL_REGEX;
-var init_validation = __esm({
-  "src/core/validation.ts"() {
-    "use strict";
-    init_errors();
-    EMAIL_REGEX = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
-  }
-});
-
-// src/core/index.ts
-var init_core = __esm({
-  "src/core/index.ts"() {
-    "use strict";
-    init_http();
-    init_auth();
-    init_errors();
-    init_pagination();
-    init_cache();
-    init_validation();
-  }
-});
-
-export {
-  __esm,
-  __export,
-  __toCommonJS,
-  MarvinError,
-  MarvinApiError,
-  MarvinAuthError,
-  MarvinConfigError,
-  MarvinValidationError,
-  MarvinNotFoundError,
-  MarvinNetworkError,
-  MarvinServerError,
-  init_errors,
-  HttpClient,
-  BearerTokenAuth,
-  SessionAuth,
-  NoAuth,
-  createPaginatedResponse,
-  extractData,
-  isPaginatedResponse,
-  pageToOffset,
-  offsetToPage,
-  MarvinCache,
-  validateEmail,
-  init_core
-};