@inneropen/marvin-sdk 1.0.2 → 1.3.0

package/dist/index.cjs

@@ -53,56 +53,307 @@ var init_config = __esm({
   }
 });
 
-// src/client/http.ts
-var MarvinHttpClient;
-var init_http = __esm({
-  "src/client/http.ts"() {
+// 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";
-    MarvinHttpClient = class {
+    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.config = config;
+        this.baseUrl = config.baseUrl;
+        this.auth = config.auth;
+        this.defaultHeaders = config.defaultHeaders || {};
+        this.credentials = config.credentials || "same-origin";
+        this.timeout = config.timeout || 3e4;
       }
-      config;
-      async fetch(endpoint) {
-        const url = `${this.config.apiUrl}${endpoint}`;
+      /**
+       * 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, {
-            headers: {
-              "Authorization": `Bearer ${this.config.siteClientToken}`,
-              "Content-Type": "application/json"
-            }
+            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();
-            throw new Error(
-              `Marvin API error: ${response.status} ${response.statusText} at ${endpoint}
-${errorText}`
+            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) {
-            const safeMessage = error.message.replace(
-              this.config.siteClientToken,
-              "[REDACTED]"
-            );
-            throw new Error(safeMessage);
+            if (error.name === "AbortError") {
+              throw new MarvinApiError(
+                `Request timeout after ${this.timeout}ms`,
+                408,
+                endpoint
+              );
+            }
+            throw new MarvinApiError(error.message, 0, endpoint);
           }
           throw error;
         }
       }
-      buildQueryString(params) {
-        const filtered = Object.entries(params).filter(([_, value]) => value !== void 0).map(([key, value]) => `${key}=${encodeURIComponent(String(value))}`);
-        return filtered.length > 0 ? `?${filtered.join("&")}` : "";
+      /**
+       * 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/utils/cache.ts
+// 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/utils/cache.ts"() {
+  "src/core/cache.ts"() {
     "use strict";
     MarvinCache = class {
       constructor(duration = 5 * 60 * 1e3) {
@@ -139,6 +390,42 @@ var init_cache = __esm({
   }
 });
 
+// src/core/index.ts
+var init_core = __esm({
+  "src/core/index.ts"() {
+    "use strict";
+    init_http();
+    init_auth();
+    init_errors();
+    init_pagination();
+    init_cache();
+  }
+});
+
+// src/client/http.ts
+var MarvinHttpClient;
+var init_http2 = __esm({
+  "src/client/http.ts"() {
+    "use strict";
+    init_core();
+    MarvinHttpClient = class extends HttpClient {
+      constructor(config) {
+        super({
+          baseUrl: config.apiUrl,
+          auth: new BearerTokenAuth(config.siteClientToken),
+          credentials: "same-origin"
+        });
+      }
+      /**
+       * Fetch endpoint (backward compatibility)
+       */
+      async fetch(endpoint) {
+        return this.get(endpoint);
+      }
+    };
+  }
+});
+
 // src/entries/entry.ts
 var Entry;
 var init_entry = __esm({
@@ -242,11 +529,12 @@ var init_entries = __esm({
           entry_type: options.entryType,
           collection: options.collection,
           limit: options.limit,
-          offset: options.offset,
-          status: options.status || "published"
+          offset: options.offset
+          // Don't send status - backend always returns published
         });
         const endpoint = `/api/publish/${this.workspaceSlug}/entries${queryString}`;
-        return this.http.fetch(endpoint);
+        const response = await this.http.fetch(endpoint);
+        return response.data || [];
       }
       /**
        * Get a single entry by slug
@@ -330,8 +618,7 @@ var init_collection = __esm({
        * Get all entries in this collection
        */
       async entries() {
-        const endpoint = `/api/publish/${this.workspaceSlug}/collections/${this.data.slug}/entries`;
-        return this.http.fetch(endpoint);
+        return this.data.entries || [];
       }
       /**
        * Get assets in this collection (future)
@@ -373,7 +660,8 @@ var init_collections = __esm({
        */
       async list() {
         const endpoint = `/api/publish/${this.workspaceSlug}/collections`;
-        return this.http.fetch(endpoint);
+        const response = await this.http.fetch(endpoint);
+        return response.data || [];
       }
       /**
        * Get a single collection by slug
@@ -416,7 +704,8 @@ var init_assets = __esm({
           offset: options.offset
         });
         const endpoint = `/api/publish/${this.workspaceSlug}/assets${queryString}`;
-        return this.http.fetch(endpoint);
+        const response = await this.http.fetch(endpoint);
+        return response.data || [];
       }
       /**
        * Convenience: Get all images
@@ -531,7 +820,8 @@ var init_resources = __esm({
           offset: options.offset
         });
         const endpoint = `/api/publish/${this.workspaceSlug}/resources${queryString}`;
-        return this.http.fetch(endpoint);
+        const response = await this.http.fetch(endpoint);
+        return response.data || [];
       }
       /**
        * Get a single resource by slug
@@ -624,8 +914,8 @@ var init_marvin = __esm({
   "src/client/marvin.ts"() {
     "use strict";
     init_config();
-    init_http();
-    init_cache();
+    init_http2();
+    init_core();
     init_workspace();
     MarvinClient = class {
       constructor(config) {
@@ -826,17 +1116,33 @@ var init_marvin = __esm({
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  BearerTokenAuth: () => BearerTokenAuth,
   Collection: () => Collection,
   Entry: () => Entry,
+  HttpClient: () => HttpClient,
+  MarvinApiError: () => MarvinApiError,
+  MarvinAuthError: () => MarvinAuthError,
+  MarvinCache: () => MarvinCache,
   MarvinClient: () => MarvinClient,
+  MarvinConfigError: () => MarvinConfigError,
+  MarvinError: () => MarvinError,
+  MarvinValidationError: () => MarvinValidationError,
+  NoAuth: () => NoAuth,
   Resource: () => Resource,
+  SessionAuth: () => SessionAuth,
   Workspace: () => Workspace,
   createConfigFromEnv: () => createConfigFromEnv,
-  createMarvinClient: () => createMarvinClient
+  createMarvinClient: () => createMarvinClient,
+  createPaginatedResponse: () => createPaginatedResponse,
+  extractData: () => extractData,
+  isPaginatedResponse: () => isPaginatedResponse,
+  offsetToPage: () => offsetToPage,
+  pageToOffset: () => pageToOffset
 });
 module.exports = __toCommonJS(index_exports);
 init_marvin();
 init_config();
+init_core();
 init_workspace();
 init_entry();
 init_collection();
@@ -849,11 +1155,26 @@ function createMarvinClient(config) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  BearerTokenAuth,
   Collection,
   Entry,
+  HttpClient,
+  MarvinApiError,
+  MarvinAuthError,
+  MarvinCache,
   MarvinClient,
+  MarvinConfigError,
+  MarvinError,
+  MarvinValidationError,
+  NoAuth,
   Resource,
+  SessionAuth,
   Workspace,
   createConfigFromEnv,
-  createMarvinClient
+  createMarvinClient,
+  createPaginatedResponse,
+  extractData,
+  isPaginatedResponse,
+  offsetToPage,
+  pageToOffset
 });

package/dist/index.d.cts

@@ -1,5 +1,7 @@
 import { MarvinResource, MarvinEntry, MarvinAsset, MarvinCollection, MarvinEntryType, MarvinSite, GetResourcesOptions as GetResourcesOptions$1 } from './types/index.cjs';
 export { GetAssetsOptions, GetEntriesOptions, MarvinPublishResponse } from './types/index.cjs';
+import { H as HttpClient } from './HttpClient-CLtgQGXH.cjs';
+export { A as AuthStrategy, B as BearerTokenAuth, a as HttpClientConfig, N as NoAuth, S as SessionAuth } from './HttpClient-CLtgQGXH.cjs';
 
 /**
  * Marvin SDK Configuration
@@ -16,14 +18,109 @@ interface MarvinConfig {
 declare function createConfigFromEnv(overrides?: Partial<MarvinConfig>): MarvinConfig;
 
 /**
- * HTTP Client for Marvin API
+ * Base error class for all Marvin SDK errors
  */
+declare class MarvinError extends Error {
+    readonly code?: string | undefined;
+    readonly statusCode?: number | undefined;
+    constructor(message: string, code?: string | undefined, statusCode?: number | undefined);
+}
+/**
+ * HTTP/API request errors
+ */
+declare class MarvinApiError extends MarvinError {
+    readonly statusCode: number;
+    readonly endpoint: string;
+    readonly responseBody?: string | undefined;
+    constructor(message: string, statusCode: number, endpoint: string, responseBody?: string | undefined);
+    static fromResponse(status: number, statusText: string, endpoint: string, body?: string): MarvinApiError;
+}
+/**
+ * Authentication/authorization errors
+ */
+declare class MarvinAuthError extends MarvinError {
+    constructor(message: string, statusCode?: number);
+}
+/**
+ * Configuration errors
+ */
+declare class MarvinConfigError extends MarvinError {
+    constructor(message: string);
+}
+/**
+ * Validation errors
+ */
+declare class MarvinValidationError extends MarvinError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined);
+}
 
