auth0-deploy-cli 7.8.0 → 7.11.0

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

@@ -20,7 +20,7 @@ const logger_1 = __importDefault(require("../../../logger"));
 function parse(context) {
     const hooksFolder = path_1.default.join(context.filePath, tools_1.constants.HOOKS_DIRECTORY);
     if (!(0, utils_1.existsMustBeDir)(hooksFolder))
-        return { hooks: undefined }; // Skip
+        return { hooks: null }; // Skip
     const files = (0, utils_1.getFiles)(hooksFolder, ['.json']);
     const hooks = files.map((f) => {
         const hook = Object.assign({}, (0, utils_1.loadJSON)(f, context.mappings));
@@ -36,8 +36,8 @@ function parse(context) {
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const hooks = [...(context.assets.hooks || [])];
-        if (hooks.length < 1)
+        const hooks = context.assets.hooks;
+        if (!hooks)
             return;
         // Create Hooks folder
         const hooksFolder = path_1.default.join(context.filePath, tools_1.constants.HOOKS_DIRECTORY);

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

@@ -1,12 +1,12 @@
 import DirectoryContext from '..';
-import { AssetTypes } from '../../../types';
+import { AssetTypes, Asset } from '../../../types';
 export declare type DirectoryHandler<T> = {
     dump: (context: DirectoryContext) => void;
     parse: (context: DirectoryContext) => T;
 };
 declare const directoryHandlers: {
     [key in AssetTypes]: DirectoryHandler<{
-        [key: string]: unknown;
+        [key: string]: Asset | Asset[] | null;
     }>;
 };
 export default directoryHandlers;

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

@@ -28,6 +28,7 @@ const organizations_1 = __importDefault(require("./organizations"));
 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 directoryHandlers = {
     rules: rules_1.default,
     rulesConfigs: rulesConfigs_1.default,
@@ -54,5 +55,6 @@ const directoryHandlers = {
     triggers: triggers_1.default,
     attackProtection: attackProtection_1.default,
     branding: branding_1.default,
+    logStreams: logStreams_1.default,
 };
 exports.default = directoryHandlers;

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

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

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

@@ -0,0 +1,49 @@
+"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 };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const tools_1 = require("../../../tools");
+const utils_1 = require("../../../utils");
+function parse(context) {
+    const logStreamsDirectory = path_1.default.join(context.filePath, tools_1.constants.LOG_STREAMS_DIRECTORY);
+    if (!(0, utils_1.existsMustBeDir)(logStreamsDirectory))
+        return { logStreams: null }; // Skip
+    const foundFiles = (0, utils_1.getFiles)(logStreamsDirectory, ['.json']);
+    const logStreams = foundFiles
+        .map((f) => (0, utils_1.loadJSON)(f, context.mappings))
+        .filter((p) => Object.keys(p).length > 0); // Filter out empty rulesConfigs
+    return {
+        logStreams,
+    };
+}
+function dump(context) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const logStreams = context.assets.logStreams;
+        if (!logStreams)
+            return; // Skip, nothing to dump
+        // Create Rules folder
+        const logStreamsDirectory = path_1.default.join(context.filePath, tools_1.constants.LOG_STREAMS_DIRECTORY);
+        fs_extra_1.default.ensureDirSync(logStreamsDirectory);
+        logStreams.forEach((logStream) => {
+            const ruleFile = path_1.default.join(logStreamsDirectory, `${(0, utils_1.sanitize)(logStream.name)}.json`);
+            (0, utils_1.dumpJSON)(ruleFile, logStream);
+        });
+    });
+}
+const logStreamsHandler = {
+    parse,
+    dump,
+};
+exports.default = logStreamsHandler;

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

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

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,6 +1,13 @@
 import { YAMLHandler } from '.';
-declare type ParsedBranding = {
-    branding: unknown;
+import { Asset, ParsedAsset } from '../../../types';
+declare type BrandingTemplate = {
+    template: string;
+    body: string;
 };
+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

@@ -8,6 +8,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -18,30 +29,41 @@ const tools_1 = require("../../../tools");
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
         // Load the HTML file for each page
-        const { branding } = context.assets;
-        if (!branding || !branding.templates)
-            return { branding };
-        const templates = branding.templates.map((templateDefinition) => {
-            const markupFile = path_1.default.join(templateDefinition.body);
+        if (!context.assets.branding)
+            return {
+                branding: {
+                    templates: [],
+                },
+            };
+        if (!context.assets.branding)
+            return { branding: null };
+        const _a = context.assets.branding, { templates } = _a, branding = __rest(_a, ["templates"]);
+        if (!templates) {
+            return { branding: Object.assign({}, branding) };
+        }
+        const parsedTemplates = templates.map((templateDefinition) => {
+            const markupFile = path_1.default.join(context.basePath, templateDefinition.body);
             return {
                 template: templateDefinition.template,
                 body: (0, tools_1.loadFileAndReplaceKeywords)(markupFile, context.mappings),
             };
         });
         return {
-            branding: Object.assign(Object.assign({}, branding), { templates }),
+            branding: Object.assign(Object.assign({}, branding), { templates: parsedTemplates }),
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { branding } = context.assets || { branding: undefined };
-        branding.templates = branding.templates || [];
+        const { branding } = context.assets;
+        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;
@@ -56,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;