@inneropen/marvin-sdk 1.0.2 → 1.3.0

package/dist/platform.cjs

@@ -0,0 +1,547 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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/platform.ts
+var platform_exports = {};
+__export(platform_exports, {
+  APIClientsModule: () => APIClientsModule,
+  AssetsModule: () => AssetsModule,
+  CollectionsModule: () => CollectionsModule,
+  EntriesModule: () => EntriesModule,
+  EntryTypesModule: () => EntryTypesModule,
+  PlatformClient: () => PlatformClient,
+  ResourcesModule: () => ResourcesModule,
+  WorkspaceMembersModule: () => WorkspaceMembersModule,
+  createPlatformClient: () => createPlatformClient
+});
+module.exports = __toCommonJS(platform_exports);
+
+// src/core/errors/MarvinError.ts
+var 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;
+};
+var 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);
+  }
+};
+
+// src/core/http/HttpClient.ts
+var 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/auth/AuthStrategy.ts
+var 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)";
+  }
+};
+
+// src/platform/entries.ts
+var EntriesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all entries
+   */
+  async list() {
+    return this.http.get("/api/platform/entries");
+  }
+  /**
+   * Get a single entry by ID
+   */
+  async get(id) {
+    return this.http.get(`/api/platform/entries/${id}`);
+  }
+  /**
+   * Create a new entry
+   */
+  async create(data) {
+    return this.http.post("/api/platform/entries", data);
+  }
+  /**
+   * Update an entry
+   */
+  async update(id, data) {
+    return this.http.patch(`/api/platform/entries/${id}`, data);
+  }
+  /**
+   * Delete an entry
+   */
+  async delete(id) {
+    return this.http.delete(`/api/platform/entries/${id}`);
+  }
+  /**
+   * Get collections that this entry belongs to
+   */
+  async listCollections(entryId) {
+    return this.http.get(`/api/platform/entries/${entryId}/collections`);
+  }
+  /**
+   * Add entry to a collection
+   */
+  async addToCollection(entryId, collectionId) {
+    return this.http.post(
+      `/api/platform/entries/${entryId}/collections/${collectionId}`,
+      {}
+    );
+  }
+  /**
+   * Remove entry from a collection
+   */
+  async removeFromCollection(entryId, collectionId) {
+    return this.http.delete(`/api/platform/entries/${entryId}/collections/${collectionId}`);
+  }
+};
+
+// src/platform/collections.ts
+var CollectionsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all collections
+   */
+  async list() {
+    return this.http.get("/api/platform/collections");
+  }
+  /**
+   * Get a single collection by ID
+   */
+  async get(id) {
+    return this.http.get(`/api/platform/collections/${id}`);
+  }
+  /**
+   * Create a new collection
+   */
+  async create(data) {
+    return this.http.post("/api/platform/collections", data);
+  }
+  /**
+   * Update a collection
+   */
+  async update(id, data) {
+    return this.http.patch(`/api/platform/collections/${id}`, data);
+  }
+  /**
+   * Delete a collection
+   */
+  async delete(id) {
+    return this.http.delete(`/api/platform/collections/${id}`);
+  }
+};
+
+// src/platform/resources.ts
+var ResourcesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all resources
+   */
+  async list() {
+    return this.http.get("/api/platform/resources");
+  }
+  /**
+   * Get a single resource by ID
+   */
+  async get(id) {
+    return this.http.get(`/api/platform/resources/${id}`);
+  }
+  /**
+   * Create a new resource
+   */
+  async create(data) {
+    return this.http.post("/api/platform/resources", data);
+  }
+  /**
+   * Update a resource
+   */
+  async update(id, data) {
+    return this.http.patch(`/api/platform/resources/${id}`, data);
+  }
+  /**
+   * Delete a resource
+   */
+  async delete(id) {
+    return this.http.delete(`/api/platform/resources/${id}`);
+  }
+};
+
+// src/platform/assets.ts
+var AssetsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all assets
+   */
+  async list() {
+    return this.http.get("/api/platform/assets");
+  }
+  /**
+   * Get a single asset by ID
+   */
+  async get(id) {
+    return this.http.get(`/api/platform/assets/${id}`);
+  }
+  /**
+   * Create a new asset
+   */
+  async create(data) {
+    return this.http.post("/api/platform/assets", data);
+  }
+  /**
+   * Update an asset
+   */
+  async update(id, data) {
+    return this.http.patch(`/api/platform/assets/${id}`, data);
+  }
+  /**
+   * Delete an asset
+   */
+  async delete(id) {
+    return this.http.delete(`/api/platform/assets/${id}`);
+  }
+};
+
+// src/platform/apiClients.ts
+var APIClientsModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all API clients
+   */
+  async list() {
+    return this.http.get("/api/platform/api-clients");
+  }
+  /**
+   * Get a single API client by ID
+   */
+  async get(id) {
+    return this.http.get(`/api/platform/api-clients/${id}`);
+  }
+  /**
+   * Create a new API client (returns client with token)
+   */
+  async create(data) {
+    return this.http.post("/api/platform/api-clients", data);
+  }
+  /**
+   * Update an API client
+   */
+  async update(id, data) {
+    return this.http.patch(`/api/platform/api-clients/${id}`, data);
+  }
+  /**
+   * Delete an API client
+   */
+  async delete(id) {
+    return this.http.delete(`/api/platform/api-clients/${id}`);
+  }
+  /**
+   * Rotate API client token (generates new token, invalidates old one)
+   */
+  async rotateToken(id) {
+    return this.http.post(
+      `/api/platform/api-clients/${id}/rotate-token`,
+      {}
+    );
+  }
+  /**
+   * Preview API client token (show token prefix and metadata without revealing full token)
+   */
+  async preview(id) {
+    return this.http.get(`/api/platform/api-clients/${id}/preview`);
+  }
+};
+
+// src/platform/entryTypes.ts
+var EntryTypesModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all entry types
+   */
+  async list() {
+    return this.http.get("/api/platform/entry-types");
+  }
+  /**
+   * Get a single entry type by ID
+   */
+  async get(id) {
+    return this.http.get(`/api/platform/entry-types/${id}`);
+  }
+};
+
+// src/platform/workspaceMembers.ts
+var WorkspaceMembersModule = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  /**
+   * List all members of a workspace
+   */
+  async list(workspaceId) {
+    return this.http.get(
+      `/api/platform/workspaces/${workspaceId}/members`
+    );
+  }
+  /**
+   * Get a specific workspace member
+   */
+  async get(workspaceId, userId) {
+    return this.http.get(
+      `/api/platform/workspaces/${workspaceId}/members/${userId}`
+    );
+  }
+  /**
+   * Add a user to a workspace with a specific role
+   */
+  async add(workspaceId, data) {
+    return this.http.post(
+      `/api/platform/workspaces/${workspaceId}/members`,
+      data
+    );
+  }
+  /**
+   * Update a workspace member's role
+   */
+  async updateRole(workspaceId, userId, data) {
+    return this.http.put(
+      `/api/platform/workspaces/${workspaceId}/members/${userId}`,
+      data
+    );
+  }
+  /**
+   * Remove a user from a workspace
+   */
+  async remove(workspaceId, userId) {
+    return this.http.delete(`/api/platform/workspaces/${workspaceId}/members/${userId}`);
+  }
+};
+
+// src/platform/client.ts
+var PlatformClient = class extends HttpClient {
+  entries;
+  collections;
+  resources;
+  assets;
+  apiClients;
+  entryTypes;
+  workspaceMembers;
+  constructor(config) {
+    const httpConfig = {
+      baseUrl: config.apiUrl,
+      auth: new SessionAuth(config.userToken),
+      credentials: config.credentials || "include"
+    };
+    super(httpConfig);
+    this.entries = new EntriesModule(this);
+    this.collections = new CollectionsModule(this);
+    this.resources = new ResourcesModule(this);
+    this.assets = new AssetsModule(this);
+    this.apiClients = new APIClientsModule(this);
+    this.entryTypes = new EntryTypesModule(this);
+    this.workspaceMembers = new WorkspaceMembersModule(this);
+  }
+};
+function createPlatformClient(config) {
+  return new PlatformClient(config);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIClientsModule,
+  AssetsModule,
+  CollectionsModule,
+  EntriesModule,
+  EntryTypesModule,
+  PlatformClient,
+  ResourcesModule,
+  WorkspaceMembersModule,
+  createPlatformClient
+});