@ductape/sdk 0.1.6 → 0.1.8

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

@@ -1,1066 +0,0 @@
-"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