-declare class MarvinHttpClient {
-    private config;
+/**
+ * Pagination response types and helpers
+ */
+interface PaginationMeta {
+    total?: number;
+    page?: number;
+    limit?: number;
+    offset?: number;
+    hasMore?: boolean;
+}
+interface PaginatedResponse<T> {
+    data: T[];
+    meta?: PaginationMeta;
+}
+interface PaginationParams {
+    limit?: number;
+    offset?: number;
+    page?: number;
+}
+/**
+ * Create a paginated response
+ */
+declare function createPaginatedResponse<T>(data: T[], meta?: PaginationMeta): PaginatedResponse<T>;
+/**
+ * Extract data from paginated response
+ */
+declare function extractData<T>(response: PaginatedResponse<T> | T[]): T[];
+/**
+ * Check if response is paginated
+ */
+declare function isPaginatedResponse<T>(response: PaginatedResponse<T> | T[]): response is PaginatedResponse<T>;
+/**
+ * Calculate pagination offset from page number
+ */
+declare function pageToOffset(page: number, limit: number): number;
+/**
+ * Calculate page number from offset
+ */
+declare function offsetToPage(offset: number, limit: number): number;
+
+/**
+ * Simple in-memory cache for SDK data
+ */
+declare class MarvinCache {
+    private duration;
+    private cache;
+    constructor(duration?: number);
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, data: T): void;
+    has(key: string): boolean;
+    clear(): void;
+    delete(key: string): void;
+}
+
+/**
+ * HTTP Client for Marvin Publishing API
+ *
+ * Wrapper around core HttpClient for Publishing API specifics
+ */
+
+declare class MarvinHttpClient extends HttpClient {
     constructor(config: MarvinConfig);
+    /**
+     * Fetch endpoint (backward compatibility)
+     */
     fetch<T>(endpoint: string): Promise<T>;
-    buildQueryString(params: Record<string, string | number | undefined>): string;
 }
 
 /**
@@ -427,4 +524,4 @@ declare class MarvinClient {
  */
 declare function createMarvinClient(config?: Partial<MarvinConfig>): MarvinClient;
 
-export { Collection, Entry, GetResourcesOptions$1 as GetResourcesOptions, MarvinAsset, MarvinClient, MarvinCollection, type MarvinConfig, MarvinEntry, MarvinEntryType, MarvinResource, MarvinSite, Resource, Workspace, createConfigFromEnv, createMarvinClient };
+export { Collection, Entry, GetResourcesOptions$1 as GetResourcesOptions, HttpClient, MarvinApiError, MarvinAsset, MarvinAuthError, MarvinCache, MarvinClient, MarvinCollection, type MarvinConfig, MarvinConfigError, MarvinEntry, MarvinEntryType, MarvinError, MarvinResource, MarvinSite, MarvinValidationError, type PaginatedResponse, type PaginationMeta, type PaginationParams, Resource, Workspace, createConfigFromEnv, createMarvinClient, createPaginatedResponse, extractData, isPaginatedResponse, offsetToPage, pageToOffset };