auth0-deploy-cli 8.25.0 → 8.27.0

package/lib/tools/auth0/handlers/connections.js

@@ -168,16 +168,21 @@ const getConnectionEnabledClients = async (auth0Client, connectionId) => {
     try {
         const enabledClientsFormatted = [];
         let enabledClients = await auth0Client.connections.clients.get(connectionId);
-        do {
-            if (enabledClients && enabledClients.data?.length > 0) {
-                enabledClients.data.forEach((client) => {
-                    if (client?.client_id) {
-                        enabledClientsFormatted.push(client.client_id);
-                    }
-                });
+        // Process first page
+        enabledClients.data?.forEach((client) => {
+            if (client?.client_id) {
+                enabledClientsFormatted.push(client.client_id);
             }
+        });
+        // Fetch remaining pages
+        while (enabledClients.hasNextPage()) {
             enabledClients = await enabledClients.getNextPage();
-        } while (enabledClients.hasNextPage());
+            enabledClients.data?.forEach((client) => {
+                if (client?.client_id) {
+                    enabledClientsFormatted.push(client.client_id);
+                }
+            });
+        }
         return enabledClientsFormatted;
     }
     catch (error) {
@@ -195,13 +200,36 @@ exports.getConnectionEnabledClients = getConnectionEnabledClients;
  * @returns Promise that resolves to true if the update was successful, false otherwise
  *
  */
-const updateConnectionEnabledClients = async (auth0Client, typeName, connectionId, enabledClientIds) => {
+const updateConnectionEnabledClients = async (auth0Client, typeName, connectionId, enabledClientIds, existingConnections) => {
     if (!connectionId || !Array.isArray(enabledClientIds) || !enabledClientIds.length)
         return false;
-    const enabledClientUpdatePayloads = enabledClientIds.map((clientId) => ({
-        client_id: clientId,
-        status: true,
-    }));
+    let existingEnabledClients = [];
+    if (Array.isArray(existingConnections)) {
+        const existingConnection = existingConnections.find((con) => con.id === connectionId);
+        existingEnabledClients = existingConnection?.enabled_clients ?? [];
+    }
+    // Determine which clients to enable vs. disable by comparing the incoming `enabledClientIds` with the `existingEnabledClients`.
+    const enabledClientIdSet = new Set(enabledClientIds);
+    const existingClientIdSet = new Set(existingEnabledClients);
+    // If both sets are identical, skip the update entirely.
+    if (enabledClientIdSet.size === existingClientIdSet.size &&
+        [...enabledClientIdSet].every((id) => existingClientIdSet.has(id))) {
+        logger_1.default.debug(`Enabled clients for ${typeName}: ${connectionId} are unchanged, skipping update`);
+        return true;
+    }
+    const clientsToEnable = enabledClientIds;
+    // Any client that exists on the tenant but not in the provided `enabledClientIds` should be disabled.
+    const clientsToDisable = existingEnabledClients.filter((clientId) => !enabledClientIdSet.has(clientId));
+    const enabledClientUpdatePayloads = [
+        ...clientsToEnable.map((clientId) => ({
+            client_id: clientId,
+            status: true,
+        })),
+        ...clientsToDisable.map((clientId) => ({
+            client_id: clientId,
+            status: false,
+        })),
+    ];
     const payloadChunks = (0, lodash_1.chunk)(enabledClientUpdatePayloads, 50);
     try {
         await Promise.all(payloadChunks.map((payload) => auth0Client.connections.clients.update(connectionId, payload)));
@@ -225,7 +253,7 @@ exports.updateConnectionEnabledClients = updateConnectionEnabledClients;
  *
  * @returns A Promise that resolves when all enabled client updates are complete
  */
-const processConnectionEnabledClients = async (auth0Client, typeName, changes, delayMs = 2500 // Default delay is 2.5 seconds
+const processConnectionEnabledClients = async (auth0Client, typeName, existingConnections, changes, delayMs = 2500 // Default delay is 2.5 seconds
 ) => {
     const { create, update, conflicts } = changes;
     let createWithId = [];
@@ -262,9 +290,9 @@ const processConnectionEnabledClients = async (auth0Client, typeName, changes, d
     // Process enabled clients for each change type
     // Delete is handled by the `processChanges` method, removed connection completely
     await Promise.all([
-        ...createWithId.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients)),
-        ...update.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients)),
-        ...conflicts.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients)),
+        ...createWithId.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients, existingConnections)),
+        ...update.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients, existingConnections)),
+        ...conflicts.map((conn) => (0, exports.updateConnectionEnabledClients)(auth0Client, typeName, conn.id, conn.enabled_clients, existingConnections)),
     ]);
 };
 exports.processConnectionEnabledClients = processConnectionEnabledClients;
