auth0-deploy-cli 8.21.0 → 8.23.0

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

@@ -38,26 +38,6 @@ 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 __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -83,97 +63,93 @@ exports.schema = {
 };
 class BrandingHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'branding' }));
+        super({
+            ...options,
+            type: 'branding',
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            let branding = {};
-            try {
-                // in case client version does not support branding
-                if (this.client.branding && typeof this.client.branding.getSettings === 'function') {
-                    const response = yield this.client.branding.getSettings();
-                    branding = response.data;
+    async getType() {
+        let branding = {};
+        try {
+            branding = await this.client.branding.get();
+            const customDomains = await this.client.customDomains.list();
+            // templates are only supported if there's custom domains.
+            if (customDomains && customDomains.length) {
+                let payload = await this.client.branding.templates.getUniversalLogin();
+                payload = payload;
+                if (Object.keys(branding).length === 0) {
+                    branding = {
+                        templates: [
+                            {
+                                template: constants_1.default.UNIVERSAL_LOGIN_TEMPLATE,
+                                body: payload.body,
+                            },
+                        ],
+                    };
                 }
-                // in case client version does not custom domains
-                if (this.client.customDomains && typeof this.client.customDomains.getAll === 'function') {
-                    let { data: customDomains } = yield this.client.customDomains.getAll();
-                    customDomains = customDomains;
-                    // templates are only supported if there's custom domains.
-                    if (customDomains && customDomains.length) {
-                        const { data: payload } = yield this.client.branding.getUniversalLoginTemplate();
-                        if (Object.keys(branding).length === 0) {
-                            branding = {
-                                templates: [
-                                    {
-                                        template: constants_1.default.UNIVERSAL_LOGIN_TEMPLATE,
-                                        body: payload.body,
-                                    },
-                                ],
-                            };
-                        }
-                        else {
-                            branding = Object.assign(Object.assign({}, branding), { templates: [
-                                    {
-                                        template: constants_1.default.UNIVERSAL_LOGIN_TEMPLATE,
-                                        body: payload.body,
-                                    },
-                                ] });
-                        }
-                    }
+                else {
+                    branding = {
+                        ...branding,
+                        templates: [
+                            {
+                                template: constants_1.default.UNIVERSAL_LOGIN_TEMPLATE,
+                                body: payload.body,
+                            },
+                        ],
+                    };
                 }
-                return branding;
             }
-            catch (err) {
-                logger_1.default.debug(`Error calling branding API, ${err.message}, status code: ${err.statusCode}`);
-                if (err.statusCode === 403) {
-                    logger_1.default.warn('Insufficient scope the read:custom_domains scope is not set. Branding templates will not be exported.');
-                    return branding;
-                }
-                if (err.statusCode === 404)
-                    return branding;
-                if (err.statusCode === 501)
-                    return branding;
-                throw err;
+            return branding;
+        }
+        catch (err) {
+            logger_1.default.debug(`Error calling branding API, ${err.message}, status code: ${err.statusCode}`);
+            if (err.statusCode === 403) {
+                logger_1.default.warn('Insufficient scope the read:custom_domains scope is not set. Branding templates will not be exported.');
+                return branding;
             }
-        });
+            if (err.statusCode === 404)
+                return branding;
+            if (err.statusCode === 501)
+                return branding;
+            throw err;
+        }
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!assets.branding)
-                return;
-            const _a = assets.branding, { templates } = _a, brandingSettings = __rest(_a, ["templates"]);
-            if (brandingSettings.logo_url === '') {
-                //Sometimes blank logo_url returned by API but is invalid on import. See: DXCDT-240
-                delete brandingSettings.logo_url;
+    async processChanges(assets) {
+        if (!assets.branding)
+            return;
+        const { templates, ...brandingSettings } = assets.branding;
+        if (brandingSettings.logo_url === '') {
+            // Sometimes blank logo_url returned by API but is invalid on import. See: DXCDT-240
+            delete brandingSettings.logo_url;
+        }
+        if (brandingSettings && Object.keys(brandingSettings).length) {
+            await this.client.branding.update(brandingSettings);
+            this.updated += 1;
+            this.didUpdate(brandingSettings);
+        }
+        // handle templates
+        if (templates && templates.length) {
+            const unknownTemplates = templates
+                .filter((t) => !constants_1.default.SUPPORTED_BRANDING_TEMPLATES.includes(t.template))
+                .map((t) => t.template);
+            if (unknownTemplates.length) {
+                // throw a helpful warning for unknown templates, the context handlers are unaware of which are supported, that's all handled here.
+                logger_1.default.warn(`Found unknown branding template(s): ${unknownTemplates
+                    .join()
+                    .toString()}. Supported branding templates are: ${constants_1.default.SUPPORTED_BRANDING_TEMPLATES.join()}.`);
             }
-            if (brandingSettings && Object.keys(brandingSettings).length) {
-                yield this.client.branding.updateSettings(brandingSettings);
+            const templateDefinition = templates.find((t) => t.template === constants_1.default.UNIVERSAL_LOGIN_TEMPLATE);
+            if (templateDefinition && templateDefinition.body) {
+                await this.client.branding.templates.updateUniversalLogin({
+                    template: templateDefinition.body,
+                });
                 this.updated += 1;
-                this.didUpdate(brandingSettings);
+                this.didUpdate(templates);
             }
-            // handle templates
-            if (templates && templates.length) {
-                const unknownTemplates = templates
-                    .filter((t) => !constants_1.default.SUPPORTED_BRANDING_TEMPLATES.includes(t.template))
-                    .map((t) => t.template);
-                if (unknownTemplates.length) {
-                    // throw a helpful warning for unknown templates, the context handlers are unaware of which are supported, that's all handled here.
-                    logger_1.default.warn(`Found unknown branding template(s): ${unknownTemplates
-                        .join()
-                        .toString()}. Supported branding templates are: ${constants_1.default.SUPPORTED_BRANDING_TEMPLATES.join()}.`);
-                }
-                const templateDefinition = templates.find((t) => t.template === constants_1.default.UNIVERSAL_LOGIN_TEMPLATE);
-                if (templateDefinition && templateDefinition.body) {
-                    yield this.client.branding.setUniversalLoginTemplate({ template: templateDefinition.body });
-                    this.updated += 1;
-                    this.didUpdate(templates);
-                }
-            }
-        });
+        }
     }
 }
 exports.default = BrandingHandler;
 __decorate([
     (0, default_1.order)('70') // Run after custom domains and themes.
 ], BrandingHandler.prototype, "processChanges", null);
-//# sourceMappingURL=branding.js.map

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

@@ -1,4 +1,4 @@
-import { ClientGrantSubjectTypeEnum } from 'auth0';
+import { Management } from 'auth0';
 import DefaultHandler from './default';
 import { Assets } from '../../../types';
 import DefaultAPIHandler from './default';
@@ -37,14 +37,7 @@ export declare const schema: {
         required: string[];
     };
 };
-export type ClientGrant = {
-    client_id: string;
-    audience: string;
-    scope: string[];
-    subject_type: ClientGrantSubjectTypeEnum;
-    authorization_details_types: string[];
-    is_system?: boolean;
-};
+export type ClientGrant = Management.ClientGrantResponseContent;
 export default class ClientGrantsHandler extends DefaultHandler {
     existing: ClientGrant[] | null;
     constructor(config: DefaultAPIHandler);

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

@@ -38,15 +38,6 @@ 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());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const auth0_1 = require("auth0");
@@ -67,7 +58,7 @@ exports.schema = {
             },
             subject_type: {
                 type: 'string',
-                enum: Object.values(auth0_1.ClientGrantSubjectTypeEnum),
+                enum: Object.values(auth0_1.Management.ClientGrantSubjectTypeEnum),
                 description: 'The subject type for this grant.',
             },
             authorization_details_types: {
@@ -79,82 +70,87 @@ exports.schema = {
                 uniqueItems: true,
             },
         },
-        required: ['client_id', 'scope', 'audience'],
+        required: ['client_id', 'audience'],
     },
 };
 class ClientGrantsHandler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'clientGrants', id: 'id', 
