auth0-deploy-cli 7.5.2 → 7.7.1

package/lib/sessionDurationsToMinutes.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sessionDurationsToMinutes = void 0;
+function hoursToMinutes(hours) {
+    return Math.round(hours * 60);
+}
+const sessionDurationsToMinutes = ({ session_lifetime, idle_session_lifetime, }) => {
+    const sessionDurations = {};
+    if (!!session_lifetime)
+        sessionDurations.session_lifetime_in_minutes = hoursToMinutes(session_lifetime);
+    if (!!idle_session_lifetime)
+        sessionDurations.idle_session_lifetime_in_minutes = hoursToMinutes(idle_session_lifetime);
+    return sessionDurations;
+};
+exports.sessionDurationsToMinutes = sessionDurationsToMinutes;

package/lib/tools/auth0/client.js

@@ -33,7 +33,7 @@ const API_FREQUENCY_PER_SECOND = 8;
 const MAX_PAGE_SIZE = 100;
 function getEntity(rsp) {
     const found = Object.values(rsp).filter((a) => Array.isArray(a));
-    if (found.length === 1) {
+    if (Array.isArray(found) && found.length === 1) {
         return found[0];
     }
     throw new Error('There was an error trying to find the entity within paginate');
@@ -48,7 +48,7 @@ function checkpointPaginator(client, target, name) {
             const { total } = yield client.pool
                 .addSingleTask({
                 data: newArgs,
-                generator: (requestArgs) => target[name](requestArgs)
+                generator: (requestArgs) => target[name](requestArgs),
             })
                 .promise();
             let done = false;
@@ -58,7 +58,7 @@ function checkpointPaginator(client, target, name) {
                 const rsp = yield client.pool
                     .addSingleTask({
                     data: newArgs,
-                    generator: (requestArgs) => target[name](requestArgs)
+                    generator: (requestArgs) => target[name](requestArgs),
                 })
                     .promise();
                 data.push(...getEntity(rsp));
@@ -92,7 +92,7 @@ function pagePaginator(client, target, name) {
             const rsp = yield client.pool
                 .addSingleTask({
                 data: lodash_1.default.cloneDeep(newArgs),
-                generator: (pageArgs) => target[name](...pageArgs)
+                generator: (pageArgs) => target[name](...pageArgs),
             })
                 .promise();
             data.push(...getEntity(rsp));
@@ -107,7 +107,7 @@ function pagePaginator(client, target, name) {
                         const pageArgs = lodash_1.default.cloneDeep(newArgs);
                         pageArgs[0].page = page + 1;
                         return target[name](...pageArgs).then((r) => getEntity(r));
-                    }
+                    },
                 })
                     .promise();
                 data.push(...(0, utils_1.flatten)(pages));
@@ -142,16 +142,16 @@ function pagedManager(client, manager) {
                 return pagedManager(client, nestedManager);
             }
             return nestedManager;
-        }
+        },
     });
 }
 // Warp around the ManagementClient and detect when requesting specific pages to return all
 function pagedClient(client) {
-    client.pool = new promise_pool_executor_1.PromisePoolExecutor({
-        concurrencyLimit: API_CONCURRENCY,
-        frequencyLimit: API_FREQUENCY_PER_SECOND,
-        frequencyWindow: 1000 // 1 sec
-    });
-    return pagedManager(client, client);
+    const clientWithPooling = Object.assign(Object.assign({}, client), { pool: new promise_pool_executor_1.PromisePoolExecutor({
+            concurrencyLimit: API_CONCURRENCY,
+            frequencyLimit: API_FREQUENCY_PER_SECOND,
+            frequencyWindow: 1000, // 1 sec
+        }) });
+    return pagedManager(clientWithPooling, clientWithPooling);
 }
 exports.default = pagedClient;

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

@@ -65,9 +65,9 @@ exports.schema = {
                     properties: {
                         name: { type: 'string' },
                         version: { type: 'string' },
-                        registry_url: { type: 'string' }
-                    }
-                }
+                        registry_url: { type: 'string' },
+                    },
+                },
             },
             secrets: {
                 type: 'array',
@@ -76,9 +76,9 @@ exports.schema = {
                     properties: {
                         name: { type: 'string' },
                         value: { type: 'string' },
-                        updated_at: { type: 'string', format: 'date-time' }
-                    }
-                }
+                        updated_at: { type: 'string', format: 'date-time' },
+                    },
+                },
             },
             name: { type: 'string', default: '' },
             supported_triggers: {
@@ -88,31 +88,28 @@ exports.schema = {
                     properties: {
                         id: { type: 'string', default: '' },
                         version: { type: 'string' },
-                        url: { type: 'string' }
-                    }
-                }
+                        url: { type: 'string' },
+                    },
+                },
             },
             deployed: { type: 'boolean' },
