@inneropen/marvin-sdk 1.0.3 → 1.3.1

package/dist/HttpClient-CLtgQGXH.d.cts

@@ -0,0 +1,113 @@
+/**
+ * Authentication strategy interface
+ *
+ * Different API surfaces use different auth methods:
+ * - Publishing API: Bearer token (site client token)
+ * - Platform API: Session token or user token
+ * - Admin API: Admin session token
+ */
+interface AuthStrategy {
+    /**
+     * Inject authentication headers into the request
+     */
+    injectAuth(headers: Headers): void;
+    /**
+     * Handle unauthorized responses (401)
+     * Optional - can be used for token refresh, redirect to login, etc.
+     */
+    handleUnauthorized?(): Promise<void>;
+    /**
+     * Get a description of the auth strategy (for debugging)
+     */
+    getDescription(): string;
+}
+/**
+ * Bearer token authentication (Publishing API, User tokens)
+ */
+declare class BearerTokenAuth implements AuthStrategy {
+    private token;
+    constructor(token: string);
+    injectAuth(headers: Headers): void;
+    getDescription(): string;
+}
+/**
+ * Session-based authentication (Platform/Admin APIs in browser)
+ * Relies on HTTP-only cookies set by the server
+ */
+declare class SessionAuth implements AuthStrategy {
+    private sessionToken?;
+    private onUnauthorized?;
+    constructor(sessionToken?: string | undefined, onUnauthorized?: (() => Promise<void>) | undefined);
+    injectAuth(headers: Headers): void;
+    handleUnauthorized(): Promise<void>;
+    getDescription(): string;
+}
+/**
+ * No authentication (for public endpoints)
+ */
+declare class NoAuth implements AuthStrategy {
+    injectAuth(_headers: Headers): void;
+    getDescription(): string;
+}
+
+/**
+ * Base HTTP client for Marvin APIs
+ */
+
+interface HttpClientConfig {
+    baseUrl: string;
+    auth: AuthStrategy;
+    defaultHeaders?: Record<string, string>;
+    credentials?: RequestCredentials;
+    timeout?: number;
+}
+declare class HttpClient {
+    private baseUrl;
+    private auth;
+    private defaultHeaders;
+    private credentials;
+    private timeout;
+    constructor(config: HttpClientConfig);
+    /**
+     * Build full URL from endpoint
+     */
+    private buildUrl;
+    /**
+     * Build headers for request
+     */
+    private buildHeaders;
+    /**
+     * Build query string from params
+     */
+    buildQueryString(params: Record<string, string | number | boolean | undefined>): string;
+    /**
+     * Perform HTTP request
+     */
+    request<T>(method: string, endpoint: string, options?: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        params?: Record<string, string | number | boolean | undefined>;
+    }): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T>(endpoint: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(endpoint: string, body?: unknown): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(endpoint: string, body?: unknown): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(endpoint: string, body?: unknown): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(endpoint: string): Promise<T>;
+}
+
+export { type AuthStrategy as A, BearerTokenAuth as B, HttpClient as H, NoAuth as N, SessionAuth as S, type HttpClientConfig as a };

package/dist/HttpClient-CLtgQGXH.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Authentication strategy interface
+ *
+ * Different API surfaces use different auth methods:
+ * - Publishing API: Bearer token (site client token)
+ * - Platform API: Session token or user token
+ * - Admin API: Admin session token
+ */
+interface AuthStrategy {
+    /**
+     * Inject authentication headers into the request
+     */
+    injectAuth(headers: Headers): void;
+    /**
+     * Handle unauthorized responses (401)
+     * Optional - can be used for token refresh, redirect to login, etc.
+     */
+    handleUnauthorized?(): Promise<void>;
+    /**
+     * Get a description of the auth strategy (for debugging)
+     */
+    getDescription(): string;
+}
+/**
+ * Bearer token authentication (Publishing API, User tokens)
+ */
+declare class BearerTokenAuth implements AuthStrategy {
+    private token;
+    constructor(token: string);
+    injectAuth(headers: Headers): void;
+    getDescription(): string;
+}
+/**
+ * Session-based authentication (Platform/Admin APIs in browser)
+ * Relies on HTTP-only cookies set by the server
+ */
+declare class SessionAuth implements AuthStrategy {
+    private sessionToken?;
+    private onUnauthorized?;
+    constructor(sessionToken?: string | undefined, onUnauthorized?: (() => Promise<void>) | undefined);
+    injectAuth(headers: Headers): void;
+    handleUnauthorized(): Promise<void>;
+    getDescription(): string;
+}
+/**
+ * No authentication (for public endpoints)
+ */
+declare class NoAuth implements AuthStrategy {
+    injectAuth(_headers: Headers): void;
+    getDescription(): string;
+}
+
+/**
+ * Base HTTP client for Marvin APIs
+ */
+
+interface HttpClientConfig {
+    baseUrl: string;
+    auth: AuthStrategy;
+    defaultHeaders?: Record<string, string>;
+    credentials?: RequestCredentials;
+    timeout?: number;
+}
+declare class HttpClient {
+    private baseUrl;
+    private auth;
+    private defaultHeaders;
+    private credentials;
+    private timeout;
+    constructor(config: HttpClientConfig);
+    /**
+     * Build full URL from endpoint
+     */
+    private buildUrl;
+    /**
+     * Build headers for request
+     */
+    private buildHeaders;
+    /**
+     * Build query string from params
+     */
+    buildQueryString(params: Record<string, string | number | boolean | undefined>): string;
+    /**
+     * Perform HTTP request
+     */
+    request<T>(method: string, endpoint: string, options?: {
+        body?: unknown;
+        headers?: Record<string, string>;
+        params?: Record<string, string | number | boolean | undefined>;
+    }): Promise<T>;
+    /**
+     * GET request
+     */
+    get<T>(endpoint: string, params?: Record<string, string | number | boolean | undefined>): Promise<T>;
+    /**
+     * POST request
+     */
+    post<T>(endpoint: string, body?: unknown): Promise<T>;
+    /**
+     * PUT request
+     */
+    put<T>(endpoint: string, body?: unknown): Promise<T>;
+    /**
+     * PATCH request
+     */
+    patch<T>(endpoint: string, body?: unknown): Promise<T>;
+    /**
+     * DELETE request
+     */
+    delete<T>(endpoint: string): Promise<T>;
+}
+
+export { type AuthStrategy as A, BearerTokenAuth as B, HttpClient as H, NoAuth as N, SessionAuth as S, type HttpClientConfig as a };