@@ -277,7 +305,7 @@ class ConnectionsHandler extends default_1.default {
             functions: {
                 // When `connections` is updated, it can result in `update`,`create` or `delete` action on SCIM.
                 // Because, `scim_configuration` is inside `connections`.
-                update: async (requestParams, bodyParams) => this.scimHandler.updateOverride(requestParams, bodyParams),
+                update: async (connectionId, bodyParams) => this.scimHandler.updateOverride(connectionId, bodyParams),
                 // When a new `connection` is created. We can perform only `create` option on SCIM.
                 // When a connection is `deleted`. `scim_configuration` is also deleted along with it; no action on SCIM is required.
                 create: async (bodyParams) => this.scimHandler.createOverride(bodyParams),
@@ -306,45 +334,19 @@ class ConnectionsHandler extends default_1.default {
         }
     }
     /**
-     * Retrieves directory provisioning configuration for a specific Auth0 connection.
-     * @param connectionId - The unique identifier of the connection
-     * @returns A promise that resolves to the configuration object, or null if not configured/supported
+     * Retrieves all directory provisioning configurations for all connections.
+     * @returns A promise that resolves to the configurations object, or null if not configured/supported
      */
-    async getConnectionDirectoryProvisioning(connectionId) {
-        if (!connectionId)
-            return null;
-        const creates = [connectionId];
-        let config = null;
+    async getConnectionDirectoryProvisionings() {
+        let directoryProvisioningConfigs;
         try {
-            await this.client.pool
-                .addEachTask({
-                data: creates || [],
-                generator: async (id) => this.client.connections.directoryProvisioning
-                    .get(id)
-                    .then((resp) => {
-                    config = resp;
-                })
-                    .catch((err) => {
-                    throw new auth0_1.ManagementError(err);
-                }),
-            })
-                .promise();
-            const stripKeysFromOutput = [
-                'connection_id',
-                'connection_name',
-                'strategy',
-                'created_at',
-                'updated_at',
-            ];
-            stripKeysFromOutput.forEach((key) => {
-                if (config && key in config) {
-                    delete config[key];
-                }
+            directoryProvisioningConfigs = await (0, client_1.paginate)(this.client.connections.directoryProvisioning.list, {
+                checkpoint: true,
             });
-            return config;
+            return directoryProvisioningConfigs;
         }
         catch (error) {
-            const errLog = `Unable to fetch directory provisioning for connection '${connectionId}'. `;
+            const errLog = `Unable to fetch directory provisioning for connections. `;
             if (error instanceof auth0_1.ManagementError) {
                 const bodyMessage = error.body?.message;
                 logger_1.default.warn(errLog + bodyMessage);
@@ -471,9 +473,12 @@ class ConnectionsHandler extends default_1.default {
     async getType() {
         if (this.existing)
             return this.existing;
-        const connections = await (0, client_1.paginate)(this.client.connections.list, {
-            checkpoint: true,
-        });
+        const [connections, directoryProvisioningConfigs] = await Promise.all([
+            (0, client_1.paginate)(this.client.connections.list, {
+                checkpoint: true,
+            }),
+            this.getConnectionDirectoryProvisionings(),
+        ]);
         // Filter out database connections as we have separate handler for it
         const filteredConnections = connections.filter((c) => c.strategy !== 'auth0');
         // If options option is empty for all connection, log the missing options scope.
@@ -493,10 +498,13 @@ class ConnectionsHandler extends default_1.default {
             if (enabledClients && enabledClients?.length) {
                 connection.enabled_clients = enabledClients;
             }
-            if (connection.strategy === 'google-apps') {
-                const dirProvConfig = await this.getConnectionDirectoryProvisioning(con.id);
+            if (connection.strategy === 'google-apps' && directoryProvisioningConfigs) {
+                const dirProvConfig = directoryProvisioningConfigs.find((congigCon) => congigCon.connection_id === con.id);
                 if (dirProvConfig) {
-                    connection.directory_provisioning_configuration = dirProvConfig;
+                    connection.directory_provisioning_configuration = {
+                        mapping: dirProvConfig.mapping,
+                        synchronize_automatically: dirProvConfig.synchronize_automatically,
+                    };
                 }
             }
             return connection;
@@ -558,7 +566,7 @@ class ConnectionsHandler extends default_1.default {
         changes = (0, utils_1.filterIncluded)(changes, includedConnections);
         await super.processChanges(assets, changes);
         // process enabled clients
-        await (0, exports.processConnectionEnabledClients)(this.client, this.type, changes);
+        await (0, exports.processConnectionEnabledClients)(this.client, this.type, await this.existing, changes);
         // process directory provisioning
         await this.processConnectionDirectoryProvisioning(changes);
     }

package/lib/tools/auth0/handlers/customDomains.d.ts

@@ -46,6 +46,10 @@ export declare const schema: {
                 description: string;
                 defaultValue: string;
             };
+            relying_party_identifier: {
+                type: string[];
+                description: string;
+            };
         };
         required: string[];
     };

package/lib/tools/auth0/handlers/customDomains.js

@@ -77,6 +77,10 @@ exports.schema = {
                 description: 'Custom domain verification method. Must be `txt`.',
                 defaultValue: 'txt',
             },
+            relying_party_identifier: {
+                type: ['string'],
+                description: 'Relying Party ID (rpId) to be used for Passkeys on this custom domain. If not provided or set to null, the full domain will be used.',
+            },
         },
         required: ['domain', 'type'],
     },
@@ -95,6 +99,7 @@ class CustomDomainsHadnler extends default_1.default {
                 'certificate',
                 'created_at',
                 'updated_at',
+                'is_default',
             ],
             stripUpdateFields: [
                 'status',
@@ -106,10 +111,8 @@ class CustomDomainsHadnler extends default_1.default {
                 'certificate',
                 'created_at',
                 'updated_at',
+                'is_default',
             ],
-            functions: {
-                update: (args, data) => this.client.customDomains.update(args.custom_domain_id, data),
-            },
         });
     }
     objString(item) {

package/lib/tools/auth0/handlers/databases.d.ts

@@ -1,5 +1,7 @@
 import DefaultAPIHandler from './default';
-import { CalculatedChanges, Assets, Asset } from '../../../types';
+import { CalculatedChanges, Assets } from '../../../types';
+import { Connection } from './connections';
+import { Action } from './actions';
 export declare const schema: {
     type: string;
     items: {
@@ -16,6 +18,50 @@ export declare const schema: {
             options: {
                 type: string;
                 properties: {
+                    authentication_methods: {
+                        type: string;
+                        properties: {
+                            passkey: {
+                                type: string;
+                                properties: {
+                                    enabled: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                            password: {
+                                type: string;
+                                properties: {
+                                    enabled: {
+                                        type: string;
+                                    };
+                                    api_behavior: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                            email_otp: {
+                                type: string;
+                                properties: {
+                                    enabled: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                            phone_otp: {
+                                type: string;
+                                properties: {
+                                    enabled: {
+                                        type: string;
+                                    };
+                                };
+                            };
+                        };
+                    };
+                    disable_self_service_change_password: {
+                        type: string;
+                        default: boolean;
+                    };
                     customScripts: {
                         type: string;
                         properties: {};
@@ -36,6 +82,10 @@ export declare const schema: {
                                             active: {
                                                 type: string;
                                             };
+                                            default_method: {
+                                                type: string;
+                                                enum: string[];
+                                            };
                                         };
                                     };
                                     profile_required: {
@@ -73,6 +123,10 @@ export declare const schema: {
                                             active: {
                                                 type: string;
                                             };
+                                            default_method: {
+                                                type: string;
+                                                enum: string[];
+                                            };
                                         };
                                     };
                                     profile_required: {
@@ -106,6 +160,10 @@ export declare const schema: {
                                             active: {
                                                 type: string;
                                             };
+                                            default_method: {
+                                                type: string;
+                                                enum: string[];
+                                            };
                                         };
                                     };
                                     profile_required: {
@@ -124,6 +182,14 @@ export declare const schema: {
                             };
                         };
                     };
+                    custom_password_hash: {
+                        type: string;
+                        properties: {
+                            action_id: {
+                                type: string;
+                            };
+                        };
+                    };
                 };
             };
         };
@@ -131,12 +197,15 @@ export declare const schema: {
     };
 };
 export default class DatabaseHandler extends DefaultAPIHandler {
+    existing: Connection[] | null;
     constructor(config: DefaultAPIHandler);
     objString(db: any): string;
+    getFormattedOptions(options: any, actions?: Action[]): any;
     validate(assets: Assets): Promise<void>;
+    private validatePasswordlessSettings;
     private validateEmailUniqueConstraints;
     getClientFN(fn: 'create' | 'delete' | 'getAll' | 'update'): Function;
-    getType(): Promise<Asset | Asset[]>;
+    getType(): Promise<Connection[]>;
     calcChanges(assets: Assets): Promise<CalculatedChanges>;
     processChanges(assets: Assets): Promise<void>;
 }

package/lib/tools/auth0/handlers/databases.js

@@ -60,6 +60,37 @@ exports.schema = {
             options: {
                 type: 'object',
                 properties: {
+                    authentication_methods: {
+                        type: 'object',
+                        properties: {
+                            passkey: {
+                                type: 'object',
+                                properties: {
+                                    enabled: { type: 'boolean' },
+                                },
+                            },
+                            password: {
+                                type: 'object',
+                                properties: {
+                                    enabled: { type: 'boolean' },
+                                    api_behavior: { type: 'string' },
+                                },
+                            },
+                            email_otp: {
+                                type: 'object',
+                                properties: {
+                                    enabled: { type: 'boolean' },
+                                },
+                            },
+                            phone_otp: {
+                                type: 'object',
+                                properties: {
+                                    enabled: { type: 'boolean' },
+                                },
+                            },
+                        },
+                    },
+                    disable_self_service_change_password: { type: 'boolean', default: false },
                     customScripts: {
                         type: 'object',
                         properties: {
@@ -77,6 +108,7 @@ exports.schema = {
                                         type: 'object',
                                         properties: {
                                             active: { type: 'boolean' },
+                                            default_method: { type: 'string', enum: ['password', 'email_otp'] },
                                         },
                                     },
                                     profile_required: { type: 'boolean' },
@@ -102,6 +134,7 @@ exports.schema = {
                                         type: 'object',
                                         properties: {
                                             active: { type: 'boolean' },
+                                            default_method: { type: 'string', enum: ['password', 'phone_otp'] },
                                         },
                                     },
                                     profile_required: { type: 'boolean' },
@@ -126,6 +159,7 @@ exports.schema = {
                                         type: 'object',
                                         properties: {
                                             active: { type: 'boolean' },
+                                            default_method: { type: 'string', enum: ['password'] },
                                         },
                                     },
                                     profile_required: { type: 'boolean' },
@@ -139,6 +173,12 @@ exports.schema = {
                             },
                         },
                     },
+                    custom_password_hash: {
+                        type: 'object',
+                        properties: {
+                            action_id: { type: 'string' },
+                        },
+                    },
                 },
             },
         },
@@ -156,6 +196,22 @@ class DatabaseHandler extends default_1.default {
     objString(db) {
         return super.objString({ name: db.name, id: db.id });
     }
+    getFormattedOptions(options, actions = []) {
+        try {
+            const formattedOptions = { ...options };
+            // Handle custom_password_hash.action_id conversion
+            if (options?.custom_password_hash?.action_id) {
+                formattedOptions.custom_password_hash = {
+                    ...options.custom_password_hash,
+                    action_id: (0, utils_1.convertActionNameToId)(options.custom_password_hash.action_id, actions),
+                };
+            }
+            return formattedOptions;
+        }
+        catch (e) {
+            return {};
+        }
+    }
     async validate(assets) {
         const { databases } = assets;
         // Do nothing if not set
@@ -164,9 +220,25 @@ class DatabaseHandler extends default_1.default {
         // Validate each database
         databases.forEach((database) => {
             this.validateEmailUniqueConstraints(database);
+            // this.validatePasswordlessSettings(database); // Enable only the feature is GA PR:#1282
         });
         await super.validate(assets);
     }
+    validatePasswordlessSettings(payload) {
+        const options = payload?.options;
+        if (!options)
+            return;
+        const passwordEnabled = options?.authentication_methods?.password?.enabled;
+        const disableSelfServiceChangePassword = options?.disable_self_service_change_password;
+        if (passwordEnabled === undefined || disableSelfServiceChangePassword === undefined)
+            return;
+        if (passwordEnabled === false && disableSelfServiceChangePassword !== true) {
+            throw new Error(`Database "${payload.name}": When password authentication is disabled, disable_self_service_change_password must be true.`);
+        }
+        if (passwordEnabled === true && disableSelfServiceChangePassword === true) {
+            throw new Error(`Database "${payload.name}": disable_self_service_change_password must be false when password authentication is enabled.`);
+        }
+    }
     validateEmailUniqueConstraints(payload) {
         const attributes = payload?.options?.attributes;
         // Only validate if attributes are present
@@ -192,11 +264,16 @@ class DatabaseHandler extends default_1.default {
     getClientFN(fn) {
         // Override this as a database is actually a connection but we are treating them as a different object
         if (fn === 'create') {
-            return (payload) => this.client.connections.create(payload);
+            return (payload) => {
+                // Remove deprecated enabled_clients field
+                if ('enabled_clients' in payload)
+                    delete payload.enabled_clients;
+                return this.client.connections.create(payload);
+            };
         }
         // If we going to update database, we need to get current options first
         if (fn === 'update') {
-            return (params, payload) => this.client.connections.get(params?.id).then((response) => {
+            return (id, payload) => this.client.connections.get(id).then((response) => {
                 const connection = response;
                 const attributes = payload?.options?.attributes;
                 const requiresUsername = payload?.options?.requires_username;
@@ -215,7 +292,10 @@ class DatabaseHandler extends default_1.default {
                 if (payload.options && Object.keys(payload.options).length === 0) {
                     delete payload.options;
                 }
-                return this.client.connections.update(params.id, payload);
+                // Remove deprecated enabled_clients field
+                if ('enabled_clients' in payload)
+                    delete payload.enabled_clients;
+                return this.client.connections.update(id, payload);
             });
         }
         return this.client.connections[fn].bind(this.client.connections);
@@ -223,25 +303,52 @@ class DatabaseHandler extends default_1.default {
     async getType() {
         if (this.existing)
             return this.existing;
-        const connections = await (0, client_1.paginate)(this.client.connections.list, {
-            strategy: [auth0_1.Management.ConnectionStrategyEnum.Auth0],
-            checkpoint: true,
-        });
+        // Fetch connections and actions concurrently
+        const [connections, actions] = await Promise.all([
+            (0, client_1.paginate)(this.client.connections.list, {
+                strategy: [auth0_1.Management.ConnectionStrategyEnum.Auth0],
+                checkpoint: true,
+            }),
+            (0, client_1.paginate)(this.client.actions.list, {
+                paginate: true,
+                include_totals: true,
+            }),
+        ]);
         const dbConnectionsWithEnabledClients = await Promise.all(connections.map(async (con) => {
             if (!con?.id)
                 return con;
             const enabledClients = await (0, connections_1.getConnectionEnabledClients)(this.client, con.id);
+            const connection = { ...con };
             if (enabledClients && enabledClients?.length) {
-                return { ...con, enabled_clients: enabledClients };
+                connection.enabled_clients = enabledClients;
             }
-            return con;
+            return connection;
         }));
+        // Convert action ID back to action name for export
+        const dbConnectionsWithActionNames = dbConnectionsWithEnabledClients.map((connection) => {
+            if (connection.options && 'custom_password_hash' in connection.options) {
+                const customPasswordHash = connection.options?.custom_password_hash;
+                if (customPasswordHash?.action_id) {
+                    return {
+                        ...connection,
+                        options: {
+                            ...connection.options,
+                            custom_password_hash: {
+                                ...customPasswordHash,
+                                action_id: (0, utils_1.convertActionIdToName)(customPasswordHash.action_id, actions),
+                            },
+                        },
+                    };
+                }
+            }
+            return connection;
+        });
         // If options option is empty for all connection, log the missing options scope.
-        const isOptionExists = dbConnectionsWithEnabledClients.every((c) => c.options && Object.keys(c.options).length > 0);
+        const isOptionExists = dbConnectionsWithActionNames.every((c) => c.options && Object.keys(c.options).length > 0);
         if (!isOptionExists) {
             logger_1.default.warn(`Insufficient scope the read:connections_options scope is required to get ${this.type} options.`);
         }
-        this.existing = dbConnectionsWithEnabledClients;
+        this.existing = dbConnectionsWithActionNames;
         return this.existing;
     }
     async calcChanges(assets) {
@@ -255,22 +362,29 @@ class DatabaseHandler extends default_1.default {
                 conflicts: [],
             };
         // Convert enabled_clients by name to the id
-        const clients = await (0, client_1.paginate)(this.client.clients.list, {
-            paginate: true,
-        });
-        const existingDatabasesConnections = await (0, client_1.paginate)(this.client.connections.list, {
-            strategy: [auth0_1.Management.ConnectionStrategyEnum.Auth0],
-            checkpoint: true,
-            include_totals: true,
-        });
+        // Fetch clients, connections, and actions concurrently
+        const [clients, existingDatabasesConnections, actions] = await Promise.all([
+            (0, client_1.paginate)(this.client.clients.list, {
+                paginate: true,
+            }),
+            (0, client_1.paginate)(this.client.connections.list, {
+                strategy: [auth0_1.Management.ConnectionStrategyEnum.Auth0],
+                checkpoint: true,
+                include_totals: true,
+            }),
+            (0, client_1.paginate)(this.client.actions.list, {
+                paginate: true,
+                include_totals: true,
+            }),
+        ]);
         const formatted = databases.map((db) => {
+            const { options, ...rest } = db;
+            const formattedOptions = this.getFormattedOptions(options, actions);
+            const formattedDb = { ...rest, options: formattedOptions };
             if (db.enabled_clients) {
-                return {
-                    ...db,
-                    enabled_clients: (0, utils_1.getEnabledClients)(assets, db, existingDatabasesConnections, clients),
-                };
+                formattedDb.enabled_clients = (0, utils_1.getEnabledClients)(assets, db, existingDatabasesConnections, clients);
             }
-            return db;
+            return formattedDb;
         });
         return super.calcChanges({ ...assets, databases: formatted });
     }
@@ -289,7 +403,7 @@ class DatabaseHandler extends default_1.default {
         const changes = await this.calcChanges(assets);
         await super.processChanges(assets, (0, utils_1.filterExcluded)(changes, excludedConnections));
         // process enabled clients
-        await (0, connections_1.processConnectionEnabledClients)(this.client, this.type, (0, utils_1.filterExcluded)(changes, excludedConnections));
+        await (0, connections_1.processConnectionEnabledClients)(this.client, this.type, await this.existing, (0, utils_1.filterExcluded)(changes, excludedConnections));
     }
 }
 exports.default = DatabaseHandler;

package/lib/tools/auth0/handlers/default.js

@@ -232,12 +232,11 @@ class APIHandler {
             data: conflicts || [],
             generator: (updateItem) => retryWithExponentialBackoff(() => {
                 const updateFN = this.getClientFN(this.functions.update);
-                const params = { [this.id]: updateItem[this.id] };
                 const updatePayload = (() => {
                     const data = (0, utils_1.stripFields)({ ...updateItem }, this.stripUpdateFields);
                     return (0, utils_1.stripObfuscatedFieldsFromPayload)(data, this.sensitiveFieldsToObfuscate);
                 })();
-                return updateFN(params, updatePayload);
+                return updateFN(updateItem[this.id], updatePayload);
             }, retryConfig)
                 .then((data) => this.didUpdate(data))
                 .catch((err) => {
@@ -272,12 +271,11 @@ class APIHandler {
             data: update || [],
             generator: (updateItem) => retryWithExponentialBackoff(() => {
                 const updateFN = this.getClientFN(this.functions.update);
-                const params = { [this.id]: updateItem[this.id] };
                 const updatePayload = (() => {
                     const data = (0, utils_1.stripFields)({ ...updateItem }, this.stripUpdateFields);
                     return (0, utils_1.stripObfuscatedFieldsFromPayload)(data, this.sensitiveFieldsToObfuscate);
                 })();
-                return updateFN(params, updatePayload);
+                return updateFN(updateItem[this.id], updatePayload);
             }, retryConfig)
                 .then((data) => {
                 this.didUpdate(data);