@playq/core 0.2.77

package/dist/helper/util/stepHelpers.d.ts

@@ -0,0 +1,2 @@
+export declare function attachResolvedStep(thisArg: any, template: string): Promise<void>;
+export declare function defineLoggedStep(pattern: string, implementation: Function): (this: any, ...args: any[]) => any;

package/dist/helper/util/stepHelpers.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attachResolvedStep = attachResolvedStep;
+exports.defineLoggedStep = defineLoggedStep;
+const global_1 = require("../../global");
+async function attachResolvedStep(thisArg, template) {
+    const resolved = global_1.vars.replaceVariables(template);
+    await thisArg.attach(`🧾 Resolved Step: ${resolved}`, 'text/plain');
+}
+function defineLoggedStep(pattern, implementation) {
+    return function (...args) {
+        const stepText = pattern.replace(/\{param\}/g, (_match, i) => `"${args[i]}"`);
+        attachResolvedStep.call(this, stepText);
+        return implementation.apply(this, args);
+    };
+}

package/dist/helper/util/test-data/dataLoader.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Reads test data from .json, .xlsx, or .csv
+ *
+ * @param file - Filename WITH extension, e.g., "login.json", "login.xlsx", "login.csv"
+ * @param sheetName - (optional) Sheet name for Excel files
+ */
+export declare function getTestData(file: string, sheetName?: string): any[];

package/dist/helper/util/test-data/dataLoader.js

@@ -0,0 +1,145 @@
+"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.getTestData = getTestData;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const XLSX = __importStar(require("@e965/xlsx"));
+/**
+ * Reads test data from .json, .xlsx, or .csv
+ *
+ * @param file - Filename WITH extension, e.g., "login.json", "login.xlsx", "login.csv"
+ * @param sheetName - (optional) Sheet name for Excel files
+ */
+function getTestData(file, sheetName) {
+    // Attempt to locate the project's test-data directory robustly.
+    // Strategy:
+    // 1. Starting at process.cwd(), walk upward looking for a folder that
+    //    contains a package.json (project root) and a test-data subfolder.
+    // 2. If found, use <foundRoot>/test-data/<file>.
+    // 3. Otherwise, fallback to process.cwd()/test-data/<file> and report a clear ENOENT.
+    function findProjectRootWithTestData(startDir) {
+        let current = path_1.default.resolve(startDir);
+        const root = path_1.default.parse(current).root;
+        while (true) {
+            const pkg = path_1.default.join(current, 'package.json');
+            const td = path_1.default.join(current, 'test-data');
+            if (fs_1.default.existsSync(pkg) && fs_1.default.existsSync(td) && fs_1.default.statSync(td).isDirectory()) {
+                return td;
+            }
+            if (current === root)
+                break;
+            current = path_1.default.dirname(current);
+        }
+        return null;
+    }
+    const start = process.cwd();
+    const projectTestData = findProjectRootWithTestData(start);
+    // If not found by walking upward, also check immediate subdirectories of the
+    // current directory. This handles the common developer workspace layout where
+    // the workspace root contains multiple project folders (e.g. PlayQ_PROJECT).
+    let basePath;
+    if (projectTestData) {
+        basePath = projectTestData;
+    }
+    else {
+        // scan one-level children for a project that contains package.json and test-data
+        const children = fs_1.default.readdirSync(start, { withFileTypes: true });
+        let found = null;
+        for (const child of children) {
+            if (!child.isDirectory())
+                continue;
+            const candidate = path_1.default.join(start, child.name);
+            const pkg = path_1.default.join(candidate, 'package.json');
+            const td = path_1.default.join(candidate, 'test-data');
+            try {
+                if (fs_1.default.existsSync(pkg) && fs_1.default.existsSync(td) && fs_1.default.statSync(td).isDirectory()) {
+                    found = td;
+                    break;
+                }
+            }
+            catch (e) {
+                // ignore permission or stat errors on non-readable dirs
+            }
+        }
+        basePath = found || path_1.default.resolve(process.cwd(), 'test-data');
+    }
+    const filePath = path_1.default.join(basePath, file);
+    if (!fs_1.default.existsSync(filePath)) {
+        throw new Error(`ENOENT: test data file not found: ${filePath}. Searched from ${start}`);
+    }
+    const ext = path_1.default.extname(file).toLowerCase();
+    switch (ext) {
+        case '.json': {
+            const raw = fs_1.default.readFileSync(filePath, 'utf-8');
+            return JSON.parse(raw);
+        }
+        case '.xlsx': {
+            const workbook = XLSX.readFile(filePath);
+            const sheet = workbook.Sheets[sheetName || workbook.SheetNames[0]];
+            const rows = XLSX.utils.sheet_to_json(sheet, { raw: false });
+            // Try to parse booleans/numbers
+            return rows.map(row => {
+                const parsedRow = {};
+                for (const key in row) {
+                    const value = row[key];
+                    if (value === 'true' || value === 'false') {
+                        parsedRow[key] = value === 'true';
+                    }
+                    else if (!isNaN(value) && value.trim() !== '') {
+                        parsedRow[key] = Number(value);
+                    }
+                    else {
+                        parsedRow[key] = value;
+                    }
+                }
+                return parsedRow;
+            });
+            // const workbook = XLSX.readFile(filePath);
+            // const sheet = workbook.Sheets[sheetName || workbook.SheetNames[0]];
+            // return XLSX.utils.sheet_to_json(sheet);
+        }
+        case '.csv': {
+            const fileData = fs_1.default.readFileSync(filePath, 'utf-8');
+            const worksheet = XLSX.read(fileData, { type: 'string' }).Sheets['Sheet1'];
+            return XLSX.utils.sheet_to_json(worksheet);
+        }
+        default:
+            throw new Error(`Unsupported file extension: ${ext}`);
+    }
+}

