auth0-deploy-cli 8.20.2 → 8.20.4-beta.0

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

@@ -38,26 +38,6 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __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 };
 };
@@ -79,71 +59,69 @@ exports.schema = {
 };
 class EmailTemplateHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'emailTemplates', identifiers: ['template'] }));
-    }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const emailTemplates = yield Promise.all(constants_1.default.EMAIL_TEMPLATES_TYPES.map((templateName) => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    const { data: template } = yield this.client.emailTemplates.get({ templateName });
-                    return template;
-                }
-                catch (err) {
-                    if (err.statusCode === 403 && templateName === constants_1.default.EMAIL_ASYNC_APPROVAL) {
-                        // Ignore if feature_not_enabled
-                        return null;
-                    }
-                    // Ignore if not found, else throw error
-                    if (err.statusCode !== 404) {
-                        throw err;
-                    }
-                }
-            })));
-            const nonEmptyTemplates = emailTemplates.filter((template) => !!template);
-            return nonEmptyTemplates;
+        super({
+            ...options,
+            type: 'emailTemplates',
+            identifiers: ['template'],
         });
     }
-    updateOrCreate(emailTemplate) {
-        return __awaiter(this, void 0, void 0, function* () {
+    async getType() {
+        const emailTemplates = await Promise.all(constants_1.default.EMAIL_TEMPLATES_TYPES.map(async (templateName) => {
             try {
-                const identifierField = this.identifiers[0];
-                const params = { templateName: emailTemplate[identifierField] };
-                const { data: updated } = yield this.client.emailTemplates.update(params, emailTemplate);
-                // Remove body from the response
-                const { body } = updated, excludedBody = __rest(updated, ["body"]);
-                this.didUpdate(excludedBody);
-                this.updated += 1;
+                const template = await this.client.emailTemplates.get(templateName);
+                return template;
             }
             catch (err) {
-                if (err.statusCode === 404) {
-                    // Create if it does not exist
-                    const { data: created } = yield this.client.emailTemplates.create(emailTemplate);
-                    // Remove body from the response
-                    const { body } = created, excludedBody = __rest(created, ["body"]);
-                    this.didCreate(excludedBody);
-                    this.created += 1;
+                if (err.statusCode === 403 && templateName === constants_1.default.EMAIL_ASYNC_APPROVAL) {
+                    // Ignore if feature_not_enabled
+                    return null;
                 }
-                else {
+                // Ignore if not found, else throw error
+                if (err.statusCode !== 404) {
                     throw err;
                 }
             }
-        });
+            return null;
+        }));
+        const nonEmptyTemplates = emailTemplates.filter((template) => !!template);
+        return nonEmptyTemplates;
+    }
+    async updateOrCreate(emailTemplate) {
+        try {
+            const identifierField = this.identifiers[0];
+            const params = { templateName: emailTemplate[identifierField] };
+            const updated = await this.client.emailTemplates.update(params.templateName, emailTemplate);
+            // Remove body from the response
+            const { body, ...excludedBody } = updated;
+            this.didUpdate(excludedBody);
+            this.updated += 1;
+        }
+        catch (err) {
+            if (err.statusCode === 404) {
+                // Create if it does not exist
+                const created = await this.client.emailTemplates.create(emailTemplate);
+                // Remove body from the response
+                const { body, ...excludedBody } = created;
+                this.didCreate(excludedBody);
+                this.created += 1;
+            }
+            else {
+                throw err;
+            }
+        }
     }
     // Run after email provider changes
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { emailTemplates } = assets;
-            // Do nothing if not set
-            if (!emailTemplates || !emailTemplates.length)
-                return;
-            yield Promise.all(emailTemplates.map((emailTemplate) => __awaiter(this, void 0, void 0, function* () {
-                yield this.updateOrCreate(emailTemplate);
-            })));
-        });
+    async processChanges(assets) {
+        const { emailTemplates } = assets;
+        // Do nothing if not set
+        if (!emailTemplates || !emailTemplates.length)
+            return;
+        await Promise.all(emailTemplates.map(async (emailTemplate) => {
+            await this.updateOrCreate(emailTemplate);
+        }));
     }
 }
 exports.default = EmailTemplateHandler;
 __decorate([
     (0, default_1.order)('70')
 ], EmailTemplateHandler.prototype, "processChanges", null);
