auth0-deploy-cli 8.21.0 → 8.23.0

package/lib/tools/auth0/handlers/resourceServers.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 };
 };
@@ -47,7 +38,7 @@ exports.schema = {
                 properties: {
                     mechanism: {
                         type: 'string',
-                        enum: Object.values(auth0_1.ResourceServerProofOfPossessionMechanismEnum),
+                        enum: Object.values(auth0_1.Management.ResourceServerProofOfPossessionMechanismEnum),
                     },
                     required: { type: 'boolean' },
                 },
@@ -62,7 +53,7 @@ exports.schema = {
                         properties: {
                             policy: {
                                 type: 'string',
-                                enum: Object.values(auth0_1.ResourceServerSubjectTypeAuthorizationUserPolicyEnum),
+                                enum: Object.values(auth0_1.Management.ResourceServerSubjectTypeAuthorizationUserPolicyEnum),
                             },
                         },
                     },
@@ -72,7 +63,7 @@ exports.schema = {
                         properties: {
                             policy: {
                                 type: 'string',
-                                enum: Object.values(auth0_1.ResourceServerSubjectTypeAuthorizationClientPolicyEnum),
+                                enum: Object.values(auth0_1.Management.ResourceServerSubjectTypeAuthorizationClientPolicyEnum),
                             },
                         },
                     },
@@ -90,63 +81,109 @@ exports.schema = {
 };
 class ResourceServersHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'resourceServers', identifiers: ['id', 'identifier'], stripCreateFields: ['client_id'], stripUpdateFields: ['identifier', 'client_id', 'is_system'] }));
+        super({
+            ...options,
+            type: 'resourceServers',
+            identifiers: ['id', 'identifier'],
+            stripCreateFields: ['client_id', 'is_system'],
+            stripUpdateFields: ['identifier', 'client_id', 'is_system'],
+            functions: {
+                update: (args, data) => this.updateResourceServer(args, data),
+            },
+        });
     }
     objString(resourceServer) {
         return super.objString({ name: resourceServer.name, identifier: resourceServer.identifier });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            const resourceServers = yield (0, client_1.paginate)(this.client.resourceServers.getAll, {
-                paginate: true,
-                include_totals: true,
-            });
-            return resourceServers.filter((rs) => rs.name !== constants_1.default.RESOURCE_SERVERS_MANAGEMENT_API_NAME);
+    async getType() {
+        if (this.existing)
+            return this.existing;
+        let resourceServers = await (0, client_1.paginate)(this.client.resourceServers.list, {
+            paginate: true,
         });
-    }
-    calcChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let { resourceServers } = assets;
-            // Do nothing if not set
-            if (!resourceServers)
-                return {
-                    del: [],
-                    create: [],
-                    conflicts: [],
-                    update: [],
-                };
-            const excluded = (assets.exclude && assets.exclude.resourceServers) || [];
-            let existing = yield this.getType();
-            // Filter excluded
-            resourceServers = resourceServers.filter((r) => !excluded.includes(r.name));
-            existing = existing.filter((r) => !excluded.includes(r.name));
-            return (0, calculateChanges_1.calculateChanges)({
-                handler: this,
-                assets: resourceServers,
-                existing,
-                identifiers: this.identifiers,
-                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
-            });
+        resourceServers = resourceServers.filter((rs) => rs.name !== constants_1.default.RESOURCE_SERVERS_MANAGEMENT_API_NAME);
+        // Sanitize resource servers fields
+        const sanitizeResourceServersFields = (rs) => rs.map((resourceServer) => {
+            // For system resource servers like Auth0 My Account API, only allow certain fields to be updated
+            if (resourceServer.is_system === true) {
+                const allowedKeys = [
+                    'token_lifetime',
+                    'proof_of_possession',
+                    'skip_consent_for_verifiable_first_party_clients',
+                    'name',
+                    'identifier',
+                    'id',
+                    'is_system',
+                ];
+                const sanitized = {};
+                allowedKeys.forEach((key) => {
+                    if (key in resourceServer) {
+                        sanitized[key] = resourceServer[key];
+                    }
+                });
+                return sanitized;
+            }
+            return resourceServer;
         });
+        this.existing = sanitizeResourceServersFields(resourceServers);
+        return this.existing;
     }
