auth0-deploy-cli 7.10.0 → 7.12.0

package/lib/context/yaml/handlers/pages.js

@@ -18,33 +18,35 @@ const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the HTML file for each page
-        if (!context.assets.pages)
-            return {};
+        const { pages } = context.assets;
+        if (!pages)
+            return { pages: null };
         return {
             pages: [
-                ...context.assets.pages.map((page) => (Object.assign(Object.assign({}, page), { html: page.html ? context.loadFile(page.html) : '' }))),
+                ...pages.map((page) => (Object.assign(Object.assign({}, page), { html: page.html ? context.loadFile(page.html) : '' }))),
             ],
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        let pages = [...(context.assets.pages || [])];
-        if (pages.length > 0) {
-            // Create Pages folder
-            const pagesFolder = path_1.default.join(context.basePath, 'pages');
-            fs_extra_1.default.ensureDirSync(pagesFolder);
-            pages = pages.map((page) => {
-                if (page.name === 'error_page' && page.html === undefined) {
-                    return page;
-                }
-                // Dump html to file
-                const htmlFile = path_1.default.join(pagesFolder, `${page.name}.html`);
-                logger_1.default.info(`Writing ${htmlFile}`);
-                fs_extra_1.default.writeFileSync(htmlFile, page.html);
-                return Object.assign(Object.assign({}, page), { html: `./pages/${page.name}.html` });
-            });
+        let pages = context.assets.pages;
+        if (!pages) {
+            return { pages: null };
         }
+        // Create Pages folder
+        const pagesFolder = path_1.default.join(context.basePath, 'pages');
+        fs_extra_1.default.ensureDirSync(pagesFolder);
+        pages = pages.map((page) => {
+            if (page.name === 'error_page' && page.html === undefined) {
+                return page;
+            }
+            // Dump html to file
+            const htmlFile = path_1.default.join(pagesFolder, `${page.name}.html`);
+            logger_1.default.info(`Writing ${htmlFile}`);
+            fs_extra_1.default.writeFileSync(htmlFile, page.html);
+            return Object.assign(Object.assign({}, page), { html: `./pages/${page.name}.html` });
+        });
         return { pages };
     });
 }

package/lib/context/yaml/handlers/prompts.d.ts

@@ -0,0 +1,6 @@
+import { YAMLHandler } from '.';
+import { ParsedAsset } from '../../../types';
+import { Prompts } from '../../../tools/auth0/handlers/prompts';
+declare type ParsedPrompts = ParsedAsset<'prompts', Prompts>;
+declare const promptsHandler: YAMLHandler<ParsedPrompts>;
+export default promptsHandler;

package/lib/context/yaml/handlers/prompts.js

@@ -0,0 +1,26 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseAndDump(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompts } = context.assets;
+        if (!prompts)
+            return { prompts: null };
+        return {
+            prompts,
+        };
+    });
+}
+const promptsHandler = {
+    parse: parseAndDump,
+    dump: parseAndDump,
+};
+exports.default = promptsHandler;

package/lib/context/yaml/handlers/resourceServers.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedResourceServers = {
-    resourceServers: unknown[];
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedResourceServers = ParsedAsset<'resourceServers', Asset[]>;
 declare const resourceServersHandler: YAMLHandler<ParsedResourceServers>;
 export default resourceServersHandler;

package/lib/context/yaml/handlers/resourceServers.js

@@ -9,24 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-function parse(context) {
+function dumpAndParse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default if empty
+        const { resourceServers } = context.assets;
+        if (!resourceServers) {
+            return { resourceServers: null };
+        }
         return {
-            resourceServers: context.assets.resourceServers,
-        };
-    });
-}
-function dump(context) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default if empty
-        return {
-            resourceServers: [...(context.assets.resourceServers || [])],
+            resourceServers,
         };
     });
 }
 const resourceServersHandler = {
-    parse,
-    dump,
+    parse: dumpAndParse,
+    dump: dumpAndParse,
 };
 exports.default = resourceServersHandler;

