auth0-deploy-cli 8.22.0 → 8.23.0

package/lib/tools/auth0/handlers/triggers.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 };
 };
@@ -79,81 +70,74 @@ function isActionsDisabled(err) {
 }
 class TriggersHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'triggers', id: 'name' }));
+        super({
+            ...options,
+            type: 'triggers',
+            id: 'name',
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
-                return this.existing;
-            }
-            // in case client version does not support actions
-            if (!this.client.actions || typeof this.client.actions.getAllTriggers !== 'function') {
-                return [];
-            }
-            const triggerBindings = {};
-            try {
-                const res = yield this.client.actions.getAllTriggers();
-                const triggers = (0, lodash_1.default)(res.data.triggers).map('id').uniq().value();
-                for (let i = 0; i < triggers.length; i++) {
-                    const triggerId = triggers[i];
-                    let bindings;
-                    try {
-                        const { data } = yield this.client.actions.getTriggerBindings({
-                            triggerId: triggerId,
-                        });
-                        bindings = data === null || data === void 0 ? void 0 : data.bindings;
-                    }
-                    catch (err) {
-                        logger_1.default.warn(`${err.message} (trigger: ${triggerId}). Skipping this trigger and continuing.`);
-                        continue;
-                    }
-                    if (bindings && bindings.length > 0) {
-                        triggerBindings[triggerId] = bindings.map((binding) => ({
-                            action_name: binding.action.name,
-                            display_name: binding.display_name,
-                        }));
-                    }
+    async getType() {
+        if (this.existing) {
+            return this.existing;
+        }
+        const triggerBindings = {};
+        try {
+            const res = await this.client.actions.triggers.list();
+            const triggers = (0, lodash_1.default)(res?.triggers).map('id').uniq().value();
+            for (let i = 0; i < triggers.length; i++) {
+                const triggerId = triggers[i];
+                let bindings;
+                try {
+                    const { data } = await this.client.actions.triggers.bindings.list(triggerId);
+                    bindings = data;
                 }
-                this.existing = triggerBindings;
-                return this.existing;
-            }
-            catch (err) {
-                if (err.statusCode === 404 || err.statusCode === 501) {
-                    return [];
+                catch (err) {
+                    logger_1.default.warn(`${err.message} (trigger: ${triggerId}). Skipping this trigger and continuing.`);
+                    bindings = null;
                 }
-                if (isActionsDisabled(err)) {
-                    logger_1.default.info('Skipping triggers because Actions is not enabled.');
-                    return {};
+                if (bindings && bindings.length > 0) {
+                    triggerBindings[triggerId] = bindings.map((binding) => ({
+                        action_name: binding.action.name,
+                        display_name: binding.display_name,
+                    }));
                 }
-                throw err;
             }
-        });
+            this.existing = triggerBindings;
+            return this.existing;
+        }
+        catch (err) {
+            if (err.statusCode === 404 || err.statusCode === 501) {
+                return [];
+            }
+            if (isActionsDisabled(err)) {
+                logger_1.default.info('Skipping triggers because Actions is not enabled.');
+                return {};
+            }
+            throw err;
+        }
     }
-    processChanges(assets) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // No API to delete or create triggers, we can only update.
-            const { triggers } = assets;
-            // Do nothing if not set
-            if (!triggers)
-                return;
-            yield (0, utils_1.sleep)(2000); // Delay to allow newly-deployed actions to register in backend
-            yield Promise.all(Object.entries(triggers).map((_a) => __awaiter(this, [_a], void 0, function* ([name, data]) {
-                const bindings = data.map((binding) => ({
-                    ref: {
-                        type: 'action_name',
-                        value: binding.action_name,
-                    },
-                    display_name: binding.display_name,
-                }));
-                yield this.client.actions.updateTriggerBindings({ triggerId: name }, { bindings });
-                this.didUpdate({ trigger_id: name });
-                this.updated += 1;
-            })));
-        });
+    async processChanges(assets) {
+        // No API to delete or create triggers, we can only update.
+        const { triggers } = assets;
+        // Do nothing if not set
+        if (!triggers)
+            return;
+        await (0, utils_1.sleep)(2000); // Delay to allow newly-deployed actions to register in backend
+        await Promise.all(Object.entries(triggers).map(async ([name, data]) => {
+            const bindings = data.map((binding) => ({
+                ref: {
+                    type: 'action_name',
+                    value: binding.action_name,
+                },
+                display_name: binding.display_name,
+            }));
+            await this.client.actions.triggers.bindings.updateMany(name, { bindings });
+            this.didUpdate({ trigger_id: name });
+            this.updated += 1;
+        }));
     }
 }
 exports.default = TriggersHandler;
 __decorate([
     (0, default_1.order)('80')
 ], TriggersHandler.prototype, "processChanges", null);
