auth0-deploy-cli 8.22.0 → 8.23.1

package/lib/tools/auth0/handlers/hooks.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 };
 };
@@ -87,166 +78,145 @@ const getActive = (hooks) => {
 };
 class HooksHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'hooks', stripUpdateFields: ['id', 'triggerId'] }));
+        super({
+            ...options,
+            type: 'hooks',
+            stripUpdateFields: ['id', 'triggerId'],
+        });
     }
     objString(hook) {
         return super.objString({ name: hook.name, triggerId: hook.triggerId });
     }
-    processSecrets(hooks) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allHooks = yield this.getType(true);
-            if (allHooks === null)
-                return;
-            const changes = {
-                create: [],
-                update: [],
-                del: [],
-                conflicts: [],
-            };
-            hooks.forEach((hook) => {
-                const current = getCertainHook(allHooks, hook.name, hook.triggerId);
-                if (current) {
-                    // if the hook was deleted we don't care about its secrets
-                    const oldSecrets = current.secrets || {};
-                    const newSecrets = hook.secrets || {};
-                    const create = {};
-                    const update = {};
-                    const del = [];
-                    Object.keys(newSecrets).forEach((key) => {
-                        if (!oldSecrets[key]) {
-                            create[key] = newSecrets[key];
-                        }
-                        else if (newSecrets[key] !== constants_1.default.HOOKS_HIDDEN_SECRET_VALUE) {
-                            update[key] = newSecrets[key];
-                        }
-                    });
-                    Object.keys(oldSecrets).forEach((key) => {
-                        if (!newSecrets[key]) {
-                            del.push(key);
-                        }
-                    });
-                    if (Object.keys(create).length)
-                        changes.create.push({ hookId: current.id, secrets: create });
-                    if (Object.keys(update).length)
-                        changes.update.push({ hookId: current.id, secrets: update });
-                    if (del.length)
-                        changes.del.push({ hookId: current.id, secrets: del });
-                }
-            });
-            yield Promise.all(changes.del.map((data) => __awaiter(this, void 0, void 0, function* () {
-                yield this.client.hooks.deleteSecrets({ id: data.hookId }, data.secrets);
-            })));
-            yield Promise.all(changes.update.map((data) => __awaiter(this, void 0, void 0, function* () {
-                yield this.client.hooks.updateSecrets({ id: data.hookId }, data.secrets);
-            })));
-            yield Promise.all(changes.create.map((data) => __awaiter(this, void 0, void 0, function* () {
-                yield this.client.hooks.addSecrets({ id: data.hookId }, data.secrets);
-            })));
+    async processSecrets(hooks) {
+        const allHooks = await this.getType(true);
+        if (allHooks === null)
+            return;
+        const changes = {
+            create: [],
+            update: [],
+            del: [],
+            conflicts: [],
+        };
+        hooks.forEach((hook) => {
+            const current = getCertainHook(allHooks, hook.name, hook.triggerId);
+            if (current) {
+                // if the hook was deleted we don't care about its secrets
+                const oldSecrets = current.secrets || {};
+                const newSecrets = hook.secrets || {};
+                const create = {};
+                const update = {};
+                const del = [];
+                Object.keys(newSecrets).forEach((key) => {
+                    if (!oldSecrets[key]) {
+                        create[key] = newSecrets[key];
+                    }
+                    else if (newSecrets[key] !== constants_1.default.HOOKS_HIDDEN_SECRET_VALUE) {
+                        update[key] = newSecrets[key];
+                    }
+                });
+                Object.keys(oldSecrets).forEach((key) => {
+                    if (!newSecrets[key]) {
+                        del.push(key);
+                    }
+                });
+                if (Object.keys(create).length)
+                    changes.create.push({ hookId: current.id, secrets: create });
+                if (Object.keys(update).length)
+                    changes.update.push({ hookId: current.id, secrets: update });
+                if (del.length)
+                    changes.del.push({ hookId: current.id, secrets: del });
+            }
         });
+        await Promise.all(changes.del.map(async (data) => {
+            await this.client.hooks.secrets.delete(data.hookId, data.secrets);
+        }));
+        await Promise.all(changes.update.map(async (data) => {
+            await this.client.hooks.secrets.update(data.hookId, data.secrets);
+        }));
+        await Promise.all(changes.create.map(async (data) => {
+            await this.client.hooks.secrets.create(data.hookId, data.secrets);
+        }));
     }
