@smythos/sre 1.6.0 → 1.6.8

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,66 +1,66 @@
-import { Component } from './Component.class';
-import { IAgent as Agent } from '@sre/types/Agent.types';
-import Joi from 'joi';
-import dayjs from 'dayjs';
-
-export class FTimestamp extends Component {
-    protected configSchema = Joi.object({
-        format: Joi.alternatives()
-            .try(Joi.string().valid('unix', 'iso', 'timestamp'), Joi.string().pattern(/^[YMDHhmsSSZzAa\s\-\/:,\.]*$/, 'custom dayjs format'))
-            .default('unix')
-            .allow(null)
-            .label('Timestamp Format')
-            .messages({
-                'string.pattern.name': 'Invalid format string: {#value}',
-            }),
-    });
-
-    constructor() {
-        super();
-    }
-    init() {}
-    async process(input, config, agent: Agent) {
-        await super.process(input, config, agent);
-
-        const logger = this.createComponentLogger(agent, config);
-
-        const validationResult = await this.validateConfig(config);
-        if (validationResult._error) {
-            return {
-                Timestamp: undefined,
-                _error: validationResult._error,
-                _debug: logger.output,
-                _debug_time: logger.elapsedTime,
-            };
-        }
-        try {
-            const _error = undefined;
-            const format = config.data.format || 'unix';
-            const now = dayjs();
-
-            let Timestamp: number | string;
-
-            switch (format) {
-                case 'unix':
-                case 'timestamp':
-                    Timestamp = Date.now();
-                    logger.debug(`Unix timestamp: ${Timestamp}`);
-                    break;
-                case 'iso':
-                    Timestamp = now.toISOString();
-                    logger.debug(`ISO timestamp: ${Timestamp}`);
-                    break;
-                default:
-                    Timestamp = now.format(format);
-                    logger.debug(`Custom formatted timestamp (${format}): ${Timestamp}`);
-                    break;
-            }
-
-            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 timestamp \n${_error}\n`);
-            return { Timestamp: undefined, _error, _debug: logger.output, _debug_time: logger.elapsedTime };
-        }
-    }
-}
+import { Component } from './Component.class';
+import { IAgent as Agent } from '@sre/types/Agent.types';
+import Joi from 'joi';
+import dayjs from 'dayjs';
+
+export class FTimestamp extends Component {
+    protected configSchema = Joi.object({
+        format: Joi.alternatives()
+            .try(Joi.string().valid('unix', 'iso', 'timestamp'), Joi.string().pattern(/^[YMDHhmsSSZzAa\s\-\/:,\.]*$/, 'custom dayjs format'))
+            .default('unix')
+            .allow(null)
+            .label('Timestamp Format')
+            .messages({
+                'string.pattern.name': 'Invalid format string: {#value}',
+            }),
+    });
+
+    constructor() {
+        super();
+    }
+    init() {}
+    async process(input, config, agent: Agent) {
+        await super.process(input, config, agent);
+
+        const logger = this.createComponentLogger(agent, config);
+
+        const validationResult = await this.validateConfig(config);
+        if (validationResult._error) {
+            return {
+                Timestamp: undefined,
+                _error: validationResult._error,
+                _debug: logger.output,
+                _debug_time: logger.elapsedTime,
+            };
+        }
+        try {
+            const _error = undefined;
+            const format = config.data.format || 'unix';
+            const now = dayjs();
+
+            let Timestamp: number | string;
+
+            switch (format) {
+                case 'unix':
+                case 'timestamp':
+                    Timestamp = Date.now();
+                    logger.debug(`Unix timestamp: ${Timestamp}`);
+                    break;
+                case 'iso':
+                    Timestamp = now.toISOString();
+                    logger.debug(`ISO timestamp: ${Timestamp}`);
+                    break;
+                default:
+                    Timestamp = now.format(format);
+                    logger.debug(`Custom formatted timestamp (${format}): ${Timestamp}`);
+                    break;
+            }
+
+            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 timestamp \n${_error}\n`);
+            return { Timestamp: 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}`;
+    }
+}