auth0-deploy-cli 8.22.0 → 8.23.1

package/lib/tools/auth0/handlers/pages.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 };
 };
@@ -39,96 +30,96 @@ exports.schema = {
 };
 class PagesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'pages', identifiers: ['name'] }));
+        super({
+            ...options,
+            type: 'pages',
+            identifiers: ['name'],
+        });
     }
     objString(page) {
         return super.objString({ name: page.name, enabled: page.enabled });
     }
-    updateLoginPage(page) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const globalClient = yield (0, client_1.paginate)(this.client.clients.getAll, {
-                paginate: true,
-                include_totals: true,
-                is_global: true,
-            });
-            if (!globalClient[0]) {
-                throw new Error('Unable to find global client id when trying to update the login page');
-            }
-            yield this.client.clients.update({ client_id: globalClient[0].client_id }, {
-                custom_login_page: page.html,
-                custom_login_page_on: page.enabled,
-            });
-            this.updated += 1;
-            this.didUpdate(page);
+    async updateLoginPage(page) {
+        const globalClient = await (0, client_1.paginate)(this.client.clients.list, {
+            paginate: true,
+            is_global: true,
         });
+        if (!globalClient[0]) {
+            throw new Error('Unable to find global client id when trying to update the login page');
+        }
+        if (!globalClient[0].client_id) {
+            throw new Error('Unable to find global client id when trying to update the login page');
+        }
+        await this.client.clients.update(globalClient[0].client_id, {
+            custom_login_page: page.html,
+            custom_login_page_on: page.enabled,
+        });
+        this.updated += 1;
+        this.didUpdate(page);
     }
-    updatePages(pages) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const toUpdate = pages.filter((p) => exports.supportedPages.includes(p.name));
-            const update = toUpdate.reduce((accum, page) => {
-                if (exports.supportedPages.includes(page.name)) {
-                    const pageName = exports.pageNameMap[page.name];
-                    if (!pageName) {
-                        throw new Error(`Unable to map page ${page.name} into tenant level page setting`);
-                    }
-                    accum[pageName] = Object.assign({}, page);
-                    delete accum[pageName].name;
+    async updatePages(pages) {
+        const toUpdate = pages.filter((p) => exports.supportedPages.includes(p.name));
+        const update = toUpdate.reduce((accum, page) => {
+            if (exports.supportedPages.includes(page.name)) {
+                const pageName = exports.pageNameMap[page.name];
+                if (!pageName) {
+                    throw new Error(`Unable to map page ${page.name} into tenant level page setting`);
                 }
-                return accum;
-            }, {});
-            if (Object.keys(update).length) {
-                yield this.client.tenants.updateSettings(update);
+                accum[pageName] = { ...page };
+                delete accum[pageName].name;
             }
-            toUpdate.forEach((page) => {
-                this.updated += 1;
-                this.didUpdate(page);
-            });
+            return accum;
+        }, {});
+        if (Object.keys(update).length) {
+            await this.client.tenants.settings.update(update);
+        }
+        toUpdate.forEach((page) => {
+            this.updated += 1;
+            this.didUpdate(page);
         });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pages = [];
-            // Login page is handled via the global client
-            const globalClient = yield (0, client_1.paginate)(this.client.clients.getAll, {
-                paginate: true,
-                include_totals: true,
-                is_global: true,
+    async getType() {
+        const pages = [];
+        // Login page is handled via the global client
+        const globalClient = await (0, client_1.paginate)(this.client.clients.list, {
+            paginate: true,
+            include_totals: true,
+            is_global: true,
+        });
+        if (!globalClient[0]) {
+            throw new Error('Unable to find global client id when trying to dump the login page');
+        }
+        if (globalClient[0].custom_login_page) {
+            pages.push({
+                name: 'login',
+                enabled: !!globalClient[0].custom_login_page_on,
+                html: globalClient[0].custom_login_page,
             });
-            if (!globalClient[0]) {
-                throw new Error('Unable to find global client id when trying to dump the login page');
-            }
-            if (globalClient[0].custom_login_page) {
+        }
+        const tenantSettings = await this.client.tenants.settings.get();
+        Object.entries(exports.pageNameMap).forEach(([key, name]) => {
+            const page = tenantSettings[name];
+            if (tenantSettings[name]) {
                 pages.push({
-                    name: 'login',
-                    enabled: !!globalClient[0].custom_login_page_on,
-                    html: globalClient[0].custom_login_page,
+                    ...page,
+                    name: key,
                 });
             }
-            const { data: tenantSettings } = yield this.client.tenants.getSettings();
-            Object.entries(exports.pageNameMap).forEach(([key, name]) => {
-                const page = tenantSettings[name];
-                if (tenantSettings[name]) {
-                    pages.push(Object.assign(Object.assign({}, page), { name: key }));
-                }
-            });
-            return pages;
         });
+        return pages;
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { pages } = assets;
-            // Do nothing if not set
-            if (!pages)
-                return;
-            // Login page is handled via the global client
-            const loginPage = pages.find((p) => p.name === 'login');
-            if (loginPage !== undefined) {
-                yield this.updateLoginPage(loginPage);
-            }
-            // Rest of pages are on tenant level settings
-            yield this.updatePages(pages.filter((p) => p.name !== 'login'));
-        });
+    async processChanges(assets) {
+        const { pages } = assets;
+        // Do nothing if not set
+        if (!pages)
+            return;
+        // Login page is handled via the global client
+        const loginPage = pages.find((p) => p.name === 'login');
+        if (loginPage !== undefined) {
+            await this.updateLoginPage(loginPage);
+        }
+        // Rest of pages are on tenant level settings
+        await this.updatePages(pages.filter((p) => p.name !== 'login'));
     }
 }
 exports.default = PagesHandler;
-//# sourceMappingURL=pages.js.map

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

@@ -1,4 +1,4 @@
-import { GetBrandingPhoneProviders200ResponseProvidersInner } from 'auth0';
+import { Management } from 'auth0';
 import DefaultHandler from './default';
 import { Assets } from '../../../types';
 export declare const schema: {
@@ -55,7 +55,7 @@ export declare const schema: {
         additionalProperties: boolean;
     };
 };
-export type PhoneProvider = GetBrandingPhoneProviders200ResponseProvidersInner;
+export type PhoneProvider = Management.GetBrandingPhoneProviderResponseContent;
 export default class PhoneProviderHandler extends DefaultHandler {
     existing: PhoneProvider[] | null;
     constructor(options: DefaultHandler);

package/lib/tools/auth0/handlers/phoneProvider.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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -149,91 +140,87 @@ exports.schema = {
 };
 class PhoneProviderHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'phoneProviders', id: 'id' }));
+        super({
+            ...options,
+            type: 'phoneProviders',
+            id: 'id',
+        });
     }
     objString(provider) {
-        return super.objString({ name: provider.name, disabled: provider.disabled }); //Que
+        return super.objString({ name: provider.name, disabled: provider.disabled });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.existing) {
-                this.existing = yield this.getPhoneProviders();
-            }
-            return this.existing;
-        });
+    async getType() {
+        if (!this.existing) {
+            this.existing = await this.getPhoneProviders();
+        }
+        return this.existing;
     }
