@extrahorizon/exh-cli 1.5.0

package/build/commands/tasks/sync.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const fs = require("fs/promises");
+const chalk = require("chalk");
+const constants_1 = require("../../constants");
+const util_1 = require("../../helpers/util");
+const functionRepository = require("../../repositories/functions");
+const taskConfig_1 = require("./taskConfig");
+const util_2 = require("./util");
+exports.command = 'sync';
+exports.desc = 'Sync a task. Will create the task first if it doesn\'t exist yet';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
+    path: {
+        demandOption: false,
+        describe: `Path of the configuration json file containing task parameters. If a directory is given instead, all sub-directories will be searched for a task-config.json file & synced. 
+    If this option is not used, each parameter (name, code, entryPoint, runtime, ...) will need to be supplied separately`,
+        type: 'string',
+    },
+    name: {
+        demandOption: false,
+        describe: 'Name of the task',
+        type: 'string',
+    },
+    code: {
+        demandOption: false,
+        describe: 'The path to a directory containing the built task. exh-cli will compress the directory and upload it',
+        type: 'string',
+    },
+    entryPoint: {
+        demandOption: false,
+        describe: "The code function that should be invoked. For example 'index.handler' for Nodejs",
+        type: 'string',
+    },
+    runtime: {
+        demandOption: false,
+        describe: 'Runtime to use for the task',
+        choices: constants_1.runtimeChoices,
+        type: 'string',
+    },
+    description: {
+        describe: 'A description for this task',
+        type: 'string',
+        default: '',
+    },
+    timeLimit: {
+        describe: 'The execution time limit for this task (in seconds). Min: 3 max: 900',
+        type: 'number',
+    },
+    memoryLimit: {
+        describe: 'The allocated memory for this task (in MB). Min: 128 max: 10240',
+        type: 'number',
+    },
+    env: {
+        describe: 'Environment Variables set for this task. This option can be used multiple times.',
+        type: 'string',
+        default: [],
+    },
+    executionPermission: {
+        type: 'string',
+    },
+})
+    .check(async ({ path, entryPoint, runtime, name, code, executionPermission }) => {
+    if (!path && (!name || !code || !runtime || !entryPoint)) {
+        throw new Error('Need to specify either a task config file or all parameters separately');
+    }
+    (0, taskConfig_1.assertExecutionPermission)(executionPermission);
+    return true;
+});
+exports.builder = builder;
+const handler = async ({ sdk, ...cmdLineParams }) => {
+    for await (const config of (0, taskConfig_1.getValidatedConfigIterator)(cmdLineParams)) {
+        console.log('Syncing task', config.name, '...');
+        await syncSingleTask(sdk, config);
+    }
+};
+exports.handler = handler;
+async function syncSingleTask(sdk, config) {
+    const uploadFilePath = await (0, util_2.zipFileFromDirectory)(config.path);
+    const file = await fs.readFile(uploadFilePath);
+    const allFunctions = await functionRepository.find(sdk);
+    const myFunction = allFunctions.find((f) => f.name === config.name);
+    const request = {
+        name: config.name,
+        description: config.description || 'none',
+        entryPoint: config.entryPoint,
+        code: file.toString('base64'),
+        runtime: config.runtime,
+    };
+    if (config.executionPermission) {
+        request.executionOptions = { permissionMode: config.executionPermission };
+    }
+    if (config.timeLimit) {
+        request.timeLimit = config.timeLimit;
+    }
+    if (config.memoryLimit) {
+        request.memoryLimit = config.memoryLimit;
+    }
+    if (config.environment) {
+        request.environmentVariables =
+            Object.entries(config.environment).reduce((prev, curr) => ({ ...prev, [curr[0]]: { value: curr[1] } }), {});
+    }
+    if (config.retryPolicy) {
+        request.retryPolicy = config.retryPolicy;
+    }
+    if (myFunction === undefined) {
+        await functionRepository.create(sdk, request);
+        console.log(chalk.green('Successfully created task', config.name));
+    }
+    else {
+        const existingFunction = await functionRepository.findByName(sdk, myFunction.name);
+        if (request.runtime === existingFunction.runtime) {
+            delete request.runtime;
+        }
+        const updateResponse = await functionRepository.update(sdk, request);
+        if (!updateResponse?.affectedRecords) {
+            throw new Error(`Failed to update task ${request.name}`);
+        }
+        console.log(chalk.green('Successfully updated task', config.name));
+    }
+    await fs.unlink(uploadFilePath);
+}