package/lib/context/yaml/handlers/roles.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedRoles = {
-    roles: unknown[];
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedRoles = ParsedAsset<'roles', Asset[]>;
 declare const rolesHandler: YAMLHandler<ParsedRoles>;
 export default rolesHandler;

package/lib/context/yaml/handlers/roles.js

@@ -11,24 +11,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default empty
+        const { roles } = context.assets;
+        if (!roles)
+            return { roles: null };
         return {
-            roles: context.assets.roles,
+            roles,
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // remove empty descriptions
+        const { roles } = context.assets;
+        if (!roles)
+            return { roles: null };
         return {
-            roles: [
-                ...(context.assets.roles || []).map((role) => {
-                    if (role.description === null) {
-                        delete role.description;
-                    }
-                    return role;
-                }),
-            ],
+            roles: roles.map((role) => {
+                if (role.description === null) {
+                    delete role.description;
+                }
+                return role;
+            }),
         };
     });
 }

package/lib/context/yaml/handlers/rules.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedRules = {
-    rules: unknown[];
-} | {};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedRules = ParsedAsset<'rules', Asset[]>;
 declare const rulesHandler: YAMLHandler<ParsedRules>;
 export default rulesHandler;

package/lib/context/yaml/handlers/rules.js

@@ -18,32 +18,33 @@ const utils_1 = require("../../../utils");
 const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Load the script file for each rule
-        if (!context.assets.rules)
-            return {};
+        const { rules } = context.assets;
+        if (!rules)
+            return { rules: null };
         return {
             rules: [
-                ...context.assets.rules.map((rule) => (Object.assign(Object.assign({}, rule), { script: context.loadFile(rule.script) }))),
+                ...rules.map((rule) => (Object.assign(Object.assign({}, rule), { script: context.loadFile(rule.script) }))),
             ],
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        let rules = [...(context.assets.rules || [])];
-        if (rules.length > 0) {
-            // Create Rules folder
-            const rulesFolder = path_1.default.join(context.basePath, 'rules');
-            fs_extra_1.default.ensureDirSync(rulesFolder);
-            rules = rules.map((rule) => {
-                // Dump rule to file
-                const scriptName = (0, utils_1.sanitize)(`${rule.name}.js`);
-                const scriptFile = path_1.default.join(rulesFolder, scriptName);
-                logger_1.default.info(`Writing ${scriptFile}`);
-                fs_extra_1.default.writeFileSync(scriptFile, rule.script);
-                return Object.assign(Object.assign({}, rule), { script: `./rules/${scriptName}` });
-            });
+        let { rules } = context.assets;
+        if (!rules) {
+            return { rules: null };
         }
+        // Create Rules folder
+        const rulesFolder = path_1.default.join(context.basePath, 'rules');
+        fs_extra_1.default.ensureDirSync(rulesFolder);
+        rules = rules.map((rule) => {
+            // Dump rule to file
+            const scriptName = (0, utils_1.sanitize)(`${rule.name}.js`);
+            const scriptFile = path_1.default.join(rulesFolder, scriptName);
+            logger_1.default.info(`Writing ${scriptFile}`);
+            fs_extra_1.default.writeFileSync(scriptFile, rule.script);
+            return Object.assign(Object.assign({}, rule), { script: `./rules/${scriptName}` });
+        });
         return { rules };
     });
 }

package/lib/context/yaml/handlers/rulesConfigs.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedRulesConfigs = {
-    rulesConfigs: unknown[];
-} | {};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedRulesConfigs = ParsedAsset<'rulesConfigs', Asset[]>;
 declare const rulesConfigsHandler: YAMLHandler<ParsedRulesConfigs>;
 export default rulesConfigsHandler;

package/lib/context/yaml/handlers/rulesConfigs.js

@@ -11,17 +11,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default if empty
+        const { rulesConfigs } = context.assets;
+        if (!rulesConfigs)
+            return { rulesConfigs: null };
         return {
-            rulesConfigs: context.assets.rulesConfigs,
+            rulesConfigs,
         };
     });
 }
-function dump(_context) {
+function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // do not export rulesConfigs as its values cannot be extracted
+        const { rulesConfigs } = context.assets;
+        if (!rulesConfigs)
+            return { rulesConfigs: null };
         return {
-            rulesConfigs: [],
+            rulesConfigs: [], // even if they exist, do not export rulesConfigs as its values cannot be extracted
         };
     });
 }

