dh-auth-library 1.1.0 → 1.2.1

package/dist/index.es.js

@@ -0,0 +1,523 @@
+import { BasePage, LocalLoginPage, SessionManager, Url, getUrl, isRunningOnLocalhost, urls } from "nl-portal-playwright-libraries";
+import * as process$2 from "node:process";
+import process$1 from "node:process";
+import { expect } from "@playwright/test";
+import { TOTP } from "totp-generator";
+import * as path from "node:path";
+//#region src/auth/loginhandlers/localhostLoginHandler.ts
+var LocalhostLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new LocalLoginPage(page).loginAndCreateNewSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/pages/loginOverzichtPage.ts
+var LoginOverzichtPage = class extends BasePage {
+	digidLoginKnop;
+	digidMachtigenLoginKnop;
+	eHerkenningLoginKnop;
+	eHerkenningMachtigingLoginKnop;
+	constructor(page) {
+		super(page);
+		this.digidLoginKnop = page.locator("#oidc-digid");
+		this.digidMachtigenLoginKnop = page.locator("#digid-machtigen");
+		this.eHerkenningLoginKnop = page.locator("#oidc-eHerkenning");
+		this.eHerkenningMachtigingLoginKnop = page.locator("#eherkenning-bewindvoering");
+	}
+	async klikOpDigidLoginOptie() {
+		await this.digidLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		await this.digidLoginKnop.click();
+	}
+	async klikOpDigidMachtigenLoginOptie() {
+		await this.digidMachtigenLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		await this.digidMachtigenLoginKnop.click();
+	}
+	async klikOpEHerkenningLoginOptie() {
+		await this.eHerkenningLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		try {
+			await this.eHerkenningLoginKnop.click();
+		} catch (_error) {
+			await this.reloadPage();
+			await this.eHerkenningLoginKnop.waitFor();
+			await this.page.waitForTimeout(2e3);
+			await this.eHerkenningLoginKnop.click();
+		}
+	}
+	async klikOpProfessioneelBewindvoerderLoginOptie() {
+		await this.eHerkenningMachtigingLoginKnop.waitFor();
+		await this.page.waitForTimeout(2e3);
+		try {
+			await this.eHerkenningMachtigingLoginKnop.click();
+		} catch (_error) {
+			await this.reloadPage();
+			await this.eHerkenningMachtigingLoginKnop.waitFor();
+			await this.page.waitForTimeout(2e3);
+			await this.eHerkenningMachtigingLoginKnop.click();
+		}
+	}
+	async valideerDatHetLoginOverzichtZichtbaarIs() {
+		await expect(this.page.getByRole("heading", { name: "Inloggen voor mijzelf" })).toBeVisible();
+	}
+	async accepteerCookies() {
+		try {
+			await this.page.locator("#ppms_cm_agree-to-all").click();
+		} catch (_ignore) {}
+	}
+	async reloadPage() {
+		try {
+			await this.page.reload();
+		} catch (_error) {}
+	}
+};
+//#endregion
+//#region src/auth/pages/digidLoginPage.ts
+var DigidLoginPage = class extends LoginOverzichtPage {
+	constructor(page) {
+		super(page);
+	}
+	async loginAndCreateNewSession(account, fileName) {
+		await this.openPage();
+		await this.handleAnySpecialADLoginScreen();
+		try {
+			await this.klikOpDigidLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.handleAnySpecialADLoginScreen();
+			await this.klikOpDigidLoginOptie();
+		}
+		if (!this.page.url().match(/authn/)) {
+			await this.loginWithDigid(account);
+			await this.accepteerCookies();
+		}
+		await this.page.context().storageState({ path: fileName });
+	}
+	async loginAndCreateNewGemachtigdeSession(account, fileName) {
+		await this.openPage();
+		await this.handleAnySpecialADLoginScreen();
+		try {
+			await this.klikOpDigidMachtigenLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.klikOpDigidMachtigenLoginOptie();
+		}
+		await this.loginWithDigid(account, true);
+		await this.accepteerCookies();
+		await this.page.context().storageState({ path: fileName });
+	}
+	/**
+	* Indien er al een AD sessie is maar voor de verkeerde omgeving
+	* Je krijgt dan een speciaal scherm waar je moet bevestigen voordat je door kan
+	*/
+	async handleAnySpecialADLoginScreen() {
+		try {
+			await this.page.locator(`//div[contains(@data-test-id,'${process$1.env.AD_USER}')]`).first().waitFor({ timeout: 1e3 });
+			await this.page.locator(`//div[contains(@data-test-id,'${process$1.env.AD_USER}')]`).first().click();
+		} catch (_error) {}
+	}
+	async loginWithDigid(account, gemachtigde) {
+		await this.page.getByLabel("Inlogoptie 5 van 5: Inloggen").click();
+		await this.page.getByLabel("Testen betrouwbaarheidsniveau").selectOption("25");
+		await this.page.getByLabel("DigiD gebruikersnaam").fill(account.username);
+		await this.page.getByLabel("Wachtwoord", { exact: true }).fill(account.password);
+		const responsePromise = this.page.waitForResponse(/callback/, { timeout: 6e4 });
+		await this.page.getByRole("button", { name: "Inloggen" }).click();
+		if (gemachtigde) await this.page.getByRole("button", { name: "Kies" }).click();
+		return await responsePromise;
+	}
+	async loginAlsDigidGemachtigde() {
+		const gemachtigde = {
+			username: `${process$1.env.DIGID_GEMACHTIGDE_USER}`,
+			password: `${process$1.env.DIGID_GEMACHTIGDE_PASSWORD}`
+		};
+		await this.klikOpDigidMachtigenLoginOptie();
+		await this.loginWithDigid(gemachtigde, true);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/digidLoginHandler.ts
+var DigidLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new DigidLoginPage(page).loginAndCreateNewSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/pages/eHerkenningLoginPage.ts
+var EHerkenningLoginPage = class extends LoginOverzichtPage {
+	dropdownSelectIdentityProvider;
+	buttonConfirmIdentityProviderSelection;
+	textfieldUsername;
+	textfieldPassword;
+	inloggenKnop;
+	verderKnop;
+	verderLink;
+	inputBsn;
+	buttonZoek;
+	constructor(page) {
+		super(page);
+		this.dropdownSelectIdentityProvider = page.locator("#identity_provider");
+		this.buttonConfirmIdentityProviderSelection = page.locator("//*[@name='commit']");
+		this.textfieldUsername = page.locator("#account_username");
+		this.textfieldPassword = page.locator("#account_password");
+		this.inloggenKnop = page.getByRole("button", { name: /Inloggen|Log in/ });
+		this.verderKnop = page.getByRole("button", { name: /Verder|Continue|Ga verder/ });
+		this.inputBsn = page.locator("#bsn-input");
+		this.buttonZoek = page.locator("#search-submit");
+		this.verderLink = page.getByRole("link", { name: /Verder|Continue|Ga verder/ });
+	}
+	async probeerInTeLoggenMetEHerkenning(account) {
+		await this.dropdownSelectIdentityProvider.selectOption("Digidentity AD 1.13 (preproduction)");
+		await this.page.locator("#remember").click();
+		await this.buttonConfirmIdentityProviderSelection.click();
+		await this.textfieldUsername.fill(account.username);
+		await this.verderKnop.click();
+		await this.textfieldPassword.fill(account.password);
+		await this.inloggenKnop.click();
+	}
+	async loginWithEHerkenningAndCreateSession(fileName, account) {
+		await this.openPage();
+		try {
+			await this.klikOpEHerkenningLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.klikOpEHerkenningLoginOptie();
+		}
+		await this.loginWithEHerkenning(account);
+		await this.page.context().storageState({ path: fileName });
+	}
+	async loginWithEHerkenning(account) {
+		await this.probeerInTeLoggenMetEHerkenning(account);
+		await this.page.waitForTimeout(2e3);
+		if (await this.verderKnop.isVisible()) await this.verderKnop.click();
+		await this.accepteerCookies();
+	}
+	async loginWithEHerkenningVestigingAndCreateSession(fileName, account) {
+		await this.openPage();
+		try {
+			await this.klikOpEHerkenningLoginOptie();
+		} catch (_error) {
+			await this.openPage();
+			await this.klikOpEHerkenningLoginOptie();
+		}
+		await this.loginWithEHerkenningVestiging(account);
+		await this.page.context().storageState({ path: fileName });
+	}
+	async loginWithEHerkenningVestiging(account) {
+		await this.probeerInTeLoggenMetEHerkenning(account);
+		await this.page.waitForTimeout(2e3);
+		if (await this.verderKnop.isVisible()) await this.verderKnop.click();
+		await this.accepteerCookies();
+	}
+	async loginAlsProfessioneelBewindvoerder(gemachtigde, file) {
+		await this.openPage();
+		await this.klikOpProfessioneelBewindvoerderLoginOptie();
+		try {
+			await this.probeerInTeLoggenMetEHerkenning(gemachtigde);
+		} catch (_error) {
+			await this.openPage();
+			await this.probeerInTeLoggenMetEHerkenning(gemachtigde);
+		}
+		if (gemachtigde.bsn != null) {
+			await this.verderLink.click();
+			await this.inputBsn.fill(gemachtigde.bsn);
+		}
+		await this.buttonZoek.click();
+		await this.verderLink.click();
+		await this.accepteerCookies();
+		if (file) await this.page.context().storageState({ path: file });
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/eHerkenningLoginHandler.ts
+var EHerkenningLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new EHerkenningLoginPage(page).loginWithEHerkenningVestigingAndCreateSession(file, account);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/digidGemachtigdeLoginHandler.ts
+var DigidGemachtigdeLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new DigidLoginPage(page).loginAndCreateNewGemachtigdeSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/eHerkenningBewindvoerderLoginHandler.ts
+var EHerkenningBewindvoerderLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new EHerkenningLoginPage(page).loginAlsProfessioneelBewindvoerder(account, file);
+	}
+};
+//#endregion
+//#region src/auth/pages/adLoginPage.ts
+var gzacUrlProd = "https://alg-zgw.denhaag.nl";
+var gzacUrlAcp = "https://alg-zgw.acc.denhaag.nl";
+var gzacUrlTest = "https://alg-zgw.test.denhaag.nl";
+var ADLoginPage = class ADLoginPage extends BasePage {
+	gebruikersnaamInput;
+	wachtwoordInput;
+	volgendeInput;
+	aanmeldenInput;
+	kanAuthAppNietGebruikenLink;
+	gebruikVerificatieCode;
+	codeInput;
+	verifierenInput;
+	constructor(page) {
+		super(page);
+		this.gebruikersnaamInput = page.locator("//input[@type='email']");
+		this.wachtwoordInput = page.locator("//input[@name='passwd']");
+		this.volgendeInput = page.locator("//input[@type='submit']");
+		this.aanmeldenInput = page.locator("//input[@type='submit']");
+		this.kanAuthAppNietGebruikenLink = page.locator("//*[@id='signInAnotherWay']");
+		this.gebruikVerificatieCode = page.locator("//div[@id='idDiv_SAOTCS_Proofs']//div[contains(@role,'listitem')][2]");
+		this.codeInput = page.locator("//input[@name='otc']");
+		this.verifierenInput = page.locator("//input[@type='submit']");
+	}
+	async openPage(path) {
+		await this.page.goto(path);
+	}
+	/**
+	* Login with the AD account so we can get behind the firewall
+	*
+	* @param account
+	* @param fileName
+	*/
+	async loginWithADAccountAndCreateSession(account, fileName) {
+		const adLoginPage = new ADLoginPage(this.page);
+		await this.page.goto(this.getGzacUrl());
+		await adLoginPage.gebruikersnaamInput.waitFor();
+		await adLoginPage.gebruikersnaamInput.fill(account.username);
+		await adLoginPage.volgendeInput.click();
+		await adLoginPage.wachtwoordInput.fill(account.password);
+		await adLoginPage.aanmeldenInput.click();
+		await this.page.waitForTimeout(1e3);
+		try {
+			if (await this.page.getByText("Uw account is niet geverifieerd. Probeer het opnieuw").isVisible()) await this.tryAgainUntilSuccesful();
+		} catch (_error) {}
+		await adLoginPage.kanAuthAppNietGebruikenLink.click();
+		await adLoginPage.gebruikVerificatieCode.click();
+		const token = await TOTP.generate(`${process.env.AD_SECRET}`);
+		await adLoginPage.codeInput.fill(token.otp);
+		await adLoginPage.verifierenInput.click();
+		await adLoginPage.page.waitForTimeout(5e3);
+		adLoginPage.page.on("domcontentloaded", () => {});
+		await adLoginPage.page.context().storageState({ path: fileName });
+	}
+	async tryAgainUntilSuccesful() {
+		let maxNumberOfTries = 6;
+		let foutMeldingIsSHowing = true;
+		while (foutMeldingIsSHowing) {
+			await this.page.waitForTimeout(1e4);
+			maxNumberOfTries--;
+			if (maxNumberOfTries == 0) return;
+			try {
+				await this.page.goBack();
+				await this.page.waitForTimeout(1e3);
+				await this.page.locator("//div[contains(@role,'listitem')]").first().click();
+				await this.page.waitForTimeout(1e3);
+				foutMeldingIsSHowing = await this.page.getByText("Uw account is niet geverifieerd. Probeer het opnieuw").isVisible();
+			} catch (_error) {}
+		}
+	}
+	getGzacUrl() {
+		const baseUrl = this.getBaseUrl();
+		if (/klantportaal-zgw.denhaag.nl./.exec(baseUrl)) return gzacUrlProd;
+		if (/.acc./.exec(baseUrl)) return gzacUrlAcp;
+		if (/.test./.exec(baseUrl)) return gzacUrlTest;
+		else throw new Error("Cannot find current environment for baseUrl: " + baseUrl);
+	}
+};
+//#endregion
+//#region src/auth/loginhandlers/adLoginHandler.ts
+var ADLoginHandler = class {
+	async loginAndCreateSessionStorage(page, account, file) {
+		await new ADLoginPage(page).loginWithADAccountAndCreateSession(account, file);
+	}
+};
+//#endregion
+//#region src/auth/getLoginHandler.ts
+function getLoginHandler(authType) {
+	switch (authType) {
+		case "digid": return isRunningOnLocalhost() ? new LocalhostLoginHandler() : new DigidLoginHandler();
+		case "digid_gemachtigde": return new DigidGemachtigdeLoginHandler();
+		case "eherkenning": return isRunningOnLocalhost() ? new LocalhostLoginHandler() : new EHerkenningLoginHandler();
+		case "eherkenning_vestiging": return new EHerkenningLoginHandler();
+		case "eherkenning_bewindvoerder": return new EHerkenningBewindvoerderLoginHandler();
+		case "ad-session": return new ADLoginHandler();
+		default: throw new Error(`Unsupported auth type: ${authType}. If needed please create a new LoginHandler and register it here in getLoginHandler().`);
+	}
+}
+//#endregion
+//#region src/auth/utils/sessionFileHelper.ts
+var sessionsDir = process$2.env.SESSIONS_DIR ?? path.resolve(process$2.cwd(), "sessions");
+var environment = process$2.env.ENV ?? "test";
+/**
+* Easy way to create the filenames for the sessions
+*/
+var SessionFileHelper = class {
+	static getLocalhostFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-${environment}-${account.username}.json`);
+	}
+	static getLocalhostFileNameBedrijf(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-${environment}-${account.username}.json`);
+	}
+	static getDigidFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-digid-${environment}-${account.username}.json`);
+	}
+	static getDigidGemachtigdeFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-digid-gemachtigde-${environment}-${account.username}.json`);
+	}
+	static getEHerkenningFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-eherkenning-${environment}-${account.username}.json`);
+	}
+	static getEHerkenningVestigingFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-eherkenning-vestiging-${environment}-${account.username}.json`);
+	}
+	static getEHerkenningBewindvoerderFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-eherkenning-bewindvoerder-${environment}-${account.username}.json`);
+	}
+	static getADFileName(browser, account) {
+		return path.join(sessionsDir, `${browser.browserType().name()}-ad-${environment}-${account.username}.json`);
+	}
+};
+//#endregion
+//#region src/auth/sessionHandler.ts
+var MAX_SESSION_TIME_IN_MINUTES = 10;
+/**
+* This class creates the correct SessionHandler
+* It will also perform the process of setting op the session
+*
+* @param authType type of login
+* @param account with login details
+* @param loginHandler that will handle the login itself
+*/
+function createSessionHandler(authType, account, loginHandler) {
+	return {
+		getFile: (browser) => {
+			switch (authType) {
+				case "digid": return SessionFileHelper.getDigidFileName(browser, account);
+				case "digid_gemachtigde": return SessionFileHelper.getDigidGemachtigdeFileName(browser, account);
+				case "eherkenning": return SessionFileHelper.getEHerkenningFileName(browser, account);
+				case "eherkenning_vestiging": return SessionFileHelper.getEHerkenningVestigingFileName(browser, account);
+				case "eherkenning_bewindvoerder": return SessionFileHelper.getEHerkenningBewindvoerderFileName(browser, account);
+				case "ad-session": return SessionFileHelper.getADFileName(browser, account);
+				default: throw new Error(`Unsupported auth type: ${authType}`);
+			}
+		},
+		/**
+		* Setup the new session
+		* If needed the AD Session if used (Needed outside the firewall)
+		*
+		* @param browser
+		* @param file
+		*/
+		setupSession: async (browser, file) => {
+			const useADSession = process.env.WITH_AD_SESSION === "true";
+			const page = await browser.newPage({
+				ignoreHTTPSErrors: true,
+				storageState: useADSession && authType !== "ad-session" ? SessionFileHelper.getADFileName(browser, {
+					username: `${process.env.AD_USER}`,
+					password: `${process.env.AD_PASSWORD}`
+				}) : void 0
+			});
+			console.log(`New session will be created: ${file}`);
+			try {
+				await loginHandler.loginAndCreateSessionStorage(page, account, file);
+			} finally {
+				await page.close();
+			}
+		},
+		/**
+		* Refresh the current session by opening a page and storing that session
+		* The UI should have refreshed the session meanwhile
+		*
+		* This is being called from the nl-portal-base-library
+		*
+		* @param browser
+		* @param file
+		*/
+		refreshSession: async (browser, file) => {
+			const page = await browser.newPage({
+				ignoreHTTPSErrors: true,
+				storageState: file
+			});
+			console.log(`Refresh of session started for : ${file}`);
+			await page.goto(getUrl(Url.PortalBaseUrl));
+			await page.waitForLoadState("networkidle");
+			if (page.url().match(/authn/)) {
+				console.log(`New session will be created as the current one is no longer valid: ${file}`);
+				try {
+					await loginHandler.loginAndCreateSessionStorage(page, account, file);
+				} catch (_error) {
+					console.error(_error);
+				}
+			} else {
+				console.log(`Current session was still valid and will be refreshed now: ${file}`);
+				await page.context().storageState({ path: file });
+			}
+			await page.close();
+		}
+	};
+}
+//#endregion
+//#region src/auth/api/apiTokenHelper.ts
+/**
+* The token is often being refreshed so the easiest is to open a browser using the current session
+* The UI will automatically refresh the token and that is the token we will return
+*
+* That token can be used to perform some api requests for a short time
+* Per specfile it is not problem but this should be done in every specfile to assure a valid token
+*
+* @param baseTest
+* @param handler
+*/
+function getApiTokenFromSession(baseTest, handler) {
+	return baseTest.extend({
+		urls: async ({}, use) => {
+			await use(urls);
+		},
+		token: async ({ browser }, use) => {
+			const storageState = await SessionManager.getOrCreateSession(browser, handler);
+			const context = await browser.newContext(storageState ? { storageState } : {});
+			const page = await context.newPage();
+			try {
+				await page.goto("/");
+				await page.waitForFunction(() => {
+					const key = Object.keys(sessionStorage).find((k) => k.startsWith("oidc"));
+					if (!key) return false;
+					const raw = sessionStorage.getItem(key);
+					if (!raw) return false;
+					try {
+						return !!JSON.parse(raw)?.access_token;
+					} catch {
+						return false;
+					}
+				});
+				const token = await page.evaluate(() => {
+					const key = Object.keys(sessionStorage).find((k) => k.startsWith("oidc"));
+					if (!key) return null;
+					const raw = sessionStorage.getItem(key);
+					if (!raw) return null;
+					try {
+						return JSON.parse(raw)?.access_token ?? null;
+					} catch {
+						return null;
+					}
+				});
+				if (!token) throw new Error("❌ Token not found in sessionStorage");
+				await use(token);
+			} finally {
+				await context.close();
+			}
+		}
+	});
+}
+//#endregion
+//#region src/auth/api/sessionHandlerResolvers.ts
+function getSessionHandler(authType, account) {
+	return createSessionHandler(authType, account, getLoginHandler(authType));
+}
+//#endregion
+export { ADLoginHandler, ADLoginPage, DigidGemachtigdeLoginHandler, DigidLoginHandler, DigidLoginPage, EHerkenningBewindvoerderLoginHandler, EHerkenningLoginHandler, EHerkenningLoginPage, LocalhostLoginHandler, LoginOverzichtPage, MAX_SESSION_TIME_IN_MINUTES, SessionFileHelper, createSessionHandler, getApiTokenFromSession, getLoginHandler, getSessionHandler };

package/package.json

@@ -1,50 +1,55 @@
-{
-    "name": "dh-auth-library",
-    "version": "1.1.0",
-    "repository": {
-        "type": "git",
-        "url": "git+https://github.com/Gemeente-DenHaag/dh-auth-library.git"
-    },
-    "packageManager": "pnpm@11.5.2",
-    "description": "Authentication package for all types of login on DH applications",
-    "license": "MIT",
-    "main": "dist/index.js",
-    "types": "dist/index.d.ts",
-    "exports": {
-        ".": {
-            "types": "./dist/index.d.ts",
-            "default": "./dist/index.js"
-        }
-    },
-    "files": [
-        "dist"
-    ],
-    "scripts": {
-        "build": "tsc -p tsconfig.build.json",
-        "prepublishOnly": "pnpm build",
-        "lint": "eslint ."
-    },
-    "engines": {
-        "node": ">=22",
-        "pnpm": "^11"
-    },
-    "devDependencies": {
-        "@eslint/js": "10.0.1",
-        "@playwright/test": "^1.61.1",
-        "@types/node": "^25.9.4",
-        "eslint": "^10.5.0",
-        "typescript": "^6.0.3",
-        "typescript-eslint": "8.60.1"
-    },
-    "dependencies": {
-        "nl-portal-playwright-libraries": "^1.1.3",
-        "totp-generator": "^2.0.1"
-    },
-    "keywords": [
-        "playwright",
-        "testing",
-        "automation",
-        "e2e",
-        "nl-portal"
-    ]
-}
+{
+  "name": "dh-auth-library",
+  "version": "1.2.1",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Gemeente-DenHaag/dh-auth-library.git"
+  },
+  "description": "Authentication package for all types of login on DH applications",
+  "license": "MIT",
+  "main": "dist/index.cjs.js",
+  "module": "dist/index.es.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.es.js",
+      "require": "./dist/index.cjs.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=22",
+    "pnpm": "^11"
+  },
+  "peerDependencies": {
+    "@playwright/test": ">=1.60.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "10.0.1",
+    "@playwright/test": "^1.61.1",
+    "@types/node": "^25.9.4",
+    "eslint": "^10.5.0",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "8.60.1",
+    "vite": "^8.1.0",
+    "vite-tsconfig-paths": "^6.1.1"
+  },
+  "dependencies": {
+    "nl-portal-playwright-libraries": "^1.1.3",
+    "totp-generator": "^2.0.1"
+  },
+  "keywords": [
+    "playwright",
+    "testing",
+    "automation",
+    "e2e",
+    "dh-auth"
+  ],
+  "scripts": {
+    "build": "vite build && tsc -p tsconfig.build.json",
+    "lint": "eslint ."
+  }
+}

package/dist/auth/api/apiAuthentication.d.ts

@@ -1,10 +0,0 @@
-/**
- * The api's will use an existing session and use that token for the requests.
- * The reason for this is that the token life-span is short and the UI always does a token-refresh.
- * By using the UI session and stealing that token it will always be valid.
- */
-export declare const burgerApiTest: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & import("./apiTokenHelper").ApiFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
-export declare const bedrijfApiTest: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & import("./apiTokenHelper").ApiFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
-export declare const vestigingApiTest: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & import("./apiTokenHelper").ApiFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
-export declare const digidGemachtigdeApiTest: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & import("./apiTokenHelper").ApiFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;
-export declare const eHerkenningBewindvoerderApiTest: import("@playwright/test").TestType<import("@playwright/test").PlaywrightTestArgs & import("@playwright/test").PlaywrightTestOptions & import("./apiTokenHelper").ApiFixtures, import("@playwright/test").PlaywrightWorkerArgs & import("@playwright/test").PlaywrightWorkerOptions>;

package/dist/auth/api/apiAuthentication.js

@@ -1,13 +0,0 @@
-import { baseTest as base } from 'nl-portal-playwright-libraries';
-import { getApiTokenFromSession } from './apiTokenHelper';
-import { getBedrijfSessionHandler, getBurgerSessionHandler, getDigidGemachtigdeSessionHandler, getEHerkenningBewindvoerderSessionHandler, getVestigingSessionHandler, } from './sessionHandlerResolvers';
-/**
- * The api's will use an existing session and use that token for the requests.
- * The reason for this is that the token life-span is short and the UI always does a token-refresh.
- * By using the UI session and stealing that token it will always be valid.
- */
-export const burgerApiTest = getApiTokenFromSession(base, getBurgerSessionHandler);
-export const bedrijfApiTest = getApiTokenFromSession(base, getBedrijfSessionHandler);
-export const vestigingApiTest = getApiTokenFromSession(base, getVestigingSessionHandler);
-export const digidGemachtigdeApiTest = getApiTokenFromSession(base, getDigidGemachtigdeSessionHandler);
-export const eHerkenningBewindvoerderApiTest = getApiTokenFromSession(base, getEHerkenningBewindvoerderSessionHandler);