package/build/commands/tasks/taskConfig.d.ts

@@ -0,0 +1,24 @@
+export declare enum permissionModes {
+    permissionRequired = "permissionRequired",
+    allUsers = "allUsers",
+    public = "public"
+}
+export interface TaskConfig {
+    name?: string;
+    path?: string;
+    entryPoint?: string;
+    runtime?: string;
+    description?: string;
+    timeLimit?: number;
+    memoryLimit?: number;
+    environment?: Record<string, string>;
+    executionPermission?: permissionModes;
+    retryPolicy?: {
+        enabled: boolean;
+        errorsToRetry: string[];
+    };
+}
+export declare function assertExecutionPermission(mode: string): asserts mode is permissionModes | undefined;
+export declare function validateConfig(config: TaskConfig): Promise<boolean>;
+export declare function loadSingleConfigFile(path: string): Promise<TaskConfig>;
+export declare function getValidatedConfigIterator({ path, name, code, entryPoint, runtime, description, timeLimit, memoryLimit, executionPermission, env }: any): AsyncGenerator<TaskConfig>;

package/build/commands/tasks/taskConfig.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValidatedConfigIterator = exports.loadSingleConfigFile = exports.validateConfig = exports.assertExecutionPermission = exports.permissionModes = void 0;
+const assert_1 = require("assert");
+const fs = require("fs/promises");
+const ospath = require("path");
+const Joi = require("joi");
+const constants_1 = require("../../constants");
+var permissionModes;
+(function (permissionModes) {
+    permissionModes["permissionRequired"] = "permissionRequired";
+    permissionModes["allUsers"] = "allUsers";
+    permissionModes["public"] = "public";
+})(permissionModes = exports.permissionModes || (exports.permissionModes = {}));
+const taskConfigSchema = Joi.object({
+    name: Joi.string().pattern(/^[A-Za-z0-9-]+$/).required(),
+    description: Joi.string(),
+    entryPoint: Joi.string().required(),
+    runtime: Joi.string().valid(...constants_1.runtimeChoices).required(),
+    timeLimit: Joi.number().min(constants_1.limits.time.min).max(constants_1.limits.time.max),
+    memoryLimit: Joi.number().min(constants_1.limits.memory.min).max(constants_1.limits.memory.max),
+    path: Joi.string(),
+    retryPolicy: Joi.object({
+        enabled: Joi.boolean().required(),
+        errorsToRetry: Joi.array().items(Joi.string()),
+    }),
+    environment: Joi.object().pattern(/.*/, Joi.string()),
+    executionPermission: Joi.string().valid(...Object.values(permissionModes)),
+});
+function assertExecutionPermission(mode) {
+    if (mode !== undefined && !Object.values(permissionModes).includes(mode)) {
+        throw new assert_1.AssertionError({ message: `executionPermission incorrect. Should be one of ${Object.values(permissionModes).join(',')}` });
+    }
+}
+exports.assertExecutionPermission = assertExecutionPermission;
+function replaceConfigVariables(config) {
+    let result;
+    switch (typeof config) {
+        case 'object':
+            if (Array.isArray(config)) {
+                result = [];
+                for (const element of config) {
+                    result.push(replaceConfigVariables(element));
+                }
+            }
+            else {
+                result = {};
+                for (const [key, value] of Object.entries(config)) {
+                    result[key] = replaceConfigVariables(value);
+                }
+            }
+            return result;
+        case 'string':
+            if (config.charAt(0) === '$') {
+                const variable = config.slice(1);
+                if (process.env[variable]) {
+                    return process.env[variable];
+                }
+                throw new Error(`Variable ${variable} not found in environment`);
+            }
+            return config;
+        default:
+            result = config;
+            break;
+    }
+    return result;
+}
+async function validateConfig(config) {
+    try {
+        Joi.attempt(config, taskConfigSchema);
+    }
+    catch (err) {
+        throw new Error(err.details[0]?.message || 'Unknown config validation error');
+    }
+    if (config.path) {
+        try {
+            await fs.access(config.path);
+        }
+        catch (err) {
+            throw new Error(`Please provide a valid directory path for your code, ${config.path} not found`);
+        }
+        if ((await fs.stat(config.path)).isFile()) {
+            throw new Error(`please provide a valid directory path for your code, ${config.path} points to a file`);
+        }
+    }
+    else {
+        throw new Error('Code path not specified');
+    }
+    assertExecutionPermission(config.executionPermission);
+    return true;
+}
+exports.validateConfig = validateConfig;
+async function loadSingleConfigFile(path) {
+    let taskConfig;
+    try {
+        const data = await fs.readFile(path);
+        try {
+            taskConfig = JSON.parse(data.toString());
+        }
+        catch (err) {
+            throw new Error(`failed to parse file ${err.message}`);
+        }
+    }
+    catch (err2) {
+        throw new Error(`Invalid config file: ${err2.message}`);
+    }
+    taskConfig = replaceConfigVariables(taskConfig);
+    if (taskConfig.path) {
+        taskConfig.path = ospath.join(ospath.dirname(path), taskConfig.path);
+    }
+    return taskConfig;
+}
+exports.loadSingleConfigFile = loadSingleConfigFile;
+async function* getValidatedConfigIterator({ path, name, code, entryPoint, runtime, description, timeLimit, memoryLimit, executionPermission, env }) {
+    let taskConfig = {};
+    if (path) {
+        const stat = await fs.stat(path);
+        if (stat.isDirectory()) {
+            const dirContents = await fs.readdir(path);
+            for (const file of dirContents) {
+                let filePath = ospath.join(path, file);
+                if ((await fs.stat(filePath)).isDirectory()) {
+                    filePath = ospath.join(filePath, 'task-config.json');
+                    const cfg = await loadSingleConfigFile(filePath);
+                    if (cfg) {
+                        await validateConfig(cfg);
+                        yield cfg;
+                    }
+                }
+            }
+            return;
+        }
+        taskConfig = await loadSingleConfigFile(path);
+        if (!taskConfig) {
+            throw new Error("Path is a file but doesn't point to a valid configuration file");
+        }
+    }
+    if (name) {
+        taskConfig.name = name;
+    }
+    if (code) {
+        taskConfig.path = code;
+    }
+    if (entryPoint) {
+        taskConfig.entryPoint = entryPoint;
+    }
+    if (runtime) {
+        taskConfig.runtime = runtime;
+    }
+    if (description) {
+        taskConfig.description = description;
+    }
+    if (timeLimit) {
+        taskConfig.timeLimit = timeLimit;
+    }
+    if (memoryLimit) {
+        taskConfig.memoryLimit = memoryLimit;
+    }
+    if (executionPermission) {
+        taskConfig.executionPermission = executionPermission;
+    }
+    if (env && env.length) {
+        const envArr = Array.isArray(env) ? env : [env];
+        taskConfig.environment = envArr.map(e => e.split('=')).filter(e => e.length === 2).reduce((prev, curr) => ({ ...prev, [curr[0]]: curr[1] }), {});
+    }
+    await validateConfig(taskConfig);
+    yield taskConfig;
+}
+exports.getValidatedConfigIterator = getValidatedConfigIterator;

