@smythos/sre 1.5.1 → 1.5.4

package/src/helpers/S3Cache.helper.ts

@@ -0,0 +1,129 @@
+import { GetBucketLifecycleConfigurationCommandOutput, PutBucketLifecycleConfigurationCommand } from '@aws-sdk/client-s3';
+
+import { GetBucketLifecycleConfigurationCommand } from '@aws-sdk/client-s3';
+
+import { S3Client } from '@aws-sdk/client-s3';
+
+export function generateLifecycleRules() {
+    const rules = [];
+
+    // Add rules for 1-100 days
+    for (let i = 1; i < 100; i++) {
+        rules.push({
+            ID: `ExpireAfter${i}Days`,
+            Filter: {
+                // Prefix: '',
+                Tag: {
+                    Key: 'Expiry',
+                    Value: 'ExpireAfter' + i + 'Days',
+                },
+            },
+            Status: 'Enabled',
+            Expiration: { Days: i },
+        });
+    }
+
+    // Add rules for 110-1000 days with 10-day steps
+    for (let i = 100; i < 1000; i += 10) {
+        rules.push({
+            ID: `ExpireAfter${i}Days`,
+            Filter: {
+                // Prefix: '',
+                Tag: {
+                    Key: 'Expiry',
+                    Value: 'ExpireAfter' + i + 'Days',
+                },
+            },
+            Status: 'Enabled',
+            Expiration: { Days: i },
+        });
+    }
+
+    // Add rules for 1000-10000 days with 100-day steps
+    for (let i = 1000; i <= 10000; i += 100) {
+        rules.push({
+            ID: `ExpireAfter${i}Days`,
+            Filter: {
+                // Prefix: '',
+                Tag: {
+                    Key: 'Expiry',
+                    Value: 'ExpireAfter' + i + 'Days',
+                },
+            },
+            Status: 'Enabled',
+            Expiration: { Days: i },
+        });
+    }
+
+    return rules;
+}
+
+
+export function generateExpiryMetadata(expiryDays) {
+    let metadataValue;
+
+    if (expiryDays >= 1 && expiryDays < 100) {
+        metadataValue = `ExpireAfter${expiryDays}Days`;
+    } else if (expiryDays >= 100 && expiryDays < 1000) {
+        const roundedUpDays = Math.ceil(expiryDays / 10) * 10;
+        metadataValue = `ExpireAfter${roundedUpDays}Days`;
+    } else if (expiryDays >= 1000 && expiryDays <= 10000) {
+        const roundedUpDays = Math.ceil(expiryDays / 100) * 100;
+        metadataValue = `ExpireAfter${roundedUpDays}Days`;
+    } else {
+        throw new Error('Invalid expiry days. Please provide a valid expiry days value.');
+    }
+
+    return {
+        Key: 'Expiry',
+        Value: metadataValue,
+    };
+}
+
+export function getNonExistingRules(existingRules: any[], newRules: any[]) {
+    return newRules.filter((rule) => !existingRules.some((existingRule) => existingRule.ID === rule.ID));
+}
+
+export function ttlToExpiryDays(ttl: number) {
+    // seconds
+    return Math.ceil(ttl / (60 * 60 * 24));
+}
+
+export async function checkAndInstallLifecycleRules(bucketName: string, s3Client: S3Client) {
+    try {
+        // Check existing lifecycle configuration
+        const getLifecycleCommand = new GetBucketLifecycleConfigurationCommand({ Bucket: bucketName });
+        const existingLifecycle: GetBucketLifecycleConfigurationCommandOutput = await s3Client.send(getLifecycleCommand);
+        const existingRules = existingLifecycle.Rules;
+        const newRules = generateLifecycleRules();
+        const nonExistingNewRules = getNonExistingRules(existingRules, newRules);
+        if (nonExistingNewRules.length > 0) {
+            const params = {
+                Bucket: bucketName,
+                LifecycleConfiguration: { Rules: [...existingRules, ...nonExistingNewRules] },
+            };
+            const putLifecycleCommand = new PutBucketLifecycleConfigurationCommand(params);
+            // Put the new lifecycle configuration
+            await s3Client.send(putLifecycleCommand);
+        } else {
+            console.log('Lifecycle configuration already exists');
+        }
+    } catch (error) {
+        if (error.code === 'NoSuchLifecycleConfiguration') {
+            console.log('No lifecycle configuration found. Creating new configuration...');
+
+            const lifecycleRules = generateLifecycleRules();
+
+            const params = {
+                Bucket: bucketName,
+                LifecycleConfiguration: { Rules: lifecycleRules },
+            };
+            const putLifecycleCommand = new PutBucketLifecycleConfigurationCommand(params);
+            // Put the new lifecycle configuration
+            await s3Client.send(putLifecycleCommand);
+            console.log('Lifecycle configuration created successfully.');
+        } else {
+            console.error('Error checking lifecycle configuration:', error);
+        }
+    }
+}