-            status: { type: 'string' }
-        }
-    }
+            status: { type: 'string' },
+        },
+    },
 };
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function isActionsDisabled(err) {
     const errorBody = lodash_1.default.get(err, 'originalError.response.body') || {};
-    return (err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled');
+    return err.statusCode === 403 && errorBody.errorCode === 'feature_not_enabled';
 }
 class ActionHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'actions', functions: {
                 create: (action) => this.createAction(action),
-                delete: (action) => this.deleteAction(action)
-            }, stripUpdateFields: [
-                'deployed',
-                'status'
-            ] }));
+                delete: (action) => this.deleteAction(action),
+            }, stripUpdateFields: ['deployed', 'status'] }));
     }
     createAction(action) {
         return __awaiter(this, void 0, void 0, function* () {
@@ -148,7 +145,7 @@ class ActionHandler extends default_1.default {
                 })
                     .catch((err) => {
                     throw new Error(`Problem Deploying ${this.type} ${this.objString(action)}\n${err}`);
-                })
+                }),
             })
                 .promise();
         });
@@ -160,7 +157,7 @@ class ActionHandler extends default_1.default {
             }
             catch (err) {
                 // Retry if pending build.
-                if (err.message && err.message.includes('must be in the \'built\' state')) {
+                if (err.message && err.message.includes("must be in the 'built' state")) {
                     if (!action.retry_count) {
                         logger_1.default.info(`[${this.type}]: Waiting for build to complete ${this.objString(action)}`);
                         action.retry_count = 1;
@@ -237,9 +234,10 @@ class ActionHandler extends default_1.default {
             const changes = yield this.calcChanges(assets);
             yield _super.processChanges.call(this, assets, changes);
             // Deploy actions
-            const deployActions = [];
-            deployActions.push(...changes.create.filter((action) => action.deployed));
-            deployActions.push(...changes.update.filter((action) => action.deployed));
+            const deployActions = [
+                ...changes.create.filter((action) => action.deployed),
+                ...changes.update.filter((action) => action.deployed),
+            ];
             yield this.deployActions(deployActions);
         });
     }

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

@@ -18,16 +18,16 @@ exports.schema = {
     type: 'object',
     properties: {
         breachedPasswordDetection: {
-            type: 'object'
+            type: 'object',
         },
         bruteForceProtection: {
-            type: 'object'
+            type: 'object',
         },
         suspiciousIpThrottling: {
-            type: 'object'
-        }
+            type: 'object',
+        },
     },
-    additionalProperties: false
+    additionalProperties: false,
 };
 class AttackProtectionHandler extends default_1.default {
     constructor(config) {
@@ -36,14 +36,14 @@ class AttackProtectionHandler extends default_1.default {
     objString(item) {
         return super.objString({
             'breached-password-protection': {
-                enabled: item.breachedPasswordDetection.enabled
+                enabled: item.breachedPasswordDetection.enabled,
             },
             'brute-force-protection': {
-                enabled: item.bruteForceProtection.enabled
+                enabled: item.bruteForceProtection.enabled,
             },
             'suspicious-ip-throttling': {
-                enabled: item.suspiciousIpThrottling.enabled
-            }
+                enabled: item.suspiciousIpThrottling.enabled,
+            },
         });
     }
     getType() {
@@ -54,12 +54,12 @@ class AttackProtectionHandler extends default_1.default {
             const [breachedPasswordDetection, bruteForceProtection, suspiciousIpThrottling] = yield Promise.all([
                 this.client.attackProtection.getBreachedPasswordDetectionConfig(),
                 this.client.attackProtection.getBruteForceConfig(),
-                this.client.attackProtection.getSuspiciousIpThrottlingConfig()
+                this.client.attackProtection.getSuspiciousIpThrottlingConfig(),
             ]);
             this.existing = {
                 breachedPasswordDetection,
                 bruteForceProtection,
-                suspiciousIpThrottling
+                suspiciousIpThrottling,
             };
             return this.existing;
         });
@@ -71,12 +71,9 @@ class AttackProtectionHandler extends default_1.default {
                 return;
             }
             Promise.all([
-                this.client.attackProtection
-                    .updateBreachedPasswordDetectionConfig({}, attackProtection.breachedPasswordDetection),
-                this.client.attackProtection
-                    .updateSuspiciousIpThrottlingConfig({}, attackProtection.suspiciousIpThrottling),
-                this.client.attackProtection
-                    .updateBruteForceConfig({}, attackProtection.bruteForceProtection)
+                this.client.attackProtection.updateBreachedPasswordDetectionConfig({}, attackProtection.breachedPasswordDetection),
+                this.client.attackProtection.updateSuspiciousIpThrottlingConfig({}, attackProtection.suspiciousIpThrottling),
+                this.client.attackProtection.updateBruteForceConfig({}, attackProtection.bruteForceProtection),
             ]);
             this.updated += 1;
             this.didUpdate(attackProtection);

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

@@ -14,25 +14,59 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.schema = void 0;
 const default_1 = __importDefault(require("./default"));
-exports.schema = { type: 'object' };
+const constants_1 = __importDefault(require("../../constants"));
+const logger_1 = __importDefault(require("../../../logger"));
+exports.schema = {
+    type: 'object',
+    properties: {
+        templates: {
+            type: 'array',
+            items: {
+                type: 'object',
+                properties: {
+                    template: { type: 'string' },
+                    body: { type: 'string' },
+                },
+            },
+        },
+    },
+};
 class BrandingHandler extends default_1.default {
     constructor(options) {
         super(Object.assign(Object.assign({}, options), { type: 'branding' }));
     }
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
-            // in case client version does not support branding
-            if (!this.client.branding || typeof this.client.branding.getSettings !== 'function') {
-                return {};
-            }
+            let branding = {};
             try {
-                return yield this.client.branding.getSettings();
+                // in case client version does not support branding
+                if (this.client.branding && typeof this.client.branding.getSettings === 'function') {
+                    branding = yield this.client.branding.getSettings();
+                }
+                // in case client version does not custom domains
+                if (this.client.customDomains && typeof this.client.customDomains.getAll === 'function') {
+                    const customDomains = yield this.client.customDomains.getAll();
+                    // templates are only supported if there's custom domains.
+                    if (customDomains && customDomains.length) {
+                        const payload = yield this.client.branding.getUniversalLoginTemplate();
+                        branding.templates = [
+                            {
+                                template: constants_1.default.UNIVERSAL_LOGIN_TEMPLATE,
+                                body: payload.body,
+                            },
+                        ];
+                    }
+                }
+                return branding;
             }
             catch (err) {
+                logger_1.default.debug(`Error calling branding API, ${err.message}, status code: ${err.statusCode}`);
+                if (err.statusCode === 403)
+                    return branding;
                 if (err.statusCode === 404)
-                    return {};
+                    return branding;
                 if (err.statusCode === 501)
-                    return {};
+                    return branding;
                 throw err;
             }
         });
@@ -40,12 +74,36 @@ class BrandingHandler extends default_1.default {
     processChanges(assets) {
         return __awaiter(this, void 0, void 0, function* () {
             const { branding } = assets;
-            // Do nothing if not set
-            if (!branding || !Object.keys(branding).length)
+            // quit early if there's no branding to process.
+            if (!branding)
                 return;
-            yield this.client.branding.updateSettings({}, branding);
-            this.updated += 1;
-            this.didUpdate(branding);
+            // remove templates, we only want top level branding settings for this API call
+            const brandingSettings = Object.assign({}, branding);
+            delete brandingSettings.templates;
+            // Do nothing if not set
+            if (brandingSettings && Object.keys(brandingSettings).length) {
+                yield this.client.branding.updateSettings({}, brandingSettings);
+                this.updated += 1;
+                this.didUpdate(brandingSettings);
+            }
+            // handle templates
+            if (branding.templates && branding.templates.length) {
+                const unknownTemplates = branding.templates
+                    .filter((t) => !constants_1.default.SUPPORTED_BRANDING_TEMPLATES.includes(t.template))
+                    .map((t) => t.template);
+                if (unknownTemplates.length) {
+                    // throw a helpful warning for unknown templates, the context handlers are unaware of which are supported, that's all handled here.
+                    logger_1.default.warn(`Found unknown branding template(s): ${unknownTemplates
+                        .join()
+                        .toString()}. Supported branding templates are: ${constants_1.default.SUPPORTED_BRANDING_TEMPLATES.join()}.`);
+                }
+                const templateDefinition = branding.templates.find((t) => t.template === constants_1.default.UNIVERSAL_LOGIN_TEMPLATE);
+                if (templateDefinition && templateDefinition.body) {
+                    yield this.client.branding.setUniversalLoginTemplate({}, { template: templateDefinition.body });
+                    this.updated += 1;
+                    this.didUpdate(branding.templates);
+                }
+            }
         });
     }
 }

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

@@ -51,15 +51,17 @@ exports.schema = {
             scope: {
                 type: 'array',
                 items: { type: 'string' },
-                uniqueItems: true
-            }
+                uniqueItems: true,
+            },
         },
-        required: ['client_id', 'scope', 'audience']
-    }
+        required: ['client_id', 'scope', 'audience'],
+    },
 };