package/build/commands/tasks/util.d.ts

@@ -0,0 +1 @@
+export declare function zipFileFromDirectory(path: string): Promise<string>;

package/build/commands/tasks/util.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipFileFromDirectory = void 0;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const archiver = require("archiver");
+const uuid_1 = require("uuid");
+async function zipFileFromDirectory(path) {
+    return new Promise((res, rej) => {
+        const tmpPath = `${(0, os_1.tmpdir)()}/${(0, uuid_1.v4)()}`;
+        const output = (0, fs_1.createWriteStream)(tmpPath);
+        const archive = archiver('zip', {
+            zlib: { level: 9 },
+        });
+        output.on('close', () => {
+            res(tmpPath);
+        });
+        archive.on('error', (err) => {
+            (0, fs_1.unlink)(tmpPath, msg => { console.log(msg); });
+            rej(err);
+        });
+        archive.pipe(output);
+        archive.directory(`${path}/`, false);
+        archive.finalize();
+    });
+}
+exports.zipFileFromDirectory = zipFileFromDirectory;

package/build/commands/tasks.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="yargs" />
+export declare const command = "tasks <command>";
+export declare const desc = "Manage tasks";
+export declare const builder: (yargs: any) => import("yargs").Argv<{}>;
+export declare const handler: () => void;

