auth0-deploy-cli 7.11.1 → 7.12.0

package/CHANGELOG.md

@@ -7,6 +7,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [7.12.0] - 2022-05-10
+
+### Added
+
+- Prompts support (both prompts settings and custom text for prompts) [#530]
+- Custom domains support [#527]
+
 ## [7.11.1] - 2022-05-04
 
 ### Fixed
@@ -723,7 +730,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 [#517]: https://github.com/auth0/auth0-deploy-cli/issues/517
 [#524]: https://github.com/auth0/auth0-deploy-cli/issues/524
 [#526]: https://github.com/auth0/auth0-deploy-cli/issues/526
-[unreleased]: https://github.com/auth0/auth0-deploy-cli/compare/v7.11.1...HEAD
+[#527]: https://github.com/auth0/auth0-deploy-cli/issues/527
+[#530]: https://github.com/auth0/auth0-deploy-cli/issues/530
+[unreleased]: https://github.com/auth0/auth0-deploy-cli/compare/v7.12.0...HEAD
+[7.12.0]: https://github.com/auth0/auth0-deploy-cli/compare/v7.11.1...v7.12.0
 [7.11.1]: https://github.com/auth0/auth0-deploy-cli/compare/v7.11.0...v7.11.1
 [7.11.0]: https://github.com/auth0/auth0-deploy-cli/compare/v7.10.0...v7.11.0
 [7.10.0]: https://github.com/auth0/auth0-deploy-cli/compare/v7.9.0...v7.10.0

package/lib/context/directory/handlers/customDomains.d.ts

@@ -0,0 +1,5 @@
+import { DirectoryHandler } from '.';
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedCustomDomains = ParsedAsset<'customDomains', Asset[]>;
+declare const customDomainsHandler: DirectoryHandler<ParsedCustomDomains>;
+export default customDomainsHandler;

package/lib/context/directory/handlers/customDomains.js

@@ -0,0 +1,46 @@
+"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 });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const tools_1 = require("../../../tools");
+const utils_1 = require("../../../utils");
+const getCustomDomainsDirectory = (filePath) => path_1.default.join(filePath, tools_1.constants.CUSTOM_DOMAINS_DIRECTORY);
+const getCustomDomainsFile = (filePath) => path_1.default.join(getCustomDomainsDirectory(filePath), 'custom-domains.json');
+function parse(context) {
+    const customDomainsDirectory = getCustomDomainsDirectory(context.filePath);
+    if (!(0, utils_1.existsMustBeDir)(customDomainsDirectory))
+        return { customDomains: null }; // Skip
+    const customDomainsFile = getCustomDomainsFile(context.filePath);
+    return {
+        customDomains: (0, utils_1.loadJSON)(customDomainsFile, context.mappings),
+    };
+}
+function dump(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { customDomains } = context.assets;
+        if (!customDomains)
+            return; // Skip, nothing to dump
+        // Create Rules folder
+        const customDomainsDirectory = getCustomDomainsDirectory(context.filePath);
+        fs_extra_1.default.ensureDirSync(customDomainsDirectory);
+        const customDomainsFile = getCustomDomainsFile(context.filePath);
+        (0, utils_1.dumpJSON)(customDomainsFile, customDomains);
+    });
+}
+const customDomainsHandler = {
+    parse,
+    dump,
+};
+exports.default = customDomainsHandler;

package/lib/context/directory/handlers/index.js

@@ -29,6 +29,8 @@ const triggers_1 = __importDefault(require("./triggers"));
 const attackProtection_1 = __importDefault(require("./attackProtection"));
 const branding_1 = __importDefault(require("./branding"));
 const logStreams_1 = __importDefault(require("./logStreams"));
+const prompts_1 = __importDefault(require("./prompts"));
+const customDomains_1 = __importDefault(require("./customDomains"));
 const directoryHandlers = {
     rules: rules_1.default,
     rulesConfigs: rulesConfigs_1.default,
@@ -56,5 +58,7 @@ const directoryHandlers = {
     attackProtection: attackProtection_1.default,
     branding: branding_1.default,
     logStreams: logStreams_1.default,
+    prompts: prompts_1.default,
+    customDomains: customDomains_1.default,
 };
 exports.default = directoryHandlers;

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

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

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

@@ -0,0 +1,81 @@
+"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 __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 });
+const path_1 = __importDefault(require("path"));
+const fs_extra_1 = require("fs-extra");
+const tools_1 = require("../../../tools");
+const utils_1 = require("../../../utils");
+const getPromptsDirectory = (filePath) => {
+    return path_1.default.join(filePath, tools_1.constants.PROMPTS_DIRECTORY);
+};
+const getPromptsSettingsFile = (promptsDirectory) => {
+    return path_1.default.join(promptsDirectory, 'prompts.json');
+};
+const getCustomTextFile = (promptsDirectory) => {
+    return path_1.default.join(promptsDirectory, 'custom-text.json');
+};
+function parse(context) {
+    const promptsDirectory = getPromptsDirectory(context.filePath);
+    if (!(0, utils_1.existsMustBeDir)(promptsDirectory))
+        return { prompts: null }; // Skip
+    const promptsSettings = (() => {
+        const promptsSettingsFile = getPromptsSettingsFile(promptsDirectory);
+        if (!(0, utils_1.isFile)(promptsSettingsFile))
+            return {};
+        return (0, utils_1.loadJSON)(promptsSettingsFile, context.mappings);
+    })();
+    const customText = (() => {
+        const customTextFile = getCustomTextFile(promptsDirectory);
+        if (!(0, utils_1.isFile)(customTextFile))
+            return {};
+        return (0, utils_1.loadJSON)(customTextFile, context.mappings);
+    })();
+    return {
+        prompts: Object.assign(Object.assign({}, promptsSettings), { customText }),
+    };
+}
+function dump(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { prompts } = context.assets;
+        if (!prompts)
+            return;
+        const { customText } = prompts, promptsSettings = __rest(prompts, ["customText"]);
+        const promptsDirectory = getPromptsDirectory(context.filePath);
+        (0, fs_extra_1.ensureDirSync)(promptsDirectory);
+        if (!promptsSettings)
+            return;
+        const promptsSettingsFile = getPromptsSettingsFile(promptsDirectory);
+        (0, utils_1.dumpJSON)(promptsSettingsFile, promptsSettings);
+        if (!customText)
+            return;
+        const customTextFile = getCustomTextFile(promptsDirectory);
+        (0, utils_1.dumpJSON)(customTextFile, customText);
+    });
+}
+const promptsHandler = {
+    parse,
+    dump,
+};
+exports.default = promptsHandler;

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

@@ -0,0 +1,5 @@
+import { YAMLHandler } from '.';
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedCustomDomains = ParsedAsset<'customDomains', Asset[]>;
+declare const customDomainsHandler: YAMLHandler<ParsedCustomDomains>;
+export default customDomainsHandler;

package/lib/context/yaml/handlers/customDomains.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 { customDomains } = context.assets;
+        if (!customDomains)
+            return { customDomains: null };
+        return {
+            customDomains,
+        };
+    });
+}
+const customDomainsHandler = {
+    parse: parseAndDump,
+    dump: parseAndDump,
+};
+exports.default = customDomainsHandler;

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

@@ -29,6 +29,8 @@ const triggers_1 = __importDefault(require("./triggers"));
 const attackProtection_1 = __importDefault(require("./attackProtection"));
 const branding_1 = __importDefault(require("./branding"));
 const logStreams_1 = __importDefault(require("./logStreams"));
+const prompts_1 = __importDefault(require("./prompts"));
+const customDomains_1 = __importDefault(require("./customDomains"));
 const yamlHandlers = {
     rules: rules_1.default,
     hooks: hooks_1.default,
@@ -56,5 +58,7 @@ const yamlHandlers = {
     attackProtection: attackProtection_1.default,
     branding: branding_1.default,
     logStreams: logStreams_1.default,
+    prompts: prompts_1.default,
+    customDomains: customDomains_1.default,
 };
 exports.default = yamlHandlers;

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/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/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/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/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/types.d.ts

@@ -1,3 +1,4 @@
+import { PromptScreenTypes, Prompts, PromptsCustomText, PromptSettings } from './tools/auth0/handlers/prompts';
 declare type SharedPaginationParams = {
     checkpoint?: boolean;
     paginate?: boolean;
@@ -126,9 +127,20 @@ export declare type BaseAuth0APIClient = {
             get: (arg0: Asset) => Promise<Asset>;
         };
     };
-    prompts: APIClientBaseFunctions & {
-        getSettings: () => Promise<Asset[]>;
-        updateSettings: (arg0: {}, arg1: Asset) => Promise<void>;
+    prompts: {
+        updateCustomTextByLanguage: (arg0: {
+            prompt: PromptScreenTypes;
+            language: Language;
+            body: {
+                [key: string]: string;
+            };
+        }) => Promise<void>;
+        getCustomTextByLanguage: (arg0: {
+            prompt: PromptScreenTypes;
+            language: Language;
+        }) => Promise<Partial<PromptsCustomText>>;
+        getSettings: () => Promise<PromptSettings>;
+        updateSettings: (arg0: {}, arg1: Partial<PromptSettings>) => Promise<void>;
     };
     resourceServers: APIClientBaseFunctions;
     roles: APIClientBaseFunctions & {
@@ -150,7 +162,9 @@ export declare type BaseAuth0APIClient = {
         getAll: () => Promise<Asset[]>;
     };
     tenant: APIClientBaseFunctions & {
-        getSettings: () => Promise<Asset>;
+        getSettings: () => Promise<Asset & {
+            enabled_locales: Language[];
+        }>;
         updateSettings: (arg0: Asset) => Promise<void>;
     };
     triggers: APIClientBaseFunctions & {
@@ -217,6 +231,7 @@ export declare type Assets = Partial<{
     clients: Asset[] | null;
     clientGrants: Asset[] | null;
     connections: Asset[] | null;
+    customDomains: Asset[] | null;
     databases: Asset[] | null;
     emailProvider: Asset | null;
     emailTemplates: Asset[] | null;
@@ -235,6 +250,7 @@ export declare type Assets = Partial<{
     migrations: Asset[] | null;
     organizations: Asset[] | null;
     pages: Asset[] | null;
+    prompts: Prompts | null;
     resourceServers: Asset[] | null;
     roles: Asset[] | null;
     rules: Asset[] | null;
@@ -252,11 +268,13 @@ export declare type CalculatedChanges = {
     conflicts: Asset[];
     create: Asset[];
 };
-export declare type AssetTypes = 'rules' | 'rulesConfigs' | 'hooks' | 'pages' | 'databases' | 'clientGrants' | 'resourceServers' | 'clients' | 'connections' | 'tenant' | 'emailProvider' | 'emailTemplates' | 'guardianFactors' | 'guardianFactorProviders' | 'guardianFactorTemplates' | 'migrations' | 'guardianPhoneFactorMessageTypes' | 'guardianPhoneFactorSelectedProvider' | 'guardianPolicies' | 'roles' | 'actions' | 'organizations' | 'triggers' | 'attackProtection' | 'branding' | 'logStreams';
+export declare type AssetTypes = 'rules' | 'rulesConfigs' | 'hooks' | 'pages' | 'databases' | 'clientGrants' | 'resourceServers' | 'clients' | 'connections' | 'tenant' | 'emailProvider' | 'emailTemplates' | 'guardianFactors' | 'guardianFactorProviders' | 'guardianFactorTemplates' | 'migrations' | 'guardianPhoneFactorMessageTypes' | 'guardianPhoneFactorSelectedProvider' | 'guardianPolicies' | 'roles' | 'actions' | 'organizations' | 'triggers' | 'attackProtection' | 'branding' | 'logStreams' | 'prompts' | 'customDomains';
 export declare type KeywordMappings = {
     [key: string]: (string | number)[] | string | number;
 };
 export declare type ParsedAsset<Key extends AssetTypes, T> = {
     [key in Key]: T | null;
 };
+export declare const languages: readonly ["ar", "bg", "bs", "cs", "da", "de", "el", "en", "es", "et", "fi", "fr", "fr-CA", "fr-FR", "he", "hi", "hr", "hu", "id", "is", "it", "ja", "ko", "lt", "lv", "nb", "nl", "pl", "pt", "pt-BR", "pt-PT", "ro", "ru", "sk", "sl", "sr", "sv", "th", "tr", "uk", "vi", "zh-CN", "zh-TW"];
+export declare type Language = typeof languages[number];
 export {};

package/lib/types.js

@@ -1,2 +1,48 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.languages = void 0;
+exports.languages = [
+    'ar',
+    'bg',
+    'bs',
+    'cs',
+    'da',
+    'de',
+    'el',
+    'en',
+    'es',
+    'et',
+    'fi',
+    'fr',
+    'fr-CA',
+    'fr-FR',
+    'he',
+    'hi',
+    'hr',
+    'hu',
+    'id',
+    'is',
+    'it',
+    'ja',
+    'ko',
+    'lt',
+    'lv',
+    'nb',
+    'nl',
+    'pl',
+    'pt',
+    'pt-BR',
+    'pt-PT',
+    'ro',
+    'ru',
+    'sk',
+    'sl',
+    'sr',
+    'sv',
+    'th',
+    'tr',
+    'uk',
+    'vi',
+    'zh-CN',
+    'zh-TW',
+];

package/lib/utils.d.ts

@@ -21,6 +21,7 @@ export declare function stripIdentifiers(auth0: Auth0, assets: Assets): {
     clients?: Asset[] | null | undefined;
     clientGrants?: Asset[] | null | undefined;
     connections?: Asset[] | null | undefined;
+    customDomains?: Asset[] | null | undefined;
     databases?: Asset[] | null | undefined;
     emailProvider?: Asset | null | undefined;
     emailTemplates?: Asset[] | null | undefined;
@@ -39,6 +40,53 @@ export declare function stripIdentifiers(auth0: Auth0, assets: Assets): {
     migrations?: Asset[] | null | undefined;
     organizations?: Asset[] | null | undefined;
     pages?: Asset[] | null | undefined;
+    prompts?: Partial<import("./tools/auth0/handlers/prompts").PromptSettings & {
+        customText: Partial<{
+            id: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            ar: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            bg: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            bs: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            cs: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            da: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            de: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            el: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            en: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            es: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            et: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            fi: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            fr: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            "fr-CA": Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            "fr-FR": Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            he: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            hi: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            hr: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            hu: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            is: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            it: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            ja: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            ko: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            lt: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            lv: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            nb: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            nl: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            pl: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            pt: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            "pt-BR": Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            "pt-PT": Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            ro: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            ru: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            sk: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            sl: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            sr: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            sv: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            th: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            tr: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            uk: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            vi: Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            "zh-CN": Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+            "zh-TW": Partial<import("./tools/auth0/handlers/prompts").PromptsCustomText>;
+        }>;
+    }> | null | undefined;
     resourceServers?: Asset[] | null | undefined;
     roles?: Asset[] | null | undefined;
     rules?: Asset[] | null | undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "auth0-deploy-cli",
-  "version": "7.11.1",
+  "version": "7.12.0",
   "description": "A command line tool for deploying updates to your Auth0 tenant",
   "main": "lib/index.js",
   "bin": {