-    getPhoneProviders() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const { data: response } = yield this.client.branding.getAllPhoneProviders();
-            return (_a = response.providers) !== null && _a !== void 0 ? _a : [];
-        });
+    async getPhoneProviders() {
+        const response = await this.client.branding.phone.providers.list();
+        return response.providers ?? [];
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { phoneProviders } = assets;
-            // Non-existing section means themes doesn't need to be processed
-            if (!phoneProviders)
-                return;
-            // Empty array means themes should be deleted
-            if (phoneProviders.length === 0) {
-                yield this.deletePhoneProviders();
-            }
-            else {
-                yield this.updatePhoneProviders(phoneProviders);
-            }
-        });
+    async processChanges(assets) {
+        const { phoneProviders } = assets;
+        // Non-existing section means themes doesn't need to be processed
+        if (!phoneProviders)
+            return;
+        // Empty array means themes should be deleted
+        if (phoneProviders.length === 0) {
+            await this.deletePhoneProviders();
+        }
+        else {
+            await this.updatePhoneProviders(phoneProviders);
+        }
     }
-    deletePhoneProviders() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (!this.config('AUTH0_ALLOW_DELETE')) {
-                return;
-            }
-            // if phone providers exists we need to delete it
-            const currentProviders = yield this.getPhoneProviders();
-            if (currentProviders === null || currentProviders.length === 0) {
-                return;
-            }
-            const currentProvider = currentProviders[0];
-            yield this.client.branding.deletePhoneProvider({
-                id: currentProvider.id,
-            });
-            this.deleted += 1;
-            this.didDelete(currentProvider);
-        });
+    async deletePhoneProviders() {
+        if (!this.config('AUTH0_ALLOW_DELETE')) {
+            return;
+        }
+        // if phone providers exists we need to delete it
+        const currentProviders = await this.getPhoneProviders();
+        if (currentProviders === null || currentProviders.length === 0) {
+            return;
+        }
+        const currentProvider = currentProviders[0];
+        if (!currentProvider.id) {
+            throw new Error('Unable to find phone provider id when trying to delete');
+        }
+        await this.client.branding.phone.providers.delete(currentProvider.id);
+        this.deleted += 1;
+        this.didDelete(currentProvider);
     }
