@inneropen/marvin-sdk 1.0.3 → 1.3.0

package/dist/index.d.ts

@@ -1,5 +1,7 @@
 import { MarvinResource, MarvinEntry, MarvinAsset, MarvinCollection, MarvinEntryType, MarvinSite, GetResourcesOptions as GetResourcesOptions$1 } from './types/index.js';
 export { GetAssetsOptions, GetEntriesOptions, MarvinPublishResponse } from './types/index.js';
+import { H as HttpClient } from './HttpClient-CLtgQGXH.js';
+export { A as AuthStrategy, B as BearerTokenAuth, a as HttpClientConfig, N as NoAuth, S as SessionAuth } from './HttpClient-CLtgQGXH.js';
 
 /**
  * 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 };

package/dist/index.js

@@ -1,23 +1,24 @@
-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);
+import {
+  BearerTokenAuth,
+  HttpClient,
+  MarvinApiError,
+  MarvinAuthError,
+  MarvinCache,
+  MarvinConfigError,
+  MarvinError,
+  MarvinValidationError,
+  NoAuth,
+  SessionAuth,
+  __esm,
+  __export,
+  __toCommonJS,
+  createPaginatedResponse,
+  extractData,
+  init_core,
+  isPaginatedResponse,
+  offsetToPage,
+  pageToOffset
+} from "./chunk-LQOFJMRJ.js";
 
 // src/client/config.ts
 var config_exports = {};
@@ -57,82 +58,20 @@ var MarvinHttpClient;
 var init_http = __esm({
   "src/client/http.ts"() {
     "use strict";
-    MarvinHttpClient = class {
+    init_core();
+    MarvinHttpClient = class extends HttpClient {
       constructor(config) {
-        this.config = config;
-      }
-      config;
-      async fetch(endpoint) {
-        const url = `${this.config.apiUrl}${endpoint}`;
-        try {
-          const response = await fetch(url, {
-            headers: {
-              "Authorization": `Bearer ${this.config.siteClientToken}`,
-              "Content-Type": "application/json"
-            }
-          });
-          if (!response.ok) {
-            const errorText = await response.text();
-            throw new Error(
-              `Marvin API error: ${response.status} ${response.statusText} at ${endpoint}
-${errorText}`
-            );
-          }
-          return await response.json();
-        } catch (error) {
-          if (error instanceof Error) {
-            const safeMessage = error.message.replace(
-              this.config.siteClientToken,
-              "[REDACTED]"
-            );
-            throw new Error(safeMessage);
-          }
-          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("&")}` : "";
-      }
-    };
-  }
-});
-
-// src/utils/cache.ts
-var MarvinCache;
-var init_cache = __esm({
-  "src/utils/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()
+        super({
+          baseUrl: config.apiUrl,
+          auth: new BearerTokenAuth(config.siteClientToken),
+          credentials: "same-origin"
         });
       }
-      has(key) {
-        return this.get(key) !== void 0;
-      }
-      clear() {
-        this.cache.clear();
-      }
-      delete(key) {
-        this.cache.delete(key);
+      /**
+       * Fetch endpoint (backward compatibility)
+       */
+      async fetch(endpoint) {
+        return this.get(endpoint);
       }
     };
   }
@@ -330,8 +269,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)
@@ -628,7 +566,7 @@ var init_marvin = __esm({
     "use strict";
     init_config();
     init_http();
-    init_cache();
+    init_core();
     init_workspace();
     MarvinClient = class {
       constructor(config) {
@@ -829,6 +767,7 @@ var init_marvin = __esm({
 // src/index.ts
 init_marvin();
 init_config();
+init_core();
 init_workspace();
 init_entry();
 init_collection();
@@ -840,11 +779,26 @@ function createMarvinClient(config) {
   return new MarvinClient2(finalConfig);
 }
 export {
+  BearerTokenAuth,
   Collection,
   Entry,
+  HttpClient,
+  MarvinApiError,
+  MarvinAuthError,
+  MarvinCache,
   MarvinClient,
+  MarvinConfigError,
+  MarvinError,
+  MarvinValidationError,
+  NoAuth,
   Resource,
+  SessionAuth,
   Workspace,
   createConfigFromEnv,
-  createMarvinClient
+  createMarvinClient,
+  createPaginatedResponse,
+  extractData,
+  isPaginatedResponse,
+  offsetToPage,
+  pageToOffset
 };