@grnsft/if 1.0.1 → 1.1.0-beta.0

package/build/if-api/config/config.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = void 0;
+const config_1 = require("../../common/config");
+const { DISCLAIMER_MESSAGE } = config_1.STRINGS;
+/**
+ * Configuration for if-api.
+ */
+exports.CONFIG = {
+    ARGS: {
+        debug: {
+            type: Boolean,
+            alias: 'd',
+            description: 'Print debug logs to the console',
+            defaultValue: false,
+        },
+        disableExternalPluginWarning: {
+            type: Boolean,
+            alias: 'w',
+            description: 'Disable external plugin warning',
+            defaultValue: false,
+        },
+        disabledPlugins: {
+            type: String,
+            alias: 'f',
+            description: 'Filename that contains plugin names to be disabled',
+            optional: true,
+        },
+        port: {
+            type: String,
+            alias: 'p',
+            description: 'Port to listen on',
+            defaultValue: process.env.PORT ?? '3000',
+        },
+        host: {
+            type: String,
+            alias: 'b',
+            description: 'Host to listen on',
+            defaultValue: process.env.HOST ?? 'localhost',
+        },
+        help: {
+            type: Boolean,
+            alias: 'h',
+            description: 'Show help',
+            optional: true,
+        },
+    },
+    HELP: {
+        helpArg: 'help',
+        headerContentSections: [
+            { header: 'Impact Framework', content: 'Helpful keywords:' },
+        ],
+        footerContentSections: [
+            { header: 'Green Software Foundation', content: DISCLAIMER_MESSAGE },
+        ],
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-api/config/index.d.ts

@@ -0,0 +1,2 @@
+export { CONFIG } from './config';
+export { STRINGS } from './strings';

package/build/if-api/config/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = exports.CONFIG = void 0;
+var config_1 = require("./config");
+Object.defineProperty(exports, "CONFIG", { enumerable: true, get: function () { return config_1.CONFIG; } });
+var strings_1 = require("./strings");
+Object.defineProperty(exports, "STRINGS", { enumerable: true, get: function () { return strings_1.STRINGS; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvaWYtYXBpL2NvbmZpZy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQSxtQ0FBZ0M7QUFBeEIsZ0dBQUEsTUFBTSxPQUFBO0FBQ2QscUNBQWtDO0FBQTFCLGtHQUFBLE9BQU8sT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7Q09ORklHfSBmcm9tICcuL2NvbmZpZyc7XG5leHBvcnQge1NUUklOR1N9IGZyb20gJy4vc3RyaW5ncyc7XG4iXX0=

package/build/if-api/config/strings.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Strings for if-api.
+ */
+export declare const STRINGS: {
+    readonly SERVER_STARTED: (addr: string) => string;
+    readonly SERVER_START_FAILED: (err: Error) => string;
+    readonly PROCESSING_REQUEST: "Processing request";
+    readonly INTERNAL_SERVER_ERROR: "Internal Server Error";
+    readonly INVALID_JSON: "Invalid JSON format";
+    readonly INVALID_YAML: "Invalid YAML format";
+    readonly MISSING_MANIFEST: "Missing manifest in request body";
+    readonly UNSUPPORTED_CONTENT_TYPE: "Unsupported content type. Supported types are: application/json, application/yaml";
+    readonly DISCLAIMER_MESSAGE: "Impact Framework API - Green Software Foundation";
+    readonly INVALID_DISABLED_PLUGINS: (line: string) => string;
+    readonly INVALID_PORT_NUMBER: (port: string) => string;
+};

package/build/if-api/config/strings.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STRINGS = void 0;
+/**
+ * Strings for if-api.
+ */
+exports.STRINGS = {
+    SERVER_STARTED: (addr) => `Server started on ${addr}`,
+    SERVER_START_FAILED: (err) => `Failed to start server: ${err}`,
+    PROCESSING_REQUEST: 'Processing request',
+    INTERNAL_SERVER_ERROR: 'Internal Server Error',
+    INVALID_JSON: 'Invalid JSON format',
+    INVALID_YAML: 'Invalid YAML format',
+    MISSING_MANIFEST: 'Missing manifest in request body',
+    UNSUPPORTED_CONTENT_TYPE: 'Unsupported content type. Supported types are: application/json, application/yaml',
+    DISCLAIMER_MESSAGE: 'Impact Framework API - Green Software Foundation',
+    INVALID_DISABLED_PLUGINS: (line) => `Invalid DisabledPlugins settings:${line}`,
+    INVALID_PORT_NUMBER: (port) => `Invalid port number \`${port}\`. The port number should be a number between 0 and 65535.`,
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RyaW5ncy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9pZi1hcGkvY29uZmlnL3N0cmluZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDVSxRQUFBLE9BQU8sR0FBRztJQUNyQixjQUFjLEVBQUUsQ0FBQyxJQUFZLEVBQUUsRUFBRSxDQUFDLHFCQUFxQixJQUFJLEVBQUU7SUFDN0QsbUJBQW1CLEVBQUUsQ0FBQyxHQUFVLEVBQUUsRUFBRSxDQUFDLDJCQUEyQixHQUFHLEVBQUU7SUFDckUsa0JBQWtCLEVBQUUsb0JBQW9CO0lBQ3hDLHFCQUFxQixFQUFFLHVCQUF1QjtJQUM5QyxZQUFZLEVBQUUscUJBQXFCO0lBQ25DLFlBQVksRUFBRSxxQkFBcUI7SUFDbkMsZ0JBQWdCLEVBQUUsa0NBQWtDO0lBQ3BELHdCQUF3QixFQUN0QixtRkFBbUY7SUFDckYsa0JBQWtCLEVBQUUsa0RBQWtEO0lBQ3RFLHdCQUF3QixFQUFFLENBQUMsSUFBWSxFQUFFLEVBQUUsQ0FDekMsb0NBQW9DLElBQUksRUFBRTtJQUM1QyxtQkFBbUIsRUFBRSxDQUFDLElBQVksRUFBRSxFQUFFLENBQ3BDLHlCQUF5QixJQUFJLDZEQUE2RDtDQUNwRixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBTdHJpbmdzIGZvciBpZi1hcGkuXG4gKi9cbmV4cG9ydCBjb25zdCBTVFJJTkdTID0ge1xuICBTRVJWRVJfU1RBUlRFRDogKGFkZHI6IHN0cmluZykgPT4gYFNlcnZlciBzdGFydGVkIG9uICR7YWRkcn1gLFxuICBTRVJWRVJfU1RBUlRfRkFJTEVEOiAoZXJyOiBFcnJvcikgPT4gYEZhaWxlZCB0byBzdGFydCBzZXJ2ZXI6ICR7ZXJyfWAsXG4gIFBST0NFU1NJTkdfUkVRVUVTVDogJ1Byb2Nlc3NpbmcgcmVxdWVzdCcsXG4gIElOVEVSTkFMX1NFUlZFUl9FUlJPUjogJ0ludGVybmFsIFNlcnZlciBFcnJvcicsXG4gIElOVkFMSURfSlNPTjogJ0ludmFsaWQgSlNPTiBmb3JtYXQnLFxuICBJTlZBTElEX1lBTUw6ICdJbnZhbGlkIFlBTUwgZm9ybWF0JyxcbiAgTUlTU0lOR19NQU5JRkVTVDogJ01pc3NpbmcgbWFuaWZlc3QgaW4gcmVxdWVzdCBib2R5JyxcbiAgVU5TVVBQT1JURURfQ09OVEVOVF9UWVBFOlxuICAgICdVbnN1cHBvcnRlZCBjb250ZW50IHR5cGUuIFN1cHBvcnRlZCB0eXBlcyBhcmU6IGFwcGxpY2F0aW9uL2pzb24sIGFwcGxpY2F0aW9uL3lhbWwnLFxuICBESVNDTEFJTUVSX01FU1NBR0U6ICdJbXBhY3QgRnJhbWV3b3JrIEFQSSAtIEdyZWVuIFNvZnR3YXJlIEZvdW5kYXRpb24nLFxuICBJTlZBTElEX0RJU0FCTEVEX1BMVUdJTlM6IChsaW5lOiBzdHJpbmcpID0+XG4gICAgYEludmFsaWQgRGlzYWJsZWRQbHVnaW5zIHNldHRpbmdzOiR7bGluZX1gLFxuICBJTlZBTElEX1BPUlRfTlVNQkVSOiAocG9ydDogc3RyaW5nKSA9PlxuICAgIGBJbnZhbGlkIHBvcnQgbnVtYmVyIFxcYCR7cG9ydH1cXGAuIFRoZSBwb3J0IG51bWJlciBzaG91bGQgYmUgYSBudW1iZXIgYmV0d2VlbiAwIGFuZCA2NTUzNS5gLFxufSBhcyBjb25zdDtcbiJdfQ==

package/build/if-api/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/if-api/index.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("fs/promises");
+const express_1 = __importDefault(require("express"));
+const js_yaml_1 = require("js-yaml");
+const utils_1 = require("@grnsft/if-core/utils");
+const debug_logger_1 = require("../common/util/debug-logger");
+const logger_1 = require("../common/util/logger");
+const storage_1 = require("../common/util/storage");
+const validations_1 = require("../common/util/validations");
+const aggregate_1 = require("../if-run/lib/aggregate");
+const environment_1 = require("../if-run/lib/environment");
+const initialize_1 = require("../if-run/lib/initialize");
+const compute_1 = require("../if-run/lib/compute");
+const explain_1 = require("../if-run/lib/explain");
+const config_1 = require("./config");
+const args_1 = require("./util/args");
+const { DISCLAIMER_MESSAGE, INTERNAL_SERVER_ERROR, INVALID_DISABLED_PLUGINS, INVALID_JSON, INVALID_YAML, MISSING_MANIFEST, PROCESSING_REQUEST, SERVER_STARTED, SERVER_START_FAILED, UNSUPPORTED_CONTENT_TYPE, } = config_1.STRINGS;
+const CT_YAML = 'application/yaml';
+const CT_JSON = 'application/json';
+const CT_VALID = [CT_YAML, CT_JSON];
+const ERROR_LIST = Object.values(utils_1.ERRORS);
+/**
+ * Determine response type.
+ */
+const determineResponseType = (req) => {
+    const acceptHeader = req.get('Accept');
+    if (acceptHeader && acceptHeader !== '*/*') {
+        // Determine based on request Accept header
+        const responseType = req.accepts(CT_VALID);
+        if (responseType) {
+            return responseType;
+        }
+    }
+    // Determine based on request Content-Type
+    return req.get('Content-Type');
+};
+/**
+ * Send the response in the appropriate format.
+ */
+const sendResponse = (req, res, manifest, status) => {
+    const responseType = determineResponseType(req);
+    if (responseType === CT_YAML) {
+        const yamlData = (0, js_yaml_1.dump)(manifest, { noRefs: true });
+        res.set('Content-Type', responseType);
+        res.status(status).send(yamlData);
+    }
+    else {
+        res.set('Content-Type', responseType);
+        res.status(status).json(manifest);
+    }
+};
+/**
+ * Parse disabled plugins file
+ * @param filename Filename that contains plugin names to be disabled
+ * @returns Set of disabledPlugins
+ */
+const parseDisabledPlugins = async (filename) => {
+    // If no filename is specified, disable builtin:Shell, builtin:CSVImport, builtin:CSVLookup by default.
+    if (!filename) {
+        return new Set([
+            'builtin:Shell',
+            'builtin:CSVImport',
+            'builtin:CSVLookup',
+        ]);
+    }
+    const disabledPlugins = new Set();
+    const file = await (0, promises_1.open)(filename);
+    try {
+        for await (const line of file.readLines()) {
+            const words = line.split(/ *: */);
+            switch (words.length) {
+                case 1:
+                    disabledPlugins.add(`builtin:${words[0]}`);
+                    break;
+                case 2:
+                    disabledPlugins.add(`${words[0]}:${words[1]}`);
+                    break;
+                default:
+                    throw new Error(INVALID_DISABLED_PLUGINS(line));
+            }
+        }
+    }
+    finally {
+        await file.close();
+    }
+    return disabledPlugins;
+};
+const formatAddr = (addr) => {
+    if (typeof addr === 'string') {
+        return addr;
+    }
+    else if (addr === null) {
+        return 'unknown';
+    }
+    else if (addr.family === 'IPv6') {
+        return `[${addr.address}]:${addr.port}`;
+    }
+    else {
+        return `${addr.address}:${addr.port}`;
+    }
+};
+/**
+ * Start the API server.
+ */
+const startServer = async () => {
+    const options = (0, args_1.parseIfApiProcessArgs)();
+    debug_logger_1.debugLogger.overrideConsoleMethods(options.debug);
+    logger_1.logger.info(DISCLAIMER_MESSAGE);
+    (0, initialize_1.setExternalPluginWarning)(!options.disableExternalPluginWarning);
+    const disabledPlugins = await parseDisabledPlugins(options.disabledPlugins);
+    (0, initialize_1.setDisabledPlugins)(disabledPlugins);
+    // Get execution information (command, environment).
+    const execution = await (0, environment_1.getExecution)();
+    const app = (0, express_1.default)();
+    // Middleware for JSON requests
+    app.use(express_1.default.json({ type: CT_JSON }));
+    // Custom middleware for YAML requests
+    app.use(express_1.default.text({ type: CT_YAML }), (req, res, next) => {
+        if (req.is(CT_YAML)) {
+            try {
+                req.body = (0, js_yaml_1.load)(req.body);
+            }
+            catch (err) {
+                res.status(400).json({
+                    error: INVALID_YAML,
+                    detail: err.message,
+                });
+                return;
+            }
+        }
+        next();
+    });
+    // Add request context storage
+    app.use((_req, _res, next) => (0, storage_1.executeWithContext)(next));
+    // Health check endpoint
+    app.get('/health', (_req, res) => {
+        res.status(200).send('OK');
+    });
+    // Process manifest endpoint
+    app.post('/v1/run', async (req, res) => {
+        logger_1.logger.info(PROCESSING_REQUEST);
+        // Check if request body exists
+        if (!req.body) {
+            res.status(400).json({ error: MISSING_MANIFEST });
+            return;
+        }
+        // Check request Content-Type
+        if (!req.is(CT_VALID)) {
+            res.status(415).json({ error: UNSUPPORTED_CONTENT_TYPE });
+            return;
+        }
+        // Create manifest with execution information
+        const envManifest = {
+            ...req.body,
+            execution: {
+                command: execution.command,
+                environment: {
+                    ...execution.environment,
+                    'date-time': `${new Date().toISOString()} (UTC)`,
+                },
+                status: execution.status,
+            },
+        };
+        try {
+            const { tree, ...context } = (0, validations_1.validateManifest)(envManifest);
+            const pluginStorage = await (0, initialize_1.initialize)(context);
+            const computedTree = await (0, compute_1.compute)(tree, {
+                context,
+                pluginStorage,
+                observe: req.query.observe === 'true',
+                regroup: req.query.regroup === 'true',
+                compute: req.query.compute === 'true',
+                append: false,
+            });
+            const aggregatedTree = (0, aggregate_1.aggregate)(computedTree, context.aggregation);
+            envManifest.explainer && (context.explain = (0, explain_1.explain)());
+            // Prepare response data
+            const responseData = { tree: aggregatedTree, ...context };
+            // Return response in the determined format
+            sendResponse(req, res, responseData, 200);
+        }
+        catch (err) {
+            // If it's one of the errors in ERRORS, terminate with status code 400
+            if (ERROR_LIST.some(val => err instanceof val)) {
+                /** Execution block exists because manifest is already processed. Set's status to `fail`. */
+                envManifest.execution.status = 'fail';
+                envManifest.execution.error = err.toString();
+                // Return response in the determined format
+                sendResponse(req, res, envManifest, 400);
+                return;
+            }
+            // Set Content-Type to application/json
+            res.set('Content-Type', CT_JSON);
+            // For all other cases, terminate with status code 500
+            if (err instanceof Error) {
+                res.status(500).json({
+                    error: INTERNAL_SERVER_ERROR,
+                    detail: err.message,
+                });
+                return;
+            }
+            res.status(500).json({ error: INTERNAL_SERVER_ERROR });
+        }
+    });
+    // Set up custom error handler
+    app.use(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    (err, _req, res, _next) => {
+        // Set Content-Type to application/json
+        res.set('Content-Type', CT_JSON);
+        // If SyntaxError (JSON parse error), terminate with status code 400
+        if (err.status === 400 && err instanceof SyntaxError && 'body' in err) {
+            res.status(400).json({
+                error: INVALID_JSON,
+                detail: err.message,
+            });
+        }
+        else if (err instanceof Error) {
+            if ('status' in err) {
+                res.status(err.status).json({
+                    error: err.message,
+                });
+            }
+            else {
+                res.status(500).json({
+                    error: INTERNAL_SERVER_ERROR,
+                    detail: err.message,
+                });
+            }
+        }
+        else {
+            res.status(500).json({
+                error: INTERNAL_SERVER_ERROR,
+            });
+        }
+    });
+    // Start the server
+    const { port, host } = options;
+    const server = app.listen(port, host, (err) => {
+        if (err) {
+            logger_1.logger.error(SERVER_START_FAILED(err));
+            // eslint-disable-next-line no-process-exit
+            process.exit(2);
+        }
+        logger_1.logger.info(SERVER_STARTED(formatAddr(server.address())));
+    });
+    // Handle Signal
+    const handler = (err) => {
+        logger_1.logger.debug(`${err} signal received: closing HTTP server`);
+        server.close(() => {
+            logger_1.logger.debug('HTTP server closed');
+        });
+    };
+    process.once('SIGTERM', handler);
+    process.once('SIGINT', handler);
+};
+// Start the server
+startServer().catch(err => {
+    logger_1.logger.error(SERVER_START_FAILED(err));
+    // eslint-disable-next-line no-process-exit
+    process.exit(2);
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/if-api/index.ts"],"names":[],"mappings":"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","sourcesContent":["#!/usr/bin/env node\nimport {open} from 'fs/promises';\nimport type {AddressInfo} from 'net';\n\nimport express from 'express';\nimport type {NextFunction, Request, Response} from 'express';\nimport {dump, load} from 'js-yaml';\nimport {ERRORS} from '@grnsft/if-core/utils';\n\nimport type {Manifest} from '../common/types/manifest';\nimport {debugLogger} from '../common/util/debug-logger';\nimport {logger} from '../common/util/logger';\nimport {executeWithContext} from '../common/util/storage';\nimport {validateManifest} from '../common/util/validations';\n\nimport {aggregate} from '../if-run/lib/aggregate';\nimport {getExecution} from '../if-run/lib/environment';\nimport {\n  initialize,\n  setExternalPluginWarning,\n  setDisabledPlugins,\n} from '../if-run/lib/initialize';\nimport {compute} from '../if-run/lib/compute';\nimport {explain} from '../if-run/lib/explain';\n\nimport {STRINGS} from './config';\nimport {parseIfApiProcessArgs} from './util/args';\n\nconst {\n  DISCLAIMER_MESSAGE,\n  INTERNAL_SERVER_ERROR,\n  INVALID_DISABLED_PLUGINS,\n  INVALID_JSON,\n  INVALID_YAML,\n  MISSING_MANIFEST,\n  PROCESSING_REQUEST,\n  SERVER_STARTED,\n  SERVER_START_FAILED,\n  UNSUPPORTED_CONTENT_TYPE,\n} = STRINGS;\n\nconst CT_YAML = 'application/yaml';\nconst CT_JSON = 'application/json';\nconst CT_VALID = [CT_YAML, CT_JSON];\n\nconst ERROR_LIST: readonly ErrorConstructor[] = Object.values(ERRORS);\n\n/**\n * Determine response type.\n */\nconst determineResponseType = (req: express.Request) => {\n  const acceptHeader = req.get('Accept');\n  if (acceptHeader && acceptHeader !== '*/*') {\n    // Determine based on request Accept header\n    const responseType = req.accepts(CT_VALID);\n    if (responseType) {\n      return responseType;\n    }\n  }\n\n  // Determine based on request Content-Type\n  return req.get('Content-Type');\n};\n\n/**\n * Send the response in the appropriate format.\n */\nconst sendResponse = (\n  req: Request,\n  res: Response,\n  manifest: Manifest,\n  status: number\n) => {\n  const responseType = determineResponseType(req);\n  if (responseType === CT_YAML) {\n    const yamlData = dump(manifest, {noRefs: true});\n    res.set('Content-Type', responseType);\n    res.status(status).send(yamlData);\n  } else {\n    res.set('Content-Type', responseType);\n    res.status(status).json(manifest);\n  }\n};\n\n/**\n * Parse disabled plugins file\n * @param filename Filename that contains plugin names to be disabled\n * @returns Set of disabledPlugins\n */\nconst parseDisabledPlugins = async (filename: string | undefined) => {\n  // If no filename is specified, disable builtin:Shell, builtin:CSVImport, builtin:CSVLookup by default.\n  if (!filename) {\n    return new Set<string>([\n      'builtin:Shell',\n      'builtin:CSVImport',\n      'builtin:CSVLookup',\n    ]);\n  }\n\n  const disabledPlugins = new Set<string>();\n  const file = await open(filename);\n  try {\n    for await (const line of file.readLines()) {\n      const words = line.split(/ *: */);\n      switch (words.length) {\n        case 1:\n          disabledPlugins.add(`builtin:${words[0]}`);\n          break;\n        case 2:\n          disabledPlugins.add(`${words[0]}:${words[1]}`);\n          break;\n        default:\n          throw new Error(INVALID_DISABLED_PLUGINS(line));\n      }\n    }\n  } finally {\n    await file.close();\n  }\n  return disabledPlugins;\n};\n\nconst formatAddr = (addr: string | AddressInfo | null): string => {\n  if (typeof addr === 'string') {\n    return addr;\n  } else if (addr === null) {\n    return 'unknown';\n  } else if (addr.family === 'IPv6') {\n    return `[${addr.address}]:${addr.port}`;\n  } else {\n    return `${addr.address}:${addr.port}`;\n  }\n};\n\n/**\n * Start the API server.\n */\nconst startServer = async () => {\n  const options = parseIfApiProcessArgs();\n\n  debugLogger.overrideConsoleMethods(options.debug);\n\n  logger.info(DISCLAIMER_MESSAGE);\n\n  setExternalPluginWarning(!options.disableExternalPluginWarning);\n\n  const disabledPlugins = await parseDisabledPlugins(options.disabledPlugins);\n  setDisabledPlugins(disabledPlugins);\n\n  // Get execution information (command, environment).\n  const execution = await getExecution();\n\n  const app = express();\n\n  // Middleware for JSON requests\n  app.use(express.json({type: CT_JSON}));\n\n  // Custom middleware for YAML requests\n  app.use(\n    express.text({type: CT_YAML}),\n    (req: Request, res: Response, next: NextFunction): void => {\n      if (req.is(CT_YAML)) {\n        try {\n          req.body = load(req.body);\n        } catch (err: any) {\n          res.status(400).json({\n            error: INVALID_YAML,\n            detail: err.message,\n          });\n          return;\n        }\n      }\n      next();\n    }\n  );\n\n  // Add request context storage\n  app.use((_req: Request, _res: Response, next: NextFunction): void =>\n    executeWithContext(next)\n  );\n\n  // Health check endpoint\n  app.get('/health', (_req: Request, res: Response): void => {\n    res.status(200).send('OK');\n  });\n\n  // Process manifest endpoint\n  app.post('/v1/run', async (req: Request, res: Response): Promise<void> => {\n    logger.info(PROCESSING_REQUEST);\n\n    // Check if request body exists\n    if (!req.body) {\n      res.status(400).json({error: MISSING_MANIFEST});\n      return;\n    }\n\n    // Check request Content-Type\n    if (!req.is(CT_VALID)) {\n      res.status(415).json({error: UNSUPPORTED_CONTENT_TYPE});\n      return;\n    }\n\n    // Create manifest with execution information\n    const envManifest: Manifest = {\n      ...req.body,\n      execution: {\n        command: execution.command,\n        environment: {\n          ...execution.environment,\n          'date-time': `${new Date().toISOString()} (UTC)`,\n        },\n        status: execution.status,\n      },\n    };\n\n    try {\n      const {tree, ...context} = validateManifest(envManifest);\n\n      const pluginStorage = await initialize(context);\n\n      const computedTree = await compute(tree, {\n        context,\n        pluginStorage,\n        observe: req.query.observe === 'true',\n        regroup: req.query.regroup === 'true',\n        compute: req.query.compute === 'true',\n        append: false,\n      });\n\n      const aggregatedTree = aggregate(computedTree, context.aggregation);\n\n      envManifest.explainer && (context.explain = explain());\n\n      // Prepare response data\n      const responseData = {tree: aggregatedTree, ...context};\n\n      // Return response in the determined format\n      sendResponse(req, res, responseData, 200);\n    } catch (err) {\n      // If it's one of the errors in ERRORS, terminate with status code 400\n      if (ERROR_LIST.some(val => err instanceof val)) {\n        /** Execution block exists because manifest is already processed. Set's status to `fail`. */\n        envManifest.execution!.status = 'fail';\n        envManifest.execution!.error = (err as Error).toString();\n\n        // Return response in the determined format\n        sendResponse(req, res, envManifest, 400);\n        return;\n      }\n\n      // Set Content-Type to application/json\n      res.set('Content-Type', CT_JSON);\n      // For all other cases, terminate with status code 500\n      if (err instanceof Error) {\n        res.status(500).json({\n          error: INTERNAL_SERVER_ERROR,\n          detail: err.message,\n        });\n        return;\n      }\n      res.status(500).json({error: INTERNAL_SERVER_ERROR});\n    }\n  });\n\n  // Set up custom error handler\n  app.use(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    (err: any, _req: Request, res: Response, _next: NextFunction): void => {\n      // Set Content-Type to application/json\n      res.set('Content-Type', CT_JSON);\n\n      // If SyntaxError (JSON parse error), terminate with status code 400\n      if (err.status === 400 && err instanceof SyntaxError && 'body' in err) {\n        res.status(400).json({\n          error: INVALID_JSON,\n          detail: err.message,\n        });\n      } else if (err instanceof Error) {\n        if ('status' in err) {\n          res.status(err.status as number).json({\n            error: err.message,\n          });\n        } else {\n          res.status(500).json({\n            error: INTERNAL_SERVER_ERROR,\n            detail: err.message,\n          });\n        }\n      } else {\n        res.status(500).json({\n          error: INTERNAL_SERVER_ERROR,\n        });\n      }\n    }\n  );\n\n  // Start the server\n  const {port, host} = options;\n  const server = app.listen(port, host, (err?: Error) => {\n    if (err) {\n      logger.error(SERVER_START_FAILED(err));\n      // eslint-disable-next-line no-process-exit\n      process.exit(2);\n    }\n    logger.info(SERVER_STARTED(formatAddr(server.address())));\n  });\n\n  // Handle Signal\n  const handler = (err: NodeJS.Signals) => {\n    logger.debug(`${err} signal received: closing HTTP server`);\n    server.close(() => {\n      logger.debug('HTTP server closed');\n    });\n  };\n  process.once('SIGTERM', handler);\n  process.once('SIGINT', handler);\n};\n\n// Start the server\nstartServer().catch(err => {\n  logger.error(SERVER_START_FAILED(err));\n  // eslint-disable-next-line no-process-exit\n  process.exit(2);\n});\n"]}

package/build/if-api/types/process-args.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Interface for if-api process arguments.
+ */
+export interface IfApiArgs {
+    debug: boolean;
+    disableExternalPluginWarning: boolean;
+    disabledPlugins?: string;
+    port: string;
+    host: string;
+    help?: boolean;
+}
+export interface IfApiOptions {
+    debug: boolean;
+    disableExternalPluginWarning: boolean;
+    disabledPlugins: string | undefined;
+    port: number;
+    host: string;
+}

package/build/if-api/types/process-args.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1hcmdzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vc3JjL2lmLWFwaS90eXBlcy9wcm9jZXNzLWFyZ3MudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogSW50ZXJmYWNlIGZvciBpZi1hcGkgcHJvY2VzcyBhcmd1bWVudHMuXG4gKi9cbmV4cG9ydCBpbnRlcmZhY2UgSWZBcGlBcmdzIHtcbiAgZGVidWc6IGJvb2xlYW47XG4gIGRpc2FibGVFeHRlcm5hbFBsdWdpbldhcm5pbmc6IGJvb2xlYW47XG4gIGRpc2FibGVkUGx1Z2lucz86IHN0cmluZztcbiAgcG9ydDogc3RyaW5nO1xuICBob3N0OiBzdHJpbmc7XG4gIGhlbHA/OiBib29sZWFuO1xufVxuXG5leHBvcnQgaW50ZXJmYWNlIElmQXBpT3B0aW9ucyB7XG4gIGRlYnVnOiBib29sZWFuO1xuICBkaXNhYmxlRXh0ZXJuYWxQbHVnaW5XYXJuaW5nOiBib29sZWFuO1xuICBkaXNhYmxlZFBsdWdpbnM6IHN0cmluZyB8IHVuZGVmaW5lZDtcbiAgcG9ydDogbnVtYmVyO1xuICBob3N0OiBzdHJpbmc7XG59XG4iXX0=

package/build/if-api/util/args.d.ts

@@ -0,0 +1,5 @@
+import type { IfApiOptions } from '../types/process-args';
+/**
+ * Parse command line arguments for `if-api`.
+ */
+export declare const parseIfApiProcessArgs: () => IfApiOptions;

package/build/if-api/util/args.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseIfApiProcessArgs = void 0;
+const ts_command_line_args_1 = require("ts-command-line-args");
+const config_1 = require("../config");
+const { ARGS, HELP } = config_1.CONFIG;
+const { INVALID_PORT_NUMBER } = config_1.STRINGS;
+/**
+ * Validates `if-api` process arguments.
+ */
+const validateAndParseProcessArgs = () => {
+    try {
+        return (0, ts_command_line_args_1.parse)(ARGS, HELP);
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            console.log(error.message);
+            console.log('Here are the supported flags for the `if-api` command:');
+            (0, ts_command_line_args_1.parse)(ARGS, { ...HELP, argv: ['--help'], processExitCode: 1 });
+        }
+        throw error;
+    }
+};
+/**
+ * Parse command line arguments for `if-api`.
+ */
+const parseIfApiProcessArgs = () => {
+    const options = validateAndParseProcessArgs();
+    const port = parseInt(options.port, 10);
+    if (Number.isNaN(port) || port < 0 || port > 65535) {
+        throw new Error(INVALID_PORT_NUMBER(options.port));
+    }
+    return {
+        debug: options.debug,
+        disableExternalPluginWarning: options.disableExternalPluginWarning,
+        disabledPlugins: options.disabledPlugins,
+        port,
+        host: options.host,
+    };
+};
+exports.parseIfApiProcessArgs = parseIfApiProcessArgs;
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-check/index.js

@@ -46,13 +46,7 @@ const IfCheck = async () => {
         }
         catch (error) {
             const fileName = path.basename(manifest);
-            const executedFile = manifest
-                .replace(fileName, `re-${fileName}`)
-                .replace('yml', 'yaml');
-            const manifestDirPath = path.dirname(manifest);
             (0, helpers_1.logStdoutFailMessage)(error, fileName);
-            await (0, fs_1.removeFileIfExists)(`${manifestDirPath}/package.json`);
-            await (0, fs_1.removeFileIfExists)(executedFile);
         }
     }
     else {
@@ -71,13 +65,9 @@ const IfCheck = async () => {
             }
             catch (error) {
                 const fileName = path.basename(file);
-                const executedFile = file
-                    .replace(fileName, `re-${fileName}`)
-                    .replace('yml', 'yaml');
                 const failedFilesLog = (0, helpers_1.logStdoutFailMessage)(error, fileName);
                 failedLogs.message = failedLogs.message.concat(failedFilesLog);
                 failedLogs.count++;
-                await (0, fs_1.removeFileIfExists)(executedFile);
             }
         }
         if (failedLogs.count > 0) {
@@ -95,4 +85,4 @@ IfCheck().catch(error => {
         process.exit(2);
     }
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/build/if-check/util/npm.d.ts

@@ -1,4 +1,4 @@
 /**
- * Executes a series of npm commands based on the provided manifest file.
+ * Executes a series of Impact Framework commands based on the provided manifest file.
  */
 export declare const executeCommands: (manifest: string) => Promise<void>;