-class ClientHandler extends default_1.default {
+class ClientGrantsHandler extends default_1.default {
     constructor(config) {
-        super(Object.assign(Object.assign({}, config), { type: 'clientGrants', id: 'id', identifiers: ['id', ['client_id', 'audience']], stripUpdateFields: ['audience', 'client_id'] }));
+        super(Object.assign(Object.assign({}, config), { type: 'clientGrants', id: 'id', 
+            //@ts-ignore because not sure why two-dimensional array passed in
+            identifiers: ['id', ['client_id', 'audience']], stripUpdateFields: ['audience', 'client_id'] }));
     }
     objString(item) {
         return super.objString({ id: item.id, client_id: item.client_id, audience: item.audience });
@@ -103,15 +105,20 @@ class ClientHandler extends default_1.default {
             const { del, update, create, conflicts } = yield this.calcChanges(Object.assign(Object.assign({}, assets), { clientGrants: formatted }));
             const filterGrants = (list) => {
                 if (excludedClients.length) {
-                    return list.filter((item) => item.client_id !== currentClient && ![...excludedClientsByNames, ...excludedClients].includes(item.client_id));
+                    return list.filter((item) => item.client_id !== currentClient &&
+                        ![...excludedClientsByNames, ...excludedClients].includes(item.client_id));
                 }
                 return list.filter((item) => item.client_id !== currentClient);
             };
             const changes = {
+                //@ts-ignore because this expects `client_id` and that's not yet typed on Asset
                 del: filterGrants(del),
+                //@ts-ignore because this expects `client_id` and that's not yet typed on Asset
                 update: filterGrants(update),
+                //@ts-ignore because this expects `client_id` and that's not yet typed on Asset
                 create: filterGrants(create),
-                conflicts: filterGrants(conflicts)
+                //@ts-ignore because this expects `client_id` and that's not yet typed on Asset
+                conflicts: filterGrants(conflicts),
             };
             yield _super.processChanges.call(this, assets, Object.assign({}, changes));
         });
@@ -119,5 +126,5 @@ class ClientHandler extends default_1.default {
 }
 __decorate([
     (0, default_1.order)('60')
-], ClientHandler.prototype, "processChanges", null);
-exports.default = ClientHandler;
+], ClientGrantsHandler.prototype, "processChanges", null);
+exports.default = ClientGrantsHandler;

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

