@riverbankcms/sdk 0.4.3 → 0.5.1

package/dist/server/{chunk-ES6QDZUX.mjs → chunk-C6FIJC7T.mjs}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-A2FZMRDW.mjs";
 import {
   prefetchBlockData
-} from "./chunk-7DS4Q3GA.mjs";
+} from "./chunk-AEFWG657.mjs";
 
 // src/rendering/helpers/loadPage.ts
 async function loadPage(params) {
@@ -85,4 +85,4 @@ async function loadPage(params) {
 export {
   loadPage
 };
-//# sourceMappingURL=chunk-ES6QDZUX.mjs.map
+//# sourceMappingURL=chunk-C6FIJC7T.mjs.map

package/dist/server/{chunk-N3PX76AP.mjs → chunk-CMABGYGI.mjs}

@@ -182,6 +182,28 @@ var ENDPOINT_DEFINITIONS = {
     tags: ["site-{siteId}", "api-keys", "access-logs"],
     responseKind: "json"
   },
+  // Management API Keys (SDK write operations)
+  listManagementKeys: {
+    path: "/sites/{siteId}/api-keys/management",
+    method: "GET",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "management-keys"],
+    responseKind: "json"
+  },
+  createManagementKey: {
+    path: "/sites/{siteId}/api-keys/management",
+    method: "POST",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "management-keys"],
+    responseKind: "json"
+  },
+  revokeManagementKey: {
+    path: "/sites/{siteId}/api-keys/management",
+    method: "DELETE",
+    auth: "user",
+    tags: ["site-{siteId}", "api-keys", "management-keys"],
+    responseKind: "json"
+  },
   getBookingSettings: {
     path: "/sites/{siteId}/bookings/settings",
     method: "GET",
@@ -1457,6 +1479,15 @@ var ENDPOINT_DEFINITIONS = {
     auth: "public",
     responseKind: "json"
   },
+  // Resolve event occurrence by URL segment (date or UUID)
+  resolveEventOccurrence: {
+    path: "/public/sites/{siteId}/events/occurrences/resolve",
+    method: "GET",
+    revalidate: 60,
+    tags: ["public-events-{siteId}", "event-occurrence"],
+    auth: "public",
+    responseKind: "json"
+  },
   // Public event registration
   registerForEvent: {
     path: "/public/sites/{siteId}/events/register",
@@ -1634,6 +1665,20 @@ if (typeof window === "undefined") {
     revalidateTag = null;
   }
 }
+var sdkVersion;
+function generateRequestId() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+function setSdkVersion(version) {
+  sdkVersion = version;
+}
 var ApiRequestError = class extends Error {
   constructor(message, options) {
     super(message);
@@ -1645,6 +1690,7 @@ var ApiRequestError = class extends Error {
     this.requestId = options.requestId;
     this.body = options.body;
     this.cause = options.cause;
+    this.errorCode = options.errorCode;
   }
 };
 function buildEndpointURL2(baseURL, endpoint) {
@@ -1681,6 +1727,29 @@ async function parseErrorBody(response) {
     return null;
   }
 }
+function buildSuccessEnvelope(data, requestId) {
+  return {
+    success: true,
+    data,
+    meta: {
+      requestId: requestId ?? generateRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      apiVersion: "2025-01-01"
+    }
+  };
+}
+function buildErrorEnvelope(code, message, status, requestId) {
+  return {
+    success: false,
+    error: {
+      code,
+      message,
+      requestId: requestId ?? generateRequestId(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      status
+    }
+  };
+}
 async function parseSuccessResponse(endpoint, response, config) {
   const responseKind = config.responseKind ?? "json";
   const auth = config.auth ?? "user";
@@ -1688,14 +1757,15 @@ async function parseSuccessResponse(endpoint, response, config) {
   switch (responseKind) {
     case "json": {
       if (response.status === 204 || response.status === 205 || response.status === 304) {
-        return void 0;
+        return buildSuccessEnvelope(void 0, requestId);
       }
       const raw = await response.text();
       if (!raw.trim()) {
-        return void 0;
+        return buildSuccessEnvelope(void 0, requestId);
       }
+      let parsed;
       try {
-        return JSON.parse(raw);
+        parsed = JSON.parse(raw);
       } catch (cause) {
         throw new ApiRequestError(
           `Failed to parse JSON response for endpoint ${String(endpoint)}`,
@@ -1710,32 +1780,33 @@ async function parseSuccessResponse(endpoint, response, config) {
           }
         );
       }
+      if (parsed && typeof parsed === "object" && "success" in parsed && typeof parsed.success === "boolean") {
+        return parsed;
+      }
+      return buildSuccessEnvelope(parsed, requestId);
     }
     case "text": {
-      return await response.text();
+      const text = await response.text();
+      return buildSuccessEnvelope(text, requestId);
     }
     case "stream": {
       const body = response.body;
       if (!body) {
-        throw new ApiRequestError(
+        return buildErrorEnvelope(
+          "server:internal_error",
           `Expected a streamed body for endpoint ${String(endpoint)}`,
-          {
-            endpoint,
-            status: response.status,
-            method: config.method,
-            auth,
-            requestId
-          }
+          response.status,
+          requestId
         );
       }
       const stream = body;
-      return stream;
+      return buildSuccessEnvelope(stream, requestId);
     }
     case "void": {
-      return void 0;
+      return buildSuccessEnvelope(void 0, requestId);
     }
     default: {
-      return void 0;
+      return buildSuccessEnvelope(void 0, requestId);
     }
   }
 }
@@ -1801,11 +1872,15 @@ function createRawCMSClient(headers = {}, baseUrl) {
     const requestInit = {
       method,
       ...options,
+      // Include credentials for same-origin requests (sends cookies for auth)
+      credentials: "same-origin",
       // Don't include body for GET/HEAD requests
       body: isGetOrHead ? void 0 : isFormData ? body : body ? JSON.stringify(body) : void 0,
       headers: {
         ...options.headers,
         ...headers,
+        // Include SDK version if set
+        ...sdkVersion && { "x-sdk-version": sdkVersion },
         // Don't set Content-Type for GET/HEAD requests without body
         ...isGetOrHead ? {} : isFormData ? {} : { "Content-Type": "application/json" }
       },
@@ -1859,94 +1934,30 @@ function createBearerAPIClient(token, baseUrl) {
   return createCMSClient(authHeaders, baseUrl);
 }
 
-// ../api/src/aiPlayground.ts
-import { z } from "zod";
-var Rfc6902PatchOp = z.discriminatedUnion("op", [
-  // Standard RFC-6902 operations
-  z.object({
-    op: z.literal("add"),
-    path: z.string(),
-    value: z.unknown()
-  }),
-  z.object({
-    op: z.literal("remove"),
-    path: z.string()
-  }),
-  z.object({
-    op: z.literal("replace"),
-    path: z.string(),
-    value: z.unknown()
-  }),
-  z.object({
-    op: z.literal("move"),
-    from: z.string(),
-    path: z.string()
-  }),
-  z.object({
-    op: z.literal("copy"),
-    from: z.string(),
-    path: z.string()
-  }),
-  // Block-level operations (Phase 2)
-  z.object({
-    op: z.literal("add_block"),
-    blockKind: z.string(),
-    afterBlockId: z.string().nullable(),
-    content: z.record(z.string(), z.unknown()),
-    rationale: z.string()
-  }),
-  z.object({
-    op: z.literal("delete_block"),
-    blockId: z.string(),
-    rationale: z.string()
-  }),
-  z.object({
-    op: z.literal("reorder_block"),
-    blockId: z.string(),
-    afterBlockId: z.string().nullable(),
-    rationale: z.string()
-  })
-]);
-var PatchEnvelope = z.object({
-  blockId: z.string(),
-  blockKind: z.string().optional(),
-  blockPurpose: z.string().optional().nullable(),
-  ops: z.array(Rfc6902PatchOp),
-  rationale: z.string(),
-  currentContent: z.record(z.string(), z.unknown()).optional()
-});
-var ContentUpdateResponse = z.object({
-  patches: z.array(PatchEnvelope),
-  assistantMessage: z.string()
-});
-var PlaygroundProposeRequest = z.object({
-  request: z.string().min(1).max(2e3)
-});
-var PlaygroundProposeResponse = z.object({
-  patches: z.array(PatchEnvelope),
-  assistantMessage: z.string(),
-  validation: z.object({
-    valid: z.boolean(),
-    issues: z.array(z.string()),
-    filtered: z.number()
-  })
-});
-var MultiPagePatchEnvelope = z.object({
-  pageId: z.string(),
-  blockId: z.string().optional(),
-  // Not present for page-level ops
-  blockKind: z.string().optional(),
-  blockPurpose: z.string().optional().nullable(),
-  ops: z.array(Rfc6902PatchOp),
-  rationale: z.string(),
-  currentContent: z.record(z.string(), z.unknown()).optional()
-});
-var MultiPageUpdateResponse = z.object({
-  patches: z.array(MultiPagePatchEnvelope),
-  assistantMessage: z.string(),
-  pagesModified: z.number(),
-  toolCallsUsed: z.number()
-});
+// ../api/src/common/envelope.ts
+function isApiError(result) {
+  return result.success === false;
+}
+function isApiSuccess(result) {
+  return result.success === true;
+}
+var ApiEnvelopeError = class extends Error {
+  constructor(error) {
+    super(error.message);
+    this.name = "ApiEnvelopeError";
+    this.code = error.code;
+    this.requestId = error.requestId;
+    this.timestamp = error.timestamp;
+    this.status = error.status;
+    this.fieldErrors = error.fieldErrors;
+  }
+};
+function unwrapResponse(result) {
+  if (isApiSuccess(result)) {
+    return result.data;
+  }
+  throw new ApiEnvelopeError(result.error);
+}
 
 // src/client/cache.ts
 var SimpleCache = class {
@@ -1984,7 +1995,100 @@ var SimpleCache = class {
   }
 };
 
+// src/version.ts
+var SDK_VERSION = "0.5.0";
+
+// src/client/error.ts
+var RiverbankApiError = class _RiverbankApiError extends Error {
+  constructor(apiError) {
+    super(apiError.message);
+    this.name = "RiverbankApiError";
+    this.code = apiError.code;
+    this.requestId = apiError.requestId;
+    this.status = apiError.status;
+    this.fieldErrors = apiError.fieldErrors;
+    this.timestamp = apiError.timestamp;
+    Object.setPrototypeOf(this, _RiverbankApiError.prototype);
+  }
+  /**
+   * Check if this error matches a specific error code
+   *
+   * @example
+   * ```ts
+   * if (error.is('auth:unauthenticated')) {
+   *   // Redirect to login
+   * }
+   * ```
+   */
+  is(code) {
+    return this.code === code;
+  }
+  /**
+   * Check if this is an authentication or authorization error
+   *
+   * Matches: auth:unauthenticated, auth:token_expired, auth:token_invalid,
+   * auth:forbidden, auth:mfa_required, auth:insufficient_permissions
+   */
+  isAuthError() {
+    return this.code.startsWith("auth:");
+  }
+  /**
+   * Check if this is a validation error
+   *
+   * Matches: validation:invalid_input, validation:missing_field, validation:invalid_format
+   */
+  isValidationError() {
+    return this.code.startsWith("validation:");
+  }
+  /**
+   * Check if this is a resource error (not found, conflict, etc.)
+   *
+   * Matches: resource:not_found, resource:already_exists, resource:conflict, resource:gone
+   */
+  isResourceError() {
+    return this.code.startsWith("resource:");
+  }
+  /**
+   * Check if this is a rate limiting error
+   */
+  isRateLimitError() {
+    return this.code.startsWith("rate_limit:");
+  }
+  /**
+   * Check if this is a billing/payment error
+   */
+  isBillingError() {
+    return this.code.startsWith("billing:");
+  }
+  /**
+   * Check if this is a server error
+   */
+  isServerError() {
+    return this.code.startsWith("server:");
+  }
+};
+
 // src/client/index.ts
+setSdkVersion(SDK_VERSION);
+function convertToTypedError(error) {
+  if (error instanceof ApiEnvelopeError) {
+    throw new RiverbankApiError({
+      code: error.code,
+      message: error.message,
+      requestId: error.requestId,
+      timestamp: error.timestamp,
+      status: error.status,
+      fieldErrors: error.fieldErrors
+    });
+  }
+  if (error instanceof ApiRequestError && error.body && typeof error.body === "object") {
+    const body = error.body;
+    if (isApiError(body)) {
+      throw new RiverbankApiError(body.error);
+    }
+  }
+  throw error;
+}
 function createRiverbankClient(config) {
   if (!config.baseUrl) {
     throw new Error(
@@ -2011,7 +2115,13 @@ function createRiverbankClient(config) {
         return cached;
       }
     }
-    const data = await fetcher();
+    let data;
+    try {
+      const response = await fetcher();
+      data = unwrapResponse(response);
+    } catch (error) {
+      convertToTypedError(error);
+    }
     if (cacheEnabled) {
       cache.set(cacheKey, data);
     }
@@ -2046,33 +2156,27 @@ function createRiverbankClient(config) {
       const entryIdsCacheKey = mode === "manual" && entryIds?.length ? entryIds.join(",") : "";
       const cacheKey = `entries:${siteId}:${contentType}:${limit ?? ""}:${offset ?? ""}:${order ?? ""}:${preview}:${mode ?? ""}:${entryIdsCacheKey}:${includeMeta ?? ""}`;
       return cachedFetch(cacheKey, async () => {
-        const apiParams = {
-          siteId,
-          type: contentType
-        };
-        if (typeof limit === "number") {
-          apiParams.limit = String(limit);
-        }
-        if (typeof offset === "number") {
-          apiParams.offset = String(offset);
-        }
-        if (includeMeta) {
-          apiParams.meta = "true";
-        }
+        let orderParam;
         if (order === "newest") {
-          apiParams.order = "published_at.desc";
+          orderParam = "published_at.desc";
         } else if (order === "oldest") {
-          apiParams.order = "published_at.asc";
+          orderParam = "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);
+          orderParam = "title.asc";
         }
+        const apiParams = {
+          siteId,
+          type: contentType,
+          ...typeof limit === "number" && { limit: String(limit) },
+          ...typeof offset === "number" && { offset: String(offset) },
+          ...includeMeta && { meta: "true" },
+          ...orderParam && { order: orderParam },
+          ...preview && { stage: "preview" },
+          ...mode === "manual" && entryIds?.length && {
+            mode: "manual",
+            entryIds: JSON.stringify(entryIds)
+          }
+        };
         return await apiClient({ endpoint: "listPublishedEntries", params: apiParams });
       });
     },
@@ -2100,8 +2204,10 @@ function createRiverbankClient(config) {
       }
       const cacheKey = `public-booking-services:${siteId}:${ids ?? ""}`;
       return cachedFetch(cacheKey, async () => {
-        const apiParams = { siteId };
-        if (ids) apiParams.ids = ids;
+        const apiParams = {
+          siteId,
+          ...ids && { ids }
+        };
         return await apiClient({ endpoint: "getPublicBookingServices", params: apiParams });
       });
     },
@@ -2112,14 +2218,42 @@ function createRiverbankClient(config) {
       }
       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;
+        const apiParams = {
+          siteId,
+          ...typeof limit === "number" && { limit: String(limit) },
+          ...from && { from },
+          ...to && { to },
+          ...stage && { stage }
+        };
         return await apiClient({ endpoint: "listPublicEvents", params: apiParams });
       });
     },
+    async resolveEventOccurrence(params) {
+      const { siteId, entryId, segment } = params;
+      if (!siteId || !entryId || !segment) {
+        throw new Error("resolveEventOccurrence() requires siteId, entryId, and segment");
+      }
+      const cacheKey = `event-occurrence:${siteId}:${entryId}:${segment}`;
+      return cachedFetch(cacheKey, async () => {
+        return await apiClient({
+          endpoint: "resolveEventOccurrence",
+          params: { siteId, entryId, segment }
+        });
+      });
+    },
+    async checkRedirect(params) {
+      const { siteId, path } = params;
+      if (!siteId || !path) {
+        throw new Error("checkRedirect() requires siteId and path");
+      }
+      const cacheKey = `redirect:${siteId}:${path}`;
+      return cachedFetch(cacheKey, async () => {
+        return await apiClient({
+          endpoint: "checkRedirect",
+          params: { site: siteId, path }
+        });
+      });
+    },
     clearCache() {
       cache.clear();
     }
@@ -2133,4 +2267,4 @@ export {
   buildEndpointURL,
   createRiverbankClient
 };
-//# sourceMappingURL=chunk-N3PX76AP.mjs.map
+//# sourceMappingURL=chunk-CMABGYGI.mjs.map