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

package/lib/tools/auth0/handlers/flows.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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -58,6 +49,7 @@ const default_1 = __importStar(require("./default"));
 const client_1 = require("../client");
 const logger_1 = __importDefault(require("../../../logger"));
 const utils_1 = require("../../../utils");
+const flowVaultConnections_1 = require("./flowVaultConnections");
 exports.schema = {
     type: 'array',
     items: {
@@ -72,143 +64,114 @@ exports.schema = {
 };
 class FlowHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'flows', id: 'id', stripCreateFields: ['created_at', 'updated_at', 'executed_at'], stripUpdateFields: ['created_at', 'updated_at', 'executed_at'] }));
+        super({
+            ...options,
+            type: 'flows',
+            id: 'id',
+            stripCreateFields: ['created_at', 'updated_at', 'executed_at'],
+            stripUpdateFields: ['created_at', 'updated_at', 'executed_at'],
+            functions: {
+                update: async ({ id }, bodyParams) => this.client.flows.update(id, bodyParams),
+            },
+        });
     }
     objString(item) {
         return super.objString({ id: item.id, name: item.name });
     }
-    getFlows(flows) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allFlows = yield this.client.pool
-                .addEachTask({
-                data: flows,
-                generator: ({ id }) => this.client.flows.get({ id: id }).then((response) => {
-                    if ((0, lodash_1.isEmpty)(response === null || response === void 0 ? void 0 : response.data))
-                        return null;
-                    return response.data;
-                }),
-            })
-                .promise();
-            return allFlows.filter((flow) => flow !== null);
-        });
+    async getFlows(flows) {
+        const allFlows = await this.client.pool
+            .addEachTask({
+            data: flows,
+            generator: ({ id }) => this.client.flows.get(id).then((response) => {
+                if ((0, lodash_1.isEmpty)(response))
+                    return null;
+                return response;
+            }),
+        })
+            .promise();
+        return allFlows.filter((flow) => flow !== null);
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            const [flows, allFlowConnections] = yield Promise.all([
-                (0, client_1.paginate)(this.client.flows.getAll, {
-                    paginate: true,
-                    include_totals: true,
-                }),
-                this.getAllFlowConnections(),
-            ]);
-            // get more details for each flows
-            const allFlows = yield this.getFlows(flows);
-            // create a map for id to name from allFlowConnections
-            const connectionIdMap = {};
-            allFlowConnections.forEach((c) => {
-                connectionIdMap[c.id] = c.name;
-            });
-            this.existing = yield this.formateFlowConnectionId(allFlows, connectionIdMap);
+    async getType() {
+        if (this.existing) {
             return this.existing;
+        }
+        const [flows, allFlowConnections] = await Promise.all([
+            (0, client_1.paginate)(this.client.flows.list, {
+                paginate: true,
+            }),
+            (0, flowVaultConnections_1.getAllFlowConnections)(this.client),
+        ]);
+        // get more details for each flows
+        const allFlows = await this.getFlows(flows);
+        // create a map for id to name from allFlowConnections
+        const connectionIdMap = {};
+        allFlowConnections.forEach((c) => {
+            connectionIdMap[c.id] = c.name;
         });
+        this.existing = await this.formateFlowConnectionId(allFlows, connectionIdMap);
+        return this.existing;
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
+    async processChanges(assets) {
+        const { flows } = assets;
+        // Do nothing if not set
+        if (!flows)
+            return;
+        const allFlowConnections = await (0, flowVaultConnections_1.getAllFlowConnections)(this.client);
+        // create a map for name to id from allFlowConnections
+        const connectionNameMap = {};
+        allFlowConnections.forEach((c) => {
+            connectionNameMap[c.name] = c.id;
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { flows } = assets;
-            // Do nothing if not set
-            if (!flows)
-                return;
-            const allFlowConnections = yield this.getAllFlowConnections();
-            // create a map for name to id from allFlowConnections
-            const connectionNameMap = {};
-            allFlowConnections.forEach((c) => {
-                connectionNameMap[c.name] = c.id;
-            });
-            assets.flows = yield this.pargeFlowConnectionName(flows, connectionNameMap);
-            const { del, update, create, conflicts } = yield this.calcChanges(assets);
-            const changes = {
-                del: del,
-                update: update,
-                create: create,
-                conflicts: conflicts,
-            };
-            yield _super.processChanges.call(this, assets, Object.assign({}, changes));
+        assets.flows = await this.pargeFlowConnectionName(flows, connectionNameMap);
+        const { del, update, create, conflicts } = await this.calcChanges(assets);
+        const changes = {
+            del: del,
+            update: update,
+            create: create,
+            conflicts: conflicts,
+        };
+        await super.processChanges(assets, {
+            ...changes,
         });
     }
-    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') {
-                    break;
+    async formateFlowConnectionId(flows, connectionIdMap) {
+        // replace connection_id with flow connection names
+        await Promise.all(flows.map(async (flow) => {
+            const flowConnetions = (0, utils_1.findKeyPathWithValue)(flow, 'connection_id');
+            await Promise.all(flowConnetions.map(async (f) => {
+                const connectionId = (dot_prop_1.default.get(flow, f.path) || '');
+                const flowConnectionName = connectionIdMap[connectionId];
+                if (!flowConnectionName) {
+                    logger_1.default.warn(`Flow connection: ${connectionId} not found for flow:${flow.name}, please verify the flow connection id.`);
                 }
-                allFlowConnections.push(...connections);
-                page += 1;
-                if (allFlowConnections.length === total) {
-                    break;
+                else {
+                    dot_prop_1.default.set(flow, f.path, flowConnectionName);
                 }
-            }
-            return allFlowConnections;
-        });
+            }));
+            return flow;
+        }));
+        return flows;
     }
-    formateFlowConnectionId(flows, connectionIdMap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // replace connection_id with flow connection names
-            yield Promise.all(flows.map((flow) => __awaiter(this, void 0, void 0, function* () {
-                const flowConnetions = (0, utils_1.findKeyPathWithValue)(flow, 'connection_id');
-                yield Promise.all(flowConnetions.map((f) => __awaiter(this, void 0, void 0, function* () {
-                    const connectionId = (dot_prop_1.default.get(flow, f.path) || '');
-                    const flowConnectionName = connectionIdMap[connectionId];
-                    if (!flowConnectionName) {
-                        logger_1.default.warn(`Flow connection: ${connectionId} not found for flow:${flow.name}, please verify the flow connection id.`);
-                    }
-                    else {
-                        dot_prop_1.default.set(flow, f.path, flowConnectionName);
-                    }
-                })));
-                return flow;
-            })));
-            return flows;
-        });
-    }
-    pargeFlowConnectionName(flows, connectionNameMap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // replace connection_id with flow connection names
-            const parsedFlows = yield Promise.all(flows.map((flow) => __awaiter(this, void 0, void 0, function* () {
-                const flowConnetions = (0, utils_1.findKeyPathWithValue)(flow, 'connection_id');
-                yield Promise.all(flowConnetions.map((f) => __awaiter(this, void 0, void 0, function* () {
-                    const connectionName = (dot_prop_1.default.get(flow, f.path) || '');
-                    const flowConnectionId = connectionNameMap[connectionName];
-                    if (!flowConnectionId) {
-                        logger_1.default.error(`Flow connection: ${flowConnectionId} not found for flow:${flow.name}, please verify the flow connection name.`);
-                    }
-                    else {
-                        dot_prop_1.default.set(flow, f.path, flowConnectionId);
-                    }
-                })));
-                return flow;
-            })));
-            return parsedFlows;
-        });
+    async pargeFlowConnectionName(flows, connectionNameMap) {
+        // replace connection_id with flow connection names
+        const parsedFlows = await Promise.all(flows.map(async (flow) => {
+            const flowConnetions = (0, utils_1.findKeyPathWithValue)(flow, 'connection_id');
+            await Promise.all(flowConnetions.map(async (f) => {
+                const connectionName = (dot_prop_1.default.get(flow, f.path) || '');
+                const flowConnectionId = connectionNameMap[connectionName];
+                if (!flowConnectionId) {
+                    logger_1.default.error(`Flow connection: ${flowConnectionId} not found for flow:${flow.name}, please verify the flow connection name.`);
+                }
+                else {
+                    dot_prop_1.default.set(flow, f.path, flowConnectionId);
+                }
+            }));
+            return flow;
+        }));
+        return parsedFlows;
     }
 }
 exports.default = FlowHandler;
 __decorate([
     (0, default_1.order)('80')
 ], FlowHandler.prototype, "processChanges", null);
