auth0-deploy-cli 8.22.0 → 8.23.1

package/lib/tools/auth0/handlers/rules.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 };
 };
@@ -61,177 +52,168 @@ exports.schema = {
 };
 class RulesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'rules', stripUpdateFields: ['stage'] }));
+        super({
+            ...options,
+            type: 'rules',
+            stripUpdateFields: ['stage'], // Fields not allowed in updates
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                if (this.existing)
-                    return this.existing;
-                const rules = yield (0, client_1.paginate)(this.client.rules.getAll, {
-                    paginate: true,
-                    include_totals: true,
-                });
-                this.existing = rules;
+    async getType() {
+        try {
+            if (this.existing)
                 return this.existing;
+            const rules = await (0, client_1.paginate)(this.client.rules.list, {
+                paginate: true,
+            });
+            this.existing = rules;
+            return this.existing;
+        }
+        catch (err) {
+            if ((0, utils_1.isDeprecatedError)(err)) {
+                return null;
             }
-            catch (err) {
-                if ((0, utils_1.isDeprecatedError)(err)) {
-                    return null;
-                }
-                throw err;
-            }
-        });
+            throw err;
+        }
     }
     objString(rule) {
         return super.objString({ name: rule.name, order: rule.order });
     }
-    calcChanges(assets_1) {
-        return __awaiter(this, arguments, void 0, function* (assets, includeExcluded = false) {
-            let { rules } = assets;
-            const excludedRules = (assets.exclude && assets.exclude.rules) || [];
-            let existing = yield this.getType();
-            if (existing === null) {
-                return {
-                    del: [],
-                    update: [],
-                    conflicts: [],
-                    create: [],
-                    reOrder: [],
-                };
-            }
-            // Filter excluded rules
-            if (!includeExcluded) {
-                rules = rules.filter((r) => !excludedRules.includes(r.name));
-                existing = existing.filter((r) => !excludedRules.includes(r.name));
-            }
-            // Figure out what needs to be updated vs created
-            const { del, update, create, conflicts } = (0, calculateChanges_1.calculateChanges)({
-                handler: this,
-                assets: rules,
-                existing,
-                identifiers: this.identifiers,
-                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
-            });
-            // Figure out the rules that need to be re-ordered
-            const futureRules = [...create, ...update];
-            const futureMaxOrder = Math.max(...futureRules.map((r) => r.order));
-            const existingMaxOrder = Math.max(...existing.map((r) => r.order));
-            let nextOrderNo = Math.max(futureMaxOrder, existingMaxOrder);
-            //@ts-ignore because we know reOrder is Asset[]
-            const reOrder = futureRules.reduce((accum, r) => {
-                if (existing === null)
-                    return accum;
-                const conflict = existing.find((f) => r.order === f.order && r.name !== f.name);
-                if (conflict !== undefined) {
-                    nextOrderNo += 1;
-                    return [
-                        ...accum,
-                        Object.assign(Object.assign({}, conflict), { order: nextOrderNo }),
-                    ];
-                }
-                return accum;
-            }, []);
+    async calcChanges(assets, includeExcluded = false) {
+        let { rules } = assets;
+        const excludedRules = (assets.exclude && assets.exclude.rules) || [];
+        let existing = await this.getType();
+        if (existing === null) {
             return {
-                del,
-                update,
-                create,
-                reOrder,
-                conflicts,
+                del: [],
+                update: [],
+                conflicts: [],
+                create: [],
+                reOrder: [],
             };
+        }
+        // Filter excluded rules
+        if (!includeExcluded) {
+            rules = rules.filter((r) => !excludedRules.includes(r.name));
+            existing = existing.filter((r) => !excludedRules.includes(r.name));
+        }
+        // Figure out what needs to be updated vs created
+        const { del, update, create, conflicts } = (0, calculateChanges_1.calculateChanges)({
+            handler: this,
+            assets: rules,
+            existing,
+            identifiers: this.identifiers,
+            allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
         });
+        // Figure out the rules that need to be re-ordered
+        const futureRules = [...create, ...update];
+        const futureMaxOrder = Math.max(...futureRules.map((r) => r.order));
+        const existingMaxOrder = Math.max(...existing.map((r) => r.order));
+        let nextOrderNo = Math.max(futureMaxOrder, existingMaxOrder);
+        // @ts-ignore because we know reOrder is Asset[]
+        const reOrder = futureRules.reduce((accum, r) => {
+            if (existing === null)
+                return accum;
+            const conflict = existing.find((f) => r.order === f.order && r.name !== f.name);
+            if (conflict !== undefined) {
+                nextOrderNo += 1;
+                return [
+                    ...accum,
+                    {
+                        ...conflict,
+                        order: nextOrderNo,
+                    },
+                ];
+            }
+            return accum;
+        }, []);
+        return {
+            del,
+            update,
+            create,
+            reOrder,
+            conflicts,
+        };
     }
-    validate(assets) {
-        const _super = Object.create(null, {
-            validate: { get: () => super.validate }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { rules } = assets;
-            // Do nothing if not set
-            if (!rules)
-                return;
-            const excludedRules = (assets.exclude && assets.exclude.rules) || [];
-            // Figure out what needs to be updated vs created
-            const { update, create, del } = yield this.calcChanges(assets, true);
-            // Include del rules which are actually not going to be deleted but are excluded
-            // they can still muck up the ordering so we must take it into consideration.
-            const futureRules = [
-                ...create,
-                ...update,
-                ...del.filter((r) => excludedRules.includes(r.name)),
-            ];
-            // Detect rules with the same order
-            const rulesSameOrder = (0, utils_1.duplicateItems)(futureRules, 'order');
-            if (rulesSameOrder.length > 0) {
-                const formatted = rulesSameOrder.map((dups) => dups.map((d) => `${d.name}`));
-                throw new validationError_1.default(`There are multiple rules for the following stage-order combinations
+    async validate(assets) {
+        const { rules } = assets;
+        // Do nothing if not set
+        if (!rules)
+            return;
+        const excludedRules = (assets.exclude && assets.exclude.rules) || [];
+        // Figure out what needs to be updated vs created
+        const { update, create, del } = await this.calcChanges(assets, true);
+        // Include del rules which are actually not going to be deleted but are excluded
+        // they can still muck up the ordering so we must take it into consideration.
+        const futureRules = [
+            ...create,
+            ...update,
+            ...del.filter((r) => excludedRules.includes(r.name)),
+        ];
+        // Detect rules with the same order
+        const rulesSameOrder = (0, utils_1.duplicateItems)(futureRules, 'order');
+        if (rulesSameOrder.length > 0) {
+            const formatted = rulesSameOrder.map((dups) => dups.map((d) => `${d.name}`));
+            throw new validationError_1.default(`There are multiple rules for the following stage-order combinations
       ${(0, utils_1.convertJsonToString)(formatted)}.
        Only one rule must be defined for the same order number in a stage.`);
-            }
-            // Detect Rules that are changing stage as it's not allowed.
-            const existing = yield this.getType();
-            if (existing === null)
-                return;
-            const stateChanged = futureRules
-                .reduce((changed, rule) => [
-                ...changed,
-                ...existing.filter((r) => rule.name.toLowerCase() === r.name.toLowerCase() && r.stage !== rule.stage),
-            ], [])
-                .map((r) => r.name);
-            if (stateChanged.length > 0) {
-                throw new validationError_1.default(`The following rules changed stage which is not allowed:
+        }
+        // Detect Rules that are changing stage as it's not allowed.
+        const existing = await this.getType();
+        if (existing === null)
+            return;
+        const stateChanged = futureRules
+            .reduce((changed, rule) => [
+            ...changed,
+            ...existing.filter((r) => rule.name.toLowerCase() === r.name.toLowerCase() && r.stage !== rule.stage),
+        ], [])
+            .map((r) => r.name);
+        if (stateChanged.length > 0) {
+            throw new validationError_1.default(`The following rules changed stage which is not allowed:
       ${(0, utils_1.convertJsonToString)(stateChanged)}.
       Rename the rules to recreate them and avoid this error.`);
-            }
-            yield _super.validate.call(this, assets);
-        });
+        }
+        await super.validate(assets);
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { rules } = assets;
-            // Do nothing if not set
-            if (!rules)
+    async processChanges(assets) {
+        const { rules } = assets;
+        // Do nothing if not set
+        if (!rules)
+            return;
+        logger_1.default.warn('Rules are deprecated, migrate to using actions instead. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-rules-to-actions for more information.');
+        try {
+            // Figure out what needs to be updated vs created
+            const changes = await this.calcChanges(assets);
+            // Temporally re-order rules with conflicting ordering
+            await this.client.pool
+                .addEachTask({
+                data: changes.reOrder,
+                generator: (rule) => this.client.rules
+                    .update(rule.id, (0, utils_1.stripFields)(rule, this.stripUpdateFields))
+                    .then(() => {
+                    const updated = {
+                        name: rule.name,
+                        stage: rule.stage,
+                        order: rule.order,
+                        id: rule.id,
+                    };
+                    logger_1.default.info(`Temporally re-order Rule ${(0, utils_1.convertJsonToString)(updated)}`);
+                }),
+            })
+                .promise();
+            await super.processChanges(assets, {
+                del: changes.del,
+                create: changes.create,
+                update: changes.update,
+                conflicts: changes.conflicts,
+            });
+        }
+        catch (err) {
+            if ((0, utils_1.isDeprecatedError)(err)) {
+                logger_1.default.warn('Failed to update rules because functionality has been deprecated in favor of actions. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-rules-to-actions for more information.');
                 return;
-            logger_1.default.warn('Rules are deprecated, migrate to using actions instead. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-rules-to-actions for more information.');
-            try {
-                // Figure out what needs to be updated vs created
-                const changes = yield this.calcChanges(assets);
-                // Temporally re-order rules with conflicting ordering
-                yield this.client.pool
-                    .addEachTask({
-                    data: changes.reOrder,
-                    generator: (rule) => this.client.rules
-                        .update({ id: rule.id }, (0, utils_1.stripFields)(rule, this.stripUpdateFields))
-                        .then(() => {
-                        const updated = {
-                            name: rule.name,
-                            stage: rule.stage,
-                            order: rule.order,
-                            id: rule.id,
-                        };
-                        logger_1.default.info(`Temporally re-order Rule ${(0, utils_1.convertJsonToString)(updated)}`);
-                    }),
-                })
-                    .promise();
-                yield _super.processChanges.call(this, assets, {
-                    del: changes.del,
-                    create: changes.create,
-                    update: changes.update,
-                    conflicts: changes.conflicts,
-                });
-            }
-            catch (err) {
-                if ((0, utils_1.isDeprecatedError)(err)) {
-                    logger_1.default.warn('Failed to update rules because functionality has been deprecated in favor of actions. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-rules-to-actions for more information.');
-                    return;
-                }
-                throw err;
             }
-        });
+            throw err;
+        }
     }
 }
 exports.default = RulesHandler;
-//# sourceMappingURL=rules.js.map

package/lib/tools/auth0/handlers/rulesConfigs.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 };
 };