-//# sourceMappingURL=emailTemplates.js.map

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

@@ -1,14 +1,7 @@
-import { GetFlowsVaultConnections200ResponseOneOfInner } from 'auth0';
+import { Management } from 'auth0';
 import DefaultHandler from './default';
-import { Asset, Assets, CalculatedChanges } from '../../../types';
-export type FlowVaultConnection = {
-    name: string;
-    app_id: string;
-    environment: string;
-    setup: object;
-    account_name: string;
-    ready: string;
-};
+import { Asset, Assets, Auth0APIClient, CalculatedChanges } from '../../../types';
+export type FlowVaultConnection = Management.GetFlowsVaultConnectionResponseContent;
 export declare const schema: {
     type: string;
     items: {
@@ -38,16 +31,16 @@ export declare const schema: {
     };
     additionalProperties: boolean;
 };
+export declare const getAllFlowConnections: (auth0Client: Auth0APIClient) => Promise<Management.FlowsVaultConnectionSummary[]>;
 export default class FlowVaultHandler extends DefaultHandler {
     existing: Asset;
     constructor(options: DefaultHandler);
     objString(item: any): string;
     getType(): Promise<Asset>;
     processChanges(assets: Assets): Promise<void>;
-    getAllFlowConnections(): Promise<GetFlowsVaultConnections200ResponseOneOfInner[]>;
     createVaultConnection(conn: any): Promise<Asset>;
     createVaultConnections(creates: CalculatedChanges['create']): Promise<void>;
-    updateVaultConnection(conn: any): Promise<import("auth0").ApiResponse<import("auth0").PostFlowsVaultConnections201Response>>;
+    updateVaultConnection(conn: any): Promise<Management.UpdateFlowsVaultConnectionResponseContent>;
     updateVaultConnections(updates: CalculatedChanges['update']): Promise<void>;
     deleteVaultConnection(conn: any): Promise<void>;
     deleteVaultConnections(data: Asset[]): Promise<void>;

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

@@ -38,20 +38,11 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = void 0;
+exports.getAllFlowConnections = exports.schema = void 0;
 const lodash_1 = require("lodash");
 const default_1 = __importStar(require("./default"));
 const constants_1 = __importDefault(require("../../constants"));
@@ -72,165 +63,139 @@ exports.schema = {
     },
     additionalProperties: false,
 };
+const getAllFlowConnections = async (auth0Client) => {
+    const allFlowConnections = [];
+    let vaultConnections = await auth0Client.flows.vault.connections.list();
+    do {
+        allFlowConnections.push(...vaultConnections.data);
+        vaultConnections = await vaultConnections.getNextPage();
+    } while (vaultConnections.hasNextPage());
+    return allFlowConnections;
+};
+exports.getAllFlowConnections = getAllFlowConnections;
 class FlowVaultHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'flowVaultConnections', id: 'id', stripCreateFields: ['created_at', 'updated_at', 'refreshed_at', 'fingerprint', 'ready'], stripUpdateFields: ['created_at', 'updated_at', 'refreshed_at', 'fingerprint', 'ready'] }));
