@jahia/cypress 8.0.0 → 8.1.1

package/dist/support/apollo/apollo.d.ts

@@ -8,9 +8,11 @@ declare global {
 }
 export type FileQueryOptions = Partial<QueryOptions> & {
     queryFile?: string;
+    sourcePackage?: string;
 };
 export type FileMutationOptions = Partial<MutationOptions> & {
     mutationFile?: string;
+    sourcePackage?: string;
 };
 export type ApolloOptions = (QueryOptions | MutationOptions | FileQueryOptions | FileMutationOptions) & Partial<Cypress.Loggable>;
 export declare const apollo: (apollo: ApolloClient<any>, options: ApolloOptions) => void;

package/dist/support/apollo/apollo.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.apollo = void 0;
 var graphql_tag_1 = __importDefault(require("graphql-tag"));
+var graphql_1 = require("graphql");
 function isQuery(options) {
     return options.query !== undefined;
 }
@@ -37,53 +38,114 @@ function isQueryFile(options) {
 function isMutationFile(options) {
     return options.mutationFile !== undefined;
 }
+function getOperationLabel(doc, opType) {
+    var _a, _b, _c, _d, _e;
+    var opDef = (0, graphql_1.getOperationAST)(doc);
+    if ((_a = opDef === null || opDef === void 0 ? void 0 : opDef.name) === null || _a === void 0 ? void 0 : _a.value) {
+        return "[".concat(opType, "] ").concat(opDef.name.value);
+    }
+    // Anonymous operation: traverse up to 2 selection levels for a meaningful label
+    var firstSel = (_c = (_b = opDef === null || opDef === void 0 ? void 0 : opDef.selectionSet) === null || _b === void 0 ? void 0 : _b.selections) === null || _c === void 0 ? void 0 : _c[0];
+    if ((firstSel === null || firstSel === void 0 ? void 0 : firstSel.kind) === 'Field') {
+        var firstName = firstSel.name.value;
+        var secondSel = (_e = (_d = firstSel.selectionSet) === null || _d === void 0 ? void 0 : _d.selections) === null || _e === void 0 ? void 0 : _e[0];
+        if ((secondSel === null || secondSel === void 0 ? void 0 : secondSel.kind) === 'Field') {
+            return "[".concat(opType, "] ").concat(firstName, " \u203A ").concat(secondSel.name.value);
+        }
+        return "[".concat(opType, "] ").concat(firstName);
+    }
+    return "[".concat(opType, "]");
+}
+function getQueryBody(doc) {
+    var _a, _b, _c;
+    return (_c = (_b = (_a = doc === null || doc === void 0 ? void 0 : doc.loc) === null || _a === void 0 ? void 0 : _a.source) === null || _b === void 0 ? void 0 : _b.body) !== null && _c !== void 0 ? _c : (0, graphql_1.print)(doc);
+}
 // eslint-disable-next-line default-param-last, @typescript-eslint/no-shadow
 var apollo = function (apollo, options) {
     if (apollo === void 0) { apollo = this.currentApolloClient; }
     var result;
     var logger;
+    var duration;
     var optionsWithDefaultCache = __assign({ fetchPolicy: 'no-cache' }, options);
     if (!apollo) {
         cy.apolloClient().apollo(optionsWithDefaultCache);
     }
     else if (isQueryFile(optionsWithDefaultCache)) {
-        var queryFile = optionsWithDefaultCache.queryFile, apolloOptions_1 = __rest(optionsWithDefaultCache, ["queryFile"]);
-        cy.fixture(queryFile).then(function (content) {
-            cy.apollo(__assign({ query: (0, graphql_tag_1.default)(content) }, apolloOptions_1));
+        var _a = optionsWithDefaultCache, queryFile_1 = _a.queryFile, sourcePackage_1 = _a.sourcePackage, apolloOptions_1 = __rest(_a, ["queryFile", "sourcePackage"]);
+        cy.fixture(queryFile_1).then(function (content) {
+            var fileLabel = sourcePackage_1 ? "".concat(queryFile_1, " @ ").concat(sourcePackage_1) : queryFile_1;
+            cy.apollo(__assign(__assign({ query: (0, graphql_tag_1.default)(content) }, apolloOptions_1), { _sourceFile: fileLabel }));
         });
     }
     else if (isMutationFile(optionsWithDefaultCache)) {
-        var mutationFile = optionsWithDefaultCache.mutationFile, apolloOptions_2 = __rest(optionsWithDefaultCache, ["mutationFile"]);
-        cy.fixture(mutationFile).then(function (content) {
-            cy.apollo(__assign({ mutation: (0, graphql_tag_1.default)(content) }, apolloOptions_2));
+        var _b = optionsWithDefaultCache, mutationFile_1 = _b.mutationFile, sourcePackage_2 = _b.sourcePackage, apolloOptions_2 = __rest(_b, ["mutationFile", "sourcePackage"]);
+        cy.fixture(mutationFile_1).then(function (content) {
+            var fileLabel = sourcePackage_2 ? "".concat(mutationFile_1, " @ ").concat(sourcePackage_2) : mutationFile_1;
+            cy.apollo(__assign(__assign({ mutation: (0, graphql_tag_1.default)(content) }, apolloOptions_2), { _sourceFile: fileLabel }));
         });
     }
     else {
-        var _a = optionsWithDefaultCache.log, log = _a === void 0 ? true : _a, apolloOptions_3 = __rest(optionsWithDefaultCache, ["log"]);
+        var _c = optionsWithDefaultCache.log, log = _c === void 0 ? true : _c, apolloOptions = __rest(optionsWithDefaultCache, ["log"]);
+        var doc = isQuery(apolloOptions) ?
+            apolloOptions.query :
+            apolloOptions.mutation;
+        var opType_1 = isQuery(apolloOptions) ? 'Query' : 'Mutation';
+        var operationLabel_1 = getOperationLabel(doc, opType_1);
+        var queryBody_1 = getQueryBody(doc);
+        var variables_1 = apolloOptions.variables;
+        var sourceLabel_1 = optionsWithDefaultCache._sourceFile ? " (".concat(optionsWithDefaultCache._sourceFile, ")") : '';
+        var variablesLabel_1 = variables_1 && Object.keys(variables_1).length > 0 ?
+            " \u2014 ".concat(JSON.stringify(variables_1)) :
+            '';
         if (log) {
             logger = Cypress.log({
                 autoEnd: false,
                 name: 'apollo',
                 displayName: 'apollo',
-                message: isQuery(apolloOptions_3) ? "Execute Graphql Query: ".concat(apolloOptions_3.query.loc.source.body) : "Execute Graphql Mutation: ".concat(apolloOptions_3.mutation.loc.source.body),
+                message: "".concat(operationLabel_1).concat(sourceLabel_1).concat(variablesLabel_1),
                 consoleProps: function () {
-                    return {
-                        Options: apolloOptions_3,
-                        Yielded: result
-                    };
+                    var _a;
+                    var _b, _c, _d;
+                    var errors = (_c = (_b = result === null || result === void 0 ? void 0 : result.errors) !== null && _b !== void 0 ? _b : result === null || result === void 0 ? void 0 : result.graphQLErrors) !== null && _c !== void 0 ? _c : null;
+                    var isCaughtError = result instanceof Error;
+                    var hasErrors = ((errors === null || errors === void 0 ? void 0 : errors.length) > 0) || isCaughtError;
+                    return _a = {
+                            Operation: operationLabel_1,
+                            Variables: variables_1 !== null && variables_1 !== void 0 ? variables_1 : {}
+                        },
+                        _a["".concat(opType_1, " Body")] = queryBody_1,
+                        _a.Duration = duration === undefined ? 'pending' : "".concat(duration, "ms"),
+                        _a.Status = hasErrors ?
+                            "error".concat(isCaughtError ? ": ".concat(result.message) : '') :
+                            'success',
+                        _a.Data = (_d = result === null || result === void 0 ? void 0 : result.data) !== null && _d !== void 0 ? _d : null,
+                        _a.Errors = errors,
+                        _a.Yielded = result,
+                        _a;
                 }
             });
         }
-        cy.wrap({}, { log: true })
+        var startTime_1 = Date.now();
+        cy.wrap({}, { log: false })
             .then(function () { return (isQuery(optionsWithDefaultCache) ? apollo.query(optionsWithDefaultCache).catch(function (error) {
-            cy.log("Caught Graphql Query Error: ".concat(JSON.stringify(error)));
+            var _a;
+            cy.log("Caught GraphQL query error: ".concat((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : JSON.stringify(error)));
             return error;
         }) : apollo.mutate(optionsWithDefaultCache).catch(function (error) {
-            cy.log("Caught Graphql Mutation Error: ".concat(JSON.stringify(error)));
+            var _a;
+            cy.log("Caught GraphQL mutation error: ".concat((_a = error === null || error === void 0 ? void 0 : error.message) !== null && _a !== void 0 ? _a : JSON.stringify(error)));
             return error;
         }))
             .then(function (r) {
+            var _a;
             result = r;
+            duration = Date.now() - startTime_1;
+            if (logger) {
+                var errors = (_a = r === null || r === void 0 ? void 0 : r.errors) !== null && _a !== void 0 ? _a : r === null || r === void 0 ? void 0 : r.graphQLErrors;
+                var hasErrors = (r instanceof Error) || ((errors === null || errors === void 0 ? void 0 : errors.length) > 0);
+                var prefix = hasErrors ? '❌ ' : '✅ ';
+                logger.set('message', "".concat(prefix).concat(operationLabel_1).concat(sourceLabel_1).concat(variablesLabel_1));
+            }
             logger === null || logger === void 0 ? void 0 : logger.end();
             return r;
         }); });

package/dist/support/browserHelper.d.ts

@@ -0,0 +1,10 @@
+export declare const BrowserHelper: {
+    logCookies: () => Cypress.Chainable<void>;
+    logCookie: (cookieName: string) => Cypress.Chainable<void>;
+    logSessionStorage: () => Cypress.Chainable<void>;
+    logLocalStorage: () => Cypress.Chainable<void>;
+    clearSessionCookies: () => Cypress.Chainable<void>;
+    clearPersistentCookies: () => Cypress.Chainable<void>;
+    simulateClose: () => void;
+    resetState: () => void;
+};

package/dist/support/browserHelper.js

@@ -0,0 +1,167 @@
+"use strict";
+/*
+ * Contains helpers for printing or clearing browser's storage and cookies.
+ * These are intended for interactive debugging and log full values by design.
+ * Use with caution in automated tests to avoid exposing sensitive data in logs.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BrowserHelper = void 0;
+/**
+ * Prints cookie details in a structured format for debugging.
+ *
+ * Note: This helper logs the full cookie value by design.
+ * @param {Cypress.Cookie} cookie Cookie object returned by Cypress.
+ * @returns {void}
+ * @private
+ */
+var printCookieValues = function (cookie) {
+    var cookieType = cookie.expiry ? 'Persistent' : 'Session';
+    var expiryDate = cookie.expiry ? new Date(cookie.expiry * 1000).toISOString() : 'Session only';
+    var daysUntilExpiry = cookie.expiry ? Math.round(((cookie.expiry * 1000) - Date.now()) / 1000 / 60 / 60 / 24) : null;
+    cy.log('-'.repeat(60));
+    cy.log("Cookie: ".concat(cookie.name));
+    cy.log('-'.repeat(60));
+    cy.log("Type:       ".concat(cookieType));
+    cy.log("Value:      ".concat(cookie.value));
+    cy.log("Domain:     ".concat(cookie.domain));
+    cy.log("Path:       ".concat(cookie.path));
+    cy.log("Secure:     ".concat(cookie.secure ? '✔ Yes' : '✘ No'));
+    cy.log("HttpOnly:   ".concat(cookie.httpOnly ? '✔ Yes' : '✘ No'));
+    cy.log("SameSite:   ".concat(cookie.sameSite || '(not set)'));
+    if (cookie.expiry) {
+        cy.log("Expires:    ".concat(expiryDate));
+        cy.log("Days left:  ".concat(daysUntilExpiry, " days"));
+        cy.log("Unix time:  ".concat(cookie.expiry));
+    }
+    else {
+        cy.log('Expires:    When browser closes (session cookie)');
+    }
+};
+/**
+ * Clears cookies based on their persistence type.
+ * @param {'session'|'persistent'} [type='session'] Cookie category to clear.
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when clearing is complete.
+ */
+var clearCookiesByType = function (type) {
+    if (type === void 0) { type = 'session'; }
+    return cy.getCookies().then(function (cookies) {
+        var cookiesToClear = cookies.filter(function (cookie) { return (type === 'session' ? !cookie.expiry : Boolean(cookie.expiry)); });
+        cy.step("\uD83D\uDDD1\uFE0F CLEAR ".concat(cookiesToClear.length, " ").concat(type, " cookie(s):"), function () {
+            cookiesToClear.forEach(function (cookie) {
+                var info = cookie.expiry ? "expires ".concat(new Date(cookie.expiry * 1000).toISOString()) : 'session only';
+                cy.log(" ... clearing ".concat(cookie.name, " (").concat(info, ")"));
+                cy.clearCookie(cookie.name);
+            });
+        });
+    }).then(function () { return undefined; });
+};
+/**
+ * Logs all available cookies with metadata and values.
+ *
+ * Intended for interactive debugging when full cookie visibility is needed.
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when logging is complete.
+ */
+var logCookies = function () {
+    return cy.getCookies().then(function (cookies) {
+        if (cookies.length === 0) {
+            cy.log('No cookies found');
+            return;
+        }
+        cy.step("COOKIES REPORT - Total: ".concat(cookies.length), function () {
+            var sessionCookies = cookies.filter(function (c) { return !c.expiry; });
+            var persistentCookies = cookies.filter(function (c) { return Boolean(c.expiry); });
+            cy.log("Session Cookies: ".concat(sessionCookies.length));
+            cy.log("Persistent Cookies: ".concat(persistentCookies.length));
+            cookies.forEach(function (cookie) {
+                printCookieValues(cookie);
+            });
+        });
+    }).then(function () { return undefined; });
+};
+/**
+ * Logs a specific cookie by name in a detailed format.
+ *
+ * Intended for interactive debugging when full cookie visibility is needed.
+ * @param {string} cookieName Name of the cookie to read and print.
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when logging is complete.
+ */
+var logCookie = function (cookieName) {
+    return cy.getCookie(cookieName).then(function (cookie) {
+        if (!cookie) {
+            cy.log("Cookie \"".concat(cookieName, "\" not found"));
+            return;
+        }
+        printCookieValues(cookie);
+    }).then(function () { return undefined; });
+};
+/**
+ * Clears Session cookies
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when logging is complete.
+ */
+var clearSessionCookies = function () {
+    return clearCookiesByType('session').then(function () { return undefined; });
+};
+/**
+ * Clears Persistent cookies
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when logging is complete.
+ */
+var clearPersistentCookies = function () {
+    return clearCookiesByType('persistent').then(function () { return undefined; });
+};
+/**
+ * Simulates a browser close by clearing session storage and cookies.
+ * Persistent cookies are kept intentionally.
+ * @returns {void}
+ */
+var simulateClose = function () {
+    cy.log('Simulating browser close...');
+    // Clear session storage
+    cy.clearAllSessionStorage();
+    // Clear session cookies only
+    clearSessionCookies();
+    cy.log('Browser close simulated (session storage and cookies are cleared)');
+};
+/**
+ * Resets browser state by clearing all storages and all cookies.
+ * Use this when a test needs a fully clean client-side state.
+ * @returns {void}
+ */
+var resetState = function () {
+    cy.log('Reset browser state...');
+    // Clear all storage
+    cy.clearAllLocalStorage();
+    cy.clearAllSessionStorage();
+    // Clear all cookies
+    cy.clearAllCookies();
+    cy.log('Browser reset is done (all storages and cookies cleared)');
+};
+/**
+ * Logs all sessionStorage entries grouped by origin.
+ * Intended for interactive debugging and logs full values.
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when logging is complete.
+ */
+var logSessionStorage = function () {
+    return cy.getAllSessionStorage().then(function (session) {
+        cy.log("sessionStorage: ".concat(JSON.stringify(session)));
+    }).then(function () { return undefined; });
+};
+/**
+ * Logs all localStorage entries grouped by origin.
+ * Intended for interactive debugging and logs full values.
+ * @returns {Cypress.Chainable<void>} Cypress chainable resolved when logging is complete.
+ */
+var logLocalStorage = function () {
+    return cy.getAllLocalStorage().then(function (local) {
+        cy.log("localStorage: ".concat(JSON.stringify(local)));
+    }).then(function () { return undefined; });
+};
+exports.BrowserHelper = {
+    logCookies: logCookies,
+    logCookie: logCookie,
+    logSessionStorage: logSessionStorage,
+    logLocalStorage: logLocalStorage,
+    clearSessionCookies: clearSessionCookies,
+    clearPersistentCookies: clearPersistentCookies,
+    simulateClose: simulateClose,
+    resetState: resetState
+};

package/dist/support/index.d.ts

@@ -5,3 +5,6 @@ export * from './logout';
 export * from './repeatUntil';
 export * from './testStep';
 export * from './jsErrorsLogger';
+export * from './jfaker';
+export * from './browserHelper';
+export * from './modSince';

package/dist/support/index.js

@@ -21,3 +21,6 @@ __exportStar(require("./logout"), exports);
 __exportStar(require("./repeatUntil"), exports);
 __exportStar(require("./testStep"), exports);
 __exportStar(require("./jsErrorsLogger"), exports);
+__exportStar(require("./jfaker"), exports);
+__exportStar(require("./browserHelper"), exports);
+__exportStar(require("./modSince"), exports);

package/dist/support/jfaker.d.ts

@@ -0,0 +1,60 @@
+/**
+ * jfaker - A flexible data generator for Cypress tests, supporting both faker.js generated data and custom injection payloads.
+ *
+ * This module provides a unified interface to generate either faker data or custom injection payloads based on the method called and global settings.
+ * It uses a dynamic Proxy to handle method calls and determine whether to generate faker data or injection data.
+ *
+ * IMPORTANT:
+ * When using the generated strings from jfaker in Cypress commands like `.type()`, make sure to:
+ * use `parseSpecialCharSequences: false`, e.g.: `<input>.type(text, {parseSpecialCharSequences: false})`
+ * to prevent Cypress from interpreting special characters in the generated strings (e.g., {, }, [, ], etc.) as commands,
+ * which is especially important for injection payloads that may contain such characters.
+ */
+/**
+ * Interface to Fake Data generator (using DeepApi proxy to handle dynamic method calls)
+ * @param {Record<string, unknown>} options Options for data generation (length for injections, faker options, safe flag), \
+ *                                          e.g.: `{length: 100}` for injections to specify desired length of the generated string, \
+ *                                          or `{provider: 'example.com'}` for faker to pass options to the faker method. \
+ *                                          For faker data generation, an additional option `safe` can be set to `true` \
+ *                                          to force faker generation regardless of global type settings \
+ *                                          (useful for specific cases where faker data is needed even when global type is set to injection).
+ * @remarks
+ * Available injection methods:
+ * - `.xss()` - Generate XSS injection payloads
+ * - `.sql()` - Generate SQL injection payloads
+ * - `.bash()` - Generate Bash injection payloads
+ * - `.chars()` - Generate random special characters
+ * - `.htmlentities()` - Generate HTML entities
+ * - `.numbers()` - Generate random numbers entities and edge cases
+ * - or any faker.js method can also be called (e.g., `person.firstName()`, `internet.email()`)
+ *
+ * @returns {string} Generated data string based on the method called and options provided
+ *
+ * @see https://fakerjs.dev/api/ for available faker methods and options
+ * @example
+ * ```typescript
+ *
+ * // Generate faker data with entity.
+ * const name = jfaker.person.firstName();
+ *
+ * // Entity will always be generated using faker (safe: true)
+ * const name = jfaker.person.firstName({safe: true});
+ *
+ * // Generate faker data with options.
+ * const email = jfaker.internet.email({provider: 'example.com'});
+ *
+ * // Generate injection payloads (random between min and max items joined into a single string)..
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss();
+ *
+ * // Generate injection payloads with specific length.
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss({length: 100});
+ *
+ * // Use all SQL injections.
+ * // Entity will always be generated using 'sql'.
+ * const allSql = jfaker.sql({length: -1});
+ * ```
+ */
+declare const jfaker: any;
+export { jfaker };

package/dist/support/jfaker.js

@@ -0,0 +1,241 @@
+"use strict";
+/* eslint-disable no-else-return */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/**
+ * jfaker - A flexible data generator for Cypress tests, supporting both faker.js generated data and custom injection payloads.
+ *
+ * This module provides a unified interface to generate either faker data or custom injection payloads based on the method called and global settings.
+ * It uses a dynamic Proxy to handle method calls and determine whether to generate faker data or injection data.
+ *
+ * IMPORTANT:
+ * When using the generated strings from jfaker in Cypress commands like `.type()`, make sure to:
+ * use `parseSpecialCharSequences: false`, e.g.: `<input>.type(text, {parseSpecialCharSequences: false})`
+ * to prevent Cypress from interpreting special characters in the generated strings (e.g., {, }, [, ], etc.) as commands,
+ * which is especially important for injection payloads that may contain such characters.
+ */
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.jfaker = void 0;
+var faker_1 = require("@faker-js/faker");
+// Import injection data from corresponding files in injections-ts directory
+var xss_data_1 = require("../injections/xss-data");
+var sql_data_1 = require("../injections/sql-data");
+var bash_data_1 = require("../injections/bash-data");
+var chars_data_1 = require("../injections/chars-data");
+var htmlentities_data_1 = require("../injections/htmlentities-data");
+var numbers_data_1 = require("../injections/numbers-data");
+var injectionData = {
+    xss: xss_data_1.xssData,
+    sql: sql_data_1.sqlData,
+    bash: bash_data_1.bashData,
+    chars: chars_data_1.charsData,
+    htmlentities: htmlentities_data_1.htmlentitiesData,
+    numbers: numbers_data_1.numbersData
+};
+// Environment variable key for storing injection type in Cypress env
+// Can be set either using corresponding FakeData method or as an env var from CI/CD pipeline
+var ENV_INJECTIONS_TYPE = 'JAHIA_CYPRESS_INJECTION_TYPE';
+// Default range for random length of injection payloads; used when length is undefined
+// Random items within the range will be picked and joined into a single string
+var injectionsDefaultLength = { min: 2, max: 5 };
+/**
+ * Store FakeData type in Cypress env for persistence across specs
+ * @param {string} type FakeData type: 'faker' | 'xss' | 'sql' | 'bash' | 'chars' | 'htmlentities' | 'numbers'
+ * @returns void
+ */
+function setDataType(type) {
+    Cypress.env(ENV_INJECTIONS_TYPE, type);
+}
+/**
+ * Retrieve FakeData type from Cypress env (defaults to 'faker' if not set)
+ * @returns {string} Type of FakeData to use
+ */
+function getDataType() {
+    return Cypress.env(ENV_INJECTIONS_TYPE) || 'faker';
+}
+/**
+ * Generate injection data based on the specified type and length
+ * @param {string} type Injection type to generate (xss, sql, bash, chars, htmlentities, numbers)
+ * @param {number} length Length of the generated injection (optional)
+ * @returns {string} Generated injection string
+ */
+function generateInjection(type, length) {
+    var result = [];
+    // Type is specified and exists in injectionData, use it to generate data
+    var data = injectionData[type];
+    if (!data || data.length === 0) {
+        throw new Error("[jFaker EXCEPTION] No injection data found for type: ".concat(type, "."));
+    }
+    if (length === -1) {
+        // If length is -1, use all available items from the data array
+        result = data;
+    }
+    else if (length && length > 0) {
+        // If length is specified and greater than 0, pick random items until the combined length meets the requirement
+        while (result.join('').length < length) {
+            var randomIndex = Math.floor(Math.random() * data.length);
+            result.push(data[randomIndex]);
+        }
+        // Trim the combined string to the specified length
+        var combined = result.join('');
+        result = [combined.substring(0, length)];
+    }
+    else {
+        // If length is not specified, pick a random number of items within the default range
+        var itemsCount = Math.floor(Math.random() * injectionsDefaultLength.max) + injectionsDefaultLength.min;
+        for (var i = 0; i < itemsCount; i++) {
+            var randomIndex = Math.floor(Math.random() * data.length);
+            result.push(data[randomIndex]);
+        }
+    }
+    return result.join('');
+}
+/**
+ * Generate faker data based on the specified entity and options
+ * @param {string} entity Faker entity to generate (e.g., "person.firstName")
+ * @param {Record<string, unknown> | string | number | boolean | undefined} options Options to pass to the faker method (optional)
+ * @returns {string} Generated faker string
+ */
+function generateFake(entity, options) {
+    var generator;
+    var result = [];
+    var parts = entity.split('.');
+    var fakerMethod = faker_1.faker;
+    for (var _i = 0, parts_1 = parts; _i < parts_1.length; _i++) {
+        var part = parts_1[_i];
+        if (fakerMethod && typeof fakerMethod[part] !== 'undefined') {
+            fakerMethod = fakerMethod[part];
+        }
+        else {
+            throw new Error("[jFaker EXCEPTION] Invalid faker method: ".concat(entity));
+        }
+    }
+    if (typeof fakerMethod === 'function') {
+        generator = (options && Object.keys(options).length > 0) ? function () { return fakerMethod(options); } : function () { return fakerMethod(); };
+    }
+    else {
+        throw new Error("[jFaker EXCEPTION] ".concat(entity, " is not a function"));
+    }
+    result.push(generator());
+    return result.join('');
+}
+/**
+ * Escape string to prevent issues when used in contexts like HTML or JavaScript
+ * @param str
+ */
+function escape(str) {
+    return JSON.stringify(str).slice(1, -1);
+}
+/**
+ * Simple DeepApi class to create a dynamic nested Proxy for generating fake data using faker or injection data based on method calls
+ */
+var DeepApi = /** @class */ (function () {
+    function DeepApi(handler) {
+        this.handler = handler;
+        return this.createProxy([]);
+    }
+    DeepApi.prototype.createProxy = function (path) {
+        var _this = this;
+        return new Proxy(
+        // The target is a function, so the proxy itself is callable
+        function () { }, {
+            // Handle property access - go deeper
+            get: function (target, prop) {
+                return _this.createProxy(__spreadArray(__spreadArray([], path, true), [String(prop)], false));
+            },
+            // Handle function call - execute handler
+            apply: function (target, thisArg, args) {
+                return _this.handler(path.join('.'), args);
+            }
+        });
+    };
+    return DeepApi;
+}());
+/**
+ * Interface to Fake Data generator (using DeepApi proxy to handle dynamic method calls)
+ * @param {Record<string, unknown>} options Options for data generation (length for injections, faker options, safe flag), \
+ *                                          e.g.: `{length: 100}` for injections to specify desired length of the generated string, \
+ *                                          or `{provider: 'example.com'}` for faker to pass options to the faker method. \
+ *                                          For faker data generation, an additional option `safe` can be set to `true` \
+ *                                          to force faker generation regardless of global type settings \
+ *                                          (useful for specific cases where faker data is needed even when global type is set to injection).
+ * @remarks
+ * Available injection methods:
+ * - `.xss()` - Generate XSS injection payloads
+ * - `.sql()` - Generate SQL injection payloads
+ * - `.bash()` - Generate Bash injection payloads
+ * - `.chars()` - Generate random special characters
+ * - `.htmlentities()` - Generate HTML entities
+ * - `.numbers()` - Generate random numbers entities and edge cases
+ * - or any faker.js method can also be called (e.g., `person.firstName()`, `internet.email()`)
+ *
+ * @returns {string} Generated data string based on the method called and options provided
+ *
+ * @see https://fakerjs.dev/api/ for available faker methods and options
+ * @example
+ * ```typescript
+ *
+ * // Generate faker data with entity.
+ * const name = jfaker.person.firstName();
+ *
+ * // Entity will always be generated using faker (safe: true)
+ * const name = jfaker.person.firstName({safe: true});
+ *
+ * // Generate faker data with options.
+ * const email = jfaker.internet.email({provider: 'example.com'});
+ *
+ * // Generate injection payloads (random between min and max items joined into a single string)..
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss();
+ *
+ * // Generate injection payloads with specific length.
+ * // Entity will always be generated using 'xss'.
+ * const xssName = jfaker.xss({length: 100});
+ *
+ * // Use all SQL injections.
+ * // Entity will always be generated using 'sql'.
+ * const allSql = jfaker.sql({length: -1});
+ * ```
+ */
+var jfaker = new DeepApi(function (path, args) {
+    var _a, _b, _c, _d;
+    // Handle non-faker methods first (escape, setFakeDataType, getFakeDataType)
+    switch (path) {
+        case 'escape':
+            return escape(args[0]);
+        case 'setDataType':
+            return setDataType(args[0]);
+        case 'getDataType':
+            return getDataType();
+        case Object.prototype.hasOwnProperty.call(injectionData, path) ? path : 'default':
+            // If the path corresponds to a valid injection type, generate data using that type,
+            // or fallback to default case which treats the path as a faker entity.
+            // Keep (safe === true) logic in "default" case for a readability.
+            return generateInjection(path, (_a = args[0]) === null || _a === void 0 ? void 0 : _a.length);
+        default: {
+            // For faker data generation, check if the generation should be persistent based on global settings and options passed.
+            var safe = ((_b = args[0]) === null || _b === void 0 ? void 0 : _b.safe) === true;
+            // Delete the 'safe' property from options to avoid passing it to faker methods
+            (_c = args[0]) === null || _c === void 0 ? true : delete _c.safe;
+            // Here path represents a faker entity.
+            // Check desired data type and 'safe' option to determine whether to generate faker data or injection data.
+            // If global type is set to injection (to override faker data) but safe is explicitly set to true in options -
+            // generate faker data for this specific call regardless of global settings.
+            if (getDataType() === 'faker' || safe) {
+                return generateFake(path, args[0]);
+            }
+            else {
+                return generateInjection(getDataType(), (_d = args[0]) === null || _d === void 0 ? void 0 : _d.length);
+            }
+        }
+    }
+});
+exports.jfaker = jfaker;