auth0-deploy-cli 8.22.0 → 8.23.0

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

@@ -1,13 +1,4 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -46,34 +37,39 @@ class ScimHandler {
      * So, we need this map to perform `create`, `update` or `delete` actions on SCIM.
      * @param connections
      */
-    createIdMap(connections) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.idMap.clear();
-            logger_1.default.info('Reviewing connections for SCIM support. This may take a while...');
-            yield this.poolClient
-                .addEachTask({
-                data: connections || [],
-                generator: (connection) => {
-                    if (!this.scimScopes.read)
-                        return Promise.resolve(null);
-                    if (!this.isScimStrategy(connection.strategy))
-                        return Promise.resolve(null);
-                    this.idMap.set(connection.id, { strategy: connection.strategy });
-                    return this.getScimConfiguration({ id: connection.id })
-                        .then((response) => {
-                        const scimConfiguration = response === null || response === void 0 ? void 0 : response.data;
-                        if (scimConfiguration) {
-                            const { mapping, user_id_attribute, connection_id } = scimConfiguration;
-                            this.idMap.set(connection_id, Object.assign(Object.assign({}, this.idMap.get(connection_id)), { scimConfiguration: { mapping, user_id_attribute } }));
+    async createIdMap(connections) {
+        this.idMap.clear();
+        logger_1.default.info('Reviewing connections for SCIM support. This may take a while...');
+        await this.poolClient
+            .addEachTask({
+            data: connections || [],
+            generator: (connection) => {
+                if (!this.scimScopes.read)
+                    return Promise.resolve(null);
+                if (!this.isScimStrategy(connection.strategy))
+                    return Promise.resolve(null);
+                this.idMap.set(connection.id, { strategy: connection.strategy });
+                return this.getScimConfiguration({ id: connection.id })
+                    .then((response) => {
+                    const scimConfiguration = response;
+                    if (scimConfiguration) {
+                        // eslint-disable-next-line camelcase
+                        const { mapping, user_id_attribute, connection_id } = scimConfiguration;
+                        // eslint-disable-next-line camelcase
+                        if (connection_id) {
+                            this.idMap.set(connection_id, {
+                                ...this.idMap.get(connection_id),
+                                scimConfiguration: { mapping, user_id_attribute },
+                            });
                         }
-                    })
-                        .catch((error) => {
-                        throw new Error(`Problem fetching SCIM configurations while running \"createIdMap\".\n${error}`);
-                    });
-                },
-            })
-                .promise();
-        });
+                    }
+                })
+                    .catch((error) => {
+                    throw new Error(`Problem fetching SCIM configurations while running \"createIdMap\".\n${error}`);
+                });
+            },
+        })
+            .promise();
     }
     /**
      * Iterate through all the connections and add property `scim_configuration` to only `SCIM` connections.
@@ -83,22 +79,20 @@ class ScimHandler {
      *
      * This method mutates the incoming `connections`.
      */
-    applyScimConfiguration(connections) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // If `this.idMap` is empty, it means we haven't created the idMap yet. Create it.
-            // If `this.scimScopes.read` is false, it means we don't have `read:scim_config` scope. Return connections as is.
-            if (this.idMap.size === 0) {
-                if (!this.scimScopes.read)
-                    return connections;
-                yield this.createIdMap(connections);
-            }
-            for (const connection of connections) {
-                const { scimConfiguration } = this.idMap.get(connection.id) || {};
-                if (scimConfiguration) {
-                    connection.scim_configuration = scimConfiguration;
-                }
+    async applyScimConfiguration(connections) {
+        // If `this.idMap` is empty, it means we haven't created the idMap yet. Create it.
+        // If `this.scimScopes.read` is false, it means we don't have `read:scim_config` scope. Return connections as is.
+        if (this.idMap.size === 0) {
+            if (!this.scimScopes.read)
+                return connections;
+            await this.createIdMap(connections);
+        }
+        for (const connection of connections) {
+            const { scimConfiguration } = this.idMap.get(connection.id) || {};
+            if (scimConfiguration) {
+                connection.scim_configuration = scimConfiguration;
             }
-        });
+        }
     }
     /**
      * Wrapper over scimClient methods.
@@ -120,21 +114,18 @@ class ScimHandler {
     /**
      * Error handler wrapper.
      */