-    updatePhoneProviders(phoneProviders) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (phoneProviders.length > 1) {
-                logger_1.default.warn('Currently only one phone provider is supported per tenant');
+    async updatePhoneProviders(phoneProviders) {
+        if (phoneProviders.length > 1) {
+            logger_1.default.warn('Currently only one phone provider is supported per tenant');
+        }
+        const currentProviders = await this.getPhoneProviders();
+        const providerReqPayload = (() => {
+            // Removing id from update and create payloads, otherwise API will error
+            // id may be required to handle if `--export_ids=true`
+            const payload = phoneProviders[0];
+            if (payload && 'id' in payload) {
+                delete payload.id;
             }
-            const currentProviders = yield this.getPhoneProviders();
-            const providerReqPayload = (() => {
-                // Removing id from update and create payloads, otherwise API will error
-                // id may be required to handle if `--export_ids=true`
-                const payload = phoneProviders[0];
-                if (payload && 'id' in payload) {
-                    delete payload.id;
-                }
-                return payload;
-            })();
-            if (currentProviders === null || currentProviders.length === 0) {
-                // if provider does not exist, create it
-                this.created += 1;
-                yield this.client.branding.configurePhoneProvider(providerReqPayload);
-            }
-            else {
-                const currentProvider = currentProviders[0];
-                // if provider exists, overwrite it
-                yield this.client.branding.updatePhoneProvider({ id: currentProvider.id }, providerReqPayload);
-                this.updated += 1;
-                this.didUpdate(phoneProviders[0]);
+            return payload;
+        })();
+        if (currentProviders === null || currentProviders.length === 0) {
+            // if provider does not exist, create it
+            this.created += 1;
+            await this.client.branding.phone.providers.create(providerReqPayload);
+        }
+        else {
+            const currentProvider = currentProviders[0];
+            if (!currentProvider.id) {
+                throw new Error('Unable to find phone provider id when trying to delete');
             }
-        });
+            // if provider exists, overwrite it
+            await this.client.branding.phone.providers.update(currentProvider.id, providerReqPayload);
+            this.updated += 1;
+            this.didUpdate(phoneProviders[0]);
+        }
     }
 }
 exports.default = PhoneProviderHandler;
 __decorate([
     (0, default_1.order)('60')
 ], PhoneProviderHandler.prototype, "processChanges", null);
-//# sourceMappingURL=phoneProvider.js.map

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

