@smythos/sre 1.5.53 → 1.5.54

package/src/Components/FSign.class.ts

@@ -1,80 +1,80 @@
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import crypto from 'crypto';
-import querystring from 'querystring';
-
-export class FSign extends Component {
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            const _error = undefined;
-            const teamId = agent ? agent.teamId : null;
-
-            let data = input.Data;
-            //if (typeof data === 'object') data = JSON.stringify(data);
-            let signingKey = input.Key || config.data.key;
-            // signingKey = parseTemplate(signingKey, input, { processUnmatched: false });
-            // signingKey = await parseKey(signingKey, teamId);
-            signingKey = await TemplateString(signingKey).parse(input).parseTeamKeysAsync(teamId).asyncResult;
-
-            const signMethod = config.data.signMethod || 'HMAC';
-            const dataTransform = config.data.dataTransform || 'None';
-            const hashType = config.data.hashType || 'md5';
-            const RSA_padding = config.data.RSA_padding;
-            const RSA_saltLength = config.data.RSA_saltLength;
-            const encoding = config.data.encoding || 'hex';
-
-            if (typeof data != 'string') {
-                switch (dataTransform) {
-                    case 'Stringify':
-                        data = JSON.stringify(data);
-                        break;
-                    case 'Querystring':
-                        data = querystring.stringify(data);
-                        break;
-                }
-            }
-            logger.debug(' Data to sign = ', data);
-            logger.debug(` Signing data using ${signMethod} algorithm and ${encoding} encoding`);
-            const Signature = this.signData(data, signingKey, signMethod, encoding, { hashType, RSA_padding, RSA_saltLength });
-
-            logger.debug(` Signature generated: ${Signature}`);
-            return { Signature, _error, _debug: logger.output };
-        } catch (err: any) {
-            const _error = err?.response?.data || err?.message || err.toString();
-            logger.error(` Error generating hash \n${_error}\n`);
-            return { hash: undefined, _error, _debug: logger.output };
-        }
-    }
-
-    private signData(data, key, signMethod, encoding = 'hex', options: any = {}) {
-        // Determine if the algorithm is for HMAC or RSA/DSA/ECDSA
-        switch (signMethod) {
-            case 'RSA':
-                const algo = `${signMethod}-${options.hashType || 'md5'}`.toUpperCase();
-                const sign = crypto.createSign(algo);
-                sign.update(data);
-
-                const sign_options = {
-                    key,
-                    padding: options.RSA_padding ? crypto.constants[options.RSA_padding] : undefined,
-                    saltLength: options.RSA_saltLength ? crypto.constants[options.RSA_saltLength] : undefined,
-                };
-                // For RSA/DSA/ECDSA, options may include padding and saltLength
-                return sign.sign(sign_options, encoding.toLowerCase() as crypto.BinaryToTextEncoding);
-
-            case 'HMAC':
-                const hmac = crypto.createHmac(options.hashType, key);
-                hmac.update(data);
-                return hmac.digest(encoding as crypto.BinaryToTextEncoding);
-        }
-
-        return null;
-    }
-}
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import crypto from 'crypto';
+import querystring from 'querystring';
+
+export class FSign extends Component {
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            const _error = undefined;
+            const teamId = agent ? agent.teamId : null;
+
+            let data = input.Data;
+            //if (typeof data === 'object') data = JSON.stringify(data);
+            let signingKey = input.Key || config.data.key;
+            // signingKey = parseTemplate(signingKey, input, { processUnmatched: false });
+            // signingKey = await parseKey(signingKey, teamId);
+            signingKey = await TemplateString(signingKey).parse(input).parseTeamKeysAsync(teamId).asyncResult;
+
+            const signMethod = config.data.signMethod || 'HMAC';
+            const dataTransform = config.data.dataTransform || 'None';
+            const hashType = config.data.hashType || 'md5';
+            const RSA_padding = config.data.RSA_padding;
+            const RSA_saltLength = config.data.RSA_saltLength;
+            const encoding = config.data.encoding || 'hex';
+
+            if (typeof data != 'string') {
+                switch (dataTransform) {
+                    case 'Stringify':
+                        data = JSON.stringify(data);
+                        break;
+                    case 'Querystring':
+                        data = querystring.stringify(data);
+                        break;
+                }
+            }
+            logger.debug(' Data to sign = ', data);
+            logger.debug(` Signing data using ${signMethod} algorithm and ${encoding} encoding`);
+            const Signature = this.signData(data, signingKey, signMethod, encoding, { hashType, RSA_padding, RSA_saltLength });
+
+            logger.debug(` Signature generated: ${Signature}`);
+            return { Signature, _error, _debug: logger.output };
+        } catch (err: any) {
+            const _error = err?.response?.data || err?.message || err.toString();
+            logger.error(` Error generating hash \n${_error}\n`);
+            return { hash: undefined, _error, _debug: logger.output };
+        }
+    }
+
+    private signData(data, key, signMethod, encoding = 'hex', options: any = {}) {
+        // Determine if the algorithm is for HMAC or RSA/DSA/ECDSA
+        switch (signMethod) {
+            case 'RSA':
+                const algo = `${signMethod}-${options.hashType || 'md5'}`.toUpperCase();
+                const sign = crypto.createSign(algo);
+                sign.update(data);
+
+                const sign_options = {
+                    key,
+                    padding: options.RSA_padding ? crypto.constants[options.RSA_padding] : undefined,
+                    saltLength: options.RSA_saltLength ? crypto.constants[options.RSA_saltLength] : undefined,
+                };
+                // For RSA/DSA/ECDSA, options may include padding and saltLength
+                return sign.sign(sign_options, encoding.toLowerCase() as crypto.BinaryToTextEncoding);
+
+            case 'HMAC':
+                const hmac = crypto.createHmac(options.hashType, key);
+                hmac.update(data);
+                return hmac.digest(encoding as crypto.BinaryToTextEncoding);
+        }
+
+        return null;
+    }
+}