-    //@ts-ignore because hooks use a special reload argument
-    getType(reload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing && !reload) {
-                return this.existing;
-            }
-            // in case client version does not support hooks
-            if (!this.client.hooks || typeof this.client.hooks.getAll !== 'function') {
+    // @ts-ignore because hooks use a special reload argument
+    async getType(reload) {
+        if (this.existing && !reload) {
+            return this.existing;
+        }
+        try {
+            const hooks = await (0, client_1.paginate)(this.client.hooks.list, {
+                paginate: true,
+            });
+            // hooks.getAll does not return code and secrets, we have to fetch hooks one-by-one
+            this.existing = await Promise.all(hooks.map((hook) => this.client.hooks
+                .get(hook.id)
+                .then((hookWithCode) => this.client.hooks.secrets
+                .get(hook.id)
+                .then(({ data: secrets }) => ({ ...hookWithCode, secrets })))));
+            return this.existing;
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
                 return [];
             }
-            try {
-                const hooks = yield (0, client_1.paginate)(this.client.hooks.getAll, {
-                    paginate: true,
-                    include_totals: true,
-                });
-                // hooks.getAll does not return code and secrets, we have to fetch hooks one-by-one
-                this.existing = yield Promise.all(hooks.map((hook) => this.client.hooks
-                    .get({ id: hook.id })
-                    .then(({ data: hookWithCode }) => this.client.hooks
-                    .getSecrets({ id: hook.id })
-                    .then(({ data: secrets }) => (Object.assign(Object.assign({}, hookWithCode), { secrets }))))));
-                return this.existing;
+            if ((0, utils_1.isDeprecatedError)(err)) {
+                return null;
             }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return [];
-                }
-                if ((0, utils_1.isDeprecatedError)(err)) {
-                    return null;
-                }
+            throw err;
+        }
+    }
+    async calcChanges(assets) {
+        const { del, update, create, conflicts } = await super.calcChanges(assets);
+        // strip secrets before hooks creating/updating, secrets have to be handled separately
+        const stripSecrets = (list) => list.map((item) => ({ ...item, secrets: undefined }));
+        return {
+            del,
+            update: stripSecrets(update),
+            create: stripSecrets(create),
+            conflicts: stripSecrets(conflicts),
+        };
+    }
+    async validate(assets) {
+        const { hooks } = assets;
+        // Do nothing if not set
+        if (!hooks)
+            return;
+        const activeHooks = getActive(hooks);
+        ALLOWED_TRIGGER_IDS.forEach((type) => {
+            if (activeHooks[type].length > 1) {
+                // There can be only one!
+                const conflict = activeHooks[type].map((h) => h.name).join(', ');
+                const err = new Error(`Only one active hook allowed for "${type}" extensibility point. Conflicting hooks: ${conflict}`);
+                // @ts-ignore need to investigate if appending status actually works here
+                err.status = 409;
                 throw err;
             }
         });
+        await super.validate(assets);
     }
