@inneropen/marvin-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,859 @@
+"use strict";
+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/client/config.ts
+var config_exports = {};
+__export(config_exports, {
+  createConfigFromEnv: () => createConfigFromEnv,
+  validateConfig: () => validateConfig
+});
+function validateConfig(config) {
+  if (!config.apiUrl) {
+    throw new Error("MARVIN_API_URL is required");
+  }
+  if (!config.siteClientToken) {
+    throw new Error("MARVIN_SITE_CLIENT_TOKEN is required");
+  }
+  if (!config.workspaceSlug) {
+    throw new Error("MARVIN_WORKSPACE_SLUG is required");
+  }
+}
+function createConfigFromEnv(overrides) {
+  return {
+    apiUrl: overrides?.apiUrl || process.env.MARVIN_API_URL || "",
+    siteClientToken: overrides?.siteClientToken || process.env.MARVIN_SITE_CLIENT_TOKEN || "",
+    workspaceSlug: overrides?.workspaceSlug || process.env.MARVIN_WORKSPACE_SLUG || "",
+    autoInitialize: overrides?.autoInitialize ?? false,
+    cacheDuration: overrides?.cacheDuration ?? 5 * 60 * 1e3
+    // 5 minutes
+  };
+}
+var init_config = __esm({
+  "src/client/config.ts"() {
+    "use strict";
+  }
+});
+
+// src/client/http.ts
+var MarvinHttpClient;
+var init_http = __esm({
+  "src/client/http.ts"() {
+    "use strict";
+    MarvinHttpClient = class {
+      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()
+        });
+      }
+      has(key) {
+        return this.get(key) !== void 0;
+      }
+      clear() {
+        this.cache.clear();
+      }
+      delete(key) {
+        this.cache.delete(key);
+      }
+    };
+  }
+});
+
+// src/entries/entry.ts
+var Entry;
+var init_entry = __esm({
+  "src/entries/entry.ts"() {
+    "use strict";
+    Entry = class {
+      constructor(data, http, workspaceSlug) {
+        this.data = data;
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      data;
+      http;
+      workspaceSlug;
+      // Expose all entry data as properties
+      get id() {
+        return this.data.id;
+      }
+      get title() {
+        return this.data.title;
+      }
+      get slug() {
+        return this.data.slug;
+      }
+      get summary() {
+        return this.data.summary;
+      }
+      get description() {
+        return this.data.description;
+      }
+      get contentMarkdown() {
+        return this.data.contentMarkdown;
+      }
+      get metadata() {
+        return this.data.metadata;
+      }
+      get status() {
+        return this.data.status;
+      }
+      get publishedAt() {
+        return this.data.publishedAt;
+      }
+      get createdAt() {
+        return this.data.createdAt;
+      }
+      get updatedAt() {
+        return this.data.updatedAt;
+      }
+      get entryTypeId() {
+        return this.data.entryTypeId;
+      }
+      get entryType() {
+        return this.data.entryType;
+      }
+      /**
+       * Get entry assets
+       */
+      get assets() {
+        return this.data.assets || [];
+      }
+      /**
+       * Get entry collections
+       */
+      get collections() {
+        return this.data.collections || [];
+      }
+      /**
+       * Get related entries (future)
+       */
+      async relatedEntries() {
+        throw new Error("Related entries not yet implemented");
+      }
+      /**
+       * Get raw entry data
+       */
+      toJSON() {
+        return this.data;
+      }
+    };
+  }
+});
+
+// src/entries/entries.ts
+var EntriesModule;
+var init_entries = __esm({
+  "src/entries/entries.ts"() {
+    "use strict";
+    init_entry();
+    EntriesModule = class {
+      constructor(http, workspaceSlug) {
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      http;
+      workspaceSlug;
+      /**
+       * Get all published entries
+       */
+      async list(options = {}) {
+        const queryString = this.http.buildQueryString({
+          entry_type: options.entryType,
+          collection: options.collection,
+          limit: options.limit,
+          offset: options.offset,
+          status: options.status || "published"
+        });
+        const endpoint = `/api/publish/${this.workspaceSlug}/entries${queryString}`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Get a single entry by slug
+       */
+      async get(slug) {
+        const endpoint = `/api/publish/${this.workspaceSlug}/entries/${slug}`;
+        const data = await this.http.fetch(endpoint);
+        return new Entry(data, this.http, this.workspaceSlug);
+      }
+      /**
+       * Convenience: Get all pages
+       */
+      async pages(options) {
+        return this.list({ ...options, entryType: "page" });
+      }
+      /**
+       * Convenience: Get all blog posts
+       */
+      async posts(options) {
+        return this.list({ ...options, entryType: "blog" });
+      }
+      /**
+       * Convenience: Get all projects
+       */
+      async projects(options) {
+        return this.list({ ...options, entryType: "project" });
+      }
+    };
+  }
+});
+
+// src/collections/collection.ts
+var Collection;
+var init_collection = __esm({
+  "src/collections/collection.ts"() {
+    "use strict";
+    Collection = class {
+      constructor(data, http, workspaceSlug) {
+        this.data = data;
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      data;
+      http;
+      workspaceSlug;
+      // Expose all collection data as properties
+      get id() {
+        return this.data.id;
+      }
+      get name() {
+        return this.data.name;
+      }
+      get slug() {
+        return this.data.slug;
+      }
+      get description() {
+        return this.data.description;
+      }
+      get icon() {
+        return this.data.icon;
+      }
+      get color() {
+        return this.data.color;
+      }
+      get sortOrder() {
+        return this.data.sortOrder;
+      }
+      get isSmart() {
+        return this.data.isSmart;
+      }
+      get smartRules() {
+        return this.data.smartRules;
+      }
+      get createdAt() {
+        return this.data.createdAt;
+      }
+      get updatedAt() {
+        return this.data.updatedAt;
+      }
+      /**
+       * Get all entries in this collection
+       */
+      async entries() {
+        const endpoint = `/api/publish/${this.workspaceSlug}/collections/${this.data.slug}/entries`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Get assets in this collection (future)
+       */
+      async assets() {
+        throw new Error("Collection assets not yet implemented");
+      }
+      /**
+       * Get collection metadata (future)
+       */
+      async metadata() {
+        throw new Error("Collection metadata not yet implemented");
+      }
+      /**
+       * Get raw collection data
+       */
+      toJSON() {
+        return this.data;
+      }
+    };
+  }
+});
+
+// src/collections/collections.ts
+var CollectionsModule;
+var init_collections = __esm({
+  "src/collections/collections.ts"() {
+    "use strict";
+    init_collection();
+    CollectionsModule = class {
+      constructor(http, workspaceSlug) {
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      http;
+      workspaceSlug;
+      /**
+       * Get all collections
+       */
+      async list() {
+        const endpoint = `/api/publish/${this.workspaceSlug}/collections`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Get a single collection by slug
+       */
+      async get(slug) {
+        const endpoint = `/api/publish/${this.workspaceSlug}/collections/${slug}`;
+        const data = await this.http.fetch(endpoint);
+        return new Collection(data, this.http, this.workspaceSlug);
+      }
+      /**
+       * Get entries in a collection
+       */
+      async entries(slug) {
+        const collection = await this.get(slug);
+        return collection.entries();
+      }
+    };
+  }
+});
+
+// src/assets/assets.ts
+var AssetsModule;
+var init_assets = __esm({
+  "src/assets/assets.ts"() {
+    "use strict";
+    AssetsModule = class {
+      constructor(http, workspaceSlug) {
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      http;
+      workspaceSlug;
+      /**
+       * Get all published assets
+       */
+      async list(options = {}) {
+        const queryString = this.http.buildQueryString({
+          type: options.type,
+          limit: options.limit,
+          offset: options.offset
+        });
+        const endpoint = `/api/publish/${this.workspaceSlug}/assets${queryString}`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Convenience: Get all images
+       */
+      async images(options) {
+        return this.list({ ...options, type: "image" });
+      }
+      /**
+       * Convenience: Get all videos
+       */
+      async videos(options) {
+        return this.list({ ...options, type: "video" });
+      }
+      /**
+       * Convenience: Get all documents
+       */
+      async documents(options) {
+        return this.list({ ...options, type: "document" });
+      }
+    };
+  }
+});
+
+// src/resources/resource.ts
+var Resource;
+var init_resource = __esm({
+  "src/resources/resource.ts"() {
+    "use strict";
+    Resource = class {
+      constructor(data, http, workspaceSlug) {
+        this.data = data;
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      data;
+      http;
+      workspaceSlug;
+      // Expose all resource data as properties
+      get id() {
+        return this.data.id;
+      }
+      get name() {
+        return this.data.name;
+      }
+      get slug() {
+        return this.data.slug;
+      }
+      get resourceType() {
+        return this.data.resourceType;
+      }
+      get description() {
+        return this.data.description;
+      }
+      get externalId() {
+        return this.data.externalId;
+      }
+      get url() {
+        return this.data.url;
+      }
+      get metadata() {
+        return this.data.metadata;
+      }
+      get createdAt() {
+        return this.data.createdAt;
+      }
+      get updatedAt() {
+        return this.data.updatedAt;
+      }
+      /**
+       * Get all entries that reference this resource
+       */
+      async entries() {
+        const endpoint = `/api/publish/${this.workspaceSlug}/resources/${this.data.slug}/entries`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Get assets related to this resource (future)
+       */
+      async assets() {
+        throw new Error("Resource assets not yet implemented");
+      }
+      /**
+       * Get raw resource data
+       */
+      toJSON() {
+        return this.data;
+      }
+    };
+  }
+});
+
+// src/resources/resources.ts
+var ResourcesModule;
+var init_resources = __esm({
+  "src/resources/resources.ts"() {
+    "use strict";
+    init_resource();
+    ResourcesModule = class {
+      constructor(http, workspaceSlug) {
+        this.http = http;
+        this.workspaceSlug = workspaceSlug;
+      }
+      http;
+      workspaceSlug;
+      /**
+       * Get all published resources
+       */
+      async list(options = {}) {
+        const queryString = this.http.buildQueryString({
+          resource_type: options.resourceType,
+          limit: options.limit,
+          offset: options.offset
+        });
+        const endpoint = `/api/publish/${this.workspaceSlug}/resources${queryString}`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Get a single resource by slug
+       */
+      async get(slug) {
+        const endpoint = `/api/publish/${this.workspaceSlug}/resources/${slug}`;
+        const data = await this.http.fetch(endpoint);
+        return new Resource(data, this.http, this.workspaceSlug);
+      }
+      /**
+       * Get entries that reference this resource
+       */
+      async entries(slug) {
+        const resource = await this.get(slug);
+        return resource.entries();
+      }
+    };
+  }
+});
+
+// src/workspaces/workspace.ts
+var Workspace;
+var init_workspace = __esm({
+  "src/workspaces/workspace.ts"() {
+    "use strict";
+    init_entries();
+    init_collections();
+    init_assets();
+    init_resources();
+    Workspace = class {
+      constructor(http, slug) {
+        this.http = http;
+        this._slug = slug;
+        this.entries = new EntriesModule(http, slug);
+        this.collections = new CollectionsModule(http, slug);
+        this.assets = new AssetsModule(http, slug);
+        this.resources = new ResourcesModule(http, slug);
+      }
+      http;
+      _site = null;
+      _slug;
+      entries;
+      collections;
+      assets;
+      resources;
+      /**
+       * Get workspace slug
+       */
+      get slug() {
+        return this._slug;
+      }
+      /**
+       * Get site configuration (cached after first load)
+       */
+      get site() {
+        return this._site;
+      }
+      /**
+       * Load site configuration
+       */
+      async loadSite() {
+        const endpoint = `/api/publish/${this._slug}/site`;
+        this._site = await this.http.fetch(endpoint);
+        return this._site;
+      }
+      /**
+       * Get workspace info (name and slug only)
+       */
+      async getInfo() {
+        const endpoint = `/api/publish/${this._slug}`;
+        return this.http.fetch(endpoint);
+      }
+      /**
+       * Get workspace settings (future)
+       */
+      async settings() {
+        throw new Error("Workspace settings not yet implemented");
+      }
+    };
+  }
+});
+
+// src/client/marvin.ts
+var marvin_exports = {};
+__export(marvin_exports, {
+  MarvinClient: () => MarvinClient
+});
+var MarvinClient;
+var init_marvin = __esm({
+  "src/client/marvin.ts"() {
+    "use strict";
+    init_config();
+    init_http();
+    init_cache();
+    init_workspace();
+    MarvinClient = class {
+      constructor(config) {
+        this.config = config;
+        validateConfig(config);
+        this.http = new MarvinHttpClient(config);
+        this.cache = new MarvinCache(config.cacheDuration);
+        this.workspace = new Workspace(this.http, config.workspaceSlug);
+        if (config.autoInitialize) {
+          this.initialize();
+        }
+      }
+      config;
+      http;
+      cache;
+      workspace;
+      initialized = false;
+      /**
+       * Initialize the SDK
+       * Preloads site configuration and metadata
+       */
+      async initialize() {
+        if (this.initialized) return;
+        try {
+          await this.workspace.loadSite();
+          this.initialized = true;
+        } catch (error) {
+          console.warn("Marvin SDK initialization warning:", error);
+        }
+      }
+      // ======================
+      // Workspace-First API
+      // ======================
+      /**
+       * Get the workspace object
+       */
+      async getWorkspace() {
+        if (!this.initialized) {
+          await this.initialize();
+        }
+        return this.workspace;
+      }
+      /**
+       * Get site configuration (cached)
+       */
+      get site() {
+        return this.workspace.site;
+      }
+      /**
+       * Get workspace info (name and slug)
+       */
+      async getWorkspaceInfo() {
+        return this.workspace.getInfo();
+      }
+      /**
+       * Get entries module
+       */
+      get entries() {
+        return this.workspace.entries;
+      }
+      /**
+       * Get collections module
+       */
+      get collections() {
+        return this.workspace.collections;
+      }
+      /**
+       * Get assets module
+       */
+      get assets() {
+        return this.workspace.assets;
+      }
+      /**
+       * Get resources module
+       */
+      get resources() {
+        return this.workspace.resources;
+      }
+      // ======================
+      // Convenience Methods
+      // ======================
+      /**
+       * Get a single entry by slug
+       */
+      async entry(slug) {
+        return this.workspace.entries.get(slug);
+      }
+      /**
+       * Get a single collection by slug
+       */
+      async collection(slug) {
+        return this.workspace.collections.get(slug);
+      }
+      /**
+       * Get all pages
+       */
+      async pages(options) {
+        return this.workspace.entries.pages(options);
+      }
+      /**
+       * Get all blog posts
+       */
+      async posts(options) {
+        return this.workspace.entries.posts(options);
+      }
+      /**
+       * Get all projects
+       */
+      async projects(options) {
+        return this.workspace.entries.projects(options);
+      }
+      /**
+       * Get a single resource by slug
+       */
+      async resource(slug) {
+        return this.workspace.resources.get(slug);
+      }
+      // ======================
+      // Backwards-Compatible Publishing API
+      // ======================
+      /**
+       * @deprecated Use workspace.site or marvin.site instead
+       * Get site configuration
+       */
+      async getSite() {
+        return this.workspace.loadSite();
+      }
+      /**
+       * @deprecated Use workspace.entries.list() instead
+       * Get all published entries
+       */
+      async getEntries(options) {
+        return this.workspace.entries.list(options);
+      }
+      /**
+       * @deprecated Use workspace.entries.get() instead
+       * Get a single published entry by slug
+       */
+      async getEntry(slug) {
+        const entry = await this.workspace.entries.get(slug);
+        return entry.toJSON();
+      }
+      /**
+       * @deprecated Use workspace.collections.list() instead
+       * Get all collections
+       */
+      async getCollections() {
+        return this.workspace.collections.list();
+      }
+      /**
+       * @deprecated Use workspace.collections.get() instead
+       * Get a single collection by slug
+       */
+      async getCollection(slug) {
+        const collection = await this.workspace.collections.get(slug);
+        return collection.toJSON();
+      }
+      /**
+       * @deprecated Use workspace.collections.entries() instead
+       * Get all entries in a collection
+       */
+      async getCollectionEntries(slug) {
+        return this.workspace.collections.entries(slug);
+      }
+      /**
+       * @deprecated Use workspace.assets.list() instead
+       * Get all published assets
+       */
+      async getAssets(options) {
+        return this.workspace.assets.list(options);
+      }
+      /**
+       * @deprecated Use workspace.resources.list() instead
+       * Get all published resources
+       */
+      async getResources(options) {
+        return this.workspace.resources.list(options);
+      }
+      /**
+       * @deprecated Use workspace.resources.get() instead
+       * Get a single resource by slug
+       */
+      async getResource(slug) {
+        const resource = await this.workspace.resources.get(slug);
+        return resource.toJSON();
+      }
+      /**
+       * @deprecated Use workspace.resources.entries() instead
+       * Get entries that reference a resource
+       */
+      async getResourceEntries(slug) {
+        return this.workspace.resources.entries(slug);
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Collection: () => Collection,
+  Entry: () => Entry,
+  MarvinClient: () => MarvinClient,
+  Resource: () => Resource,
+  Workspace: () => Workspace,
+  createConfigFromEnv: () => createConfigFromEnv,
+  createMarvinClient: () => createMarvinClient
+});
+module.exports = __toCommonJS(index_exports);
+init_marvin();
+init_config();
+init_workspace();
+init_entry();
+init_collection();
+init_resource();
+function createMarvinClient(config) {
+  const { MarvinClient: MarvinClient2 } = (init_marvin(), __toCommonJS(marvin_exports));
+  const { createConfigFromEnv: createConfigFromEnv2 } = (init_config(), __toCommonJS(config_exports));
+  const finalConfig = createConfigFromEnv2(config);
+  return new MarvinClient2(finalConfig);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Collection,
+  Entry,
+  MarvinClient,
+  Resource,
+  Workspace,
+  createConfigFromEnv,
+  createMarvinClient
+});