package/lib/context/yaml/handlers/tenant.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedTenant = {
-    tenant: unknown[];
-} | {};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedTenant = ParsedAsset<'tenant', Asset>;
 declare const tenantHandler: YAMLHandler<ParsedTenant>;
 export default tenantHandler;

package/lib/context/yaml/handlers/tenant.js

@@ -24,9 +24,8 @@ const utils_1 = require("../../../utils");
 const sessionDurationsToMinutes_1 = require("../../../sessionDurationsToMinutes");
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Nothing to do
         if (!context.assets.tenant)
-            return {};
+            return { tenant: null };
         /* eslint-disable camelcase */
         const _a = context.assets.tenant, { session_lifetime, idle_session_lifetime } = _a, tenant = __rest(_a, ["session_lifetime", "idle_session_lifetime"]);
         (0, utils_1.clearTenantFlags)(tenant);
@@ -38,7 +37,9 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const tenant = Object.assign({}, (context.assets.tenant || {}));
+        const tenant = context.assets.tenant;
+        if (!tenant)
+            return { tenant: null };
         (0, utils_1.clearTenantFlags)(tenant);
         return { tenant };
     });

package/lib/context/yaml/handlers/triggers.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedTriggers = {
-    triggers: unknown[];
-} | {};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedTriggers = ParsedAsset<'triggers', Asset[]>;
 declare const triggersHandler: YAMLHandler<ParsedTriggers>;
 export default triggersHandler;

package/lib/context/yaml/handlers/triggers.js

@@ -13,7 +13,7 @@ function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the script file for each action
         if (!context.assets.triggers)
-            return {};
+            return { triggers: null };
         return {
             triggers: context.assets.triggers,
         };