-    calcChanges(assets) {
-        const _super = Object.create(null, {
-            calcChanges: { get: () => super.calcChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { del, update, create, conflicts } = yield _super.calcChanges.call(this, assets);
-            // strip secrets before hooks creating/updating, secrets have to be handled separately
-            const stripSecrets = (list) => list.map((item) => (Object.assign(Object.assign({}, item), { secrets: undefined })));
-            return {
-                del,
-                update: stripSecrets(update),
-                create: stripSecrets(create),
-                conflicts: stripSecrets(conflicts),
-            };
-        });
-    }
-    validate(assets) {
-        const _super = Object.create(null, {
-            validate: { get: () => super.validate }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { hooks } = assets;
-            // Do nothing if not set
-            if (!hooks)
-                return;
-            const activeHooks = getActive(hooks);
-            ALLOWED_TRIGGER_IDS.forEach((type) => {
-                if (activeHooks[type].length > 1) {
-                    // There can be only one!
-                    const conflict = activeHooks[type].map((h) => h.name).join(', ');
-                    const err = new Error(`Only one active hook allowed for "${type}" extensibility point. Conflicting hooks: ${conflict}`);
-                    //@ts-ignore need to investigate if appending status actually works here
-                    err.status = 409;
-                    throw err;
-                }
+    async processChanges(assets) {
+        const { hooks } = assets;
+        // Do nothing if not set
+        if (!hooks)
+            return;
+        logger_1.default.warn('Hooks are deprecated, migrate to using actions instead. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-hooks-to-actions for more information.');
+        try {
+            // Figure out what needs to be updated vs created
+            const changes = await this.calcChanges(assets);
+            await super.processChanges(assets, {
+                del: changes.del,
+                create: changes.create,
+                update: changes.update,
+                conflicts: changes.conflicts,
             });
-            yield _super.validate.call(this, assets);
-        });
-    }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { hooks } = assets;
-            // Do nothing if not set
-            if (!hooks)
+            await this.processSecrets(hooks);
+        }
+        catch (err) {
+            if ((0, utils_1.isDeprecatedError)(err)) {
+                logger_1.default.warn('Failed to update hooks because functionality has been deprecated in favor of actions. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-hooks-to-actions for more information.');
                 return;
-            logger_1.default.warn('Hooks are deprecated, migrate to using actions instead. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-hooks-to-actions for more information.');
-            try {
-                // Figure out what needs to be updated vs created
-                const changes = yield this.calcChanges(assets);
-                yield _super.processChanges.call(this, assets, {
-                    del: changes.del,
-                    create: changes.create,
-                    update: changes.update,
-                    conflicts: changes.conflicts,
-                });
-                yield this.processSecrets(hooks);
             }
-            catch (err) {
-                if ((0, utils_1.isDeprecatedError)(err)) {
-                    logger_1.default.warn('Failed to update hooks because functionality has been deprecated in favor of actions. See: https://auth0.com/docs/customize/actions/migrate/migrate-from-hooks-to-actions for more information.');
-                    return;
-                }
-                throw err;
-            }
-        });
+            throw err;
+        }
     }
 }
 exports.default = HooksHandler;
-//# sourceMappingURL=hooks.js.map

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

@@ -54,6 +54,7 @@ const guardianPhoneFactorMessageTypes = __importStar(require("./guardianPhoneFac
 const roles = __importStar(require("./roles"));
 const branding = __importStar(require("./branding"));
 const phoneProviders = __importStar(require("./phoneProvider"));
+const phoneTemplates = __importStar(require("./phoneTemplates"));
 const prompts = __importStar(require("./prompts"));
 const actions = __importStar(require("./actions"));
 const triggers = __importStar(require("./triggers"));
@@ -69,6 +70,7 @@ const selfServiceProfiles = __importStar(require("./selfServiceProfiles"));
 const networkACLs = __importStar(require("./networkACLs"));
 const userAttributeProfiles = __importStar(require("./userAttributeProfiles"));
 const connectionProfiles = __importStar(require("./connectionProfiles"));
+const tokenExchangeProfiles = __importStar(require("./tokenExchangeProfiles"));
 const auth0ApiHandlers = {
     rules,
     rulesConfigs,
@@ -91,6 +93,7 @@ const auth0ApiHandlers = {
     roles,
     branding,
     phoneProviders,
+    phoneTemplates,
     //@ts-ignore because prompts have not been universally implemented yet
     prompts,
     actions,
@@ -107,6 +110,6 @@ const auth0ApiHandlers = {
     networkACLs,
     userAttributeProfiles,
     connectionProfiles,
+    tokenExchangeProfiles,
 };
 exports.default = auth0ApiHandlers; // TODO: apply stronger types to schema properties
-//# sourceMappingURL=index.js.map

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

@@ -38,15 +38,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importStar(require("./default"));
@@ -95,55 +86,59 @@ exports.schema = {
 };
 class LogStreamsHandler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'logStreams', stripUpdateFields: ['type'], stripCreateFields: ['status', 'sink.awsPartnerEventSource', 'sink.azurePartnerTopic'], sensitiveFieldsToObfuscate: [
+        super({
+            ...config,
+            type: 'logStreams',
+            stripUpdateFields: ['type'],
+            stripCreateFields: ['status', 'sink.awsPartnerEventSource', 'sink.azurePartnerTopic'],
+            sensitiveFieldsToObfuscate: [
                 'sink.httpAuthorization',
                 'sink.splunkToken',
                 'sink.datadogApiKey',
-            ] }));
+            ],
+            functions: {
+                update: async (params, payload) => this.client.logStreams.update(params?.id, payload),
+            },
+        });
     }
     objString(item) {
         return super.objString(item.name);
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            const logStreams = yield this.client.logStreams.getAll().then(({ data: logStreams }) => logStreams.map((logStream) => {
-                if (logStream.status === 'suspended')
-                    delete logStream.status;
-                return logStream;
-            }));
-            this.existing = logStreams;
-            return logStreams;
-        });
+    async getType() {
+        if (this.existing) {
+            return this.existing;
+        }
+        const logStreams = await this.client.logStreams.list().then((logStreamsResponse) => logStreamsResponse.map((logStream) => {
+            if (logStream.status === 'suspended')
+                delete logStream.status;
+            return logStream;
+        }));
+        this.existing = logStreams;
+        return logStreams;
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { logStreams } = assets;
-            if (!logStreams)
-                return;
-            const changes = yield this.calcChanges(assets).then((changes) => (Object.assign(Object.assign({}, changes), { update: changes.update.map((update) => {
-                    if (update.type === 'eventbridge' || update.type === 'eventgrid') {
-                        delete update.sink;
-                    }
-                    if (update.status === 'suspended') {
-                        // @ts-ignore because while status is usually expected for update payloads, it is ok to be omitted
-                        // for suspended log streams. Setting as `active` in these instances would probably be ok
-                        // but bit presumptuous, let suspended log streams remain suspended.
-                        delete update.status;
-                    }
-                    return update;
-                }) })));
-            yield _super.processChanges.call(this, assets, changes);
-        });
+    async processChanges(assets) {
+        const { logStreams } = assets;
+        if (!logStreams)
+            return;
+        const changes = await this.calcChanges(assets).then((changesResponse) => ({
+            ...changesResponse,
+            update: changesResponse.update.map((update) => {
+                if (update.type === 'eventbridge' || update.type === 'eventgrid') {
+                    delete update.sink;
+                }
+                if (update.status === 'suspended') {
+                    // @ts-ignore because while status is usually expected for update payloads, it is ok to be omitted
+                    // for suspended log streams. Setting as `active` in these instances would probably be ok
+                    // but bit presumptuous, let suspended log streams remain suspended.
+                    delete update.status;
+                }
+                return update;
+            }),
+        }));
+        await super.processChanges(assets, changes);
     }
 }
 exports.default = LogStreamsHandler;
 __decorate([
     (0, default_1.order)('70')
 ], LogStreamsHandler.prototype, "processChanges", null);
