simple-playwright-framework 0.0.2

package/dist/fixtures/auth.fixture.d.ts

@@ -0,0 +1,2 @@
+import { AuthProvider } from "../types/auth";
+export declare const basicAuthProvider: AuthProvider;

package/dist/fixtures/auth.fixture.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.basicAuthProvider = void 0;
+// Example provider implementation
+exports.basicAuthProvider = {
+    async login(page) {
+        // login steps...
+    }
+};

package/dist/fixtures/data.fixture.d.ts

@@ -0,0 +1,5 @@
+import { TestInfo } from "@playwright/test";
+import { Scenario } from "../types/scenario";
+export declare const dataFixture: {
+    td: ({}: {}, use: (td: Scenario[] | object) => Promise<void>, testInfo: TestInfo) => Promise<void>;
+};

package/dist/fixtures/data.fixture.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dataFixture = void 0;
+const data_loader_1 = require("../loaders/data.loader");
+exports.dataFixture = {
+    td: async ({}, use, testInfo) => {
+        const envName = process.env.TEST_ENV || "qa";
+        const tag = process.env.SCENARIO_TAG;
+        console.log("I am inside Fixture");
+        let td;
+        try {
+            td = (0, data_loader_1.loadTestData)(testInfo, envName);
+            console.log("Loaded test data:", td, "Type:", Array.isArray(td) ? "array" : typeof td);
+        }
+        catch (err) {
+            console.error(`❌ loadTestData threw for env '${envName}':`, err);
+            throw err;
+        }
+        if (!td || (Array.isArray(td) && td.length === 0)) {
+            throw new Error(`❌ No test data found for ${testInfo.file} in environment '${envName}'`);
+        }
+        // ✅ Only filter if data is an array of scenarios
+        if (Array.isArray(td)) {
+            td = td.filter(sc => !tag || sc.tags?.includes(tag));
+            if (td.length === 0) {
+                throw new Error(`❌ No scenarios found for env="${envName}" with tag="${tag}"`);
+            }
+            console.log(`✅ Loaded ${td.length} scenarios [env=${envName}${tag ? `, tag=${tag}` : ""}]`);
+        }
+        else {
+            console.log("✅ Loaded test data object (no tag filtering applied)");
+        }
+        await use(td);
+    },
+};

package/dist/fixtures/envConfig.fixture.d.ts

@@ -0,0 +1,7 @@
+import { Page } from "@playwright/test";
+import type { EnvConfig } from "../types/env";
+export declare const envConfigFixture: {
+    envConfig: ({ page }: {
+        page: Page;
+    }, use: (config: EnvConfig) => Promise<void>) => Promise<void>;
+};

package/dist/fixtures/envConfig.fixture.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envConfigFixture = void 0;
+const envConfig_loader_1 = require("../loaders/envConfig.loader");
+exports.envConfigFixture = {
+    envConfig: async ({ page }, use) => {
+        const config = (0, envConfig_loader_1.loadConfig)();
+        /*
+        if (config.autoLaunch && config.baseUrl) {
+          console.log(`🌐 Navigating to: ${config.baseUrl}`);
+          await page.goto(config.baseUrl, { waitUntil: "domcontentloaded" });
+          console.log("✅ Navigation complete");
+        }
+        */
+        await use(config);
+    },
+};

package/dist/fixtures/file.fixture.d.ts

@@ -0,0 +1,7 @@
+import { Page } from "@playwright/test";
+import { FileUtils } from "../utils/file-utils";
+export declare const fileFixture: {
+    fileUtils: ({ page }: {
+        page: Page;
+    }, use: (value: FileUtils) => Promise<void>) => Promise<void>;
+};

package/dist/fixtures/file.fixture.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileFixture = void 0;
+const file_utils_1 = require("../utils/file-utils");
+exports.fileFixture = {
+    fileUtils: async ({ page }, use) => {
+        const utils = new file_utils_1.FileUtils(page);
+        await use(utils);
+    },
+};

package/dist/fixtures/index.d.ts