package/src/Components/FSleep.class.ts

@@ -1,25 +1,25 @@
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-
-export class FSleep extends Component {
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            const _error = undefined;
-            const delay = parseInt(config.data.delay || 1);
-            const Output = input.Input;
-            logger.debug(`Sleeping for ${delay} seconds`);
-            await new Promise((resolve) => setTimeout(resolve, delay * 1000));
-            return { Output, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        } catch (err: any) {
-            const _error = err?.response?.data || err?.message || err.toString();
-            logger.error(` Error processing data \n${_error}\n`);
-            return { hash: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        }
-    }
-}
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+
+export class FSleep extends Component {
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            const _error = undefined;
+            const delay = parseInt(config.data.delay || 1);
+            const Output = input.Input;
+            logger.debug(`Sleeping for ${delay} seconds`);
+            await new Promise((resolve) => setTimeout(resolve, delay * 1000));
+            return { Output, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+        } catch (err: any) {
+            const _error = err?.response?.data || err?.message || err.toString();
+            logger.error(` Error processing data \n${_error}\n`);
+            return { hash: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+        }
+    }
+}

package/src/Components/FTimestamp.class.ts

@@ -1,25 +1,25 @@
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-
-export class FTimestamp extends Component {
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            const _error = undefined;
-            const format = config.data.format; //TODO set timestamp format
-            const Timestamp = Date.now();
-            logger.debug(`Timestamp : ${Timestamp}`);
-
-            return { Timestamp, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        } catch (err: any) {
-            const _error = err?.response?.data || err?.message || err.toString();
-            logger.error(` Error processing data \n${_error}\n`);
-            return { hash: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        }
-    }
-}
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+
+export class FTimestamp extends Component {
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            const _error = undefined;
+            const format = config.data.format; //TODO set timestamp format
+            const Timestamp = Date.now();
+            logger.debug(`Timestamp : ${Timestamp}`);
+
+            return { Timestamp, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+        } catch (err: any) {
+            const _error = err?.response?.data || err?.message || err.toString();
+            logger.error(` Error processing data \n${_error}\n`);
+            return { hash: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
+        }
+    }
+}

package/src/Components/FileStore.class.ts

