auth0-deploy-cli 7.8.0 → 7.11.0

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;

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

@@ -18,7 +18,9 @@ const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the HTML file for each page
-        const emailTemplates = context.assets.emailTemplates || [];
+        const { emailTemplates } = context.assets;
+        if (!emailTemplates)
+            return { emailTemplates: null };
         return {
             emailTemplates: [
                 ...emailTemplates.map((et) => (Object.assign(Object.assign({}, et), { body: context.loadFile(et.body) }))),
@@ -28,19 +30,20 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        let emailTemplates = [...(context.assets.emailTemplates || [])];
-        if (emailTemplates.length > 0) {
-            // Create Templates folder
-            const templatesFolder = path_1.default.join(context.basePath, 'emailTemplates');
-            fs_extra_1.default.ensureDirSync(templatesFolder);
-            emailTemplates = emailTemplates.map((template) => {
-                // Dump template to file
-                const templateFile = path_1.default.join(templatesFolder, `${template.template}.html`);
-                logger_1.default.info(`Writing ${templateFile}`);
-                fs_extra_1.default.writeFileSync(templateFile, template.body);
-                return Object.assign(Object.assign({}, template), { body: `./emailTemplates/${template.template}.html` });
-            });
+        let emailTemplates = context.assets.emailTemplates;
+        if (!emailTemplates) {
+            return { emailTemplates: null };
         }
+        // Create Templates folder
+        const templatesFolder = path_1.default.join(context.basePath, 'emailTemplates');
+        fs_extra_1.default.ensureDirSync(templatesFolder);
+        emailTemplates = emailTemplates.map((template) => {
+            // Dump template to file
+            const templateFile = path_1.default.join(templatesFolder, `${template.template}.html`);
+            logger_1.default.info(`Writing ${templateFile}`);
+            fs_extra_1.default.writeFileSync(templateFile, template.body);
+            return Object.assign(Object.assign({}, template), { body: `./emailTemplates/${template.template}.html` });
+        });
         return { emailTemplates };
     });
 }

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

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

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

@@ -11,9 +11,11 @@ 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* () {
-        // nothing to do, set default empty
+        const { guardianFactorProviders } = context.assets;
+        if (!guardianFactorProviders)
+            return { guardianFactorProviders: null };
         return {
-            guardianFactorProviders: [...(context.assets.guardianFactorProviders || [])],
+            guardianFactorProviders,
         };
     });
 }

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

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

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

@@ -11,9 +11,11 @@ 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* () {
-        // nothing to do, set default if empty
+        const { guardianFactorTemplates } = context.assets;
+        if (!guardianFactorTemplates)
+            return { guardianFactorTemplates: null };
         return {
-            guardianFactorTemplates: [...(context.assets.guardianFactorTemplates || [])],
+            guardianFactorTemplates,
         };
     });
 }

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

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

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

@@ -11,9 +11,11 @@ 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* () {
-        // nothing to do, set default if empty
+        const { guardianFactors } = context.assets;
+        if (!guardianFactors)
+            return { guardianFactors: null };
         return {
-            guardianFactors: [...(context.assets.guardianFactors || [])],
+            guardianFactors,
         };
     });
 }

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

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

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

@@ -11,9 +11,11 @@ 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* () {
-        // nothing to do, set default if empty
+        const { guardianPhoneFactorMessageTypes } = context.assets;
+        if (!guardianPhoneFactorMessageTypes)
+            return { guardianPhoneFactorMessageTypes: null };
         return {
-            guardianPhoneFactorMessageTypes: Object.assign({}, (context.assets.guardianPhoneFactorMessageTypes || {})),
+            guardianPhoneFactorMessageTypes,
         };
     });
 }

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

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

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

@@ -11,9 +11,11 @@ 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* () {
-        // nothing to do, set default empty
+        const { guardianPhoneFactorSelectedProvider } = context.assets;
+        if (!guardianPhoneFactorSelectedProvider)
+            return { guardianPhoneFactorSelectedProvider: null };
         return {
-            guardianPhoneFactorSelectedProvider: Object.assign({}, (context.assets.guardianPhoneFactorSelectedProvider || {})),
+            guardianPhoneFactorSelectedProvider,
         };
     });
 }

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

@@ -1,6 +1,7 @@
 import { YAMLHandler } from '.';
