@wix/sdk 1.17.4 → 1.17.6

package/build/event-handlers-modules.js

@@ -1,4 +1,5 @@
 import { EventDefinition, } from '@wix/sdk-types';
+import { attemptTransformationWithModifiedFields } from './modified-fields-manipulator.js';
 import { createNanoEvents } from './nanoevents.js';
 export const isEventHandlerModule = (val) => val.__type === 'event-definition';
 export function buildEventDefinition(eventDefinition, registerHandler) {
@@ -32,9 +33,19 @@ function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
                 metadata,
             };
         }
+        else if (updatedEvent) {
+            envelope = {
+                entity: updatedEvent.currentEntity,
+                metadata,
+                ...(updatedEvent.modifiedFields
+                    ? { modifiedFields: updatedEvent.modifiedFields }
+                    : {}),
+            };
+        }
         else {
+            // createdEvent
             envelope = {
-                entity: createdEvent?.entity ?? updatedEvent?.currentEntity,
+                entity: createdEvent?.entity,
                 metadata,
             };
         }
@@ -46,7 +57,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));
 }
 export function eventHandlersModules(authStrategy) {
     const eventHandlers = new Map();

package/build/modified-fields-manipulator.d.ts

@@ -0,0 +1,35 @@
+export declare class ModifiedFieldsManipulator {
+    private readonly BRACKET_PATTERN;
+    private readonly NUMERIC_PATTERN;
+    private readonly ESCAPED_DOT_PATTERN;
+    private readonly ESCAPED_LEFT_BRACKET_PATTERN;
+    private readonly ESCAPED_RIGHT_BRACKET_PATTERN;
+    private readonly SPLIT_PATTERN;
+    private readonly DOT_BEFORE_BRACKET_PATTERN;
+    private readonly ESCAPED_DOT_PLACEHOLDER;
+    private readonly ESCAPED_RIGHT_BRACKET_PLACEHOLDER;
+    private readonly ESCAPED_LEFT_BRACKET_PLACEHOLDER;
+    private readonly modifiedFields;
+    private cleanedModifiedFields;
+    constructor(modifiedFields: Record<string, unknown>);
+    private replaceEscapedCharacters;
+    private restoreEscapedCharacters;
+    unflatten(): Record<string, unknown>;
+    flatten(transformedModifiedFields: Record<string, unknown>): Record<string, unknown>;
+    private splitPath;
+    private navigatePath;
+    private buildPathString;
+    private bracketToDotNotation;
+}
+/**
+ * Transforms an envelope while preserving the structure of modifiedFields.
+ *
+ * Modified fields come as flattened objects, while transformations are applied to the nested object (e.g. "a.b.c" -> { a: { b: { c: 'value' } } }).
+ * This function handles the transformation of envelopes that contain flattened modifiedFields.
+ * It unflattens the modifiedFields, applies the transformation function, and then flattens
+ * the modifiedFields back to their original format while preserving the transformation.
+ * @param envelope - The envelope object containing flattened modifiedFields
+ * @param transformFromRESTFn - Function to transform the envelope from REST format to SDK format
+ * @returns The transformed envelope with flattened modifiedFields, or null if transformation fails
+ */
+export declare function attemptTransformationWithModifiedFields(envelope: any, transformFromRESTFn: (envelope: unknown) => unknown): unknown;

package/build/modified-fields-manipulator.js

@@ -0,0 +1,205 @@
+import { unflatten } from 'flat';
+import { RESTResponseToSDKResponseRenameMap } from '@wix/sdk-runtime/rest-modules';
+export class ModifiedFieldsManipulator {
+    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]
+                : undefined;
+            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;
+        });
+    }
+}
+/**
+ * Transforms an envelope while preserving the structure of modifiedFields.
+ *
+ * Modified fields come as flattened objects, while transformations are applied to the nested object (e.g. "a.b.c" -> { a: { b: { c: 'value' } } }).
+ * This function handles the transformation of envelopes that contain flattened modifiedFields.
+ * It unflattens the modifiedFields, applies the transformation function, and then flattens
+ * the modifiedFields back to their original format while preserving the transformation.
+ * @param envelope - The envelope object containing flattened modifiedFields
+ * @param transformFromRESTFn - Function to transform the envelope from REST format to SDK format
+ * @returns The transformed envelope with flattened modifiedFields, or null if transformation fails
+ */
+export 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;
+}
+// Simple camelCase implementation to avoid lodash (which uses `new Function()` internally
+// and breaks Cloudflare Workers/Edge runtimes)
+function camelCase(str) {
+    return str
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^./, (c) => c.toLowerCase());
+}