@@ -1,78 +1,78 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import Joi from 'joi';
-import _config from '@sre/config';
-import { S3Storage } from '@sre/IO/Storage.service/connectors/S3Storage.class';
-import { ConnectorService } from '@sre/Core/ConnectorsService';
-import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
-import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
-import { TemplateString } from '@sre/helpers/TemplateString.helper';
-import { SmythFS } from '@sre/IO/Storage.service/SmythFS.class';
-
-export class FileStore extends Component {
-    protected configSchema = Joi.object({
-        name: Joi.string().max(1000).allow('').label('Name'),
-        ttl: Joi.number().integer().label('TTL'),
-    });
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            logger.debug(`=== File Store Log ===`);
-            let Output: any = {};
-            let _error = undefined;
-            let data = input.Data;
-            const accessCandidate = AccessCandidate.agent(agent.id);
-            const binaryData = await BinaryInput.from(data, null, null, accessCandidate);
-            const fileData = await binaryData.getJsonData(accessCandidate);
-            const buffer = await binaryData.getBuffer();
-            const customFileName = TemplateString(config.data.name).parse(input).result;
-            const metadata = {
-                ContentType: fileData.mimetype,
-            };
-            const ttl = config.data.ttl || 86400;
-            const extension = fileData.url?.split('.').pop();
-            const s3StorageConnector = ConnectorService.getStorageConnector('S3') as S3Storage;
-            const fileName = this.getFileName(customFileName, extension);
-            try {
-                //const s3Key = `teams/${agent.teamId}/components_data/${fileName}`;
-
-                //await s3StorageConnector.requester(AccessCandidate.agent(agent.id)).write(s3Key, buffer, null, metadata);
-                //await s3StorageConnector.requester(AccessCandidate.agent(agent.id)).expire(s3Key, +ttl);
-
-                
-                const smythFSUrl = `smythfs://${agent.id}.agent/components_data/${fileName}`;
-                await SmythFS.Instance.write(smythFSUrl, buffer, null, metadata, ttl);
-                const url = await SmythFS.Instance.genResourceUrl(smythFSUrl, AccessCandidate.agent(agent.id));
-                Output = {
-                    Url: url,
-                };
-            } catch (error: any) {
-                logger.error(`Error saving file \n${error}\n`);
-                _error = error?.response?.data || error?.message || error.toString();
-                Output = undefined; //prevents running next component if the code execution failed
-            }
-
-            return { ...Output, _error, _debug: logger.output };
-        } catch (err: any) {
-            const _error = err?.response?.data || err?.message || err.toString();
-            logger.error(` Error saving file \n${_error}\n`);
-            return { Output: undefined, _error, _debug: logger.output };
-        }
-    }
-
-    getExtension(mimeType: string) {
-        const extension = mimeType.split('/')[1];
-        return extension;
-    }
-
-    getFileName(customName: string, extension: string) {
-        const uniqueId = (() => btoa(String.fromCharCode(...crypto.getRandomValues(new Uint8Array(9)))).replace(/[+/=]/g, ''))();
-        return `${uniqueId}${customName ? `.${customName}` : ''}.${extension}`;
-    }
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import Joi from 'joi';
+import _config from '@sre/config';
+import { S3Storage } from '@sre/IO/Storage.service/connectors/S3Storage.class';
+import { ConnectorService } from '@sre/Core/ConnectorsService';
+import { AccessCandidate } from '@sre/Security/AccessControl/AccessCandidate.class';
+import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import { TemplateString } from '@sre/helpers/TemplateString.helper';
+import { SmythFS } from '@sre/IO/Storage.service/SmythFS.class';
+
+export class FileStore extends Component {
+    protected configSchema = Joi.object({
+        name: Joi.string().max(1000).allow('').label('Name'),
+        ttl: Joi.number().integer().label('TTL'),
+    });
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            logger.debug(`=== File Store Log ===`);
+            let Output: any = {};
+            let _error = undefined;
+            let data = input.Data;
+            const accessCandidate = AccessCandidate.agent(agent.id);
+            const binaryData = await BinaryInput.from(data, null, null, accessCandidate);
+            const fileData = await binaryData.getJsonData(accessCandidate);
+            const buffer = await binaryData.getBuffer();
+            const customFileName = TemplateString(config.data.name).parse(input).result;
+            const metadata = {
+                ContentType: fileData.mimetype,
+            };
+            const ttl = config.data.ttl || 86400;
+            const extension = fileData.url?.split('.').pop();
+            const s3StorageConnector = ConnectorService.getStorageConnector('S3') as S3Storage;
+            const fileName = this.getFileName(customFileName, extension);
+            try {
+                //const s3Key = `teams/${agent.teamId}/components_data/${fileName}`;
+
+                //await s3StorageConnector.requester(AccessCandidate.agent(agent.id)).write(s3Key, buffer, null, metadata);
+                //await s3StorageConnector.requester(AccessCandidate.agent(agent.id)).expire(s3Key, +ttl);
+
+                
+                const smythFSUrl = `smythfs://${agent.id}.agent/components_data/${fileName}`;
+                await SmythFS.Instance.write(smythFSUrl, buffer, null, metadata, ttl);
+                const url = await SmythFS.Instance.genResourceUrl(smythFSUrl, AccessCandidate.agent(agent.id));
+                Output = {
+                    Url: url,
+                };
+            } catch (error: any) {
+                logger.error(`Error saving file \n${error}\n`);
+                _error = error?.response?.data || error?.message || error.toString();
+                Output = undefined; //prevents running next component if the code execution failed
+            }
+
+            return { ...Output, _error, _debug: logger.output };
+        } catch (err: any) {
+            const _error = err?.response?.data || err?.message || err.toString();
+            logger.error(` Error saving file \n${_error}\n`);
+            return { Output: undefined, _error, _debug: logger.output };
+        }
+    }
+
+    getExtension(mimeType: string) {
+        const extension = mimeType.split('/')[1];
+        return extension;
+    }
+
+    getFileName(customName: string, extension: string) {
+        const uniqueId = (() => btoa(String.fromCharCode(...crypto.getRandomValues(new Uint8Array(9)))).replace(/[+/=]/g, ''))();
+        return `${uniqueId}${customName ? `.${customName}` : ''}.${extension}`;
+    }
+}