-//# sourceMappingURL=triggers.js.map

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

@@ -1,6 +1,7 @@
-import { UserAttributeProfile } from 'auth0';
+import { Management } from 'auth0';
 import DefaultAPIHandler from './default';
 import { Assets, Auth0APIClient } from '../../../types';
+export type UserAttributeProfile = Management.UserAttributeProfile;
 export declare const schema: {
     type: string;
     items: {
@@ -117,6 +118,6 @@ export declare const getUserAttributeProfiles: (auth0Client: Auth0APIClient) =>
 export default class UserAttributeProfilesHandler extends DefaultAPIHandler {
     existing: UserAttributeProfile[];
     constructor(options: DefaultAPIHandler);
-    getType(): Promise<UserAttributeProfile[]>;
+    getType(): Promise<Management.UserAttributeProfile[]>;
     processChanges(assets: Assets): Promise<void>;
 }

package/lib/tools/auth0/handlers/userAttributeProfiles.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 };
 };
@@ -60,7 +51,9 @@ const strategies = ['pingfederate', 'ad', 'adfs', 'waad', 'google-apps', 'okta',
 const strategyOverrides = {
     type: 'object',
     additionalProperties: false,
-    properties: strategies.reduce((acc, curr) => (Object.assign(Object.assign({}, acc), { [curr]: {
+    properties: strategies.reduce((acc, curr) => ({
+        ...acc,
+        [curr]: {
             type: 'object',
             additionalProperties: false,
             properties: {
@@ -96,7 +89,8 @@ const strategyOverrides = {
                     maxLength: 128,
                 },
             },
-        } })), {}),
+        },
+    }), {}),
 };
 exports.schema = {
     type: 'array',
@@ -131,7 +125,9 @@ exports.schema = {
                     },
                     strategy_overrides: {
                         type: 'object',
-                        properties: strategies.reduce((acc, curr) => (Object.assign(Object.assign({}, acc), { [curr]: {
+                        properties: strategies.reduce((acc, curr) => ({
+                            ...acc,
+                            [curr]: {
                                 type: 'object',
                                 additionalProperties: false,
                                 properties: {
@@ -154,7 +150,8 @@ exports.schema = {
                                         default: 'externalId',
                                     },
                                 },
-                            } })), {}),
+                            },
+                        }), {}),
                     },
                 },
             },
@@ -229,9 +226,9 @@ exports.schema = {
         },
     },
 };
