auth0-deploy-cli 7.10.0 → 7.11.0

package/lib/context/directory/handlers/migrations.js

@@ -17,10 +17,10 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const baseFolder = path_1.default.join(context.filePath);
     if (!(0, utils_1.existsMustBeDir)(baseFolder))
-        return {}; // Skip
+        return { migrations: null }; // Skip
     const migrationsFile = path_1.default.join(baseFolder, 'migrations.json');
     if (!(0, utils_1.isFile)(migrationsFile))
-        return {};
+        return { migrations: null };
     /* eslint-disable camelcase */
     const migrations = (0, utils_1.loadJSON)(migrationsFile, context.mappings);
     return { migrations };

package/lib/context/directory/handlers/organizations.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from '.';
-declare type ParsedOrganizations = {
-    organizations: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedOrganizations = ParsedAsset<'organizations', Asset[]>;
 declare const organizationsHandler: DirectoryHandler<ParsedOrganizations>;
 export default organizationsHandler;

package/lib/context/directory/handlers/organizations.js

@@ -19,7 +19,7 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const organizationsFolder = path_1.default.join(context.filePath, 'organizations');
     if (!(0, utils_1.existsMustBeDir)(organizationsFolder))
-        return { organizations: undefined }; // Skip
+        return { organizations: null }; // Skip
     const files = (0, utils_1.getFiles)(organizationsFolder, ['.json']);
     const organizations = files.map((f) => {
         const org = Object.assign({}, (0, utils_1.loadJSON)(f, context.mappings));

package/lib/context/directory/handlers/pages.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from '.';
-declare type ParsedPages = {
-    pages: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedPages = ParsedAsset<'pages', Asset[]>;
 declare const pagesHandler: DirectoryHandler<ParsedPages>;
 export default pagesHandler;

package/lib/context/directory/handlers/pages.js

@@ -20,7 +20,7 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const pagesFolder = path_1.default.join(context.filePath, tools_1.constants.PAGES_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(pagesFolder))
-        return { pages: undefined }; // Skip
+        return { pages: null }; // Skip
     const files = (0, utils_1.getFiles)(pagesFolder, ['.json', '.html']);
     const sorted = files.reduce((acc, file) => {
         const { ext, name } = path_1.default.parse(file);
@@ -49,7 +49,7 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const pages = [...(context.assets.pages || [])];
+        const pages = context.assets.pages;
         if (!pages)
             return; // Skip, nothing to dump
         // Create Pages folder

package/lib/context/directory/handlers/resourceServers.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from '.';
-declare type ParsedResourceServers = {
-    resourceServers: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedResourceServers = ParsedAsset<'resourceServers', Asset[]>;
 declare const resourceServersHandler: DirectoryHandler<ParsedResourceServers>;
 export default resourceServersHandler;

package/lib/context/directory/handlers/resourceServers.js

@@ -19,7 +19,7 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const resourceServersFolder = path_1.default.join(context.filePath, tools_1.constants.RESOURCE_SERVERS_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(resourceServersFolder))
-        return { resourceServers: undefined }; // Skip
+        return { resourceServers: null }; // Skip
     const foundFiles = (0, utils_1.getFiles)(resourceServersFolder, ['.json']);
     const resourceServers = foundFiles
         .map((f) => (0, utils_1.loadJSON)(f, context.mappings))

package/lib/context/directory/handlers/roles.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from '.';
-declare type ParsedRoles = {
-    roles: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedRoles = ParsedAsset<'roles', Asset[]>;
 declare const rolesHandler: DirectoryHandler<ParsedRoles>;
 export default rolesHandler;

package/lib/context/directory/handlers/roles.js

@@ -20,7 +20,7 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const rolesFolder = path_1.default.join(context.filePath, tools_1.constants.ROLES_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(rolesFolder))
-        return { roles: undefined }; // Skip
+        return { roles: null }; // Skip
     const files = (0, utils_1.getFiles)(rolesFolder, ['.json']);
     const roles = files.map((f) => {
         const role = Object.assign({}, (0, utils_1.loadJSON)(f, context.mappings));

package/lib/context/directory/handlers/rules.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from './index';
-declare type ParsedRules = {
-    rules: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedRules = ParsedAsset<'rules', Asset[]>;
 declare const rulesHandler: DirectoryHandler<ParsedRules>;
 export default rulesHandler;

package/lib/context/directory/handlers/rules.js

@@ -20,7 +20,7 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const rulesFolder = path_1.default.join(context.filePath, tools_1.constants.RULES_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(rulesFolder))
-        return { rules: undefined }; // Skip
+        return { rules: null }; // Skip
     const files = (0, utils_1.getFiles)(rulesFolder, ['.json']);
     const rules = files.map((f) => {
         const rule = Object.assign({}, (0, utils_1.loadJSON)(f, context.mappings));
@@ -35,7 +35,7 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const rules = [...(context.assets.rules || [])];
+        const { rules } = context.assets;
         if (!rules)
             return; // Skip, nothing to dump
         // Create Rules folder

package/lib/context/directory/handlers/rulesConfigs.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from '.';
-declare type ParsedRulesConfigs = {
-    rulesConfigs: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedRulesConfigs = ParsedAsset<'rulesConfigs', Asset[]>;
 declare const rulesConfigsHandler: DirectoryHandler<ParsedRulesConfigs>;
 export default rulesConfigsHandler;

package/lib/context/directory/handlers/rulesConfigs.js

@@ -18,7 +18,7 @@ const utils_1 = require("../../../utils");
 function parse(context) {
     const rulesConfigsFolder = path_1.default.join(context.filePath, tools_1.constants.RULES_CONFIGS_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(rulesConfigsFolder))
-        return { rulesConfigs: undefined }; // Skip
+        return { rulesConfigs: null }; // Skip
     const foundFiles = (0, utils_1.getFiles)(rulesConfigsFolder, ['.json']);
     const rulesConfigs = foundFiles
         .map((f) => (0, utils_1.loadJSON)(f, context.mappings))

package/lib/context/directory/handlers/tenant.d.ts

@@ -1,10 +1,10 @@
 import { DirectoryHandler } from '.';
-declare type ParsedTenant = {
-    tenant: {
-        session_lifetime: number;
-        idle_session_lifetime: number;
-        [key: string]: unknown;
-    };
-} | {};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedTenant = ParsedAsset<'tenant', {
+    session_lifetime: number;
+    idle_session_lifetime: number;
+} & {
+    [key: string]: Asset;
+}>;
 declare const tenantHandler: DirectoryHandler<ParsedTenant>;
 export default tenantHandler;

package/lib/context/directory/handlers/tenant.js

@@ -29,18 +29,19 @@ const sessionDurationsToMinutes_1 = require("../../../sessionDurationsToMinutes"
 function parse(context) {
     const baseFolder = path_1.default.join(context.filePath);
     if (!(0, utils_1.existsMustBeDir)(baseFolder))
-        return {}; // Skip
+        return { tenant: null }; // Skip
     const tenantFile = path_1.default.join(baseFolder, 'tenant.json');
-    if ((0, utils_1.isFile)(tenantFile)) {
-        /* eslint-disable camelcase */
-        const _a = (0, utils_1.loadJSON)(tenantFile, context.mappings), { session_lifetime, idle_session_lifetime } = _a, tenant = __rest(_a, ["session_lifetime", "idle_session_lifetime"]);
-        (0, utils_1.clearTenantFlags)(tenant);
-        const sessionDurations = (0, sessionDurationsToMinutes_1.sessionDurationsToMinutes)({ session_lifetime, idle_session_lifetime });
-        return {
-            tenant: Object.assign(Object.assign({}, tenant), sessionDurations),
-        };
+    if (!(0, utils_1.isFile)(tenantFile)) {
+        return { tenant: null };
     }
-    return {};
+    /* eslint-disable camelcase */
+    const _a = (0, utils_1.loadJSON)(tenantFile, context.mappings), { session_lifetime, idle_session_lifetime } = _a, tenant = __rest(_a, ["session_lifetime", "idle_session_lifetime"]);
+    (0, utils_1.clearTenantFlags)(tenant);
+    const sessionDurations = (0, sessionDurationsToMinutes_1.sessionDurationsToMinutes)({ session_lifetime, idle_session_lifetime });
+    return {
+        //@ts-ignore
+        tenant: Object.assign(Object.assign({}, tenant), sessionDurations),
+    };
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {

package/lib/context/directory/handlers/triggers.d.ts

@@ -1,6 +1,5 @@
 import { DirectoryHandler } from '.';
-declare type ParsedTriggers = {
-    triggers: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedTriggers = ParsedAsset<'triggers', Asset[]>;
 declare const triggersHandler: DirectoryHandler<ParsedTriggers>;
 export default triggersHandler;

package/lib/context/directory/handlers/triggers.js

@@ -20,7 +20,7 @@ const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     const triggersFolder = path_1.default.join(context.filePath, tools_1.constants.TRIGGERS_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(triggersFolder))
-        return { triggers: undefined }; // Skip
+        return { triggers: null }; // Skip
     const files = (0, utils_1.getFiles)(triggersFolder, ['.json']);
     const triggers = Object.assign({}, (0, utils_1.loadJSON)(files[0], context.mappings));
     return { triggers };

package/lib/context/yaml/handlers/actions.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedActions = {
-    actions: unknown[] | undefined;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedActions = ParsedAsset<'actions', Asset[]>;
 declare const ActionsHandler: YAMLHandler<ParsedActions>;
 export default ActionsHandler;

package/lib/context/yaml/handlers/actions.js

@@ -27,15 +27,14 @@ function parseCode(context, code) {
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the script file for each action
-        //@ts-ignore TODO: understand if empty array is intentionally being returned
-        if (!context.assets.actions)
-            return [];
-        const actions = {
+        const { actions } = context.assets;
+        if (!actions)
+            return { actions: null };
+        return {
             actions: [
-                ...context.assets.actions.map((action) => (Object.assign(Object.assign({}, action), { code: parseCode(context, action.code) }))),
+                ...actions.map((action) => (Object.assign(Object.assign({}, action), { code: parseCode(context, action.code) }))),
             ],
         };
-        return actions;
     });
 }
 function mapSecrets(secrets) {
@@ -60,9 +59,8 @@ function mapActionCode(basePath, action) {
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const { actions } = context.assets;
-        //@ts-ignore TODO: need to investigate why returning void here when other handlers do not
         if (!actions)
-            return; // Nothing to do
+            return { actions: null };
         return {
             actions: actions.map((action) => ({
                 name: action.name,

package/lib/context/yaml/handlers/attackProtection.d.ts

@@ -1,6 +1,9 @@
 import { YAMLHandler } from '.';
-declare type ParsedAttackProtection = {
-    attackProtection: unknown;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedAttackProtection = ParsedAsset<'attackProtection', {
+    breachedPasswordDetection: Asset;
+    bruteForceProtection: Asset;
+    suspiciousIpThrottling: Asset;
+}>;
 declare const attackProtectionHandler: YAMLHandler<ParsedAttackProtection>;
 export default attackProtectionHandler;

package/lib/context/yaml/handlers/attackProtection.js

@@ -11,8 +11,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 function parseAndDump(context) {
     return __awaiter(this, void 0, void 0, function* () {
+        const { attackProtection } = context.assets;
+        if (!attackProtection)
+            return { attackProtection: null };
+        const { suspiciousIpThrottling, breachedPasswordDetection, bruteForceProtection } = attackProtection;
         return {
-            attackProtection: context.assets.attackProtection || {},
+            attackProtection: {
+                suspiciousIpThrottling,
+                breachedPasswordDetection,
+                bruteForceProtection,
+            },
         };
     });
 }

package/lib/context/yaml/handlers/branding.d.ts

@@ -1,13 +1,13 @@
 import { YAMLHandler } from '.';
+import { Asset, ParsedAsset } from '../../../types';
 declare type BrandingTemplate = {
     template: string;
     body: string;
 };
-declare type ParsedBranding = {
-    branding: {
-        templates?: BrandingTemplate[];
-        [key: string]: unknown;
-    };
-};
+declare type ParsedBranding = ParsedAsset<'branding', {
+    [key: string]: Asset;
+} & {
+    templates?: BrandingTemplate[];
+}>;
 declare const brandingHandler: YAMLHandler<ParsedBranding>;
 export default brandingHandler;

package/lib/context/yaml/handlers/branding.js

@@ -35,9 +35,12 @@ function parse(context) {
                     templates: [],
                 },
             };
+        if (!context.assets.branding)
+            return { branding: null };
         const _a = context.assets.branding, { templates } = _a, branding = __rest(_a, ["templates"]);
-        if (!branding && !branding['templates'])
-            return { branding };
+        if (!templates) {
+            return { branding: Object.assign({}, branding) };
+        }
         const parsedTemplates = templates.map((templateDefinition) => {
             const markupFile = path_1.default.join(context.basePath, templateDefinition.body);
             return {
@@ -53,12 +56,14 @@ function parse(context) {
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const { branding } = context.assets;
-        branding.templates = branding.templates || [];
+        if (!branding)
+            return { branding: null };
+        let templates = branding.templates || [];
         // create templates folder
-        if (branding.templates.length) {
+        if (templates.length) {
             const brandingTemplatesFolder = path_1.default.join(context.basePath, tools_1.constants.BRANDING_TEMPLATES_YAML_DIRECTORY);
             fs_extra_1.default.ensureDirSync(brandingTemplatesFolder);
-            branding.templates = branding.templates.map((templateDefinition) => {
+            templates = templates.map((templateDefinition) => {
                 const file = `${templateDefinition.template}.html`;
                 const templateMarkupFile = path_1.default.join(brandingTemplatesFolder, file);
                 const markup = templateDefinition.body;
@@ -73,7 +78,7 @@ function dump(context) {
                 return templateDefinition;
             });
         }
-        return { branding };
+        return { branding: { templates } };
     });
 }
 const brandingHandler = {

package/lib/context/yaml/handlers/clientGrants.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedClientGrants = {
-    clientGrants: unknown[];
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedClientGrants = ParsedAsset<'clientGrants', Asset[]>;
 declare const clientGrantsHandler: YAMLHandler<ParsedClientGrants>;
 export default clientGrantsHandler;

package/lib/context/yaml/handlers/clientGrants.js

@@ -12,23 +12,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("../../../utils");
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default empty
+        const { clientGrants } = context.assets;
+        if (!clientGrants)
+            return { clientGrants: null };
         return {
-            clientGrants: context.assets.clientGrants,
+            clientGrants,
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { clientGrants } = context.assets;
-        // Nothing to do
+        const { clientGrants, clients } = context.assets;
         if (!clientGrants)
-            return {};
+            return { clientGrants: null };
         // Convert client_id to the client name for readability
         return {
             clientGrants: clientGrants.map((grant) => {
                 const dumpGrant = Object.assign({}, grant);
-                dumpGrant.client_id = (0, utils_1.convertClientIdToName)(dumpGrant.client_id, context.assets.clients);
+                dumpGrant.client_id = (0, utils_1.convertClientIdToName)(dumpGrant.client_id, clients || []);
                 return dumpGrant;
             }),
         };

package/lib/context/yaml/handlers/clients.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedClients = {
-    clients: unknown[];
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedClients = ParsedAsset<'clients', Asset[]>;
 declare const clientsHandler: YAMLHandler<ParsedClients>;
 export default clientsHandler;

package/lib/context/yaml/handlers/clients.js

@@ -22,8 +22,8 @@ function parse(context) {
         // Load the HTML file for custom_login_page
         const { clients } = context.assets;
         const clientsFolder = path_1.default.join(context.basePath, tools_1.constants.CLIENTS_DIRECTORY);
-        if (!clients || !clients.length) {
-            return { clients: context.assets.clients };
+        if (!clients) {
+            return { clients: null };
         }
         return {
             clients: [
@@ -44,9 +44,12 @@ function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Save custom_login_page to a separate html file
         const clientsFolder = path_1.default.join(context.basePath, tools_1.constants.CLIENTS_DIRECTORY);
+        const { clients } = context.assets;
+        if (!clients)
+            return { clients: null };
         return {
             clients: [
-                ...context.assets.clients.map((client) => {
+                ...clients.map((client) => {
                     if (client.custom_login_page) {
                         const clientName = (0, utils_1.sanitize)(client.name);
                         const html = client.custom_login_page;

package/lib/context/yaml/handlers/connections.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedConnections = {
-    connections: unknown[];
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedConnections = ParsedAsset<'connections', Asset[]>;
 declare const connectionsHandler: YAMLHandler<ParsedConnections>;
 export default connectionsHandler;

package/lib/context/yaml/handlers/connections.js

@@ -19,11 +19,10 @@ const logger_1 = __importDefault(require("../../../logger"));
 const utils_1 = require("../../../utils");
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Load the HTML file for email connections
         const { connections } = context.assets;
         const connectionsFolder = path_1.default.join(context.basePath, tools_1.constants.CONNECTIONS_DIRECTORY);
-        if (!connections || !connections.length) {
-            return { connections: context.assets.connections };
+        if (!connections) {
+            return { connections: null };
         }
         return {
             connections: [
@@ -53,15 +52,13 @@ const getFormattedOptions = (connection, clients) => {
 };
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { connections } = context.assets;
-        // Nothing to do
+        const { connections, clients } = context.assets;
         if (!connections)
-            return {};
-        // nothing to do, set default if empty
+            return { connections: null };
         return {
             connections: connections.map((connection) => {
-                const dumpedConnection = Object.assign(Object.assign(Object.assign({}, connection), getFormattedOptions(connection, context.assets.clients)), (connection.enabled_clients && {
-                    enabled_clients: (0, utils_1.mapClientID2NameSorted)(connection.enabled_clients, context.assets.clients),
+                const dumpedConnection = Object.assign(Object.assign(Object.assign({}, connection), getFormattedOptions(connection, clients)), (connection.enabled_clients && {
+                    enabled_clients: (0, utils_1.mapClientID2NameSorted)(connection.enabled_clients, clients || []),
                 }));
                 if (dumpedConnection.strategy === 'email') {
                     (0, utils_1.ensureProp)(connection, 'options.email.body');

package/lib/context/yaml/handlers/databases.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedDatabases = {
-    databases: unknown[];
-};
-declare const databasesHandler: YAMLHandler<ParsedDatabases | {}>;
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedDatabases = ParsedAsset<'databases', Asset[]>;
+declare const databasesHandler: YAMLHandler<ParsedDatabases>;
 export default databasesHandler;

package/lib/context/yaml/handlers/databases.js

@@ -19,11 +19,12 @@ const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the script file for custom db
-        if (!context.assets.databases)
-            return {};
+        const { databases } = context.assets;
+        if (!databases)
+            return { databases: null };
         return {
             databases: [
-                ...context.assets.databases.map((database) => (Object.assign(Object.assign({}, database), { options: Object.assign(Object.assign({}, database.options), (database.options.customScripts && {
+                ...databases.map((database) => (Object.assign(Object.assign({}, database), { options: Object.assign(Object.assign({}, database.options), (database.options.customScripts && {
                         customScripts: Object.entries(database.options.customScripts).reduce((scripts, [name, script]) => (Object.assign(Object.assign({}, scripts), { [name]: context.loadFile(script) })), {}),
                     })) }))),
             ],
@@ -32,10 +33,9 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { databases } = context.assets;
-        // Nothing to do
+        const { databases, clients } = context.assets;
         if (!databases)
-            return {};
+            return { databases: null };
         const sortCustomScripts = ([name1], [name2]) => {
             if (name1 === name2)
                 return 0;
@@ -44,7 +44,7 @@ function dump(context) {
         return {
             databases: [
                 ...databases.map((database) => (Object.assign(Object.assign(Object.assign({}, database), (database.enabled_clients && {
-                    enabled_clients: (0, utils_1.mapClientID2NameSorted)(database.enabled_clients, context.assets.clients),
+                    enabled_clients: (0, utils_1.mapClientID2NameSorted)(database.enabled_clients, clients || []),
                 })), { options: Object.assign(Object.assign({}, database.options), (database.options.customScripts && {
                         customScripts: Object.entries(database.options.customScripts)
                             .sort(sortCustomScripts)

package/lib/context/yaml/handlers/emailProvider.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedEmailProvider = {
-    emailProvider: unknown;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedEmailProvider = ParsedAsset<'emailProvider', Asset>;
 declare const emailProviderHandler: YAMLHandler<ParsedEmailProvider>;
 export default emailProviderHandler;

package/lib/context/yaml/handlers/emailProvider.js

@@ -12,23 +12,30 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const defaults_1 = require("../../defaults");
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default if empty
+        const { emailProvider } = context.assets;
+        if (!emailProvider)
+            return { emailProvider: null };
         return {
-            emailProvider: Object.assign({}, (context.assets.emailProvider || {})),
+            emailProvider,
         };
     });
 }
 function dump(context) {
-    var _a;
     return __awaiter(this, void 0, void 0, function* () {
-        let { emailProvider } = context.assets;
-        const excludedDefaults = ((_a = context.assets.exclude) === null || _a === void 0 ? void 0 : _a.defaults) || [];
-        if (emailProvider && !excludedDefaults.includes('emailProvider')) {
-            // Add placeholder for credentials as they cannot be exported
-            emailProvider = (0, defaults_1.emailProviderDefaults)(emailProvider);
-        }
+        if (!context.assets.emailProvider)
+            return { emailProvider: null };
+        const emailProvider = (() => {
+            var _a;
+            const { emailProvider } = context.assets;
+            const excludedDefaults = ((_a = context.assets.exclude) === null || _a === void 0 ? void 0 : _a.defaults) || [];
+            if (emailProvider && !excludedDefaults.includes('emailProvider')) {
+                // Add placeholder for credentials as they cannot be exported
+                return (0, defaults_1.emailProviderDefaults)(emailProvider);
+            }
+            return emailProvider;
+        })();
         return {
-            emailProvider: emailProvider || {},
+            emailProvider,
         };
     });
 }

package/lib/context/yaml/handlers/emailTemplates.d.ts

@@ -1,6 +1,5 @@
 import { YAMLHandler } from '.';
-declare type ParsedEmailTemplates = {
-    emailTemplates: unknown[];
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedEmailTemplates = ParsedAsset<'emailTemplates', Asset[]>;
 declare const emailTemplatesHandler: YAMLHandler<ParsedEmailTemplates>;
 export default emailTemplatesHandler;