-//# sourceMappingURL=flows.js.map

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

@@ -1,11 +1,11 @@
-import { PostForms201Response } from 'auth0';
+import { Management } from 'auth0';
 import DefaultHandler from './default';
 import { Asset, Assets } from '../../../types';
 export type Form = {
     name: string;
     body: string;
 };
-export type FormResponse = PostForms201Response;
+export type FormResponse = Management.GetFormResponseContent;
 export declare const schema: {
     type: string;
     items: {
@@ -26,7 +26,7 @@ export default class FormsHandler extends DefaultHandler {
     existing: Asset;
     constructor(options: DefaultHandler);
     objString(item: any): string;
-    getForms(forms: Array<PostForms201Response>): Promise<PostForms201Response[]>;
+    getForms(forms: Array<Management.FormSummary>): Promise<Management.GetFormResponseContent[]>;
     getType(): Promise<Asset>;
     formateFormFlowId(forms: any, flowIdMap: any): Promise<Asset>;
     pargeFormFlowName(forms: any, flowNameMap: any): Promise<Form[]>;

package/lib/tools/auth0/handlers/forms.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());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -72,119 +63,115 @@ exports.schema = {
 };
 class FormsHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'forms', id: 'id', stripCreateFields: ['created_at', 'updated_at', 'submitted_at', 'embedded_at'], stripUpdateFields: ['created_at', 'updated_at', 'submitted_at', 'embedded_at'] }));
