@grnsft/if 0.5.0 → 0.6.0-beta.0

package/build/if-run/builtins/multiply/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Multiply = void 0;
+const zod_1 = require("zod");
+const validations_1 = require("../../../common/util/validations");
+const Multiply = (globalConfig, parametersMetadata) => {
+    const metadata = {
+        kind: 'execute',
+        inputs: parametersMetadata?.inputs,
+        outputs: parametersMetadata?.outputs,
+    };
+    /**
+     * Checks global config value are valid.
+     */
+    const validateGlobalConfig = () => {
+        const globalConfigSchema = zod_1.z.object({
+            'input-parameters': zod_1.z.array(zod_1.z.string()),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(globalConfigSchema, globalConfig);
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateSingleInput = (input, inputParameters) => {
+        const inputData = inputParameters.reduce((acc, param) => {
+            acc[param] = input[param];
+            return acc;
+        }, {});
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        (0, validations_1.validate)(validationSchema, inputData);
+        return input;
+    };
+    /**
+     * Calculate the product of each input parameter.
+     */
+    const execute = (inputs) => {
+        const safeGlobalConfig = validateGlobalConfig();
+        const inputParameters = safeGlobalConfig['input-parameters'];
+        const outputParameter = safeGlobalConfig['output-parameter'];
+        return inputs.map(input => {
+            validateSingleInput(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculateProduct(input, inputParameters),
+            };
+        });
+    };
+    /**
+     * Calculates the product of the components.
+     */
+    const calculateProduct = (input, inputParameters) => inputParameters.reduce((accumulator, metricToMultiply) => accumulator * input[metricToMultiply], 1);
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Multiply = Multiply;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/regex/index.d.ts

@@ -0,0 +1,2 @@
+import { ExecutePlugin, ConfigParams, PluginParametersMetadata } from '@grnsft/if-core/types';
+export declare const Regex: (globalConfig: ConfigParams, parametersMetadata: PluginParametersMetadata) => ExecutePlugin;

package/build/if-run/builtins/regex/index.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Regex = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { MissingInputDataError, GlobalConfigError, RegexMismatchError } = utils_1.ERRORS;
+const { MISSING_GLOBAL_CONFIG, MISSING_INPUT_DATA, REGEX_MISMATCH } = config_1.STRINGS;
+const Regex = (globalConfig, parametersMetadata) => {
+    const metadata = {
+        kind: 'execute',
+        inputs: parametersMetadata?.inputs,
+        outputs: parametersMetadata?.outputs,
+    };
+    /**
+     * Checks global config value are valid.
+     */
+    const validateGlobalConfig = () => {
+        if (!globalConfig) {
+            throw new GlobalConfigError(MISSING_GLOBAL_CONFIG);
+        }
+        const schema = zod_1.z.object({
+            parameter: zod_1.z.string().min(1),
+            match: zod_1.z.string().min(1),
+            output: zod_1.z.string(),
+        });
+        return (0, validations_1.validate)(schema, globalConfig);
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateSingleInput = (input, parameter) => {
+        if (!input[parameter]) {
+            throw new MissingInputDataError(MISSING_INPUT_DATA(parameter));
+        }
+        return input;
+    };
+    /**
+     * Executes the regex of the given parameter.
+     */
+    const execute = (inputs) => {
+        const safeGlobalConfig = validateGlobalConfig();
+        const { parameter: parameter, match, output } = safeGlobalConfig;
+        return inputs.map(input => {
+            const safeInput = Object.assign({}, input, validateSingleInput(input, parameter));
+            return {
+                ...input,
+                [output]: extractMatching(safeInput, parameter, match),
+            };
+        });
+    };
+    /**
+     * Extracts a substring from the given input parameter that matches the provided regular expression pattern.
+     */
+    const extractMatching = (input, parameter, match) => {
+        if (!match.startsWith('/')) {
+            match = '/' + match;
+        }
+        if (!match.endsWith('/g') && !match.endsWith('/')) {
+            match += '/';
+        }
+        const regex = eval(match);
+        const matchedItems = input[parameter].match(regex);
+        if (!matchedItems || matchedItems.length === 0) {
+            throw new RegexMismatchError(REGEX_MISMATCH(input[parameter], match));
+        }
+        return matchedItems.join(' ');
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Regex = Regex;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvaWYtcnVuL2J1aWx0aW5zL3JlZ2V4L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLDZCQUFzQjtBQUN0QixpREFBNkM7QUFRN0Msa0VBQTBEO0FBRTFELHlDQUFxQztBQUVyQyxNQUFNLEVBQUMscUJBQXFCLEVBQUUsaUJBQWlCLEVBQUUsa0JBQWtCLEVBQUMsR0FBRyxjQUFNLENBQUM7QUFDOUUsTUFBTSxFQUFDLHFCQUFxQixFQUFFLGtCQUFrQixFQUFFLGNBQWMsRUFBQyxHQUFHLGdCQUFPLENBQUM7QUFFckUsTUFBTSxLQUFLLEdBQUcsQ0FDbkIsWUFBMEIsRUFDMUIsa0JBQTRDLEVBQzdCLEVBQUU7SUFDakIsTUFBTSxRQUFRLEdBQUc7UUFDZixJQUFJLEVBQUUsU0FBUztRQUNmLE1BQU0sRUFBRSxrQkFBa0IsRUFBRSxNQUFNO1FBQ2xDLE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxPQUFPO0tBQ3JDLENBQUM7SUFFRjs7T0FFRztJQUNILE1BQU0sb0JBQW9CLEdBQUcsR0FBRyxFQUFFO1FBQ2hDLElBQUksQ0FBQyxZQUFZLEVBQUU7WUFDakIsTUFBTSxJQUFJLGlCQUFpQixDQUFDLHFCQUFxQixDQUFDLENBQUM7U0FDcEQ7UUFFRCxNQUFNLE1BQU0sR0FBRyxPQUFDLENBQUMsTUFBTSxDQUFDO1lBQ3RCLFNBQVMsRUFBRSxPQUFDLENBQUMsTUFBTSxFQUFFLENBQUMsR0FBRyxDQUFDLENBQUMsQ0FBQztZQUM1QixLQUFLLEVBQUUsT0FBQyxDQUFDLE1BQU0sRUFBRSxDQUFDLEdBQUcsQ0FBQyxDQUFDLENBQUM7WUFDeEIsTUFBTSxFQUFFLE9BQUMsQ0FBQyxNQUFNLEVBQUU7U0FDbkIsQ0FBQyxDQUFDO1FBRUgsT0FBTyxJQUFBLHNCQUFRLEVBQXlCLE1BQU0sRUFBRSxZQUFZLENBQUMsQ0FBQztJQUNoRSxDQUFDLENBQUM7SUFFRjs7T0FFRztJQUNILE1BQU0sbUJBQW1CLEdBQUcsQ0FBQyxLQUFtQixFQUFFLFNBQWlCLEVBQUUsRUFBRTtRQUNyRSxJQUFJLENBQUMsS0FBSyxDQUFDLFNBQVMsQ0FBQyxFQUFFO1lBQ3JCLE1BQU0sSUFBSSxxQkFBcUIsQ0FBQyxrQkFBa0IsQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDO1NBQ2hFO1FBRUQsT0FBTyxLQUFLLENBQUM7SUFDZixDQUFDLENBQUM7SUFFRjs7T0FFRztJQUNILE1BQU0sT0FBTyxHQUFHLENBQUMsTUFBc0IsRUFBRSxFQUFFO1FBQ3pDLE1BQU0sZ0JBQWdCLEdBQUcsb0JBQW9CLEVBQUUsQ0FBQztRQUNoRCxNQUFNLEVBQUMsU0FBUyxFQUFFLFNBQVMsRUFBRSxLQUFLLEVBQUUsTUFBTSxFQUFDLEdBQUcsZ0JBQWdCLENBQUM7UUFFL0QsT0FBTyxNQUFNLENBQUMsR0FBRyxDQUFDLEtBQUssQ0FBQyxFQUFFO1lBQ3hCLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxNQUFNLENBQzdCLEVBQUUsRUFDRixLQUFLLEVBQ0wsbUJBQW1CLENBQUMsS0FBSyxFQUFFLFNBQVMsQ0FBQyxDQUN0QyxDQUFDO1lBRUYsT0FBTztnQkFDTCxHQUFHLEtBQUs7Z0JBQ1IsQ0FBQyxNQUFNLENBQUMsRUFBRSxlQUFlLENBQUMsU0FBUyxFQUFFLFNBQVMsRUFBRSxLQUFLLENBQUM7YUFDdkQsQ0FBQztRQUNKLENBQUMsQ0FBQyxDQUFDO0lBQ0wsQ0FBQyxDQUFDO0lBRUY7O09BRUc7SUFDSCxNQUFNLGVBQWUsR0FBRyxDQUN0QixLQUFtQixFQUNuQixTQUFpQixFQUNqQixLQUFhLEVBQ2IsRUFBRTtRQUNGLElBQUksQ0FBQyxLQUFLLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1lBQzFCLEtBQUssR0FBRyxHQUFHLEdBQUcsS0FBSyxDQUFDO1NBQ3JCO1FBRUQsSUFBSSxDQUFDLEtBQUssQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxLQUFLLENBQUMsUUFBUSxDQUFDLEdBQUcsQ0FBQyxFQUFFO1lBQ2pELEtBQUssSUFBSSxHQUFHLENBQUM7U0FDZDtRQUVELE1BQU0sS0FBSyxHQUFHLElBQUksQ0FBQyxLQUFLLENBQUMsQ0FBQztRQUMxQixNQUFNLFlBQVksR0FBRyxLQUFLLENBQUMsU0FBUyxDQUFDLENBQUMsS0FBSyxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBRW5ELElBQUksQ0FBQyxZQUFZLElBQUksWUFBWSxDQUFDLE1BQU0sS0FBSyxDQUFDLEVBQUU7WUFDOUMsTUFBTSxJQUFJLGtCQUFrQixDQUFDLGNBQWMsQ0FBQyxLQUFLLENBQUMsU0FBUyxDQUFDLEVBQUUsS0FBSyxDQUFDLENBQUMsQ0FBQztTQUN2RTtRQUVELE9BQU8sWUFBWSxDQUFDLElBQUksQ0FBQyxHQUFHLENBQUMsQ0FBQztJQUNoQyxDQUFDLENBQUM7SUFFRixPQUFPO1FBQ0wsUUFBUTtRQUNSLE9BQU87S0FDUixDQUFDO0FBQ0osQ0FBQyxDQUFDO0FBekZXLFFBQUEsS0FBSyxTQXlGaEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge3p9IGZyb20gJ3pvZCc7XG5pbXBvcnQge0VSUk9SU30gZnJvbSAnQGdybnNmdC9pZi1jb3JlL3V0aWxzJztcbmltcG9ydCB7XG4gIEV4ZWN1dGVQbHVnaW4sXG4gIFBsdWdpblBhcmFtcyxcbiAgQ29uZmlnUGFyYW1zLFxuICBQbHVnaW5QYXJhbWV0ZXJzTWV0YWRhdGEsXG59IGZyb20gJ0Bncm5zZnQvaWYtY29yZS90eXBlcyc7XG5cbmltcG9ydCB7dmFsaWRhdGV9IGZyb20gJy4uLy4uLy4uL2NvbW1vbi91dGlsL3ZhbGlkYXRpb25zJztcblxuaW1wb3J0IHtTVFJJTkdTfSBmcm9tICcuLi8uLi9jb25maWcnO1xuXG5jb25zdCB7TWlzc2luZ0lucHV0RGF0YUVycm9yLCBHbG9iYWxDb25maWdFcnJvciwgUmVnZXhNaXNtYXRjaEVycm9yfSA9IEVSUk9SUztcbmNvbnN0IHtNSVNTSU5HX0dMT0JBTF9DT05GSUcsIE1JU1NJTkdfSU5QVVRfREFUQSwgUkVHRVhfTUlTTUFUQ0h9ID0gU1RSSU5HUztcblxuZXhwb3J0IGNvbnN0IFJlZ2V4ID0gKFxuICBnbG9iYWxDb25maWc6IENvbmZpZ1BhcmFtcyxcbiAgcGFyYW1ldGVyc01ldGFkYXRhOiBQbHVnaW5QYXJhbWV0ZXJzTWV0YWRhdGFcbik6IEV4ZWN1dGVQbHVnaW4gPT4ge1xuICBjb25zdCBtZXRhZGF0YSA9IHtcbiAgICBraW5kOiAnZXhlY3V0ZScsXG4gICAgaW5wdXRzOiBwYXJhbWV0ZXJzTWV0YWRhdGE/LmlucHV0cyxcbiAgICBvdXRwdXRzOiBwYXJhbWV0ZXJzTWV0YWRhdGE/Lm91dHB1dHMsXG4gIH07XG5cbiAgLyoqXG4gICAqIENoZWNrcyBnbG9iYWwgY29uZmlnIHZhbHVlIGFyZSB2YWxpZC5cbiAgICovXG4gIGNvbnN0IHZhbGlkYXRlR2xvYmFsQ29uZmlnID0gKCkgPT4ge1xuICAgIGlmICghZ2xvYmFsQ29uZmlnKSB7XG4gICAgICB0aHJvdyBuZXcgR2xvYmFsQ29uZmlnRXJyb3IoTUlTU0lOR19HTE9CQUxfQ09ORklHKTtcbiAgICB9XG5cbiAgICBjb25zdCBzY2hlbWEgPSB6Lm9iamVjdCh7XG4gICAgICBwYXJhbWV0ZXI6IHouc3RyaW5nKCkubWluKDEpLFxuICAgICAgbWF0Y2g6IHouc3RyaW5nKCkubWluKDEpLFxuICAgICAgb3V0cHV0OiB6LnN0cmluZygpLFxuICAgIH0pO1xuXG4gICAgcmV0dXJuIHZhbGlkYXRlPHouaW5mZXI8dHlwZW9mIHNjaGVtYT4+KHNjaGVtYSwgZ2xvYmFsQ29uZmlnKTtcbiAgfTtcblxuICAvKipcbiAgICogQ2hlY2tzIGZvciByZXF1aXJlZCBmaWVsZHMgaW4gaW5wdXQuXG4gICAqL1xuICBjb25zdCB2YWxpZGF0ZVNpbmdsZUlucHV0ID0gKGlucHV0OiBQbHVnaW5QYXJhbXMsIHBhcmFtZXRlcjogc3RyaW5nKSA9PiB7XG4gICAgaWYgKCFpbnB1dFtwYXJhbWV0ZXJdKSB7XG4gICAgICB0aHJvdyBuZXcgTWlzc2luZ0lucHV0RGF0YUVycm9yKE1JU1NJTkdfSU5QVVRfREFUQShwYXJhbWV0ZXIpKTtcbiAgICB9XG5cbiAgICByZXR1cm4gaW5wdXQ7XG4gIH07XG5cbiAgLyoqXG4gICAqIEV4ZWN1dGVzIHRoZSByZWdleCBvZiB0aGUgZ2l2ZW4gcGFyYW1ldGVyLlxuICAgKi9cbiAgY29uc3QgZXhlY3V0ZSA9IChpbnB1dHM6IFBsdWdpblBhcmFtc1tdKSA9PiB7XG4gICAgY29uc3Qgc2FmZUdsb2JhbENvbmZpZyA9IHZhbGlkYXRlR2xvYmFsQ29uZmlnKCk7XG4gICAgY29uc3Qge3BhcmFtZXRlcjogcGFyYW1ldGVyLCBtYXRjaCwgb3V0cHV0fSA9IHNhZmVHbG9iYWxDb25maWc7XG5cbiAgICByZXR1cm4gaW5wdXRzLm1hcChpbnB1dCA9PiB7XG4gICAgICBjb25zdCBzYWZlSW5wdXQgPSBPYmplY3QuYXNzaWduKFxuICAgICAgICB7fSxcbiAgICAgICAgaW5wdXQsXG4gICAgICAgIHZhbGlkYXRlU2luZ2xlSW5wdXQoaW5wdXQsIHBhcmFtZXRlcilcbiAgICAgICk7XG5cbiAgICAgIHJldHVybiB7XG4gICAgICAgIC4uLmlucHV0LFxuICAgICAgICBbb3V0cHV0XTogZXh0cmFjdE1hdGNoaW5nKHNhZmVJbnB1dCwgcGFyYW1ldGVyLCBtYXRjaCksXG4gICAgICB9O1xuICAgIH0pO1xuICB9O1xuXG4gIC8qKlxuICAgKiBFeHRyYWN0cyBhIHN1YnN0cmluZyBmcm9tIHRoZSBnaXZlbiBpbnB1dCBwYXJhbWV0ZXIgdGhhdCBtYXRjaGVzIHRoZSBwcm92aWRlZCByZWd1bGFyIGV4cHJlc3Npb24gcGF0dGVybi5cbiAgICovXG4gIGNvbnN0IGV4dHJhY3RNYXRjaGluZyA9IChcbiAgICBpbnB1dDogUGx1Z2luUGFyYW1zLFxuICAgIHBhcmFtZXRlcjogc3RyaW5nLFxuICAgIG1hdGNoOiBzdHJpbmdcbiAgKSA9PiB7XG4gICAgaWYgKCFtYXRjaC5zdGFydHNXaXRoKCcvJykpIHtcbiAgICAgIG1hdGNoID0gJy8nICsgbWF0Y2g7XG4gICAgfVxuXG4gICAgaWYgKCFtYXRjaC5lbmRzV2l0aCgnL2cnKSAmJiAhbWF0Y2guZW5kc1dpdGgoJy8nKSkge1xuICAgICAgbWF0Y2ggKz0gJy8nO1xuICAgIH1cblxuICAgIGNvbnN0IHJlZ2V4ID0gZXZhbChtYXRjaCk7XG4gICAgY29uc3QgbWF0Y2hlZEl0ZW1zID0gaW5wdXRbcGFyYW1ldGVyXS5tYXRjaChyZWdleCk7XG5cbiAgICBpZiAoIW1hdGNoZWRJdGVtcyB8fCBtYXRjaGVkSXRlbXMubGVuZ3RoID09PSAwKSB7XG4gICAgICB0aHJvdyBuZXcgUmVnZXhNaXNtYXRjaEVycm9yKFJFR0VYX01JU01BVENIKGlucHV0W3BhcmFtZXRlcl0sIG1hdGNoKSk7XG4gICAgfVxuXG4gICAgcmV0dXJuIG1hdGNoZWRJdGVtcy5qb2luKCcgJyk7XG4gIH07XG5cbiAgcmV0dXJuIHtcbiAgICBtZXRhZGF0YSxcbiAgICBleGVjdXRlLFxuICB9O1xufTtcbiJdfQ==

package/build/if-run/builtins/sci/config.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIME_UNITS_IN_SECONDS = void 0;
+exports.TIME_UNITS_IN_SECONDS = {
+    s: 1,
+    second: 1,
+    sec: 1,
+    secs: 1,
+    seconds: 1,
+    min: 60,
+    mins: 60,
+    minute: 60,
+    minutes: 60,
+    h: 3600,
+    hs: 3600,
+    hr: 3600,
+    hrs: 3600,
+    hour: 3600,
+    hours: 3600,
+    d: 86400,
+    ds: 86400,
+    day: 86400,
+    days: 86400,
+    w: 604800,
+    ws: 604800,
+    wk: 604800,
+    wks: 604800,
+    week: 604800,
+    weeks: 604800,
+    m: 2419200,
+    mnth: 2419200,
+    mth: 2419200,
+    mnths: 2419200,
+    mths: 2419200,
+    month: 2419200,
+    months: 2419200,
+    y: 31536000,
+    ys: 31536000,
+    yr: 31536000,
+    yrs: 31536000,
+    year: 31536000,
+    years: 31536000,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/sci/index.d.ts

@@ -0,0 +1,2 @@
+import { ExecutePlugin, ConfigParams, PluginParametersMetadata } from '@grnsft/if-core/types';
+export declare const Sci: (globalConfig: ConfigParams, parametersMetadata: PluginParametersMetadata) => ExecutePlugin;

package/build/if-run/builtins/sci/index.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sci = void 0;
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { MissingInputDataError } = utils_1.ERRORS;
+const { MISSING_FUNCTIONAL_UNIT_CONFIG, MISSING_FUNCTIONAL_UNIT_INPUT, SCI_MISSING_FN_UNIT, ZERO_DIVISION, } = config_1.STRINGS;
+const Sci = (globalConfig, parametersMetadata) => {
+    const metadata = {
+        kind: 'execute',
+        inputs: {
+            ...{
+                carbon: {
+                    description: 'an amount of carbon emitted into the atmosphere',
+                    unit: 'gCO2e',
+                    'aggregation-method': 'sum',
+                },
+                'functional-unit': {
+                    description: 'the name of the functional unit in which the final SCI value should be expressed, e.g. requests, users',
+                    unit: 'none',
+                    'aggregation-method': 'sum',
+                },
+            },
+            ...parametersMetadata?.inputs,
+        },
+        outputs: parametersMetadata?.outputs || {
+            sci: {
+                description: 'carbon expressed in terms of the given functional unit',
+                unit: 'gCO2e',
+                'aggregation-method': 'sum',
+            },
+        },
+    };
+    /**
+     * Validates node and gloabl configs.
+     */
+    const validateConfig = (config) => {
+        const schema = zod_1.z
+            .object({
+            'functional-unit': zod_1.z.string(),
+        })
+            .refine(data => data['functional-unit'], {
+            message: MISSING_FUNCTIONAL_UNIT_CONFIG,
+        });
+        return (0, validations_1.validate)(schema, config);
+    };
+    /**
+     * Calculate the total emissions for a list of inputs.
+     */
+    const execute = (inputs) => inputs.map((input, index) => {
+        const safeInput = validateInput(input);
+        const functionalUnit = input[globalConfig['functional-unit']];
+        if (functionalUnit === 0) {
+            console.warn(ZERO_DIVISION(exports.Sci.name, index));
+            return {
+                ...input,
+                sci: safeInput['carbon'],
+            };
+        }
+        return {
+            ...input,
+            sci: safeInput['carbon'] / functionalUnit,
+        };
+    });
+    /**
+     * Checks for fields in input.
+     */
+    const validateInput = (input) => {
+        const validatedConfig = validateConfig(globalConfig);
+        if (!(validatedConfig['functional-unit'] in input &&
+            input[validatedConfig['functional-unit']] >= 0)) {
+            throw new MissingInputDataError(MISSING_FUNCTIONAL_UNIT_INPUT);
+        }
+        const schema = zod_1.z
+            .object({
+            carbon: zod_1.z.number().gte(0),
+            duration: zod_1.z.number().gte(1),
+        })
+            .refine(validations_1.allDefined, {
+            message: SCI_MISSING_FN_UNIT(globalConfig['functional-unit']),
+        });
+        return (0, validations_1.validate)(schema, input);
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Sci = Sci;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/sci-embodied/index.d.ts

@@ -0,0 +1,2 @@
+import { ExecutePlugin, PluginParametersMetadata } from '@grnsft/if-core/types';
+export declare const SciEmbodied: (parametersMetadata: PluginParametersMetadata) => ExecutePlugin;

package/build/if-run/builtins/sci-embodied/index.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SciEmbodied = void 0;
+const zod_1 = require("zod");
+const validations_1 = require("../../../common/util/validations");
+const config_1 = require("../../config");
+const { SCI_EMBODIED_ERROR } = config_1.STRINGS;
+const SciEmbodied = (parametersMetadata) => {
+    const metadata = {
+        kind: 'execute',
+        inputs: {
+            ...{
+                'device/emissions-embodied': {
+                    description: 'total embodied emissions of some component',
+                    unit: 'gCO2e',
+                    'aggregation-method': 'sum',
+                },
+                'device/expected-lifespan': {
+                    description: 'Total Expected Lifespan of the Component in Seconds',
+                    unit: 'seconds',
+                    'aggregation-method': 'sum',
+                },
+                'resources-reserved': {
+                    description: 'resources reserved for an application',
+                    unit: 'count',
+                    'aggregation-method': 'none',
+                },
+                'resources-total': {
+                    description: 'total resources available',
+                    unit: 'count',
+                    'aggregation-method': 'none',
+                },
+                'vcpus-allocated': {
+                    description: 'number of vcpus allocated to particular resource',
+                    unit: 'count',
+                    'aggregation-method': 'none',
+                },
+                'vcpus-total': {
+                    description: 'total number of vcpus available on a particular resource',
+                    unit: 'count',
+                    'aggregation-method': 'none',
+                },
+            },
+            ...parametersMetadata?.inputs,
+        },
+        outputs: parametersMetadata?.outputs || {
+            'carbon-embodied': {
+                description: 'embodied emissions of the component',
+                unit: 'gCO2e',
+                'aggregation-method': 'sum',
+            },
+        },
+    };
+    const METRICS = [
+        'device/emissions-embodied',
+        'device/expected-lifespan',
+        'resources-reserved',
+        'vcpus-allocated',
+        'resources-total',
+        'vcpus-total',
+    ];
+    /**
+     * Calculate the Embodied carbon for a list of inputs.
+     */
+    const execute = (inputs) => inputs.map(input => {
+        const safeInput = validateInput(input);
+        return {
+            ...input,
+            'carbon-embodied': calculateEmbodiedCarbon(safeInput),
+        };
+    });
+    /**
+     * Calculate the Embodied carbon for the input.
+     * M = totalEmissions * (duration/ExpectedLifespan) * (resourcesReserved/totalResources)
+     */
+    const calculateEmbodiedCarbon = (input) => {
+        const totalEmissions = input['device/emissions-embodied'];
+        const duration = input['duration'];
+        const expectedLifespan = input['device/expected-lifespan'];
+        const resourcesReserved = input['vcpus-allocated'] || input['resources-reserved'];
+        const totalResources = input['vcpus-total'] || input['resources-total'];
+        return (totalEmissions *
+            (duration / expectedLifespan) *
+            (resourcesReserved / totalResources));
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateInput = (input) => {
+        const commonSchemaPart = (errorMessage) => ({
+            'device/emissions-embodied': zod_1.z
+                .number({
+                invalid_type_error: errorMessage('gCO2e'),
+            })
+                .gte(0)
+                .min(0),
+            'device/expected-lifespan': zod_1.z
+                .number({
+                invalid_type_error: errorMessage('gCO2e'),
+            })
+                .gte(0)
+                .min(0),
+            duration: zod_1.z
+                .number({
+                invalid_type_error: errorMessage('seconds'),
+            })
+                .gte(1),
+        });
+        const vcpusSchemaPart = {
+            'vcpus-allocated': zod_1.z
+                .number({
+                invalid_type_error: SCI_EMBODIED_ERROR('count'),
+            })
+                .gte(0)
+                .min(0),
+            'vcpus-total': zod_1.z
+                .number({
+                invalid_type_error: SCI_EMBODIED_ERROR('count'),
+            })
+                .gte(0)
+                .min(0),
+        };
+        const resourcesSchemaPart = {
+            'resources-reserved': zod_1.z
+                .number({
+                invalid_type_error: SCI_EMBODIED_ERROR('count'),
+            })
+                .gte(0)
+                .min(0),
+            'resources-total': zod_1.z
+                .number({
+                invalid_type_error: SCI_EMBODIED_ERROR('count'),
+            })
+                .gte(0)
+                .min(0),
+        };
+        const schemaWithVcpus = zod_1.z.object({
+            ...commonSchemaPart(SCI_EMBODIED_ERROR),
+            ...vcpusSchemaPart,
+        });
+        const schemaWithResources = zod_1.z.object({
+            ...commonSchemaPart(SCI_EMBODIED_ERROR),
+            ...resourcesSchemaPart,
+        });
+        const schema = schemaWithVcpus.or(schemaWithResources).refine(validations_1.allDefined, {
+            message: `All ${METRICS} should be present.`,
+        });
+        return (0, validations_1.validate)(schema, input);
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.SciEmbodied = SciEmbodied;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/if-run/builtins/sci-embodied/index.ts"],"names":[],"mappings":"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","sourcesContent":["import {z} from 'zod';\nimport {\n  ExecutePlugin,\n  ParameterMetadata,\n  PluginParametersMetadata,\n  PluginParams,\n} from '@grnsft/if-core/types';\n\nimport {validate, allDefined} from '../../../common/util/validations';\n\nimport {STRINGS} from '../../config';\n\nconst {SCI_EMBODIED_ERROR} = STRINGS;\n\nexport const SciEmbodied = (\n  parametersMetadata: PluginParametersMetadata\n): ExecutePlugin => {\n  const metadata = {\n    kind: 'execute',\n    inputs: {\n      ...({\n        'device/emissions-embodied': {\n          description: 'total embodied emissions of some component',\n          unit: 'gCO2e',\n          'aggregation-method': 'sum',\n        },\n        'device/expected-lifespan': {\n          description: 'Total Expected Lifespan of the Component in Seconds',\n          unit: 'seconds',\n          'aggregation-method': 'sum',\n        },\n        'resources-reserved': {\n          description: 'resources reserved for an application',\n          unit: 'count',\n          'aggregation-method': 'none',\n        },\n        'resources-total': {\n          description: 'total resources available',\n          unit: 'count',\n          'aggregation-method': 'none',\n        },\n        'vcpus-allocated': {\n          description: 'number of vcpus allocated to particular resource',\n          unit: 'count',\n          'aggregation-method': 'none',\n        },\n        'vcpus-total': {\n          description:\n            'total number of vcpus available on a particular resource',\n          unit: 'count',\n          'aggregation-method': 'none',\n        },\n      } as ParameterMetadata),\n      ...parametersMetadata?.inputs,\n    },\n    outputs: parametersMetadata?.outputs || {\n      'carbon-embodied': {\n        description: 'embodied emissions of the component',\n        unit: 'gCO2e',\n        'aggregation-method': 'sum',\n      },\n    },\n  };\n\n  const METRICS = [\n    'device/emissions-embodied',\n    'device/expected-lifespan',\n    'resources-reserved',\n    'vcpus-allocated',\n    'resources-total',\n    'vcpus-total',\n  ];\n\n  /**\n   * Calculate the Embodied carbon for a list of inputs.\n   */\n  const execute = (inputs: PluginParams[]) =>\n    inputs.map(input => {\n      const safeInput = validateInput(input);\n\n      return {\n        ...input,\n        'carbon-embodied': calculateEmbodiedCarbon(safeInput),\n      };\n    });\n\n  /**\n   * Calculate the Embodied carbon for the input.\n   * M = totalEmissions * (duration/ExpectedLifespan) * (resourcesReserved/totalResources)\n   */\n  const calculateEmbodiedCarbon = (input: PluginParams) => {\n    const totalEmissions = input['device/emissions-embodied'];\n    const duration = input['duration'];\n    const expectedLifespan = input['device/expected-lifespan'];\n    const resourcesReserved =\n      input['vcpus-allocated'] || input['resources-reserved'];\n    const totalResources = input['vcpus-total'] || input['resources-total'];\n\n    return (\n      totalEmissions *\n      (duration / expectedLifespan) *\n      (resourcesReserved / totalResources)\n    );\n  };\n\n  /**\n   * Checks for required fields in input.\n   */\n  const validateInput = (input: PluginParams) => {\n    const commonSchemaPart = (errorMessage: (unit: string) => string) => ({\n      'device/emissions-embodied': z\n        .number({\n          invalid_type_error: errorMessage('gCO2e'),\n        })\n        .gte(0)\n        .min(0),\n      'device/expected-lifespan': z\n        .number({\n          invalid_type_error: errorMessage('gCO2e'),\n        })\n        .gte(0)\n        .min(0),\n      duration: z\n        .number({\n          invalid_type_error: errorMessage('seconds'),\n        })\n        .gte(1),\n    });\n\n    const vcpusSchemaPart = {\n      'vcpus-allocated': z\n        .number({\n          invalid_type_error: SCI_EMBODIED_ERROR('count'),\n        })\n        .gte(0)\n        .min(0),\n      'vcpus-total': z\n        .number({\n          invalid_type_error: SCI_EMBODIED_ERROR('count'),\n        })\n        .gte(0)\n        .min(0),\n    };\n\n    const resourcesSchemaPart = {\n      'resources-reserved': z\n        .number({\n          invalid_type_error: SCI_EMBODIED_ERROR('count'),\n        })\n        .gte(0)\n        .min(0),\n      'resources-total': z\n        .number({\n          invalid_type_error: SCI_EMBODIED_ERROR('count'),\n        })\n        .gte(0)\n        .min(0),\n    };\n\n    const schemaWithVcpus = z.object({\n      ...commonSchemaPart(SCI_EMBODIED_ERROR),\n      ...vcpusSchemaPart,\n    });\n    const schemaWithResources = z.object({\n      ...commonSchemaPart(SCI_EMBODIED_ERROR),\n      ...resourcesSchemaPart,\n    });\n\n    const schema = schemaWithVcpus.or(schemaWithResources).refine(allDefined, {\n      message: `All ${METRICS} should be present.`,\n    });\n\n    return validate<z.infer<typeof schema>>(schema, input);\n  };\n\n  return {\n    metadata,\n    execute,\n  };\n};\n"]}

package/build/if-run/builtins/shell/index.d.ts

@@ -0,0 +1,2 @@
+import { ExecutePlugin, ConfigParams, PluginParametersMetadata } from '@grnsft/if-core/types';
+export declare const Shell: (globalConfig: ConfigParams, parametersMetadata: PluginParametersMetadata) => ExecutePlugin;

package/build/if-run/builtins/shell/index.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shell = void 0;
+const child_process_1 = require("child_process");
+const js_yaml_1 = require("js-yaml");
+const zod_1 = require("zod");
+const utils_1 = require("@grnsft/if-core/utils");
+const validations_1 = require("../../../common/util/validations");
+const { ProcessExecutionError } = utils_1.ERRORS;
+const Shell = (globalConfig, parametersMetadata) => {
+    const metadata = {
+        kind: 'execute',
+        inputs: parametersMetadata?.inputs,
+        outputs: parametersMetadata?.outputs,
+    };
+    /**
+     * Calculate the total emissions for a list of inputs.
+     */
+    const execute = (inputs) => {
+        const inputWithConfig = Object.assign({}, inputs[0], validateConfig());
+        const command = inputWithConfig.command;
+        const inputAsString = (0, js_yaml_1.dump)(inputs, { indent: 2 });
+        const results = runModelInShell(inputAsString, command);
+        return results?.outputs?.flat();
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateConfig = () => {
+        const schema = zod_1.z.object({
+            command: zod_1.z.string(),
+        });
+        return (0, validations_1.validate)(schema, globalConfig);
+    };
+    /**
+     * Runs the model in a shell. Spawns a child process to run an external IMP,
+     * an executable with a CLI exposing two methods: `--execute` and `--manifest`.
+     * The shell command then calls the `--command` method passing var manifest as the path to the desired manifest file.
+     */
+    const runModelInShell = (input, command) => {
+        try {
+            const [executable, ...args] = command.split(' ');
+            const result = (0, child_process_1.spawnSync)(executable, args, {
+                input,
+                encoding: 'utf8',
+            });
+            const outputs = (0, js_yaml_1.loadAll)(result.stdout);
+            return { outputs };
+        }
+        catch (error) {
+            throw new ProcessExecutionError(error.message);
+        }
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Shell = Shell;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-run/builtins/subtract/index.d.ts

@@ -0,0 +1,2 @@
+import { ExecutePlugin, PluginParametersMetadata, SubtractConfig } from '@grnsft/if-core/types';
+export declare const Subtract: (globalConfig: SubtractConfig, parametersMetadata: PluginParametersMetadata) => ExecutePlugin;

package/build/if-run/builtins/subtract/index.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Subtract = void 0;
+const zod_1 = require("zod");
+const validations_1 = require("../../../common/util/validations");
+const Subtract = (globalConfig, parametersMetadata) => {
+    const metadata = {
+        kind: 'execute',
+        inputs: parametersMetadata?.inputs,
+        outputs: parametersMetadata?.outputs,
+    };
+    /**
+     * Checks global config value are valid.
+     */
+    const validateGlobalConfig = () => {
+        const globalConfigSchema = zod_1.z.object({
+            'input-parameters': zod_1.z.array(zod_1.z.string()),
+            'output-parameter': zod_1.z.string().min(1),
+        });
+        return (0, validations_1.validate)(globalConfigSchema, globalConfig);
+    };
+    /**
+     * Checks for required fields in input.
+     */
+    const validateSingleInput = (input, inputParameters) => {
+        const inputData = inputParameters.reduce((acc, param) => {
+            acc[param] = input[param];
+            return acc;
+        }, {});
+        const validationSchema = zod_1.z.record(zod_1.z.string(), zod_1.z.number());
+        (0, validations_1.validate)(validationSchema, inputData);
+        return input;
+    };
+    /**
+     * Subtract items from inputParams[1..n] from inputParams[0] and write the result in a new param outputParam.
+     */
+    const execute = (inputs) => {
+        const { 'input-parameters': inputParameters, 'output-parameter': outputParameter, } = validateGlobalConfig();
+        return inputs.map(input => {
+            validateSingleInput(input, inputParameters);
+            return {
+                ...input,
+                [outputParameter]: calculateDiff(input, inputParameters),
+            };
+        });
+    };
+    /**
+     * Calculates the diff between the 1st item in the inputs nad the rest of the items
+     */
+    const calculateDiff = (input, inputParameters) => {
+        const [firstItem, ...restItems] = inputParameters;
+        return restItems.reduce((accumulator, metricToSubtract) => accumulator - input[metricToSubtract], input[firstItem] // Starting accumulator with the value of the first item
+        );
+    };
+    return {
+        metadata,
+        execute,
+    };
+};
+exports.Subtract = Subtract;
+//# sourceMappingURL=data:application/json;base64,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