auth0-deploy-cli 8.22.0 → 8.23.0

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

@@ -38,22 +38,13 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 exports.isMarketplaceAction = isMarketplaceAction;
-const lodash_1 = __importDefault(require("lodash"));
+const lodash_1 = require("lodash");
 const default_1 = __importStar(require("./default"));
 const logger_1 = __importDefault(require("../../../logger"));
 const utils_1 = require("../../utils");
@@ -110,7 +101,7 @@ exports.schema = {
     },
 };
 function isActionsDisabled(err) {
-    const errorBody = lodash_1.default.get(err, 'originalError.response.body') || {};
+    const errorBody = (0, lodash_1.get)(err, 'originalError.response.body') || {};
     return err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled';
 }
 function isMarketplaceAction(action) {
@@ -118,169 +109,167 @@ function isMarketplaceAction(action) {
 }
 class ActionHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'actions', functions: {
+        super({
+            ...options,
+            type: 'actions',
+            functions: {
                 create: (action) => this.createAction(action),
-                delete: (action) => this.deleteAction(action),
-            }, stripUpdateFields: ['deployed', 'status'] }));
+                update: ({ id }, action) => this.updateAction(id, action),
+                delete: (actionId) => this.deleteAction(actionId),
+            },
+            stripUpdateFields: ['deployed', 'status'],
+        });
     }
-    createAction(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Strip the deployed flag
-            const addAction = Object.assign({}, action);
-            if ('deployed' in addAction) {
-                delete addAction.deployed;
-            }
-            if ('status' in addAction) {
-                delete addAction.status;
-            }
-            const { data: createdAction } = yield this.client.actions.create(addAction);
-            // Add the action id so we can deploy it later
+    async createAction(action) {
+        // Strip the deployed flag
+        const addAction = { ...action };
+        if ('deployed' in addAction) {
+            delete addAction.deployed;
+        }
+        if ('status' in addAction) {
+            delete addAction.status;
+        }
+        const createdAction = await this.client.actions.create(addAction);
+        // Add the action id so we can deploy it later
+        if (createdAction?.id) {
             action.id = createdAction.id;
-            return createdAction;
-        });
+        }
+        return createdAction;
     }
-    deleteAction(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.client.actions || typeof this.client.actions.delete !== 'function') {
-                return [];
-            }
-            return this.client.actions.delete({ id: action.id, force: true });
-        });
+    async updateAction(actionId, action) {
+        return this.client.actions.update(actionId, action);
+    }
+    async deleteAction(actionId) {
+        if (!this.client.actions || typeof this.client.actions.delete !== 'function') {
+            return [];
+        }
+        return this.client.actions.delete(actionId, { force: true });
     }
     objString(action) {
         return super.objString({ id: action.id, name: action.name });
     }
-    deployActions(actions) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool
-                .addEachTask({
-                data: actions || [],
-                generator: (action) => this.deployAction(action)
-                    .then(() => {
-                    logger_1.default.info(`Deployed [${this.type}]: ${this.objString(action)}`);
-                })
-                    .catch((err) => {
-                    throw new Error(`Problem Deploying ${this.type} ${this.objString(action)}\n${err}`);
-                }),
+    async deployActions(actions) {
+        await this.client.pool
+            .addEachTask({
+            data: actions || [],
+            generator: (action) => this.deployAction(action)
+                .then(() => {
+                logger_1.default.info(`Deployed [${this.type}]: ${this.objString(action)}`);
             })
-                .promise();
-        });
+                .catch((err) => {
+                throw new Error(`Problem Deploying ${this.type} ${this.objString(action)}\n${err}`);
+            }),
+        })
+            .promise();
     }