@@ -0,0 +1,10 @@
+import { Page } from "@playwright/test";
+import { Fixtures } from "../types/fixtures";
+export declare const test: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & Fixtures & {
+    authStore: (page: Page, creds: {
+        username: string;
+        password: string;
+    }, providerRegistry: Record<string, any>) => Promise<void>;
+}, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
+export { expect } from "@playwright/test";
+export * from "../loaders/scenario.loader";

package/dist/fixtures/index.js

@@ -0,0 +1,40 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expect = exports.test = void 0;
+const test_1 = require("@playwright/test");
+const envConfig_fixture_1 = require("./envConfig.fixture");
+const data_fixture_1 = require("./data.fixture");
+const testrail_fixture_1 = require("./testrail.fixture");
+const initAuthSession_1 = require("../utils/auth-session/initAuthSession");
+const file_fixture_1 = require("./file.fixture");
+exports.test = test_1.test.extend({
+    ...envConfig_fixture_1.envConfigFixture,
+    ...data_fixture_1.dataFixture,
+    ...testrail_fixture_1.testrailFixture,
+    ...file_fixture_1.fileFixture,
+    authStore: async ({ envConfig }, use) => {
+        await use(async (page, creds, providerRegistry) => {
+            if (!envConfig.authStorage) {
+                throw new Error(`[Framework] authStorage block missing in envConfig for this environment`);
+            }
+            await (0, initAuthSession_1.initAuthSession)(page, envConfig.authStorage, creds, providerRegistry);
+        });
+    },
+});
+var test_2 = require("@playwright/test");
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return test_2.expect; } });
+__exportStar(require("../loaders/scenario.loader"), exports); // ✅ keep scenarioLoader export

package/dist/fixtures/testrail.fixture.d.ts

@@ -0,0 +1,5 @@
+import { TestRailClient } from "../utils/testrail.client";
+import { TestFixture } from "@playwright/test";
+export declare const testrailFixture: {
+    testrail: TestFixture<TestRailClient, {}>;
+};

package/dist/fixtures/testrail.fixture.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testrailFixture = void 0;
+const testrail_client_1 = require("../utils/testrail.client");
+exports.testrailFixture = {
+    testrail: async ({}, use) => {
+        const client = new testrail_client_1.TestRailClient(process.env.TESTRAIL_URL, process.env.TESTRAIL_USER, process.env.TESTRAIL_APIKEY);
+        await use(client);
+    },
+};

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { initAuthSession } from "./utils/auth-session/initAuthSession";
+export { test, expect } from "./fixtures/index";
+export { scenarioLoader } from "./loaders/scenario.loader";
+export { loadConfig } from "./loaders/envConfig.loader";
+export { FileUtils } from "./utils/file-utils";

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtils = exports.loadConfig = exports.scenarioLoader = exports.expect = exports.test = exports.initAuthSession = void 0;
+var initAuthSession_1 = require("./utils/auth-session/initAuthSession");
+Object.defineProperty(exports, "initAuthSession", { enumerable: true, get: function () { return initAuthSession_1.initAuthSession; } });
+var index_1 = require("./fixtures/index");
+Object.defineProperty(exports, "test", { enumerable: true, get: function () { return index_1.test; } });
+Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return index_1.expect; } });
+var scenario_loader_1 = require("./loaders/scenario.loader");
+Object.defineProperty(exports, "scenarioLoader", { enumerable: true, get: function () { return scenario_loader_1.scenarioLoader; } });
+var envConfig_loader_1 = require("./loaders/envConfig.loader");
+Object.defineProperty(exports, "loadConfig", { enumerable: true, get: function () { return envConfig_loader_1.loadConfig; } });
+var file_utils_1 = require("./utils/file-utils");
+Object.defineProperty(exports, "FileUtils", { enumerable: true, get: function () { return file_utils_1.FileUtils; } });

package/dist/loaders/data.loader.d.ts

@@ -0,0 +1,8 @@
+import { TestInfo } from "@playwright/test";
+/**
+ * Loads environment-specific test data for a given test file.
+ * - Resolves JSON file path based on test file location
+ * - Validates existence, non-empty content, and JSON format
+ * - Returns environment-specific slice of data
+ */
+export declare function loadTestData(testInfo: TestInfo, envName: string): any;