@@ -19,16 +19,20 @@ exports.schema = {
     items: {
         type: 'object',
         properties: {
-            name: { type: 'string', minLength: 1, pattern: '[^<>]+' }
+            name: { type: 'string', minLength: 1, pattern: '[^<>]+' },
         },
-        required: ['name']
-    }
+        required: ['name'],
+    },
 };
 class ClientHandler extends default_1.default {
     constructor(config) {
         super(Object.assign(Object.assign({}, config), { type: 'clients', id: 'client_id', identifiers: ['client_id', 'name'], objectFields: ['client_metadata'], stripUpdateFields: [
                 // Fields not allowed during updates
-                'callback_url_template', 'signing_keys', 'global', 'tenant', 'jwt_configuration.secret_encoded'
+                'callback_url_template',
+                'signing_keys',
+                'global',
+                'tenant',
+                'jwt_configuration.secret_encoded',
             ] }));
     }
     objString(item) {
@@ -58,17 +62,20 @@ class ClientHandler extends default_1.default {
                 del: filterClients(del),
                 update: filterClients(update),
                 create: filterClients(create),
-                conflicts: filterClients(conflicts)
+                conflicts: filterClients(conflicts),
             };
             yield _super.processChanges.call(this, assets, Object.assign({}, changes));
         });
     }
     getType() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.existing) {
+            if (this.existing)
                 return this.existing;
-            }
-            this.existing = yield this.client.clients.getAll({ paginate: true, include_totals: true, is_global: false });
+            this.existing = yield this.client.clients.getAll({
+                paginate: true,
+                include_totals: true,
+                is_global: false,
+            });
             return this.existing;
         });
     }

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

