auth0-deploy-cli 8.24.0 → 8.26.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) {
@@ -277,7 +282,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 +311,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 +450,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 +475,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;
@@ -551,13 +536,16 @@ class ConnectionsHandler extends default_1.default {
         if (!isOptionExists) {
             logger_1.default.warn(`Insufficient scope the update:connections_options scope is required to update ${this.type} options.`);
         }
+        const includedConnections = (assets.include && assets.include.connections) || [];
         const excludedConnections = (assets.exclude && assets.exclude.connections) || [];
-        const changes = await this.calcChanges(assets);
-        await super.processChanges(assets, (0, utils_1.filterExcluded)(changes, excludedConnections));
+        let changes = await this.calcChanges(assets);
+        changes = (0, utils_1.filterExcluded)(changes, excludedConnections);
+        changes = (0, utils_1.filterIncluded)(changes, includedConnections);
+        await super.processChanges(assets, changes);
         // process enabled clients
-        await (0, exports.processConnectionEnabledClients)(this.client, this.type, (0, utils_1.filterExcluded)(changes, excludedConnections));
+        await (0, exports.processConnectionEnabledClients)(this.client, this.type, changes);
         // process directory provisioning
-        await this.processConnectionDirectoryProvisioning((0, utils_1.filterExcluded)(changes, excludedConnections));
+        await this.processConnectionDirectoryProvisioning(changes);
     }
 }
 exports.default = ConnectionsHandler;

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

@@ -16,6 +16,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 +80,10 @@ export declare const schema: {
                                             active: {
                                                 type: string;
                                             };
+                                            default_method: {
+                                                type: string;
+                                                enum: string[];
+                                            };
                                         };
                                     };
                                     profile_required: {
@@ -73,6 +121,10 @@ export declare const schema: {
                                             active: {
                                                 type: string;
                                             };
+                                            default_method: {
+                                                type: string;
+                                                enum: string[];
+                                            };
                                         };
                                     };
                                     profile_required: {
@@ -106,6 +158,10 @@ export declare const schema: {
                                             active: {
                                                 type: string;
                                             };
+                                            default_method: {
+                                                type: string;
+                                                enum: string[];
+                                            };
                                         };
                                     };
                                     profile_required: {
@@ -134,6 +190,7 @@ export default class DatabaseHandler extends DefaultAPIHandler {
     constructor(config: DefaultAPIHandler);
     objString(db: any): string;
     validate(assets: Assets): Promise<void>;
+    private validatePasswordlessSettings;
     private validateEmailUniqueConstraints;
     getClientFN(fn: 'create' | 'delete' | 'getAll' | 'update'): Function;
     getType(): Promise<Asset | Asset[]>;

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' },
@@ -164,9 +198,25 @@ class DatabaseHandler extends default_1.default {
         // Validate each database
         databases.forEach((database) => {
             this.validateEmailUniqueConstraints(database);
+            this.validatePasswordlessSettings(database);
         });
         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
@@ -196,7 +246,7 @@ class DatabaseHandler extends default_1.default {
         }
         // 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 +265,7 @@ 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);
+                return this.client.connections.update(id, payload);
             });
         }
         return this.client.connections[fn].bind(this.client.connections);

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);

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

@@ -66,10 +66,13 @@ exports.schema = {
 const getAllFlowConnections = async (auth0Client) => {
     const allFlowConnections = [];
     let vaultConnections = await auth0Client.flows.vault.connections.list();
-    do {
-        allFlowConnections.push(...vaultConnections.data);
+    // Process first page
+    allFlowConnections.push(...vaultConnections.data);
+    // Fetch remaining pages
+    while (vaultConnections.hasNextPage()) {
         vaultConnections = await vaultConnections.getNextPage();
-    } while (vaultConnections.hasNextPage());
+        allFlowConnections.push(...vaultConnections.data);
+    }
     return allFlowConnections;
 };
 exports.getAllFlowConnections = getAllFlowConnections;

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

@@ -70,9 +70,6 @@ class FlowHandler extends default_1.default {
             id: 'id',
             stripCreateFields: ['created_at', 'updated_at', 'executed_at'],
             stripUpdateFields: ['created_at', 'updated_at', 'executed_at'],
-            functions: {
-                update: async ({ id }, bodyParams) => this.client.flows.update(id, bodyParams),
-            },
         });
     }
     objString(item) {

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

@@ -69,9 +69,6 @@ class FormsHandler extends default_1.default {
             id: 'id',
             stripCreateFields: ['created_at', 'updated_at', 'submitted_at', 'embedded_at'],
             stripUpdateFields: ['created_at', 'updated_at', 'submitted_at', 'embedded_at'],
-            functions: {
-                update: async ({ id }, bodyParams) => this.client.forms.update(id, bodyParams),
-            },
         });
     }
     objString(item) {

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

@@ -4,5 +4,6 @@ declare const _default: { [key in AssetTypes]: {
     default: typeof APIHandler;
     excludeSchema?: any;
     schema: any;
+    includeSchema?: any;
 }; };
 export default _default;

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

@@ -96,9 +96,6 @@ class LogStreamsHandler extends default_1.default {
                 'sink.splunkToken',
                 'sink.datadogApiKey',
             ],
-            functions: {
-                update: async (params, payload) => this.client.logStreams.update(params?.id, payload),
-            },
         });
     }
     objString(item) {

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

@@ -87,6 +87,9 @@ export declare const schema: {
                             type: string;
                             enum: string[];
                         };
+                        use_for_organization_discovery: {
+                            type: string;
+                        };
                     };
                     required: string[];
                 };