+        super({
+            ...options,
+            type: 'forms',
+            id: 'id',
+            stripCreateFields: ['created_at', 'updated_at', 'submitted_at', 'embedded_at'],
+            stripUpdateFields: ['created_at', 'updated_at', 'submitted_at', 'embedded_at'],
+            functions: {
+                update: async ({ id }, bodyParams) => this.client.forms.update(id, bodyParams),
+            },
+        });
     }
     objString(item) {
         return super.objString({ id: item.id, name: item.name });
     }
-    getForms(forms) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const allForms = yield this.client.pool
-                .addEachTask({
-                data: forms,
-                generator: ({ id }) => this.client.forms.get({ id: id }).then((response) => {
-                    if ((0, lodash_1.isEmpty)(response === null || response === void 0 ? void 0 : response.data))
-                        return null;
-                    return response.data;
-                }),
-            })
-                .promise();
-            return allForms.filter((form) => form !== null);
-        });
+    async getForms(forms) {
+        const allForms = await this.client.pool
+            .addEachTask({
+            data: forms,
+            generator: ({ id }) => this.client.forms.get(id).then((response) => {
+                if ((0, lodash_1.isEmpty)(response))
+                    return null;
+                return response;
+            }),
+        })
+            .promise();
+        return allForms.filter((form) => form !== null);
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            const [forms, flows] = yield Promise.all([
-                (0, client_1.paginate)(this.client.forms.getAll, {
-                    paginate: true,
-                    include_totals: true,
-                }),
-                (0, client_1.paginate)(this.client.flows.getAll, {
-                    paginate: true,
-                    include_totals: true,
-                }),
-            ]);
-            // get more details for each form
-            const allForms = yield this.getForms(forms);
-            // create a map for id to name from allFlows
-            const flowIdMap = {};
-            flows.forEach((f) => {
-                flowIdMap[f.id] = f.name;
-            });
-            this.existing = yield this.formateFormFlowId(allForms, flowIdMap);
+    async getType() {
+        if (this.existing) {
             return this.existing;
+        }
+        const [forms, flows] = await Promise.all([
+            (0, client_1.paginate)(this.client.forms.list, {
+                paginate: true,
+            }),
+            (0, client_1.paginate)(this.client.flows.list, {
+                paginate: true,
+            }),
+        ]);
+        // get more details for each form
+        const allForms = await this.getForms(forms);
+        // create a map for id to name from allFlows
+        const flowIdMap = {};
+        flows.forEach((f) => {
+            flowIdMap[f.id] = f.name;
         });
+        this.existing = await this.formateFormFlowId(allForms, flowIdMap);
+        return this.existing;
     }
-    formateFormFlowId(forms, flowIdMap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // replace flow_id with flow names
-            yield Promise.all(forms.map((form) => __awaiter(this, void 0, void 0, function* () {
-                const flows = (0, utils_1.findKeyPathWithValue)(form, 'flow_id');
-                yield Promise.all(flows.map((f) => __awaiter(this, void 0, void 0, function* () {
-                    const flowId = (dot_prop_1.default.get(form, f.path) || '');
-                    const flowName = flowIdMap[flowId];
-                    if (!flowName) {
-                        logger_1.default.warn(`Flow: ${flowId} not found for form:${form.name}, please verify the flow id.`);
-                    }
-                    else {
-                        dot_prop_1.default.set(form, f.path, flowName);
-                    }
-                })));
-                return form;
-            })));
-            return forms;
-        });
+    async formateFormFlowId(forms, flowIdMap) {
+        // replace flow_id with flow names
+        await Promise.all(forms.map(async (form) => {
+            const flows = (0, utils_1.findKeyPathWithValue)(form, 'flow_id');
+            await Promise.all(flows.map(async (f) => {
+                const flowId = (dot_prop_1.default.get(form, f.path) || '');
+                const flowName = flowIdMap[flowId];
+                if (!flowName) {
+                    logger_1.default.warn(`Flow: ${flowId} not found for form:${form.name}, please verify the flow id.`);
+                }
+                else {
+                    dot_prop_1.default.set(form, f.path, flowName);
+                }
+            }));
+            return form;
+        }));
+        return forms;
     }