-declare type ParsedGuardianPolicies = {
-    guardianPolicies: unknown;
-};
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedGuardianPolicies = ParsedAsset<'guardianPolicies', {
+    policies: Asset[];
+}>;
 declare const guardianPoliciesHandler: YAMLHandler<ParsedGuardianPolicies>;
 export default guardianPoliciesHandler;

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

@@ -11,9 +11,11 @@ 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* () {
-        // nothing to do, set default if empty
+        const { guardianPolicies } = context.assets;
+        if (!guardianPolicies)
+            return { guardianPolicies: null };
         return {
-            guardianPolicies: Object.assign({}, (context.assets.guardianPolicies || {})),
+            guardianPolicies,
         };
     });
 }

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

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

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

@@ -19,12 +19,12 @@ const utils_1 = require("../../../utils");
 const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Load the script file for each hook
-        if (!context.assets.hooks)
-            return {};
+        const { hooks } = context.assets;
+        if (!hooks)
+            return { hooks: null };
         return {
             hooks: [
-                ...context.assets.hooks.map((hook) => {
+                ...hooks.map((hook) => {
                     if (hook.script) {
                         //@ts-ignore TODO: understand why two arguments are passed when context.loadFile only accepts one
                         hook.script = context.loadFile(hook.script, tools_1.constants.HOOKS_DIRECTORY);
@@ -38,22 +38,23 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        let hooks = [...(context.assets.hooks || [])];
-        if (hooks.length > 0) {
-            // Create hooks folder
-            const hooksFolder = path_1.default.join(context.basePath, 'hooks');
-            fs_extra_1.default.ensureDirSync(hooksFolder);
-            hooks = hooks.map((hook) => {
-                // Dump hook code to file
-                // For cases when hook does not have `meta['hook-name']`
-                hook.name = hook.name || hook.id;
-                const codeName = (0, utils_1.sanitize)(`${hook.name}.js`);
-                const codeFile = path_1.default.join(hooksFolder, codeName);
-                logger_1.default.info(`Writing ${codeFile}`);
-                fs_extra_1.default.writeFileSync(codeFile, hook.script);
-                return Object.assign(Object.assign({}, hook), { script: `./hooks/${codeName}` });
-            });
+        let hooks = context.assets.hooks;
+        if (!hooks) {
+            return { hooks: null };
         }
+        // Create hooks folder
+        const hooksFolder = path_1.default.join(context.basePath, 'hooks');
+        fs_extra_1.default.ensureDirSync(hooksFolder);
+        hooks = hooks.map((hook) => {
+            // Dump hook code to file
+            // For cases when hook does not have `meta['hook-name']`
+            hook.name = hook.name || hook.id;
+            const codeName = (0, utils_1.sanitize)(`${hook.name}.js`);
+            const codeFile = path_1.default.join(hooksFolder, codeName);
+            logger_1.default.info(`Writing ${codeFile}`);
+            fs_extra_1.default.writeFileSync(codeFile, hook.script);
+            return Object.assign(Object.assign({}, hook), { script: `./hooks/${codeName}` });
+        });
         return { hooks };
     });
 }

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

@@ -1,7 +1,7 @@
 import YAMLContext from '..';
 import { AssetTypes } from '../../../types';
 export declare type YAMLHandler<T> = {
-    dump: (context: YAMLContext) => Promise<T | {}>;
+    dump: (context: YAMLContext) => Promise<T>;
     parse: (context: YAMLContext) => Promise<T>;
 };
 declare const yamlHandlers: {

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

@@ -28,6 +28,7 @@ const actions_1 = __importDefault(require("./actions"));
 const triggers_1 = __importDefault(require("./triggers"));
 const attackProtection_1 = __importDefault(require("./attackProtection"));
 const branding_1 = __importDefault(require("./branding"));
+const logStreams_1 = __importDefault(require("./logStreams"));
 const yamlHandlers = {
     rules: rules_1.default,
     hooks: hooks_1.default,
@@ -54,5 +55,6 @@ const yamlHandlers = {
     triggers: triggers_1.default,
     attackProtection: attackProtection_1.default,
     branding: branding_1.default,
+    logStreams: logStreams_1.default,
 };
 exports.default = yamlHandlers;

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

@@ -0,0 +1,5 @@
+import { YAMLHandler } from '.';
+import { Asset, ParsedAsset } from '../../../types';
+declare type ParsedLogStreams = ParsedAsset<'logStreams', Asset[]>;
+declare const logStreamsHandler: YAMLHandler<ParsedLogStreams>;
+export default logStreamsHandler;

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

@@ -0,0 +1,26 @@
+"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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function parseAndDump(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { logStreams } = context.assets;
+        if (!logStreams)
+            return { logStreams: null };
+        return {
+            logStreams,
+        };
+    });
+}
+const logStreamsHandler = {
+    parse: parseAndDump,
+    dump: parseAndDump,
+};
+exports.default = logStreamsHandler;

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

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

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

@@ -9,20 +9,16 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-function parse(context) {
+function parseAndDump(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const { migrations } = context.assets;
+        if (!migrations)
+            return { migrations: null };
         return { migrations };
     });
 }
-function dump(context) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const { migrations } = context.assets;
-        return { migrations: migrations || {} };
-    });
-}
 const migrationsHandler = {
-    parse,
-    dump,
+    parse: parseAndDump,
+    dump: parseAndDump,
 };
 exports.default = migrationsHandler;

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

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

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