@@ -56,19 +56,20 @@ exports.schema = {
             options: { type: 'object' },
             enabled_clients: { type: 'array', items: { type: 'string' } },
             realms: { type: 'array', items: { type: 'string' } },
-            metadata: { type: 'object' }
+            metadata: { type: 'object' },
         },
-        required: ['name', 'strategy']
-    }
+        required: ['name', 'strategy'],
+    },
 };
 // addExcludedConnectionPropertiesToChanges superimposes excluded properties on the `options` object. The Auth0 API
 // will overwrite the options property when updating connections, so it is necessary to add excluded properties back in to prevent those excluded properties from being deleted.
 // This use case is common because organizations may not want to expose sensitive connection details, but want to preserve them in the tenant.
 // exported only for unit testing purposes
-const addExcludedConnectionPropertiesToChanges = ({ proposedChanges, existingConnections, config }) => {
+const addExcludedConnectionPropertiesToChanges = ({ proposedChanges, existingConnections, config, }) => {
     var _a, _b;
     if (proposedChanges.update.length === 0)
         return proposedChanges;
+    //@ts-ignore because this expects a parameter to be passed
     const excludedFields = ((_b = (_a = config()) === null || _a === void 0 ? void 0 : _a.EXCLUDED_PROPS) === null || _b === void 0 ? void 0 : _b.connections) || [];
     if (excludedFields.length === 0)
         return proposedChanges;
@@ -84,7 +85,9 @@ const addExcludedConnectionPropertiesToChanges = ({ proposedChanges, existingCon
             const currentExcludedFieldValue = dot_prop_1.default.get(currConnection, excludedField);
             dot_prop_1.default.set(agg, excludedField, currentExcludedFieldValue);
             return agg;
-        }, {});
+        }, {
+            options: {},
+        });
         return Object.assign(Object.assign({}, proposedConnection), { options: Object.assign(Object.assign({}, proposedConnection.options), currentExcludedPropertyValues.options) });
     });
     return Object.assign(Object.assign({}, proposedChanges), { update: newProposedUpdates });
@@ -100,7 +103,7 @@ class ConnectionsHandler extends default_1.default {
     getFormattedOptions(connection, clients) {
         try {
             return {
-                options: Object.assign(Object.assign({}, connection.options), { idpinitiated: Object.assign(Object.assign({}, connection.options.idpinitiated), { client_id: (0, utils_1.convertClientNameToId)(connection.options.idpinitiated.client_id, clients) }) })
+                options: Object.assign(Object.assign({}, connection.options), { idpinitiated: Object.assign(Object.assign({}, connection.options.idpinitiated), { client_id: (0, utils_1.convertClientNameToId)(connection.options.idpinitiated.client_id, clients) }) }),
             };
         }
         catch (e) {
@@ -111,9 +114,14 @@ class ConnectionsHandler extends default_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.existing)
                 return this.existing;
-            const connections = yield this.client.connections.getAll({ paginate: true, include_totals: true });
+            const connections = yield this.client.connections.getAll({
+                paginate: true,
+                include_totals: true,
+            });
             // Filter out database connections
             this.existing = connections.filter((c) => c.strategy !== 'auth0');
+            if (this.existing === null)
+                return [];
             return this.existing;
         });
     }
