@sanity/client 7.11.2-audience-decide.3 → 7.11.2-audience-decide.4

package/dist/index.browser.cjs

@@ -854,30 +854,118 @@ function requestOptions(config, overrides = {}) {
   });
 }
 function isDecideField(value) {
-  return value != null && typeof value == "object" && !Array.isArray(value) && "default" in value && "conditions" in value && Array.isArray(value.conditions);
+  console.log("isDecideField: checking value:", {
+    value: typeof value == "object" ? JSON.stringify(value, null, 2) : value,
+    type: typeof value,
+    isNull: value === null,
+    isArray: Array.isArray(value)
+  });
+  const isValid = value != null && typeof value == "object" && !Array.isArray(value) && "default" in value && "conditions" in value && Array.isArray(value.conditions);
+  return console.log("isDecideField: result:", {
+    isValid,
+    hasDefault: value != null && typeof value == "object" && "default" in value,
+    hasConditions: value != null && typeof value == "object" && "conditions" in value,
+    conditionsIsArray: value != null && typeof value == "object" && "conditions" in value && Array.isArray(value.conditions)
+  }), isValid;
 }
 function resolveDecideField(field, decideParameters) {
-  const audience = decideParameters.audience, matchingCondition = field.conditions.find((condition) => Array.isArray(audience) ? audience.includes(condition.audience) : condition.audience === audience);
-  return matchingCondition ? matchingCondition.value : field.default;
-}
-function processObjectRecursively(obj, decideParameters) {
-  return obj == null || typeof obj != "object" ? obj : Array.isArray(obj) ? obj.map((item) => processObjectRecursively(item, decideParameters)) : Object.entries(obj).reduce((processed, [key, value]) => {
+  console.log("resolveDecideField: starting resolution:", {
+    field: {
+      default: field.default,
+      conditionsCount: field.conditions.length,
+      conditions: field.conditions.map((c, i) => ({
+        index: i,
+        audience: c.audience,
+        value: c.value
+      }))
+    },
+    decideParameters
+  });
+  const audience = decideParameters?.audience;
+  if (console.log("resolveDecideField: audience processing:", {
+    audience,
+    audienceType: typeof audience,
+    isArray: Array.isArray(audience),
+    isEmpty: Array.isArray(audience) ? audience.length === 0 : audience === "",
+    isUndefined: audience === void 0,
+    isNull: audience === null
+  }), !audience || Array.isArray(audience) && audience.length === 0 || audience === "")
+    return console.log("resolveDecideField: no valid audience, returning default:", field.default), field.default;
+  console.log("resolveDecideField: searching for matching condition...");
+  const matchingCondition = field.conditions.find((condition, index) => {
+    const isMatch = Array.isArray(audience) ? audience.includes(condition.audience) : condition.audience === audience;
+    return console.log(`resolveDecideField: checking condition ${index}:`, {
+      conditionAudience: condition.audience,
+      conditionValue: condition.value,
+      searchAudience: audience,
+      isArraySearch: Array.isArray(audience),
+      isMatch
+    }), isMatch;
+  }), resolvedValue = matchingCondition ? matchingCondition.value : field.default;
+  return console.log("resolveDecideField: resolution complete:", {
+    matchingCondition: matchingCondition ? {
+      audience: matchingCondition.audience,
+      value: matchingCondition.value
+    } : null,
+    resolvedValue,
+    usedDefault: !matchingCondition
+  }), resolvedValue;
+}
+function processObjectRecursively(obj, decideParameters, depth = 0, path = "root") {
+  const indent = "  ".repeat(depth);
+  return console.log(`${indent}processObjectRecursively: processing at path '${path}':`, {
+    type: typeof obj,
+    isNull: obj === null,
+    isUndefined: obj === void 0,
+    isArray: Array.isArray(obj),
+    depth,
+    decideParameters
+  }), obj == null || typeof obj != "object" ? (console.log(`${indent}processObjectRecursively: returning primitive/null value:`, obj), obj) : Array.isArray(obj) ? (console.log(`${indent}processObjectRecursively: processing array with ${obj.length} items`), obj.map((item, index) => (console.log(`${indent}processObjectRecursively: processing array item ${index}`), processObjectRecursively(item, decideParameters, depth + 1, `${path}[${index}]`)))) : (console.log(`${indent}processObjectRecursively: processing object with keys:`, Object.keys(obj)), Object.entries(obj).reduce((processed, [key, value]) => {
+    const currentPath = `${path}.${key}`;
+    console.log(`${indent}processObjectRecursively: processing key '${key}' at path '${currentPath}'`);
     try {
-      isDecideField(value) ? processed[key] = resolveDecideField(value, decideParameters) : processed[key] = processObjectRecursively(value, decideParameters);
+      isDecideField(value) ? (console.log(`${indent}processObjectRecursively: '${key}' is a decide field, resolving...`), processed[key] = resolveDecideField(value, decideParameters), console.log(`${indent}processObjectRecursively: '${key}' resolved to:`, processed[key])) : (console.log(`${indent}processObjectRecursively: '${key}' is not a decide field, recursing...`), processed[key] = processObjectRecursively(value, decideParameters, depth + 1, currentPath));
     } catch (error) {
-      console.warn(`Failed to process decide field '${key}':`, error), processed[key] = value;
+      console.warn(`${indent}processObjectRecursively: Failed to process decide field '${key}':`, error), processed[key] = value;
     }
     return processed;
-  }, {});
+  }, {}));
 }
 function processDecideFields(data, decideParameters) {
-  if (!decideParameters || !decideParameters.audience)
-    return data;
-  console.log("Starting decide field processing with parameters:", decideParameters);
+  console.log("=== DECIDE FIELD PROCESSING START ==="), console.log("processDecideFields: analyzing response structure:", {
+    dataType: typeof data,
+    isObject: typeof data == "object" && data !== null,
+    hasResultsKey: typeof data == "object" && data !== null && "result" in data,
+    hasDocumentsKey: typeof data == "object" && data !== null && "documents" in data,
+    topLevelKeys: typeof data == "object" && data !== null ? Object.keys(data) : null
+  });
+  let decideFieldCount = 0;
+  const countDecideFields = (obj, path = "") => {
+    obj == null || typeof obj != "object" || (Array.isArray(obj) ? obj.forEach((item, index) => countDecideFields(item, `${path}[${index}]`)) : Object.entries(obj).forEach(([key, value]) => {
+      const currentPath = path ? `${path}.${key}` : key;
+      isDecideField(value) ? (decideFieldCount++, console.log(`processDecideFields: Found decide field at path '${currentPath}':`, {
+        default: value.default,
+        conditionsCount: value.conditions.length
+      })) : countDecideFields(value, currentPath);
+    }));
+  };
+  console.log("processDecideFields: scanning for decide fields..."), countDecideFields(data), console.log(`processDecideFields: found ${decideFieldCount} decide fields in response`), console.log("processDecideFields: entry parameters:", {
+    decideParameters,
+    hasAudience: !!decideParameters?.audience,
+    audience: decideParameters?.audience,
+    audienceType: typeof decideParameters?.audience,
+    dataType: typeof data,
+    dataPreview: typeof data == "object" && data !== null ? JSON.stringify(data, null, 2).substring(0, 500) + (JSON.stringify(data, null, 2).length > 500 ? "..." : "") : data
+  });
   try {
-    return processObjectRecursively(data, decideParameters);
+    console.log("processDecideFields: starting recursive processing...");
+    const result = processObjectRecursively(data, decideParameters);
+    return console.log("processDecideFields: processing completed successfully"), console.log("processDecideFields: result preview:", {
+      resultType: typeof result,
+      resultPreview: typeof result == "object" && result !== null ? JSON.stringify(result, null, 2).substring(0, 500) + (JSON.stringify(result, null, 2).length > 500 ? "..." : "") : result
+    }), console.log("=== DECIDE FIELD PROCESSING END ==="), result;
   } catch (error) {
-    return console.warn("Failed to process decide fields:", error), data;
+    return console.warn("processDecideFields: processing failed, returning original data:", error), console.log("=== DECIDE FIELD PROCESSING END (ERROR) ==="), data;
   }
 }
 const encodeQueryString = ({
@@ -913,13 +1001,18 @@ function _fetch(client, httpRequest, _stega, query, _params = {}, options = {})
   const stega = "stega" in options ? {
     ..._stega || {},
     ...typeof options.stega == "boolean" ? { enabled: options.stega } : options.stega || {}
-  } : _stega, params = stega.enabled ? stegaClean.stegaClean(_params) : _params, mapResponse = options.filterResponse === !1 ? (res) => res : (res) => res.result, processDecideResponse = (response) => (console.log("inside processDecideResponse:", {
-    audience: options.decideParameters?.audience,
-    decideParameters: options.decideParameters?.audience
-  }), options.decideParameters && options.decideParameters.audience ? (console.log("Processing response with decideParameters:", {
-    audience: options.decideParameters.audience,
-    decideParameters: options.decideParameters
-  }), processDecideFields(response, options.decideParameters)) : response), { cache, next, ...opts } = {
+  } : _stega, params = stega.enabled ? stegaClean.stegaClean(_params) : _params, mapResponse = options.filterResponse === !1 ? (res) => res : (res) => res.result, processDecideResponse = (response) => {
+    console.log("=== HTTP RESPONSE TO DECIDE PROCESSING ==="), console.log("processDecideResponse: received response for processing:", {
+      responseType: typeof response,
+      responseKeys: typeof response == "object" && response !== null ? Object.keys(response) : null,
+      responsePreview: typeof response == "object" && response !== null ? JSON.stringify(response, null, 2).substring(0, 300) + (JSON.stringify(response, null, 2).length > 300 ? "..." : "") : response,
+      audience: options.decideParameters?.audience,
+      decideParameters: options.decideParameters,
+      hasDecideParameters: !!options.decideParameters
+    }), console.log("processDecideResponse: calling processDecideFields...");
+    const processedData = processDecideFields(response, options.decideParameters);
+    return console.log("processDecideResponse: decide processing complete, returning processed data"), console.log("=== HTTP RESPONSE TO DECIDE PROCESSING COMPLETE ==="), processedData;
+  }, { cache, next, ...opts } = {
     // Opt out of setting a `signal` on an internal `fetch` if one isn't provided.
     // This is necessary in React Server Components to avoid opting out of Request Memoization.
     useAbortSignal: typeof options.signal < "u",
@@ -930,7 +1023,7 @@ function _fetch(client, httpRequest, _stega, query, _params = {}, options = {})
     // or `returnQuery` is explicitly set. `true` is the default in Content Lake, so skip if truthy
     returnQuery: options.filterResponse === !1 && options.returnQuery !== !1
   }, reqOpts = typeof cache < "u" || typeof next < "u" ? { ...opts, fetch: { cache, next } } : opts, $request = _dataRequest(client, httpRequest, "query", { query, params }, reqOpts);
-  return stega.enabled ? $request.pipe(
+  return console.log("_fetch: pipeline setup, stega.enabled:", stega.enabled), stega.enabled ? $request.pipe(
     operators.combineLatestWith(
       rxjs.from(
         Promise.resolve().then(function() {
@@ -944,11 +1037,18 @@ function _fetch(client, httpRequest, _stega, query, _params = {}, options = {})
     ),
     operators.map(
       ([res, stegaEncodeSourceMap]) => {
+        console.log("_fetch: stega path - processing response");
         const result = stegaEncodeSourceMap(res.result, res.resultSourceMap, stega), mappedResponse = mapResponse({ ...res, result });
-        return processDecideResponse(mappedResponse);
+        return console.log("_fetch: stega path - calling processDecideResponse"), processDecideResponse(mappedResponse);
       }
     )
-  ) : $request.pipe(operators.map(mapResponse), operators.map(processDecideResponse));
+  ) : $request.pipe(
+    operators.map((res) => {
+      console.log("_fetch: non-stega path - processing response");
+      const mappedResponse = mapResponse(res);
+      return console.log("_fetch: non-stega path - calling processDecideResponse"), processDecideResponse(mappedResponse);
+    })
+  );
 }
 function _getDocument(client, httpRequest, id, opts = {}) {
   const docId = (() => {