package/build/commands/tasks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const util_1 = require("../helpers/util");
+exports.command = 'tasks <command>';
+exports.desc = 'Manage tasks';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).commandDir('tasks');
+exports.builder = builder;
+const handler = () => { };
+exports.handler = handler;

package/build/commands/templates/delete.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="yargs" />
+import { OAuth1Client } from '@extrahorizon/javascript-sdk';
+export declare const command = "delete";
+export declare const desc = "Delete a template";
+export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "id" | "name"> & import("yargs").InferredOptionTypes<{
+    name: {
+        describe: string;
+        type: "string";
+    };
+    id: {
+        describe: string;
+        type: "string";
+    };
+}>>;
+export declare const handler: ({ sdk, name, id }: {
+    sdk: OAuth1Client;
+    name: string;
+    id: string;
+}) => Promise<void>;

package/build/commands/templates/delete.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const chalk = require("chalk");
+const util_1 = require("../../helpers/util");
+exports.command = 'delete';
+exports.desc = 'Delete a template';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
+    name: {
+        describe: 'Name of the template to delete',
+        type: 'string',
+    },
+    id: {
+        describe: 'ID of the template to delete',
+        type: 'string',
+    },
+}).check(({ id, name }) => {
+    if ((!id && !name) || (id && name)) {
+        throw new Error('Either id or name needs to be provided');
+    }
+    return true;
+});
+exports.builder = builder;
+const handler = async function list({ sdk, name, id }) {
+    let template = null;
+    if (name) {
+        template = await sdk.templates.findByName(name);
+    }
+    if (id) {
+        template = await sdk.templates.findById(id);
+    }
+    if (!template) {
+        console.log(chalk.red('Template not found!'));
+        return;
+    }
+    try {
+        const { affectedRecords } = await sdk.templates.remove(template.id);
+        if (!affectedRecords) {
+            console.log(chalk.red('Failed to remove template', name));
+            return;
+        }
+        console.log('Template deleted');
+    }
+    catch (err) {
+        console.log(chalk.red('Failed to remove template', name));
+    }
+};
+exports.handler = handler;

package/build/commands/templates/get.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="yargs" />
+import { OAuth1Client } from '@extrahorizon/javascript-sdk';
+export declare const command = "get";
+export declare const desc = "Fetch a template";
+export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "id" | "name"> & import("yargs").InferredOptionTypes<{
+    name: {
+        describe: string;
+        type: "string";
+    };
+    id: {
+        describe: string;
+        type: "string";
+    };
+}>>;
+export declare const handler: ({ sdk, name, id }: {
+    sdk: OAuth1Client;
+    name: string;
+    id: string;
+}) => Promise<void>;