package/dist/loaders/data.loader.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadTestData = loadTestData;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/**
+ * Loads environment-specific test data for a given test file.
+ * - Resolves JSON file path based on test file location
+ * - Validates existence, non-empty content, and JSON format
+ * - Returns environment-specific slice of data
+ */
+function loadTestData(testInfo, envName) {
+    const projectRoot = process.cwd();
+    // Derive relative path from tests/ to the current test file
+    const rel = path_1.default.relative(path_1.default.join(projectRoot, "tests"), testInfo.file);
+    // Strip .spec.ts / .test.ts suffix
+    const fileBase = path_1.default.basename(rel)
+        .replace(/\.spec\.ts$/, "")
+        .replace(/\.test\.ts$/, "");
+    const dir = path_1.default.dirname(rel);
+    // Construct data file path
+    const dataPath = path_1.default.join(projectRoot, "data", dir, `${fileBase}.json`);
+    // Validate existence
+    if (!fs_1.default.existsSync(dataPath)) {
+        throw new Error(`\n❌ Test data file not found for test: ${fileBase}\nPath: ${dataPath}`);
+    }
+    // Validate non-empty
+    const raw = fs_1.default.readFileSync(dataPath, "utf-8").trim();
+    if (!raw) {
+        throw new Error(`\n❌ Test data file is empty for test: ${fileBase}\nPath: ${dataPath}`);
+    }
+    // Parse JSON
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`\n❌ Invalid JSON format in test data for: ${fileBase}\nPath: ${dataPath}`);
+    }
+    // Return environment-specific slice
+    if (parsed[envName]) {
+        return parsed[envName];
+    }
+    else {
+        throw new Error(`\n❌ Data is not available for Execution Environment ${envName} in test data for: ${fileBase}\nPath: ${dataPath}`);
+    }
+}

package/dist/loaders/envConfig.loader.d.ts

@@ -0,0 +1,2 @@
+import type { EnvConfig } from "../types/env";
+export declare function loadConfig(): EnvConfig;

package/dist/loaders/envConfig.loader.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadConfig = loadConfig;
+// framework/src/loaders/envConfig.loader.ts
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function loadConfig() {
+    const configPath = path_1.default.join(process.cwd(), "config", "environments.json");
+    if (!fs_1.default.existsSync(configPath)) {
+        throw new Error(`❌ environments.json not found at ${configPath}`);
+    }
+    const raw = fs_1.default.readFileSync(configPath, "utf-8");
+    const allConfig = JSON.parse(raw);
+    const envName = process.env.TEST_ENV || "qa";
+    const defaults = allConfig.defaults || {};
+    const envConfig = allConfig[envName]; // ✅ flat lookup
+    if (!envConfig) {
+        throw new Error(`❌ Environment '${envName}' not defined in environments.json`);
+    }
+    if (!envConfig.baseUrl) {
+        throw new Error(`❌ Environment '${envName}' missing baseUrl`);
+    }
+    return { ...defaults, ...envConfig };
+}

package/dist/loaders/scenario.loader.d.ts

@@ -0,0 +1,2 @@
+import { Scenario } from "../types/scenario";
+export declare function scenarioLoader(testFile: string, env?: string, tag?: string): Scenario[];

package/dist/loaders/scenario.loader.js