-    validate(assets) {
-        const _super = Object.create(null, {
-            validate: { get: () => super.validate }
+    async calcChanges(assets) {
+        let { resourceServers } = assets;
+        // Do nothing if not set
+        if (!resourceServers)
+            return {
+                del: [],
+                create: [],
+                conflicts: [],
+                update: [],
+            };
+        const excluded = (assets.exclude && assets.exclude.resourceServers) || [];
+        let existing = await this.getType();
+        // Filter excluded
+        resourceServers = resourceServers.filter((r) => r.name && !excluded.includes(r.name));
+        existing = existing.filter((r) => r.name && !excluded.includes(r.name));
+        return (0, calculateChanges_1.calculateChanges)({
+            handler: this,
+            assets: resourceServers,
+            existing,
+            identifiers: this.identifiers,
+            allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { resourceServers } = assets;
-            // Do nothing if not set
-            if (!resourceServers)
-                return;
-            const mgmtAPIResource = resourceServers.find((r) => r.name === constants_1.default.RESOURCE_SERVERS_MANAGEMENT_API_NAME);
-            if (mgmtAPIResource) {
-                throw new validationError_1.default(`You can not configure the '${constants_1.default.RESOURCE_SERVERS_MANAGEMENT_API_NAME}'.`);
-            }
-            yield _super.validate.call(this, assets);
+    }
+    async validate(assets) {
+        const { resourceServers } = assets;
+        // Do nothing if not set
+        if (!resourceServers)
+            return;
+        const mgmtAPIResource = resourceServers.find((r) => r.name === constants_1.default.RESOURCE_SERVERS_MANAGEMENT_API_NAME);
+        if (mgmtAPIResource) {
+            throw new validationError_1.default(`You can not configure the '${constants_1.default.RESOURCE_SERVERS_MANAGEMENT_API_NAME}'.`);
+        }
+        await super.validate(assets);
+    }
+    async processChanges(assets) {
+        const { resourceServers } = assets;
+        // Do nothing if not set
+        if (!resourceServers)
+            return;
+        const changes = await this.calcChanges(assets);
+        await super.processChanges(assets, {
+            ...changes,
         });
     }
+    async updateResourceServer(args, update) {
+        // Exclude name from update as it cannot be modified for system resource servers like Auth0 My Account API
+        if (update.is_system === true || update.name === 'Auth0 My Account API') {
+            const updateFields = {
+                token_lifetime: update.token_lifetime,
+                proof_of_possession: update.proof_of_possession,
+                skip_consent_for_verifiable_first_party_clients: update.skip_consent_for_verifiable_first_party_clients,
+                subject_type_authorization: update.subject_type_authorization,
+            };
+            return this.client.resourceServers.update(args?.id, updateFields);
+        }
+        return this.client.resourceServers.update(args?.id, update);
+    }
 }
 exports.default = ResourceServersHandler;
-//# sourceMappingURL=resourceServers.js.map

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

@@ -38,21 +38,11 @@ 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;
-const lodash_1 = require("lodash");
 const default_1 = __importStar(require("./default"));
 const calculateChanges_1 = require("../../calculateChanges");
 const logger_1 = __importDefault(require("../../../logger"));
@@ -81,196 +71,190 @@ exports.schema = {
 };
 class RolesHandler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'roles', id: 'id' }));
-    }
-    createRole(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const role = Object.assign({}, data);
-            delete role.permissions;
-            const { data: created } = yield this.client.roles.create(role);
-            if (typeof data.permissions !== 'undefined' && data.permissions.length > 0) {
-                yield this.client.roles.addPermissions({ id: created.id }, { permissions: data.permissions });
-            }
-            return created;
+        super({
+            ...config,
+            type: 'roles',
+            id: 'id',
         });
     }