package/cjs/build/event-handlers-modules.js

@@ -4,6 +4,7 @@ exports.isEventHandlerModule = void 0;
 exports.buildEventDefinition = buildEventDefinition;
 exports.eventHandlersModules = eventHandlersModules;
 const sdk_types_1 = require("@wix/sdk-types");
+const modified_fields_manipulator_js_1 = require("./modified-fields-manipulator.js");
 const nanoevents_js_1 = require("./nanoevents.js");
 const isEventHandlerModule = (val) => val.__type === 'event-definition';
 exports.isEventHandlerModule = isEventHandlerModule;
@@ -38,9 +39,19 @@ function runHandler(eventDefinition, handler, payload, baseEventMetadata) {
                 metadata,
             };
         }
+        else if (updatedEvent) {
+            envelope = {
+                entity: updatedEvent.currentEntity,
+                metadata,
+                ...(updatedEvent.modifiedFields
+                    ? { modifiedFields: updatedEvent.modifiedFields }
+                    : {}),
+            };
+        }
         else {
+            // createdEvent
             envelope = {
-                entity: createdEvent?.entity ?? updatedEvent?.currentEntity,
+                entity: createdEvent?.entity,
                 metadata,
             };
         }
@@ -52,7 +63,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 = (0, modified_fields_manipulator_js_1.attemptTransformationWithModifiedFields)(envelopeAny, transformFromRESTFn);
+            if (transformedEnvelope) {
+                return handler(transformedEnvelope);
+            }
+        }
+    }
+    return handler(transformFromRESTFn(originalEnvelope));
 }
 function eventHandlersModules(authStrategy) {
     const eventHandlers = new Map();

package/cjs/build/modified-fields-manipulator.d.ts

@@ -0,0 +1,35 @@
+export declare class ModifiedFieldsManipulator {
+    private readonly BRACKET_PATTERN;
+    private readonly NUMERIC_PATTERN;
+    private readonly ESCAPED_DOT_PATTERN;
+    private readonly ESCAPED_LEFT_BRACKET_PATTERN;
+    private readonly ESCAPED_RIGHT_BRACKET_PATTERN;
+    private readonly SPLIT_PATTERN;
+    private readonly DOT_BEFORE_BRACKET_PATTERN;
+    private readonly ESCAPED_DOT_PLACEHOLDER;
+    private readonly ESCAPED_RIGHT_BRACKET_PLACEHOLDER;
+    private readonly ESCAPED_LEFT_BRACKET_PLACEHOLDER;
+    private readonly modifiedFields;
+    private cleanedModifiedFields;
+    constructor(modifiedFields: Record<string, unknown>);
+    private replaceEscapedCharacters;
+    private restoreEscapedCharacters;
+    unflatten(): Record<string, unknown>;
+    flatten(transformedModifiedFields: Record<string, unknown>): Record<string, unknown>;
+    private splitPath;
+    private navigatePath;
+    private buildPathString;
+    private bracketToDotNotation;
+}
+/**
+ * Transforms an envelope while preserving the structure of modifiedFields.
+ *
+ * Modified fields come as flattened objects, while transformations are applied to the nested object (e.g. "a.b.c" -> { a: { b: { c: 'value' } } }).
+ * This function handles the transformation of envelopes that contain flattened modifiedFields.
+ * It unflattens the modifiedFields, applies the transformation function, and then flattens
+ * the modifiedFields back to their original format while preserving the transformation.
+ * @param envelope - The envelope object containing flattened modifiedFields
+ * @param transformFromRESTFn - Function to transform the envelope from REST format to SDK format
+ * @returns The transformed envelope with flattened modifiedFields, or null if transformation fails
+ */
+export declare function attemptTransformationWithModifiedFields(envelope: any, transformFromRESTFn: (envelope: unknown) => unknown): unknown;

package/cjs/build/modified-fields-manipulator.js

@@ -0,0 +1,210 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModifiedFieldsManipulator = void 0;
+exports.attemptTransformationWithModifiedFields = attemptTransformationWithModifiedFields;
+const flat_1 = require("flat");
+const rest_modules_1 = require("@wix/sdk-runtime/rest-modules");
+class ModifiedFieldsManipulator {
+    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 (0, flat_1.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 rest_modules_1.RESTResponseToSDKResponseRenameMap
+                ? rest_modules_1.RESTResponseToSDKResponseRenameMap[part]
+                : undefined;
+            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;
+        });
+    }
+}
+exports.ModifiedFieldsManipulator = ModifiedFieldsManipulator;
+/**
+ * Transforms an envelope while preserving the structure of modifiedFields.
+ *
+ * Modified fields come as flattened objects, while transformations are applied to the nested object (e.g. "a.b.c" -> { a: { b: { c: 'value' } } }).
+ * This function handles the transformation of envelopes that contain flattened modifiedFields.
+ * It unflattens the modifiedFields, applies the transformation function, and then flattens
+ * the modifiedFields back to their original format while preserving the transformation.
+ * @param envelope - The envelope object containing flattened modifiedFields
+ * @param transformFromRESTFn - Function to transform the envelope from REST format to SDK format
+ * @returns The transformed envelope with flattened modifiedFields, or null if transformation fails
+ */
+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;
+}
+// Simple camelCase implementation to avoid lodash (which uses `new Function()` internally
+// and breaks Cloudflare Workers/Edge runtimes)
+function camelCase(str) {
+    return str
+        .replace(/[-_\s]+(.)?/g, (_, c) => (c ? c.toUpperCase() : ''))
+        .replace(/^./, (c) => c.toLowerCase());
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wix/sdk",
-  "version": "1.17.4",
+  "version": "1.17.6",
   "license": "MIT",
   "author": {
     "name": "Ronny Ringel",
@@ -76,8 +76,9 @@
     "@wix/image-kit": "^1.114.0",
     "@wix/redirects": "^1.0.70",
     "@wix/sdk-context": "0.0.1",
-    "@wix/sdk-runtime": "1.0.0",
-    "@wix/sdk-types": "1.14.0",
+    "@wix/sdk-runtime": "1.0.1",
+    "@wix/sdk-types": "1.16.0",
+    "flat": "^6.0.1",
     "jose": "^5.10.0",
     "type-fest": "^4.41.0"
   },
@@ -86,19 +87,19 @@
   },
   "devDependencies": {
     "@types/is-ci": "^3.0.4",
-    "@types/node": "^20.19.24",
+    "@types/node": "^20.19.25",
     "@vitest/ui": "^1.6.1",
     "@wix/ecom": "^1.0.886",
     "@wix/events": "^1.0.382",
     "@wix/metro": "^1.0.93",
     "@wix/metro-runtime": "^1.1891.0",
-    "@wix/sdk-runtime": "1.0.0",
+    "@wix/sdk-runtime": "1.0.1",
     "eslint": "^8.57.1",
     "eslint-config-sdk": "1.0.0",
     "graphql": "^16.8.0",
     "is-ci": "^3.0.1",
     "jsdom": "^22.1.0",
-    "msw": "^2.12.0",
+    "msw": "^2.12.2",
     "typescript": "^5.9.3",
     "vitest": "^1.6.1",
     "vitest-teamcity-reporter": "^0.3.1"
@@ -126,5 +127,5 @@
   "wallaby": {
     "autoDetect": true
   },
-  "falconPackageHash": "eacf57f635a721131d0cbb326058cde3c0bdde089387ae82f60df8d5"
+  "falconPackageHash": "25d16bf9f75c7cef263c96b55f2354cca27dc38f4cb230c62b00251f"
 }