@@ -125,13 +133,25 @@ class ConnectionsHandler extends default_1.default {
             const { connections } = assets;
             // Do nothing if not set
             if (!connections)
-                return {};
+                return {
+                    del: [],
+                    create: [],
+                    update: [],
+                    conflicts: [],
+                };
             // Convert enabled_clients by name to the id
             const clients = yield this.client.clients.getAll({ paginate: true, include_totals: true });
-            const existingConnections = yield this.client.connections.getAll({ paginate: true, include_totals: true });
+            const existingConnections = yield this.client.connections.getAll({
+                paginate: true,
+                include_totals: true,
+            });
             const formatted = assets.connections.map((connection) => (Object.assign(Object.assign(Object.assign({}, connection), this.getFormattedOptions(connection, clients)), { enabled_clients: (0, utils_1.getEnabledClients)(assets, connection, existingConnections, clients) })));
             const proposedChanges = yield _super.calcChanges.call(this, Object.assign(Object.assign({}, assets), { connections: formatted }));
-            const proposedChangesWithExcludedProperties = (0, exports.addExcludedConnectionPropertiesToChanges)({ proposedChanges, existingConnections, config: this.config });
+            const proposedChangesWithExcludedProperties = (0, exports.addExcludedConnectionPropertiesToChanges)({
+                proposedChanges,
+                existingConnections,
+                config: this.config,
+            });
             return proposedChangesWithExcludedProperties;
         });
     }

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

@@ -57,13 +57,13 @@ exports.schema = {
                 properties: {
                     customScripts: {
                         type: 'object',
-                        properties: Object.assign({}, constants_1.default.DATABASE_SCRIPTS.reduce((o, script) => (Object.assign(Object.assign({}, o), { [script]: { type: 'string' } })), {}))
-                    }
-                }
-            }
+                        properties: Object.assign({}, constants_1.default.DATABASE_SCRIPTS.reduce((o, script) => (Object.assign(Object.assign({}, o), { [script]: { type: 'string' } })), {})),
+                    },
+                },
+            },
         },
-        required: ['name']
-    }
+        required: ['name'],
+    },
 };
 class DatabaseHandler extends default_1.default {
     constructor(config) {
@@ -75,9 +75,8 @@ class DatabaseHandler extends default_1.default {
     getClientFN(fn) {
         // Override this as a database is actually a connection but we are treating them as a different object
         // If we going to update database, we need to get current options first
-        if (fn === this.functions.update) {
-            return (params, payload) => this.client.connections.get(params)
-                .then((connection) => {
+        if (fn === 'update') {
+            return (params, payload) => this.client.connections.get(params).then((connection) => {
                 payload.options = Object.assign(Object.assign({}, connection.options), payload.options);
                 return this.client.connections.update(params, payload);
             });
@@ -88,7 +87,11 @@ class DatabaseHandler extends default_1.default {
         return __awaiter(this, void 0, void 0, function* () {
             if (this.existing)
                 return this.existing;
-            this.existing = this.client.connections.getAll({ strategy: 'auth0', paginate: true, include_totals: true });
+            this.existing = this.client.connections.getAll({
+                strategy: 'auth0',
+                paginate: true,
+                include_totals: true,
+            });
             return this.existing;
         });
     }
@@ -100,13 +103,22 @@ class DatabaseHandler extends default_1.default {
             const { databases } = assets;
             // Do nothing if not set
             if (!databases)
-                return {};
+                return {
+                    del: [],
+                    create: [],
+                    update: [],
+                    conflicts: [],
+                };
             // Convert enabled_clients by name to the id
             const clients = yield this.client.clients.getAll({ paginate: true, include_totals: true });
-            const existingDatabasesConecctions = yield this.client.connections.getAll({ strategy: 'auth0', paginate: true, include_totals: true });
+            const existingDatabasesConnections = yield this.client.connections.getAll({
+                strategy: 'auth0',
+                paginate: true,
+                include_totals: true,
+            });
             const formatted = databases.map((db) => {
                 if (db.enabled_clients) {
-                    return Object.assign(Object.assign({}, db), { enabled_clients: (0, utils_1.getEnabledClients)(assets, db, existingDatabasesConecctions, clients) });
+                    return Object.assign(Object.assign({}, db), { enabled_clients: (0, utils_1.getEnabledClients)(assets, db, existingDatabasesConnections, clients) });
                 }
                 return db;
             });