@@ -122,7 +125,7 @@ export default class OrganizationsHandler extends DefaultHandler {
     getAllOrganizationDiscoveryDomains(organizationId: string): Promise<Management.OrganizationDiscoveryDomain[] | null>;
     getOrganizationDiscoveryDomain(organizationId: string, discoveryDomainId: string): Promise<Management.GetOrganizationDiscoveryDomainResponseContent>;
     createOrganizationDiscoveryDomain(organizationId: string, discoveryDomain: Management.CreateOrganizationDiscoveryDomainRequestContent): Promise<Management.CreateOrganizationDiscoveryDomainResponseContent>;
-    updateOrganizationDiscoveryDomain(organizationId: string, discoveryDomainId: string, discoveryDomain: string, status: Management.OrganizationDiscoveryDomainStatus): Promise<Management.UpdateOrganizationDiscoveryDomainResponseContent>;
+    updateOrganizationDiscoveryDomain(organizationId: string, discoveryDomainId: string, discoveryDomain: string, discoveryDomainUpdate: Management.UpdateOrganizationDiscoveryDomainRequestContent): Promise<Management.UpdateOrganizationDiscoveryDomainResponseContent>;
     deleteOrganizationDiscoveryDomain(organizationId: string, discoveryDomain: string, discoveryDomainId: string): Promise<void>;
 }
 export {};

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

@@ -112,6 +112,9 @@ exports.schema = {
                     properties: {
                         domain: { type: 'string' },
                         status: { type: 'string', enum: ['pending', 'verified'] },
+                        use_for_organization_discovery: {
+                            type: 'boolean',
+                        },
                     },
                     required: ['domain', 'status'],
                 },