package/src/helpers/SmythURI.helper.ts

@@ -0,0 +1,5 @@
+export class SmythURI {
+    static agent(id: string): string {
+        return `smyth:agent:${id}`;
+    }
+}

package/src/helpers/TemplateString.helper.ts

@@ -0,0 +1,243 @@
+import { VaultHelper } from '@sre/Security/Vault.service/Vault.helper';
+
+export type TemplateStringMatch = RegExp;
+
+export const Match = {
+    default: /{{(.*?)}}/g,
+    //matches all placeholders
+    doubleCurly: /{{(.*?)}}/g,
+    singleCurly: /{(.*?)}/g,
+    doubleCurlyForSingleMatch: /{{(.*?)}}/,
+
+    //matches component template variables
+    //example of matching strings
+    // {{VAULTINPUT:Input label:[APIKEY]}}
+    // {{VARINPUT:Variable label:{ "key":"value" }}}
+    templateVariables: /{{([A-Z]+):([\w\s]+):[\[{](.*?)[\]}]}}/gm,
+
+    //matches only the placeholders that have a specific prefix
+    prefix(prefix: string) {
+        return new RegExp(`{{${prefix}(.*?)}}`, 'g');
+    },
+
+    //matches only the placeholders that have a specific suffix
+    suffix(suffix: string) {
+        return new RegExp(`{{(.*?)${suffix}}}`, 'g');
+    },
+    //matches only the placeholders that have a specific prefix and suffix
+    prefSuf(prefix: string, suffix: string) {
+        return new RegExp(`{{${prefix}(.*?)${suffix}}}`, 'g');
+    },
+
+    //matches a function annotation with a given name, just like prefix but with wrapping parenthesis
+    fn(name: string) {
+        return new RegExp(`{{${name}\\((.*?)\\)}}`, 'g');
+    },
+};
+
+export const TPLProcessor = {
+    vaultTeam(teamId: string): (token) => Promise<string> {
+        //the token here represents the vault key name
+        return async (token) => {
+            try {
+                return await VaultHelper.getTeamKey(token, teamId);
+            } catch (error) {
+                return token;
+            }
+        };
+    },
+    componentTemplateVar(templateSettings: Record<string, any>): (token, matches) => Promise<string> {
+        return async (token, matches) => {
+            try {
+                const label = matches[2]; //template variables are identified by their label inside the component config
+                if (!label) return token;
+
+                const entry: any = Object.values(templateSettings).find((o: any) => o.label == label);
+                if (!entry) return token;
+                return `{{${entry.id}}}`;
+            } catch (error) {
+                return token;
+            }
+        };
+    },
+};
+
+/**
+ * Provides a chainable to manipulate template strings
+ *
+ * Template strings are strings that can contain placeholders, which are expressions that get evaluated to produce a resulting string.
+ * The placeholders are defined by double curly braces `{{` and `}}`.
+ */
+
+//FIXME: async parsing breaks the chainability of the TemplateStringHelper
+export class TemplateStringHelper {
+    private _current: string;
+
+    //this queue is used to wait for asyncronous results when async processors are used
+    //if all processors are synchronous, this queue will be empty and .result getter can be used
+    //if any processor is async, the .result getter will throw an error and you should use .asyncResult instead
+    private _promiseQueue: Promise<any>[] = [];
+
+    public get result(): string {
+        if (this._promiseQueue.length <= 0) return this._current;
+        throw new Error('This template object has async results, you should use .asyncResult with await instead of .result');
+    }
+
+    public get asyncResult(): Promise<string> {
+        return new Promise(async (resolve, reject) => {
+            await Promise.all(this._promiseQueue);
+            resolve(this._current);
+        });
+    }
+
+    private constructor(private templateString: string) {
+        this._current = templateString;
+    }
+
+    public static create(templateString: string) {
+        return new TemplateStringHelper(templateString);
+    }
+
+    /**
+     * Parses a template string by replacing the placeholders with the values from the provided data object
+     * unmatched placeholders will be left as is
+     */
+    public parse(data: Record<string, string>, regex: TemplateStringMatch = Match.default) {
+        if (typeof this._current !== 'string' || typeof data !== 'object') return this;
+        this._current = this._current.replace(regex, (match, token) => {
+            const val = data?.[token] ?? match; // Use nullish coalescing to preserve falsy values (0, '', false)
+
+            return typeof val === 'object' ? JSON.stringify(val) : escapeJsonField(val);
+        });
+
+        return this;
+    }
+
+    /**
+     * Parses a template string by replacing placeholders with values from the provided data object, keeping the original raw values intact. This is particularly important for BinaryInput instances, as they include buffer data.
+     * unmatched placeholders will be left as is
+     */
+    // Note: right now this method only match the first occurrence of the regex
+    public parseRaw(data: Record<string, string>, regex: TemplateStringMatch = Match.doubleCurlyForSingleMatch) {
+        if (typeof this._current !== 'string' || typeof data !== 'object') return this;
+
+        const match = this._current.match(regex);
+        const key = match ? match[1] : '';
+
+        if (key) {
+            const value = data?.[key];
+            this._current = value;
+        }
+
+        return this;
+    }
+
+    /**
+     * This is a shortcut function that parses vault key values and replace them with corresponding values from team vault
+     * @param teamId
+     * @returns
+     */
+    public parseTeamKeysAsync(teamId: string) {
+        return this.process(TPLProcessor.vaultTeam(teamId), Match.fn('KEY'));
+    }
+
+    /**
+     * This is a shortcut function that parses component template variables and replace them with their corresponding values
+     * @param templateSettings the component template settings to be used for parsing
+     * @returns
+     */
+    public parseComponentTemplateVarsAsync(templateSettings: Record<string, any>) {
+        return this.process(TPLProcessor.componentTemplateVar(templateSettings), Match.templateVariables);
+    }
+
+    /**
+     * Processes a template string by replacing the placeholders with the result of the provided processor function
+     * The processor function receives the token as an argument and should return the value to replace the token with
+     * If the processor function returns undefined, the token will be left as is
+     */
+    public process(processor: (token, matches?) => Promise<string> | string, regex: TemplateStringMatch = Match.default) {
+        if (typeof this._current !== 'string') return this;
+        //first build a json object with all matching tokens
+        let tokens = {};
+        let match;
+
+        const prosessorPromises = [];
+        while ((match = regex.exec(this._current)) !== null) {
+            const token = match[1];
+            tokens[token] = match[0];
+
+            const _processor = processor(token, match);
+
+            //if an async processor is used, the TemplateStringHelper switches to async mode
+            if (_processor instanceof Promise) {
+                _processor.then((result) => {
+                    if (result === undefined) {
+                        return match?.[0];
+                    }
+                    tokens[token] = result;
+                });
+                prosessorPromises.push(_processor);
+            } else {
+                tokens[token] = _processor;
+            }
+        }
+
+        if (prosessorPromises.length > 0) {
+            const promise = new Promise(async (resolve, reject) => {
+                await Promise.all(prosessorPromises);
+                this.parse(tokens, regex);
+                resolve(true);
+            });
+            this._promiseQueue.push(Promise.all(prosessorPromises));
+        } else {
+            this.parse(tokens, regex);
+        }
+
+        // this._current = await asyncReplace(this._current, regex, async (match, token) => {
+        //     let result = await processor(token);
+        //     if (result === undefined) {
+        //         return match;
+        //     }
+        //     return result;
+        // });
+
+        return this;
+    }
+
+    /**
+     * Removes all placeholders from the template string, leaving only the plain text
+     * This is useful when you want to clean up a template string that has placeholders that were not parsed
+     */
+    public clean(regex: TemplateStringMatch = Match.default, replaceWith: string = '') {
+        if (typeof this._current !== 'string') return this;
+        this._current = this._current.replace(regex, replaceWith);
+        return this;
+    }
+
+    // public toString() {
+    //     if (this._promiseQueue.length <= 0) return this._current;
+    //     return new Promise(async (resolve, reject) => {
+    //         await Promise.all(this._promiseQueue);
+    //         resolve(this._current);
+    //     });
+    // }
+}
+
+/**
+ * a helper function that takes a string and escape it
+ * This is useful when you have a stringified json and want to replace one of its values while making sure it won't break the json structure (e.g new lines, double quotes ...etc)
+ */
+export function escapeString(str?: string) {
+    if (!str) return str;
+    return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n').replace(/\r/g, '\\r').replace(/\t/g, '\\t');
+}
+
+// This is used escape JSON values characters like double quotes '"' to parse it properly
+export function escapeJsonField(str?: string) {
+    if (typeof str !== 'string') return str;
+    return str.replace(/\\"/g, '"').replace(/"/g, '\\"');
+}
+
+export function TemplateString(templateString: string) {
+    return TemplateStringHelper.create(templateString);
+}