package/dist/chunk-LQOFJMRJ.js

@@ -0,0 +1,391 @@
+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;
+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;
+    };
+  }
+});
+
+// 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;
+      constructor(config) {
+        this.baseUrl = config.baseUrl;
+        this.auth = config.auth;
+        this.defaultHeaders = config.defaultHeaders || {};
+        this.credentials = config.credentials || "same-origin";
+        this.timeout = config.timeout || 3e4;
+      }
+      /**
+       * 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) {
+        const headers = new Headers({
+          "Content-Type": "application/json",
+          ...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("&")}` : "";
+      }
+      /**
+       * Perform HTTP request
+       */
+      async request(method, endpoint, options) {
+        const url = this.buildUrl(endpoint) + (options?.params ? this.buildQueryString(options.params) : "");
+        const headers = this.buildHeaders(options?.headers);
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        try {
+          const response = await fetch(url, {
+            method,
+            headers,
+            body: options?.body ? JSON.stringify(options.body) : void 0,
+            credentials: this.credentials,
+            signal: controller.signal
+          });
+          clearTimeout(timeoutId);
+          if (response.status === 401 && this.auth.handleUnauthorized) {
+            await this.auth.handleUnauthorized();
+          }
+          if (!response.ok) {
+            const errorText = await response.text().catch(() => "");
+            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;
+          }
+          return await response.json();
+        } catch (error) {
+          clearTimeout(timeoutId);
+          if (error instanceof MarvinApiError) {
+            throw error;
+          }
+          if (error instanceof Error) {
+            if (error.name === "AbortError") {
+              throw new MarvinApiError(
+                `Request timeout after ${this.timeout}ms`,
+                408,
+                endpoint
+              );
+            }
+            throw new MarvinApiError(error.message, 0, endpoint);
+          }
+          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;
+      injectAuth(headers) {
+        if (this.sessionToken) {
+          headers.set("Authorization", `Bearer ${this.sessionToken}`);
+        }
+      }
+      async handleUnauthorized() {
+        if (this.onUnauthorized) {
+          await this.onUnauthorized();
+        }
+      }
+      getDescription() {
+        return this.sessionToken ? "Session authentication (explicit token)" : "Session authentication (cookies)";
+      }
+    };
+    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) {
+        this.duration = duration;
+      }
+      duration;
+      cache = /* @__PURE__ */ new Map();
+      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(key, data) {
+        this.cache.set(key, {
+          data,
+          timestamp: Date.now()
+        });
+      }
+      has(key) {
+        return this.get(key) !== void 0;
+      }
+      clear() {
+        this.cache.clear();
+      }
+      delete(key) {
+        this.cache.delete(key);
+      }
+    };
+  }
+});
+
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    "use strict";
+    init_http();
+    init_auth();
+    init_errors();
+    init_pagination();
+    init_cache();
+  }
+});
+
+export {
+  __esm,
+  __export,
+  __toCommonJS,
+  MarvinError,
+  MarvinApiError,
+  MarvinAuthError,
+  MarvinConfigError,
+  MarvinValidationError,
+  HttpClient,
+  BearerTokenAuth,
+  SessionAuth,
+  NoAuth,
+  createPaginatedResponse,
+  extractData,
+  isPaginatedResponse,
+  pageToOffset,
+  offsetToPage,
+  MarvinCache,
+  init_core
+};