-const getUserAttributeProfiles = (auth0Client) => __awaiter(void 0, void 0, void 0, function* () {
+const getUserAttributeProfiles = async (auth0Client) => {
     try {
-        const userAttributeProfiles = yield (0, client_1.paginate)(auth0Client.userAttributeProfiles.getAll, {
+        const userAttributeProfiles = await (0, client_1.paginate)(auth0Client.userAttributeProfiles.list, {
             checkpoint: true,
             include_totals: true,
             is_global: false,
@@ -249,44 +246,45 @@ const getUserAttributeProfiles = (auth0Client) => __awaiter(void 0, void 0, void
         }
         throw err;
     }
-});
+};
 exports.getUserAttributeProfiles = getUserAttributeProfiles;
 class UserAttributeProfilesHandler extends default_1.default {
     constructor(options) {
-        super(Object.assign(Object.assign({}, options), { type: 'userAttributeProfiles', id: 'id', identifiers: ['id', 'name'], stripUpdateFields: ['id'] }));
+        super({
+            ...options,
+            type: 'userAttributeProfiles',
+            id: 'id',
+            identifiers: ['id', 'name'],
+            stripUpdateFields: ['id'],
+            functions: {
+                update: async (params, payload) => this.client.userAttributeProfiles.update(params?.id, payload),
+            },
+        });
     }
-    getType() {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing)
-                return this.existing;
-            this.existing = yield (0, exports.getUserAttributeProfiles)(this.client);
+    async getType() {
+        if (this.existing)
             return this.existing;
-        });
+        this.existing = await (0, exports.getUserAttributeProfiles)(this.client);
+        return this.existing;
     }
-    processChanges(assets) {
-        const _super = Object.create(null, {
-            processChanges: { get: () => super.processChanges }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            const { userAttributeProfiles } = assets;
-            // Do nothing if not set
-            if (!userAttributeProfiles)
-                return;
-            const existing = yield this.getType();
-            const changes = (0, calculateChanges_1.calculateChanges)({
-                handler: this,
-                assets: userAttributeProfiles,
-                existing,
-                identifiers: this.identifiers,
-                allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
-            });
-            logger_1.default.debug(`Start processChanges for userAttributeProfile [delete:${changes.del.length}] [update:${changes.update.length}], [create:${changes.create.length}]`);
-            yield _super.processChanges.call(this, assets, changes);
+    async processChanges(assets) {
+        const { userAttributeProfiles } = assets;
+        // Do nothing if not set
+        if (!userAttributeProfiles)
+            return;
+        const existing = await this.getType();
+        const changes = (0, calculateChanges_1.calculateChanges)({
+            handler: this,
+            assets: userAttributeProfiles,
+            existing,
+            identifiers: this.identifiers,
+            allowDelete: !!this.config('AUTH0_ALLOW_DELETE'),
         });
+        logger_1.default.debug(`Start processChanges for userAttributeProfile [delete:${changes.del.length}] [update:${changes.update.length}], [create:${changes.create.length}]`);
+        await super.processChanges(assets, changes);
     }
 }
 exports.default = UserAttributeProfilesHandler;
 __decorate([
     (0, default_1.order)('50')
 ], UserAttributeProfilesHandler.prototype, "processChanges", null);
-//# sourceMappingURL=userAttributeProfiles.js.map

package/lib/tools/auth0/index.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 };
 };
@@ -30,11 +21,10 @@ function sortByOrder(toSort, stage) {
     const defaultOrder = 50;
     const sorted = [...toSort];
     sorted.sort((a, b) => {
-        var _a, _b;
         // @ts-ignore because stage methods may have order property
-        const aOrder = ((_a = a[stage]) === null || _a === void 0 ? void 0 : _a.order) || defaultOrder;
+        const aOrder = a[stage]?.order || defaultOrder;
         // @ts-ignore because stage methods may have order property
-        const bOrder = ((_b = b[stage]) === null || _b === void 0 ? void 0 : _b.order) || defaultOrder;
+        const bOrder = b[stage]?.order || defaultOrder;
         return aOrder - bOrder;
     });
     return sorted;
@@ -62,47 +52,44 @@ class Auth0 {
             return onlyIncludedAssetTypes.includes(handler.type);
         });
     }
-    runStage(stage) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Sort by priority
-            for (const handler of sortByOrder(this.handlers, stage)) {
-                // eslint-disable-line
-                try {
-                    const stageFn = Object.getPrototypeOf(handler)[stage];
-                    this.assets = Object.assign(Object.assign({}, this.assets), ((yield stageFn.apply(handler, [this.assets])) || {}));
-                }
-                catch (err) {
-                    err.type = handler.type;
-                    err.stage = stage;
-                    throw err;
+    async runStage(stage) {
+        // Sort by priority
+        for (const handler of sortByOrder(this.handlers, stage)) {
+            // eslint-disable-line
+            try {
+                const stageFn = Object.getPrototypeOf(handler)[stage];
+                if (typeof stageFn !== 'function') {
+                    throw new Error(`Handler ${handler.type} does not have a ${stage} method or it is not a function (got ${typeof stageFn})`);
                 }
+                this.assets = {
+                    ...this.assets,
+                    ...((await stageFn.apply(handler, [this.assets])) || {}),
+                };
             }
-        });
-    }
-    validate() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const ajv = new ajv_1.default({ useDefaults: true, nullable: true });
-            const nonNullAssets = Object.keys(this.assets)
-                .filter((k) => this.assets[k] != null)
-                .reduce((a, k) => (Object.assign(Object.assign({}, a), { [k]: this.assets[k] })), {});
-            const valid = ajv.validate(schema_1.default, nonNullAssets);
-            if (!valid) {
-                throw new Error(`Schema validation failed loading ${JSON.stringify(ajv.errors, null, 4)}`);
+            catch (err) {
+                err.type = handler.type;
+                err.stage = stage;
+                throw err;
             }
-            yield this.runStage('validate');
-        });
+        }
     }
-    loadAssetsFromAuth0() {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Populate assets from auth0 tenant
-            yield this.runStage('load');
-        });
+    async validate() {
+        const ajv = new ajv_1.default({ useDefaults: true, nullable: true });
+        const nonNullAssets = Object.keys(this.assets)
+            .filter((k) => this.assets[k] != null)
+            .reduce((a, k) => ({ ...a, [k]: this.assets[k] }), {});
+        const valid = ajv.validate(schema_1.default, nonNullAssets);
+        if (!valid) {
+            throw new Error(`Schema validation failed loading ${JSON.stringify(ajv.errors, null, 4)}`);
+        }
+        await this.runStage('validate');
     }