@@ -174,6 +177,7 @@ class OrganizationsHandler extends default_1.default {
                 generator: (discoveryDomain) => this.createOrganizationDiscoveryDomain(created.id, {
                     domain: discoveryDomain?.domain,
                     status: discoveryDomain?.status,
+                    use_for_organization_discovery: discoveryDomain?.use_for_organization_discovery,
                 }).catch((err) => {
                     throw new Error(`Problem creating discovery domain ${discoveryDomain?.domain} for organization ${created.id}\n${err}`);
                 }),
@@ -256,32 +260,47 @@ class OrganizationsHandler extends default_1.default {
         const orgDiscoveryDomainsToRemove = existingDiscoveryDomains?.filter((existingDomain) => !organizationDiscoveryDomains?.find((d) => d.domain === existingDomain.domain)) || [];
         const orgDiscoveryDomainsToAdd = organizationDiscoveryDomains?.filter((domain) => !existingDiscoveryDomains?.find((d) => d.domain === domain.domain)) || [];
         const orgDiscoveryDomainsToUpdate = existingDiscoveryDomains
-            ?.filter((existingDomain) => {
+            ?.map((existingDomain) => {
             const updatedDomain = organizationDiscoveryDomains?.find((d) => d.domain === existingDomain.domain);
-            return updatedDomain && updatedDomain.status !== existingDomain.status;
+            if (!updatedDomain)
+                return undefined;
+            return {
+                ...updatedDomain,
+                id: existingDomain.id, // setting remote id for update
+            };
         })
-            .map((existingDomain) => ({
-            id: existingDomain.id,
-            domain: existingDomain.domain,
-            status: organizationDiscoveryDomains.find((d) => d.domain === existingDomain.domain)
-                .status,
-        })) || [];
-        // Handle updates first
-        await Promise.all(orgDiscoveryDomainsToUpdate.map((domainUpdate) => this.updateOrganizationDiscoveryDomain(params.id, domainUpdate.id, domainUpdate.domain, domainUpdate.status).catch((err) => {
-            throw new Error(`Problem updating discovery domain ${domainUpdate.domain} for organization ${params.id}\n${err.message}`);
-        })));
-        await Promise.all(orgDiscoveryDomainsToAdd.map((domain) => this.createOrganizationDiscoveryDomain(params.id, {
-            domain: domain.domain,
-            status: domain.status,
-        }).catch((err) => {
-            throw new Error(`Problem adding discovery domain ${domain.domain} for organization ${params.id}\n${err.message}`);
-        })));
+            .filter(Boolean) || [];
+        for (const { id, domain, ...updateParams } of orgDiscoveryDomainsToUpdate) {
+            try {
+                await this.updateOrganizationDiscoveryDomain(params.id, id, domain, updateParams);
+            }
+            catch (err) {
+                throw new Error(`Problem updating discovery domain ${domain} for organization ${params.id}\n${err.message}`);
+            }
+        }
+        for (const domain of orgDiscoveryDomainsToAdd) {
+            try {
+                await this.createOrganizationDiscoveryDomain(params.id, {
+                    domain: domain.domain,
+                    status: domain.status,
+                    use_for_organization_discovery: domain.use_for_organization_discovery,
+                });
+            }
+            catch (err) {
+                throw new Error(`Problem adding discovery domain ${domain.domain} for organization ${params.id}\n${err.message}`);
+            }
+        }
         if (orgDiscoveryDomainsToRemove.length > 0) {
             if (this.config('AUTH0_ALLOW_DELETE') === 'true' ||
                 this.config('AUTH0_ALLOW_DELETE') === true) {
-                await Promise.all(orgDiscoveryDomainsToRemove.map((domain) => this.deleteOrganizationDiscoveryDomain(params.id, domain.domain, domain.id).catch((err) => {
-                    throw new Error(`Problem removing discovery domain ${domain.domain} for organization ${params.id}\n${err.message}`);
-                })));
+                for (const domain of orgDiscoveryDomainsToRemove) {
+                    try {
+                        await this.deleteOrganizationDiscoveryDomain(params.id, domain.domain, domain.id);
+                    }
+                    catch (err) {
+                        throw new Error(`Problem removing discovery domain ${domain.domain} for organization ${params.id}\n${err.message}`);
+                    }
+                }
             }
             else {
                 logger_1.default.warn(`Detected the following organization discovery domains should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config
@@ -416,19 +435,25 @@ class OrganizationsHandler extends default_1.default {
     async getOrganizationEnabledConnections(organizationId) {
         const allOrganizationConnections = [];
         let organizationConnections = await this.client.organizations.enabledConnections.list(organizationId);
-        do {
-            allOrganizationConnections.push(...organizationConnections.data);
+        // Process first page
+        allOrganizationConnections.push(...organizationConnections.data);
+        // Fetch remaining pages
+        while (organizationConnections.hasNextPage()) {
             organizationConnections = await organizationConnections.getNextPage();
-        } while (organizationConnections.hasNextPage());
+            allOrganizationConnections.push(...organizationConnections.data);
+        }
         return allOrganizationConnections;
     }
     async getOrganizationClientGrants(organizationId) {
         const allOrganizationClientGrants = [];
         let organizationClientGrants = await this.client.organizations.clientGrants.list(organizationId);
-        do {
-            allOrganizationClientGrants.push(...organizationClientGrants.data);
+        // Process first page
+        allOrganizationClientGrants.push(...organizationClientGrants.data);
+        // Fetch remaining pages
+        while (organizationClientGrants.hasNextPage()) {
             organizationClientGrants = await organizationClientGrants.getNextPage();
-        } while (organizationClientGrants.hasNextPage());
+            allOrganizationClientGrants.push(...organizationClientGrants.data);
+        }
         return allOrganizationClientGrants;
     }
     async createOrganizationClientGrants(organizationId, grantId) {
@@ -447,10 +472,13 @@ class OrganizationsHandler extends default_1.default {
         const allDiscoveryDomains = [];
         try {
             let orgDiscoveryDomain = await this.client.organizations.discoveryDomains.list(organizationId);
-            do {
-                allDiscoveryDomains.push(...orgDiscoveryDomain.data);
+            // Process first page
+            allDiscoveryDomains.push(...orgDiscoveryDomain.data);
+            // Fetch remaining pages
+            while (orgDiscoveryDomain.hasNextPage()) {
                 orgDiscoveryDomain = await orgDiscoveryDomain.getNextPage();
-            } while (orgDiscoveryDomain.hasNextPage());
+                allDiscoveryDomains.push(...orgDiscoveryDomain.data);
+            }
             return allDiscoveryDomains;
         }
         catch (err) {
@@ -480,7 +508,7 @@ class OrganizationsHandler extends default_1.default {
             .promise();
         return orgDiscoveryDomain;
     }
-    async updateOrganizationDiscoveryDomain(organizationId, discoveryDomainId, discoveryDomain, status) {
+    async updateOrganizationDiscoveryDomain(organizationId, discoveryDomainId, discoveryDomain, discoveryDomainUpdate) {
         logger_1.default.debug(`Updating discovery domain ${discoveryDomain} for organization ${organizationId}`);
         // stripUpdateFields does not support in sub modules
         const stripUpdateFields = ['verification_host', 'verification_txt'];
@@ -492,7 +520,8 @@ class OrganizationsHandler extends default_1.default {
                 discoveryDomainId: discoveryDomainId,
             },
             generator: (args) => this.client.organizations.discoveryDomains.update(args.id, args.discoveryDomainId, {
-                status: status,
+                status: discoveryDomainUpdate.status,
+                use_for_organization_discovery: discoveryDomainUpdate.use_for_organization_discovery,
             }),
         })
             .promise();