-    createRoles(creates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool
+    async createRole(data) {
+        const role = { ...data };
+        delete role.permissions;
+        const created = await this.client.roles.create(role);
+        if (created.id && typeof data.permissions !== 'undefined' && data.permissions.length > 0) {
+            await this.client.roles.permissions.add(created.id, { permissions: data.permissions });
+        }
+        return created;
+    }
+    async createRoles(creates) {
+        await this.client.pool
+            .addEachTask({
+            data: creates || [],
+            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();
+    }
+    async deleteRole(data) {
+        await this.client.roles.delete(data.id);
+    }
+    async deleteRoles(dels) {
+        if (this.config('AUTH0_ALLOW_DELETE') === 'true' ||
+            this.config('AUTH0_ALLOW_DELETE') === true) {
+            await this.client.pool
                 .addEachTask({
-                data: creates || [],
-                generator: (item) => this.createRole(item)
-                    .then((data) => {
-                    this.didCreate(data);
-                    this.created += 1;
+                data: dels || [],
+                generator: (item) => this.deleteRole(item)
+                    .then(() => {
+                    this.didDelete(item);
+                    this.deleted += 1;
                 })
                     .catch((err) => {
-                    throw new Error(`Problem creating ${this.type} ${this.objString(item)}\n${err}`);
+                    throw new Error(`Problem deleting ${this.type} ${this.objString(item)}\n${err}`);
                 }),
             })
                 .promise();
-        });
-    }
-    deleteRole(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.roles.delete({ id: data.id });
-        });
-    }
-    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({
-                    data: dels || [],
-                    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();
-            }
-            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
+        }
+        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
       \n${dels.map((i) => this.objString(i)).join('\n')}`);
-            }
-        });
+        }
     }
-    updateRole(data, roles) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const existingRole = yield roles.find((roleDataForUpdate) => roleDataForUpdate.name === data.name);
-            const params = { id: data.id };
-            const newPermissions = data.permissions;
-            delete data.permissions;
-            delete data.id;
-            yield this.client.roles.update(params, data);
-            if (typeof existingRole.permissions !== 'undefined' && existingRole.permissions.length > 0) {
-                yield this.client.roles.deletePermissions(params, { permissions: existingRole.permissions });
-            }
-            if (typeof newPermissions !== 'undefined' && newPermissions.length > 0) {
-                yield this.client.roles.addPermissions(params, { permissions: newPermissions });
-            }
-            return params;
-        });
+    async updateRole(data, roles) {
+        const existingRole = await roles.find((roleDataForUpdate) => roleDataForUpdate.name === data.name);
+        const params = { id: data.id };
+        const newPermissions = data.permissions;
+        delete data.permissions;
+        delete data.id;
+        await this.client.roles.update(params.id, data);
+        if (typeof existingRole.permissions !== 'undefined' && existingRole.permissions.length > 0) {
+            await this.client.roles.permissions.delete(params.id, {
+                permissions: existingRole.permissions,
+            });
+        }
+        if (typeof newPermissions !== 'undefined' && newPermissions.length > 0) {
+            await this.client.roles.permissions.add(params.id, { permissions: newPermissions });
+        }
+        return params;
     }
-    updateRoles(updates, roles) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool
-                .addEachTask({
-                data: updates || [],
-                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}`);
-                }),
+    async updateRoles(updates, roles) {
+        await this.client.pool
+            .addEachTask({
+            data: updates || [],
+            generator: (item) => this.updateRole(item, roles)
+                .then((data) => {
+                this.didUpdate(data);
+                this.updated += 1;
             })
-                .promise();
-        });
+                .catch((err) => {
+                throw new Error(`Problem updating ${this.type} ${this.objString(item)}\n${err}`);
+            }),
+        })
+            .promise();
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            // in case client version does not support roles
-            if (!this.client.roles || typeof this.client.roles.getAll !== 'function') {
-                return [];
-            }
-            try {
-                const roles = yield (0, client_1.paginate)(this.client.roles.getAll, {
-                    paginate: true,
+    async getType() {
+        if (this.existing) {
+            return this.existing;
+        }
+        try {
+            const roles = await (0, client_1.paginate)(this.client.roles.list, {
+                paginate: true,
+                include_totals: true,
+            });
+            for (let index = 0; index < roles.length; index++) {
+                const allPermission = [];
+                /*
+                let page = 0;
+                while (true) {
+                  const {
+                    data: { permissions, total },
+                  } = await this.client.roles.permissions.list({
                     include_totals: true,
-                });
-                for (let index = 0; index < roles.length; index++) {
-                    // paginate without paginate<T> helper as this is not getAll but getPermissions
-                    // paginate through all permissions for each role
-                    const allPermission = [];
-                    let page = 0;
-                    while (true) {
-                        const { data: { permissions, total }, } = yield this.client.roles.getPermissions({
-                            include_totals: true,
-                            id: roles[index].id,
-                            page: page,
-                            per_page: 100,
-                        });
-                        allPermission.push(...permissions);
-                        page += 1;
-                        if (allPermission.length === total) {
-                            break;
-                        }
-                        // if we get an unexpected response, break the loop to avoid infinite loop
-                        if (!(0, lodash_1.isArray)(permissions) || typeof total !== 'number') {
-                            break;
-                        }
-                    }
-                    const strippedPerms = yield Promise.all(allPermission.map((permission) => __awaiter(this, void 0, void 0, function* () {
-                        delete permission.resource_server_name;
-                        delete permission.description;
-                        return permission;
-                    })));
-                    roles[index].permissions = strippedPerms;
+                    id: roles[index].id,
+                    page: page,
+                    per_page: 100,
+                  });
+        
+                  allPermission.push(...permissions);
+                  page += 1;
+                  if (allPermission.length === total) {
+                    break;
+                  }
+                  // if we get an unexpected response, break the loop to avoid infinite loop
+                  if (!isArray(permissions) || typeof total !== 'number') {
+                    break;
+                  }
                 }
-                this.existing = roles;
-                return this.existing;
+                */
+                const rolesId = roles[index].id;
+                let permissions = await this.client.roles.permissions.list(rolesId, { per_page: 100 });
+                do {
+                    allPermission.push(...permissions.data);
+                    permissions = await permissions.getNextPage();
+                } while (permissions.hasNextPage());
+                const strippedPerms = await Promise.all(allPermission.map(async (permission) => {
+                    delete permission.resource_server_name;
+                    delete permission.description;
+                    return permission;
+                }));
+                roles[index].permissions = strippedPerms;
             }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return [];
-                }
-                throw err;
+            this.existing = roles;
+            return this.existing;
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
+                return [];
             }
-        });
+            throw err;
+        }
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { roles } = assets;
-            // Do nothing if not set
-            if (!roles)
-                return;
-            // Gets roles from destination tenant
-            const existing = yield this.getType();
-            const changes = (0, calculateChanges_1.calculateChanges)({
-                handler: this,
-                assets: roles,
-                existing,
-                identifiers: this.identifiers,
-                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
-            });
-            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 },
-            ];
-            yield Promise.all(myChanges.map((change) => __awaiter(this, void 0, void 0, function* () {
-                switch (true) {
-                    case change.del && change.del.length > 0:
-                        if (change.del)
-                            yield this.deleteRoles(change.del);
-                        break;
-                    case change.create && change.create.length > 0:
-                        yield this.createRoles(changes.create); //TODO: fix this tho change.create
-                        break;
-                    case change.update && change.update.length > 0:
-                        if (change.update)
-                            yield this.updateRoles(change.update, existing);
-                        break;
-                    default:
-                        break;
-                }
-            })));
+    async processChanges(assets) {
+        const { roles } = assets;
+        // Do nothing if not set
+        if (!roles)
+            return;
+        // Gets roles from destination tenant
+        const existing = await this.getType();
+        const changes = (0, calculateChanges_1.calculateChanges)({
+            handler: this,
+            assets: roles,
+            existing,
+            identifiers: this.identifiers,
+            allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
         });
+        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 },
+        ];
+        await Promise.all(myChanges.map(async (change) => {
+            switch (true) {
+                case change.del && change.del.length > 0:
+                    if (change.del)
+                        await this.deleteRoles(change.del);
+                    break;
+                case change.create && change.create.length > 0:
+                    await this.createRoles(changes.create);
+                    break;
+                case change.update && change.update.length > 0:
+                    if (change.update)
+                        await this.updateRoles(change.update, existing);
+                    break;
+                default:
+                    break;
+            }
+        }));
     }
 }
 exports.default = RolesHandler;
 __decorate([
     (0, default_1.order)('60')
 ], RolesHandler.prototype, "processChanges", null);
-//# sourceMappingURL=roles.js.map