package/dist/helper/util/test-data/dataTest.d.ts

@@ -0,0 +1,10 @@
+export declare function dataTest<T extends Record<string, any>>(label: string, dataSource: T[] | {
+    file: string;
+    filter?: string;
+    sheet?: string;
+    testType?: string;
+    suffix?: string;
+}, callback: (args: {
+    row: T;
+    page?: any;
+}) => Promise<void>): void;

package/dist/helper/util/test-data/dataTest.js

@@ -0,0 +1,216 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataTest = dataTest;
+// dataTest.ts
+const test_1 = require("@playwright/test");
+const dataLoader_1 = require("./dataLoader");
+const vars = __importStar(require("../../bundle/vars"));
+const customFaker_1 = require("../../faker/customFaker");
+function dataTest(label, dataSource, callback) {
+    let dataset = [];
+    const { testType = "UI", suffix = "" } = typeof dataSource === "object" && !Array.isArray(dataSource) ? dataSource : {};
+    if (Array.isArray(dataSource)) {
+        dataset = applyRowReplacements(dataSource);
+    }
+    else {
+        let { file, filter, sheet } = dataSource;
+        file = vars.replaceVariables(file);
+        sheet = (sheet) ? vars.replaceVariables(sheet) : undefined;
+        filter = vars.replaceVariables(filter);
+        const raw = (0, dataLoader_1.getTestData)(file, sheet);
+        // Expand faker/variable placeholders within each row before filtering/scheduling tests
+        const preprocessed = applyRowReplacements(raw);
+        dataset = filter
+            ? preprocessed.filter(row => {
+                try {
+                    // Create a scoped function where row keys are destructured
+                    const fn = new Function("row", `
+              const { ${Object.keys(row).join(", ")} } = row;
+              return ${filter};
+            `);
+                    return fn(row);
+                }
+                catch (err) {
+                    console.warn(`⚠️ Filter failed: ${filter}`, err);
+                    return false;
+                }
+            })
+            : preprocessed;
+    }
+    test_1.test.describe(label, () => {
+        dataset.forEach((row, index) => {
+            vars.setValue('playq.iteration.count', `${index + 1}`);
+            const name = `${label} ${vars.replaceVariables(replaceIterationDataVars(suffix, row))} [-${index + 1}-]`;
+            if (testType.toUpperCase() === "API") {
+                (0, test_1.test)(name, async () => {
+                    test_1.test.info().annotations.push({ type: "tag", description: label });
+                    await callback({ row });
+                });
+            }
+            else {
+                (0, test_1.test)(name, async ({ page }) => {
+                    test_1.test.info().annotations.push({ type: "tag", description: label });
+                    await callback({ row, page });
+                });
+            }
+        });
+    });
+}
+// ----------------- helpers -----------------
+function applyRowReplacements(rows) {
+    return rows.map((row) => {
+        const out = { ...row };
+        for (const k of Object.keys(out)) {
+            const v = out[k];
+            if (typeof v === 'string') {
+                // First, evaluate any faker placeholders
+                const withFaker = replaceFakerPlaceholders(v);
+                // Then, apply generic variable replacements
+                out[k] = typeof withFaker === 'string' ? vars.replaceVariables(withFaker) : withFaker;
+            }
+        }
+        return out;
+    });
+}
+function replaceFakerPlaceholders(input) {
+    const trimmed = input.trim();
+    // Entire value is wrapped: #{faker....}
+    const wrapped = trimmed.match(/^#\{(faker(?:\.[a-zA-Z0-9_]+)+\((.*)\))\}$/);
+    if (wrapped) {
+        return evalFakerCall(wrapped[1]);
+    }
+    // Entire value is a faker call: faker....
+    const full = trimmed.match(/^faker((?:\.[a-zA-Z0-9_]+)+)\((.*)\)$/);
+    if (full) {
+        return evalFakerFromParts(full[1], full[2]);
+    }
+    // Embedded placeholders inside a larger string
+    return input.replace(/#\{faker((?:\.[a-zA-Z0-9_]+)+)\((.*?)\)\}/g, (_m, pathPart, argsRaw) => {
+        try {
+            const val = evalFakerFromParts(pathPart, argsRaw);
+            return String(val);
+        }
+        catch (e) {
+            console.warn(`⚠️ Failed to evaluate faker placeholder: #{faker${pathPart}(${argsRaw})}`, e);
+            return _m;
+        }
+    });
+}
+function evalFakerCall(expr) {
+    // expr like: faker.xxx.yyy(args)
+    const m = expr.match(/^faker((?:\.[a-zA-Z0-9_]+)+)\((.*)\)$/);
+    if (!m)
+        throw new Error(`Invalid faker expression: ${expr}`);
+    return evalFakerFromParts(m[1], m[2]);
+}
+function evalFakerFromParts(pathPart, argsRaw) {
+    const path = pathPart.replace(/^\./, '');
+    const parts = path.split('.');
+    // Prefer global faker set up by core; fall back to imported one
+    let ctx = globalThis.faker || customFaker_1.faker;
+    let fn = ctx;
+    for (const p of parts) {
+        fn = fn === null || fn === void 0 ? void 0 : fn[p];
+    }
+    if (typeof fn !== 'function')
+        throw new Error(`Resolved faker path is not a function: faker.${path}`);
+    const args = parseFakerArgs(argsRaw);
+    return fn(...args);
+}
+function parseFakerArgs(argsRaw) {
+    const trimmed = (argsRaw || '').trim();
+    if (!trimmed)
+        return [];
+    if (trimmed.startsWith('{')) {
+        // Object literal; normalize to JSON
+        const normalized = trimmed
+            .replace(/([{,]\s*)([a-zA-Z0-9_]+)\s*:/g, '$1"$2":')
+            .replace(/'/g, '"');
+        try {
+            return [JSON.parse(normalized)];
+        }
+        catch (e) {
+            throw new Error(`Failed to parse faker argument object: ${argsRaw}`);
+        }
+    }
+    // Simple comma-separated values (strip surrounding quotes)
+    return splitArgs(trimmed).map(a => a.trim().replace(/^(["'])(.*)\1$/, '$2'));
+}
+function splitArgs(s) {
+    const out = [];
+    let buf = '';
+    let depth = 0;
+    let quote = null;
+    for (let i = 0; i < s.length; i++) {
+        const ch = s[i];
+        if (quote) {
+            if (ch === quote && s[i - 1] !== '\\') {
+                quote = null;
+            }
+            buf += ch;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            quote = ch;
+            buf += ch;
+            continue;
+        }
+        if (ch === '{' || ch === '[' || ch === '(')
+            depth++;
+        if (ch === '}' || ch === ']' || ch === ')')
+            depth--;
+        if (ch === ',' && depth === 0) {
+            out.push(buf);
+            buf = '';
+            continue;
+        }
+        buf += ch;
+    }
+    if (buf)
+        out.push(buf);
+    return out;
+}
+/**
+ * Replaces all #{playq.iteration.data.KEY} in the input string with the value from the row object.
+ * @param input The string containing placeholders.
+ * @param row The row object with data.
+ * @returns The string with placeholders replaced.
+ */
+function replaceIterationDataVars(input, row) {
+    return input.replace(/#\{playq\.iteration\.data\.([a-zA-Z0-9_]+)\}/g, (_, key) => {
+        return row[key] !== undefined ? String(row[key]) : '';
+    });
+}

package/dist/helper/util/totp/totpHelper.d.ts

@@ -0,0 +1,38 @@
+export declare class TOTPHelper {
+    private secret;
+    private serviceName;
+    private accountName;
+    constructor(secret?: string, serviceName?: string, accountName?: string);
+    /**
+     * Generate a new TOTP secret
+     */
+    generateSecret(): string;
+    /**
+     * Generate current TOTP token
+     */
+    generateToken(): string;
+    /**
+     * Verify TOTP token
+     */
+    verifyToken(token: string): boolean;
+    /**
+     * Get OTP Auth URL for QR code generation
+     */
+    getOtpAuthUrl(): string;
+    /**
+     * Generate QR code for authenticator app setup
+     */
+    generateQRCode(): Promise<string>;
+    /**
+     * Get the secret (for environment variable storage)
+     */
+    getSecret(): string;
+    /**
+     * Check if current time is near token expiry
+     */
+    getTimeRemaining(): number;
+    /**
+     * Generate token with retry logic for time window
+     */
+    generateTokenWithRetry(maxRetries?: number): Promise<string>;
+}

package/dist/helper/util/totp/totpHelper.js

@@ -0,0 +1,117 @@
+"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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOTPHelper = void 0;
+const otplib_1 = require("otplib");
+const QRCode = __importStar(require("qrcode"));
+class TOTPHelper {
+    constructor(secret, serviceName = 'PlayQ', accountName = 'automation') {
+        this.secret = secret || this.generateSecret();
+        this.serviceName = serviceName;
+        this.accountName = accountName;
+        // Configure otplib options
+        otplib_1.authenticator.options = {
+            window: 2, // Allow 2 time steps tolerance
+            step: 30 // 30-second time step
+        };
+    }
+    /**
+     * Generate a new TOTP secret
+     */
+    generateSecret() {
+        return otplib_1.authenticator.generateSecret();
+    }
+    /**
+     * Generate current TOTP token
+     */
+    generateToken() {
+        return otplib_1.authenticator.generate(this.secret);
+    }
+    /**
+     * Verify TOTP token
+     */
+    verifyToken(token) {
+        return otplib_1.authenticator.verify({
+            token,
+            secret: this.secret
+        });
+    }
+    /**
+     * Get OTP Auth URL for QR code generation
+     */
+    getOtpAuthUrl() {
+        return otplib_1.authenticator.keyuri(this.accountName, this.serviceName, this.secret);
+    }
+    /**
+     * Generate QR code for authenticator app setup
+     */
+    async generateQRCode() {
+        const otpAuthUrl = this.getOtpAuthUrl();
+        return await QRCode.toDataURL(otpAuthUrl);
+    }
+    /**
+     * Get the secret (for environment variable storage)
+     */
+    getSecret() {
+        return this.secret;
+    }
+    /**
+     * Check if current time is near token expiry
+     */
+    getTimeRemaining() {
+        const epoch = Math.round(Date.now() / 1000.0);
+        const timeStep = 30;
+        return timeStep - (epoch % timeStep);
+    }
+    /**
+     * Generate token with retry logic for time window
+     */
+    async generateTokenWithRetry(maxRetries = 3) {
+        let attempts = 0;
+        while (attempts < maxRetries) {
+            const timeRemaining = this.getTimeRemaining();
+            // If token expires soon, wait for new window
+            if (timeRemaining < 5) {
+                console.log(`Token expires in ${timeRemaining}s, waiting for new window...`);
+                await new Promise(resolve => setTimeout(resolve, (timeRemaining + 1) * 1000));
+            }
+            const token = this.generateToken();
+            console.log(`Generated TOTP token: ${token.substring(0, 3)}*** (${this.getTimeRemaining()}s remaining)`);
+            return token;
+        }
+        throw new Error('Failed to generate TOTP token after retries');
+    }
+}
+exports.TOTPHelper = TOTPHelper;

package/dist/helper/util/utilities/cryptoUtil.d.ts

@@ -0,0 +1,2 @@
+export declare function encrypt(plaintext: string): string;
+export declare function decrypt(data: string): string;

package/dist/helper/util/utilities/cryptoUtil.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encrypt = encrypt;
+exports.decrypt = decrypt;
+// src/utils/cryptoUtil.ts
+const crypto_1 = __importDefault(require("crypto"));
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+const algorithm = 'aes-256-gcm';
+const secretKey = crypto_1.default.scryptSync(process.env.PLAYQ_SECRET_KEY || '_DEFAULT_SECRET_32_CHARACTERS_!_', 'salt', 32);
+const ivLength = 12; // Recommended IV size for GCM
+function encrypt(plaintext) {
+    const iv = crypto_1.default.randomBytes(ivLength);
+    const cipher = crypto_1.default.createCipheriv(algorithm, secretKey, iv);
+    const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+    const authTag = cipher.getAuthTag();
+    const combined = Buffer.concat([iv, authTag, encrypted]);
+    return combined.toString('base64').replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
+}
+function decrypt(data) {
+    const combined = Buffer.from(data.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+    const iv = combined.subarray(0, ivLength);
+    const authTag = combined.subarray(ivLength, ivLength + 16);
+    const encrypted = combined.subarray(ivLength + 16);
+    const decipher = crypto_1.default.createDecipheriv(algorithm, secretKey, iv);
+    decipher.setAuthTag(authTag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString('utf8');
+}
+// const algorithm = 'aes-256-cbc';
+// const secretKey = process.env.CRYPTO_SECRET_KEY || '_DEFAULT_SECRET_32_CHARACTERS_!_';
+// const ivLength = 16; // AES block size
+// // --- Encrypt ---
+// export function encrypt(text: string): string {
+//   const iv = crypto.randomBytes(ivLength);
+//   const cipher = crypto.createCipheriv(algorithm, Buffer.from(secretKey, 'utf-8'), iv);
+//   let encrypted = cipher.update(text, 'utf8', 'hex');
+//   encrypted += cipher.final('hex');
+//   return iv.toString('hex') + ':' + encrypted;
+// }
+// // --- Decrypt ---
+// export function decrypt(encryptedText: string): string {
+//   const [ivHex, encrypted] = encryptedText.split(':');
+//   if (!ivHex || !encrypted) throw new Error('Invalid encrypted text format.');
+//   const iv = Buffer.from(ivHex, 'hex');
+//   const decipher = crypto.createDecipheriv(algorithm, Buffer.from(secretKey, 'utf-8'), iv);
+//   let decrypted = decipher.update(encrypted, 'hex', 'utf8');
+//   decrypted += decipher.final('utf8');
+//   return decrypted;
+// }

package/dist/helper/util/utilities/schemaGeneratorUtil.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};