@@ -0,0 +1,78 @@
+"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.scenarioLoader = scenarioLoader;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+function scenarioLoader(testFile, env = process.env.TEST_ENV || "qa", tag = process.env.SCENARIO_TAG || "") {
+    // Replace "tests" with "data" and change extension
+    const relPath = testFile.replace("tests", "data").replace(/\.spec\.ts$/, ".json");
+    const scenarioFile = path.resolve(relPath);
+    if (!fs.existsSync(scenarioFile)) {
+        throw new Error(`❌ Scenario file not found: ${scenarioFile}`);
+    }
+    const raw = fs.readFileSync(scenarioFile, "utf-8").trim();
+    if (!raw) {
+        throw new Error(`❌ Scenario file is empty: ${scenarioFile}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        throw new Error(`❌ Invalid JSON format in scenario file: ${scenarioFile}`);
+    }
+    let scenarios;
+    // If top-level is an array, return it directly
+    if (Array.isArray(parsed)) {
+        scenarios = parsed;
+    }
+    // If top-level is an object keyed by env, return the matching array
+    else if (parsed[env] && Array.isArray(parsed[env])) {
+        scenarios = parsed[env];
+    }
+    else {
+        throw new Error(`❌ Scenario file must contain an array or an object with environment key "${env}"`);
+    }
+    // ✅ Strict tag filtering
+    if (tag) {
+        scenarios = scenarios.filter(sc => sc.tags?.includes(tag));
+        if (scenarios.length === 0) {
+            throw new Error(`❌ No scenarios found for env="${env}" with tag="${tag}"`);
+        }
+    }
+    console.log(`✅ Loaded ${scenarios.length} scenarios [env=${env}${tag ? `, tag=${tag}` : ""}]`);
+    return scenarios;
+}

package/dist/logger.d.ts

@@ -0,0 +1 @@
+export declare function log(message: string): void;

package/dist/logger.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.log = log;
+function log(message) {
+    console.log('[Framework] ${message}');
+}

package/dist/types/auth.d.ts

@@ -0,0 +1,9 @@
+import { Page } from "@playwright/test";
+export interface AuthProvider {
+    login(page: Page): Promise<void>;
+}
+export interface AuthStorageConfig {
+    enabled: boolean;
+    validityMinutes: number;
+    provider: string;
+}

package/dist/types/auth.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/env.d.ts

@@ -0,0 +1,12 @@
+import type { AuthStorageConfig } from "./auth";
+export interface EnvConfig {
+    baseUrl: string;
+    apiUrl?: string;
+    db?: {
+        host: string;
+        port: number;
+        user: string;
+        password: string;
+    };
+    authStorage?: AuthStorageConfig;
+}

package/dist/types/env.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/fixtures.d.ts

@@ -0,0 +1,12 @@
+import type { EnvConfig } from "./env";
+import type { TestrailType } from "./testrail";
+import type { FileUtils } from "../utils/file-utils";
+/**
+ * Central fixture contract for Playwright test.extend
+ */
+export type Fixtures = {
+    envConfig: EnvConfig;
+    td: any;
+    testrail: TestrailType;
+    fileUtils: FileUtils;
+};

package/dist/types/fixtures.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/scenario.d.ts

@@ -0,0 +1,5 @@
+export interface Scenario {
+    name: string;
+    [key: string]: any;
+    tags?: string[];
+}

package/dist/types/scenario.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/testrail.d.ts

@@ -0,0 +1,5 @@
+import type { TestRailClient } from "../utils/testrail.client";
+/**
+ * Type alias for TestRail client fixture
+ */
+export type TestrailType = TestRailClient;

package/dist/types/testrail.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils/auth-session/initAuthSession.d.ts

@@ -0,0 +1,9 @@
+import { Page } from "@playwright/test";
+import { AuthProvider, AuthStorageConfig } from "../../types/auth";
+export declare function initAuthSession(page: Page, authStorage: AuthStorageConfig | undefined, creds: {
+    username: string;
+    password: string;
+}, providerRegistry: Record<string, new (creds: {
+    username: string;
+    password: string;
+}) => AuthProvider>): Promise<void>;

package/dist/utils/auth-session/initAuthSession.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initAuthSession = initAuthSession;
+const storagePath_1 = require("./storagePath");
+const validateStore_1 = require("./validateStore");
+async function initAuthSession(page, authStorage, creds, providerRegistry) {
+    if (!authStorage?.enabled) {
+        console.log("[Framework] Auth storage disabled");
+        const ProviderClass = providerRegistry[authStorage?.provider ?? "OrangeHRMLogin"];
+        const authProvider = new ProviderClass(creds);
+        await authProvider.login(page);
+        return;
+    }
+    const { validityMinutes, provider } = authStorage;
+    const envName = process.env.TEST_ENV || "default";
+    const storagePath = (0, storagePath_1.getStoragePath)(provider, envName, creds.username);
+    const ProviderClass = providerRegistry[provider];
+    if (!ProviderClass)
+        throw new Error(`[Framework] Unknown provider: ${provider}`);
+    const authProvider = new ProviderClass(creds);
+    let needsLogin = true;
+    if ((0, validateStore_1.isAuthStoreValid)(storagePath, validityMinutes)) {
+        console.log(`[Framework] Found valid auth store: ${storagePath}`);
+        const state = JSON.parse(require("fs").readFileSync(storagePath, "utf-8"));
+        await page.context().addCookies(state.cookies);
+        await page.reload();
+        if (!page.url().includes("/auth/login")) {
+            console.log(`[Framework] Reusing valid auth store`);
+            needsLogin = false;
+        }
+        else {
+            console.log("[Framework] Auth store rejected, will re-login...");
+        }
+    }
+    if (needsLogin) {
+        console.log("[Framework] Performing fresh login...");
+        await authProvider.login(page);
+        await page.context().storageState({ path: storagePath });
+        console.log(`[Framework] New auth store created: ${storagePath}`);
+    }
+}

package/dist/utils/auth-session/storagePath.d.ts

@@ -0,0 +1 @@
+export declare function getStoragePath(provider: string, envName: string, username: string): string;

package/dist/utils/auth-session/storagePath.js

@@ -0,0 +1,14 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getStoragePath = getStoragePath;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+function getStoragePath(provider, envName, username) {
+    const storageDir = path_1.default.resolve("storage");
+    if (!fs_1.default.existsSync(storageDir))
+        fs_1.default.mkdirSync(storageDir, { recursive: true });
+    return path_1.default.join(storageDir, `${provider}-${envName}-${username}-auth.json`);
+}

package/dist/utils/auth-session/validateStore.d.ts

@@ -0,0 +1 @@
+export declare function isAuthStoreValid(storagePath: string, validityMinutes: number): boolean;

package/dist/utils/auth-session/validateStore.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAuthStoreValid = isAuthStoreValid;
+const fs_1 = __importDefault(require("fs"));
+function isAuthStoreValid(storagePath, validityMinutes) {
+    if (!fs_1.default.existsSync(storagePath))
+        return false;
+    const raw = fs_1.default.readFileSync(storagePath, "utf-8").trim();
+    if (!raw)
+        return false;
+    try {
+        const state = JSON.parse(raw);
+        const stats = fs_1.default.statSync(storagePath);
+        const ageMinutes = (Date.now() - stats.mtimeMs) / 60000;
+        return (state.cookies?.length > 0 || state.origins?.length > 0) && ageMinutes < validityMinutes;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,7 @@
+import { Page } from "@playwright/test";
+export declare class FileUtils {
+    private page;
+    constructor(page: Page);
+    uploadFile(selector: string, filePath: string): Promise<void>;
+    downloadFile(selector: string, downloadDir?: string): Promise<string>;
+}

package/dist/utils/file-utils.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileUtils = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+class FileUtils {
+    page;
+    constructor(page) {
+        this.page = page;
+    }
+    // Upload a file by setting input[type=file]
+    async uploadFile(selector, filePath) {
+        const absolutePath = path_1.default.resolve(filePath);
+        if (!fs_1.default.existsSync(absolutePath)) {
+            throw new Error(`❌ File not found: ${absolutePath}`);
+        }
+        await this.page.setInputFiles(selector, absolutePath);
+        console.log(`✅ Uploaded file: ${absolutePath}`);
+    }
+    // Download a file triggered by clicking a link/button
+    async downloadFile(selector, downloadDir = "downloads") {
+        const downloadPromise = this.page.waitForEvent("download");
+        await this.page.click(selector);
+        const download = await downloadPromise;
+        const filePath = path_1.default.join(downloadDir, await download.suggestedFilename());
+        await download.saveAs(filePath);
+        console.log(`✅ File downloaded to: ${filePath}`);
+        return filePath;
+    }
+}
+exports.FileUtils = FileUtils;

package/dist/utils/testrail.client.d.ts

@@ -0,0 +1,6 @@
+export declare class TestRailClient {
+    private baseUrl;
+    private authHeader;
+    constructor(baseUrl?: string, username?: string, apiKey?: string);
+    addResult(caseId: number, statusId: number, comment: string): Promise<unknown>;
+}

package/dist/utils/testrail.client.js

@@ -0,0 +1,36 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestRailClient = void 0;
+// framework/src/utils/testrail.client.ts
+const node_fetch_1 = __importDefault(require("node-fetch"));
+// framework/src/utils/testrail.client.ts
+class TestRailClient {
+    baseUrl;
+    authHeader;
+    constructor(baseUrl, username, apiKey) {
+        this.baseUrl = baseUrl || "";
+        this.authHeader = username && apiKey
+            ? "Basic " + Buffer.from(`${username}:${apiKey}`).toString("base64")
+            : "";
+    }
+    async addResult(caseId, statusId, comment) {
+        if (!this.baseUrl) {
+            console.warn(`⚠️ Demo mode: would push result to TestRail case ${caseId} → status ${statusId}, comment: ${comment}`);
+            return { demo: true };
+        }
+        const url = `${this.baseUrl}/index.php?/api/v2/add_result_for_case/${caseId}`;
+        const response = await (0, node_fetch_1.default)(url, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "Authorization": this.authHeader,
+            },
+            body: JSON.stringify({ status_id: statusId, comment }),
+        });
+        return response.json();
+    }
+}
+exports.TestRailClient = TestRailClient;

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "simple-playwright-framework",
+  "version": "0.0.2",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "clean": "rimraf dist .cache",
+    "build": "tsc -p tsconfig.json"
+  },
+  "dependencies": {
+    "node-fetch": "^3.3.2"
+  },
+  "peerDependencies": {
+    "@playwright/test": "^1.58.2"
+  },
+  "bin": {
+    "init-sample-project": "./scripts/setup-framework.js"
+  },
+  "files": [
+    "dist",
+    "scripts"
+  ]
+}

package/scripts/setup-framework.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+});
+
+function ask(question, defaultValue) {
+  return new Promise(resolve => {
+    rl.question(`${question} (${defaultValue}): `, answer => {
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+async function main() {
+  console.log("🚀 Init Sample Playwright Project");
+
+  const projectName = await ask("Project name", "sample-project");
+  const includeAuth = await ask("Include auth example? yes/no", "yes");
+  const includeData = await ask("Include data example? yes/no", "yes");
+
+  rl.close();
+
+  const projectDir = path.join(process.cwd(), projectName);
+  fs.mkdirSync(projectDir, { recursive: true });
+
+  // Config
+  fs.mkdirSync(path.join(projectDir, "config"), { recursive: true });
+  fs.writeFileSync(
+    path.join(projectDir, "config", "environments.json"),
+    JSON.stringify({ qa: { baseUrl: "http://localhost:3000" } }, null, 2)
+  );
+
+  // Tests
+  fs.mkdirSync(path.join(projectDir, "tests", "ui"), { recursive: true });
+  fs.writeFileSync(
+    path.join(projectDir, "tests", "ui", "login.spec.ts"),
+    `import { test, expect } from '@playwright/test';
+
+test('login example', async ({ page }) => {
+  await page.goto('http://localhost:3000/login');
+  await expect(page).toHaveTitle(/Login/);
+});`
+  );
+
+  if (includeAuth.toLowerCase() === "yes") {
+    fs.mkdirSync(path.join(projectDir, "auth"), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, "auth", "index.ts"),
+      `export const creds = { username: "testuser", password: "testpass" };`
+    );
+  }
+
+  if (includeData.toLowerCase() === "yes") {
+    fs.mkdirSync(path.join(projectDir, "data", "ui"), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, "data", "ui", "sample.txt"),
+      "Sample test data"
+    );
+  }
+
+  console.log(`✅ Sample project created in ${projectDir}`);
+  console.log(`👉 Next steps:\n   cd ${projectName}\n   npx playwright test`);
+}
+
+main();