lint

acceptance/tests/admin.spec.ts

@@ -1,7 +1,7 @@
-import {test} from "@playwright/test";
-import {loginScreenExpect, loginWithPassword} from "./login";
+import { test } from "@playwright/test";
+import { loginScreenExpect, loginWithPassword } from "./login";
 
-test("admin login", async ({page}) => {
-    await loginWithPassword(page, "zitadel-admin@zitadel.localhost", "Password1.")
-    await loginScreenExpect(page, "ZITADEL Admin");
+test("admin login", async ({ page }) => {
+  await loginWithPassword(page, "zitadel-admin@zitadel.localhost", "Password1.");
+  await loginScreenExpect(page, "ZITADEL Admin");
 });

acceptance/tests/login.ts

@@ -1,30 +1,28 @@
-import {expect, Page} from "@playwright/test";
-import {loginname} from "./loginname";
-import {password} from "./password";
+import { expect, Page } from "@playwright/test";
+import { loginname } from "./loginname";
+import { password } from "./password";
 
 export async function startLogin(page: Page) {
-    await page.goto("/loginname");
+  await page.goto("/loginname");
 }
 
 export async function loginWithPassword(page: Page, username: string, pw: string) {
-    await startLogin(page);
-    await loginname(page, username);
-    await password(page, pw);
+  await startLogin(page);
+  await loginname(page, username);
+  await password(page, pw);
 }
 
 export async function loginWithPasskey(page: Page, authenticatorId: string, username: string) {
-    await startLogin(page);
-    await loginname(page, username);
-    // await passkey(page, authenticatorId);
+  await startLogin(page);
+  await loginname(page, username);
+  // await passkey(page, authenticatorId);
 }
 
 export async function loginScreenExpect(page: Page, fullName: string) {
-    await expect(page).toHaveURL(/signedin.*/)
-    await expect(page.getByRole('heading')).toContainText(fullName);
+  await expect(page).toHaveURL(/signedin.*/);
+  await expect(page.getByRole("heading")).toContainText(fullName);
 }
 
 export async function loginWithOTP(page: Page, username: string, password: string) {
-    await loginWithPassword(page, username, password);
-
-
+  await loginWithPassword(page, username, password);
 }

acceptance/tests/loginname-screen.ts

@@ -1,12 +1,12 @@
-import {expect, Page} from "@playwright/test";
+import { expect, Page } from "@playwright/test";
 
-const usernameUserInput = "username-text-input"
+const usernameUserInput = "username-text-input";
 
 export async function loginnameScreen(page: Page, username: string) {
-    await page.getByTestId(usernameUserInput).pressSequentially(username);
+  await page.getByTestId(usernameUserInput).pressSequentially(username);
 }
 
 export async function loginnameScreenExpect(page: Page, username: string) {
-    await expect(page.getByTestId(usernameUserInput)).toHaveValue(username);
-    await expect(page.getByTestId('error').locator('div')).toContainText("Could not find user")
+  await expect(page.getByTestId(usernameUserInput)).toHaveValue(username);
+  await expect(page.getByTestId("error").locator("div")).toContainText("Could not find user");
 }

acceptance/tests/loginname.ts

@@ -1,7 +1,7 @@
-import {Page} from "@playwright/test";
-import {loginnameScreen} from "./loginname-screen";
+import { Page } from "@playwright/test";
+import { loginnameScreen } from "./loginname-screen";
 
 export async function loginname(page: Page, username: string) {
-    await loginnameScreen(page, username)
-    await page.getByTestId("submit-button").click()
+  await loginnameScreen(page, username);
+  await page.getByTestId("submit-button").click();
 }

acceptance/tests/otp.ts

@@ -3,29 +3,29 @@ import * as http from "node:http";
 let messages = new Map<string, any>();
 
 export function startSink() {
-    const hostname = "127.0.0.1"
-    const port = 3030
+  const hostname = "127.0.0.1";
+  const port = 3030;
 
-    const server = http.createServer((req, res) => {
-        console.log("Sink received message: ")
-        let body = '';
-        req.on('data', (chunk) => {
-            body += chunk;
-        });
-
-        req.on('end', () => {
-            console.log(body);
-            const data = JSON.parse(body)
-            messages.set(data.contextInfo.recipientEmailAddress, data.args.code)
-            res.statusCode = 200;
-            res.setHeader('Content-Type', 'text/plain');
-            res.write('OK');
-            res.end();
-        });
+  const server = http.createServer((req, res) => {
+    console.log("Sink received message: ");
+    let body = "";
+    req.on("data", (chunk) => {
+      body += chunk;
     });
 
-    server.listen(port, hostname, () => {
-        console.log(`Sink running at http://${hostname}:${port}/`);
+    req.on("end", () => {
+      console.log(body);
+      const data = JSON.parse(body);
+      messages.set(data.contextInfo.recipientEmailAddress, data.args.code);
+      res.statusCode = 200;
+      res.setHeader("Content-Type", "text/plain");
+      res.write("OK");
+      res.end();
     });
-    return server
-}
+  });
+
+  server.listen(port, hostname, () => {
+    console.log(`Sink running at http://${hostname}:${port}/`);
+  });
+  return server;
+}

acceptance/tests/passkey.ts

@@ -1,109 +1,109 @@
-import {expect, Page} from "@playwright/test";
-import {CDPSession} from "playwright-core";
+import { expect, Page } from "@playwright/test";
+import { CDPSession } from "playwright-core";
 
 interface session {
-    client: CDPSession
-    authenticatorId: string
+  client: CDPSession;
+  authenticatorId: string;
 }
 
 async function client(page: Page): Promise<session> {
-    const cdpSession = await page.context().newCDPSession(page);
-    await cdpSession.send('WebAuthn.enable', {enableUI: false});
-    const result = await cdpSession.send('WebAuthn.addVirtualAuthenticator', {
-        options: {
-            protocol: 'ctap2',
-            transport: 'internal',
-            hasResidentKey: true,
-            hasUserVerification: true,
-            isUserVerified: true,
-            automaticPresenceSimulation: true,
-        },
-    });
-    return {client: cdpSession, authenticatorId: result.authenticatorId};
+  const cdpSession = await page.context().newCDPSession(page);
+  await cdpSession.send("WebAuthn.enable", { enableUI: false });
+  const result = await cdpSession.send("WebAuthn.addVirtualAuthenticator", {
+    options: {
+      protocol: "ctap2",
+      transport: "internal",
+      hasResidentKey: true,
+      hasUserVerification: true,
+      isUserVerified: true,
+      automaticPresenceSimulation: true,
+    },
+  });
+  return { client: cdpSession, authenticatorId: result.authenticatorId };
 }
 
 export async function passkeyRegister(page: Page): Promise<string> {
-    const session = await client(page)
+  const session = await client(page);
 
-    await passkeyNotExisting(session.client, session.authenticatorId);
-    await simulateSuccessfulPasskeyRegister(
-        session.client,
-        session.authenticatorId,
-        () =>
-            page.getByTestId("submit-button").click()
-    );
-    await passkeyRegistered(session.client, session.authenticatorId);
+  await passkeyNotExisting(session.client, session.authenticatorId);
+  await simulateSuccessfulPasskeyRegister(session.client, session.authenticatorId, () =>
+    page.getByTestId("submit-button").click(),
+  );
+  await passkeyRegistered(session.client, session.authenticatorId);
 
-    return session.authenticatorId
+  return session.authenticatorId;
 }
 
 export async function passkey(page: Page, authenticatorId: string) {
-    const cdpSession = await page.context().newCDPSession(page);
-    await cdpSession.send('WebAuthn.enable', {enableUI: false});
+  const cdpSession = await page.context().newCDPSession(page);
+  await cdpSession.send("WebAuthn.enable", { enableUI: false });
 
-    const signCount = await passkeyExisting(cdpSession, authenticatorId);
+  const signCount = await passkeyExisting(cdpSession, authenticatorId);
 
-    await simulateSuccessfulPasskeyInput(
-        cdpSession,
-        authenticatorId,
-        () =>
-            page.getByTestId("submit-button").click()
-    );
+  await simulateSuccessfulPasskeyInput(cdpSession, authenticatorId, () => page.getByTestId("submit-button").click());
 
-    await passkeyUsed(cdpSession, authenticatorId, signCount);
+  await passkeyUsed(cdpSession, authenticatorId, signCount);
 }
 
 async function passkeyNotExisting(client: CDPSession, authenticatorId: string) {
-    const result = await client.send('WebAuthn.getCredentials', {authenticatorId});
-    expect(result.credentials).toHaveLength(0);
+  const result = await client.send("WebAuthn.getCredentials", { authenticatorId });
+  expect(result.credentials).toHaveLength(0);
 }
 
 async function passkeyRegistered(client: CDPSession, authenticatorId: string) {
-    const result = await client.send('WebAuthn.getCredentials', {authenticatorId});
-    expect(result.credentials).toHaveLength(1);
-    await passkeyUsed(client, authenticatorId, 0);
+  const result = await client.send("WebAuthn.getCredentials", { authenticatorId });
+  expect(result.credentials).toHaveLength(1);
+  await passkeyUsed(client, authenticatorId, 0);
 }
 
 async function passkeyExisting(client: CDPSession, authenticatorId: string): Promise<number> {
-    const result = await client.send('WebAuthn.getCredentials', {authenticatorId});
-    expect(result.credentials).toHaveLength(1);
-    return result.credentials[0].signCount
+  const result = await client.send("WebAuthn.getCredentials", { authenticatorId });
+  expect(result.credentials).toHaveLength(1);
+  return result.credentials[0].signCount;
 }
 
 async function passkeyUsed(client: CDPSession, authenticatorId: string, signCount: number) {
-    const result = await client.send('WebAuthn.getCredentials', {authenticatorId});
-    expect(result.credentials).toHaveLength(1);
-    expect(result.credentials[0].signCount).toBeGreaterThan(signCount);
+  const result = await client.send("WebAuthn.getCredentials", { authenticatorId });
+  expect(result.credentials).toHaveLength(1);
+  expect(result.credentials[0].signCount).toBeGreaterThan(signCount);
 }
 
-async function simulateSuccessfulPasskeyRegister(client: CDPSession, authenticatorId: string, operationTrigger: () => Promise<void>) {
-    // initialize event listeners to wait for a successful passkey input event
-    const operationCompleted = new Promise<void>(resolve => {
-        client.on('WebAuthn.credentialAdded', () => {
-            console.log('Credential Added!');
-            resolve()
-        });
+async function simulateSuccessfulPasskeyRegister(
+  client: CDPSession,
+  authenticatorId: string,
+  operationTrigger: () => Promise<void>,
+) {
+  // initialize event listeners to wait for a successful passkey input event
+  const operationCompleted = new Promise<void>((resolve) => {
+    client.on("WebAuthn.credentialAdded", () => {
+      console.log("Credential Added!");
+      resolve();
     });
+  });
 
-    // perform a user action that triggers passkey prompt
-    await operationTrigger();
+  // perform a user action that triggers passkey prompt
+  await operationTrigger();
 
-    // wait to receive the event that the passkey was successfully registered or verified
-    await operationCompleted;
+  // wait to receive the event that the passkey was successfully registered or verified
+  await operationCompleted;
 }
 
-async function simulateSuccessfulPasskeyInput(client: CDPSession, authenticatorId: string, operationTrigger: () => Promise<void>) {
-    // initialize event listeners to wait for a successful passkey input event
-    const operationCompleted = new Promise<void>(resolve => {
-        client.on('WebAuthn.credentialAsserted', () => {
-            console.log('Credential Asserted!');
-            resolve()
-        });
+async function simulateSuccessfulPasskeyInput(
+  client: CDPSession,
+  authenticatorId: string,
+  operationTrigger: () => Promise<void>,
+) {
+  // initialize event listeners to wait for a successful passkey input event
+  const operationCompleted = new Promise<void>((resolve) => {
+    client.on("WebAuthn.credentialAsserted", () => {
+      console.log("Credential Asserted!");
+      resolve();
     });
+  });
 
-    // perform a user action that triggers passkey prompt
-    await operationTrigger();
+  // perform a user action that triggers passkey prompt
+  await operationTrigger();
 
-    // wait to receive the event that the passkey was successfully registered or verified
-    await operationCompleted;
+  // wait to receive the event that the passkey was successfully registered or verified
+  await operationCompleted;
 }

acceptance/tests/password-screen.ts

@@ -1,47 +1,57 @@
-import {expect, Page} from "@playwright/test";
+import { expect, Page } from "@playwright/test";
 
-const passwordField = 'password-text-input'
-const passwordConfirmField = 'password-confirm-text-input'
-const lengthCheck = "length-check"
-const symbolCheck = "symbol-check"
-const numberCheck = "number-check"
-const uppercaseCheck = "uppercase-check"
-const lowercaseCheck = "lowercase-check"
-const equalCheck = "equal-check"
+const passwordField = "password-text-input";
+const passwordConfirmField = "password-confirm-text-input";
+const lengthCheck = "length-check";
+const symbolCheck = "symbol-check";
+const numberCheck = "number-check";
+const uppercaseCheck = "uppercase-check";
+const lowercaseCheck = "lowercase-check";
+const equalCheck = "equal-check";
 
-const matchText = "Matches"
-const noMatchText = "Doesn\'t match"
+const matchText = "Matches";
+const noMatchText = "Doesn't match";
 
 export async function changePasswordScreen(page: Page, password1: string, password2: string) {
-    await page.getByTestId(passwordField).pressSequentially(password1);
-    await page.getByTestId(passwordConfirmField).pressSequentially(password2);
+  await page.getByTestId(passwordField).pressSequentially(password1);
+  await page.getByTestId(passwordConfirmField).pressSequentially(password2);
 }
 
 export async function passwordScreen(page: Page, password: string) {
-    await page.getByTestId(passwordField).pressSequentially(password);
+  await page.getByTestId(passwordField).pressSequentially(password);
 }
 
 export async function passwordScreenExpect(page: Page, password: string) {
-    await expect(page.getByTestId(passwordField)).toHaveValue(password);
-    await expect(page.getByTestId('error').locator('div')).toContainText("Could not verify password");
+  await expect(page.getByTestId(passwordField)).toHaveValue(password);
+  await expect(page.getByTestId("error").locator("div")).toContainText("Could not verify password");
 }
 
-export async function changePasswordScreenExpect(page: Page, password1: string, password2: string, length: boolean, symbol: boolean, number: boolean, uppercase: boolean, lowercase: boolean, equals: boolean) {
-    await expect(page.getByTestId(passwordField)).toHaveValue(password1);
-    await expect(page.getByTestId(passwordConfirmField)).toHaveValue(password2);
+export async function changePasswordScreenExpect(
+  page: Page,
+  password1: string,
+  password2: string,
+  length: boolean,
+  symbol: boolean,
+  number: boolean,
+  uppercase: boolean,
+  lowercase: boolean,
+  equals: boolean,
+) {
+  await expect(page.getByTestId(passwordField)).toHaveValue(password1);
+  await expect(page.getByTestId(passwordConfirmField)).toHaveValue(password2);
 
-    await checkContent(page, lengthCheck, length);
-    await checkContent(page, symbolCheck, symbol);
-    await checkContent(page, numberCheck, number);
-    await checkContent(page, uppercaseCheck, uppercase);
-    await checkContent(page, lowercaseCheck, lowercase);
-    await checkContent(page, equalCheck, equals);
+  await checkContent(page, lengthCheck, length);
+  await checkContent(page, symbolCheck, symbol);
+  await checkContent(page, numberCheck, number);
+  await checkContent(page, uppercaseCheck, uppercase);
+  await checkContent(page, lowercaseCheck, lowercase);
+  await checkContent(page, equalCheck, equals);
 }
 
 async function checkContent(page: Page, testid: string, match: boolean) {
-    if (match) {
-        await expect(page.getByTestId(testid)).toContainText(matchText);
-    } else {
-        await expect(page.getByTestId(testid)).toContainText(noMatchText);
-    }
-}
+  if (match) {
+    await expect(page.getByTestId(testid)).toContainText(matchText);
+  } else {
+    await expect(page.getByTestId(testid)).toContainText(noMatchText);
+  }
+}

acceptance/tests/password.ts

@@ -1,20 +1,19 @@
-import {Page} from "@playwright/test";
-import {changePasswordScreen, passwordScreen} from "./password-screen";
-
-const passwordSubmitButton = "submit-button"
+import { Page } from "@playwright/test";
+import { changePasswordScreen, passwordScreen } from "./password-screen";
 
+const passwordSubmitButton = "submit-button";
 
 export async function startChangePassword(page: Page, loginname: string) {
-    await page.goto('password/change?' + new URLSearchParams({loginName: loginname}));
+  await page.goto("password/change?" + new URLSearchParams({ loginName: loginname }));
 }
 
 export async function changePassword(page: Page, loginname: string, password: string) {
-    await startChangePassword(page, loginname);
-    await changePasswordScreen(page, password, password)
-    await page.getByTestId(passwordSubmitButton).click();
+  await startChangePassword(page, loginname);
+  await changePasswordScreen(page, password, password);
+  await page.getByTestId(passwordSubmitButton).click();
 }
 
 export async function password(page: Page, password: string) {
-    await passwordScreen(page, password)
-    await page.getByTestId(passwordSubmitButton).click()
+  await passwordScreen(page, password);
+  await page.getByTestId(passwordSubmitButton).click();
 }

acceptance/tests/register-screen.ts

@@ -1,27 +1,27 @@
-import {Page} from "@playwright/test";
+import { Page } from "@playwright/test";
 
-const passwordField = 'password-text-input'
-const passwordConfirmField = 'password-confirm-text-input'
+const passwordField = "password-text-input";
+const passwordConfirmField = "password-confirm-text-input";
 
 export async function registerUserScreenPassword(page: Page, firstname: string, lastname: string, email: string) {
-    await registerUserScreen(page, firstname, lastname, email)
-    await page.getByTestId('Password-radio').click();
+  await registerUserScreen(page, firstname, lastname, email);
+  await page.getByTestId("Password-radio").click();
 }
 
 export async function registerUserScreenPasskey(page: Page, firstname: string, lastname: string, email: string) {
-    await registerUserScreen(page, firstname, lastname, email)
-    await page.getByTestId('Passkeys-radio').click();
+  await registerUserScreen(page, firstname, lastname, email);
+  await page.getByTestId("Passkeys-radio").click();
 }
 
 export async function registerPasswordScreen(page: Page, password1: string, password2: string) {
-    await page.getByTestId(passwordField).pressSequentially(password1);
-    await page.getByTestId(passwordConfirmField).pressSequentially(password2);
+  await page.getByTestId(passwordField).pressSequentially(password1);
+  await page.getByTestId(passwordConfirmField).pressSequentially(password2);
 }
 
 export async function registerUserScreen(page: Page, firstname: string, lastname: string, email: string) {
-    await page.getByTestId('firstname-text-input').pressSequentially(firstname);
-    await page.getByTestId('lastname-text-input').pressSequentially(lastname);
-    await page.getByTestId('email-text-input').pressSequentially(email);
-    await page.getByTestId('privacy-policy-checkbox').check();
-    await page.getByTestId('tos-checkbox').check();
-}
+  await page.getByTestId("firstname-text-input").pressSequentially(firstname);
+  await page.getByTestId("lastname-text-input").pressSequentially(lastname);
+  await page.getByTestId("email-text-input").pressSequentially(email);
+  await page.getByTestId("privacy-policy-checkbox").check();
+  await page.getByTestId("tos-checkbox").check();
+}

acceptance/tests/register.spec.ts

@@ -1,30 +1,30 @@
-import {test} from "@playwright/test";
-import {registerWithPasskey, registerWithPassword} from './register';
-import {loginScreenExpect} from "./login";
-import {removeUserByUsername} from './zitadel';
-import path from 'path';
-import dotenv from 'dotenv';
+import { test } from "@playwright/test";
+import dotenv from "dotenv";
+import path from "path";
+import { loginScreenExpect } from "./login";
+import { registerWithPasskey, registerWithPassword } from "./register";
+import { removeUserByUsername } from "./zitadel";
 
 // Read from ".env" file.
-dotenv.config({path: path.resolve(__dirname, '.env.local')});
+dotenv.config({ path: path.resolve(__dirname, ".env.local") });
 
-test("register with password", async ({page}) => {
-    const username = "register-password@example.com"
-    const password = "Password1!"
-    const firstname = "firstname"
-    const lastname = "lastname"
+test("register with password", async ({ page }) => {
+  const username = "register-password@example.com";
+  const password = "Password1!";
+  const firstname = "firstname";
+  const lastname = "lastname";
 
-    await removeUserByUsername(username)
-    await registerWithPassword(page, firstname, lastname, username, password, password)
-    await loginScreenExpect(page, firstname + " " + lastname);
+  await removeUserByUsername(username);
+  await registerWithPassword(page, firstname, lastname, username, password, password);
+  await loginScreenExpect(page, firstname + " " + lastname);
 });
 
-test("register with passkey", async ({page}) => {
-    const username = "register-passkey@example.com"
-    const firstname = "firstname"
-    const lastname = "lastname"
+test("register with passkey", async ({ page }) => {
+  const username = "register-passkey@example.com";
+  const firstname = "firstname";
+  const lastname = "lastname";
 
-    await removeUserByUsername(username)
-    await registerWithPasskey(page, firstname, lastname, username)
-    await loginScreenExpect(page, firstname + " " + lastname);
+  await removeUserByUsername(username);
+  await registerWithPasskey(page, firstname, lastname, username);
+  await loginScreenExpect(page, firstname + " " + lastname);
 });

acceptance/tests/register.ts

@@ -1,18 +1,25 @@
-import {Page} from "@playwright/test";
-import {passkeyRegister} from './passkey';
-import {registerPasswordScreen, registerUserScreenPasskey, registerUserScreenPassword} from './register-screen';
+import { Page } from "@playwright/test";
+import { passkeyRegister } from "./passkey";
+import { registerPasswordScreen, registerUserScreenPasskey, registerUserScreenPassword } from "./register-screen";
 
-export async function registerWithPassword(page: Page, firstname: string, lastname: string, email: string, password1: string, password2: string) {
-    await page.goto('/register');
-    await registerUserScreenPassword(page, firstname, lastname, email)
-    await page.getByTestId('submit-button').click();
-    await registerPasswordScreen(page, password1, password2)
-    await page.getByTestId('submit-button').click();
+export async function registerWithPassword(
+  page: Page,
+  firstname: string,
+  lastname: string,
+  email: string,
+  password1: string,
+  password2: string,
+) {
+  await page.goto("/register");
+  await registerUserScreenPassword(page, firstname, lastname, email);
+  await page.getByTestId("submit-button").click();
+  await registerPasswordScreen(page, password1, password2);
+  await page.getByTestId("submit-button").click();
 }
 
 export async function registerWithPasskey(page: Page, firstname: string, lastname: string, email: string): Promise<string> {
-    await page.goto('/register');
-    await registerUserScreenPasskey(page, firstname, lastname, email)
-    await page.getByTestId('submit-button').click();
-    return await passkeyRegister(page)
+  await page.goto("/register");
+  await registerUserScreenPasskey(page, firstname, lastname, email);
+  await page.getByTestId("submit-button").click();
+  return await passkeyRegister(page);
 }

acceptance/tests/user.ts

@@ -1,196 +1,195 @@
+import { Page } from "@playwright/test";
 import fetch from "node-fetch";
-import {Page} from "@playwright/test";
-import {registerWithPasskey} from "./register";
-import {getUserByUsername, removeUser} from './zitadel';
+import { registerWithPasskey } from "./register";
+import { getUserByUsername, removeUser } from "./zitadel";
 
 export interface userProps {
-    email: string;
-    firstName: string;
-    lastName: string;
-    organization: string;
-    password: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  organization: string;
+  password: string;
 }
 
 class User {
-    private readonly props: userProps;
-    private user: string;
+  private readonly props: userProps;
+  private user: string;
 
-    constructor(userProps: userProps) {
-        this.props = userProps;
+  constructor(userProps: userProps) {
+    this.props = userProps;
+  }
+
+  async ensure(page: Page) {
+    await this.remove();
+
+    const body = {
+      username: this.props.email,
+      organization: {
+        orgId: this.props.organization,
+      },
+      profile: {
+        givenName: this.props.firstName,
+        familyName: this.props.lastName,
+      },
+      email: {
+        email: this.props.email,
+        isVerified: true,
+      },
+      password: {
+        password: this.props.password!,
+      },
+    };
+
+    const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/human", {
+      method: "POST",
+      body: JSON.stringify(body),
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!,
+      },
+    });
+    if (response.statusCode >= 400 && response.statusCode != 409) {
+      const error = "HTTP Error: " + response.statusCode + " - " + response.statusMessage;
+      console.error(error);
+      throw new Error(error);
     }
+    return;
+  }
 
-    async ensure(page: Page) {
-        await this.remove()
-
-        const body = {
-            username: this.props.email,
-            organization: {
-                orgId: this.props.organization
-            },
-            profile: {
-                givenName: this.props.firstName,
-                familyName: this.props.lastName,
-            },
-            email: {
-                email: this.props.email,
-                isVerified: true,
-            },
-            password: {
-                password: this.props.password!,
-            }
-        }
-
-        const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/human", {
-            method: 'POST',
-            body: JSON.stringify(body),
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
-            }
-        });
-        if (response.statusCode >= 400 && response.statusCode != 409) {
-            const error = 'HTTP Error: ' + response.statusCode + ' - ' + response.statusMessage;
-            console.error(error);
-            throw new Error(error);
-        }
-        return
+  async remove() {
+    const resp = await getUserByUsername(this.getUsername());
+    if (!resp || !resp.result || !resp.result[0]) {
+      return;
     }
+    await removeUser(resp.result[0].userId);
+    return;
+  }
 
-    async remove() {
-        const resp = await getUserByUsername(this.getUsername())
-        if (!resp || !resp.result || !resp.result[0]) {
-            return
-        }
-        await removeUser(resp.result[0].userId)
-        return
-    }
+  public setUserId(userId: string) {
+    this.user = userId;
+  }
 
-    public setUserId(userId: string) {
-        this.user = userId
-    }
+  public getUserId() {
+    return this.user;
+  }
 
-    public getUserId() {
-        return this.user;
-    }
+  public getUsername() {
+    return this.props.email;
+  }
 
-    public getUsername() {
-        return this.props.email;
-    }
+  public getPassword() {
+    return this.props.password;
+  }
 
-    public getPassword() {
-        return this.props.password;
-    }
+  public getFirstname() {
+    return this.props.firstName;
+  }
 
-    public getFirstname() {
-        return this.props.firstName
-    }
+  public getLastname() {
+    return this.props.lastName;
+  }
 
-    public getLastname() {
-        return this.props.lastName
-    }
-
-    public getFullName() {
-        return this.props.firstName + " " + this.props.lastName
-    }
+  public getFullName() {
+    return this.props.firstName + " " + this.props.lastName;
+  }
 }
 
-export class PasswordUser extends User {
-}
+export class PasswordUser extends User {}
 
 export enum OtpType {
-    sms = "sms",
-    email = "email",
+  sms = "sms",
+  email = "email",
 }
 
 export interface otpUserProps {
-    email: string;
-    firstName: string;
-    lastName: string;
-    organization: string;
-    password: string,
-    type: OtpType,
+  email: string;
+  firstName: string;
+  lastName: string;
+  organization: string;
+  password: string;
+  type: OtpType;
 }
 
 export class PasswordUserWithOTP extends User {
-    private type: OtpType
-    private code: string
+  private type: OtpType;
+  private code: string;
 
-    constructor(props: otpUserProps) {
-        super({
-            email: props.email,
-            firstName: props.firstName,
-            lastName: props.lastName,
-            organization: props.organization,
-            password: props.password,
-        })
-        this.type = props.type
+  constructor(props: otpUserProps) {
+    super({
+      email: props.email,
+      firstName: props.firstName,
+      lastName: props.lastName,
+      organization: props.organization,
+      password: props.password,
+    });
+    this.type = props.type;
+  }
+
+  async ensure(page: Page) {
+    await super.ensure(page);
+
+    let url = "otp_";
+    switch (this.type) {
+      case OtpType.sms:
+        url = url + "sms";
+      case OtpType.email:
+        url = url + "email";
     }
 
-    async ensure(page: Page) {
-        await super.ensure(page)
-
-        let url = "otp_"
-        switch (this.type) {
-            case OtpType.sms:
-                url = url + "sms"
-            case OtpType.email:
-                url = url + "email"
-        }
-
-        const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/" + this.getUserId() + "/" + url, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
-            }
-        });
-        if (response.statusCode >= 400 && response.statusCode != 409) {
-            const error = 'HTTP Error: ' + response.statusCode + ' - ' + response.statusMessage;
-            console.error(error);
-            throw new Error(error);
-        }
-
-        // TODO: get code from SMS or Email provider
-        this.code = ""
-        return
+    const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/" + this.getUserId() + "/" + url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!,
+      },
+    });
+    if (response.statusCode >= 400 && response.statusCode != 409) {
+      const error = "HTTP Error: " + response.statusCode + " - " + response.statusMessage;
+      console.error(error);
+      throw new Error(error);
     }
 
-    public getCode() {
-        return this.code
-    }
+    // TODO: get code from SMS or Email provider
+    this.code = "";
+    return;
+  }
+
+  public getCode() {
+    return this.code;
+  }
 }
 
 export interface passkeyUserProps {
-    email: string;
-    firstName: string;
-    lastName: string;
-    organization: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  organization: string;
 }
 
 export class PasskeyUser extends User {
-    private authenticatorId: string
+  private authenticatorId: string;
 
-    constructor(props: passkeyUserProps) {
-        super({
-            email: props.email,
-            firstName: props.firstName,
-            lastName: props.lastName,
-            organization: props.organization,
-            password: ""
-        })
-    }
+  constructor(props: passkeyUserProps) {
+    super({
+      email: props.email,
+      firstName: props.firstName,
+      lastName: props.lastName,
+      organization: props.organization,
+      password: "",
+    });
+  }
 
-    public async ensure(page: Page) {
-        await this.remove()
-        const authId = await registerWithPasskey(page, this.getFirstname(), this.getLastname(), this.getUsername())
-        this.authenticatorId = authId
-    }
+  public async ensure(page: Page) {
+    await this.remove();
+    const authId = await registerWithPasskey(page, this.getFirstname(), this.getLastname(), this.getUsername());
+    this.authenticatorId = authId;
+  }
 
-    public async remove() {
-        await super.remove()
-    }
+  public async remove() {
+    await super.remove();
+  }
 
-    public getAuthenticatorId(): string {
-        return this.authenticatorId
-    }
+  public getAuthenticatorId(): string {
+    return this.authenticatorId;
+  }
 }

acceptance/tests/username-passkey.spec.ts

@@ -1,26 +1,26 @@
-import {test as base} from "@playwright/test";
-import path from 'path';
-import dotenv from 'dotenv';
-import {PasskeyUser} from "./user";
-import {loginScreenExpect, loginWithPasskey} from "./login";
+import { test as base } from "@playwright/test";
+import dotenv from "dotenv";
+import path from "path";
+import { loginScreenExpect, loginWithPasskey } from "./login";
+import { PasskeyUser } from "./user";
 
 // Read from ".env" file.
-dotenv.config({path: path.resolve(__dirname, '.env.local')});
+dotenv.config({ path: path.resolve(__dirname, ".env.local") });
 
 const test = base.extend<{ user: PasskeyUser }>({
-    user: async ({page}, use) => {
-        const user = new PasskeyUser({
-            email: "passkey@example.com",
-            firstName: "first",
-            lastName: "last",
-            organization: "",
-        });
-        await user.ensure(page);
-        await use(user);
-    },
+  user: async ({ page }, use) => {
+    const user = new PasskeyUser({
+      email: "passkey@example.com",
+      firstName: "first",
+      lastName: "last",
+      organization: "",
+    });
+    await user.ensure(page);
+    await use(user);
+  },
 });
 
-test("username and passkey login", async ({user, page}) => {
-    await loginWithPasskey(page, user.getAuthenticatorId(), user.getUsername())
-    await loginScreenExpect(page, user.getFullName());
+test("username and passkey login", async ({ user, page }) => {
+  await loginWithPasskey(page, user.getAuthenticatorId(), user.getUsername());
+  await loginScreenExpect(page, user.getFullName());
 });

acceptance/tests/username-password-changed.spec.ts

@@ -1,41 +1,41 @@
-import {test as base} from "@playwright/test";
-import {PasswordUser} from './user';
-import path from 'path';
-import dotenv from 'dotenv';
-import {loginScreenExpect, loginWithPassword} from "./login";
-import {changePassword, startChangePassword} from "./password";
-import {changePasswordScreen, changePasswordScreenExpect} from "./password-screen";
+import { test as base } from "@playwright/test";
+import dotenv from "dotenv";
+import path from "path";
+import { loginScreenExpect, loginWithPassword } from "./login";
+import { changePassword, startChangePassword } from "./password";
+import { changePasswordScreen, changePasswordScreenExpect } from "./password-screen";
+import { PasswordUser } from "./user";
 
 // Read from ".env" file.
-dotenv.config({path: path.resolve(__dirname, '.env.local')});
+dotenv.config({ path: path.resolve(__dirname, ".env.local") });
 
 const test = base.extend<{ user: PasswordUser }>({
-    user: async ({page}, use) => {
-        const user = new PasswordUser({
-            email: "password-changed@example.com",
-            firstName: "first",
-            lastName: "last",
-            password: "Password1!",
-            organization: "",
-        });
-        await user.ensure(page);
-        await use(user);
-    },
+  user: async ({ page }, use) => {
+    const user = new PasswordUser({
+      email: "password-changed@example.com",
+      firstName: "first",
+      lastName: "last",
+      password: "Password1!",
+      organization: "",
+    });
+    await user.ensure(page);
+    await use(user);
+  },
 });
 
-test("username and password changed login", async ({user, page}) => {
-    const changedPw = "ChangedPw1!"
-    await loginWithPassword(page, user.getUsername(), user.getPassword())
-    await changePassword(page, user.getUsername(), changedPw)
-    await loginWithPassword(page, user.getUsername(), changedPw)
-    await loginScreenExpect(page, user.getFullName());
+test("username and password changed login", async ({ user, page }) => {
+  const changedPw = "ChangedPw1!";
+  await loginWithPassword(page, user.getUsername(), user.getPassword());
+  await changePassword(page, user.getUsername(), changedPw);
+  await loginWithPassword(page, user.getUsername(), changedPw);
+  await loginScreenExpect(page, user.getFullName());
 });
 
-test("password not with desired complexity", async ({user, page}) => {
-    const changedPw1 = "change"
-    const changedPw2 = "chang"
-    await loginWithPassword(page, user.getUsername(), user.getPassword())
-    await startChangePassword(page, user.getUsername());
-    await changePasswordScreen(page, changedPw1, changedPw2)
-    await changePasswordScreenExpect(page, changedPw1, changedPw2, false, false, false, false, true, false)
+test("password not with desired complexity", async ({ user, page }) => {
+  const changedPw1 = "change";
+  const changedPw2 = "chang";
+  await loginWithPassword(page, user.getUsername(), user.getPassword());
+  await startChangePassword(page, user.getUsername());
+  await changePasswordScreen(page, changedPw1, changedPw2);
+  await changePasswordScreenExpect(page, changedPw1, changedPw2, false, false, false, false, true, false);
 });

acceptance/tests/username-password-otp_sms.spec.ts

@@ -1,36 +1,32 @@
-import {test as base} from "@playwright/test";
-import {OtpType, PasswordUserWithOTP} from './user';
-import path from 'path';
-import dotenv from 'dotenv';
-import {loginScreenExpect, loginWithPassword} from "./login";
-import {startSink} from "./otp";
+import { test as base } from "@playwright/test";
+import dotenv from "dotenv";
+import path from "path";
+import { loginScreenExpect, loginWithPassword } from "./login";
+import { OtpType, PasswordUserWithOTP } from "./user";
 
 // Read from ".env" file.
-dotenv.config({path: path.resolve(__dirname, '.env.local')});
+dotenv.config({ path: path.resolve(__dirname, ".env.local") });
 
 const test = base.extend<{ user: PasswordUserWithOTP }>({
-    user: async ({page}, use) => {
-        const user = new PasswordUserWithOTP({
-            email: "otp_sms@example.com",
-            firstName: "first",
-            lastName: "last",
-            password: "Password1!",
-            organization: "",
-            type: OtpType.sms,
-        });
+  user: async ({ page }, use) => {
+    const user = new PasswordUserWithOTP({
+      email: "otp_sms@example.com",
+      firstName: "first",
+      lastName: "last",
+      password: "Password1!",
+      organization: "",
+      type: OtpType.sms,
+    });
 
-        await user.ensure(page);
-        await use(user);
-    },
+    await user.ensure(page);
+    await use(user);
+  },
 });
 
-test("username, password and otp login", async ({user, page}) => {
-    //const server = startSink()
-    await loginWithPassword(page, user.getUsername(), user.getPassword())
+test("username, password and otp login", async ({ user, page }) => {
+  //const server = startSink()
+  await loginWithPassword(page, user.getUsername(), user.getPassword());
 
-
-    await loginScreenExpect(page, user.getFullName());
-    //server.close()
+  await loginScreenExpect(page, user.getFullName());
+  //server.close()
 });
-
-

acceptance/tests/zitadel.ts

@@ -1,50 +1,52 @@
 import fetch from "node-fetch";
 
 export async function removeUserByUsername(username: string) {
-    const resp = await getUserByUsername(username)
-    if (!resp || !resp.result || !resp.result[0]) {
-        return
-    }
-    await removeUser(resp.result[0].userId)
+  const resp = await getUserByUsername(username);
+  if (!resp || !resp.result || !resp.result[0]) {
+    return;
+  }
+  await removeUser(resp.result[0].userId);
 }
 
 export async function removeUser(id: string) {
-    const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/" + id, {
-        method: 'DELETE',
-        headers: {
-            'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
-        }
-    });
-    if (response.statusCode >= 400 && response.statusCode != 404) {
-        const error = 'HTTP Error: ' + response.statusCode + ' - ' + response.statusMessage;
-        console.error(error);
-        throw new Error(error);
-    }
-    return
+  const response = await fetch(process.env.ZITADEL_API_URL! + "/v2/users/" + id, {
+    method: "DELETE",
+    headers: {
+      Authorization: "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!,
+    },
+  });
+  if (response.statusCode >= 400 && response.statusCode != 404) {
+    const error = "HTTP Error: " + response.statusCode + " - " + response.statusMessage;
+    console.error(error);
+    throw new Error(error);
+  }
+  return;
 }
 
 export async function getUserByUsername(username: string) {
-    const listUsersBody = {
-        queries: [{
-            userNameQuery: {
-                userName: username,
-            }
-        }]
-    }
-    const jsonBody = JSON.stringify(listUsersBody)
-    const registerResponse = await fetch(process.env.ZITADEL_API_URL! + "/v2/users", {
-        method: 'POST',
-        body: jsonBody,
-        headers: {
-            'Content-Type': 'application/json',
-            'Authorization': "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!
-        }
-    });
-    if (registerResponse.statusCode >= 400) {
-        const error = 'HTTP Error: ' + registerResponse.statusCode + ' - ' + registerResponse.statusMessage;
-        console.error(error);
-        throw new Error(error);
-    }
-    const respJson = await registerResponse.json()
-    return respJson
-}
+  const listUsersBody = {
+    queries: [
+      {
+        userNameQuery: {
+          userName: username,
+        },
+      },
+    ],
+  };
+  const jsonBody = JSON.stringify(listUsersBody);
+  const registerResponse = await fetch(process.env.ZITADEL_API_URL! + "/v2/users", {
+    method: "POST",
+    body: jsonBody,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: "Bearer " + process.env.ZITADEL_SERVICE_USER_TOKEN!,
+    },
+  });
+  if (registerResponse.statusCode >= 400) {
+    const error = "HTTP Error: " + registerResponse.statusCode + " - " + registerResponse.statusMessage;
+    console.error(error);
+    throw new Error(error);
+  }
+  const respJson = await registerResponse.json();
+  return respJson;
+}