@@ -12,29 +12,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const { organizations } = context.assets;
+        if (!organizations)
+            return { organizations: null };
         return {
-            organizations: organizations,
+            organizations,
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
         const { organizations } = context.assets;
+        if (!organizations)
+            return { organizations: null };
         return {
-            organizations: [
-                ...(organizations || []).map((org) => {
-                    if (org.connections.length > 0) {
-                        org.connections = org.connections.map((c) => {
-                            // connection is a computed field
-                            const name = c.connection && c.connection.name;
-                            delete c.connection_id;
-                            delete c.connection;
-                            return Object.assign({ name }, c);
-                        });
-                    }
-                    return org;
-                }),
-            ],
+            organizations: organizations.map((org) => {
+                if (org.connections.length > 0) {
+                    org.connections = org.connections.map((c) => {
+                        // connection is a computed field
+                        const name = c.connection && c.connection.name;
+                        delete c.connection_id;
+                        delete c.connection;
+                        return Object.assign({ name }, c);
+                    });
+                }
+                return org;
+            }),
         };
     });
 }

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

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

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

@@ -18,33 +18,35 @@ const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the HTML file for each page
-        if (!context.assets.pages)
-            return {};
+        const { pages } = context.assets;
+        if (!pages)
+            return { pages: null };
         return {
             pages: [
-                ...context.assets.pages.map((page) => (Object.assign(Object.assign({}, page), { html: page.html ? context.loadFile(page.html) : '' }))),
+                ...pages.map((page) => (Object.assign(Object.assign({}, page), { html: page.html ? context.loadFile(page.html) : '' }))),
             ],
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        let pages = [...(context.assets.pages || [])];
-        if (pages.length > 0) {
-            // Create Pages folder
-            const pagesFolder = path_1.default.join(context.basePath, 'pages');
-            fs_extra_1.default.ensureDirSync(pagesFolder);
-            pages = pages.map((page) => {
-                if (page.name === 'error_page' && page.html === undefined) {
-                    return page;
-                }
-                // Dump html to file
-                const htmlFile = path_1.default.join(pagesFolder, `${page.name}.html`);
-                logger_1.default.info(`Writing ${htmlFile}`);
-                fs_extra_1.default.writeFileSync(htmlFile, page.html);
-                return Object.assign(Object.assign({}, page), { html: `./pages/${page.name}.html` });
-            });
+        let pages = context.assets.pages;
+        if (!pages) {
+            return { pages: null };
         }
+        // Create Pages folder
+        const pagesFolder = path_1.default.join(context.basePath, 'pages');
+        fs_extra_1.default.ensureDirSync(pagesFolder);
+        pages = pages.map((page) => {
+            if (page.name === 'error_page' && page.html === undefined) {
+                return page;
+            }
+            // Dump html to file
+            const htmlFile = path_1.default.join(pagesFolder, `${page.name}.html`);
+            logger_1.default.info(`Writing ${htmlFile}`);
+            fs_extra_1.default.writeFileSync(htmlFile, page.html);
+            return Object.assign(Object.assign({}, page), { html: `./pages/${page.name}.html` });
+        });
         return { pages };
     });
 }