-    deployAction(action) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield this.client.actions.deploy({ id: action.id });
-            }
-            catch (err) {
-                // Retry if pending build.
-                if (err.message && err.message.includes("must be in the 'built' state")) {
-                    if (!action.retry_count) {
-                        logger_1.default.info(`[${this.type}]: Waiting for build to complete ${this.objString(action)}`);
-                        action.retry_count = 1;
-                    }
-                    if (action.retry_count > MAX_ACTION_DEPLOY_RETRY_ATTEMPTS) {
-                        throw err;
-                    }
-                    yield (0, utils_1.sleep)(2000);
-                    action.retry_count += 1;
-                    yield this.deployAction(action);
+    async deployAction(action) {
+        try {
+            await this.client.actions.deploy(action.id);
+        }
+        catch (err) {
+            // Retry if pending build.
+            if (err.message && err.message.includes("must be in the 'built' state")) {
+                if (!action.retry_count) {
+                    logger_1.default.info(`[${this.type}]: Waiting for build to complete ${this.objString(action)}`);
+                    action.retry_count = 1;
                 }
-                else {
+                if (action.retry_count > MAX_ACTION_DEPLOY_RETRY_ATTEMPTS) {
                     throw err;
                 }
+                await (0, utils_1.sleep)(2000);
+                action.retry_count += 1;
+                await this.deployAction(action);
             }
-        });
+            else {
+                throw err;
+            }
+        }
     }
-    actionChanges(action, found) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const actionChanges = {};
-            // if action is deployed, should compare against curren_version - calcDeployedVersionChanges method
-            if (!action.deployed) {
-                // name or secrets modifications are not supported yet
-                if (action.code !== found.code) {
-                    actionChanges.code = action.code;
-                }
-                if (action.runtime !== found.runtime) {
-                    actionChanges.runtime = action.runtime;
-                }
-                if (!(0, utils_1.areArraysEquals)(action.dependencies, found.dependencies)) {
-                    actionChanges.dependencies = action.dependencies;
-                }
+    async actionChanges(action, found) {
+        const actionChanges = {};
+        // if action is deployed, should compare against curren_version - calcDeployedVersionChanges method
+        if (!action.deployed) {
+            // name or secrets modifications are not supported yet
+            if (action.code !== found.code) {
+                actionChanges.code = action.code;
             }
-            if (!(0, utils_1.areArraysEquals)(action.supported_triggers, found.supported_triggers)) {
-                actionChanges.supported_triggers = action.supported_triggers;
+            if (action.runtime !== found.runtime) {
+                actionChanges.runtime = action.runtime;
             }
-            return actionChanges;
-        });
+            if (!(0, utils_1.areArraysEquals)(action.dependencies, found.dependencies)) {
+                actionChanges.dependencies = action.dependencies;
+            }
+        }
+        if (!(0, utils_1.areArraysEquals)(action.supported_triggers, found.supported_triggers)) {
+            actionChanges.supported_triggers = action.supported_triggers;
+        }
+        return actionChanges;
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            if (!this.client.actions || typeof this.client.actions.getAll !== 'function') {
-                return [];
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        if (!this.client.actions || typeof this.client.actions.list !== 'function') {
+            return [];
+        }
+        // Actions API does not support include_totals param like the other paginate API's.
+        // So we set it to false otherwise it will fail with "Additional properties not allowed: include_totals"
+        try {
+            const actions = await (0, client_1.paginate)(this.client.actions.list, {
+                paginate: true,
+            });
+            this.existing = actions;
+            return actions;
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
+                return null;
             }
-            // Actions API does not support include_totals param like the other paginate API's.
-            // So we set it to false otherwise it will fail with "Additional properties not allowed: include_totals"
-            try {
-                const actions = yield (0, client_1.paginate)(this.client.actions.getAll, {
-                    paginate: true,
-                });
-                this.existing = actions;
-                return actions;
+            if (err.statusCode === 500 && err.message === 'An internal server error occurred') {
+                throw new Error("Cannot process actions because the actions service is currently unavailable. Retrying may result in a successful operation. Alternatively, adding 'actions' to `AUTH0_EXCLUDED` configuration property will provide ability to skip until service is restored to actions service. This is not an issue with the Deploy CLI.");
             }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return null;
-                }
-                if (err.statusCode === 500 && err.message === 'An internal server error occurred') {
-                    throw new Error("Cannot process actions because the actions service is currently unavailable. Retrying may result in a successful operation. Alternatively, adding 'actions' to `AUTH0_EXCLUDED` configuration property will provide ability to skip until service is restored to actions service. This is not an issue with the Deploy CLI.");
-                }
-                if (isActionsDisabled(err)) {
-                    logger_1.default.info('Skipping actions because it is not enabled.');
-                    return null;
-                }
-                throw err;
+            if (isActionsDisabled(err)) {
+                logger_1.default.info('Skipping actions because it is not enabled.');
+                return null;
             }
-        });
+            throw err;
+        }
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { actions } = assets;
-            // Do nothing if not set
-            if (!actions)
-                return;
-            const changes = yield this.calcChanges(assets);
-            // Management of marketplace actions not currently supported, see ESD-23225.
-            const changesWithMarketplaceActionsFiltered = (() => (Object.assign(Object.assign({}, changes), { del: changes.del.filter((action) => !isMarketplaceAction(action)) })))();
-            yield _super.processChanges.call(this, assets, changesWithMarketplaceActionsFiltered);
-            const postProcessedActions = yield (() => __awaiter(this, void 0, void 0, function* () {
-                this.existing = null; // Clear the cache
-                return this.getType();
-            }))();
-            // Deploy actions
-            const deployActions = [
-                ...changes.create
-                    .filter((action) => action.deployed)
-                    .map((actionWithoutId) => {
-                    var _a;
-                    // Add IDs to just-created actions
-                    const actionId = (_a = postProcessedActions === null || postProcessedActions === void 0 ? void 0 : postProcessedActions.find((postProcessedAction) => postProcessedAction.name === actionWithoutId.name)) === null || _a === void 0 ? void 0 : _a.id;
-                    const actionWithId = Object.assign(Object.assign({}, actionWithoutId), { id: actionId });
-                    return actionWithId;
-                })
-                    .filter((action) => !!action.id),
-                ...changes.update.filter((action) => action.deployed),
-            ];
-            yield this.deployActions(deployActions);
-        });
+    async processChanges(assets) {
+        const { actions } = assets;
+        // Do nothing if not set
+        if (!actions)
+            return;
+        const changes = await this.calcChanges(assets);
+        // Management of marketplace actions not currently supported, see ESD-23225.
+        const changesWithMarketplaceActionsFiltered = (() => ({
+            ...changes,
+            del: changes.del.filter((action) => !isMarketplaceAction(action)),
+        }))();
+        await super.processChanges(assets, changesWithMarketplaceActionsFiltered);
+        const postProcessedActions = await (async () => {
+            this.existing = null; // Clear the cache
+            return this.getType();
+        })();
+        // Deploy actions
+        const deployActions = [
+            ...changes.create
+                .filter((action) => action.deployed)
+                .map((actionWithoutId) => {
+                // Add IDs to just-created actions
+                const actionId = postProcessedActions?.find((postProcessedAction) => postProcessedAction.name === actionWithoutId.name)?.id;
+                const actionWithId = {
+                    ...actionWithoutId,
+                    id: actionId,
+                };
+                return actionWithId;
+            })
+                .filter((action) => !!action.id),
+            ...changes.update.filter((action) => action.deployed),
+        ];
+        await this.deployActions(deployActions);
     }
 }
 exports.default = ActionHandler;
 __decorate([
     (0, default_1.order)('50')
 ], ActionHandler.prototype, "processChanges", null);