@@ -30,47 +21,47 @@ exports.schema = {
 };
 class RulesConfigsHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'rulesConfigs', id: 'key', functions: {
+        super({
+            ...options,
+            type: 'rulesConfigs',
+            id: 'key',
+            functions: {
                 update: 'set', // Update or Creation of a ruleConfig is via set not update
-            } }));
-    }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                const { data } = yield this.client.rulesConfigs.getAll();
-                return data;
-            }
-            catch (err) {
-                if ((0, utils_1.isDeprecatedError)(err))
-                    return null;
-                throw err;
-            }
+            },
         });
     }
+    async getType() {
+        try {
+            const data = await this.client.rulesConfigs.list();
+            return data;
+        }
+        catch (err) {
+            if ((0, utils_1.isDeprecatedError)(err))
+                return null;
+            throw err;
+        }
+    }
     objString(item) {
         return super.objString({ key: item.key });
     }
-    calcChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { rulesConfigs } = assets;
-            // Do nothing if not set
-            if (!rulesConfigs || !rulesConfigs.length)
-                return {
-                    del: [],
-                    update: [],
-                    create: [],
-                    conflicts: [],
-                };
-            logger_1.default.warn('Rules are deprecated, migrate to using actions instead. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-rules-to-actions for more information.');
-            // Intention is to not delete/cleanup old configRules, that needs to be handled manually.
+    async calcChanges(assets) {
+        const { rulesConfigs } = assets;
+        // Do nothing if not set
+        if (!rulesConfigs || !rulesConfigs.length)
             return {
                 del: [],
-                update: rulesConfigs,
+                update: [],
                 create: [],
                 conflicts: [],
             };
-        });
+        logger_1.default.warn('Rules are deprecated, migrate to using actions instead. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-rules-to-actions for more information.');
+        // Intention is to not delete/cleanup old configRules, that needs to be handled manually.
+        return {
+            del: [],
+            update: rulesConfigs,
+            create: [],
+            conflicts: [],
+        };
     }
 }
 exports.default = RulesConfigsHandler;