-    withErrorHandling(callback, method, connectionId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                return yield callback();
-            }
-            catch (error) {
-                return this.handleExpectedErrors(error, method, connectionId);
-            }
-        });
+    async withErrorHandling(callback, method, connectionId) {
+        try {
+            return await callback();
+        }
+        catch (error) {
+            return this.handleExpectedErrors(error, method, connectionId);
+        }
     }
     /**
      * Handle expected errors.
      */
     handleExpectedErrors(error, method, connectionId) {
-        var _a;
         // Skip the connection if it returns 404. This can happen if `SCIM` is not enabled on a `SCIM` connection.
         if (error && error.statusCode === 404) {
             logger_1.default.debug(`SCIM configuration is not enabled on connection \"${connectionId}\".`);
@@ -150,7 +141,7 @@ class ScimHandler {
             return null;
         }
         // Skip the connection if it returns 400. This can happen if `SCIM` configuration already exists on a `SCIM` connection.
-        if (error && error.statusCode === 400 && ((_a = error.message) === null || _a === void 0 ? void 0 : _a.includes('already exists'))) {
+        if (error && error.statusCode === 400 && error.message?.includes('already exists')) {
             logger_1.default.warn(`SCIM configuration already exists on connection \"${connectionId}\".`);
             return null;
         }
@@ -165,94 +156,81 @@ class ScimHandler {
     /**
      * Creates a new `SCIM` configuration.
      */
-    createScimConfiguration(_a, _b) {
-        return __awaiter(this, arguments, void 0, function* ({ id }, 
-        // eslint-disable-next-line camelcase
-        { user_id_attribute, mapping }) {
-            logger_1.default.debug(`Creating SCIM configuration on connection ${id}`);
-            return this.withErrorHandling(() => __awaiter(this, void 0, void 0, function* () { return this.connectionsManager.createScimConfiguration({ id }, { user_id_attribute, mapping }); }), 'create', id);
-        });
+    async createScimConfiguration({ id }, 
+    // eslint-disable-next-line camelcase
+    { user_id_attribute, mapping }) {
+        logger_1.default.debug(`Creating SCIM configuration on connection ${id}`);
+        return this.withErrorHandling(async () => this.connectionsManager.scimConfiguration.create(id, { user_id_attribute, mapping }), 'create', id);
     }
     /**
      * Retrieves `SCIM` configuration of an enterprise connection.
      */
-    getScimConfiguration(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ id }) {
-            logger_1.default.debug(`Getting SCIM configuration from connection ${id}`);
-            return this.withErrorHandling(() => __awaiter(this, void 0, void 0, function* () { return this.connectionsManager.getScimConfiguration({ id }); }), 'get', id);
-        });
+    async getScimConfiguration({ id, }) {
+        logger_1.default.debug(`Getting SCIM configuration from connection ${id}`);
+        return this.withErrorHandling(async () => this.connectionsManager.scimConfiguration.get(id), 'get', id);
     }
     /**
      * Updates an existing `SCIM` configuration.
      */
-    updateScimConfiguration(_a, _b) {
-        return __awaiter(this, arguments, void 0, function* ({ id }, 
-        // eslint-disable-next-line camelcase
-        { user_id_attribute, mapping }) {
-            logger_1.default.debug(`Updating SCIM configuration on connection ${id}`);
-            return this.withErrorHandling(() => __awaiter(this, void 0, void 0, function* () { return this.connectionsManager.updateScimConfiguration({ id }, { user_id_attribute, mapping }); }), 'patch', id);
-        });
+    async updateScimConfiguration({ id }, 
+    // eslint-disable-next-line camelcase
+    { user_id_attribute, mapping }) {
+        logger_1.default.debug(`Updating SCIM configuration on connection ${id}`);
+        return this.withErrorHandling(async () => this.connectionsManager.scimConfiguration.update(id, { user_id_attribute, mapping }), 'patch', id);
     }
     /**
      * Deletes an existing `SCIM` configuration.
      */
-    deleteScimConfiguration(_a) {
-        return __awaiter(this, arguments, void 0, function* ({ id }) {
-            logger_1.default.debug(`Deleting SCIM configuration on connection ${id}`);
-            return this.withErrorHandling(() => __awaiter(this, void 0, void 0, function* () { return this.connectionsManager.deleteScimConfiguration({ id }); }), 'delete', id);
-        });
+    async deleteScimConfiguration({ id }) {
+        logger_1.default.debug(`Deleting SCIM configuration on connection ${id}`);
+        return this.withErrorHandling(async () => this.connectionsManager.scimConfiguration.delete(id), 'delete', id);
     }
-    updateOverride(requestParams, bodyParams) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Extract `scim_configuration` from `bodyParams`.
-            // Remove `scim_configuration` from `bodyParams`, because `connections.update` doesn't accept it.
-            const { scim_configuration: scimBodyParams } = bodyParams;
-            delete bodyParams.scim_configuration;
-            // First, update `connections`.
-            const updated = yield this.connectionsManager.update(requestParams, bodyParams);
-            const idMapEntry = this.idMap.get(requestParams.id);
-            // Now, update `scim_configuration` inside the updated connection.
-            // If `scim_configuration` exists in both local and remote -> updateScimConfiguration(...)
-            // If `scim_configuration` exists in remote but local -> deleteScimConfiguration(...)
-            // If `scim_configuration` exists in local but remote -> createScimConfiguration(...)
-            if (idMapEntry === null || idMapEntry === void 0 ? void 0 : idMapEntry.scimConfiguration) {
-                if (scimBodyParams) {
-                    if (this.scimScopes.update) {
-                        yield this.updateScimConfiguration(requestParams, scimBodyParams);
-                    }
-                }
-                else if (this.config('AUTH0_ALLOW_DELETE')) {
-                    if (this.scimScopes.delete) {
-                        yield this.deleteScimConfiguration(requestParams);
-                    }
+    async updateOverride(requestParams, bodyParams) {
+        // Extract `scim_configuration` from `bodyParams`.
+        // Remove `scim_configuration` from `bodyParams`, because `connections.update` doesn't accept it.
+        const { scim_configuration: scimBodyParams } = bodyParams;
+        delete bodyParams.scim_configuration;
+        // First, update `connections`.
+        const updated = await this.connectionsManager.update(requestParams.id, bodyParams);
+        const idMapEntry = this.idMap.get(requestParams.id);
+        // Now, update `scim_configuration` inside the updated connection.
+        // If `scim_configuration` exists in both local and remote -> updateScimConfiguration(...)
+        // If `scim_configuration` exists in remote but local -> deleteScimConfiguration(...)
+        // If `scim_configuration` exists in local but remote -> createScimConfiguration(...)
+        if (idMapEntry?.scimConfiguration) {
+            if (scimBodyParams) {
+                if (this.scimScopes.update) {
+                    await this.updateScimConfiguration(requestParams, scimBodyParams);
                 }
-                else {
-                    logger_1.default.warn(`Skipping DELETE scim_configuration on \"${requestParams.id}\". Enable deletes by setting \"AUTH0_ALLOW_DELETE\" to true in your config.`);
+            }
+            else if (this.config('AUTH0_ALLOW_DELETE')) {
+                if (this.scimScopes.delete) {
+                    await this.deleteScimConfiguration(requestParams);
                 }
             }
-            else if (scimBodyParams && this.scimScopes.create) {
-                yield this.createScimConfiguration(requestParams, scimBodyParams);
+            else {
+                logger_1.default.warn(`Skipping DELETE scim_configuration on \"${requestParams.id}\". Enable deletes by setting \"AUTH0_ALLOW_DELETE\" to true in your config.`);
             }
-            // Return response from connections.update(...).
-            return updated;
-        });
+        }
+        else if (scimBodyParams && this.scimScopes.create) {
+            await this.createScimConfiguration(requestParams, scimBodyParams);
+        }
+        // Return response from connections.update(...).
+        return updated;
     }
-    createOverride(bodyParams) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Extract `scim_configuration` from `bodyParams`.
-            // Remove `scim_configuration` from `bodyParams`, because `connections.create` doesn't accept it.
-            const { scim_configuration: scimBodyParams } = bodyParams;
-            delete bodyParams.scim_configuration;
-            // First, create the new `connection`.
-            const { data } = yield this.connectionsManager.create(bodyParams);
-            if (scimBodyParams && this.scimScopes.create) {
-                // Now, create the `scim_configuration` for newly created `connection`.
-                yield this.createScimConfiguration({ id: data.id }, scimBodyParams);
-            }
-            // Return response from connections.create(...).
-            return data;
-        });
+    async createOverride(bodyParams) {
+        // Extract `scim_configuration` from `bodyParams`.
+        // Remove `scim_configuration` from `bodyParams`, because `connections.create` doesn't accept it.
+        const { scim_configuration: scimBodyParams } = bodyParams;
+        delete bodyParams.scim_configuration;
+        // First, create the new `connection`.
+        const data = await this.connectionsManager.create(bodyParams);
+        if (data?.id && scimBodyParams && this.scimScopes.create) {
+            // Now, create the `scim_configuration` for newly created `connection`.
+            await this.createScimConfiguration({ id: data.id }, scimBodyParams);
+        }
+        // Return response from connections.create(...).
+        return data;
     }
 }
 exports.default = ScimHandler;
-//# sourceMappingURL=scimHandler.js.map

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

@@ -1,11 +1,19 @@
-import { GetSelfServiceProfileCustomTextLanguageEnum, GetSelfServiceProfileCustomTextPageEnum, SsProfile, UserAttributeProfile } from 'auth0';
+import { Management } from 'auth0';
 import { Asset, Assets, Auth0APIClient, CalculatedChanges } from '../../../types';
 import DefaultAPIHandler from './default';
+import { UserAttributeProfile } from './userAttributeProfiles';
+declare const SelfServiceProfileCustomTextLanguageEnum: {
+    readonly en: "en";
+};
+declare const SelfServiceProfileCustomTextPageEnum: {
+    readonly getStarted: "get-started";
+};
 type customTextType = {
-    [GetSelfServiceProfileCustomTextLanguageEnum.en]: {
-        [GetSelfServiceProfileCustomTextPageEnum.get_started]: Object;
+    [SelfServiceProfileCustomTextLanguageEnum.en]: {
+        [SelfServiceProfileCustomTextPageEnum.getStarted]: Object;
     };
 };
+type SsProfile = Management.SelfServiceProfile;
 export type SsProfileWithCustomText = Omit<SsProfile, 'created_at' | 'updated_at'> & {
     customText?: customTextType;
 };
@@ -80,6 +88,7 @@ export declare const schema: {
 export default class SelfServiceProfileHandler extends DefaultAPIHandler {
     existing: SsProfileWithCustomText[];
     constructor(config: DefaultAPIHandler);
+    objString(item: any): string;
     getType(): Promise<SsProfileWithCustomText[]>;
     processChanges(assets: Assets): Promise<void>;
     updateCustomText(ssProfileId: string, customText: customTextType): Promise<void>;