demo-dev 0.0.1-alpha.0

package/src/auth/bootstrap.ts

@@ -0,0 +1,72 @@
+import { mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import { chromium, type Locator, type Page } from "playwright";
+import type { ActionTarget } from "../types.js";
+import type { ProjectAuthConfig } from "../config/project.js";
+
+export interface BootstrapAuthOptions {
+  baseUrl: string;
+  email: string;
+  password: string;
+  outputPath: string;
+  auth?: ProjectAuthConfig;
+}
+
+const resolveLocator = (page: Page, target: ActionTarget): Locator => {
+  switch (target.strategy) {
+    case "label":
+      return page.getByLabel(target.value, { exact: target.exact });
+    case "text":
+      return page.getByText(target.value, { exact: target.exact });
+    case "placeholder":
+      return page.getByPlaceholder(target.value, { exact: target.exact });
+    case "testId":
+      return page.getByTestId(target.value);
+    case "css":
+      return page.locator(target.value);
+    case "role":
+      return page.getByRole(target.role as never, {
+        name: target.name,
+        exact: target.exact,
+      });
+  }
+};
+
+export const bootstrapAuth = async (options: BootstrapAuthOptions) => {
+  const browser = await chromium.launch({ headless: true });
+  const auth = options.auth;
+  const loginPath = auth?.loginPath ?? "/login";
+  const emailTarget: ActionTarget = auth?.emailTarget ?? { strategy: "css", value: "#email" };
+  const passwordTarget: ActionTarget = auth?.passwordTarget ?? { strategy: "css", value: "#password" };
+  const submitTarget: ActionTarget = auth?.submitTarget ?? { strategy: "role", role: "button", name: "Login" };
+
+  try {
+    const context = await browser.newContext();
+    const page = await context.newPage();
+    await page.goto(new URL(loginPath, options.baseUrl).toString(), { waitUntil: "networkidle" });
+
+    await resolveLocator(page, emailTarget).first().fill(options.email);
+    await resolveLocator(page, passwordTarget).first().fill(options.password);
+    await resolveLocator(page, submitTarget).first().click();
+
+    await page.waitForLoadState("networkidle").catch(() => undefined);
+    await page.waitForTimeout(auth?.postSubmitWaitMs ?? 1200);
+
+    if (auth?.successUrlPattern) {
+      await page.waitForURL(auth.successUrlPattern, { timeout: 15000 });
+    } else {
+      await page.waitForURL((url) => !url.toString().includes(loginPath), { timeout: 15000 });
+    }
+
+    await mkdir(dirname(options.outputPath), { recursive: true });
+    await context.storageState({ path: options.outputPath });
+
+    return {
+      storageStatePath: options.outputPath,
+      url: page.url(),
+      title: await page.title(),
+    };
+  } finally {
+    await browser.close();
+  }
+};

package/src/browser/session.ts

@@ -0,0 +1,43 @@
+import { access, mkdir } from "node:fs/promises";
+import { dirname } from "node:path";
+import type { BrowserContextOptions, Page } from "playwright";
+
+const fileExists = async (path: string) => {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+export interface SessionConfig {
+  storageStatePath?: string;
+  saveStorageStatePath?: string;
+}
+
+export const resolveSessionConfig = (outputDir: string): SessionConfig => {
+  const storageStatePath = process.env.DEMO_STORAGE_STATE;
+  const saveStorageStatePath = process.env.DEMO_SAVE_STORAGE_STATE ?? `${outputDir}/storage-state.json`;
+  return { storageStatePath, saveStorageStatePath };
+};
+
+export const getContextOptionsWithSession = async (
+  contextOptions: BrowserContextOptions,
+  session: SessionConfig,
+): Promise<BrowserContextOptions> => {
+  if (session.storageStatePath && (await fileExists(session.storageStatePath))) {
+    return {
+      ...contextOptions,
+      storageState: session.storageStatePath,
+    };
+  }
+
+  return contextOptions;
+};
+
+export const persistSessionState = async (page: Page, session: SessionConfig) => {
+  if (!session.saveStorageStatePath) return;
+  await mkdir(dirname(session.saveStorageStatePath), { recursive: true }).catch(() => undefined);
+  await page.context().storageState({ path: session.saveStorageStatePath }).catch(() => undefined);
+};