-//# sourceMappingURL=actions.js.map

package/lib/tools/auth0/handlers/attackProtection.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 };
 };
@@ -193,11 +184,13 @@ exports.schema = {
 };
 class AttackProtectionHandler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'attackProtection' }));
+        super({
+            ...config,
+            type: 'attackProtection',
+        });
     }
     objString(item) {
         const objectString = (() => {
-            var _a, _b, _c;
             const obj = {};
             if (item.botDetection) {
                 obj['bot-detection'] = {
@@ -205,12 +198,12 @@ class AttackProtectionHandler extends default_1.default {
                     monitoring_mode_enabled: item.botDetection.monitoring_mode_enabled,
                 };
             }
-            if ((_a = item.breachedPasswordDetection) === null || _a === void 0 ? void 0 : _a.enabled) {
+            if (item.breachedPasswordDetection?.enabled) {
                 obj['breached-password-protection'] = {
                     enabled: item.breachedPasswordDetection.enabled,
                 };
             }
-            if ((_b = item.bruteForceProtection) === null || _b === void 0 ? void 0 : _b.enabled) {
+            if (item.bruteForceProtection?.enabled) {
                 obj['brute-force-protection'] = {
                     enabled: item.bruteForceProtection.enabled,
                 };
@@ -220,7 +213,7 @@ class AttackProtectionHandler extends default_1.default {
                     active_provider_id: item.captcha.active_provider_id,
                 };
             }
-            if ((_c = item.suspiciousIpThrottling) === null || _c === void 0 ? void 0 : _c.enabled) {
+            if (item.suspiciousIpThrottling?.enabled) {
                 obj['suspicious-ip-throttling'] = {
                     enabled: item.suspiciousIpThrottling.enabled,
                 };
@@ -229,88 +222,83 @@ class AttackProtectionHandler extends default_1.default {
         })();
         return super.objString(objectString);
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            const [breachedPasswordDetection, bruteForceProtection, suspiciousIpThrottling] = yield Promise.all([
-                this.client.attackProtection.getBreachedPasswordDetectionConfig(),
-                this.client.attackProtection.getBruteForceConfig(),
-                this.client.attackProtection.getSuspiciousIpThrottlingConfig(),
+    async getType() {
+        if (this.existing) {
+            return this.existing;
+        }
+        const [breachedPasswordDetection, bruteForceProtection, suspiciousIpThrottling] = await Promise.all([
+            this.client.attackProtection.breachedPasswordDetection.get(),
+            this.client.attackProtection.bruteForceProtection.get(),
+            this.client.attackProtection.suspiciousIpThrottling.get(),
+        ]);
+        let botDetection = null;
+        let captcha = null;
+        try {
+            [botDetection, captcha] = await Promise.all([
+                this.client.attackProtection.botDetection.get(),
+                this.client.attackProtection.captcha.get(),
             ]);
-            let botDetection = null;
-            let captcha = null;
-            try {
-                [botDetection, captcha] = yield Promise.all([
-                    this.client.attackProtection.getBotDetectionConfig(),
-                    this.client.attackProtection.getCaptchaConfig(),
-                ]);
-            }
-            catch (err) {
-                if (err.statusCode === 403) {
-                    logger_1.default.warn('Bot Detection API are not enabled for this tenant. Please verify `scope` or contact Auth0 support to enable this feature.');
-                }
-            }
-            const attackProtection = {
-                breachedPasswordDetection: breachedPasswordDetection.data,
-                bruteForceProtection: bruteForceProtection.data,
-                suspiciousIpThrottling: suspiciousIpThrottling.data,
-            };
-            if (botDetection === null || botDetection === void 0 ? void 0 : botDetection.data) {
-                attackProtection.botDetection = botDetection.data;
-            }
-            if (captcha === null || captcha === void 0 ? void 0 : captcha.data) {
-                attackProtection.captcha = captcha.data;
+        }
+        catch (err) {
+            if (err.statusCode === 403) {
+                logger_1.default.warn('Bot Detection API are not enabled for this tenant. Please verify `scope` or contact Auth0 support to enable this feature.');
             }
-            this.existing = attackProtection;
-            return this.existing;
-        });
+        }
+        const attackProtection = {
+            breachedPasswordDetection: breachedPasswordDetection,
+            bruteForceProtection: bruteForceProtection,
+            suspiciousIpThrottling: suspiciousIpThrottling,
+        };
+        if (botDetection) {
+            attackProtection.botDetection = botDetection;
+        }
+        if (captcha) {
+            attackProtection.captcha = captcha;
+        }
+        this.existing = attackProtection;
+        return this.existing;
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { attackProtection } = assets;
-            if (!attackProtection || !Object.keys(attackProtection).length) {
-                return;
-            }
-            const updates = [];
-            if (attackProtection.botDetection && Object.keys(attackProtection.botDetection).length) {
-                updates.push(this.client.attackProtection.updateBotDetectionConfig(attackProtection.botDetection));
-            }
-            if (attackProtection.breachedPasswordDetection) {
-                updates.push(this.client.attackProtection.updateBreachedPasswordDetectionConfig(attackProtection.breachedPasswordDetection));
-            }
-            if (attackProtection.captcha && Object.keys(attackProtection.captcha).length) {
-                const { captcha } = attackProtection;
-                // remove empty CAPTCHA provider configurations before updates to prevent API errors
-                exports.CAPTCHA_PROVIDERS.forEach((provider) => {
-                    if (provider in captcha) {
-                        const providerConfig = captcha[provider];
-                        const isEmpty = provider === 'auth_challenge' || provider === 'simple_captcha'
-                            ? Object.keys(providerConfig).length === 0
-                            : !(providerConfig === null || providerConfig === void 0 ? void 0 : providerConfig.site_key) || providerConfig.site_key === '';
-                        if (isEmpty) {
-                            delete captcha[provider];
-                        }
+    async processChanges(assets) {
+        const { attackProtection } = assets;
+        if (!attackProtection || !Object.keys(attackProtection).length) {
+            return;
+        }
+        const updates = [];
+        if (attackProtection.botDetection && Object.keys(attackProtection.botDetection).length) {
+            updates.push(this.client.attackProtection.botDetection.update(attackProtection.botDetection));
+        }
+        if (attackProtection.breachedPasswordDetection) {
+            updates.push(this.client.attackProtection.breachedPasswordDetection.update(attackProtection.breachedPasswordDetection));
+        }
+        if (attackProtection.captcha && Object.keys(attackProtection.captcha).length) {
+            const { captcha } = attackProtection;
+            // remove empty CAPTCHA provider configurations before updates to prevent API errors
+            exports.CAPTCHA_PROVIDERS.forEach((provider) => {
+                if (provider in captcha) {
+                    const providerConfig = captcha[provider];
+                    const isEmpty = provider === 'auth_challenge' || provider === 'simple_captcha'
+                        ? Object.keys(providerConfig).length === 0
+                        : !providerConfig?.site_key || providerConfig.site_key === '';
+                    if (isEmpty) {
+                        delete captcha[provider];
                     }
-                });
-                attackProtection.captcha = captcha;
-                updates.push(this.client.attackProtection.updateCaptchaConfig(attackProtection.captcha));
-            }
-            if (attackProtection.bruteForceProtection) {
-                updates.push(this.client.attackProtection.updateBruteForceConfig(attackProtection.bruteForceProtection));
-            }
-            if (attackProtection.suspiciousIpThrottling) {
-                updates.push(this.client.attackProtection.updateSuspiciousIpThrottlingConfig(attackProtection.suspiciousIpThrottling));
-            }
-            if (!updates.length) {
-                return;
-            }
-            yield Promise.all(updates);
-            this.updated += 1;
-            this.didUpdate(attackProtection);
-        });
+                }
+            });
+            attackProtection.captcha = captcha;
+            updates.push(this.client.attackProtection.captcha.update(attackProtection.captcha));
+        }
+        if (attackProtection.bruteForceProtection) {
+            updates.push(this.client.attackProtection.bruteForceProtection.update(attackProtection.bruteForceProtection));
+        }
+        if (attackProtection.suspiciousIpThrottling) {
+            updates.push(this.client.attackProtection.suspiciousIpThrottling.update(attackProtection.suspiciousIpThrottling));
+        }
+        if (!updates.length) {
+            return;
+        }
+        await Promise.all(updates);
+        this.updated += 1;
+        this.didUpdate(attackProtection);
     }
 }
 exports.default = AttackProtectionHandler;
-//# sourceMappingURL=attackProtection.js.map