@ductape/sdk 0.1.8 → 0.1.10

package/dist/processor/utils/processor.utils.js

@@ -0,0 +1,1066 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateMockData = exports.getMigrationsToRun = exports.validateFeatureJSONInput = exports.updateUrlsInObject = exports.extractAxiosErrorDetails = exports.validateStringsInObject = exports.generateIndexes = exports.cleanBlob = exports.structuredClone = exports.compareValues = exports.generateDatabaseQuery = exports.transformToJson = exports.mailerClient = exports.replacePlaceholderString = exports.removeWrappingQuotes = exports.isValidSqsUrl = exports.calculateJWTExpiry = exports.calculateExpiry = exports.extractNumberFromArrayString = exports.decrypt = exports.encrypt = exports.generateObjectId = exports.generateAxiosConfig = void 0;
+exports.parameterizeResource = parameterizeResource;
+exports.validateNotification = validateNotification;
+exports.generateNotificationTemplate = generateNotificationTemplate;
+exports.convertStringToObject = convertStringToObject;
+exports.generateSqlQuery = generateSqlQuery;
+exports.truncateInputForApi = truncateInputForApi;
+exports.parseTimeToMs = parseTimeToMs;
+exports.anonymizeObject = anonymizeObject;
+exports.anonymizeValue = anonymizeValue;
+exports.toFormUrlEncoded = toFormUrlEncoded;
+exports.extractSelectorValue = extractSelectorValue;
+//import * as crypto from 'crypto';
+const CryptoJS = __importStar(require("crypto-js"));
+const enums_1 = require("../../types/enums");
+const bson_objectid_1 = __importDefault(require("bson-objectid"));
+const enums_2 = require("../../types/enums");
+const string_utils_1 = require("../../products/utils/string.utils");
+const inputs_service_1 = __importDefault(require("../../inputs/inputs.service"));
+const types_1 = require("../../types");
+const crypto_1 = require("crypto");
+async function loadTransport() {
+    if (typeof window === 'undefined') {
+        const { createTransport } = await Promise.resolve().then(() => __importStar(require('nodemailer')));
+        return createTransport;
+    }
+    return null;
+}
+const generateAxiosConfig = () => {
+    return {
+        headers: {
+            Accept: enums_2.DataFormats.JSON,
+            'Content-Type': enums_2.DataFormats.JSON,
+        },
+    };
+};
+exports.generateAxiosConfig = generateAxiosConfig;
+const generateObjectId = () => {
+    return new bson_objectid_1.default().toHexString();
+};
+exports.generateObjectId = generateObjectId;
+// Encrypt function using CryptoJS
+const encrypt = (text, key) => {
+    const iv = CryptoJS.lib.WordArray.random(16); // Generate random IV
+    // Hash the key with SHA-256
+    const hashedKey = CryptoJS.SHA256(key);
+    // Encrypt the text using AES with the hashed key and IV
+    const encrypted = CryptoJS.AES.encrypt(text, hashedKey, { iv });
+    // Return IV and encrypted data as hex strings, separated by ':'
+    return iv.toString(CryptoJS.enc.Hex) + ':' + encrypted.toString();
+};
+exports.encrypt = encrypt;
+// Decrypt function using CryptoJS
+const decrypt = (text, key) => {
+    //console.log('[decrypt] Called with text:', text ? `${String(text).substring(0, 50)}...` : text, 'key:', key ? 'SET' : 'NULL');
+    if (!text || typeof text !== 'string') {
+        throw new Error(`[decrypt] Invalid text parameter: expected string, got ${typeof text}`);
+    }
+    const colonIndex = text.indexOf(':');
+    if (colonIndex === -1) {
+        throw new Error('[decrypt] Invalid encrypted format: expected iv:ciphertext');
+    }
+    const ivHex = text.slice(0, colonIndex);
+    const encryptedText = text.slice(colonIndex + 1);
+    // Parse IV from hex format
+    const iv = CryptoJS.enc.Hex.parse(ivHex);
+    // Hash the key with SHA-256
+    const hashedKey = CryptoJS.SHA256(key);
+    // Decrypt the encrypted text using AES with the hashed key and IV
+    const decrypted = CryptoJS.AES.decrypt(encryptedText, hashedKey, { iv });
+    return decrypted.toString(CryptoJS.enc.Utf8); // Convert decrypted data to UTF-8 string
+};
+exports.decrypt = decrypt;
+const extractNumberFromArrayString = (str) => {
+    const regex = /^\[(\d+)\]$/;
+    const match = str.match(regex);
+    if (match) {
+        return parseInt(match[1]);
+    }
+    else {
+        return null;
+    }
+};
+exports.extractNumberFromArrayString = extractNumberFromArrayString;
+const calculateExpiry = (expiry, period) => {
+    const now = new Date();
+    if (expiry === null) {
+        now.setFullYear(now.getFullYear() + 100);
+        return now.getTime();
+    }
+    switch (period) {
+        case enums_1.TokenPeriods.SECONDS:
+            return now.getTime() + expiry * 1000;
+        case enums_1.TokenPeriods.MINUTES:
+            return now.getTime() + expiry * 60 * 1000;
+        case enums_1.TokenPeriods.HOURS:
+            return now.getTime() + expiry * 60 * 60 * 1000;
+        case enums_1.TokenPeriods.DAYS:
+            return now.getTime() + expiry * 24 * 60 * 60 * 1000;
+        case enums_1.TokenPeriods.WEEKS:
+            return now.getTime() + expiry * 7 * 24 * 60 * 60 * 1000;
+        case enums_1.TokenPeriods.MONTHS:
+            now.setMonth(now.getMonth() + expiry);
+            return now.getTime();
+        case enums_1.TokenPeriods.YEARS:
+            now.setFullYear(now.getFullYear() + expiry);
+            return now.getTime();
+        default:
+            throw new Error('Invalid token period');
+    }
+};
+exports.calculateExpiry = calculateExpiry;
+const calculateJWTExpiry = (expiry, period) => {
+    if (expiry === null) {
+        return '100y'; // fallback for near-infinite expiry
+    }
+    switch (period) {
+        case enums_1.TokenPeriods.SECONDS:
+            return `${expiry}s`;
+        case enums_1.TokenPeriods.MINUTES:
+            return `${expiry}m`;
+        case enums_1.TokenPeriods.HOURS:
+            return `${expiry}h`;
+        case enums_1.TokenPeriods.DAYS:
+            return `${expiry}d`;
+        case enums_1.TokenPeriods.WEEKS:
+            return `${expiry * 7}d`; // JWT doesn't support 'w' in all libs
+        case enums_1.TokenPeriods.MONTHS:
+            return `${expiry * 30}d`; // approximate
+        case enums_1.TokenPeriods.YEARS:
+            return `${expiry}y`;
+        default:
+            throw new Error('Invalid token period');
+    }
+};
+exports.calculateJWTExpiry = calculateJWTExpiry;
+function parameterizeResource(resource, key, datapoint) {
+    if (!datapoint)
+        return resource;
+    // Regex matches :key or {{key}} (with optional whitespace)
+    const regex = new RegExp(`(:${key})|(\{\{\s*${key}\s*\}\})`, 'g');
+    return resource.replace(regex, datapoint);
+}
+function validateNotification({ push_notification }, payload) {
+    const requiredFields = {
+        title: (0, string_utils_1.extractPlaceholders)(push_notification.title).map((field) => field.key),
+        body: (0, string_utils_1.extractPlaceholders)(push_notification.body).map((field) => field.key),
+        data: push_notification.data
+            ? (0, string_utils_1.extractPlaceholders)(JSON.stringify(push_notification.data)).map((field) => field.key)
+            : [],
+    };
+    const payloadFields = {
+        title: payload.title || {},
+        body: payload.body || {},
+        data: payload.data || {},
+    };
+    let missingFields = [];
+    const checkMissingKeys = (inputFields, fieldValue, fieldName) => {
+        // If the payload field is already a string (resolved template), skip key validation
+        if (typeof fieldValue !== 'object' || fieldValue === null) {
+            return;
+        }
+        const obj = fieldValue;
+        inputFields.forEach((key) => {
+            if (!(key in obj)) {
+                missingFields.push(`${fieldName}.${key}`);
+            }
+        });
+    };
+    checkMissingKeys(requiredFields.title, payloadFields.title, 'title');
+    checkMissingKeys(requiredFields.body, payloadFields.body, 'body');
+    checkMissingKeys(requiredFields.data, payloadFields.data, 'data');
+    if (missingFields.length > 0) {
+        throw new Error(`The following keys are required: ${missingFields.join(', ')}`);
+    }
+}
+const isValidSqsUrl = (url) => {
+    const sqsUrlRegex = types_1.sqsUrlPattern;
+    return sqsUrlRegex.test(url);
+};
+exports.isValidSqsUrl = isValidSqsUrl;
+const removeWrappingQuotes = (str) => {
+    return str.replace(/^[“”"‘']|[“”"‘']$/g, '');
+};
+exports.removeWrappingQuotes = removeWrappingQuotes;
+const replacePlaceholderString = (template, payloadFields) => {
+    if (typeof payloadFields !== 'object' || payloadFields === null) {
+        return template;
+    }
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
+        if (key in payloadFields) {
+            return payloadFields[key];
+        }
+        return `{{${key}}}`;
+    });
+};
+exports.replacePlaceholderString = replacePlaceholderString;
+function generateNotificationTemplate({ push_notification }, payload) {
+    const title = typeof payload.title === 'string'
+        ? payload.title
+        : (0, exports.replacePlaceholderString)(push_notification.title, payload.title || {});
+    const body = typeof payload.body === 'string'
+        ? payload.body
+        : (0, exports.replacePlaceholderString)(push_notification.body, payload.body || {});
+    const data = typeof payload.data === 'string'
+        ? payload.data
+        : push_notification.data
+            ? (0, exports.replacePlaceholderString)(JSON.stringify(push_notification.data), payload.data || {})
+            : '{}';
+    return { title, body, data };
+}
+function convertStringToObject(str) {
+    const regex = /(\w+):\s*([^}]+)/g;
+    let match;
+    const obj = {};
+    while ((match = regex.exec(str)) !== null) {
+        obj[match[1]] = match[2];
+    }
+    return obj;
+}
+function replacePlaceholders(template, payload) {
+    const placeholderRegex = /{{\s*(\w+)\s*}}/g;
+    // Replace each placeholder with corresponding value from payload
+    return template.replace(placeholderRegex, (match, key) => {
+        if (key in payload) {
+            return payload[key];
+        }
+        else {
+            console.error(`Missing value for placeholder: {{${key}}}`);
+            return match; // Keep the placeholder if no value is provided
+        }
+    });
+}
+const mailerClient = async (auth) => {
+    /*const auth = {
+      host: process.env.SMTP_HOST,
+      port: Number(process.env.SMTP_PORT),
+      auth: {
+        user: process.env.SMTP_USER,
+        pass: process.env.SMTP_PASSWORD,
+      },
+      secure: false, // true for 465, false for other ports
+      tls: {
+        rejectUnauthorized: false, // do not fail on invalid certs
+      },
+    }*/
+    const createTransport = await loadTransport();
+    if (createTransport) {
+        const transport = createTransport(auth);
+        return transport;
+    }
+    else {
+        throw new Error(`Running in browser, mailer client not loaded.`);
+    }
+};
+exports.mailerClient = mailerClient;
+// function transformToJson(template: string, payload: Record<string, any>) {
+//   try {
+//     // Regular expression to match {{key}} placeholders
+//     const regex = /{{\s*([^}]+)\s*}}|(?<!")(\$?\w+)(?=\s*:)/g;
+//     // Replace placeholders with values from the payload and wrap keys and values in double quotes
+//     const jsonString = template
+//       .replace(regex, (_, key) => {
+//         if (!(key in payload)) {
+//           throw new Error(`Missing value for placeholder: {{${key}}}`);
+//         }
+//         return JSON.stringify(payload[key]); // Ensures values are properly JSON stringified
+//       })
+//       .replace(/([a-zA-Z0-9_]+)\s*:/g, '"$1:'); // Wrap keys in double quotes
+//     console.log(jsonString);
+//     // Parse the resulting string into JSON
+//     const jsonObject = JSON.parse(jsonString);
+//     return jsonObject;
+//   } catch (error) {
+//     console.error('Error transforming string to JSON:', error);
+//     return null;
+//   }
+// }
+const transformToJson = (template, payload) => {
+    try {
+        // Regular expression to match placeholders {{key}} and optional $ at the start of the key
+        const combinedRegex = /{{\s*([^}]+)\s*}}|(?<!")(\$?\w+)(?=\s*:)/g;
+        let jsonString = template.replace(combinedRegex, (match, placeholder, keyOrMongoOperator) => {
+            if (placeholder) {
+                // If it's a placeholder (e.g., {{key}})
+                const key = placeholder.split(':')[0];
+                if (!(key in payload)) {
+                    throw new Error(`Missing key: ${key}`);
+                }
+                return JSON.stringify(payload[key]); // Replace placeholder with the corresponding value from the payload
+            }
+            else if (keyOrMongoOperator) {
+                // If it's a key or MongoDB operator (e.g., $match or status)
+                return `${keyOrMongoOperator}`; // Just wrap it in double quotes
+            }
+            return match; // Default case: return match unchanged
+        });
+        jsonString = jsonString.replace(/:""/g, ':"');
+        jsonString = jsonString.replace(/"",/g, '",');
+        jsonString = jsonString.replace(/""}/g, '"}');
+        //console.log(jsonString);
+        // Parse the resulting string into JSON
+        const jsonObject = JSON.parse(jsonString);
+        return jsonObject;
+    }
+    catch (error) {
+        console.error('Error transforming string to JSON:', error);
+        return null;
+    }
+};
+exports.transformToJson = transformToJson;
+const generateDatabaseQuery = (query, payload) => {
+    const json = (0, exports.transformToJson)(query, payload);
+    if (!json) {
+        throw new Error('Could not transform query to json');
+    }
+    return json;
+};
+exports.generateDatabaseQuery = generateDatabaseQuery;
+function generateSqlQuery(template, data) {
+    // Extract all field placeholders and their positions
+    const placeholders = [];
+    const pattern = /{{\s*([^{}\s]+)\s*}}/g;
+    let match;
+    while ((match = pattern.exec(template)) !== null) {
+        placeholders.push({
+            field: match[1].split(':')[0],
+            position: match.index,
+        });
+    }
+    // Handle single record case
+    if (!Array.isArray(data)) {
+        const values = [];
+        let query = template;
+        placeholders
+            .sort((a, b) => b.position - a.position)
+            .forEach(({ field }, index) => {
+            if (data[field] === undefined) {
+                throw new Error(`Missing value for field: ${field}`);
+            }
+            const paramNumber = placeholders.length - index;
+            query = query.replace(new RegExp(`{{\\s*${field}\\s*}}`, 'g'), `$${paramNumber}`);
+            values.unshift(data[field]);
+        });
+        return { parameterizedQuery: query, values };
+    }
+    // Handle multiple records case
+    if (data.length === 0) {
+        throw new Error('Data array cannot be empty');
+    }
+    // Check if this is an INSERT (has VALUES clause) or UPDATE query
+    const isInsert = /INSERT\s+INTO/i.test(template);
+    const isUpdate = /UPDATE\s+\w+\s+SET/i.test(template);
+    if (!isInsert && !isUpdate) {
+        throw new Error('Multiple record operations only supported for INSERT and UPDATE queries');
+    }
+    // Handle bulk INSERT
+    if (isInsert) {
+        const valuesMatch = template.match(/VALUES\s*\((.*?)\)/i);
+        if (!valuesMatch) {
+            throw new Error('Cannot find VALUES clause in template for bulk insert');
+        }
+        const valueFields = Array.from(valuesMatch[1].matchAll(pattern)).map((match) => match[1]);
+        const values = data.map((record) => valueFields.map((field) => {
+            if (record[field] === undefined) {
+                throw new Error(`Missing value for field: ${field} in record`);
+            }
+            return record[field];
+        }));
+        const parameterStrings = values.map((_, rowIndex) => {
+            const params = valueFields.map((_, colIndex) => `$${rowIndex * valueFields.length + colIndex + 1}`);
+            return `(${params.join(', ')})`;
+        });
+        const query = template.replace(/VALUES\s*\(.*?\)/i, `VALUES ${parameterStrings.join(', ')}`);
+        return { parameterizedQuery: query, values: values.flat() };
+    }
+    // Handle bulk UPDATE
+    if (isUpdate) {
+        // Extract the table name
+        const tableMatch = template.match(/UPDATE\s+(\w+)/i);
+        if (!tableMatch) {
+            throw new Error('Cannot parse table name from UPDATE query');
+        }
+        const tableName = tableMatch[1];
+        // Extract SET fields and WHERE condition fields
+        const setFields = [];
+        const whereFields = [];
+        let inWhereClause = false;
+        placeholders.forEach(({ field }) => {
+            if (template.indexOf(`WHERE`) < template.indexOf(`{{${field}}}`)) {
+                inWhereClause = true;
+            }
+            if (inWhereClause) {
+                whereFields.push(field);
+            }
+            else {
+                setFields.push(field);
+            }
+        });
+        if (whereFields.length === 0) {
+            throw new Error('Bulk UPDATE requires a WHERE clause with at least one field');
+        }
+        // Generate the bulk update query
+        const allFields = [...setFields, ...whereFields];
+        const values = data.flatMap((record) => allFields.map((field) => {
+            if (record[field] === undefined) {
+                throw new Error(`Missing value for field: ${field} in record`);
+            }
+            return record[field];
+        }));
+        // Create the VALUES section for the CTE
+        const parameterStrings = data.map((_, rowIndex) => {
+            const params = allFields.map((_, colIndex) => `$${rowIndex * allFields.length + colIndex + 1}`);
+            return `(${params.join(', ')})`;
+        });
+        // Construct the new query using a CTE
+        const query = `
+      UPDATE ${tableName} AS t SET
+        ${setFields.map((field) => `${field} = c.${field}`).join(',\n        ')}
+      FROM (VALUES
+        ${parameterStrings.join(',\n        ')}
+      ) AS c(${allFields.join(', ')})
+      WHERE ${whereFields.map((field) => `t.${field} = c.${field}`).join(' AND ')}
+    `.trim();
+        return { parameterizedQuery: query, values };
+    }
+    throw new Error('Unsupported query type');
+}
+const compareValues = (initiator, operator, value) => {
+    // Convert initiator and value to numbers if they are numeric strings
+    const isInitiatorNumeric = !isNaN(Number(initiator));
+    const isValueNumeric = !isNaN(Number(value));
+    const left = isInitiatorNumeric ? Number(initiator) : initiator;
+    const right = isValueNumeric ? Number(value) : value;
+    // Check if the operator is valid
+    const validOperators = ['>', '<', '>=', '<=', '==', '!=='];
+    if (!validOperators.includes(operator)) {
+        throw new Error(`Invalid operator: ${operator}`);
+    }
+    // Compare based on the operator
+    switch (operator) {
+        case '>':
+            if (typeof left === 'number' && typeof right === 'number') {
+                return left > right;
+            }
+            throw new Error(`Operator '>' is not valid for non-numeric values.`);
+        case '<':
+            if (typeof left === 'number' && typeof right === 'number') {
+                return left < right;
+            }
+            throw new Error(`Operator '<' is not valid for non-numeric values.`);
+        case '>=':
+            if (typeof left === 'number' && typeof right === 'number') {
+                return left >= right;
+            }
+            throw new Error(`Operator '>=' is not valid for non-numeric values.`);
+        case '<=':
+            if (typeof left === 'number' && typeof right === 'number') {
+                return left <= right;
+            }
+            throw new Error(`Operator '<=' is not valid for non-numeric values.`);
+        case '==':
+            return left == right; // Equality check (loose comparison)
+        case '!==':
+            return left !== right; // Inequality check
+        default:
+            throw new Error(`Unhandled operator: ${operator}`);
+    }
+};
+exports.compareValues = compareValues;
+const structuredClone = (data) => {
+    return JSON.parse(JSON.stringify(data));
+};
+exports.structuredClone = structuredClone;
+/** Max bytes/chars to keep when truncating buffer for logging or API payloads (file jobs) */
+const TRUNCATE_BUFFER_MAX = 256;
+function truncateBuffer(value) {
+    if (Buffer.isBuffer(value)) {
+        const len = value.length;
+        if (len <= TRUNCATE_BUFFER_MAX)
+            return `[Buffer ${len} bytes]`;
+        return `[Buffer truncated, ${len} bytes total, first ${TRUNCATE_BUFFER_MAX} shown]`;
+    }
+    if (typeof value === 'string') {
+        if (value.length <= TRUNCATE_BUFFER_MAX)
+            return value;
+        return value.slice(0, TRUNCATE_BUFFER_MAX) + '...';
+    }
+    return String(value);
+}
+const cleanBlob = (data) => {
+    var _a;
+    if (((_a = data.input) === null || _a === void 0 ? void 0 : _a.buffer) != null) {
+        data.input.buffer = truncateBuffer(data.input.buffer);
+    }
+    return data;
+};
+exports.cleanBlob = cleanBlob;
+/**
+ * Returns a shallow copy of input with any buffer field truncated for logging/API (e.g. job execution tracker).
+ * Use for file/storage job input so large buffers are not sent to the backend.
+ */
+function truncateInputForApi(input) {
+    if (input == null || typeof input !== 'object')
+        return input;
+    const out = Object.assign({}, input);
+    if (out.buffer != null) {
+        out.buffer = truncateBuffer(out.buffer);
+    }
+    return out;
+}
+const generateIndexes = (operator, //">" | "<" | ">=" | "<=" | "==" | "!==",
+iter, init, value) => {
+    const indexes = [];
+    let i = init;
+    // Define a function to dynamically evaluate the condition
+    const condition = (current) => {
+        switch (operator) {
+            case '>':
+                return current > value;
+            case '<':
+                return current < value;
+            case '>=':
+                return current >= value;
+            case '<=':
+                return current <= value;
+            case '==':
+                return current === value;
+            case '!==':
+                return current !== value;
+            default:
+                throw new Error(`Invalid operator: ${operator}`);
+        }
+    };
+    // Generate indexes
+    while (condition(i)) {
+        indexes.push(i);
+        i += iter; // Increment by the iterator value
+    }
+    return indexes;
+};
+exports.generateIndexes = generateIndexes;
+function parseTimeToMs(interval) {
+    const match = interval.match(/^(\d+)\s*(s|m|h|d|w|mo)$/);
+    if (!match)
+        throw new Error(`Invalid interval: ${interval}`);
+    const [, valueStr, unit] = match;
+    const value = parseInt(valueStr, 10);
+    const unitToMs = {
+        s: 1000,
+        m: 60 * 1000,
+        h: 60 * 60 * 1000,
+        d: 24 * 60 * 60 * 1000,
+        w: 7 * 24 * 60 * 60 * 1000,
+        mo: 30 * 24 * 60 * 60 * 1000, // Approximate
+    };
+    return value * unitToMs[unit];
+}
+const validateStringsInObject = (obj) => {
+    let isValid = true;
+    const invalidPrefixes = ['$Input{', '$Sequence{', '$Size{', '$Length{'];
+    const validate = (value) => {
+        // Check if value is a string and does not start with any invalid prefix
+        if (typeof value === 'string') {
+            for (const prefix of invalidPrefixes) {
+                if (value.startsWith(prefix)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    };
+    const recurse = (item) => {
+        if (!isValid)
+            return; // Stop processing if already invalid
+        if (Array.isArray(item)) {
+            for (const element of item) {
+                recurse(element);
+                if (!isValid)
+                    break;
+            }
+        }
+        else if (typeof item === 'object' && item !== null) {
+            for (const key in item) {
+                if (Object.prototype.hasOwnProperty.call(item, key)) {
+                    recurse(item[key]);
+                    if (!isValid)
+                        break;
+                }
+            }
+        }
+        else {
+            // Validate primitive value
+            isValid = validate(item);
+        }
+    };
+    recurse(obj);
+    return isValid;
+};
+exports.validateStringsInObject = validateStringsInObject;
+const extractAxiosErrorDetails = (error) => {
+    var _a;
+    if (error.isAxiosError) {
+        const { code, message, config, response, cause, errors } = error;
+        const extractedError = {
+            code: code || null,
+            message: message || null,
+            method: ((_a = config === null || config === void 0 ? void 0 : config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || null,
+            url: (config === null || config === void 0 ? void 0 : config.baseURL) + (config === null || config === void 0 ? void 0 : config.url) || null,
+            status: (response === null || response === void 0 ? void 0 : response.status) || null,
+            responseMessage: (response === null || response === void 0 ? void 0 : response.statusText) || null,
+            data: (response === null || response === void 0 ? void 0 : response.data) || null,
+            cause: cause || null,
+            nestedErrors: Array.isArray(errors)
+                ? errors.map((err) => ({
+                    message: err.message,
+                    code: err.code,
+                    address: err.address,
+                    port: err.port,
+                    syscall: err.syscall,
+                }))
+                : null,
+        };
+        //console.log('Extracted Axios Error:', extractedError);
+        return extractedError;
+    }
+    else {
+        return { error: error.toString() };
+    }
+};
+exports.extractAxiosErrorDetails = extractAxiosErrorDetails;
+const updateUrlsInObject = (obj, replacementValue) => {
+    let foundUrl = null;
+    // Helper function to check if a string is a valid URL
+    function isValidUrl(str) {
+        try {
+            new URL(str);
+            return true;
+        }
+        catch (_a) {
+            return false;
+        }
+    }
+    // Recursive function to traverse and update the object
+    const traverseAndUpdate = (currentObj) => {
+        if (Array.isArray(currentObj)) {
+            return currentObj.map((item) => traverseAndUpdate(item));
+        }
+        else if (typeof currentObj === 'object' && currentObj !== null) {
+            const result = {};
+            for (const [key, value] of Object.entries(currentObj)) {
+                result[key] = traverseAndUpdate(value);
+            }
+            return result;
+        }
+        else if (typeof currentObj === 'string' && isValidUrl(currentObj)) {
+            if (foundUrl !== null) {
+                throw new Error(`More than one URL found: ${foundUrl} and ${currentObj}`);
+            }
+            foundUrl = currentObj;
+            return replacementValue;
+        }
+        else {
+            return currentObj;
+        }
+    };
+    const updatedObj = traverseAndUpdate(obj);
+    if (!foundUrl) {
+        throw new Error('No URL found in the object.');
+    }
+    return { updatedObj, replacedUrl: foundUrl };
+};
+exports.updateUrlsInObject = updateUrlsInObject;
+const validateFeatureJSONInput = (input, feature_input) => {
+    const input_keys = Object.keys(input);
+    const feature_keys = Object.keys(feature_input);
+    // validate input to flag keys that are not expected
+    for (let i = 0; i < input_keys.length; i++) {
+        const key = input_keys[i];
+        const value = feature_input[key];
+        if (!value) {
+            throw new Error(`{ ${key} : ${value}}, is not expected in the input  `);
+        }
+        const validation_keys = ['type', 'minlength', 'maxlength'];
+        // handle nested objects
+        if (typeof value === 'object' &&
+            !Array.isArray(value) &&
+            !Object.keys(value).every((value) => validation_keys.includes(value))) {
+            // TODO: handle arrays
+            (0, exports.validateFeatureJSONInput)(input[key], value);
+        }
+        // TODO: validate arrays later on
+        if (typeof value === 'object' && Array.isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                (0, exports.validateFeatureJSONInput)(input[key], value[i]);
+            }
+        }
+    }
+    // validate input to flag missing keys
+    for (let i = 0; i < feature_keys.length; i++) {
+        const key = feature_keys[i];
+        const value = input[key];
+        if (!value) {
+            throw new Error(`${key}, is expected in the input  `);
+        }
+        const feature_value = feature_input[key];
+        const inputService = new inputs_service_1.default();
+        inputService.validateFeatureInputData({ key, value }, feature_value);
+    }
+};
+exports.validateFeatureJSONInput = validateFeatureJSONInput;
+const getMigrationsToRun = (allMigrations, type, migrationTag, env) => {
+    const migrationsToRun = [];
+    const index = allMigrations.findIndex((value) => value.tag === migrationTag);
+    if (type === 'up') {
+        const migrations = allMigrations.splice(index - 1);
+        migrationsToRun.push(...migrations);
+    }
+    else {
+        const migrations = allMigrations.splice(0, index + 1);
+        migrationsToRun.push(...migrations);
+    }
+    const results = [];
+    for (const migration of migrationsToRun) {
+        const environment = migration.envs.find((envValue) => envValue.slug === env);
+        if (!environment) {
+            continue;
+        }
+        results.push(migration);
+    }
+    return migrationsToRun;
+};
+exports.getMigrationsToRun = getMigrationsToRun;
+const inAYear = () => {
+    const oneYearLater = new Date();
+    oneYearLater.setFullYear(oneYearLater.getFullYear() + 1);
+    return oneYearLater.getTime();
+};
+const generateMockData = (resource, env, payload) => {
+    /*const testAccountNumbers = [
+      '0234567890',
+      '1087654321',
+      '2156789034',
+      '3054987612',
+      '4076543219',
+      '5067892345',
+      '6789012348',
+    ];
+    const prodAccountNumbers = [
+      '8543946818',
+      '8563920810',
+      '8500946878',
+      '8387746800',
+      '8233676839',
+      '8263946910',
+      '8223977899',
+    ];
+  
+    const random = Math.floor(Math.random() * 7);
+    const InAYear = inAYear();
+    if (resource === 'v3/virtual-account-numbers') {
+      let bank_name = 'Mock Bank';
+      let flw_ref = `MockFLWRef-${InAYear}`;
+  
+      let account_number = testAccountNumbers[random];
+  
+      if (env === 'prd') {
+        bank_name = 'Wema Bank';
+        flw_ref = `FLWRef-${InAYear}`;
+  
+        account_number = prodAccountNumbers[random];
+      }
+  
+      return {
+        status: 'success',
+        message: 'Virtual account created',
+        data: {
+          response_code: '02',
+          response_message: 'Transaction in progress',
+          flw_ref,
+          order_ref: payload.tx_ref,
+          account_number,
+          account_status: 'active',
+          frequency: 1,
+          bank_name,
+          created_at: Date.now(),
+          expiry_date: InAYear,
+          note: payload.narration,
+          amount: payload.amount,
+        },
+      };
+    }*/
+    if (resource === 'v3/virtual-cards') {
+        const cardId = (0, crypto_1.randomUUID)();
+        const pan = generateCardPan(env);
+        return {
+            status: 'success',
+            message: 'Card created successfully',
+            data: {
+                id: cardId,
+                account_id: Math.floor(10000 + Math.random() * 90000),
+                amount: String(payload.amount),
+                currency: payload.currency,
+                card_hash: (0, crypto_1.randomUUID)(),
+                card_pan: pan,
+                masked_pan: maskCardPan(pan),
+                city: payload.billing_city,
+                state: payload.billing_state,
+                address_1: payload.billing_address,
+                address_2: '',
+                zip_code: payload.billing_postal_code,
+                cvv: Math.floor(100 + Math.random() * 900),
+                expiration: '2028-03',
+                send_to: '',
+                bin_check_name: '',
+                card_type: 'mastercard',
+                name_on_card: payload.billing_name,
+                created_at: new Date().toISOString(),
+                is_active: false,
+                callback_url: '',
+            },
+        };
+    }
+    else {
+        return null;
+    }
+    /*if (resource === 'customer') {
+      return {
+        status: true,
+        message: 'Customer created',
+        data: {
+          // @ts-ignore
+          transactions: [],
+          // @ts-ignore
+          subscriptions: [],
+          // @ts-ignore
+          authorizations: [],
+          email: payload.email,
+          first_name: payload.first_name,
+          last_name: payload.last_name,
+          phone: payload.phone,
+          integration: Math.floor(100000 + Math.random() * 900000),
+          domain: 'test',
+          metadata: {},
+          customer_code: `CUS_${generateRandomString()}`,
+          risk_action: 'default',
+          id: Math.floor(10000000 + Math.random() * 90000000),
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+          identified: false,
+          // @ts-ignore
+          identifications: [],
+        },
+      };
+    }
+  
+    if (resource === 'dedicated_account') {
+      let bank_name = 'Mock Bank';
+      let bank_slug = 'mock-bank';
+      let account_number = testAccountNumbers[random];
+  
+      if (env === 'prd') {
+        bank_name = 'Paystack-Titan Bank';
+        bank_slug = 'paystack-titan-bank';
+  
+        account_number = prodAccountNumbers[random];
+      }
+  
+      return {
+        status: true,
+        message: 'NUBAN successfully created',
+        data: {
+          bank: {
+            name: bank_name,
+            id: Math.floor(Math.random() * 20),
+            slug: bank_slug,
+          },
+          account_number,
+          account_name: 'Oluwafikayo Sanni',
+          assigned: true,
+          currency: 'NGN',
+          metadata: null,
+          active: true,
+          id: Math.floor(Math.random() * 999),
+          created_at: '2019-12-12T12:39:04.000Z',
+          updated_at: '2020-01-06T15:51:24.000Z',
+          assignment: {
+            integration: Math.floor(100000 + Math.random() * 900000),
+            assignee_id: Math.floor(100000 + Math.random() * 900000),
+            assignee_type: 'Customer',
+            expired: false,
+            account_type: 'PAY-WITH-TRANSFER-RECURRING',
+            assigned_at: new Date(),
+          },
+          customer: {
+            id: Math.floor(100000 + Math.random() * 900000),
+            first_name: 'Oluwafikayo',
+            last_name: 'Sanni',
+            email: 'fikayo@ductape.app',
+            customer_code: 'CUS_kpb3qj71u1m0rw8',
+            phone: 2349053267565,
+            risk_action: 'default',
+          },
+        },
+      };
+    }*/
+};
+exports.generateMockData = generateMockData;
+function generateRandomString(length = 15) {
+    const characters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';
+    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+}
+function generateCardPan(env) {
+    const bin = '536613'; // Wema Bank BIN (first 6 digits for MasterCard)
+    const randomDigits = Array.from({ length: 9 }, () => Math.floor(Math.random() * 10)).join('');
+    const partialPan = bin + randomDigits;
+    // Calculate Luhn check digit
+    const checkDigit = getLuhnCheckDigit(partialPan);
+    return partialPan + checkDigit;
+}
+function getLuhnCheckDigit(number) {
+    const digits = number.split('').map(Number).reverse();
+    const sum = digits.reduce((acc, digit, index) => {
+        if (index % 2 === 0) {
+            digit *= 2;
+            if (digit > 9)
+                digit -= 9;
+        }
+        return acc + digit;
+    }, 0);
+    return (10 - (sum % 10)) % 10;
+}
+function maskCardPan(cardPan) {
+    return cardPan.replace(/^(\d{6})\d{6}(\d{4})$/, '$1******$2');
+}
+function anonymizeObject(obj) {
+    if (typeof obj !== 'object' || obj === null)
+        return obj;
+    if (Array.isArray(obj)) {
+        return obj.map((item) => anonymizeObject(item));
+    }
+    const anonymized = {};
+    for (const key in obj) {
+        if (!Object.prototype.hasOwnProperty.call(obj, key))
+            continue;
+        const value = obj[key];
+        // Exclude fields ending with "Id" (case insensitive)
+        if (key.match(/Id$/i)) {
+            anonymized[key] = value;
+            continue;
+        }
+        if (typeof value === 'string') {
+            anonymized[key] = anonymizeValue(value);
+        }
+        else if (typeof value === 'number') {
+            anonymized[key] = Number(anonymizeValue(value.toString())); // Convert back to number
+        }
+        else if (typeof value === 'boolean') {
+            anonymized[key] = false; // Replace booleans with `false`
+        }
+        else {
+            anonymized[key] = anonymizeObject(value); // Recursively handle objects/arrays
+        }
+    }
+    return anonymized;
+}
+/** Simple check: value has exactly one @ with non-empty local and domain parts. */
+function looksLikeEmail(value) {
+    if (value == null || typeof value !== 'string')
+        return false;
+    const parts = value.split("@");
+    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0 && parts[1].includes(".");
+}
+function anonymizeValue(value) {
+    if (value == null || typeof value !== 'string')
+        return '';
+    if (!looksLikeEmail(value)) {
+        return maskString(value);
+    }
+    const [localPart, domainPart] = value.split("@");
+    // Mask Local Part (Username)
+    const localSegments = localPart.split(".");
+    const maskedLocal = localSegments
+        .map(segment => {
+        if (segment.length <= 2)
+            return segment[0] + "*";
+        return segment[0] + "*".repeat(segment.length - 2) + segment.slice(-1);
+    })
+        .join(".");
+    // Mask Domain Part (e.g., example.com)
+    const domainSegments = domainPart.split(".");
+    const maskedDomain = domainSegments
+        .map(segment => {
+        if (segment.length <= 2)
+            return segment[0] + "*";
+        return segment[0] + "*".repeat(segment.length - 2) + segment.slice(-1);
+    })
+        .join(".");
+    return `${maskedLocal}@${maskedDomain}`;
+}
+// Your existing mask logic, renamed for clarity
+function maskString(value) {
+    if (value.length <= 3)
+        return '***'; // Short values get fully masked
+    const chars = value.split('');
+    const maskCount = Math.floor((2 / 3) * chars.length);
+    const maskIndexes = new Set();
+    while (maskIndexes.size < maskCount) {
+        maskIndexes.add(Math.floor(Math.random() * chars.length));
+    }
+    return chars.map((char, index) => (maskIndexes.has(index) ? '*' : char)).join('');
+}
+function toFormUrlEncoded(json) {
+    return new URLSearchParams(json).toString();
+}
+function extractSelectorValue(schema, stages, selector) {
+    let current = schema;
+    for (const stage of stages) {
+        if (current && typeof current === 'object' && stage in current) {
+            current = current[stage];
+        }
+        else {
+            throw new Error(`${selector} not found in event sample`);
+        }
+    }
+    return current;
+}
+//# sourceMappingURL=processor.utils.js.map