-    pargeFormFlowName(forms, flowNameMap) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // replace flow names with flow_id
-            yield Promise.all(forms.map((form) => __awaiter(this, void 0, void 0, function* () {
-                const flows = (0, utils_1.findKeyPathWithValue)(form, 'flow_id');
-                yield Promise.all(flows.map((f) => __awaiter(this, void 0, void 0, function* () {
-                    const flowName = (dot_prop_1.default.get(form, f.path) || '');
-                    const flowId = flowNameMap[flowName];
-                    if (!flowId) {
-                        logger_1.default.error(`Flow: ${flowName} not found for form:${form.name}, please verify the flow name.`);
-                    }
-                    else {
-                        dot_prop_1.default.set(form, f.path, flowNameMap[flowName]);
-                    }
-                })));
-                return form;
-            })));
-            return forms;
-        });
+    async pargeFormFlowName(forms, flowNameMap) {
+        // replace flow names with flow_id
+        await Promise.all(forms.map(async (form) => {
+            const flows = (0, utils_1.findKeyPathWithValue)(form, 'flow_id');
+            await Promise.all(flows.map(async (f) => {
+                const flowName = (dot_prop_1.default.get(form, f.path) || '');
+                const flowId = flowNameMap[flowName];
+                if (!flowId) {
+                    logger_1.default.error(`Flow: ${flowName} not found for form:${form.name}, please verify the flow name.`);
+                }
+                else {
+                    dot_prop_1.default.set(form, f.path, flowNameMap[flowName]);
+                }
+            }));
+            return form;
+        }));
+        return forms;
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
+    async processChanges(assets) {
+        const { forms } = assets;
+        // Do nothing if not set
+        if (!forms)
+            return;
+        const flows = await (0, client_1.paginate)(this.client.flows.list, {
+            paginate: true,
+            include_totals: true,
         });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { forms } = assets;
-            // Do nothing if not set
-            if (!forms)
-                return;
-            const flows = yield (0, client_1.paginate)(this.client.flows.getAll, {
-                paginate: true,
-                include_totals: true,
-            });
-            // create a map for id to name from flows
-            const flowNamMap = {};
-            flows.forEach((f) => {
-                flowNamMap[f.name] = f.id;
-            });
-            assets.forms = yield this.pargeFormFlowName(forms, flowNamMap);
-            const { del, update, create, conflicts } = yield this.calcChanges(assets);
-            const changes = {
-                del: del,
-                update: update,
-                create: create,
-                conflicts: conflicts,
-            };
-            yield _super.processChanges.call(this, assets, Object.assign({}, changes));
+        // create a map for id to name from flows
+        const flowNamMap = {};
+        flows.forEach((f) => {
+            flowNamMap[f.name] = f.id;
+        });
+        assets.forms = await this.pargeFormFlowName(forms, flowNamMap);
+        const { del, update, create, conflicts } = await this.calcChanges(assets);
+        const changes = {
+            del: del,
+            update: update,
+            create: create,
+            conflicts: conflicts,
+        };
+        await super.processChanges(assets, {
+            ...changes,
         });
     }
 }
@@ -192,4 +179,3 @@ exports.default = FormsHandler;
 __decorate([
     (0, default_1.order)('90')
 ], FormsHandler.prototype, "processChanges", null);
-//# sourceMappingURL=forms.js.map