+        super({
+            ...config,
+            type: 'clientGrants',
+            id: 'id',
             // @ts-ignore because not sure why two-dimensional array passed in
-            identifiers: ['id', ['client_id', 'audience']], stripUpdateFields: ['audience', 'client_id', 'subject_type', 'is_system'] }));
+            identifiers: ['id', ['client_id', 'audience']],
+            functions: {
+                update: async ({ id }, bodyParams) => this.client.clientGrants.update(id, bodyParams),
+            },
+            stripUpdateFields: ['audience', 'client_id', 'subject_type', 'is_system'],
+        });
     }
     objString(item) {
         return super.objString({ id: item.id, client_id: item.client_id, audience: item.audience });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            const clientGrants = yield (0, client_1.paginate)(this.client.clientGrants.getAll, {
-                paginate: true,
-                include_totals: true,
-            });
-            this.existing = clientGrants;
-            // Always filter out the client we are using to access Auth0 Management API
-            // As it could cause problems if the grants are deleted or updated etc
-            const currentClient = this.config('AUTH0_CLIENT_ID');
-            this.existing = this.existing.filter((grant) => grant.client_id !== currentClient);
+    async getType() {
+        if (this.existing) {
             return this.existing;
+        }
+        const clientGrants = await (0, client_1.paginate)(this.client.clientGrants.list, {
+            paginate: true,
         });
+        this.existing = clientGrants;
+        // Always filter out the client we are using to access Auth0 Management API
+        // As it could cause problems if the grants are deleted or updated etc
+        const currentClient = this.config('AUTH0_CLIENT_ID');
+        this.existing = this.existing.filter((grant) => grant.client_id !== currentClient);
+        return this.existing;
     }
     // Run after clients are updated so we can convert client_id names to id's
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
+    async processChanges(assets) {
+        const { clientGrants } = assets;
+        // Do nothing if not set
+        if (!clientGrants)
+            return;
+        const clients = await (0, client_1.paginate)(this.client.clients.list, {
+            paginate: true,
+        });
+        const excludedClientsByNames = (assets.exclude && assets.exclude.clients) || [];
+        const excludedClients = (0, utils_1.convertClientNamesToIds)(excludedClientsByNames, clients);
+        // Convert clients by name to the id
+        const formatted = clientGrants.map((clientGrant) => {
+            const grant = { ...clientGrant };
+            const found = clients.find((c) => c.name === grant.client_id);
+            if (found)
+                grant.client_id = found.client_id;
+            return grant;
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { clientGrants } = assets;
-            // Do nothing if not set
-            if (!clientGrants)
-                return;
-            const clients = yield (0, client_1.paginate)(this.client.clients.getAll, {
-                paginate: true,
-                include_totals: true,
-            });
-            const excludedClientsByNames = (assets.exclude && assets.exclude.clients) || [];
-            const excludedClients = (0, utils_1.convertClientNamesToIds)(excludedClientsByNames, clients);
-            // Convert clients by name to the id
-            const formatted = clientGrants.map((clientGrant) => {
-                const grant = Object.assign({}, clientGrant);
-                const found = clients.find((c) => c.name === grant.client_id);
-                if (found)
-                    grant.client_id = found.client_id;
-                return grant;
-            });
-            // Always filter out the client we are using to access Auth0 Management API
-            const currentClient = this.config('AUTH0_CLIENT_ID');
-            const { del, update, create, conflicts } = yield this.calcChanges(Object.assign(Object.assign({}, assets), { clientGrants: formatted }));
-            const filterGrants = (list) => {
-                if (excludedClients.length) {
-                    return list.filter((item) => item.client_id !== currentClient &&
-                        ![...excludedClientsByNames, ...excludedClients].includes(item.client_id));
-                }
-                return list
-                    .filter((item) => item.client_id !== currentClient)
-                    .filter((item) => item.is_system !== true);
-            };
-            const changes = {
-                // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
-                del: filterGrants(del),
-                // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
-                update: filterGrants(update),
-                // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
-                create: filterGrants(create),
-                // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
-                conflicts: filterGrants(conflicts),
-            };
-            yield _super.processChanges.call(this, assets, Object.assign({}, changes));
+        // Always filter out the client we are using to access Auth0 Management API
+        const currentClient = this.config('AUTH0_CLIENT_ID');
+        const { del, update, create, conflicts } = await this.calcChanges({
+            ...assets,
+            clientGrants: formatted,
+        });
+        const filterGrants = (list) => {
+            if (excludedClients.length) {
+                return list.filter((item) => item.client_id !== currentClient &&
+                    item.client_id &&
+                    ![...excludedClientsByNames, ...excludedClients].includes(item.client_id));
+            }
+            return list
+                .filter((item) => item.client_id !== currentClient)
+                .filter((item) => item.is_system !== true);
+        };
+        const changes = {
+            // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
+            del: filterGrants(del),
+            // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
+            update: filterGrants(update),
+            // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
+            create: filterGrants(create),
+            // @ts-ignore because this expects `client_id` and that's not yet typed on Asset
+            conflicts: filterGrants(conflicts),
+        };
+        await super.processChanges(assets, {
+            ...changes,
         });
     }
 }
@@ -162,4 +158,3 @@ exports.default = ClientGrantsHandler;
 __decorate([
     (0, default_1.order)('60')
 ], ClientGrantsHandler.prototype, "processChanges", null);
-//# sourceMappingURL=clientGrants.js.map

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

@@ -1,4 +1,4 @@
-import { ClientClientAuthenticationMethods, ClientExpressConfiguration, ClientOrganizationRequireBehaviorEnum } from 'auth0';
+import { Management } from 'auth0';
 import { Assets, Auth0APIClient } from '../../../types';
 import DefaultAPIHandler from './default';
 export declare const schema: {
@@ -249,26 +249,38 @@ export declare const schema: {
                 };
                 required: string[];
             };
+            token_exchange: {
+                type: string[];
+                description: string;
+                properties: {
+                    allow_any_profile_of_type: {
+                        type: string;
+                        description: string;
+                        items: {
+                            type: string;
+                            enum: string[];
+                        };
+                    };
+                };
+            };
         };
         required: string[];
     };
 };
-export type Client = {
-    client_id: string;
-    name: string;
-    app_type?: string;
-    resource_server_identifier?: string;
-    custom_login_page?: string;
-    custom_login_page_on?: boolean;
-    express_configuration?: ClientExpressConfiguration;
-    client_authentication_methods?: ClientClientAuthenticationMethods | null;
-    organization_require_behavior?: ClientOrganizationRequireBehaviorEnum;
-};
+export type Client = Management.Client;
 export default class ClientHandler extends DefaultAPIHandler {
     existing: Client[];
     constructor(config: DefaultAPIHandler);
     objString(item: any): string;
     processChanges(assets: Assets): Promise<void>;
-    getType(): Promise<Client[]>;
+    /**
+     * @description
+     * Sanitize the deprecated field `cross_origin_auth` to `cross_origin_authentication`
+     *
+     * @param {Client[]} clients - The client array to sanitize.
+     * @returns {Client[]} The sanitized array of clients.
+     */
+    private sanitizeCrossOriginAuth;
+    getType(): Promise<Management.Client[]>;
     sanitizeMapExpressConfiguration(auth0Client: Auth0APIClient, clientList: Client[]): Promise<Client[]>;
 }