package/build/commands/templates/get.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const chalk = require("chalk");
+const util_1 = require("../../helpers/util");
+exports.command = 'get';
+exports.desc = 'Fetch a template';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
+    name: {
+        describe: 'Name of the template',
+        type: 'string',
+    },
+    id: {
+        describe: 'ID of the template',
+        type: 'string',
+    },
+}).check(({ name, id }) => {
+    if ((name && id) || (!name && !id)) {
+        throw new Error('Either name or id should be specified (but not both at the same time)');
+    }
+    return true;
+});
+exports.builder = builder;
+const handler = async function list({ sdk, name, id }) {
+    try {
+        const template = name ? await sdk.templates.findByName(name) : await sdk.templates.findById(id);
+        if (!template) {
+            console.log(chalk.red('Failed to get template!'));
+            return;
+        }
+        console.log(JSON.stringify(template, null, 4));
+    }
+    catch (err) {
+        console.log(chalk.red('Failed to get template', name));
+    }
+};
+exports.handler = handler;

package/build/commands/templates/list.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="yargs" />
+import { OAuth1Client } from '@extrahorizon/javascript-sdk';
+export declare const command = "list";
+export declare const desc = "List all templates";
+export declare const builder: (yargs: any) => import("yargs").Argv<{}>;
+export declare const handler: ({ sdk, isTTY }: {
+    sdk: OAuth1Client;
+    isTTY: boolean;
+}) => Promise<void>;

package/build/commands/templates/list.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const chalk = require("chalk");
+const util_1 = require("../../helpers/util");
+exports.command = 'list';
+exports.desc = 'List all templates';
+const builder = (yargs) => (0, util_1.epilogue)(yargs);
+exports.builder = builder;
+const handler = async function list({ sdk, isTTY }) {
+    const templates = await sdk.templates.findAll();
+    if (templates) {
+        if (!templates.length) {
+            console.log(chalk.red('No templates found'));
+            return;
+        }
+        if (isTTY) {
+            console.table(templates.map((c) => ({ Id: c.id, Name: c.name, Description: c.description || '<none>', 'Last updated': c.updateTimestamp.toISOString() })));
+        }
+        else {
+            templates.forEach((f) => (console.log(f)));
+        }
+    }
+};
+exports.handler = handler;

package/build/commands/templates/sync.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="yargs" />
+import { TemplateService } from './util/templateService';
+export declare const command = "sync";
+export declare const desc = "Sync all templates in a directory with the ExH cloud";
+export declare const builder: (yargs: any) => import("yargs").Argv<import("yargs").Omit<{}, "template" | "path"> & import("yargs").InferredOptionTypes<{
+    path: {
+        demandOption: false;
+        describe: string;
+        type: "string";
+    };
+    template: {
+        demandOption: false;
+        describe: string;
+        type: "string";
+    };
+}>>;
+export declare const handler: ({ sdk, path, template }: {
+    sdk: any;
+    path: any;
+    template: any;
+}) => Promise<void>;
+export declare function syncTargetDir(service: TemplateService, targetDir: string): Promise<void>;

