@factorialco/fcode-cli 1.1.0

package/dist/core/executors/execution-task.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_child_process_1 = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const errors_1 = require("../errors");
+const cli_1 = require("../../utils/cli");
+const dependencies_1 = require("../utils/dependencies");
+const python_env_dependencies_1 = require("../dependencies/python-env-dependencies");
+const javascript_env_dependencies_1 = require("../dependencies/javascript-env-dependencies");
+const variables_1 = require("../utils/variables");
+const env_process_dependencies_command_1 = require("../dependencies/env-process-dependencies-command");
+const createTempDirectory = () => {
+    const runtimeDir = path.join(`${os.tmpdir()}${path.sep}fcode${path.sep}`);
+    fs.mkdirSync(runtimeDir, { recursive: true });
+    return fs.mkdtempSync(runtimeDir);
+};
+class ExecutionTask {
+    constructor(_programmingLanguage, process, options, tempDir) {
+        this.getVariablesObject = () => (0, variables_1.getVariablesObject)(this._options.variables);
+        this._programmingLanguage = _programmingLanguage;
+        this._process = process;
+        this._options = options;
+        this._tempDir = tempDir ?? createTempDirectory();
+    }
+    async getCliPath() {
+        return new Promise((resolve, reject) => {
+            (0, node_child_process_1.exec)('npm root -g', (error, rootPath) => {
+                if (error) {
+                    reject(error);
+                }
+                resolve(path.join(rootPath.trim(), '@factorialco', 'fcode-cli'));
+            });
+        });
+    }
+    getExecutionSourceCode() {
+        return this._process.script.sourceCode;
+    }
+    async getDependenciesPath() {
+        try {
+            const isScopedToProcess = this._process.settings.dependencies.scopedToProcess;
+            const fullPath = isScopedToProcess ? (0, dependencies_1.getProcessDependenciesPath)(this._process) : await (0, dependencies_1.getDependenciesPath)(this._process.script.programmingLanguage);
+            if (!fs.existsSync(fullPath)) {
+                throw isScopedToProcess ? new errors_1.ProcessDependenciesNotInstalled(this._process) : new errors_1.DependenciesNotInstalled(this._process.script.programmingLanguage);
+            }
+            return fullPath;
+        }
+        catch (error) {
+            if (error instanceof errors_1.DependenciesNotInstalled) {
+                if (!(await cli_1.default.confirm('⚠️  Dependencies are not installed. Do you want to install them? yes/no'))) {
+                    throw error;
+                }
+                else {
+                    if ('PYTHON' === this._programmingLanguage) {
+                        await python_env_dependencies_1.default.run([]);
+                    }
+                    else {
+                        await javascript_env_dependencies_1.default.run([]);
+                    }
+                    return this.getDependenciesPath();
+                }
+            }
+            else if (error instanceof errors_1.ProcessDependenciesNotInstalled) {
+                if (!(await cli_1.default.confirm('⚠️  Process dependencies are not installed. Do you want to install them? yes/no'))) {
+                    throw error;
+                }
+                else {
+                    await env_process_dependencies_command_1.default.run([this._process.slug]);
+                    return this.getDependenciesPath();
+                }
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    get returnValueFilePath() {
+        return path.join(this._tempDir, 'return_value.json');
+    }
+    get errorValueFilePath() {
+        return path.join(this._tempDir, 'error_value.json');
+    }
+    readReturnValue() {
+        if (fs.existsSync(this.returnValueFilePath)) {
+            try {
+                return JSON.parse(fs.readFileSync(this.returnValueFilePath, 'utf8'));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    readErrorValue() {
+        if (fs.existsSync(this.errorValueFilePath)) {
+            try {
+                return JSON.parse(fs.readFileSync(this.errorValueFilePath, 'utf8'));
+            }
+            catch {
+                return undefined;
+            }
+        }
+        return undefined;
+    }
+    getMetadata() {
+        return {
+            parameters: this._options.parameters,
+            execution: {
+                process: {
+                    id: this._process?.id,
+                    name: this._process?.name,
+                },
+            },
+            variables: this.getVariablesObject(),
+            request: this._options.request ?? 'No request, you are using the CLI',
+        };
+    }
+    async prepare() {
+        this._dependenciesPath = await this.getDependenciesPath();
+        const createFilesResult = await this._createExecutionFiles(this._tempDir);
+        this._execFilePath = createFilesResult.FCODE_EXECUTION_FILE;
+        const exportVars = {
+            ...createFilesResult,
+            FCODE_DEPENDENCIES_PATH: this._dependenciesPath,
+            FCODE_EXECUTION_PATH: [createFilesResult.FCODE_LIBRARY_PATH, this._dependenciesPath].filter((p) => p).join(':'),
+        };
+        fs.writeFileSync(path.join(this._tempDir, 'METADATA'), Object.entries(exportVars)
+            .map(([key, value]) => `${key}=${value}`)
+            .join('\n'));
+        return this._execFilePath;
+    }
+    cleanup() {
+        if (this._tempDir) {
+            fs.rmSync(this._tempDir, { force: true, recursive: true });
+        }
+    }
+}
+exports.default = ExecutionTask;

package/dist/core/executors/javascript-execution-task.d.ts

@@ -0,0 +1,13 @@
+import ExecutionTask from './execution-task';
+/**
+ * Task which handles native executions using child_process.
+ */
+declare class JavaScriptExecutionTask extends ExecutionTask {
+    run(): Promise<unknown>;
+    _getLegacyBlock(): string;
+    _getNewBlock(): string;
+    _createExecutionFiles(tempDir: string): Promise<{
+        [name: string]: string;
+    }>;
+}
+export default JavaScriptExecutionTask;