-    processChanges() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.runStage('processChanges');
-        });
+    async loadAssetsFromAuth0() {
+        // Populate assets from auth0 tenant
+        await this.runStage('load');
+    }
+    async processChanges() {
+        await this.runStage('processChanges');
     }
 }
 exports.default = Auth0;
-//# sourceMappingURL=index.js.map

package/lib/tools/auth0/schema.js

@@ -17,11 +17,13 @@ const excludeSchema = Object.entries(handlers_1.default).reduce((map, [name, obj
 exports.default = {
     type: 'object',
     $schema: 'http://json-schema.org/draft-07/schema#',
-    properties: Object.assign(Object.assign({}, typesSchema), { exclude: {
+    properties: {
+        ...typesSchema,
+        exclude: {
             type: 'object',
-            properties: Object.assign({}, excludeSchema),
+            properties: { ...excludeSchema },
             default: {},
-        } }),
+        },
+    },
     additionalProperties: false,
 };
-//# sourceMappingURL=schema.js.map

package/lib/tools/calculateChanges.js

@@ -16,7 +16,7 @@ const logger_1 = __importDefault(require("../logger"));
  * @returns T
  */
 function processChangedObjectFields({ handler, desiredAssetState, currentAssetState, allowDelete, }) {
-    const desiredAssetStateWithChanges = Object.assign({}, desiredAssetState);
+    const desiredAssetStateWithChanges = { ...desiredAssetState };
     // eslint-disable-next-line no-restricted-syntax
     for (const fieldName of handler.objectFields) {
         const areDesiredStateAndCurrentStateEmpty = Object.keys(desiredAssetState[fieldName] || {}).length === 0 &&
@@ -98,18 +98,25 @@ function calculateChanges({ handler, assets, existing, identifiers = ['id', 'nam
                     // Delete from create as it's an update
                     create = create.filter((e) => e !== asset);
                     // Append identifiers to asset
-                    update.push(Object.assign(Object.assign({}, identifiers.reduce((obj, i) => {
-                        if (found[i])
-                            obj[i] = found[i];
-                        return obj;
-                    }, {})), (handler.objectFields.length
-                        ? processChangedObjectFields({
-                            handler,
-                            desiredAssetState: asset,
-                            currentAssetState: found,
-                            allowDelete,
-                        })
-                        : asset)));
+                    update.push({
+                        ...identifiers.reduce((obj, i) => {
+                            if (found[i])
+                                obj[i] = found[i];
+                            return obj;
+                        }, {}),
+                        // If we have any object fields, we need to make sure that they get
+                        // special treatment. When different metadata objects are passed to APIv2
+                        // properties must explicitly be marked for deletion by indicating a `null`
+                        // value.
+                        ...(handler.objectFields.length
+                            ? processChangedObjectFields({
+                                handler,
+                                desiredAssetState: asset,
+                                currentAssetState: found,
+                                allowDelete,
+                            })
+                            : asset),
+                    });
                 }
             }
         });
@@ -134,7 +141,10 @@ function calculateChanges({ handler, assets, existing, identifiers = ['id', 'nam
                 const conflict = (existing || []).filter((e) => e.name === a.name && e[uniqueID] !== a[uniqueID])[0];
                 if (conflict) {
                     const temp = Math.random().toString(36).substr(2, 5);
-                    conflicts.push(Object.assign(Object.assign({}, conflict), { name: `${conflict.name}-${temp}` }));
+                    conflicts.push({
+                        ...conflict,
+                        name: `${conflict.name}-${temp}`,
+                    });
                 }
             }
         });
@@ -146,4 +156,3 @@ function calculateChanges({ handler, assets, existing, identifiers = ['id', 'nam
         create,
     };
 }
-//# sourceMappingURL=calculateChanges.js.map

package/lib/tools/constants.d.ts

@@ -1,4 +1,4 @@
-import { GetEmailTemplatesByTemplateNameTemplateNameEnum } from 'auth0';
+import { Management } from 'auth0';
 declare const constants: {
     CONCURRENT_CALLS: number;
     RULES_DIRECTORY: string;
@@ -18,7 +18,7 @@ declare const constants: {
     DATABASE_CONNECTIONS_DIRECTORY: string;
     DATABASE_SCRIPTS_CHANGE_EMAIL: string;
     DATABASE_SCRIPTS_GET_USER: string;
-    EMAIL_TEMPLATES_TYPES: GetEmailTemplatesByTemplateNameTemplateNameEnum[];
+    EMAIL_TEMPLATES_TYPES: Management.EmailTemplateNameEnum[];
     ACTIONS_TRIGGERS: string[];
     EMAIL_TEMPLATES_DIRECTORY: string;
     EMAIL_VERIFY: string;
@@ -47,6 +47,7 @@ declare const constants: {
     CLIENTS_GRANTS_DIRECTORY: string;
     BRANDING_DIRECTORY: string;
     PHONE_PROVIDER_DIRECTORY: string;
+    PHONE_TEMPLATES_DIRECTORY: string;
     BRANDING_TEMPLATES_DIRECTORY: string;
     BRANDING_TEMPLATES_YAML_DIRECTORY: string;
     CLIENTS_CLIENT_NAME: string;
@@ -85,5 +86,6 @@ declare const constants: {
     NETWORK_ACLS_DIRECTORY: string;
     USER_ATTRIBUTE_PROFILES_DIRECTORY: string;
     CONNECTION_PROFILES_DIRECTORY: string;
+    TOKEN_EXCHANGE_PROFILES_DIRECTORY: string;
 };
 export default constants;

package/lib/tools/constants.js

@@ -64,6 +64,7 @@ const constants = {
         'post-change-password',
         'send-phone-message',
         'password-reset-post-challenge',
+        'custom-token-exchange',
     ],
     EMAIL_TEMPLATES_DIRECTORY: 'emails',
     EMAIL_VERIFY,
@@ -92,6 +93,7 @@ const constants = {
     CLIENTS_GRANTS_DIRECTORY: 'grants',
     BRANDING_DIRECTORY: 'branding',
     PHONE_PROVIDER_DIRECTORY: 'phone-providers',
+    PHONE_TEMPLATES_DIRECTORY: 'phone-templates',
     BRANDING_TEMPLATES_DIRECTORY: 'templates',
     BRANDING_TEMPLATES_YAML_DIRECTORY: 'branding_templates',
     CLIENTS_CLIENT_NAME: 'clients',
@@ -212,6 +214,6 @@ const constants = {
     NETWORK_ACLS_DIRECTORY: 'network-acls',
     USER_ATTRIBUTE_PROFILES_DIRECTORY: 'user-attribute-profiles',
     CONNECTION_PROFILES_DIRECTORY: 'connection-profiles',
+    TOKEN_EXCHANGE_PROFILES_DIRECTORY: 'token-exchange-profiles',
 };
 exports.default = constants;
-//# sourceMappingURL=constants.js.map

package/lib/tools/deploy.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 };
 };
@@ -15,24 +6,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = deploy;
 const auth0_1 = __importDefault(require("./auth0"));
 const logger_1 = __importDefault(require("../logger"));
-function deploy(assets, client, config) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // Setup log level
-        logger_1.default.level = process.env.AUTH0_DEBUG === 'true' ? 'debug' : 'info';
-        logger_1.default.info(`Getting access token for ${config('AUTH0_CLIENT_ID') !== undefined ? `${config('AUTH0_CLIENT_ID')}/` : ''}${config('AUTH0_DOMAIN')}`);
-        const auth0 = new auth0_1.default(client, assets, config);
-        // Validate Assets
-        yield auth0.validate();
-        // Process changes
-        yield auth0.processChanges();
-        return auth0.handlers.reduce((accum, h) => {
-            accum[h.type] = {
-                deleted: h.deleted,
-                created: h.created,
-                updated: h.updated,
-            };
-            return accum;
-        }, {});
-    });
+async function deploy(assets, client, config) {
+    // Setup log level
+    logger_1.default.level = process.env.AUTH0_DEBUG === 'true' ? 'debug' : 'info';
+    logger_1.default.info(`Getting access token for ${config('AUTH0_CLIENT_ID') !== undefined ? `${config('AUTH0_CLIENT_ID')}/` : ''}${config('AUTH0_DOMAIN')}`);
+    const auth0 = new auth0_1.default(client, assets, config);
+    // Validate Assets
+    await auth0.validate();
+    // Process changes
+    await auth0.processChanges();
+    return auth0.handlers.reduce((accum, h) => {
+        accum[h.type] = {
+            deleted: h.deleted,
+            created: h.created,
+            updated: h.updated,
+        };
+        return accum;
+    }, {});
 }
-//# sourceMappingURL=deploy.js.map