-//# sourceMappingURL=rulesConfigs.js.map

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

@@ -1,4 +1,5 @@
 import { PromisePoolExecutor } from 'promise-pool-executor';
+import { Management } from 'auth0';
 import { Asset } from '../../../types';
 interface ScimRequestParams {
     id: string;
@@ -64,7 +65,7 @@ export default class ScimHandler {
     /**
      * Retrieves `SCIM` configuration of an enterprise connection.
      */
-    getScimConfiguration({ id }: ScimRequestParams): Promise<Asset | null>;
+    getScimConfiguration({ id, }: ScimRequestParams): Promise<Management.GetScimConfigurationResponseContent | null>;
     /**
      * Updates an existing `SCIM` configuration.
      */
@@ -73,7 +74,7 @@ export default class ScimHandler {
      * Deletes an existing `SCIM` configuration.
      */
     deleteScimConfiguration({ id }: ScimRequestParams): Promise<Asset | null>;
-    updateOverride(requestParams: ScimRequestParams, bodyParams: Asset): Promise<import("auth0").ApiResponse<import("auth0").Connection>>;
-    createOverride(bodyParams: Asset): Promise<import("auth0").Connection>;
+    updateOverride(requestParams: ScimRequestParams, bodyParams: Asset): Promise<Management.UpdateConnectionResponseContent>;
+    createOverride(bodyParams: Asset): Promise<Management.CreateConnectionResponseContent>;
 }
 export {};