-//# sourceMappingURL=logStreams.js.map

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

@@ -1,7 +1,7 @@
-import { GetNetworkAclsById200Response } from 'auth0';
+import { Management } from 'auth0';
 import DefaultAPIHandler from './default';
 import { Asset, Assets, CalculatedChanges } from '../../../types';
-export type NetworkACL = GetNetworkAclsById200Response;
+export type NetworkACL = Management.GetNetworkAclsResponseContent;
 export declare const schema: {
     type: string;
     description: string;
@@ -246,11 +246,12 @@ export declare const schema: {
 export default class NetworkACLsHandler extends DefaultAPIHandler {
     existing: NetworkACL[] | null;
     constructor(config: DefaultAPIHandler);
+    objString(acl: NetworkACL): string;
     getType(): Promise<Asset | null>;
     processChanges(assets: Assets): Promise<void>;
-    createNetworkACL(acl: NetworkACL): Promise<Asset>;
+    createNetworkACL(acl: NetworkACL): Promise<NetworkACL>;
     createNetworkACLs(creates: CalculatedChanges['create']): Promise<void>;
-    updateNetworkACL(acl: NetworkACL): Promise<import("auth0").ApiResponse<GetNetworkAclsById200Response>>;
+    updateNetworkACL(acl: NetworkACL): Promise<Management.UpdateNetworkAclResponseContent>;
     updateNetworkACLs(updates: CalculatedChanges['update']): Promise<void>;
     deleteNetworkACL(acl: NetworkACL): Promise<void>;
     deleteNetworkACLs(data: Asset[]): Promise<void>;