+        super({
+            ...options,
+            type: 'flowVaultConnections',
+            id: 'id',
+            stripCreateFields: ['created_at', 'updated_at', 'refreshed_at', 'fingerprint', 'ready'],
+            stripUpdateFields: ['created_at', 'updated_at', 'refreshed_at', 'fingerprint', 'ready'],
+        });
     }
     objString(item) {
         return super.objString({ id: item.id, name: item.name });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            this.existing = yield this.getAllFlowConnections();
+    async getType() {
+        if (this.existing) {
             return this.existing;
-        });
+        }
+        this.existing = await (0, exports.getAllFlowConnections)(this.client);
+        return this.existing;
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { flowVaultConnections } = assets;
-            // Do nothing if not set
-            if (!flowVaultConnections)
-                return;
-            const { del, update, create } = yield this.calcChanges(assets);
-            logger_1.default.debug(`Start processChanges for flow vault connections [delete:${del.length}] [update:${update.length}], [create:${create.length}]`);
-            const changes = [{ del: del }, { create: create }, { update: update }];
-            yield Promise.all(changes.map((change) => __awaiter(this, void 0, void 0, function* () {
-                switch (true) {
-                    case change.del && change.del.length > 0:
-                        yield this.deleteVaultConnections(change.del || []);
-                        break;
-                    case change.create && change.create.length > 0:
-                        yield this.createVaultConnections(change.create);
-                        break;
-                    case change.update && change.update.length > 0:
-                        if (change.update)
-                            yield this.updateVaultConnections(change.update);
-                        break;
-                    default:
-                        break;
-                }
-            })));
-        });
-    }
-    getAllFlowConnections() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allFlowConnections = [];
-            // paginate without paginate<T> helper as this is not getAll but getAllConnections
-            // paginate through all flow connections
-            let page = 0;
-            while (true) {
-                const { data: { connections, total }, } = yield this.client.flows.getAllConnections({
-                    page: page,
-                    per_page: 100,
-                    include_totals: true,
-                });
-                // if we get an unexpected response, break the loop to avoid infinite loop
-                if (!(0, lodash_1.isArray)(allFlowConnections) || typeof total !== 'number') {
+    async processChanges(assets) {
+        const { flowVaultConnections } = assets;
+        // Do nothing if not set
+        if (!flowVaultConnections)
+            return;
+        const { del, update, create } = await this.calcChanges(assets);
+        logger_1.default.debug(`Start processChanges for flow vault connections [delete:${del.length}] [update:${update.length}], [create:${create.length}]`);
+        const changes = [{ del: del }, { create: create }, { update: update }];
+        await Promise.all(changes.map(async (change) => {
+            switch (true) {
+                case change.del && change.del.length > 0:
+                    await this.deleteVaultConnections(change.del || []);
+                    break;
+                case change.create && change.create.length > 0:
+                    await this.createVaultConnections(change.create);
+                    break;
+                case change.update && change.update.length > 0:
+                    if (change.update)
+                        await this.updateVaultConnections(change.update);
                     break;
-                }
-                allFlowConnections.push(...connections);
-                page += 1;
-                if (allFlowConnections.length === total) {
+                default:
                     break;
-                }
             }
-            return allFlowConnections;
-        });
+        }));
     }
-    createVaultConnection(conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if ('ready' in conn) {
-                delete conn.ready;
-            }
-            if ('account_name' in conn) {
-                delete conn.account_name;
-            }
-            const { data: created } = yield this.client.flows.createConnection(conn);
-            return created;
-        });
+    async createVaultConnection(conn) {
+        if ('ready' in conn) {
+            delete conn.ready;
+        }
+        if ('account_name' in conn) {
+            delete conn.account_name;
+        }
+        const created = await this.client.flows.vault.connections.create(conn);
+        return created;
     }
-    createVaultConnections(creates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool
-                .addEachTask({
-                data: creates || [],
-                generator: (item) => this.createVaultConnection(item)
-                    .then((data) => {
-                    this.didCreate(data);
-                    this.created += 1;
-                })
-                    .catch((err) => {
-                    throw new Error(`Problem creating ${this.type} ${this.objString(item)}\n${err}`);
-                }),
+    async createVaultConnections(creates) {
+        await this.client.pool
+            .addEachTask({
+            data: creates || [],
+            generator: (item) => this.createVaultConnection(item)
+                .then((data) => {
+                this.didCreate(data);
+                this.created += 1;
             })
-                .promise();
-        });
+                .catch((err) => {
+                throw new Error(`Problem creating ${this.type} ${this.objString(item)}\n${err}`);
+            }),
+        })
+            .promise();
     }
-    updateVaultConnection(conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { id, name, setup } = conn;
-            const params = {
-                name,
-            };
-            if (!(0, lodash_1.isEmpty)(setup)) {
-                params.setup = setup;
-            }
-            const updated = yield this.client.flows.updateConnection({ id: id }, params);
-            return updated;
-        });
+    async updateVaultConnection(conn) {
+        const { id, name, setup } = conn;
+        const params = {
+            name,
+        };
+        if (!(0, lodash_1.isEmpty)(setup)) {
+            params.setup = setup;
+        }
+        const updated = await this.client.flows.vault.connections.update(id, params);
+        return updated;
+    }
+    async updateVaultConnections(updates) {
+        await this.client.pool
+            .addEachTask({
+            data: updates || [],
+            generator: (item) => this.updateVaultConnection(item)
+                .then((data) => {
+                this.didUpdate(data);
+                this.updated += 1;
+            })
+                .catch((err) => {
+                throw new Error(`Problem updating ${this.type} ${this.objString(item)}\n${err}`);
+            }),
+        })
+            .promise();
+    }
+    async deleteVaultConnection(conn) {
+        await this.client.flows.vault.connections.delete(conn.id);
     }
