@wix/cli-app 1.1.157 → 1.1.159

package/build/cloudflare-runtime/entry.js

@@ -3635,11 +3635,11 @@ async function importWithAlgCache(cache, jwk, alg) {
   return cached[alg];
 }
 function createLocalJWKSet(jwks) {
-  const set2 = new LocalJWKSet(jwks);
-  const localJWKSet = async (protectedHeader, token) => set2.getKey(protectedHeader, token);
+  const set3 = new LocalJWKSet(jwks);
+  const localJWKSet = async (protectedHeader, token) => set3.getKey(protectedHeader, token);
   Object.defineProperties(localJWKSet, {
     jwks: {
-      value: () => clone(set2._jwks),
+      value: () => clone(set3._jwks),
       enumerable: true,
       configurable: false,
       writable: false
@@ -3784,32 +3784,32 @@ function isFreshJwksCache(input, cacheMaxAge) {
   return true;
 }
 function createRemoteJWKSet(url, options) {
-  const set2 = new RemoteJWKSet(url, options);
-  const remoteJWKSet = async (protectedHeader, token) => set2.getKey(protectedHeader, token);
+  const set3 = new RemoteJWKSet(url, options);
+  const remoteJWKSet = async (protectedHeader, token) => set3.getKey(protectedHeader, token);
   Object.defineProperties(remoteJWKSet, {
     coolingDown: {
-      get: () => set2.coolingDown(),
+      get: () => set3.coolingDown(),
       enumerable: true,
       configurable: false
     },
     fresh: {
-      get: () => set2.fresh(),
+      get: () => set3.fresh(),
       enumerable: true,
       configurable: false
     },
     reload: {
-      value: () => set2.reload(),
+      value: () => set3.reload(),
       enumerable: true,
       configurable: false,
       writable: false
     },
     reloading: {
-      get: () => !!set2._pendingFetch,
+      get: () => !!set3._pendingFetch,
       enumerable: true,
       configurable: false
     },
     jwks: {
-      value: () => set2._local?.jwks(),
+      value: () => set3._local?.jwks(),
       enumerable: true,
       configurable: false,
       writable: false
@@ -4445,6 +4445,15 @@ function EventDefinition(type, isDomainEvent = false, transformations = (x) => x
   });
 }
 var SERVICE_PLUGIN_ERROR_TYPE = "wix_spi_error";
+var SORT_DIRECTIONS = {
+  ASC: "ASC",
+  DESC: "DESC"
+};
+var SORT_CAPABILITIES = {
+  ...SORT_DIRECTIONS,
+  BOTH: "BOTH",
+  NONE: "NONE"
+};
 
 // ../../node_modules/@wix/sdk/build/ambassador-modules.js
 var parseMethod = (method) => {
@@ -4627,6 +4636,13 @@ function runWithoutContext(fn) {
   }
 }
 
+// ../../node_modules/@wix/sdk-runtime/build/constants.js
+var RESTResponseToSDKResponseRenameMap = {
+  id: "_id",
+  createdDate: "_createdDate",
+  updatedDate: "_updatedDate"
+};
+
 // ../../node_modules/@wix/sdk-runtime/build/utils.js
 function constantCase(input) {
   return split(input).map((part) => part.toLocaleUpperCase()).join("_");
@@ -4913,6 +4929,239 @@ var errorBuilder2 = (code, description, details, data) => {
   });
 };
 
+// ../../node_modules/@wix/sdk-runtime/build/rest-modules.js
+var DOMAINS = ["wix.com", "editorx.com"];
+var REGEX_CAPTURE_DOMAINS = new RegExp(`\\.(${DOMAINS.join("|")})$`);
+var WIX_API_DOMAINS = ["42.wixprod.net", "uw2-edt-1.wixprod.net"];
+var DEV_WIX_CODE_DOMAIN = "dev.wix-code.com";
+var REGEX_CAPTURE_API_DOMAINS = new RegExp(`\\.(${WIX_API_DOMAINS.join("|")})$`);
+var REGEX_CAPTURE_DEV_WIX_CODE_DOMAIN = new RegExp(`.*\\.${DEV_WIX_CODE_DOMAIN}$`);
+
+// ../../node_modules/@wix/sdk/build/object-utils.js
+var DELIMITER = ".";
+function set(obj, path, value) {
+  if (obj == null) {
+    throw new Error("Cannot set value on null or undefined");
+  }
+  const keys = toPathObject(path);
+  let current = obj;
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    if (i === keys.length - 1) {
+      current[key] = value;
+      break;
+    }
+    const nextKey = keys[i + 1];
+    if (!(key in current) || current[key] == null) {
+      current[key] = typeof nextKey === "number" ? [] : {};
+    } else if (typeof current[key] !== "object" || current[key] === null) {
+      current[key] = typeof nextKey === "number" ? [] : {};
+    }
+    current = current[key];
+  }
+  return obj;
+}
+function toPathObject(path) {
+  if (Array.isArray(path)) {
+    return path;
+  }
+  return path.split(DELIMITER).map((segment) => isNumericSegment(segment) ? Number(segment) : segment);
+}
+function isNumericSegment(segment) {
+  return /^\d+$/.test(segment);
+}
+
+// ../../node_modules/@wix/sdk/build/flat-utils.js
+function unflatten(flatObject) {
+  const result = {};
+  for (const [flatKey, value] of Object.entries(flatObject)) {
+    if (isPrototypePollutionKey(flatKey)) {
+      continue;
+    }
+    const path = toPathObject(flatKey);
+    set(result, path, value);
+  }
+  return result;
+}
+function isPrototypePollutionKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+
+// ../../node_modules/@wix/sdk/build/modified-fields-manipulator.js
+var ModifiedFieldsManipulator = class {
+  BRACKET_PATTERN = /\[(\d+)\]/g;
+  NUMERIC_PATTERN = /^\d+$/;
+  ESCAPED_DOT_PATTERN = /\\\./g;
+  ESCAPED_LEFT_BRACKET_PATTERN = /\\\[/g;
+  ESCAPED_RIGHT_BRACKET_PATTERN = /\\\]/g;
+  SPLIT_PATTERN = /\.|\[(\d+)\]/g;
+  DOT_BEFORE_BRACKET_PATTERN = /\.\[/g;
+  ESCAPED_DOT_PLACEHOLDER = "__DOT__";
+  ESCAPED_RIGHT_BRACKET_PLACEHOLDER = "__RB__";
+  ESCAPED_LEFT_BRACKET_PLACEHOLDER = "__LB__";
+  modifiedFields;
+  cleanedModifiedFields;
+  constructor(modifiedFields) {
+    this.modifiedFields = modifiedFields;
+  }
+  replaceEscapedCharacters(key) {
+    return key.replace(this.ESCAPED_DOT_PATTERN, this.ESCAPED_DOT_PLACEHOLDER).replace(this.ESCAPED_LEFT_BRACKET_PATTERN, this.ESCAPED_LEFT_BRACKET_PLACEHOLDER).replace(this.ESCAPED_RIGHT_BRACKET_PATTERN, this.ESCAPED_RIGHT_BRACKET_PLACEHOLDER);
+  }
+  restoreEscapedCharacters(key) {
+    return key.replace(this.ESCAPED_DOT_PLACEHOLDER, "\\.").replace(this.ESCAPED_RIGHT_BRACKET_PLACEHOLDER, "\\]").replace(this.ESCAPED_LEFT_BRACKET_PLACEHOLDER, "\\[");
+  }
+  unflatten() {
+    this.cleanedModifiedFields = Object.fromEntries(Object.entries(this.modifiedFields).map(([key, value]) => [
+      this.replaceEscapedCharacters(this.bracketToDotNotation(key)),
+      value
+    ]));
+    return unflatten(this.cleanedModifiedFields);
+  }
+  flatten(transformedModifiedFields) {
+    let result = {};
+    for (const originalKey of Object.keys(this.cleanedModifiedFields)) {
+      const pathParts = this.splitPath(originalKey);
+      const value = this.navigatePath(transformedModifiedFields, pathParts);
+      result = { ...result, ...value };
+    }
+    return Object.fromEntries(Object.entries(result).map(([key, value]) => [
+      this.restoreEscapedCharacters(key),
+      value
+    ]));
+  }
+  splitPath(path) {
+    const parts = [];
+    let lastIndex = 0;
+    const matches = Array.from(path.matchAll(this.SPLIT_PATTERN));
+    for (const match of matches) {
+      if (match.index > lastIndex) {
+        parts.push(path.substring(lastIndex, match.index));
+      }
+      if (match[1]) {
+        parts.push(match[1]);
+      }
+      lastIndex = match.index + match[0].length;
+    }
+    if (lastIndex < path.length) {
+      parts.push(path.substring(lastIndex));
+    }
+    return parts;
+  }
+  navigatePath(obj, pathParts) {
+    let current = obj;
+    const transformedPath = [];
+    const handleArray = (part) => {
+      if (!Array.isArray(current)) {
+        throw new Error(`Expected array at path ${this.buildPathString(transformedPath)}, but got ${typeof current}`);
+      }
+      transformedPath.push(`[${part}]`);
+      current = current[parseInt(part, 10)];
+    };
+    const handleTransformedKeyName = (part, currentObj) => {
+      const transformedKey = part in RESTResponseToSDKResponseRenameMap ? RESTResponseToSDKResponseRenameMap[part] : void 0;
+      if (transformedKey && transformedKey in currentObj) {
+        transformedPath.push(transformedKey);
+        current = currentObj[transformedKey];
+        return;
+      }
+      const camelCaseKey = camelCase(part);
+      if (camelCaseKey && camelCaseKey in currentObj) {
+        transformedPath.push(camelCaseKey);
+        current = currentObj[camelCaseKey];
+        return;
+      }
+      throw new Error(`Cannot find key '${part}' or its transformations at path ${this.buildPathString(transformedPath)}`);
+    };
+    const handleObject = (part, currentObj) => {
+      transformedPath.push(part);
+      current = currentObj[part];
+      return;
+    };
+    for (const part of pathParts) {
+      if (this.NUMERIC_PATTERN.test(part)) {
+        handleArray(part);
+        continue;
+      }
+      if (current === null || typeof current !== "object") {
+        throw new Error(`Cannot access property '${part}' on ${typeof current} at path ${this.buildPathString(transformedPath)}`);
+      }
+      const currentObj = current;
+      if (part in current) {
+        handleObject(part, currentObj);
+        continue;
+      }
+      handleTransformedKeyName(part, currentObj);
+    }
+    return { [this.buildPathString(transformedPath)]: current };
+  }
+  buildPathString(pathParts) {
+    return pathParts.join(".").replace(this.DOT_BEFORE_BRACKET_PATTERN, "[");
+  }
+  bracketToDotNotation(key) {
+    return key.replace(this.BRACKET_PATTERN, (match, number, offset) => {
+      if (offset > 0 && key[offset - 1] === "\\") {
+        return match;
+      }
+      return "." + number;
+    });
+  }
+};
+function attemptTransformationWithModifiedFields(envelope, transformFromRESTFn) {
+  const modifiedFields = envelope?.modifiedFields;
+  if (!modifiedFields) {
+    return null;
+  }
+  const unflattenedResult = attemptUnflatten(modifiedFields);
+  if (!unflattenedResult) {
+    return null;
+  }
+  const { unflattenedModifiedFields, modifiedFieldsManipulator } = unflattenedResult;
+  envelope = {
+    ...envelope,
+    modifiedFields: unflattenedModifiedFields
+  };
+  const transformedEnvelope = transformFromRESTFn(envelope);
+  const transformedModifiedFields = transformedEnvelope?.modifiedFields;
+  if (!transformedModifiedFields) {
+    return null;
+  }
+  const flattened = attemptFlatten(transformedModifiedFields, modifiedFieldsManipulator);
+  if (flattened !== null) {
+    transformedEnvelope.modifiedFields = flattened;
+    return transformedEnvelope;
+  }
+  return null;
+}
+function attemptUnflatten(modifiedFields) {
+  if (typeof modifiedFields === "object" && modifiedFields !== null && !Array.isArray(modifiedFields)) {
+    try {
+      const modifiedFieldsManipulator = new ModifiedFieldsManipulator(modifiedFields);
+      const unflattened = modifiedFieldsManipulator.unflatten();
+      return {
+        unflattenedModifiedFields: unflattened,
+        modifiedFieldsManipulator
+      };
+    } catch (error) {
+      return null;
+    }
+  }
+  return null;
+}
+function attemptFlatten(transformedModifiedFields, modifiedFieldsManipulator) {
+  if (typeof transformedModifiedFields === "object" && transformedModifiedFields !== null && !Array.isArray(transformedModifiedFields)) {
+    try {
+      const flattened = modifiedFieldsManipulator.flatten(transformedModifiedFields);
+      return flattened;
+    } catch (error) {
+      return null;
+    }
+  }
+  return null;
+}
+function camelCase(str) {
+  return str.replace(/[-_\s]+(.)?/g, (_, c) => c ? c.toUpperCase() : "").replace(/^./, (c) => c.toLowerCase());
+}
+
 // ../../node_modules/@wix/sdk/build/nanoevents.js
 function createNanoEvents() {
   return {
@@ -4956,9 +5205,15 @@ function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
         data: actionEvent.body,
         metadata
       };
+    } else if (updatedEvent) {
+      envelope = {
+        entity: updatedEvent.currentEntity,
+        metadata,
+        ...updatedEvent.modifiedFields ? { modifiedFields: updatedEvent.modifiedFields } : {}
+      };
     } else {
       envelope = {
-        entity: createdEvent?.entity ?? updatedEvent?.currentEntity,
+        entity: createdEvent?.entity,
         metadata
       };
     }
@@ -4969,9 +5224,21 @@ function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
     };
   }
   const transformFromRESTFn = eventDefinition.transformations ?? ((x) => x);
-  return handler(transformFromRESTFn(envelope));
+  let originalEnvelope = envelope;
+  const envelopeAny = envelope;
+  if (envelopeAny.modifiedFields) {
+    const modifiedFieldsValue = envelopeAny.modifiedFields;
+    if (typeof modifiedFieldsValue === "object" && modifiedFieldsValue !== null && !Array.isArray(modifiedFieldsValue)) {
+      originalEnvelope = structuredClone(envelope);
+      const transformedEnvelope = attemptTransformationWithModifiedFields(envelopeAny, transformFromRESTFn);
+      if (transformedEnvelope) {
+        return handler(transformedEnvelope);
+      }
+    }
+  }
+  return handler(transformFromRESTFn(originalEnvelope));
 }
-function eventHandlersModules(authStrategy) {
+function eventHandlersModules(getAuthStrategy) {
   const eventHandlers = /* @__PURE__ */ new Map();
   const webhooksEmitter = createNanoEvents();
   const client = {
@@ -4980,7 +5247,7 @@ function eventHandlersModules(authStrategy) {
     async process(jwt, opts = {
       expectedEvents: []
     }) {
-      const { eventType, identity, instanceId, payload } = await this.parseJWT(jwt);
+      const { eventType, identity, instanceId, payload, accountInfo } = await this.parseJWT(jwt);
       const allExpectedEvents = [
         ...opts.expectedEvents,
         ...Array.from(eventHandlers.keys()).map((type) => ({ type }))
@@ -4991,13 +5258,15 @@ function eventHandlersModules(authStrategy) {
       const handlers2 = eventHandlers.get(eventType) ?? [];
       await Promise.all(handlers2.map(({ eventDefinition, handler }) => runHandler(eventDefinition, handler, payload, {
         instanceId,
-        identity
+        identity,
+        accountInfo
       })));
       return {
         instanceId,
         eventType,
         payload,
-        identity
+        identity,
+        accountInfo
       };
     },
     async processRequest(request, opts) {
@@ -5005,6 +5274,7 @@ function eventHandlersModules(authStrategy) {
       return this.process(body, opts);
     },
     async parseJWT(jwt) {
+      const authStrategy = getAuthStrategy();
       if (!authStrategy.decodeJWT) {
         throw new Error("decodeJWT is not supported by the authentication strategy");
       }
@@ -5017,6 +5287,7 @@ function eventHandlersModules(authStrategy) {
       }
       const parsedDecoded = JSON.parse(decoded.data);
       const eventType = parsedDecoded.eventType;
+      const accountInfo = parsedDecoded.accountInfo;
       const instanceId = parsedDecoded.instanceId;
       const identity = parsedDecoded.identity ? JSON.parse(parsedDecoded.identity) : void 0;
       const payload = JSON.parse(parsedDecoded.data);
@@ -5024,7 +5295,8 @@ function eventHandlersModules(authStrategy) {
         instanceId,
         eventType,
         payload,
-        identity
+        identity,
+        accountInfo
       };
     },
     async parseRequest(request) {
@@ -5062,13 +5334,14 @@ function eventHandlersModules(authStrategy) {
 
 // ../../node_modules/@wix/sdk/build/service-plugin-modules.js
 var isServicePluginModule = (val) => val.__type === "service-plugin-definition";
-function servicePluginsModules(authStrategy) {
+function servicePluginsModules(getAuthStrategy) {
   const servicePluginsImplementations = /* @__PURE__ */ new Map();
   const servicePluginsEmitter = createNanoEvents();
   const client = {
     ...servicePluginsEmitter,
     getRegisteredServicePlugins: () => servicePluginsImplementations,
     async parseJWT(jwt) {
+      const authStrategy = getAuthStrategy();
       if (!authStrategy.decodeJWT) {
         throw new Error("decodeJWT is not supported by the authentication strategy");
       }
@@ -5139,11 +5412,14 @@ function servicePluginsModules(authStrategy) {
 var X_WIX_CONSISTENT_HEADER = "X-Wix-Consistent";
 function createClient(config) {
   const _headers = config.headers || { Authorization: "" };
-  const authStrategy = config.auth || {
+  const defaultStrategy = {
     getAuthHeaders: (_) => Promise.resolve({ headers: {} })
   };
-  const boundGetAuthHeaders = authStrategy.getAuthHeaders.bind(void 0, config.host);
-  authStrategy.getAuthHeaders = boundGetAuthHeaders;
+  const auth = config.auth;
+  const getAuthStrategy = typeof auth === "function" ? auth : () => auth ?? defaultStrategy;
+  const boundGetAuthHeaders = () => {
+    return getAuthStrategy().getAuthHeaders(config.host);
+  };
   const fetchWithAuth = async (urlOrRequest, requestInit) => {
     const authHeaders = await boundGetAuthHeaders();
     const headers = {
@@ -5199,8 +5475,8 @@ function createClient(config) {
       throw e;
     }
   };
-  const { client: servicePluginsClient, initModule: initServicePluginModule } = servicePluginsModules(authStrategy);
-  const { client: eventHandlersClient, initModule: initEventHandlerModule } = eventHandlersModules(authStrategy);
+  const { client: servicePluginsClient, initModule: initServicePluginModule } = servicePluginsModules(getAuthStrategy);
+  const { client: eventHandlersClient, initModule: initEventHandlerModule } = eventHandlersModules(getAuthStrategy);
   const boundFetch = async (url, options) => {
     const authHeaders = await boundGetAuthHeaders();
     const defaultContentTypeHeader = getDefaultContentHeader(options);
@@ -5234,13 +5510,13 @@ function createClient(config) {
         return modules;
       }
       const apiBaseUrl = config.host?.apiBaseUrl ?? DEFAULT_API_URL;
-      const shouldUseCDN = config.useCDN === void 0 ? config.auth?.shouldUseCDN : config.useCDN;
+      const shouldUseCDN = config.useCDN === void 0 ? getAuthStrategy().shouldUseCDN : config.useCDN;
       return buildRESTDescriptor(runWithoutContext(() => isAmbassadorModule(modules)) ? toHTTPModule(modules) : modules, metadata ?? {}, boundFetch, config.host?.getErrorHandler?.(), (relativeUrl, fetchOptions) => {
         const finalUrl = new URL(relativeUrl, `https://${apiBaseUrl}`);
         finalUrl.host = apiBaseUrl;
         finalUrl.protocol = "https";
         return boundFetch(finalUrl.toString(), fetchOptions);
-      }, authStrategy.getActiveToken, { HTTPHost: apiBaseUrl }, config.host?.name, shouldUseCDN);
+      }, getAuthStrategy().getActiveToken, { HTTPHost: apiBaseUrl }, config.host?.name, shouldUseCDN);
     } else if (isObject(modules)) {
       return Object.fromEntries(Object.entries(modules).map(([key, value]) => {
         return [key, use(value, modules[PUBLIC_METADATA_KEY])];
@@ -5257,7 +5533,12 @@ function createClient(config) {
   const wrappedModules = config.modules ? use(config.modules) : {};
   return {
     ...wrappedModules,
-    auth: authStrategy,
+    get auth() {
+      const authStrategy = getAuthStrategy();
+      const originalGetAuthHeaders = authStrategy.getAuthHeaders;
+      authStrategy.getAuthHeaders = originalGetAuthHeaders.bind(void 0, config.host);
+      return authStrategy;
+    },
     setHeaders,
     use,
     enableContext(contextType, opts = { elevated: false }) {
@@ -12647,7 +12928,7 @@ function timing(aggregator, name, value, unit = "second", data) {
   }
   distribution(aggregator, name, value, { ...data, unit });
 }
-function set(aggregator, name, value, data) {
+function set2(aggregator, name, value, data) {
   addToMetricsAggregator(aggregator, SET_METRIC_TYPE, name, value, data);
 }
 function gauge(aggregator, name, value, data) {
@@ -12656,7 +12937,7 @@ function gauge(aggregator, name, value, data) {
 var metrics = {
   increment,
   distribution,
-  set,
+  set: set2,
   gauge,
   timing,
   /**