package/build/commands/templates/sync.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncTargetDir = exports.handler = exports.builder = exports.desc = exports.command = void 0;
+const fs = require("fs");
+const ospath = require("path");
+const util_1 = require("../../helpers/util");
+const buildTemplates_1 = require("./util/buildTemplates");
+const readTemplateFiles_1 = require("./util/readTemplateFiles");
+const templateService_1 = require("./util/templateService");
+const uploadTemplate_1 = require("./util/uploadTemplate");
+const utils_1 = require("./util/utils");
+exports.command = 'sync';
+exports.desc = 'Sync all templates in a directory with the ExH cloud';
+const builder = (yargs) => (0, util_1.epilogue)(yargs).options({
+    path: {
+        demandOption: false,
+        describe: 'Directory containing the templates which need to be synced',
+        type: 'string',
+    },
+    template: {
+        demandOption: false,
+        describe: 'Template file to sync',
+        type: 'string',
+    },
+}).check(({ path, template }) => {
+    if (template && !fs.existsSync(ospath.join(process.cwd(), template))) {
+        throw new Error('please provide a valid file path for your template');
+    }
+    if (path && (!fs.existsSync(ospath.join(process.cwd(), path)) || fs.statSync(ospath.join(process.cwd(), path)).isFile())) {
+        throw new Error('please provide a valid directory path for your code');
+    }
+    if ((template && path) || (!template && !path)) {
+        throw new Error('Either path or template must be specified (but not both at the same time)');
+    }
+    return true;
+});
+exports.builder = builder;
+const handler = async ({ sdk, path, template }) => {
+    const service = new templateService_1.TemplateService(sdk);
+    if (path) {
+        await syncTargetDir(service, ospath.resolve(path || '.'));
+        return;
+    }
+    let templ = null;
+    const templateName = (0, utils_1.removeFileNameExtension)(ospath.basename(template));
+    if (fs.statSync(ospath.join(process.cwd(), template)).isFile()) {
+        templ = await (0, readTemplateFiles_1.readTemplateJson)(template);
+    }
+    else {
+        templ = await (0, readTemplateFiles_1.readTemplateFolder)(template);
+    }
+    await buildAndUploadTemplates(service, { [templateName]: templ });
+};
+exports.handler = handler;
+async function buildAndUploadTemplates(service, templateObject) {
+    const templates = await (0, buildTemplates_1.buildTemplates)(service, templateObject);
+    for (const template of templates) {
+        await (0, uploadTemplate_1.uploadTemplate)(service, template);
+    }
+}
+async function syncTargetDir(service, targetDir) {
+    const templateFilesByName = await (0, readTemplateFiles_1.readTemplateFiles)(targetDir);
+    await buildAndUploadTemplates(service, templateFilesByName);
+}
+exports.syncTargetDir = syncTargetDir;

package/build/commands/templates/util/buildTemplates.d.ts

@@ -0,0 +1,2 @@
+import { TemplateService } from './templateService';
+export declare function buildTemplates(service: TemplateService, templateFilesByName: any): Promise<any[]>;

package/build/commands/templates/util/buildTemplates.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildTemplates = void 0;
+async function buildTemplates(service, templateFilesByName) {
+    const templates = [];
+    for (const name of Object.keys(templateFilesByName)) {
+        templates.push(await buildTemplate(service, name, templateFilesByName));
+    }
+    return templates;
+}
+exports.buildTemplates = buildTemplates;
+async function buildTemplate(service, name, templateFilesByName, callChain = []) {
+    if (callChain.includes(name)) {
+        throw new Error(`Circular extension detected. ${[...callChain, name].reverse().map((n) => `'${n}'`).join(' > ')}`);
+    }
+    let templateFile = templateFilesByName[name];
+    if (templateFile === undefined) {
+        templateFile = await service.byName(name);
+        if (!templateFile) {
+            throw new Error(`Template file dependency ${name} not found!`);
+        }
+    }
+    const { description, extends_template, schema } = templateFile;
+    let { fields } = templateFile;
+    if (extends_template) {
+        const extendingTemplate = await buildTemplate(service, extends_template, templateFilesByName, [...callChain, name]);
+        const match = (_fullMatch, variableName) => {
+            const value = fields[variableName];
+            if (typeof value === 'undefined') {
+                throw new Error(`Could not find a value to fill '$content.${variableName}' ` +
+                    `while extending '${extends_template}' ` +
+                    `in ${[...callChain, name].reverse().map(n => `'${n}'`).join(' > ')}`);
+            }
+            return value;
+        };
+        const extendedFields = {};
+        for (const extendingField of Object.keys(extendingTemplate.fields)) {
+            const extendedValue = extendingTemplate.fields[extendingField]
+                .replace(/\$content\.([a-z0-9_-]+)/ig, match);
+            extendedFields[extendingField] = extendedValue;
+        }
+        fields = extendedFields;
+    }
+    return {
+        name,
+        description,
+        schema,
+        fields,
+    };
+}