@qaick/http-executor 0.1.0-alpha.1 → 0.1.0-alpha.2

package/dist/http-action-executor.d.ts

@@ -13,6 +13,34 @@ export interface HttpTransport {
         timeoutMs?: number;
     }): Promise<HttpResponse>;
 }
+export interface HttpCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    hostOnly: boolean;
+    secure: boolean;
+    expiresAt?: number;
+}
+/** Cookie state shared by HTTP Actions during one execution. */
+export declare class HttpCookieJar {
+    private readonly cookies;
+    store(url: string, setCookie: string | string[] | undefined): void;
+    header(url: string): string | undefined;
+}
+/** HTTP-specific session boundary. One instance must be created per QAick execution. */
+export declare class HttpExecutionSession implements HttpTransport {
+    private readonly transport;
+    readonly cookies: HttpCookieJar;
+    constructor(transport: HttpTransport, cookies?: HttpCookieJar);
+    request(url: string, init: {
+        method: string;
+        body?: unknown;
+        headers?: Record<string, string>;
+        signal: AbortSignal;
+        timeoutMs?: number;
+    }): Promise<HttpResponse>;
+}
 export type HttpActionErrorCode = 'HTTP_INVALID_URL' | 'HTTP_REQUEST_CONSTRUCTION_ERROR' | 'HTTP_ABORTED' | 'HTTP_TIMEOUT' | 'HTTP_NETWORK_ERROR' | 'HTTP_RESPONSE_PARSE_ERROR' | 'HTTP_STATUS_ERROR';
 export declare class HttpActionError extends Error {
     readonly code: HttpActionErrorCode;

package/dist/http-action-executor.js

@@ -1,3 +1,59 @@
+/** Cookie state shared by HTTP Actions during one execution. */
+export class HttpCookieJar {
+    cookies = new Map();
+    store(url, setCookie) {
+        if (!setCookie)
+            return;
+        const parsedUrl = new URL(url);
+        for (const header of (Array.isArray(setCookie) ? setCookie : splitSetCookieHeader(setCookie))) {
+            const cookie = parseSetCookie(header, parsedUrl);
+            if (!cookie)
+                continue;
+            const key = cookieKey(cookie);
+            if (cookie.expiresAt !== undefined && cookie.expiresAt <= Date.now())
+                this.cookies.delete(key);
+            else
+                this.cookies.set(key, cookie);
+        }
+    }
+    header(url) {
+        const parsedUrl = new URL(url);
+        const now = Date.now();
+        const applicable = [];
+        for (const [key, cookie] of this.cookies) {
+            if (cookie.expiresAt !== undefined && cookie.expiresAt <= now) {
+                this.cookies.delete(key);
+                continue;
+            }
+            if (!cookieMatches(cookie, parsedUrl))
+                continue;
+            applicable.push(cookie);
+        }
+        applicable.sort((left, right) => right.path.length - left.path.length);
+        return applicable.length ? applicable.map(cookie => `${cookie.name}=${cookie.value}`).join('; ') : undefined;
+    }
+}
+/** HTTP-specific session boundary. One instance must be created per QAick execution. */
+export class HttpExecutionSession {
+    transport;
+    cookies;
+    constructor(transport, cookies = new HttpCookieJar()) {
+        this.transport = transport;
+        this.cookies = cookies;
+    }
+    async request(url, init) {
+        const headers = { ...(init.headers ?? {}) };
+        const cookieHeader = headerName(headers, 'cookie');
+        const managed = this.cookies.header(url);
+        const merged = mergeCookieHeaders(cookieHeader ? headers[cookieHeader] : undefined, managed);
+        if (merged)
+            headers[cookieHeader ?? 'cookie'] = merged;
+        const response = await this.transport.request(url, { ...init, headers });
+        const setCookie = response.headers && headerValue(response.headers, 'set-cookie');
+        this.cookies.store(url, setCookie);
+        return response;
+    }
+}
 export class HttpActionError extends Error {
     code;
     details;
@@ -8,6 +64,83 @@ export class HttpActionError extends Error {
         this.name = 'HttpActionError';
     }
 }
+function headerName(headers, expected) {
+    return Object.keys(headers).find(name => name.toLowerCase() === expected);
+}
+function headerValue(headers, expected) {
+    const name = Object.keys(headers).find(key => key.toLowerCase() === expected);
+    return name ? headers[name] : undefined;
+}
+function mergeCookieHeaders(explicit, managed) {
+    const cookies = new Map();
+    for (const value of [managed, explicit]) {
+        for (const item of value?.split(';') ?? []) {
+            const separator = item.indexOf('=');
+            if (separator <= 0)
+                continue;
+            cookies.set(item.slice(0, separator).trim(), item.slice(separator + 1).trim());
+        }
+    }
+    return cookies.size ? [...cookies.entries()].map(([name, value]) => `${name}=${value}`).join('; ') : undefined;
+}
+function splitSetCookieHeader(value) {
+    return value.split(/\r?\n|,(?=\s*[^;,=\s]+=[^;,]*)/).map(item => item.trim()).filter(Boolean);
+}
+function parseSetCookie(header, requestUrl) {
+    const parts = header.split(';').map(part => part.trim());
+    const pair = parts.shift();
+    if (!pair)
+        return undefined;
+    const separator = pair.indexOf('=');
+    if (separator <= 0)
+        return undefined;
+    const name = pair.slice(0, separator).trim();
+    const value = pair.slice(separator + 1).trim();
+    let domain = requestUrl.hostname.toLowerCase();
+    let hostOnly = true;
+    let path = defaultCookiePath(requestUrl.pathname);
+    let secure = false;
+    let expiresAt;
+    for (const attribute of parts) {
+        const [rawName, ...rawValue] = attribute.split('=');
+        const attributeName = rawName.trim().toLowerCase();
+        const attributeValue = rawValue.join('=').trim();
+        if (attributeName === 'domain' && attributeValue) {
+            domain = attributeValue.replace(/^\./, '').toLowerCase();
+            hostOnly = false;
+        }
+        else if (attributeName === 'path' && attributeValue.startsWith('/'))
+            path = attributeValue;
+        else if (attributeName === 'secure')
+            secure = true;
+        else if (attributeName === 'max-age') {
+            const seconds = Number(attributeValue);
+            if (Number.isFinite(seconds))
+                expiresAt = Date.now() + seconds * 1000;
+        }
+        else if (attributeName === 'expires') {
+            const timestamp = Date.parse(attributeValue);
+            if (Number.isFinite(timestamp))
+                expiresAt = timestamp;
+        }
+    }
+    return { name, value, domain, path, hostOnly, secure, ...(expiresAt !== undefined ? { expiresAt } : {}) };
+}
+function defaultCookiePath(pathname) {
+    if (!pathname || !pathname.startsWith('/'))
+        return '/';
+    const lastSlash = pathname.lastIndexOf('/');
+    return lastSlash <= 0 ? '/' : pathname.slice(0, lastSlash);
+}
+function cookieMatches(cookie, url) {
+    if (cookie.secure && url.protocol !== 'https:')
+        return false;
+    const host = url.hostname.toLowerCase();
+    if (cookie.hostOnly ? host !== cookie.domain : !(host === cookie.domain || host.endsWith(`.${cookie.domain}`)))
+        return false;
+    return url.pathname === cookie.path || url.pathname.startsWith(cookie.path.endsWith('/') ? cookie.path : `${cookie.path}/`);
+}
+function cookieKey(cookie) { return `${cookie.name};${cookie.domain};${cookie.path}`; }
 export class FetchHttpTransport {
     async request(url, init) {
         const headers = { ...init.headers };
@@ -25,7 +158,7 @@ export class FetchHttpTransport {
         const timeout = init.timeoutMs === undefined ? undefined : setTimeout(() => controller.abort(), init.timeoutMs);
         let response;
         try {
-            response = await fetch(url, { method: init.method, headers, body, signal: controller.signal });
+            response = await fetch(url, { method: init.method, headers, body, signal: controller.signal, credentials: 'include' });
         }
         catch (error) {
             if (init.signal.aborted)

package/package.json

@@ -1,19 +1,50 @@
 {
   "name": "@qaick/http-executor",
-  "version": "0.1.0-alpha.1",
+  "version": "0.1.0-alpha.2",
   "description": "Reusable QAick HTTP Action execution with browser and native Node transports.",
-  "keywords": ["qaick", "http", "executor", "automation"],
+  "keywords": [
+    "qaick",
+    "http",
+    "executor",
+    "automation"
+  ],
   "type": "module",
-  "files": ["dist", "README.md"],
-  "engines": { "node": ">=20" },
-  "publishConfig": { "access": "public", "tag": "alpha" },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "alpha"
+  },
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
-    "./node": { "types": "./dist/node-http-transport.d.ts", "import": "./dist/node-http-transport.js" }
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node-http-transport.d.ts",
+      "import": "./dist/node-http-transport.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "peerDependencies": {
+    "@qaick/executor": ">=0.1.0-alpha.1 <0.2.0"
   },
-  "scripts": { "build": "tsc -p tsconfig.json", "typecheck": "tsc -p tsconfig.json --noEmit", "test": "vitest run", "prepublishOnly": "npm run build" },
-  "peerDependencies": { "@qaick/executor": ">=0.1.0-alpha.1 <0.2.0" },
-  "devDependencies": { "@qaick/executor": "file:../QAICK_Executor", "@types/node": "^24.13.3", "typescript": "~6.0.2", "vitest": "^5.0.1" }
+  "devDependencies": {
+    "@qaick/executor": "0.1.0-alpha.1",
+    "@types/node": "^24.13.3",
+    "typescript": "~6.0.2",
+    "vitest": "^5.0.1"
+  }
 }