@smythos/sre 1.5.1 → 1.5.4

package/src/utils/base64.utils.ts

@@ -0,0 +1,275 @@
+import { fileTypeFromBuffer } from 'file-type';
+import { isValidString } from './string.utils';
+import { MAX_FILE_SIZE } from '@sre/constants';
+
+/**
+ * This function converts a text string to a base64 URL.
+ * @param text
+ * @returns
+ */
+export function textToBase64Url(text) {
+    // Create a Buffer from the string
+    const buffer = Buffer.from(text, 'utf-8');
+
+    // Convert the Buffer to a base64 string
+    const base64String = buffer.toString('base64');
+
+    // Construct the data URL
+    const base64Url = `data:text/plain;base64,${base64String}`;
+
+    return base64Url;
+}
+
+export const isBase64FileUrl = (url: string): boolean => {
+    if (typeof url !== 'string') return false;
+
+    const regex = /^data:([\w+\-\.]+\/[\w+\-\.]+);base64,(.*)$/;
+    const match = url.match(regex);
+    if (!match) return false;
+    const [, , base64Data] = match;
+
+    return isBase64(base64Data);
+};
+
+export const getMimetypeFromBase64Data = async (data: string) => {
+    try {
+        data = _cleanUpBase64Data(data);
+
+        // Convert the base64 string back to a Buffer
+        const imageBuffer = Buffer.from(data, 'base64');
+
+        const type = await fileTypeFromBuffer(imageBuffer);
+        return type?.mime || '';
+    } catch (error) {
+        console.error('Error getting mimetype from base64 data: ', error);
+        return '';
+    }
+};
+
+export async function getBase64FileInfo(data: string): Promise<{ data: string; mimetype: string; size: number } | null> {
+    if (isBase64FileUrl(data)) {
+        const regex = /^data:([^;]+);base64,(.*)$/;
+        const match = data.match(regex);
+        if (!match) return { data: '', mimetype: '', size: 0 };
+        const [, mimetype, base64Data] = match;
+
+        const cleanData = _cleanUpBase64Data(base64Data);
+        const buffer = Buffer.from(cleanData, 'base64');
+
+        return { data: cleanData, mimetype, size: buffer.byteLength };
+    } else if (isBase64(data)) {
+        const cleanData = _cleanUpBase64Data(data);
+        const buffer = Buffer.from(cleanData, 'base64');
+
+        return {
+            data: cleanData,
+            mimetype: await getMimetypeFromBase64Data(cleanData),
+            size: buffer.byteLength,
+        };
+    }
+
+    return null;
+}
+
+//=== Legacy code below ===
+//@Forhad the functions below need to be reviewed and refactored
+
+/**
+ * Remove all whitespace characters and literal \n and \s sequences
+ *
+ * @note It's common practice to split base64 data into multiple lines for better readability and to avoid issues with systems that can't handle very long lines. So we need to clean up newline characters from the base64 data before processing it.
+ * @param {string} str - The input string.
+ * @returns {string} The input string with all newline characters and escaped newline strings removed.
+ */
+function cleanBase64(str: string): string {
+    return str.replace(/\s|\\n|\\s/g, '');
+}
+
+/**
+ * Checks if the input is a data URL.
+ *
+ * @param {string} input - The input string.
+ * @returns {boolean} True if the input is a data URL, false otherwise.
+ */
+export function isBase64DataUrl(input: string): boolean {
+    // Data URL pattern: data:[<mediatype>][;base64],<data>
+    const pattern = /^data:([\w+\-\.]+\/[\w+\-\.]+);base64,(.*)$/;
+
+    return pattern.test(input);
+}
+
+/**
+ * Checks if the given string is a valid Base64-encoded string.
+ *
+ * @param {string} str - The string to check.
+ * @returns {boolean} True if the string is a valid Base64-encoded string, false otherwise.
+ */
+export function isBase64(str: string): boolean {
+    if (!isValidString(str)) return false;
+
+    const cleanedBase64Data = cleanBase64(str);
+
+    // Sometimes words like 'male' and hashes like md5, sha1, sha256, sha512 are detected as base64
+    if (cleanedBase64Data.length < 128) return false;
+
+    try {
+        const buffer = Buffer.from(cleanedBase64Data, 'base64');
+
+        // ignoring trailing padding ensures that the comparison is based on the actual content, not the padding
+        return buffer.toString('base64').replace(/=+$/, '') === cleanedBase64Data.replace(/=+$/, '');
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Parses a Base64-encoded data URL and extracts the MIME type and cleaned data.
+ *
+ * @param {string} input - The Base64-encoded data URL.
+ * @returns {{ mimetype: string; data: string }} An object containing the MIME type and the cleaned Base64 data.
+ * @throws {Error} If the input is invalid.
+ */
+function parseBase64DataUrl(input: string): { mimetype: string; data: string } {
+    const pattern = /^data:([\w+\-\.]+\/[\w+\-\.]+);base64,(.*)$/;
+    const matches = input.match(pattern);
+
+    if (!matches) {
+        throw new Error('Invalid data URL!');
+    }
+
+    const [, mimetype, data] = matches;
+
+    if (!isBase64(data)) {
+        throw new Error('Invalid base64 data!');
+    }
+
+    return { mimetype, data: cleanBase64(data) };
+}
+
+/**
+ * Parses a Base64-encoded string and extracts the MIME type and cleaned data.
+ *
+ * @param {string} input - The Base64-encoded string.
+ * @returns {Promise<{ mimetype: string; data: string }>} An object containing the MIME type and the cleaned Base64 data.
+ */
+export async function parseBase64(input: string): Promise<{ mimetype: string; data: string }> {
+    const cleanedData = cleanBase64(input);
+    const mimetype = await identifyMimetypeFromBase64(cleanedData);
+
+    return { mimetype, data: cleanedData };
+}
+
+/**
+ * Identifies the MIME type from a Base64-encoded string.
+ *
+ * This function cleans the input Base64 string, converts it to a buffer, and then identifies the MIME type
+ * using the `fileTypeFromBuffer` function.
+ *
+ * @param {string} data - The Base64-encoded string from which to identify the MIME type.
+ * @returns {Promise<string>} A promise that resolves to the MIME type of the data, or an empty string if the MIME type cannot be determined.
+ *
+ * @throws {Error} If an error occurs during the process, it logs the error and returns an empty string.
+ */
+export async function identifyMimetypeFromBase64(data: string): Promise<string> {
+    try {
+        const cleanedData = cleanBase64(data);
+
+        // Convert the base64 string back to a Buffer
+        const buffer = Buffer.from(cleanedData, 'base64');
+
+        const type = await fileTypeFromBuffer(buffer);
+
+        return type?.mime || '';
+    } catch (error) {
+        throw new Error(`Error identifying MIME type from base64 data: ${error?.message}`);
+    }
+}
+
+/**
+ * Identifies the MIME type from a Base64-encoded string.
+ *
+ * This function cleans the input Base64 string, converts it to a buffer, and then identifies the MIME type
+ * using the `fileTypeFromBuffer` function.
+ *
+ * @param {string} data - The Base64-encoded string from which to identify the MIME type.
+ * @returns {Promise<string>} A promise that resolves to the MIME type of the data, or an empty string if the MIME type cannot be determined.
+ *
+ * @throws {Error} If an error occurs during the process, it logs the error and returns an empty string.
+ */
+export async function identifyMimeTypeFromBase64DataUrl(input: string): Promise<string> {
+    try {
+        const { data } = await parseBase64DataUrl(input);
+
+        const buffer = Buffer.from(data, 'base64');
+
+        const type = await fileTypeFromBuffer(buffer);
+
+        return type?.mime || '';
+    } catch (error) {
+        throw new Error(`Error identifying MIME type from base64 data: ${error?.message}`);
+    }
+}
+
+/**
+ * Calculates the size of a Base64-encoded string in bytes.
+ *
+ * This function validates the input string to ensure it is a valid Base64-encoded string,
+ * converts it to a buffer, and then returns the byte length of the buffer.
+ *
+ * @param {string} str - The Base64-encoded string whose size is to be calculated.
+ * @returns {number} The size of the Base64-encoded string in bytes.
+ *
+ * @throws {Error} If the input string is not a valid Base64-encoded string or if an error occurs during conversion.
+ */
+export function getSizeOfBase64(str: string): number {
+    if (!isValidString(str)) {
+        throw new Error('Invalid Base64 data!');
+    }
+
+    try {
+        const buffer = Buffer.from(str, 'base64');
+        return buffer.byteLength;
+    } catch (error) {
+        throw new Error(`Invalid Base64 data! ${error.message}`);
+    }
+}
+
+/**
+ * Generates a Base64 Data URL from a Base64-encoded string.
+ *
+ * This function validates the input Base64 string, removes any newline characters,
+ * and constructs a Data URL with the specified MIME type.
+ *
+ * @param {string} data - The Base64-encoded string to be converted into a Data URL.
+ * @param {string} [mimetype='application/octet-stream'] - The MIME type of the data. Defaults to 'application/octet-stream'.
+ * @returns {string} The generated Base64 Data URL.
+ *
+ * @throws {Error} If the input string is not a valid Base64-encoded string.
+ */
+export function makeBase64Url(data: string, mimetype: string = 'application/octet-stream'): string {
+    if (!isValidString(data)) {
+        throw new Error('Invalid Base64 data!');
+    }
+
+    // Remove any newline characters from the Base64 string
+    const cleanedData = data.replace(/\n/g, '');
+
+    // Construct and return the Data URL
+    return `data:${mimetype};base64,${cleanedData}`;
+}
+
+/**
+ ** It's common practice to split base64 data into multiple lines for better readability and to avoid issues with systems that can't handle very long lines.
+ ** So we need to clean up newline characters from the base64 data before processing it.
+ * @param {string} str - The input string.
+ * @returns {string} The input string with all newline characters and escaped newline strings removed.
+ */
+const _cleanUpBase64Data = (str: string): string => {
+    // Check if the input is a string and is not excessively large
+    if (typeof str !== 'string' || str.length > MAX_FILE_SIZE) {
+        throw new Error('Invalid input');
+    }
+
+    // Remove all whitespace characters and literal \n and \s sequences
+    return str.replace(/\s|\\n|\\s/g, '');
+};

package/src/utils/cli.utils.ts

@@ -0,0 +1,68 @@
+/**
+ * This function parses the command line arguments and returns an object with the parsed values.
+ * The expected format is --file ./path/to/file.txt or --settings key1=value1 key2=value2
+ * Examples:
+ *  --file ./path/to/file.txt : calling parseCLIArgs('file', process.argv) will return {file: './path/to/file.txt'}
+ *  --settings key1=value1 key2=value2 : calling parseCLIArgs('settings', process.argv) will return {settings: {key1: 'value1', key2: 'value2'}}
+ *  it can also parse multiple arguments at once, for example:
+ *      parseCLIArgs(['file', 'settings'], process.argv) will return {file: './path/to/file.txt', settings: {key1: 'value1', key2: 'value2'}}
+ *
+ * @param argList the argument to parse
+ * @param argv the command line arguments, usually process.argv
+ * @returns parsed arguments object
+ */
+
+export function parseCLIArgs(argList: string | Array<string>, argv?: Array<string>): Record<string, any> {
+    if (!argv) argv = process.argv;
+    const args = argv;
+    const result = {};
+    const mainArgs = Array.isArray(argList) ? argList : [argList];
+    mainArgs.forEach((mainArg) => {
+        const mainArgIndex = args.indexOf(`--${mainArg}`);
+        if (mainArgIndex !== -1) {
+            const values: any = [];
+            for (let i = mainArgIndex + 1; i < args.length; i++) {
+                if (args[i].startsWith('--')) break;
+                values.push(args[i]);
+            }
+
+            if (values.length === 1 && values[0].includes('=')) {
+                const keyValuePairs = {};
+                const [key, ...valParts] = values[0].split('=');
+                const val = valParts.join('=').replace(/^"|"$/g, '');
+                keyValuePairs[key] = val;
+                result[mainArg] = keyValuePairs;
+            } else if (values.length === 1) {
+                result[mainArg] = values[0];
+            } else if (values.length > 1) {
+                const keyValuePairs = {};
+                values.forEach((value) => {
+                    const [key, ...valParts] = value.split('=');
+                    const val = valParts.join('=').replace(/^"|"$/g, '');
+                    keyValuePairs[key] = val;
+                });
+                result[mainArg] = keyValuePairs;
+            }
+        }
+    });
+
+    return result;
+}
+
+/**
+ * List all cli main arguments
+ * example : node index.js --file ./path/to/file.txt --settings key1=value1 key2=value2
+ * calling getMainArgs(process.argv) will return ['file', 'settings']
+ */
+export function getMainArgs(argv?: Array<string>): Array<string> {
+    if (!argv) argv = process.argv;
+    const args = argv;
+    const result = [];
+    for (let i = 2; i < args.length; i++) {
+        if (args[i].startsWith('--')) {
+            result.push(args[i].replace(/^--/, ''));
+        }
+    }
+
+    return result;
+}

package/src/utils/data.utils.ts

@@ -0,0 +1,263 @@
+import { Readable } from 'stream';
+import axios from 'axios';
+
+import { identifyMimeTypeFromBase64DataUrl, isBase64FileUrl, isBase64, identifyMimetypeFromBase64, isBase64DataUrl } from './base64.utils';
+import { isBinaryFileSync } from 'isbinaryfile';
+import { fileTypeFromBuffer } from 'file-type';
+import { BinaryInput } from '@sre/helpers/BinaryInput.helper';
+import { identifyMimetypeFromString } from './string.utils';
+
+// Helper function to convert stream to buffer
+export async function streamToBuffer(stream: Readable): Promise<Buffer> {
+    const chunks: Buffer[] = [];
+    for await (const chunk of stream) {
+        chunks.push(typeof chunk === 'string' ? Buffer.from(chunk) : chunk);
+    }
+    return Buffer.concat(chunks);
+}
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// == Helpers from Legacy Smyth implementation ==============================================
+// FIXME : below functions should probably be converted to a validator
+
+//export declare function isBinaryFile(file: string | Buffer, size?: number): Promise<boolean>;
+//export declare function isBinaryFileSync(file: string | Buffer, size?: number): boolean;
+const binaryMimeTypes = ['image/', 'audio/', 'video/', 'application/pdf', 'application/zip', 'application/octet-stream'];
+
+export function dataToBuffer(data: any): Buffer | null {
+    let bufferData;
+    switch (true) {
+        case data instanceof ArrayBuffer:
+            bufferData = Buffer.from(new Uint8Array(data));
+            break;
+        case ArrayBuffer.isView(data) && !(data instanceof DataView):
+            bufferData = Buffer.from(new Uint8Array(data.buffer));
+            break;
+        case data instanceof DataView:
+            bufferData = Buffer.from(new Uint8Array(data.buffer, data.byteOffset, data.byteLength));
+            break;
+        case Buffer.isBuffer(data):
+            bufferData = data;
+            break;
+        case typeof data === 'string':
+            bufferData = Buffer.from(data, 'utf-8');
+            break;
+        default:
+            return null;
+    }
+
+    return bufferData;
+}
+
+export const getSizeFromBinary = (data: any) => {
+    const buffer = dataToBuffer(data);
+    if (!buffer) return 0;
+    return buffer.byteLength;
+};
+
+/**
+ * Calculates the size in bytes of a base64-encoded string after decoding
+ *
+ * @param base64String - The base64 string to calculate the size for. Can be a raw base64 string or a data URL.
+ * @returns The size in bytes of the decoded data
+ */
+function getBase64FileSize(base64String: string): number {
+    // Remove data URL prefix if present
+    const base64Data = base64String.includes(';base64,') ? base64String.split(';base64,')[1] : base64String;
+
+    // Formula: (n * 3) / 4 - padding
+    const padding = base64Data.endsWith('==') ? 2 : base64Data.endsWith('=') ? 1 : 0;
+    return Math.floor((base64Data.length * 3) / 4) - padding;
+}
+
+export const isPlainObject = (data: any): boolean => {
+    return (
+        typeof data === 'object' &&
+        data !== null &&
+        !Array.isArray(data) &&
+        Object.prototype.toString.call(data) === '[object Object]' &&
+        data.constructor === Object
+    );
+};
+
+// isBuffer checks if the provided data is a Buffer object in Node.js.
+export const isBuffer = (data: any): boolean => {
+    try {
+        return Buffer.isBuffer(data);
+    } catch {
+        // Buffer.isBuffer throws error when non-array Object is passed
+        return false;
+    }
+};
+
+// isBinaryMimeType checks if the provided mimetype indicates binary data.
+export const isBinaryMimeType = (mimetype): boolean => {
+    if (mimetype) {
+        return binaryMimeTypes.some((type) => mimetype.startsWith(type));
+    }
+    return false;
+};
+
+// isBinaryData checks if the provided data is binary.
+// If the data is a Buffer, ArrayBuffer, TypedArray, or DataView, it checks if it contains binary data.
+export const isBinaryData = (data): boolean => {
+    // To prevent returning true when we have emojis in the string like "Hello 😀"
+    if (typeof data === 'string') return false;
+
+    try {
+        const buffer = dataToBuffer(data);
+        if (!buffer) return false;
+        return isBinaryFileSync(buffer, buffer.byteLength);
+    } catch (error) {
+        return false;
+    }
+};
+
+// TODO: Need to check if this is intentional, I think we're checking for http/https urls only
+export function isUrl(str: string): boolean {
+    if (typeof str !== 'string') return false;
+    // This regex checks for protocol, hostname, domain, port (optional), path (optional), and query string (optional)
+    //const regex = /^(https?:\/\/)([^\s.]+\.[^\s]{2,})(:[0-9]{1,5})?(\/[^\s]*)?(\?[^\s]*)?$/i;
+    const regex = /^([a-zA-Z0-9]+:\/\/)([^\s.]+\.[^\s]{2,})(:[0-9]{1,5})?(\/[^\s]*)?(\?[^\s]*)?$/i;
+
+    return regex.test(str);
+}
+
+export function isSmythFsUrl(str: string): boolean {
+    if (typeof str !== 'string') return false;
+    const regex = /^smythfs:\/\/([^\s.]+\.[^\s]{2,})(:[0-9]{1,5})?(\/[^\s]*)?(\?[^\s]*)?$/i;
+    return regex.test(str);
+}
+
+export const isSmythFileObject = (data: any): boolean => {
+    return !!(typeof data === 'object' && data !== null && data?.url && isUrl(data?.url) && 'size' in data && 'mimetype' in data);
+};
+
+export const isBufferObject = (data: Record<string, any>): boolean => {
+    if (!data) return false;
+
+    return typeof data === 'object' && data !== null && data?.buffer && isBuffer(data.buffer) && 'size' in data && 'mimetype' in data;
+};
+
+export const isBase64Object = (data: Record<string, any>): boolean => {
+    if (!data) return false;
+
+    return typeof data === 'object' && data !== null && data?.base64 && isBase64(data.base64) && 'size' in data && 'mimetype' in data;
+};
+
+export async function getMimeType(data: any): Promise<string> {
+    const mimeTypeGetters = {
+        blob: () => data.type,
+        buffer: async () => {
+            try {
+                // TODO: debug why this is not returning a file type for images when used through BinaryInput.helper.ts
+                const fileType = await fileTypeFromBuffer(data);
+                return fileType?.mime ?? '';
+            } catch {
+                console.warn('Failed to get mime type from buffer');
+                return '';
+            }
+        },
+        url: async () => {
+            try {
+                const response = await axios.get(data); // head() method does not work for all URLs
+                const contentType = response.headers['content-type'];
+                return contentType;
+            } catch {
+                console.warn('Failed to get mime type from URL');
+                return '';
+            }
+        },
+        smythFile: () => data.mimetype,
+        base64DataUrl: () => identifyMimeTypeFromBase64DataUrl(data),
+        base64: () => identifyMimetypeFromBase64(data),
+        string: () => identifyMimetypeFromString(data),
+    };
+
+    const typeChecks = {
+        blob: data instanceof Blob,
+        buffer: isBuffer(data),
+        url: isUrl(data),
+        smythFile: isSmythFileObject(data),
+        base64DataUrl: isBase64FileUrl(data),
+        base64: isBase64(data),
+        string: typeof data === 'string',
+    };
+
+    const [matchedType = ''] = Object.entries(typeChecks).find(([, value]) => value) || [];
+    if (!matchedType) return '';
+
+    return await mimeTypeGetters?.[matchedType]?.();
+}
+
+// Mask data like Buffer, FormData, etc. in debug output
+// TODO [Forhad]: Need to get the size of FormData
+export async function formatDataForDebug(data: any) {
+    let dataForDebug;
+
+    if (!data) {
+        return data;
+    }
+
+    try {
+        if (data.constructor?.name === 'BinaryInput') {
+            const jsonData = await data.getJsonData();
+            dataForDebug = `[BinaryInput size=${jsonData?.size}]`;
+        } else if (isBuffer(data)) {
+            dataForDebug = `[Buffer size=${data.byteLength}]`;
+        } else if (data.constructor?.name === 'FormData') {
+            dataForDebug = `[FormData]`;
+        } else if (isBase64(data) || isBase64DataUrl(data)) {
+            dataForDebug = `[Base64 size=${getBase64FileSize(data)}]`;
+        } else {
+            dataForDebug = data;
+        }
+    } catch (error) {
+        // Fallback to a safe representation if any error occurs
+        dataForDebug = '[Binary]';
+    }
+
+    return dataForDebug;
+}
+
+// TODO: Maybe we need move this function to any helper file, as it depends on BinaryInput class
+export async function normalizeImageInput(inputImage: string | BinaryInput): Promise<string> {
+    if (!inputImage) {
+        return '';
+    }
+
+    // Handle string inputs
+    if (typeof inputImage === 'string') {
+        if (isBase64(inputImage)) {
+            // Convert raw base64 to data URL with proper MIME type
+            const mimeType = (await getMimeType(inputImage)) || 'image/png';
+            return `data:${mimeType};base64,${inputImage}`;
+        }
+
+        if (isBase64DataUrl(inputImage)) {
+            return inputImage; // Already in correct format
+        }
+
+        if (isUrl(inputImage)) {
+            return inputImage; // Valid URL, return as-is
+        }
+
+        throw new Error('Invalid string input: must be base64, data URL, or HTTP(S) URL');
+    }
+
+    // Handle BinaryInput
+    // * There is a bug (server crash) when we check like this: inputImage instanceof BinaryInput
+    // TODO [Forhad]: Need find out the root cause and fix it
+    if (inputImage.constructor?.name === 'BinaryInput') {
+        try {
+            const buffer = await inputImage.getBuffer();
+            const mimeType = (await getMimeType(buffer)) || 'image/png';
+            const base64Data = buffer.toString('base64');
+            return `data:${mimeType};base64,${base64Data}`;
+        } catch (error) {
+            throw new Error(`Failed to process BinaryInput: ${error.message}`);
+        }
+    }
+
+    throw new Error('Unsupported input type');
+}

package/src/utils/date-time.utils.ts

@@ -0,0 +1,22 @@
+export function getCurrentFormattedDate() {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are 0-based
+    const day = String(date.getDate()).padStart(2, '0');
+    const hours = String(date.getHours()).padStart(2, '0');
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const seconds = String(date.getSeconds()).padStart(2, '0');
+    return `${year}-${month}-${day}-${hours}-${minutes}-${seconds}`;
+}
+
+export function getDayFormattedDate() {
+    const date = new Date();
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, '0'); // Months are 0-based
+    const day = String(date.getDate()).padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+
+export function delay(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}