@@ -0,0 +1,63 @@
+import { Management } from 'auth0';
+import DefaultHandler from './default';
+import { Asset, Assets, CalculatedChanges } from '../../../types';
+export type PhoneTemplate = Management.PhoneTemplate;
+export declare const schema: {
+    type: string;
+    description: string;
+    items: {
+        type: string;
+        properties: {
+            type: {
+                type: string;
+                description: string;
+                enum: string[];
+            };
+            disabled: {
+                type: string;
+                description: string;
+            };
+            content: {
+                type: string;
+                description: string;
+                properties: {
+                    syntax: {
+                        type: string;
+                        description: string;
+                    };
+                    from: {
+                        type: string;
+                        description: string;
+                    };
+                    body: {
+                        type: string;
+                        description: string;
+                        properties: {
+                            text: {
+                                type: string;
+                                description: string;
+                            };
+                            voice: {
+                                type: string;
+                                description: string;
+                            };
+                        };
+                    };
+                };
+            };
+        };
+    };
+};
+export default class PhoneTemplatesHandler extends DefaultHandler {
+    existing: PhoneTemplate[];
+    constructor(options: DefaultHandler);
+    objString(template: any): string;
+    getType(): Promise<PhoneTemplate[]>;
+    processChanges(assets: Assets): Promise<void>;
+    createPhoneTemplate(template: any): Promise<Asset>;
+    createPhoneTemplates(creates: CalculatedChanges['create']): Promise<void>;
+    updatePhoneTemplate(template: any): Promise<Asset>;
+    updatePhoneTemplates(updates: CalculatedChanges['update']): Promise<void>;
+    deletePhoneTemplate(template: any): Promise<void>;
+    deletePhoneTemplates(data: Asset[]): Promise<void>;
+}

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

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+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 default_1 = __importStar(require("./default"));
+const logger_1 = __importDefault(require("../../../logger"));
+exports.schema = {
+    type: 'array',
+    description: 'List of phone notification templates',
+    items: {
+        type: 'object',
+        properties: {
+            type: {
+                type: 'string',
+                description: 'Type of phone notification template',
+                enum: ['otp_verify', 'otp_enroll', 'change_password', 'blocked_account', 'password_breach'],
+            },
+            disabled: {
+                type: 'boolean',
+                description: 'Whether the template is enabled (false) or disabled (true).',
+            },
+            content: {
+                type: 'object',
+                description: 'Content of the phone template',
+                properties: {
+                    syntax: {
+                        type: 'string',
+                        description: 'Syntax used for the template content',
+                    },
+                    from: {
+                        type: 'string',
+                        description: 'Default phone number to be used as "from" when sending a phone notification',
+                    },
+                    body: {
+                        type: 'object',
+                        description: 'Body content of the phone template',
+                        properties: {
+                            text: {
+                                type: 'string',
+                                description: 'Content of the phone template for text notifications',
+                            },
+                            voice: {
+                                type: 'string',
+                                description: 'Content of the phone template for voice notifications',
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+class PhoneTemplatesHandler extends default_1.default {
+    constructor(options) {
+        super({
+            ...options,
+            type: 'phoneTemplates',
+            identifiers: ['type'],
+            stripCreateFields: ['channel', 'customizable', 'tenant'],
+            stripUpdateFields: ['channel', 'customizable', 'tenant', 'type'],
+        });
+    }
+    objString(template) {
+        return super.objString({ type: template.type, disabled: template.disabled });
+    }
+    async getType() {
+        if (this.existing) {
+            return this.existing;
+        }
+        const response = await this.client.branding.phone.templates.list();
+        this.existing = response.templates ?? [];
+        return this.existing;
+    }
+    async processChanges(assets) {
+        const { phoneTemplates } = assets;
+        if (!phoneTemplates)
+            return;
+        const { del, update, create } = await this.calcChanges(assets);
+        logger_1.default.debug(`Start processChanges for phone templates [delete:${del.length}] [update:${update.length}], [create:${create.length}]`);
+        if (del.length > 0) {
+            await this.deletePhoneTemplates(del);
+        }
+        if (create.length > 0) {
+            await this.createPhoneTemplates(create);
+        }
+        if (update.length > 0) {
+            await this.updatePhoneTemplates(update);
+        }
+    }
+    async createPhoneTemplate(template) {
+        const created = await this.client.branding.phone.templates.create(template);
+        return created;
+    }
+    async createPhoneTemplates(creates) {
+        await this.client.pool
+            .addEachTask({
+            data: creates || [],
+            generator: (item) => this.createPhoneTemplate(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 updatePhoneTemplate(template) {
+        const { type } = template;
+        // Find the existing template to get its id
+        const existing = this.existing?.find((t) => t.type === type);
+        if (!existing?.id) {
+            logger_1.default.warn(`Skipping update for phone template type '${type}' as unable to find existing template ID`);
+            return template;
+        }
+        // stripUpdateFields does not support in sub modules
+        const stripUpdateFields = ['content.syntax'];
+        logger_1.default.debug(`Stripping ${this.type} create-only fields ${JSON.stringify(stripUpdateFields)}`);
+        const updatePayload = {
+            content: {
+                from: template.content?.from,
+                body: {
+                    text: template.content?.body?.text,
+                    voice: template.content?.body?.voice,
+                },
+            },
+            disabled: template.disabled,
+        };
+        const updated = await this.client.branding.phone.templates.update(existing.id, updatePayload);
+        return updated;
+    }
+    async updatePhoneTemplates(updates) {
+        await this.client.pool
+            .addEachTask({
+            data: updates || [],
+            generator: (item) => this.updatePhoneTemplate(item)
+                .then((data) => {
+                this.didUpdate(data);
+                this.updated += 1;
+            })
+                .catch((err) => {
+                throw new Error(`Problem updating ${this.type} ${this.objString(item)}\n${err}`);
+            }),
+        })
+            .promise();
+    }
+    async deletePhoneTemplate(template) {
+        if (!template.id) {
+            throw new Error(`Unable to find phone template id for type ${template.type} when trying to delete`);
+        }
+        await this.client.branding.phone.templates.delete(template.id);
+    }
+    async deletePhoneTemplates(data) {
+        if (this.config('AUTH0_ALLOW_DELETE') === 'true' ||
+            this.config('AUTH0_ALLOW_DELETE') === true) {
+            await this.client.pool
+                .addEachTask({
+                data: data || [],
+                generator: (item) => this.deletePhoneTemplate(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 phone templates should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config
+      \n${data.map((i) => this.objString(i)).join('\n')}`);
+        }
+    }
+}
+exports.default = PhoneTemplatesHandler;
+__decorate([
+    (0, default_1.order)('65')
+], PhoneTemplatesHandler.prototype, "processChanges", null);