-    updateVaultConnections(updates) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.pool
+    async deleteVaultConnections(data) {
+        if (this.config('AUTH0_ALLOW_DELETE') === 'true' ||
+            this.config('AUTH0_ALLOW_DELETE') === true) {
+            await this.client.pool
                 .addEachTask({
-                data: updates || [],
-                generator: (item) => this.updateVaultConnection(item)
-                    .then((data) => {
-                    this.didUpdate(data);
-                    this.updated += 1;
+                data: data || [],
+                generator: (item) => this.deleteVaultConnection(item)
+                    .then(() => {
+                    this.didDelete(item);
+                    this.deleted += 1;
                 })
                     .catch((err) => {
-                    throw new Error(`Problem updating ${this.type} ${this.objString(item)}\n${err}`);
+                    throw new Error(`Problem deleting ${this.type} ${this.objString(item)}\n${err}`);
                 }),
             })
                 .promise();
-        });
-    }
-    deleteVaultConnection(conn) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.flows.deleteConnection({ id: conn.id });
-        });
-    }
-    deleteVaultConnections(data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.config('AUTH0_ALLOW_DELETE') === 'true' ||
-                this.config('AUTH0_ALLOW_DELETE') === true) {
-                yield this.client.pool
-                    .addEachTask({
-                    data: data || [],
-                    generator: (item) => this.deleteVaultConnection(item)
-                        .then(() => {
-                        this.didDelete(item);
-                        this.deleted += 1;
-                    })
-                        .catch((err) => {
-                        throw new Error(`Problem deleting ${this.type} ${this.objString(item)}\n${err}`);
-                    }),
-                })
-                    .promise();
-            }
-            else {
-                logger_1.default.warn(`Detected the following flow vault connection should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config
+        }
+        else {
+            logger_1.default.warn(`Detected the following flow vault connection should be deleted. Doing so may be destructive.\nYou can enable deletes by setting 'AUTH0_ALLOW_DELETE' to true in the config
       \n${data.map((i) => this.objString(i)).join('\n')}`);
-            }
-        });
+        }
     }
 }
 exports.default = FlowVaultHandler;
 __decorate([
     (0, default_1.order)('70')
 ], FlowVaultHandler.prototype, "processChanges", null);
-//# sourceMappingURL=flowVaultConnections.js.map

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

@@ -1,4 +1,4 @@
-import { GetFlows200ResponseOneOfInner, GetFlowsVaultConnections200ResponseOneOfInner, PostFlows201Response } from 'auth0';
+import { Management } from 'auth0';
 import DefaultHandler from './default';
 import { Asset, Assets } from '../../../types';
 export type Flow = {
@@ -25,10 +25,9 @@ export default class FlowHandler extends DefaultHandler {
     existing: Asset;
     constructor(options: DefaultHandler);
     objString(item: any): string;
-    getFlows(flows: Array<GetFlows200ResponseOneOfInner>): Promise<PostFlows201Response[]>;
+    getFlows(flows: Array<Management.FlowSummary>): Promise<Management.GetFlowResponseContent[]>;
     getType(): Promise<Asset>;
     processChanges(assets: Assets): Promise<void>;
-    getAllFlowConnections(): Promise<GetFlowsVaultConnections200ResponseOneOfInner[]>;
     formateFlowConnectionId(flows: any, connectionIdMap: any): Promise<Asset>;
     pargeFlowConnectionName(flows: any, connectionNameMap: any): Promise<Flow[]>;
 }