package/src/Components/ForEach.class.ts

@@ -1,97 +1,97 @@
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import { Component } from './Component.class';
-import Joi from 'joi';
-import { JSONContent } from '@sre/helpers/JsonContent.helper';
-
-export class ForEach extends Component {
-    protected configSchema = null;
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-        let Loop = {};
-        let Result;
-        let _temp_result;
-        let _error = null;
-        let _in_progress = true;
-        const logger = this.createComponentLogger(agent, config);
-        try {
-            const inputObject = input.Input;
-            let inputArray;
-
-            //Try to parse multiple arrays formats since forEach always expects and array
-            if (Array.isArray(inputObject)) inputArray = inputObject;
-            else {
-                if (typeof inputObject === 'string') {
-                    inputArray = inputObject.trim().startsWith('[') ? JSONContent(inputObject).tryParse() : inputObject.split(',');
-                } else {
-                    inputArray = [inputObject];
-                }
-            }
-
-            if (!Array.isArray(inputArray) && typeof inputArray === 'object')
-                //if json object, use the values
-                inputArray = Object.values(inputArray);
-
-            const runtimeData = agent.agentRuntime.getRuntimeData(config.id);
-            const _ForEachData = runtimeData._LoopData || { parentId: config.id, loopIndex: 0, loopLength: inputArray.length };
-
-            logger.debug(`Loop: ${_ForEachData.loopIndex} / ${_ForEachData.loopLength}`);
-            delete _ForEachData.branches; //reset branches (the number of branches is calculated in CallComponent@Agent.class.ts )
-
-            if (_ForEachData.result) {
-                _temp_result = _ForEachData.result;
-                logger.debug(`  => Loop Result : ${JSON.stringify(Loop, null, 2)}`);
-                logger.debug(`---------------------------------------------------`);
-            }
-
-            Loop = inputArray[_ForEachData.loopIndex];
-
-            logger.debug(`  => Loop Data : ${JSON.stringify(Loop, null, 2)}`);
-
-            _in_progress = Loop !== undefined;
-            if (_in_progress) {
-                _ForEachData.loopIndex++;
-            }
-            _ForEachData._in_progress = _in_progress;
-
-            agent.agentRuntime.updateRuntimeData(config.id, { _LoopData: _ForEachData });
-        } catch (error: any) {
-            _error = error;
-            logger.error(error);
-        }
-        if (!_in_progress) {
-            Result = _temp_result || [];
-
-            switch (config?.data?.format) {
-                case 'minimal':
-                    Result = Result.map((item) => cleanupResult(item.result));
-                    break;
-                case 'results-array':
-                    Result = Result.map((item) => Object.values(cleanupResult(item.result))).flat(Infinity);
-                    break;
-            }
-        }
-
-        return { Loop, Result, _temp_result, _error, _in_progress, _debug: logger.output };
-    }
-    async postProcess(output, config, agent: Agent): Promise<any> {
-        output = await super.postProcess(output, config, agent);
-        if (output?.result) {
-            delete output.result._temp_result;
-            delete output.result._in_progress;
-            delete output.result.Loop;
-        }
-        return output;
-    }
-}
-function cleanupResult(result) {
-    if (typeof result !== 'object') return result;
-    if (result._debug) delete result._debug;
-    if (result._error) delete result._error;
-    if (result._temp_result) delete result._temp_result;
-    if (result._in_progress) delete result._in_progress;
-    return result;
-}
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import { Component } from './Component.class';
+import Joi from 'joi';
+import { JSONContent } from '@sre/helpers/JsonContent.helper';
+
+export class ForEach extends Component {
+    protected configSchema = null;
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+        let Loop = {};
+        let Result;
+        let _temp_result;
+        let _error = null;
+        let _in_progress = true;
+        const logger = this.createComponentLogger(agent, config);
+        try {
+            const inputObject = input.Input;
+            let inputArray;
+
+            //Try to parse multiple arrays formats since forEach always expects and array
+            if (Array.isArray(inputObject)) inputArray = inputObject;
+            else {
+                if (typeof inputObject === 'string') {
+                    inputArray = inputObject.trim().startsWith('[') ? JSONContent(inputObject).tryParse() : inputObject.split(',');
+                } else {
+                    inputArray = [inputObject];
+                }
+            }
+
+            if (!Array.isArray(inputArray) && typeof inputArray === 'object')
+                //if json object, use the values
+                inputArray = Object.values(inputArray);
+
+            const runtimeData = agent.agentRuntime.getRuntimeData(config.id);
+            const _ForEachData = runtimeData._LoopData || { parentId: config.id, loopIndex: 0, loopLength: inputArray.length };
+
+            logger.debug(`Loop: ${_ForEachData.loopIndex} / ${_ForEachData.loopLength}`);
+            delete _ForEachData.branches; //reset branches (the number of branches is calculated in CallComponent@Agent.class.ts )
+
+            if (_ForEachData.result) {
+                _temp_result = _ForEachData.result;
+                logger.debug(`  => Loop Result : ${JSON.stringify(Loop, null, 2)}`);
+                logger.debug(`---------------------------------------------------`);
+            }
+
+            Loop = inputArray[_ForEachData.loopIndex];
+
+            logger.debug(`  => Loop Data : ${JSON.stringify(Loop, null, 2)}`);
+
+            _in_progress = Loop !== undefined;
+            if (_in_progress) {
+                _ForEachData.loopIndex++;
+            }
+            _ForEachData._in_progress = _in_progress;
+
+            agent.agentRuntime.updateRuntimeData(config.id, { _LoopData: _ForEachData });
+        } catch (error: any) {
+            _error = error;
+            logger.error(error);
+        }
+        if (!_in_progress) {
+            Result = _temp_result || [];
+
+            switch (config?.data?.format) {
+                case 'minimal':
+                    Result = Result.map((item) => cleanupResult(item.result));
+                    break;
+                case 'results-array':
+                    Result = Result.map((item) => Object.values(cleanupResult(item.result))).flat(Infinity);
+                    break;
+            }
+        }
+
+        return { Loop, Result, _temp_result, _error, _in_progress, _debug: logger.output };
+    }
+    async postProcess(output, config, agent: Agent): Promise<any> {
+        output = await super.postProcess(output, config, agent);
+        if (output?.result) {
+            delete output.result._temp_result;
+            delete output.result._in_progress;
+            delete output.result.Loop;
+        }
+        return output;
+    }
+}
+function cleanupResult(result) {
+    if (typeof result !== 'object') return result;
+    if (result._debug) delete result._debug;
+    if (result._error) delete result._error;
+    if (result._temp_result) delete result._temp_result;
+    if (result._in_progress) delete result._in_progress;
+    return result;
+}