@riverbankcms/sdk 0.1.0

package/dist/client/client.js

@@ -0,0 +1,606 @@
+"use client";
+"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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  Page: () => Page,
+  createRiverbankClient: () => createRiverbankClient,
+  isContentError: () => isContentError,
+  isContentLoading: () => isContentLoading,
+  isEntryContentResult: () => isEntryContentResult,
+  isPageContentResult: () => isPageContentResult,
+  useContent: () => useContent,
+  usePage: () => usePage
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/rendering/hooks/usePage.ts
+var import_react = require("react");
+
+// src/data/prefetchBlockData.ts
+var import_data = require("@riverbankcms/blocks/system/data");
+var SUPPORTED_LOADER_ENDPOINTS = [
+  "listPublishedEntries",
+  "getPublishedEntryPreview",
+  "listPublicEvents",
+  "getPublicFormById",
+  "getPublicBookingServices"
+];
+async function prefetchBlockData(page, context, client, options) {
+  const { customBlocks } = options ?? {};
+  const customBlockMap = new Map(
+    (customBlocks ?? []).map((block) => [block.id, block])
+  );
+  return (0, import_data.prefetchBlockData)(page, context, {
+    apiClient: async ({ endpoint, params }) => {
+      if (!isSupportedEndpoint(endpoint)) {
+        throw new Error(
+          `Unsupported loader endpoint: ${endpoint}. SDK only supports: ${SUPPORTED_LOADER_ENDPOINTS.join(", ")}`
+        );
+      }
+      switch (endpoint) {
+        case "listPublishedEntries": {
+          const { siteId, type, orderBy, limit, stage, mode, entryIds } = params ?? {};
+          if (!siteId || !type) {
+            throw new Error("listPublishedEntries requires siteId and type params");
+          }
+          const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
+          const order = orderBy === "newest" || orderBy === "oldest" || orderBy === "title" || orderBy === "order" ? orderBy : void 0;
+          let parsedEntryIds;
+          if (mode === "manual" && Array.isArray(entryIds)) {
+            parsedEntryIds = entryIds.map((item) => {
+              if (typeof item === "object" && item !== null && "entryId" in item) {
+                return item.entryId;
+              }
+              if (typeof item === "string") {
+                return item;
+              }
+              return null;
+            }).filter((id) => id !== null);
+          }
+          return await client.getEntries({
+            siteId,
+            contentType: type,
+            limit: parsedLimit,
+            order,
+            preview: stage === "preview",
+            // Manual mode - pass entry IDs for hydration
+            mode: mode === "manual" ? "manual" : void 0,
+            entryIds: parsedEntryIds
+          });
+        }
+        case "getPublishedEntryPreview": {
+          const { siteId, type, slug } = params ?? {};
+          if (!siteId || !type || !slug) {
+            throw new Error("getPublishedEntryPreview requires siteId, type, and slug params");
+          }
+          return await client.getEntry({ siteId, contentType: type, slug });
+        }
+        case "listPublicEvents": {
+          const { siteId, limit, from, to, stage } = params ?? {};
+          if (!siteId) {
+            throw new Error("listPublicEvents requires siteId param");
+          }
+          const parsedLimit = typeof limit === "string" ? Number.parseInt(limit, 10) : typeof limit === "number" ? limit : void 0;
+          return await client.listPublicEvents({ siteId, limit: parsedLimit, from, to, stage });
+        }
+        case "getPublicFormById": {
+          const { formId } = params ?? {};
+          if (!formId) {
+            throw new Error("getPublicFormById requires formId param");
+          }
+          return await client.getPublicFormById({ formId });
+        }
+        case "getPublicBookingServices": {
+          const { siteId, ids } = params ?? {};
+          if (!siteId) {
+            throw new Error("getPublicBookingServices requires siteId param");
+          }
+          return await client.getPublicBookingServices({ siteId, ids });
+        }
+        default: {
+          const _exhaustive = endpoint;
+          throw new Error(`Unhandled endpoint: ${_exhaustive}`);
+        }
+      }
+    },
+    isValidEndpoint: isSupportedEndpoint,
+    onError: (error, { block, loader }) => {
+      console.warn("[prefetchBlockData] failed to prefetch block data", {
+        block,
+        loader,
+        error
+      });
+    },
+    // Provide custom block loader lookup for SDK custom blocks
+    getCustomBlockLoaders: (blockKind) => {
+      const customBlock = customBlockMap.get(blockKind);
+      if (!customBlock?.dataLoaders) return void 0;
+      const loaders = {};
+      for (const [key, loader] of Object.entries(customBlock.dataLoaders)) {
+        loaders[key] = {
+          endpoint: loader.endpoint,
+          params: loader.params,
+          mode: loader.mode
+        };
+      }
+      return loaders;
+    }
+  });
+}
+function isSupportedEndpoint(endpoint) {
+  return SUPPORTED_LOADER_ENDPOINTS.includes(endpoint);
+}
+
+// src/rendering/hooks/usePage.ts
+function usePage(params) {
+  const { client, siteId, path, pageId, preview = false } = params;
+  const [result, setResult] = (0, import_react.useState)({
+    loading: true,
+    error: null,
+    page: null,
+    theme: null,
+    siteId,
+    resolvedData: null,
+    sdkConfig: null
+  });
+  (0, import_react.useEffect)(() => {
+    let cancelled = false;
+    async function fetchPage() {
+      try {
+        const [site, pageResponse] = await Promise.all([
+          client.getSite({ id: siteId }),
+          client.getPage({ siteId, path, preview })
+        ]);
+        if (cancelled) return;
+        if ("entry" in pageResponse) {
+          throw new Error(
+            "This path resolves to a content entry, not a page. Use useContent() instead, which handles both pages and entries. For entries, useContent() returns the raw entry data for custom rendering."
+          );
+        }
+        const { page: pageData } = pageResponse;
+        const blocks = pageData.blocks.map((block) => {
+          if (!block || typeof block !== "object") {
+            throw new Error("Invalid block format in API response");
+          }
+          if (typeof block.id !== "string" && block.id !== null) {
+            throw new Error(`Invalid block id: expected string or null, got ${typeof block.id}`);
+          }
+          if (typeof block.kind !== "string") {
+            throw new Error(`Invalid block kind: expected string, got ${typeof block.kind}`);
+          }
+          if (typeof block.purpose !== "string") {
+            throw new Error(`Invalid block purpose: expected string, got ${typeof block.purpose}`);
+          }
+          return {
+            id: block.id,
+            kind: block.kind,
+            purpose: block.purpose
+          };
+        });
+        const pageOutline = {
+          name: pageData.name,
+          path: pageData.path,
+          purpose: pageData.purpose,
+          blocks
+        };
+        const resolvedData = await prefetchBlockData(
+          pageOutline,
+          {
+            siteId,
+            pageId: pageId ?? pageData.id,
+            previewStage: preview ? "preview" : "published"
+          },
+          client
+        );
+        if (cancelled) return;
+        setResult({
+          loading: false,
+          error: null,
+          page: pageOutline,
+          theme: site.theme,
+          siteId,
+          resolvedData,
+          sdkConfig: site.sdkConfig ?? null
+        });
+      } catch (error) {
+        if (cancelled) return;
+        setResult({
+          loading: false,
+          error: error instanceof Error ? error : new Error(String(error)),
+          page: null,
+          theme: null,
+          siteId,
+          resolvedData: null,
+          sdkConfig: null
+        });
+      }
+    }
+    fetchPage();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, siteId, path, pageId, preview]);
+  return result;
+}
+
+// src/rendering/hooks/useContent.ts
+var import_react2 = require("react");
+function isContentLoading(result) {
+  return result.loading === true;
+}
+function isContentError(result) {
+  return result.loading === false && result.error !== null;
+}
+function isPageContentResult(result) {
+  return result.loading === false && result.error === null && result.type === "page";
+}
+function isEntryContentResult(result) {
+  return result.loading === false && result.error === null && result.type === "entry";
+}
+function useContent(params) {
+  const { client, siteId, path, preview = false } = params;
+  const [result, setResult] = (0, import_react2.useState)({
+    loading: true,
+    error: null,
+    type: null,
+    page: null,
+    entry: null,
+    theme: null,
+    siteId,
+    resolvedData: null
+  });
+  (0, import_react2.useEffect)(() => {
+    let cancelled = false;
+    async function fetchContent() {
+      try {
+        const [site, contentResponse] = await Promise.all([
+          client.getSite({ id: siteId }),
+          client.getPage({ siteId, path, preview })
+        ]);
+        if (cancelled) return;
+        if (isEntryResponse(contentResponse)) {
+          const entryData = contentResponse.entry;
+          const entry = {
+            id: entryData.id,
+            type: entryData.type,
+            title: entryData.title,
+            slug: entryData.slug,
+            path: entryData.path,
+            status: entryData.status,
+            publishAt: entryData.publishAt,
+            content: preview ? entryData.draftContent ?? entryData.content : entryData.content,
+            metaTitle: preview ? entryData.draftMetaTitle ?? entryData.metaTitle : entryData.metaTitle,
+            metaDescription: preview ? entryData.draftMetaDescription ?? entryData.metaDescription : entryData.metaDescription,
+            createdAt: entryData.createdAt,
+            updatedAt: entryData.updatedAt
+          };
+          setResult({
+            loading: false,
+            error: null,
+            type: "entry",
+            page: null,
+            entry,
+            theme: site.theme,
+            siteId,
+            resolvedData: null
+          });
+          return;
+        }
+        const { page: pageData } = contentResponse;
+        const blocks = pageData.blocks.map((block) => {
+          if (!block || typeof block !== "object") {
+            throw new Error("Invalid block format in API response");
+          }
+          if (typeof block.id !== "string" && block.id !== null) {
+            throw new Error(`Invalid block id: expected string or null, got ${typeof block.id}`);
+          }
+          if (typeof block.kind !== "string") {
+            throw new Error(`Invalid block kind: expected string, got ${typeof block.kind}`);
+          }
+          if (typeof block.purpose !== "string") {
+            throw new Error(`Invalid block purpose: expected string, got ${typeof block.purpose}`);
+          }
+          return {
+            id: block.id,
+            kind: block.kind,
+            purpose: block.purpose
+          };
+        });
+        const pageOutline = {
+          name: pageData.name,
+          path: pageData.path,
+          purpose: pageData.purpose,
+          blocks
+        };
+        const resolvedData = await prefetchBlockData(
+          pageOutline,
+          {
+            siteId,
+            pageId: pageData.id,
+            previewStage: preview ? "preview" : "published"
+          },
+          client
+        );
+        if (cancelled) return;
+        setResult({
+          loading: false,
+          error: null,
+          type: "page",
+          page: pageOutline,
+          entry: null,
+          theme: site.theme,
+          siteId,
+          resolvedData
+        });
+      } catch (error) {
+        if (cancelled) return;
+        setResult({
+          loading: false,
+          error: error instanceof Error ? error : new Error(String(error)),
+          type: null,
+          page: null,
+          entry: null,
+          theme: null,
+          siteId,
+          resolvedData: null
+        });
+      }
+    }
+    fetchContent();
+    return () => {
+      cancelled = true;
+    };
+  }, [client, siteId, path, preview]);
+  return result;
+}
+function isEntryResponse(response) {
+  return "type" in response && response.type === "entry";
+}
+
+// src/rendering/components/Page.tsx
+var import_blocks = require("@riverbankcms/blocks");
+var import_jsx_runtime = require("react/jsx-runtime");
+function Page({
+  page,
+  theme,
+  themeTokens: providedTokens,
+  siteId,
+  resolvedData,
+  routeMap,
+  wrapBlock,
+  registry,
+  usePlaceholders = false,
+  blockOverrides,
+  sdkConfig,
+  dataContext
+}) {
+  const baseTokens = providedTokens ?? (0, import_blocks.buildThemeRuntime)(theme).tokens;
+  const themeTokens = sdkConfig?.theme?.palette ? { ...baseTokens, palette: { ...baseTokens.palette, ...sdkConfig.theme.palette } } : baseTokens;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    import_blocks.PageRenderer,
+    {
+      theme,
+      page,
+      themeTokens,
+      usePlaceholders,
+      dataContext: {
+        siteId,
+        resolvedData,
+        routes: routeMap,
+        occurrenceContext: dataContext?.occurrenceContext ?? null,
+        contentEntry: dataContext?.contentEntry ?? null
+      },
+      routeMap,
+      wrapBlock,
+      registry,
+      blockOverrides,
+      sdkConfig
+    }
+  );
+}
+
+// src/client/index.ts
+var import_api = require("@riverbankcms/api");
+
+// src/client/cache.ts
+var SimpleCache = class {
+  constructor(options = {}) {
+    this.cache = /* @__PURE__ */ new Map();
+    this.maxSize = options.maxSize ?? 100;
+    this.ttl = options.ttl ?? 3e5;
+  }
+  get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) return void 0;
+    if (Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry.value;
+  }
+  set(key, value) {
+    if (this.cache.size >= this.maxSize) {
+      const firstKey = this.cache.keys().next().value;
+      if (firstKey) {
+        this.cache.delete(firstKey);
+      }
+    }
+    this.cache.set(key, {
+      value,
+      expires: Date.now() + this.ttl
+    });
+  }
+  clear() {
+    this.cache.clear();
+  }
+  has(key) {
+    return this.get(key) !== void 0;
+  }
+};
+
+// src/client/index.ts
+function createRiverbankClient(config) {
+  if (!config.baseUrl) {
+    throw new Error(
+      "baseUrl is required when creating a Builder client. Expected format: https://dashboard.example.com/api (must include /api path)"
+    );
+  }
+  if (!config.baseUrl.endsWith("/api")) {
+    throw new Error(
+      `baseUrl must end with '/api'. Received: ${config.baseUrl}. Expected format: https://dashboard.example.com/api`
+    );
+  }
+  const cacheEnabled = config.cache?.enabled ?? true;
+  const cacheTTL = (config.cache?.ttl ?? 300) * 1e3;
+  const cacheMaxSize = config.cache?.maxSize ?? 100;
+  const apiClient = (0, import_api.createBearerAPIClient)(config.apiKey, config.baseUrl);
+  const cache = new SimpleCache({
+    maxSize: cacheMaxSize,
+    ttl: cacheTTL
+  });
+  async function cachedFetch(cacheKey, fetcher, options) {
+    if (cacheEnabled && !options?.force) {
+      const cached = cache.get(cacheKey);
+      if (cached !== void 0) {
+        return cached;
+      }
+    }
+    const data = await fetcher();
+    if (cacheEnabled) {
+      cache.set(cacheKey, data);
+    }
+    return data;
+  }
+  return {
+    async getSite(params) {
+      const { slug, domain, id } = params;
+      if (!slug && !domain && !id) {
+        throw new Error(
+          `getSite() requires at least one identifier: slug, domain, or id. Received: ${JSON.stringify(params)}`
+        );
+      }
+      const cacheKey = `site:${slug || domain || id}`;
+      return cachedFetch(cacheKey, async () => {
+        const apiParams = {};
+        if (params.slug) apiParams.slug = params.slug;
+        if (params.domain) apiParams.domain = params.domain;
+        if (params.id) apiParams.id = params.id;
+        return await apiClient({ endpoint: "getSite", params: apiParams });
+      });
+    },
+    async getPage(params) {
+      const { siteId, path, preview = false } = params;
+      const cacheKey = `page:${siteId}:${path}:${preview}`;
+      return cachedFetch(cacheKey, async () => {
+        return await apiClient({ endpoint: "getContentByPath", params: { siteId }, body: { path, preview } });
+      });
+    },
+    async getEntries(params) {
+      const { siteId, contentType, limit, order, preview = false, mode, entryIds } = params;
+      const entryIdsCacheKey = mode === "manual" && entryIds?.length ? entryIds.join(",") : "";
+      const cacheKey = `entries:${siteId}:${contentType}:${limit ?? ""}:${order ?? ""}:${preview}:${mode ?? ""}:${entryIdsCacheKey}`;
+      return cachedFetch(cacheKey, async () => {
+        const apiParams = {
+          siteId,
+          type: contentType
+        };
+        if (typeof limit === "number") {
+          apiParams.limit = String(limit);
+        }
+        if (order === "newest") {
+          apiParams.order = "published_at.desc";
+        } else if (order === "oldest") {
+          apiParams.order = "published_at.asc";
+        } else if (order === "title") {
+          apiParams.order = "title.asc";
+        }
+        if (preview) {
+          apiParams.stage = "preview";
+        }
+        if (mode === "manual" && entryIds?.length) {
+          apiParams.mode = "manual";
+          apiParams.entryIds = JSON.stringify(entryIds);
+        }
+        return await apiClient({ endpoint: "listPublishedEntries", params: apiParams });
+      });
+    },
+    async getEntry(params) {
+      const { siteId, contentType, slug } = params;
+      const cacheKey = `entry:${siteId}:${contentType}:${slug}`;
+      return cachedFetch(cacheKey, async () => {
+        return await apiClient({ endpoint: "getPublishedEntryPreview", params: { siteId, type: contentType, slug } });
+      });
+    },
+    async getPublicFormById(params) {
+      const { formId } = params;
+      if (!formId) {
+        throw new Error("getPublicFormById() requires formId");
+      }
+      const cacheKey = `public-form:${formId}`;
+      return cachedFetch(cacheKey, async () => {
+        return await apiClient({ endpoint: "getPublicFormById", params: { formId } });
+      });
+    },
+    async getPublicBookingServices(params) {
+      const { siteId, ids } = params;
+      if (!siteId) {
+        throw new Error("getPublicBookingServices() requires siteId");
+      }
+      const cacheKey = `public-booking-services:${siteId}:${ids ?? ""}`;
+      return cachedFetch(cacheKey, async () => {
+        const apiParams = { siteId };
+        if (ids) apiParams.ids = ids;
+        return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams });
+      });
+    },
+    async listPublicEvents(params) {
+      const { siteId, limit, from, to, stage } = params;
+      if (!siteId) {
+        throw new Error("listPublicEvents() requires siteId");
+      }
+      const cacheKey = `public-events:${siteId}:${limit ?? ""}:${from ?? ""}:${to ?? ""}:${stage ?? ""}`;
+      return cachedFetch(cacheKey, async () => {
+        const apiParams = { siteId };
+        if (typeof limit === "number") apiParams.limit = String(limit);
+        if (from) apiParams.from = from;
+        if (to) apiParams.to = to;
+        if (stage) apiParams.stage = stage;
+        return await apiClient({ endpoint: "listPublicEvents", params: apiParams });
+      });
+    },
+    clearCache() {
+      cache.clear();
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Page,
+  createRiverbankClient,
+  isContentError,
+  isContentLoading,
+  isEntryContentResult,
+  isPageContentResult,
+  useContent,
+  usePage
+});
+//# sourceMappingURL=client.js.map