auth0-deploy-cli 7.6.0 → 7.8.0

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

@@ -44,7 +44,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importStar(require("./default"));
 const calculateChanges_1 = require("../../calculateChanges");
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'array',
     items: {
@@ -59,15 +59,15 @@ exports.schema = {
                     type: 'object',
                     properties: {
                         permission_name: { type: 'string' },
-                        resource_server_identifier: { type: 'string' }
-                    }
-                }
-            }
+                        resource_server_identifier: { type: 'string' },
+                    },
+                },
+            },
         },
-        required: ['name']
-    }
+        required: ['name'],
+    },
 };
-class RoleHandler extends default_1.default {
+class RolesHandler extends default_1.default {
     constructor(config) {
         super(Object.assign(Object.assign({}, config), { type: 'roles', id: 'id', identifiers: ['name'] }));
     }
@@ -84,15 +84,19 @@ class RoleHandler extends default_1.default {
     }
     createRoles(creates) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool.addEachTask({
+            yield this.client.pool
+                .addEachTask({
                 data: creates || [],
-                generator: (item) => this.createRole(item).then((data) => {
+                generator: (item) => this.createRole(item)
+                    .then((data) => {
                     this.didCreate(data);
                     this.created += 1;
-                }).catch((err) => {
-                    throw new Error(`Problem creating ${this.type} ${this.objString(item)}\n${err}`);
                 })
-            }).promise();
+                    .catch((err) => {
+                    throw new Error(`Problem creating ${this.type} ${this.objString(item)}\n${err}`);
+                }),
+            })
+                .promise();
         });
     }
     deleteRole(data) {
@@ -102,16 +106,21 @@ class RoleHandler extends default_1.default {
     }
     deleteRoles(dels) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.config('AUTH0_ALLOW_DELETE') === 'true' || this.config('AUTH0_ALLOW_DELETE') === true) {
-                yield this.client.pool.addEachTask({
+            if (this.config('AUTH0_ALLOW_DELETE') === 'true' ||
+                this.config('AUTH0_ALLOW_DELETE') === true) {
+                yield this.client.pool
+                    .addEachTask({
                     data: dels || [],
-                    generator: (item) => this.deleteRole(item).then(() => {
+                    generator: (item) => this.deleteRole(item)
+                        .then(() => {
                         this.didDelete(item);
                         this.deleted += 1;
-                    }).catch((err) => {
-                        throw new Error(`Problem deleting ${this.type} ${this.objString(item)}\n${err}`);
                     })
-                }).promise();
+                        .catch((err) => {
+                        throw new Error(`Problem deleting ${this.type} ${this.objString(item)}\n${err}`);
+                    }),
+                })
+                    .promise();
             }
             else {
                 logger_1.default.warn(`Detected the following roles should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config
@@ -138,15 +147,19 @@ class RoleHandler extends default_1.default {
     }
     updateRoles(updates, roles) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool.addEachTask({
+            yield this.client.pool
+                .addEachTask({
                 data: updates || [],
-                generator: (item) => this.updateRole(item, roles).then((data) => {
+                generator: (item) => this.updateRole(item, roles)
+                    .then((data) => {
                     this.didUpdate(data);
                     this.updated += 1;
-                }).catch((err) => {
-                    throw new Error(`Problem updating ${this.type} ${this.objString(item)}\n${err}`);
                 })
-            }).promise();
+                    .catch((err) => {
+                    throw new Error(`Problem updating ${this.type} ${this.objString(item)}\n${err}`);
+                }),
+            })
+                .promise();
         });
     }
     getType() {
@@ -161,7 +174,11 @@ class RoleHandler extends default_1.default {
             try {
                 const roles = yield this.client.roles.getAll({ paginate: true, include_totals: true });
                 for (let index = 0; index < roles.length; index++) {
-                    const permissions = yield this.client.roles.permissions.getAll({ paginate: true, include_totals: true, id: roles[index].id });
+                    const permissions = yield this.client.roles.permissions.getAll({
+                        paginate: true,
+                        include_totals: true,
+                        id: roles[index].id,
+                    });
                     const strippedPerms = yield Promise.all(permissions.map((permission) => __awaiter(this, void 0, void 0, function* () {
                         delete permission.resource_server_name;
                         delete permission.description;
@@ -192,20 +209,27 @@ class RoleHandler extends default_1.default {
                 handler: this,
                 assets: roles,
                 existing,
-                identifiers: ['id', 'name']
+                identifiers: ['id', 'name'],
+                allowDelete: false, //TODO: actually pass in correct allowDelete value
             });
             logger_1.default.debug(`Start processChanges for roles [delete:${changes.del.length}] [update:${changes.update.length}], [create:${changes.create.length}]`);
-            const myChanges = [{ del: changes.del }, { create: changes.create }, { update: changes.update }];
+            const myChanges = [
+                { del: changes.del },
+                { create: changes.create },
+                { update: changes.update },
+            ];
             yield Promise.all(myChanges.map((change) => __awaiter(this, void 0, void 0, function* () {
                 switch (true) {
                     case change.del && change.del.length > 0:
-                        yield this.deleteRoles(change.del);
+                        if (change.del)
+                            yield this.deleteRoles(change.del);
                         break;
                     case change.create && change.create.length > 0:
-                        yield this.createRoles(changes.create);
+                        yield this.createRoles(changes.create); //TODO: fix this tho change.create
                         break;
                     case change.update && change.update.length > 0:
-                        yield this.updateRoles(change.update, existing);
+                        if (change.update)
+                            yield this.updateRoles(change.update, existing);
                         break;
                     default:
                         break;
@@ -216,5 +240,5 @@ class RoleHandler extends default_1.default {
 }
 __decorate([
     (0, default_1.order)('60')
-], RoleHandler.prototype, "processChanges", null);
-exports.default = RoleHandler;
+], RolesHandler.prototype, "processChanges", null);
+exports.default = RolesHandler;

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

@@ -0,0 +1,55 @@
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export declare const excludeSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+};
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        default: never[];
+        properties: {
+            script: {
+                type: string;
+                description: string;
+                default: string;
+            };
+            name: {
+                type: string;
+                description: string;
+                pattern: string;
+            };
+            order: {
+                type: string[];
+                description: string;
+                default: null;
+            };
+            enabled: {
+                type: string;
+                description: string;
+                default: boolean;
+            };
+            stage: {
+                type: string;
+                description: string;
+                default: string;
+                enum: string[];
+            };
+        };
+        required: string[];
+    };
+};
+export default class RulesHandler extends DefaultHandler {
+    existing: Asset[];
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    objString(rule: any): string;
+    calcChanges(assets: any, includeExcluded?: boolean): Promise<CalculatedChanges & {
+        reOrder: Asset[];
+    }>;
+    validate(assets: Assets): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -13,14 +13,14 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = exports.excludeSchema = void 0;
-const ValidationError_1 = __importDefault(require("../../ValidationError"));
+const validationError_1 = __importDefault(require("../../validationError"));
 const utils_1 = require("../../utils");
 const default_1 = __importDefault(require("./default"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 const calculateChanges_1 = require("../../calculateChanges");
 exports.excludeSchema = {
     type: 'array',
-    items: { type: 'string' }
+    items: { type: 'string' },
 };
 exports.schema = {
     type: 'array',
@@ -30,38 +30,37 @@ exports.schema = {
         properties: {
             script: {
                 type: 'string',
-                description: 'A script that contains the rule\'s code',
-                default: ''
+                description: "A script that contains the rule's code",
+                default: '',
             },
             name: {
                 type: 'string',
-                description: 'The name of the rule. Can only contain alphanumeric characters, spaces and \'-\'. Can neither start nor end with \'-\' or spaces',
-                pattern: '^[^-\\s][a-zA-Z0-9-\\s]+[^-\\s]$'
+                description: "The name of the rule. Can only contain alphanumeric characters, spaces and '-'. Can neither start nor end with '-' or spaces",
+                pattern: '^[^-\\s][a-zA-Z0-9-\\s]+[^-\\s]$',
             },
             order: {
                 type: ['number', 'null'],
-                description: 'The rule\'s order in relation to other rules. A rule with a lower order than another rule executes first.',
-                default: null
+                description: "The rule's order in relation to other rules. A rule with a lower order than another rule executes first.",
+                default: null,
             },
             enabled: {
                 type: 'boolean',
                 description: 'true if the rule is enabled, false otherwise',
-                default: true
+                default: true,
             },
             stage: {
                 type: 'string',
-                description: 'The rule\'s execution stage',
+                description: "The rule's execution stage",
                 default: 'login_success',
-                enum: ['login_success', 'login_failure', 'pre_authorize']
-            }
+                enum: ['login_success', 'login_failure', 'pre_authorize'],
+            },
         },
-        required: ['name']
-    }
+        required: ['name'],
+    },
 };
 class RulesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'rules', stripUpdateFields: ['stage'] // Fields not allowed in updates
-         }));
+        super(Object.assign(Object.assign({}, options), { type: 'rules', stripUpdateFields: ['stage'] }));
     }
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
@@ -89,18 +88,23 @@ class RulesHandler extends default_1.default {
                 handler: this,
                 assets: rules,
                 existing,
-                identifiers: ['id', 'name']
+                identifiers: ['id', 'name'],
+                allowDelete: false, //TODO: actually pass in correct allowDelete value
             });
             // 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) => {
                 const conflict = existing.find((f) => r.order === f.order && r.name !== f.name);
-                if (conflict) {
+                if (conflict !== undefined) {
                     nextOrderNo += 1;
-                    accum.push(Object.assign(Object.assign({}, conflict), { order: nextOrderNo }));
+                    return [
+                        ...accum,
+                        Object.assign(Object.assign({}, conflict), { order: nextOrderNo }),
+                    ];
                 }
                 return accum;
             }, []);
@@ -109,7 +113,7 @@ class RulesHandler extends default_1.default {
                 update,
                 create,
                 reOrder,
-                conflicts
+                conflicts,
             };
         });
     }
@@ -127,24 +131,30 @@ class RulesHandler extends default_1.default {
             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))];
+            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.dumpJSON)(formatted)}.
+                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();
-            const stateChanged = futureRules.reduce((changed, rule) => ([
+            const stateChanged = futureRules
+                .reduce((changed, rule) => [
                 ...changed,
-                ...existing.filter((r) => rule.name.toLowerCase() === r.name.toLowerCase() && r.stage !== rule.stage)
-            ]), []).map((r) => r.name);
+                ...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.dumpJSON)(stateChanged)}.
+                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);
@@ -162,20 +172,27 @@ class RulesHandler extends default_1.default {
             // 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({
+            yield this.client.pool
+                .addEachTask({
                 data: changes.reOrder,
-                generator: (rule) => this.client.updateRule({ id: rule.id }, (0, utils_1.stripFields)(rule, this.stripUpdateFields)).then(() => {
+                generator: (rule) => this.client
+                    .updateRule({ 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
+                        name: rule.name,
+                        stage: rule.stage,
+                        order: rule.order,
+                        id: rule.id,
                     };
-                    logger_1.default.info(`Temporally re-order Rule ${(0, utils_1.dumpJSON)(updated)}`);
-                })
-            }).promise();
+                    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
+                conflicts: changes.conflicts,
             });
         });
     }

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

@@ -0,0 +1,25 @@
+import { Assets, Asset, CalculatedChanges } from '../../../types';
+import DefaultHandler from './default';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            key: {
+                type: string;
+                pattern: string;
+            };
+            value: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+    additionalProperties: boolean;
+};
+export default class RulesConfigsHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset[]>;
+    objString(item: any): string;
+    calcChanges(assets: Assets): Promise<CalculatedChanges>;
+}

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

@@ -20,16 +20,16 @@ exports.schema = {
         type: 'object',
         properties: {
             key: { type: 'string', pattern: '^[A-Za-z0-9_-]*$' },
-            value: { type: 'string' }
+            value: { type: 'string' },
         },
-        required: ['key', 'value']
+        required: ['key', 'value'],
     },
-    additionalProperties: false
+    additionalProperties: false,
 };
 class RulesConfigsHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'rulesConfigs', id: 'key', functions: {
-                update: 'set' // Update or Creation of a ruleConfig is via set not update
+                update: 'set', // Update or Creation of a ruleConfig is via set not update
             } }));
     }
     getType() {
@@ -45,12 +45,18 @@ class RulesConfigsHandler extends default_1.default {
             const { rulesConfigs } = assets;
             // Do nothing if not set
             if (!rulesConfigs || !rulesConfigs.length)
-                return {};
+                return {
+                    del: [],
+                    update: [],
+                    create: [],
+                    conflicts: [],
+                };
             // Intention is to not delete/cleanup old configRules, that needs to be handled manually.
             return {
                 del: [],
                 update: rulesConfigs,
-                create: []
+                create: [],
+                conflicts: [],
             };
         });
     }

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

@@ -0,0 +1,11 @@
+import DefaultHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+};
+export default class TenantHandler extends DefaultHandler {
+    constructor(options: DefaultHandler);
+    getType(): Promise<Asset>;
+    validate(assets: Assets): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -42,14 +42,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
-const ValidationError_1 = __importDefault(require("../../ValidationError"));
+const validationError_1 = __importDefault(require("../../validationError"));
 const default_1 = __importStar(require("./default"));
 const pages_1 = require("./pages");
 const utils_1 = require("../../utils");
 exports.schema = {
-    type: 'object'
+    type: 'object',
 };
-const blockPageKeys = [...Object.keys(pages_1.pageNameMap), ...Object.values(pages_1.pageNameMap), ...pages_1.supportedPages];
+const blockPageKeys = [
+    ...Object.keys(pages_1.pageNameMap),
+    ...Object.values(pages_1.pageNameMap),
+    ...pages_1.supportedPages,
+];
 class TenantHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'tenant' }));
@@ -72,7 +76,7 @@ class TenantHandler extends default_1.default {
                 return;
             const pageKeys = Object.keys(tenant).filter((k) => blockPageKeys.includes(k));
             if (pageKeys.length > 0) {
-                throw new ValidationError_1.default(`The following pages ${(0, utils_1.dumpJSON)(pageKeys)} were found in tenant settings. Pages should be set separately. Please refer to the documentation.`);
+                throw new validationError_1.default(`The following pages ${(0, utils_1.convertJsonToString)(pageKeys)} were found in tenant settings. Pages should be set separately. Please refer to the documentation.`);
             }
         });
     }

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

@@ -0,0 +1,35 @@
+import DefaultHandler from './default';
+import { Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        additionalProperties: boolean;
+        properties: {
+            trigger_id: {
+                type: string;
+                properties: {
+                    action_name: {
+                        type: string;
+                        enum: string[];
+                    };
+                    display_name: {
+                        type: string;
+                        default: string;
+                    };
+                };
+            };
+        };
+    };
+};
+export default class TriggersHandler extends DefaultHandler {
+    existing: {
+        [key: string]: {
+            action_name: string;
+            display_name: string;
+        };
+    };
+    constructor(options: DefaultHandler);
+    getType(): Promise<DefaultHandler['existing']>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -45,7 +45,7 @@ exports.schema = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const default_1 = __importStar(require("./default"));
 const constants_1 = __importDefault(require("../../constants"));
-const logger_1 = __importDefault(require("../../logger"));
+const logger_1 = __importDefault(require("../../../logger"));
 exports.schema = {
     type: 'object',
     items: {
@@ -56,15 +56,15 @@ exports.schema = {
                 type: 'object',
                 properties: {
                     action_name: { type: 'string', enum: constants_1.default.ACTIONS_TRIGGERS },
-                    display_name: { type: 'string', default: '' }
-                }
-            }
-        }
-    }
+                    display_name: { type: 'string', default: '' },
+                },
+            },
+        },
+    },
 };
 function isActionsDisabled(err) {
     const errorBody = lodash_1.default.get(err, 'originalError.response.body') || {};
-    return (err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled');
+    return err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled';
 }
 class TriggersHandler extends default_1.default {
     constructor(options) {
@@ -76,8 +76,7 @@ class TriggersHandler extends default_1.default {
                 return this.existing;
             }
             // in case client version does not support actions
-            if (!this.client.actions
-                || typeof this.client.actions.getAllTriggers !== 'function') {
+            if (!this.client.actions || typeof this.client.actions.getAllTriggers !== 'function') {
                 return [];
             }
             const triggerBindings = {};
@@ -87,12 +86,12 @@ class TriggersHandler extends default_1.default {
                 for (let i = 0; i < triggers.length; i++) {
                     const triggerId = triggers[i];
                     const { bindings } = yield this.client.actions.getTriggerBindings({
-                        trigger_id: triggerId
+                        trigger_id: triggerId,
                     });
                     if (bindings.length > 0) {
                         triggerBindings[triggerId] = bindings.map((binding) => ({
                             action_name: binding.action.name,
-                            display_name: binding.display_name
+                            display_name: binding.display_name,
                         }));
                     }
                 }
@@ -123,9 +122,9 @@ class TriggersHandler extends default_1.default {
                 const bindings = data.map((binding) => ({
                     ref: {
                         type: 'action_name',
-                        value: binding.action_name
+                        value: binding.action_name,
                     },
-                    display_name: binding.display_name
+                    display_name: binding.display_name,
                 }));
                 yield this.client.actions.updateTriggerBindings({ trigger_id: name }, { bindings });
                 this.didUpdate({ trigger_id: name });

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

@@ -0,0 +1,15 @@
+import { Assets, Auth0APIClient, BaseAuth0APIClient } from '../../types';
+import APIHandler from './handlers/default';
+import { ConfigFunction } from '../../configFactory';
+export declare type Stage = 'load' | 'validate' | 'processChanges';
+export default class Auth0 {
+    client: Auth0APIClient;
+    config: ConfigFunction;
+    assets: Assets;
+    handlers: APIHandler[];
+    constructor(client: BaseAuth0APIClient, assets: Assets, config: ConfigFunction);
+    runStage(stage: Stage): Promise<void>;
+    validate(): Promise<void>;
+    loadAll(): Promise<void>;
+    processChanges(): Promise<void>;
+}