auth0-deploy-cli 7.10.0 → 7.11.0

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/logStreams.d.ts

@@ -1,7 +1,5 @@
 import { YAMLHandler } from '.';
-import { Asset } from '../../../types';
-declare type ParsedLogStreams = {
-    logStreams: Asset[] | null;
-};
+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

@@ -11,8 +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* () {
+        const { logStreams } = context.assets;
+        if (!logStreams)
+            return { logStreams: null };
         return {
-            logStreams: context.assets.logStreams || [],
+            logStreams,
         };
     });
 }

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 };
     });
 }

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

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

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

@@ -9,24 +9,19 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-function parse(context) {
+function dumpAndParse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default if empty
+        const { resourceServers } = context.assets;
+        if (!resourceServers) {
+            return { resourceServers: null };
+        }
         return {
-            resourceServers: context.assets.resourceServers,
-        };
-    });
-}
-function dump(context) {
-    return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default if empty
-        return {
-            resourceServers: [...(context.assets.resourceServers || [])],
+            resourceServers,
         };
     });
 }
 const resourceServersHandler = {
-    parse,
-    dump,
+    parse: dumpAndParse,
+    dump: dumpAndParse,
 };
 exports.default = resourceServersHandler;

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

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

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

@@ -11,24 +11,26 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 function parse(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // nothing to do, set default empty
+        const { roles } = context.assets;
+        if (!roles)
+            return { roles: null };
         return {
-            roles: context.assets.roles,
+            roles,
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        // remove empty descriptions
+        const { roles } = context.assets;
+        if (!roles)
+            return { roles: null };
         return {
-            roles: [
-                ...(context.assets.roles || []).map((role) => {
-                    if (role.description === null) {
-                        delete role.description;
-                    }
-                    return role;
-                }),
-            ],
+            roles: roles.map((role) => {
+                if (role.description === null) {
+                    delete role.description;
+                }
+                return role;
+            }),
         };
     });
 }

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

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

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

@@ -18,32 +18,33 @@ 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 rule
-        if (!context.assets.rules)
-            return {};
+        const { rules } = context.assets;
+        if (!rules)
+            return { rules: null };
         return {
             rules: [
-                ...context.assets.rules.map((rule) => (Object.assign(Object.assign({}, rule), { script: context.loadFile(rule.script) }))),
+                ...rules.map((rule) => (Object.assign(Object.assign({}, rule), { script: context.loadFile(rule.script) }))),
             ],
         };
     });
 }
 function dump(context) {
     return __awaiter(this, void 0, void 0, function* () {
-        let rules = [...(context.assets.rules || [])];
-        if (rules.length > 0) {
-            // Create Rules folder
-            const rulesFolder = path_1.default.join(context.basePath, 'rules');
-            fs_extra_1.default.ensureDirSync(rulesFolder);
-            rules = rules.map((rule) => {
-                // Dump rule to file
-                const scriptName = (0, utils_1.sanitize)(`${rule.name}.js`);
-                const scriptFile = path_1.default.join(rulesFolder, scriptName);
-                logger_1.default.info(`Writing ${scriptFile}`);
-                fs_extra_1.default.writeFileSync(scriptFile, rule.script);
-                return Object.assign(Object.assign({}, rule), { script: `./rules/${scriptName}` });
-            });
+        let { rules } = context.assets;
+        if (!rules) {
+            return { rules: null };
         }
+        // Create Rules folder
+        const rulesFolder = path_1.default.join(context.basePath, 'rules');
+        fs_extra_1.default.ensureDirSync(rulesFolder);
+        rules = rules.map((rule) => {
+            // Dump rule to file
+            const scriptName = (0, utils_1.sanitize)(`${rule.name}.js`);
+            const scriptFile = path_1.default.join(rulesFolder, scriptName);
+            logger_1.default.info(`Writing ${scriptFile}`);
+            fs_extra_1.default.writeFileSync(scriptFile, rule.script);
+            return Object.assign(Object.assign({}, rule), { script: `./rules/${scriptName}` });
+        });
         return { rules };
     });
 }

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

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