auth0-deploy-cli 7.10.0 → 7.12.0

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

@@ -5,37 +5,37 @@ declare const _default: {
         excludeSchema?: any;
         schema: any;
     };
-    rulesConfigs: {
+    hooks: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    hooks: {
+    actions: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    pages: {
+    triggers: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    databases: {
+    pages: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    clientGrants: {
+    resourceServers: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    resourceServers: {
+    clients: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    clients: {
+    branding: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
@@ -45,87 +45,97 @@ declare const _default: {
         excludeSchema?: any;
         schema: any;
     };
-    tenant: {
+    roles: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    emailProvider: {
+    prompts: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    emailTemplates: {
+    attackProtection: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    guardianFactors: {
+    clientGrants: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    guardianFactorProviders: {
+    customDomains: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    guardianFactorTemplates: {
+    databases: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    migrations: {
+    emailProvider: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    guardianPhoneFactorMessageTypes: {
+    emailTemplates: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    guardianPhoneFactorSelectedProvider: {
+    guardianFactorProviders: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    guardianPolicies: {
+    guardianFactors: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    roles: {
+    guardianFactorTemplates: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    actions: {
+    guardianPhoneFactorMessageTypes: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    organizations: {
+    guardianPhoneFactorSelectedProvider: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    triggers: {
+    guardianPolicies: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    attackProtection: {
+    logStreams: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    branding: {
+    migrations: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;
     };
-    logStreams: {
+    organizations: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    rulesConfigs: {
+        default: typeof APIHandler;
+        excludeSchema?: any;
+        schema: any;
+    };
+    tenant: {
         default: typeof APIHandler;
         excludeSchema?: any;
         schema: any;

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

@@ -51,6 +51,7 @@ const triggers = __importStar(require("./triggers"));
 const organizations = __importStar(require("./organizations"));
 const attackProtection = __importStar(require("./attackProtection"));
 const logStreams = __importStar(require("./logStreams"));
+const customDomains = __importStar(require("./customDomains"));
 const auth0ApiHandlers = {
     rules,
     rulesConfigs,
@@ -80,5 +81,6 @@ const auth0ApiHandlers = {
     organizations,
     attackProtection,
     logStreams,
+    customDomains,
 };
 exports.default = auth0ApiHandlers; // TODO: apply stronger types to schema properties

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

@@ -1,11 +1,49 @@
 import DefaultHandler from './default';
-import { Asset, Assets } from '../../../types';
+import { Assets, Language } from '../../../types';
+declare const promptScreenTypes: readonly ["login", "login-id", "login-password", "login-email-verification", "signup", "signup-id", "signup-password", "reset-password", "consent", "mfa-push", "mfa-otp", "mfa-voice", "mfa-phone", "mfa-webauthn", "mfa-sms", "mfa-email", "mfa-recovery-code", "mfa", "status", "device-flow", "email-verification", "email-otp-challenge", "organizations", "invitation", "common"];
 export declare const schema: {
     type: string;
+    properties: {
+        universal_login_experience: {
+            type: string;
+            enum: string[];
+        };
+        webauthn_platform_first_factor: {
+            type: string;
+        };
+        identifier_first: {
+            type: string;
+        };
+        customText: {
+            type: string;
+            properties: {};
+        };
+    };
 };
+export declare type PromptScreenTypes = typeof promptScreenTypes[number];
+export declare type PromptSettings = {
+    universal_login_experience?: 'new' | 'classic';
+    webauthn_platform_first_factor?: boolean;
+    identifier_first?: boolean;
+};
+export declare type PromptsCustomText = {
+    [key in PromptScreenTypes]: {
+        [key: string]: string;
+    };
+};
+export declare type Prompts = Partial<PromptSettings & {
+    customText: AllPromptsByLanguage;
+}>;
+export declare type AllPromptsByLanguage = Partial<{
+    [key in Language]: Partial<PromptsCustomText>;
+}>;
 export default class PromptsHandler extends DefaultHandler {
-    existing: Asset[];
+    existing: Prompts;
     constructor(options: DefaultHandler);
-    getType(): Promise<Asset[]>;
+    objString({ customText }: Prompts): string;
+    getType(): Promise<Prompts | null>;
+    getCustomTextSettings(): Promise<AllPromptsByLanguage>;
     processChanges(assets: Assets): Promise<void>;
+    updateCustomTextSettings(customText: Prompts['customText']): Promise<void>;
 }
+export {};

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

@@ -8,46 +8,166 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         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 };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
-//@ts-nocheck because prompts haven't been fully implemented in this codebase yet
 const default_1 = __importDefault(require("./default"));
-exports.schema = { type: 'object' };
+const types_1 = require("../../../types");
+const lodash_1 = require("lodash");
+const promptScreenTypes = [
+    'login',
+    'login-id',
+    'login-password',
+    'login-email-verification',
+    'signup',
+    'signup-id',
+    'signup-password',
+    'reset-password',
+    'consent',
+    'mfa-push',
+    'mfa-otp',
+    'mfa-voice',
+    'mfa-phone',
+    'mfa-webauthn',
+    'mfa-sms',
+    'mfa-email',
+    'mfa-recovery-code',
+    'mfa',
+    'status',
+    'device-flow',
+    'email-verification',
+    'email-otp-challenge',
+    'organizations',
+    'invitation',
+    'common',
+];
+exports.schema = {
+    type: 'object',
+    properties: {
+        universal_login_experience: {
+            type: 'string',
+            enum: ['new', 'classic'],
+        },
+        webauthn_platform_first_factor: {
+            type: 'boolean',
+        },
+        identifier_first: {
+            type: 'boolean',
+        },
+        customText: {
+            type: 'object',
+            properties: types_1.languages.reduce((acc, language) => {
+                return Object.assign(Object.assign({}, acc), { [language]: {
+                        type: 'object',
+                        properties: promptScreenTypes.reduce((acc, screenType) => {
+                            return Object.assign(Object.assign({}, acc), { [screenType]: {
+                                    type: 'object',
+                                } });
+                        }, {}),
+                    } });
+            }, {}),
+        },
+    },
+};
 class PromptsHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'prompts' }));
     }
+    objString({ customText }) {
+        return `Prompts settings${!!customText ? ' and prompts custom text' : ''}`;
+    }
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
-            // in case client version does not support branding
-            if (!this.client.prompts || typeof this.client.prompts.getSettings !== 'function') {
-                return {};
-            }
-            try {
-                return yield this.client.prompts.getSettings();
-            }
-            catch (err) {
-                if (err.statusCode === 404)
-                    return {};
-                if (err.statusCode === 501)
-                    return {};
-                throw err;
-            }
+            const promptsSettings = yield this.client.prompts.getSettings();
+            const customText = yield this.getCustomTextSettings();
+            return Object.assign(Object.assign({}, promptsSettings), { customText });
+        });
+    }
+    getCustomTextSettings() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const supportedLanguages = yield this.client.tenant
+                .getSettings()
+                .then(({ enabled_locales }) => enabled_locales);
+            const data = yield Promise.all(supportedLanguages.flatMap((language) => {
+                return promptScreenTypes.map((screenType) => {
+                    return this.client.prompts
+                        .getCustomTextByLanguage({
+                        prompt: screenType,
+                        language,
+                    })
+                        .then((customTextData) => {
+                        if ((0, lodash_1.isEmpty)(customTextData))
+                            return null;
+                        return Object.assign({ language }, customTextData);
+                    });
+                });
+            })).then((customTextData) => {
+                return customTextData
+                    .filter((customTextData) => {
+                    return customTextData !== null;
+                })
+                    .reduce((acc, customTextItem) => {
+                    if ((customTextItem === null || customTextItem === void 0 ? void 0 : customTextItem.language) === undefined)
+                        return acc;
+                    const { language } = customTextItem, customTextSettings = __rest(customTextItem, ["language"]);
+                    return Object.assign(Object.assign({}, acc), { [language]: !!acc[language]
+                            ? Object.assign(Object.assign({}, acc[language]), customTextSettings) : Object.assign({}, customTextSettings) });
+                }, {});
+            });
+            return data;
         });
     }
     processChanges(assets) {
         return __awaiter(this, void 0, void 0, function* () {
             const { prompts } = assets;
-            // Do nothing if not set
-            if (!prompts || !Object.keys(prompts).length)
+            if (!prompts)
                 return;
-            yield this.client.prompts.updateSettings({}, prompts);
+            const { customText } = prompts, promptSettings = __rest(prompts, ["customText"]);
+            if (!(0, lodash_1.isEmpty)(promptSettings)) {
+                yield this.client.prompts.updateSettings({}, promptSettings);
+            }
+            yield this.updateCustomTextSettings(customText);
             this.updated += 1;
             this.didUpdate(prompts);
         });
     }
+    updateCustomTextSettings(customText) {
+        return __awaiter(this, void 0, void 0, function* () {
+            /*
+              Note: deletes are not currently supported
+            */
+            if (!customText)
+                return;
+            yield Promise.all(Object.keys(customText).flatMap((language) => {
+                const languageScreenTypes = customText[language];
+                if (!languageScreenTypes)
+                    return [];
+                return Object.keys(languageScreenTypes).map((prompt) => {
+                    const body = languageScreenTypes[prompt];
+                    return this.client.prompts.updateCustomTextByLanguage({
+                        prompt,
+                        language,
+                        //@ts-ignore
+                        body: {
+                            [prompt]: languageScreenTypes[prompt],
+                        } || {},
+                    });
+                });
+            }));
+        });
+    }
 }
 exports.default = PromptsHandler;

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

@@ -175,8 +175,8 @@ class RulesHandler extends default_1.default {
             yield this.client.pool
                 .addEachTask({
                 data: changes.reOrder,
-                generator: (rule) => this.client
-                    .updateRule({ id: rule.id }, (0, utils_1.stripFields)(rule, this.stripUpdateFields))
+                generator: (rule) => this.client.rules
+                    .update({ id: rule.id }, (0, utils_1.stripFields)(rule, this.stripUpdateFields))
                     .then(() => {
                     const updated = {
                         name: rule.name,

package/lib/tools/auth0/index.js

@@ -62,8 +62,11 @@ class Auth0 {
     }
     validate() {
         return __awaiter(this, void 0, void 0, function* () {
-            const ajv = new ajv_1.default({ useDefaults: true });
-            const valid = ajv.validate(schema_1.default, this.assets);
+            const ajv = new ajv_1.default({ useDefaults: true, nullable: true });
+            const nonNullAssets = Object.keys(this.assets)
+                .filter((k) => this.assets[k] != null)
+                .reduce((a, k) => (Object.assign(Object.assign({}, a), { [k]: this.assets[k] })), {});
+            const valid = ajv.validate(schema_1.default, nonNullAssets);
             if (!valid) {
                 throw new Error(`Schema validation failed loading ${JSON.stringify(ajv.errors, null, 4)}`);
             }

package/lib/tools/constants.d.ts

@@ -68,5 +68,7 @@ declare const constants: {
     EMAIL_TEMPLATES_NAMES: string[];
     SUPPORTED_BRANDING_TEMPLATES: string[];
     LOG_STREAMS_DIRECTORY: string;
+    PROMPTS_DIRECTORY: string;
+    CUSTOM_DOMAINS_DIRECTORY: string;
 };
 export default constants;

package/lib/tools/constants.js

@@ -165,5 +165,7 @@ const constants = {
     ],
     SUPPORTED_BRANDING_TEMPLATES: [UNIVERSAL_LOGIN_TEMPLATE],
     LOG_STREAMS_DIRECTORY: 'log-streams',
+    PROMPTS_DIRECTORY: 'prompts',
+    CUSTOM_DOMAINS_DIRECTORY: 'custom-domains',
 };
 exports.default = constants;

package/lib/tools/index.d.ts

@@ -73,6 +73,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 deploy;
     keywordReplace: typeof keywordReplace;

package/lib/tools/utils.d.ts

@@ -16,3 +16,12 @@ export declare function filterExcluded(changes: CalculatedChanges, exclude: stri
 export declare function areArraysEquals(x: any[], y: any[]): boolean;
 export declare const obfuscateSensitiveValues: (data: Asset | Asset[] | null, sensitiveFieldsToObfuscate: string[]) => Asset | Asset[] | null;
 export declare const stripObfuscatedFieldsFromPayload: (data: Asset | Asset[] | null, obfuscatedFields: string[]) => Asset | Asset[] | null;
+export declare const detectInsufficientScopeError: <T>(fn: Function) => Promise<{
+    hadSufficientScopes: true;
+    data: T;
+    requiredScopes: [];
+} | {
+    hadSufficientScopes: false;
+    requiredScopes: string[];
+    data: null;
+}>;

package/lib/tools/utils.js

@@ -22,11 +22,20 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     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.stripObfuscatedFieldsFromPayload = exports.obfuscateSensitiveValues = exports.areArraysEquals = exports.filterExcluded = exports.duplicateItems = exports.getEnabledClients = exports.stripFields = exports.convertJsonToString = exports.flatten = exports.loadFileAndReplaceKeywords = exports.convertClientNamesToIds = exports.convertClientNameToId = exports.keywordReplace = exports.keywordStringReplace = exports.keywordArrayReplace = void 0;
+exports.detectInsufficientScopeError = exports.stripObfuscatedFieldsFromPayload = exports.obfuscateSensitiveValues = exports.areArraysEquals = exports.filterExcluded = exports.duplicateItems = exports.getEnabledClients = exports.stripFields = exports.convertJsonToString = exports.flatten = exports.loadFileAndReplaceKeywords = exports.convertClientNamesToIds = exports.convertClientNameToId = exports.keywordReplace = exports.keywordStringReplace = exports.keywordArrayReplace = void 0;
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importStar(require("fs"));
 const dot_prop_1 = __importDefault(require("dot-prop"));
@@ -208,3 +217,26 @@ const stripObfuscatedFieldsFromPayload = (data, obfuscatedFields) => {
     return newAsset;
 };
 exports.stripObfuscatedFieldsFromPayload = stripObfuscatedFieldsFromPayload;
+const detectInsufficientScopeError = (fn) => __awaiter(void 0, void 0, void 0, function* () {
+    var _a, _b;
+    try {
+        const data = yield fn();
+        return {
+            hadSufficientScopes: true,
+            data,
+            requiredScopes: [],
+        };
+    }
+    catch (err) {
+        if (err.statusCode === 403 && err.message.includes('Insufficient scope')) {
+            const requiredScopes = (_b = (_a = err.message) === null || _a === void 0 ? void 0 : _a.split('Insufficient scope, expected any of: ')) === null || _b === void 0 ? void 0 : _b.slice(1);
+            return {
+                hadSufficientScopes: false,
+                requiredScopes,
+                data: null,
+            };
+        }
+        throw err;
+    }
+});
+exports.detectInsufficientScopeError = detectInsufficientScopeError;