@@ -24,7 +24,7 @@ function dump(context) {
         const { triggers } = context.assets;
         // Nothing to do
         if (!triggers)
-            return {};
+            return { triggers: null };
         return {
             triggers: triggers,
         };

package/lib/context/yaml/index.js

@@ -111,7 +111,8 @@ class YAMLContext {
                 try {
                     const data = yield handler.dump(this);
                     if (data) {
-                        logger_1.default.info(`Exporting ${name}`);
+                        if (data[name] !== null)
+                            logger_1.default.info(`Exporting ${name}`);
                         Object.entries(data).forEach(([k, v]) => {
                             this.assets[k] = Array.isArray(v)
                                 ? v.map(utils_1.formatResults).sort(utils_1.recordsSorter)

package/lib/index.d.ts

@@ -77,6 +77,8 @@ declare const _default: {
             EMAIL_TEMPLATES_NAMES: string[];
             SUPPORTED_BRANDING_TEMPLATES: string[];
             LOG_STREAMS_DIRECTORY: string;
+            PROMPTS_DIRECTORY: string;
+            CUSTOM_DOMAINS_DIRECTORY: string;
         };
         deploy: typeof import("./tools").deploy;
         keywordReplace: typeof import("./tools").keywordReplace;

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

@@ -46,7 +46,7 @@ const lodash_1 = __importDefault(require("lodash"));
 const default_1 = __importStar(require("./default"));
 const logger_1 = __importDefault(require("../../../logger"));
 const utils_1 = require("../../utils");
-const MAX_ACTION_DEPLOY_RETRY = 60;
+const MAX_ACTION_DEPLOY_RETRY_ATTEMPTS = 60; // 60 * 2s => 2 min timeout
 // With this schema, we can only validate property types but not valid properties on per type basis
 exports.schema = {
     type: 'array',
@@ -162,10 +162,10 @@ class ActionHandler extends default_1.default {
                         logger_1.default.info(`[${this.type}]: Waiting for build to complete ${this.objString(action)}`);
                         action.retry_count = 1;
                     }
-                    if (action.retry_count > MAX_ACTION_DEPLOY_RETRY) {
+                    if (action.retry_count > MAX_ACTION_DEPLOY_RETRY_ATTEMPTS) {
                         throw err;
                     }
-                    yield sleep(1000);
+                    yield sleep(2000);
                     action.retry_count += 1;
                     yield this.deployAction(action);
                 }
@@ -211,12 +211,12 @@ class ActionHandler extends default_1.default {
                 return this.existing;
             }
             catch (err) {
-                if (err.statusCode === 403 || err.statusCode === 404 || err.statusCode === 501) {
-                    return [];
+                if (err.statusCode === 404 || err.statusCode === 501) {
+                    return null;
                 }
                 if (isActionsDisabled(err)) {
                     logger_1.default.info('Skipping actions because it is not enabled.');
-                    return [];
+                    return null;
                 }
                 throw err;
             }
@@ -233,9 +233,25 @@ class ActionHandler extends default_1.default {
                 return;
             const changes = yield this.calcChanges(assets);
             yield _super.processChanges.call(this, assets, changes);
+            const postProcessedActions = yield (() => __awaiter(this, void 0, void 0, function* () {
+                this.existing = null; //Clear the cache
+                const actions = yield this.getType();
+                return actions;
+            }))();
             // Deploy actions
             const deployActions = [
-                ...changes.create.filter((action) => action.deployed),
+                ...changes.create
+                    .filter((action) => action.deployed)
+                    .map((actionWithoutId) => {
+                    var _a;
+                    // Add IDs to just-created actions
+                    const actionId = (_a = postProcessedActions === null || postProcessedActions === void 0 ? void 0 : postProcessedActions.find((postProcessedAction) => {
+                        return postProcessedAction.name === actionWithoutId.name;
+                    })) === null || _a === void 0 ? void 0 : _a.id;
+                    const actionWithId = Object.assign(Object.assign({}, actionWithoutId), { id: actionId });
+                    return actionWithId;
+                })
+                    .filter((action) => !!action.id),
                 ...changes.update.filter((action) => action.deployed),
             ];
             yield this.deployActions(deployActions);

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

@@ -1,5 +1,5 @@
 import DefaultHandler from './default';
-import { Asset } from '../../../types';
+import { Asset, Assets } from '../../../types';
 export declare const schema: {
     type: string;
     properties: {
@@ -23,5 +23,5 @@ export default class BrandingHandler extends DefaultHandler {
     existing: Asset;
     constructor(options: DefaultHandler);
     getType(): Promise<Asset>;
-    processChanges(assets: any): Promise<void>;
+    processChanges(assets: Assets): Promise<void>;
 }

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

@@ -93,7 +93,7 @@ class ClientGrantsHandler extends default_1.default {
             const excludedClientsByNames = (assets.exclude && assets.exclude.clients) || [];
             const excludedClients = (0, utils_1.convertClientNamesToIds)(excludedClientsByNames, clients);
             // Convert clients by name to the id
-            const formatted = assets.clientGrants.map((clientGrant) => {
+            const formatted = clientGrants.map((clientGrant) => {
                 const grant = Object.assign({}, clientGrant);
                 const found = clients.find((c) => c.name === grant.client_id);
                 if (found)

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

@@ -145,7 +145,7 @@ class ConnectionsHandler extends default_1.default {
                 paginate: true,
                 include_totals: true,
             });
-            const formatted = assets.connections.map((connection) => (Object.assign(Object.assign(Object.assign({}, connection), this.getFormattedOptions(connection, clients)), { enabled_clients: (0, utils_1.getEnabledClients)(assets, connection, existingConnections, clients) })));
+            const formatted = connections.map((connection) => (Object.assign(Object.assign(Object.assign({}, connection), this.getFormattedOptions(connection, clients)), { enabled_clients: (0, utils_1.getEnabledClients)(assets, connection, existingConnections, clients) })));
             const proposedChanges = yield _super.calcChanges.call(this, Object.assign(Object.assign({}, assets), { connections: formatted }));
             const proposedChangesWithExcludedProperties = (0, exports.addExcludedConnectionPropertiesToChanges)({
                 proposedChanges,

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

@@ -0,0 +1,43 @@
+import DefaultAPIHandler from './default';
+import { Asset, Assets } from '../../../types';
+export declare const schema: {
+    type: string;
+    items: {
+        type: string;
+        properties: {
+            custom_domain_id: {
+                type: string;
+            };
+            custom_client_ip_header: {
+                type: string;
+                nullable: boolean;
+                enum: (string | null)[];
+            };
+            domain: {
+                type: string;
+            };
+            primary: {
+                type: string;
+            };
+            status: {
+                type: string;
+                enum: string[];
+            };
+            type: {
+                type: string;
+                enum: string[];
+            };
+            verification: {
+                type: string;
+            };
+        };
+        required: string[];
+    };
+};
+export default class CustomDomainsHadnler extends DefaultAPIHandler {
+    existing: Asset[] | null;
+    constructor(config: DefaultAPIHandler);
+    objString(item: Asset): string;
+    getType(): Promise<Asset>;
+    processChanges(assets: Assets): Promise<void>;
+}

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

@@ -0,0 +1,85 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = void 0;
+const default_1 = __importDefault(require("./default"));
+exports.schema = {
+    type: 'array',
+    items: {
+        type: 'object',
+        properties: {
+            custom_domain_id: { type: 'string' },
+            custom_client_ip_header: {
+                type: 'string',
+                nullable: true,
+                enum: ['true-client-ip', 'cf-connecting-ip', 'x-forwarded-for', null],
+            },
+            domain: { type: 'string' },
+            primary: { type: 'boolean' },
+            status: { type: 'string', enum: ['pending_verification', 'ready', 'disabled', 'pending'] },
+            type: { type: 'string', enum: ['auth0_managed_certs', 'self_managed_certs'] },
+            verification: { type: 'object' },
+        },
+        required: ['domain', 'type'],
+    },
+};
+class CustomDomainsHadnler extends default_1.default {
+    constructor(config) {
+        super(Object.assign(Object.assign({}, config), { type: 'customDomains', id: 'custom_domain_id', identifiers: ['domain'], stripCreateFields: ['status', 'primary', 'verification'], functions: {
+                //@ts-ignore
+                delete: (args) => {
+                    return this.client.customDomains.delete({ id: args.custom_domain_id });
+                },
+            } }));
+    }
+    objString(item) {
+        return super.objString(item.domain);
+    }
+    getType() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.existing) {
+                return this.existing;
+            }
+            const customDomains = yield this.client.customDomains.getAll({ paginate: false });
+            this.existing = customDomains;
+            return customDomains;
+        });
+    }
+    processChanges(assets) {
+        const _super = Object.create(null, {
+            processChanges: { get: () => super.processChanges }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            const { customDomains } = assets;
+            if (!customDomains)
+                return;
+            const changes = yield this.calcChanges(assets).then((changes) => {
+                const changesWithoutUpdates = Object.assign(Object.assign({}, changes), { create: changes.create.map((customDomainToCreate) => {
+                        const newCustomDomain = Object.assign({}, customDomainToCreate);
+                        if (customDomainToCreate.custom_client_ip_header === null) {
+                            delete newCustomDomain.custom_client_ip_header;
+                        }
+                        return newCustomDomain;
+                    }), delete: changes.del.map((deleteToMake) => {
+                        const deleteWithSDKCompatibleID = Object.assign(Object.assign({}, deleteToMake), { id: deleteToMake.custom_domain_id });
+                        delete deleteWithSDKCompatibleID['custom_domain_id'];
+                        return deleteWithSDKCompatibleID;
+                    }), update: [] });
+                return changesWithoutUpdates;
+            });
+            yield _super.processChanges.call(this, assets, changes);
+        });
+    }
+}
+exports.default = CustomDomainsHadnler;

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

@@ -69,8 +69,15 @@ class APIHandler {
     load() {
         return __awaiter(this, void 0, void 0, function* () {
             // Load Asset from Tenant
-            logger_1.default.info(`Retrieving ${this.type} data from Auth0`);
-            const data = yield this.getType();
+            const data = yield (() => __awaiter(this, void 0, void 0, function* () {
+                const { data, hadSufficientScopes, requiredScopes } = yield (0, utils_1.detectInsufficientScopeError)(this.getType.bind(this));
+                if (!hadSufficientScopes) {
+                    logger_1.default.warn(`Cannot retrieve ${this.type} due to missing scopes: ${requiredScopes}`);
+                    return null;
+                }
+                logger_1.default.info(`Retrieving ${this.type} data from Auth0`);
+                return data;
+            }))();
             this.existing = (0, utils_1.obfuscateSensitiveValues)(data, this.sensitiveFieldsToObfuscate);
             return { [this.type]: this.existing };
         });