@01.software/sdk 0.29.0 → 0.31.0

package/dist/client.cjs

@@ -0,0 +1,1541 @@
+"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, {
+  Client: () => Client,
+  createClient: () => createClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/core/collection/http-client.ts
+var import_qs_esm = require("qs-esm");
+
+// src/core/internal/errors/index.ts
+var SDKError = class extends Error {
+  constructor(code, message, status, details, userMessage, suggestion, requestId) {
+    super(message);
+    this.name = "SDKError";
+    this.code = code;
+    this.status = status;
+    this.details = details;
+    this.userMessage = userMessage;
+    this.suggestion = suggestion;
+    this.requestId = requestId;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+  getUserMessage() {
+    return this.userMessage || this.message;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      code: this.code,
+      message: this.message,
+      status: this.status,
+      details: this.details,
+      userMessage: this.userMessage,
+      suggestion: this.suggestion,
+      ...this.requestId !== void 0 && { requestId: this.requestId }
+    };
+  }
+};
+var NetworkError = class extends SDKError {
+  constructor(message, status, details, userMessage, suggestion) {
+    super("NETWORK_ERROR", message, status, details, userMessage, suggestion);
+    this.name = "NetworkError";
+  }
+};
+var ValidationError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, status = 400) {
+    super("VALIDATION_ERROR", message, status, details, userMessage, suggestion);
+    this.name = "ValidationError";
+  }
+};
+var ApiError = class extends SDKError {
+  constructor(message, status, details, userMessage, suggestion, requestId) {
+    super(
+      "API_ERROR",
+      message,
+      status,
+      details,
+      userMessage,
+      suggestion,
+      requestId
+    );
+    this.name = "ApiError";
+  }
+};
+var ConfigError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion) {
+    super("CONFIG_ERROR", message, void 0, details, userMessage, suggestion);
+    this.name = "ConfigError";
+  }
+};
+var TimeoutError = class extends SDKError {
+  constructor(message = "Request timed out.", details, userMessage, suggestion) {
+    super("TIMEOUT_ERROR", message, 408, details, userMessage, suggestion);
+    this.name = "TimeoutError";
+  }
+};
+var UsageLimitError = class extends SDKError {
+  constructor(message, usage, details, userMessage, suggestion) {
+    super("USAGE_LIMIT_ERROR", message, 429, details, userMessage, suggestion);
+    this.name = "UsageLimitError";
+    this.usage = usage;
+  }
+  toJSON() {
+    return {
+      ...super.toJSON(),
+      usage: this.usage
+    };
+  }
+};
+var AuthError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super(
+      "auth_error",
+      message,
+      401,
+      details,
+      userMessage,
+      suggestion,
+      requestId
+    );
+    this.name = "AuthError";
+  }
+};
+var PermissionError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super(
+      "permission_error",
+      message,
+      403,
+      details,
+      userMessage,
+      suggestion,
+      requestId
+    );
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super(
+      "not_found",
+      message,
+      404,
+      details,
+      userMessage,
+      suggestion,
+      requestId
+    );
+    this.name = "NotFoundError";
+  }
+};
+var ConflictError = class extends SDKError {
+  constructor(message, details, userMessage, suggestion, requestId) {
+    super("conflict", message, 409, details, userMessage, suggestion, requestId);
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends SDKError {
+  constructor(message, retryAfter, details, userMessage, suggestion, requestId) {
+    super(
+      "rate_limit_exceeded",
+      message,
+      429,
+      details,
+      userMessage,
+      suggestion,
+      requestId
+    );
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var createNetworkError = (message, status, details, userMessage, suggestion) => new NetworkError(message, status, details, userMessage, suggestion);
+var createValidationError = (message, details, userMessage, suggestion, status) => new ValidationError(message, details, userMessage, suggestion, status);
+var createApiError = (message, status, details, userMessage, suggestion, requestId) => new ApiError(message, status, details, userMessage, suggestion, requestId);
+var createConfigError = (message, details, userMessage, suggestion) => new ConfigError(message, details, userMessage, suggestion);
+var createTimeoutError = (message, details, userMessage, suggestion) => new TimeoutError(message, details, userMessage, suggestion);
+var createUsageLimitError = (message, usage, details, userMessage, suggestion) => new UsageLimitError(message, usage, details, userMessage, suggestion);
+var createAuthError = (message, details, userMessage, suggestion, requestId) => new AuthError(message, details, userMessage, suggestion, requestId);
+var createPermissionError = (message, details, userMessage, suggestion, requestId) => new PermissionError(message, details, userMessage, suggestion, requestId);
+var createNotFoundError = (message, details, userMessage, suggestion, requestId) => new NotFoundError(message, details, userMessage, suggestion, requestId);
+var createConflictError = (message, details, userMessage, suggestion, requestId) => new ConflictError(message, details, userMessage, suggestion, requestId);
+var createRateLimitError = (message, retryAfter, details, userMessage, suggestion, requestId) => new RateLimitError(
+  message,
+  retryAfter,
+  details,
+  userMessage,
+  suggestion,
+  requestId
+);
+
+// src/core/internal/utils/credentials.ts
+function requirePublishableKeyForSecret(apiName, publishableKey, secretKey) {
+  if (secretKey && !publishableKey) {
+    throw createConfigError(
+      `publishableKey is required for ${apiName} when secretKey is used. It is sent as X-Publishable-Key for tenant routing, rate limiting, and quota enforcement.`
+    );
+  }
+  return publishableKey ?? "";
+}
+
+// src/core/client/types.ts
+function resolveApiUrl(apiUrl) {
+  if (apiUrl) {
+    return apiUrl.replace(/\/$/, "");
+  }
+  if (typeof process !== "undefined" && process.env) {
+    const envUrl = process.env.SOFTWARE_API_URL || process.env.NEXT_PUBLIC_SOFTWARE_API_URL;
+    if (envUrl) {
+      return envUrl.replace(/\/$/, "");
+    }
+  }
+  return "https://api.01.software";
+}
+
+// src/core/internal/utils/http.ts
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RETRYABLE_STATUSES = [408, 429, 500, 502, 503, 504];
+var NON_RETRYABLE_STATUSES = [400, 401, 403, 404, 409, 422];
+var SAFE_METHODS = ["GET", "HEAD", "OPTIONS"];
+function debugLog(debug, type, message, data) {
+  if (!debug) return;
+  const shouldLog = debug === true || type === "request" && debug.logRequests || type === "response" && debug.logResponses || type === "error" && debug.logErrors;
+  if (shouldLog) {
+    console.group(`[SDK ${type.toUpperCase()}] ${message}`);
+    if (data) console.log(data);
+    console.groupEnd();
+  }
+}
+function redactSensitiveHeader(value) {
+  const prefix = value.toLowerCase().startsWith("bearer ") ? "Bearer " : "";
+  return value.length > 20 ? `${prefix}...****${value.slice(-8)}` : "****";
+}
+function redactSensitiveHeaders(headers) {
+  const redacted = Object.fromEntries(headers.entries());
+  if (redacted.authorization) {
+    redacted.authorization = redactSensitiveHeader(redacted.authorization);
+  }
+  if (redacted["x-preview-token"]) {
+    redacted["x-preview-token"] = redactSensitiveHeader(
+      redacted["x-preview-token"]
+    );
+  }
+  return redacted;
+}
+function getErrorSuggestion(status) {
+  if (status === 400)
+    return "The request data failed validation. Check field values and types.";
+  if (status === 401) return "Please check your authentication credentials.";
+  if (status === 403)
+    return "Access denied. Check your credentials or permissions.";
+  if (status === 404) return "The requested resource was not found.";
+  if (status === 422) return "The request data failed validation.";
+  if (status >= 500) return "A server error occurred. Please try again later.";
+  return void 0;
+}
+function isUsageLimitExceededResponse(response) {
+  if (response.status !== 429) return false;
+  const limit = parseInt(response.headers.get("X-Usage-Limit") || "", 10);
+  const current = parseInt(response.headers.get("X-Usage-Current") || "", 10);
+  if (!Number.isFinite(limit) || !Number.isFinite(current)) return false;
+  return response.headers.get("X-Usage-Exceeded") === "true" || current > limit;
+}
+async function parseErrorBody(response) {
+  const fallback = {
+    errorMessage: `HTTP ${response.status}: ${response.statusText}`,
+    userMessage: `Request failed (status: ${response.status})`
+  };
+  try {
+    const body = await response.json();
+    const reason = typeof body.reason === "string" ? body.reason : typeof body.code === "string" ? body.code : void 0;
+    if (body.errors && Array.isArray(body.errors)) {
+      const fieldErrors = [];
+      for (const e of body.errors) {
+        if (e.data?.errors && Array.isArray(e.data.errors) && e.data.errors.length > 0) {
+          for (const fe of e.data.errors) {
+            fieldErrors.push({
+              field: fe.path || fe.field,
+              message: fe.message
+            });
+          }
+        } else if (e.field || e.message) {
+          fieldErrors.push({ field: e.field, message: e.message });
+        }
+      }
+      const details = (fieldErrors.length > 0 ? fieldErrors : body.errors).map(
+        (e) => e.field ? `${e.field}: ${e.message}` : e.message
+      ).filter(Boolean).join("; ");
+      if (details) {
+        return {
+          errorMessage: `HTTP ${response.status}: ${details}`,
+          userMessage: details,
+          reason,
+          body,
+          errors: fieldErrors.length > 0 ? fieldErrors : body.errors
+        };
+      }
+    }
+    if (typeof body.error === "string") {
+      return {
+        errorMessage: `HTTP ${response.status}: ${body.error}`,
+        userMessage: body.error,
+        reason,
+        body
+      };
+    }
+    if (body.message) {
+      return {
+        errorMessage: `HTTP ${response.status}: ${body.message}`,
+        userMessage: body.message,
+        reason,
+        body
+      };
+    }
+    return { ...fallback, reason, body };
+  } catch {
+    return fallback;
+  }
+}
+function getParsedErrorSuggestion(status, parsed) {
+  if (status === 403 && parsed.reason === "origin_not_allowed") {
+    return "Add the request origin to the tenant Browser API origins, then retry the browser request.";
+  }
+  return getErrorSuggestion(status);
+}
+async function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function attachRequestId(err, id) {
+  if (id) err.requestId = id;
+  return err;
+}
+function createHttpStatusError(status, parsed, details, requestId) {
+  const errorDetails = {
+    ...details,
+    ...parsed.errors && { errors: parsed.errors },
+    ...parsed.body && { body: parsed.body }
+  };
+  const suggestion = getParsedErrorSuggestion(status, parsed);
+  if (status === 400 || status === 422) {
+    return attachRequestId(
+      createValidationError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion,
+        status
+      ),
+      requestId
+    );
+  }
+  if (status === 401) {
+    return attachRequestId(
+      createAuthError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 403) {
+    return attachRequestId(
+      createPermissionError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 404) {
+    return attachRequestId(
+      createNotFoundError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  if (status === 409) {
+    return attachRequestId(
+      createConflictError(
+        parsed.errorMessage,
+        errorDetails,
+        parsed.userMessage,
+        suggestion
+      ),
+      requestId
+    );
+  }
+  return attachRequestId(
+    createNetworkError(
+      parsed.errorMessage,
+      status,
+      errorDetails,
+      parsed.userMessage,
+      suggestion
+    ),
+    requestId
+  );
+}
+async function httpFetch(url, options) {
+  const {
+    apiUrl,
+    publishableKey,
+    secretKey,
+    customerToken,
+    timeout = DEFAULT_TIMEOUT,
+    debug,
+    retry,
+    onUnauthorized,
+    ...requestInit
+  } = options || {};
+  const baseUrl = resolveApiUrl(apiUrl);
+  const retryConfig = {
+    maxRetries: retry?.maxRetries ?? 3,
+    retryableStatuses: retry?.retryableStatuses ?? DEFAULT_RETRYABLE_STATUSES,
+    retryDelay: retry?.retryDelay ?? ((attempt) => Math.min(1e3 * 2 ** attempt, 1e4))
+  };
+  let authToken;
+  if (secretKey) {
+    authToken = secretKey;
+  } else if (customerToken) {
+    authToken = customerToken;
+  }
+  let lastError;
+  let hasRetried401 = false;
+  for (let attempt = 0; attempt <= retryConfig.maxRetries; attempt++) {
+    try {
+      const headers = new Headers(requestInit.headers);
+      if (publishableKey) {
+        headers.set("X-Publishable-Key", publishableKey);
+      }
+      if (authToken) {
+        headers.set("Authorization", `Bearer ${authToken}`);
+      }
+      if (!headers.has("Content-Type") && requestInit.body && !(requestInit.body instanceof FormData)) {
+        headers.set("Content-Type", "application/json");
+      }
+      const redactedHeaders = redactSensitiveHeaders(headers);
+      debugLog(debug, "request", url, {
+        method: requestInit.method || "GET",
+        headers: redactedHeaders,
+        attempt: attempt + 1
+      });
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(`${baseUrl}${url}`, {
+        ...requestInit,
+        headers,
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      const requestId = response.headers.get("x-request-id") ?? void 0;
+      debugLog(debug, "response", url, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: redactSensitiveHeaders(response.headers)
+      });
+      if (!response.ok) {
+        if (isUsageLimitExceededResponse(response)) {
+          const limit = parseInt(
+            response.headers.get("X-Usage-Limit") || "0",
+            10
+          );
+          const current = parseInt(
+            response.headers.get("X-Usage-Current") || "0",
+            10
+          );
+          const remaining = parseInt(
+            response.headers.get("X-Usage-Remaining") || "0",
+            10
+          );
+          throw attachRequestId(
+            createUsageLimitError(
+              `Monthly API usage limit exceeded (${current.toLocaleString()}/${limit.toLocaleString()})`,
+              { limit, current, remaining },
+              {
+                url,
+                method: requestInit.method || "GET",
+                attempt: attempt + 1
+              },
+              "Monthly API call limit exceeded. Please upgrade your plan.",
+              "Upgrade your tenant plan to increase the monthly API call limit."
+            ),
+            requestId
+          );
+        }
+        const parsed = await parseErrorBody(response);
+        if (response.status === 401 && onUnauthorized && customerToken && !hasRetried401 && parsed.reason === "token_expired") {
+          hasRetried401 = true;
+          try {
+            const newToken = await onUnauthorized();
+            if (newToken) {
+              authToken = newToken;
+              continue;
+            }
+          } catch {
+          }
+        }
+        const details = {
+          url,
+          method: requestInit.method || "GET",
+          attempt: attempt + 1
+        };
+        if (NON_RETRYABLE_STATUSES.includes(response.status)) {
+          throw createHttpStatusError(
+            response.status,
+            parsed,
+            details,
+            requestId
+          );
+        }
+        const error = attachRequestId(
+          createNetworkError(
+            parsed.errorMessage,
+            response.status,
+            details,
+            parsed.userMessage,
+            getErrorSuggestion(response.status)
+          ),
+          requestId
+        );
+        const method = (requestInit.method || "GET").toUpperCase();
+        if (attempt < retryConfig.maxRetries && SAFE_METHODS.includes(method) && retryConfig.retryableStatuses.includes(response.status)) {
+          lastError = error;
+          const retryDelay = retryConfig.retryDelay(attempt);
+          debugLog(debug, "error", `Retrying in ${retryDelay}ms...`, error);
+          await delay(retryDelay);
+          continue;
+        }
+        throw error;
+      }
+      return response;
+    } catch (error) {
+      debugLog(debug, "error", url, error);
+      const method = (requestInit.method || "GET").toUpperCase();
+      const isSafe = SAFE_METHODS.includes(method);
+      if (error instanceof Error && error.name === "AbortError") {
+        const timeoutError = createTimeoutError(
+          `Request timed out after ${timeout}ms.`,
+          { url, timeout, attempt: attempt + 1 },
+          "The request timed out.",
+          "Please check your network connection or try again later."
+        );
+        if (isSafe && attempt < retryConfig.maxRetries) {
+          lastError = timeoutError;
+          await delay(retryConfig.retryDelay(attempt));
+          continue;
+        }
+        throw timeoutError;
+      }
+      if (error instanceof TypeError) {
+        const networkError = createNetworkError(
+          "Network connection failed.",
+          void 0,
+          { url, originalError: error.message, attempt: attempt + 1 },
+          "Network connection failed.",
+          "Please check your internet connection and try again."
+        );
+        if (isSafe && attempt < retryConfig.maxRetries) {
+          lastError = networkError;
+          await delay(retryConfig.retryDelay(attempt));
+          continue;
+        }
+        throw networkError;
+      }
+      if (error instanceof NetworkError || error instanceof TimeoutError) {
+        if (isSafe && attempt < retryConfig.maxRetries && error.status && !NON_RETRYABLE_STATUSES.includes(error.status) && retryConfig.retryableStatuses.includes(error.status)) {
+          lastError = error;
+          await delay(retryConfig.retryDelay(attempt));
+          continue;
+        }
+        throw error;
+      }
+      if (error instanceof SDKError) {
+        throw error;
+      }
+      const unknownError = createNetworkError(
+        error instanceof Error ? error.message : "An unknown network error occurred.",
+        void 0,
+        { url, originalError: error, attempt: attempt + 1 },
+        "An unknown error occurred.",
+        "Please try again later."
+      );
+      if (isSafe && attempt < retryConfig.maxRetries) {
+        lastError = unknownError;
+        await delay(retryConfig.retryDelay(attempt));
+        continue;
+      }
+      throw unknownError;
+    }
+  }
+  throw lastError ?? new NetworkError("Request failed after retries");
+}
+
+// src/core/collection/http-client.ts
+var HttpClient = class {
+  constructor(publishableKey, secretKey, getCustomerToken, onUnauthorized, onRequestId, apiUrl) {
+    this.publishableKey = requirePublishableKeyForSecret(
+      "CollectionClient",
+      publishableKey,
+      secretKey
+    );
+    this.secretKey = secretKey;
+    this.getCustomerToken = getCustomerToken;
+    this.onUnauthorized = onUnauthorized;
+    this.onRequestId = onRequestId;
+    this.apiUrl = apiUrl;
+  }
+  get defaultOptions() {
+    const opts = {
+      apiUrl: this.apiUrl,
+      publishableKey: this.publishableKey,
+      secretKey: this.secretKey
+    };
+    const token = this.getCustomerToken?.();
+    if (token) {
+      opts.customerToken = token;
+      if (this.onUnauthorized) {
+        opts.onUnauthorized = this.onUnauthorized;
+      }
+    }
+    return opts;
+  }
+  async fetchWithTracking(url, opts) {
+    try {
+      const response = await httpFetch(url, opts);
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return response;
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
+  buildUrl(endpoint, options) {
+    if (!options) return endpoint;
+    const queryString = (0, import_qs_esm.stringify)(options, { addQueryPrefix: true });
+    return queryString ? `${endpoint}${queryString}` : endpoint;
+  }
+  assertJsonResponse(response) {
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      throw createApiError("Response is not in JSON format.", response.status, {
+        contentType
+      });
+    }
+  }
+  /**
+   * Parse Payload CMS find response (list query)
+   * Returns native Payload response structure
+   */
+  async parseFindResponse(response) {
+    const contentType = response.headers.get("content-type");
+    try {
+      this.assertJsonResponse(response);
+      const jsonData = await response.json();
+      if (jsonData.docs === void 0) {
+        throw createApiError("Invalid find response.", response.status, {
+          jsonData
+        });
+      }
+      return {
+        docs: jsonData.docs,
+        totalDocs: jsonData.totalDocs ?? 0,
+        limit: jsonData.limit || 20,
+        totalPages: jsonData.totalPages ?? 0,
+        page: jsonData.page || 1,
+        pagingCounter: jsonData.pagingCounter || 1,
+        hasPrevPage: jsonData.hasPrevPage ?? false,
+        hasNextPage: jsonData.hasNextPage ?? false,
+        prevPage: jsonData.prevPage ?? null,
+        nextPage: jsonData.nextPage ?? null
+      };
+    } catch (error) {
+      if (error instanceof SDKError) throw error;
+      throw createApiError("Failed to parse response.", response.status, {
+        contentType,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+  /**
+   * Parse Payload CMS mutation response (create/update)
+   * Returns native Payload response structure
+   */
+  async parseMutationResponse(response) {
+    const contentType = response.headers.get("content-type");
+    try {
+      this.assertJsonResponse(response);
+      const jsonData = await response.json();
+      if (jsonData.doc === void 0) {
+        throw createApiError("Invalid mutation response.", response.status, {
+          jsonData
+        });
+      }
+      return {
+        message: jsonData.message || "",
+        doc: jsonData.doc,
+        errors: jsonData.errors
+      };
+    } catch (error) {
+      if (error instanceof SDKError) throw error;
+      throw createApiError("Failed to parse response.", response.status, {
+        contentType,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+  /**
+   * Parse Payload CMS document response (findById/delete)
+   * Returns document directly without wrapper
+   */
+  async parseDocumentResponse(response) {
+    const contentType = response.headers.get("content-type");
+    try {
+      this.assertJsonResponse(response);
+      const jsonData = await response.json();
+      return jsonData;
+    } catch (error) {
+      if (error instanceof SDKError) throw error;
+      throw createApiError("Failed to parse response.", response.status, {
+        contentType,
+        error: error instanceof Error ? error.message : error
+      });
+    }
+  }
+};
+
+// src/utils/types.ts
+var resolveRelation = (ref) => {
+  if (typeof ref === "string" || typeof ref === "number" || ref === null || ref === void 0)
+    return null;
+  return ref;
+};
+
+// src/core/metadata/index.ts
+function extractSeo(doc) {
+  const seo = doc.seo ?? {};
+  const og = seo.openGraph ?? {};
+  return {
+    title: seo.title ?? doc.title ?? null,
+    description: seo.description ?? null,
+    noIndex: seo.noIndex ?? null,
+    canonical: seo.canonical ?? null,
+    openGraph: {
+      title: og.title ?? null,
+      description: og.description ?? null,
+      image: og.image ?? null
+    }
+  };
+}
+function generateMetadata(input, options) {
+  const title = input.title ?? void 0;
+  const description = input.description ?? void 0;
+  const ogTitle = input.openGraph?.title ?? title;
+  const ogDescription = input.openGraph?.description ?? description;
+  const image = resolveMetaImage(input.openGraph?.image);
+  return {
+    title,
+    description,
+    ...input.noIndex && { robots: { index: false, follow: false } },
+    ...input.canonical && { alternates: { canonical: input.canonical } },
+    openGraph: {
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...options?.siteName && { siteName: options.siteName },
+      ...image && { images: [image] }
+    },
+    twitter: {
+      card: image ? "summary_large_image" : "summary",
+      ...ogTitle && { title: ogTitle },
+      ...ogDescription && { description: ogDescription },
+      ...image && { images: [image.url] }
+    }
+  };
+}
+function resolveMetaImage(ref) {
+  const image = resolveRelation(ref);
+  if (!image) return null;
+  const sized = image.sizes?.["1536"];
+  const url = sized?.url || image.url;
+  if (!url) return null;
+  const width = sized?.url ? sized.width : image.width;
+  const height = sized?.url ? sized.height : image.height;
+  return {
+    url,
+    ...width && { width },
+    ...height && { height },
+    ...image.alt && { alt: image.alt }
+  };
+}
+
+// src/core/collection/query-builder.ts
+var ReadOnlyCollectionQueryBuilder = class {
+  constructor(api, collection) {
+    this.api = api;
+    this.collection = collection;
+  }
+  async find(options) {
+    return this.api.requestFind(
+      `/api/${String(this.collection)}`,
+      options
+    );
+  }
+  async findById(id, options) {
+    return this.api.requestFindById(
+      `/api/${String(this.collection)}/${String(id)}`,
+      options
+    );
+  }
+  async count(options) {
+    return this.api.requestCount(
+      `/api/${String(this.collection)}/count`,
+      options
+    );
+  }
+  async findMetadata(options, metadataOptions) {
+    const { docs } = await this.find({ ...options, limit: 1, depth: 1 });
+    const doc = docs[0];
+    if (!doc) return null;
+    return generateMetadata(
+      extractSeo(doc),
+      metadataOptions
+    );
+  }
+  async findMetadataById(id, metadataOptions) {
+    const doc = await this.findById(id, { depth: 1 });
+    return generateMetadata(
+      extractSeo(doc),
+      metadataOptions
+    );
+  }
+};
+
+// src/core/collection/collection-client.ts
+var ReadOnlyCollectionClient = class extends HttpClient {
+  from(collection) {
+    return new ReadOnlyCollectionQueryBuilder(this, collection);
+  }
+  async requestFind(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
+    const response = await this.fetchWithTracking(url, {
+      ...this.defaultOptions,
+      method: "GET"
+    });
+    return this.parseFindResponse(response);
+  }
+  async requestFindById(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
+    const response = await this.fetchWithTracking(url, {
+      ...this.defaultOptions,
+      method: "GET"
+    });
+    return this.parseDocumentResponse(response);
+  }
+  async requestCount(endpoint, options) {
+    const url = this.buildUrl(endpoint, options);
+    const response = await this.fetchWithTracking(url, {
+      ...this.defaultOptions,
+      method: "GET"
+    });
+    return this.parseDocumentResponse(response);
+  }
+};
+
+// src/core/api/parse-response.ts
+async function parseApiResponse(response, endpoint) {
+  let data;
+  try {
+    data = await response.json();
+  } catch {
+    throw createApiError(
+      `Invalid JSON response from ${endpoint}`,
+      response.status,
+      void 0,
+      "Server returned an invalid response.",
+      "Check if the API endpoint is available."
+    );
+  }
+  if (data.error) {
+    const errorMessage = typeof data.error === "string" ? data.error : "Unknown API error";
+    const reason = typeof data.reason === "string" ? data.reason : void 0;
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    const retryAfterRaw = response.headers.get("Retry-After");
+    const retryAfter = retryAfterRaw ? parseInt(retryAfterRaw, 10) || void 0 : void 0;
+    if (reason === "validation_failed") {
+      throw attachRequestId(createValidationError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "token_expired" || reason === "token_invalid" || reason === "preview_token_invalid" || reason === "preview_token_required" || reason === "key_invalid" || reason === "key_revoked") {
+      throw attachRequestId(createAuthError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "forbidden") {
+      throw attachRequestId(createPermissionError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "rate_limit_exceeded") {
+      throw attachRequestId(createRateLimitError(errorMessage, retryAfter, data, errorMessage), requestId);
+    }
+    if (reason === "not_found") {
+      throw attachRequestId(createNotFoundError(errorMessage, data, errorMessage), requestId);
+    }
+    if (reason === "conflict") {
+      throw attachRequestId(createConflictError(errorMessage, data, errorMessage), requestId);
+    }
+    throw attachRequestId(
+      createApiError(errorMessage, response.status, data, errorMessage, "An error occurred while processing the request."),
+      requestId
+    );
+  }
+  return data;
+}
+
+// src/core/community/community-client.ts
+var CommunityClient = class {
+  constructor(options) {
+    this.publishableKey = requirePublishableKeyForSecret(
+      "CommunityClient",
+      options.publishableKey,
+      options.secretKey
+    );
+    this.secretKey = options.secretKey;
+    this.apiUrl = options.apiUrl;
+    this.customerToken = options.customerToken;
+    this.onUnauthorized = options.onUnauthorized;
+    this.onRequestId = options.onRequestId;
+  }
+  buildQuery(params) {
+    if (!params) return "";
+    const entries = Object.entries(params).filter((e) => e[1] !== void 0).map(([k, v]) => [k, String(v)]);
+    return entries.length ? `?${new URLSearchParams(entries).toString()}` : "";
+  }
+  async execute(endpoint, method, body) {
+    const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
+    try {
+      const response = await httpFetch(endpoint, {
+        method,
+        apiUrl: this.apiUrl,
+        publishableKey: this.publishableKey,
+        secretKey: this.secretKey,
+        customerToken: token ?? void 0,
+        ...token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
+        ...body !== void 0 && { body: JSON.stringify(body) }
+      });
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return parseApiResponse(response, endpoint);
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
+  createPost(params) {
+    return this.execute("/api/posts", "POST", params);
+  }
+  getMyPosts(params) {
+    return this.execute(
+      `/api/posts/my${this.buildQuery(params)}`,
+      "GET"
+    );
+  }
+  getTrending(params) {
+    return this.execute(
+      `/api/posts/trending${this.buildQuery(params)}`,
+      "GET"
+    );
+  }
+  incrementView(params) {
+    return this.execute(
+      `/api/posts/${params.postId}/view`,
+      "POST"
+    );
+  }
+  reportPost(params) {
+    const { postId, ...body } = params;
+    return this.execute(
+      `/api/posts/${postId}/report`,
+      "POST",
+      body
+    );
+  }
+  // Comments
+  createComment(params) {
+    const { postId, parentId, body: commentBody } = params;
+    const body = { post: postId, body: commentBody };
+    if (parentId !== void 0) {
+      body.parent = parentId;
+    }
+    return this.execute("/api/comments", "POST", body);
+  }
+  listComments(params) {
+    const { postId, page, limit, rootComment } = params;
+    const urlParams = new URLSearchParams();
+    urlParams.set("where[post][equals]", postId);
+    urlParams.set("sort", "-createdAt");
+    if (limit !== void 0) urlParams.set("limit", String(limit));
+    if (page !== void 0) urlParams.set("page", String(page));
+    if (rootComment !== void 0) urlParams.set("where[rootComment][equals]", rootComment);
+    return this.execute(
+      `/api/comments?${urlParams.toString()}`,
+      "GET"
+    );
+  }
+  updateComment(params) {
+    const { commentId, body } = params;
+    return this.execute(
+      `/api/comments/${commentId}`,
+      "PATCH",
+      { body }
+    );
+  }
+  deleteComment(params) {
+    return this.execute(
+      `/api/comments/${params.commentId}`,
+      "DELETE"
+    );
+  }
+  reportComment(params) {
+    const { commentId, ...body } = params;
+    return this.execute(
+      `/api/comments/${commentId}/report`,
+      "POST",
+      body
+    );
+  }
+  // Reactions
+  addReaction(params) {
+    const { postId, type } = params;
+    return this.execute("/api/reactions", "POST", {
+      post: postId,
+      type
+    });
+  }
+  removeReaction(params) {
+    const { postId, type } = params;
+    return this.execute(
+      `/api/posts/${postId}/react?type=${encodeURIComponent(type)}`,
+      "DELETE"
+    );
+  }
+  addCommentReaction(params) {
+    const { commentId, type } = params;
+    return this.execute("/api/reactions", "POST", {
+      comment: commentId,
+      type
+    });
+  }
+  removeCommentReaction(params) {
+    const { commentId, type } = params;
+    return this.execute(
+      `/api/comments/${commentId}/react?type=${encodeURIComponent(type)}`,
+      "DELETE"
+    );
+  }
+  getReactionSummary(params) {
+    return this.execute(
+      `/api/posts/${params.postId}/reactions`,
+      "GET"
+    );
+  }
+  getReactionTypes() {
+    return this.execute(
+      "/api/reaction-types?limit=100",
+      "GET"
+    );
+  }
+  // Bookmarks
+  addBookmark(params) {
+    return this.execute("/api/bookmarks", "POST", {
+      post: params.postId
+    });
+  }
+  removeBookmark(params) {
+    return this.execute(
+      `/api/posts/${params.postId}/bookmark`,
+      "DELETE"
+    );
+  }
+  getMyBookmarks(params) {
+    return this.execute(
+      `/api/bookmarks/my${this.buildQuery(params)}`,
+      "GET"
+    );
+  }
+};
+
+// src/core/customer/customer-auth.ts
+var DEFAULT_TIMEOUT2 = 15e3;
+function safeGetItem(key) {
+  try {
+    return localStorage.getItem(key);
+  } catch {
+    return null;
+  }
+}
+var CustomerAuth = class {
+  constructor(publishableKey, options, apiUrl) {
+    this.refreshPromise = null;
+    this.publishableKey = publishableKey;
+    this.baseUrl = resolveApiUrl(apiUrl);
+    const persist = options?.persist ?? true;
+    if (persist) {
+      const key = typeof persist === "string" ? persist : "customer-token";
+      const isBrowser = typeof window !== "undefined";
+      this.token = isBrowser ? safeGetItem(key) : null;
+      this.onTokenChange = isBrowser ? (token) => {
+        try {
+          if (token) localStorage.setItem(key, token);
+          else localStorage.removeItem(key);
+        } catch {
+        }
+      } : void 0;
+    } else {
+      this.token = options?.token ?? null;
+      this.onTokenChange = options?.onTokenChange;
+    }
+  }
+  /**
+   * Register a new customer account
+   */
+  async register(data) {
+    return this.requestJson("/api/customers/register", {
+      method: "POST",
+      body: JSON.stringify(data)
+    });
+  }
+  /**
+   * Login with email and password. Stores the token internally.
+   */
+  async login(data) {
+    const result = await this.requestJson(
+      "/api/customers/login",
+      {
+        method: "POST",
+        body: JSON.stringify(data)
+      }
+    );
+    this.setToken(result.token);
+    return result;
+  }
+  /**
+   * Refresh the current token. Requires a valid (non-expired) token.
+   */
+  async refreshToken() {
+    if (!this.token) throw new ApiError("Not authenticated", 401);
+    if (this.refreshPromise) return this.refreshPromise;
+    this.refreshPromise = this._doRefreshToken();
+    try {
+      return await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async _doRefreshToken() {
+    const result = await this.requestJson(
+      "/api/customers/refresh",
+      {
+        method: "POST",
+        headers: { Authorization: `Bearer ${this.token}` }
+      }
+    );
+    this.setToken(result.token);
+    return result;
+  }
+  /**
+   * Clear the stored token
+   */
+  logout() {
+    this.setToken(null);
+  }
+  /**
+   * Get the current authenticated customer's profile
+   */
+  async me() {
+    if (!this.token) return null;
+    try {
+      const data = await this.requestJson(
+        "/api/customers/me",
+        {
+          method: "GET",
+          headers: { Authorization: `Bearer ${this.token}` }
+        }
+      );
+      return data.customer ?? null;
+    } catch (error) {
+      if (error instanceof ApiError && error.status === 401) {
+        this.setToken(null);
+        return null;
+      }
+      throw error;
+    }
+  }
+  /**
+   * Request a password reset email
+   */
+  async forgotPassword(email) {
+    await this.requestJson("/api/customers/forgot-password", {
+      method: "POST",
+      body: JSON.stringify({ email })
+    });
+  }
+  /**
+   * Reset password using a token from the reset email
+   */
+  async resetPassword(token, password) {
+    await this.requestJson("/api/customers/reset-password", {
+      method: "POST",
+      body: JSON.stringify({ token, password })
+    });
+  }
+  /**
+   * Update the authenticated customer's profile (name, phone, marketingConsent)
+   */
+  async updateProfile(data) {
+    if (!this.token) throw new ApiError("Not authenticated", 401);
+    const result = await this.requestJson(
+      "/api/customers/me",
+      {
+        method: "PATCH",
+        headers: { Authorization: `Bearer ${this.token}` },
+        body: JSON.stringify(data)
+      }
+    );
+    return result.customer;
+  }
+  /**
+   * Change the password of the currently authenticated customer
+   */
+  async changePassword(currentPassword, newPassword) {
+    if (!this.token) throw new ApiError("Not authenticated", 401);
+    await this.requestJson("/api/customers/change-password", {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.token}` },
+      body: JSON.stringify({ currentPassword, newPassword })
+    });
+  }
+  /**
+   * Get the authenticated customer's orders with pagination and optional status filter
+   */
+  async getMyOrders(options) {
+    if (!this.token) throw new ApiError("Not authenticated", 401);
+    const params = new URLSearchParams();
+    if (options?.page) params.set("page", String(options.page));
+    if (options?.limit) params.set("limit", String(options.limit));
+    if (options?.status) params.set("status", options.status);
+    const qs = params.toString();
+    return this.requestJson(`/api/customers/me/orders${qs ? `?${qs}` : ""}`, {
+      method: "GET",
+      headers: { Authorization: `Bearer ${this.token}` }
+    });
+  }
+  /**
+   * Get the current token (or null if not authenticated)
+   */
+  getToken() {
+    return this.token;
+  }
+  /**
+   * Set the token manually (e.g. from SSR)
+   */
+  setToken(token) {
+    this.token = token;
+    this.onTokenChange?.(token);
+  }
+  /**
+   * Check if the customer is currently authenticated
+   */
+  isAuthenticated() {
+    return this.token !== null;
+  }
+  /**
+   * Internal: make a request with timeout and error handling.
+   * Auth endpoints don't retry — failures are final.
+   */
+  async requestJson(path, init) {
+    const headers = new Headers(init.headers);
+    headers.set("X-Publishable-Key", this.publishableKey);
+    if (!headers.has("Content-Type") && init.body) {
+      headers.set("Content-Type", "application/json");
+    }
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), DEFAULT_TIMEOUT2);
+    let res;
+    try {
+      res = await fetch(`${this.baseUrl}${path}`, {
+        ...init,
+        headers,
+        signal: controller.signal
+      });
+    } catch (error) {
+      clearTimeout(timeoutId);
+      if (error instanceof Error && error.name === "AbortError") {
+        throw new TimeoutError(`Request timed out after ${DEFAULT_TIMEOUT2}ms`, {
+          url: path,
+          timeout: DEFAULT_TIMEOUT2
+        });
+      }
+      throw new NetworkError(
+        error instanceof Error ? error.message : "Network request failed",
+        void 0,
+        { url: path },
+        "Network connection failed.",
+        "Please check your internet connection and try again."
+      );
+    }
+    clearTimeout(timeoutId);
+    if (!res.ok) {
+      const body = await res.json().catch(() => ({}));
+      throw new ApiError(
+        body.error || `HTTP ${res.status}`,
+        res.status,
+        body.details,
+        body.error
+      );
+    }
+    try {
+      return await res.json();
+    } catch {
+      throw new ApiError(
+        "Invalid JSON response from server",
+        res.status,
+        void 0,
+        "INVALID_RESPONSE"
+      );
+    }
+  }
+};
+
+// src/core/customer/customer-namespace.ts
+var CustomerNamespace = class {
+  constructor(publishableKey, options, apiUrl) {
+    this.auth = new CustomerAuth(publishableKey, options, apiUrl);
+  }
+};
+
+// src/core/api/cart-api.ts
+var CartApi = class {
+  constructor(options) {
+    if (!options.secretKey && !options.customerToken) {
+      throw createConfigError(
+        "Either secretKey or customerToken is required for CartApi."
+      );
+    }
+    this.publishableKey = requirePublishableKeyForSecret(
+      "CartApi",
+      options.publishableKey,
+      options.secretKey
+    );
+    this.secretKey = options.secretKey;
+    this.apiUrl = options.apiUrl;
+    this.customerToken = options.customerToken;
+    this.onUnauthorized = options.onUnauthorized;
+    this.onRequestId = options.onRequestId;
+  }
+  async execute(endpoint, method, body) {
+    const token = typeof this.customerToken === "function" ? this.customerToken() : this.customerToken;
+    try {
+      const response = await httpFetch(endpoint, {
+        method,
+        apiUrl: this.apiUrl,
+        publishableKey: this.publishableKey,
+        secretKey: this.secretKey,
+        customerToken: token ?? void 0,
+        ...token && this.onUnauthorized && { onUnauthorized: this.onUnauthorized },
+        ...body !== void 0 && { body: JSON.stringify(body) }
+      });
+      this.onRequestId?.(response.headers.get("x-request-id") ?? null);
+      return parseApiResponse(response, endpoint);
+    } catch (err) {
+      const id = err instanceof SDKError ? err.requestId ?? null : null;
+      this.onRequestId?.(id);
+      throw err;
+    }
+  }
+  getCart(cartId) {
+    return this.execute(`/api/carts/${cartId}`, "GET");
+  }
+  addItem(params) {
+    return this.execute("/api/carts/add-item", "POST", params);
+  }
+  updateItem(params) {
+    return this.execute("/api/carts/update-item", "POST", params);
+  }
+  removeItem(params) {
+    return this.execute(
+      "/api/carts/remove-item",
+      "POST",
+      params
+    );
+  }
+  applyDiscount(params) {
+    return this.execute("/api/carts/apply-discount", "POST", params);
+  }
+  removeDiscount(params) {
+    return this.execute("/api/carts/remove-discount", "POST", params);
+  }
+  clearCart(params) {
+    return this.execute(
+      "/api/carts/clear",
+      "POST",
+      params
+    );
+  }
+};
+
+// src/core/commerce/commerce-client.ts
+var CommerceClient = class {
+  constructor(options) {
+    const cartApi = new CartApi({
+      publishableKey: options.publishableKey,
+      apiUrl: options.apiUrl,
+      customerToken: options.customerToken,
+      onUnauthorized: options.onUnauthorized,
+      onRequestId: options.onRequestId
+    });
+    const execute = async (endpoint, body) => {
+      const token = options.customerToken();
+      try {
+        const response = await httpFetch(endpoint, {
+          method: "POST",
+          apiUrl: options.apiUrl,
+          publishableKey: options.publishableKey,
+          customerToken: token ?? void 0,
+          ...token && options.onUnauthorized && { onUnauthorized: options.onUnauthorized },
+          body: JSON.stringify(body)
+        });
+        options.onRequestId?.(response.headers.get("x-request-id") ?? null);
+        return parseApiResponse(response, endpoint);
+      } catch (err) {
+        const id = err instanceof SDKError ? err.requestId ?? null : null;
+        options.onRequestId?.(id);
+        throw err;
+      }
+    };
+    this.product = {
+      stockCheck: (params) => execute("/api/products/stock-check", params),
+      listingGroups: (params) => execute("/api/products/listing-groups", params),
+      detail: async (params) => {
+        try {
+          return await execute("/api/products/detail", params);
+        } catch (err) {
+          if (err instanceof NotFoundError) return null;
+          throw err;
+        }
+      }
+    };
+    this.cart = {
+      get: cartApi.getCart.bind(cartApi),
+      addItem: cartApi.addItem.bind(cartApi),
+      updateItem: cartApi.updateItem.bind(cartApi),
+      removeItem: cartApi.removeItem.bind(cartApi),
+      applyDiscount: cartApi.applyDiscount.bind(cartApi),
+      removeDiscount: cartApi.removeDiscount.bind(cartApi),
+      clear: cartApi.clearCart.bind(cartApi)
+    };
+    this.orders = {
+      checkout: (params) => execute("/api/orders/checkout", params),
+      listMine: (params) => options.customerAuth.getMyOrders(params)
+    };
+    this.discounts = {
+      validate: (params) => execute("/api/discounts/validate", params)
+    };
+    this.shipping = {
+      calculate: (params) => execute("/api/shipping-policies/calculate", params)
+    };
+  }
+};
+
+// src/core/client/client.ts
+var Client = class {
+  constructor(options) {
+    this.lastRequestId = null;
+    const publishableKey = options.publishableKey;
+    if (!publishableKey) {
+      throw createConfigError("publishableKey is required.");
+    }
+    this.config = { ...options, publishableKey };
+    const metadata = {
+      timestamp: Date.now(),
+      userAgent: typeof window !== "undefined" ? window.navigator?.userAgent : "Node.js"
+    };
+    this.state = { metadata };
+    this.customer = new CustomerNamespace(
+      this.config.publishableKey,
+      options.customer,
+      this.config.apiUrl
+    );
+    const onUnauthorized = async () => {
+      try {
+        const result = await this.customer.auth.refreshToken();
+        return result.token ?? null;
+      } catch {
+        return null;
+      }
+    };
+    const onRequestId = (id) => {
+      this.lastRequestId = id;
+    };
+    this.commerce = new CommerceClient({
+      publishableKey: this.config.publishableKey,
+      apiUrl: this.config.apiUrl,
+      customerToken: () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId,
+      customerAuth: this.customer.auth
+    });
+    this.community = new CommunityClient({
+      publishableKey: this.config.publishableKey,
+      apiUrl: this.config.apiUrl,
+      customerToken: () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId
+    });
+    this.collections = new ReadOnlyCollectionClient(
+      this.config.publishableKey,
+      void 0,
+      () => this.customer.auth.getToken(),
+      onUnauthorized,
+      onRequestId,
+      this.config.apiUrl
+    );
+  }
+  getState() {
+    return { ...this.state };
+  }
+  getConfig() {
+    return { ...this.config };
+  }
+};
+function createClient(options) {
+  return new Client(options);
+}
+//# sourceMappingURL=client.cjs.map