@jd-data-limited/easy-fm 4.1.15 → 5.0.0-beta.2

package/README.md

@@ -1,229 +1,93 @@
-# Introduction
-
-A FileMaker Data API client for NodeJS
-
-easy-fm is a Node.js module that allows you to interact with
-a FileMaker database stored on a FileMaker server
-or FileMaker Cloud. This module interacts with your server using the
-FileMaker Data API.
-
-# Contents
-
-<!-- TOC -->
-* [Introduction](#introduction)
-* [Contents](#contents)
-* [Installation](#installation)
-* [Usage](#usage)
-  * [Connecting to a database](#connecting-to-a-database)
-  * [An important note about timezones](#an-important-note-about-timezones)
-  * [Getting records](#getting-records)
-    * [Fetch a range of records](#fetch-a-range-of-records)
-    * [Searching for records](#searching-for-records)
-    * [Fetch a record using its record ID (NOT RECOMMENDED)](#fetch-a-record-using-its-record-id-not-recommended)
-    * [Create a record](#create-a-record)
-    * [Modify a record](#modify-a-record)
-* [Field names](#field-names)
-* [Portal names](#portal-names)
-* [Typescript Implementation](#typescript-implementation)
-<!-- TOC -->
-
-# Installation
-
-```npm
-npm install @jd-data-limited/easy-fm --save
-```
+# easy-fm
 
-easy-fm also requires the following to be configured within your FileMaker enviroment:
+`easy-fm` is a Node.js client for Claris FileMaker Data API.
 
-1. Enable the FileMaker Data API from the server's admin console. This setting is located
-   in `Connectors > FileMaker Data API`.
-2. Create a FileMaker database account for easy-fm to use. This account must have the 'Access via FileMaker Data API (
-   fmrest)' extended privilege
+It helps you connect Node.js code to FileMaker Server or FileMaker Cloud so you can fetch records, run finds, edit data, work with portals, and run scripts using a typed JavaScript or TypeScript API.
 
----
+## Requirements
 
-# Usage
+- Node.js `22+`
+- FileMaker Data API enabled
+- account with `fmrest` privilege
+- at least one accessible layout
 
-## Connecting to a database
+Claris Data API reference:
+[`help.claris.com/en/data-api-guide/content/index.html`](https://help.claris.com/en/data-api-guide/content/index.html)
 
-```javascript
-import FMHost from "easy-fm"; // Import the module
-const host = new FMHost("https://<your-servers-address>")
-const database = host.database({
-    database: "your_database.fmp12",
-    credentials: {
-        method: "filemaker",
-        username: "<username>",
-        password: "<password>"
-    },
-    externalSources: []
-})
+## Install
 
-// OPTIONAL - EasyFM will automatically attempt a login anyway when you perform your first operation
-database.login().then(() => {
-
-})
+```sh
+npm install @jd-data-limited/easy-fm
 ```
 
-> **NOTE:** A connection will only give you access to the layouts in the database you are connected to, and not the
-> layouts
-> in
-> any external sources that you have specified.
->
-> If you need to interact with layouts on multiple databases, you need to open a separate connection for each.
+## Quick Start
 
-## An important note about timezones
+```ts
+import {FMHost} from "@jd-data-limited/easy-fm"
 
-Although it is recommended, timestamps in FileMaker databases are not always stored in UTC time. To account for this,
-EasyFM allows you to specify a function/method that determines the server's current timezone.
-EasyFM will use this timezone offset to convert timestamps to and from JavaScript Date objects.
-
-```typescript
-import FMHost from "easy-fm";
-import {type Moment} from 'moment'
-
-const host = new FMHost("https://<your-servers-address>", (moment: Moment) => {
+const host = new FMHost("https://example.com")
 
+const database = host.database({
+  database: "Contacts",
+  credentials: {
+    method: "filemaker",
+    username: "api-user",
+    password: "secret"
+  },
+  externalSources: []
 })
-```
-
-## Getting records
 
-One of (if not the) most common interactions you'll need to use is fetching records.
+const layout = database.layout("Contacts_API")
+const records = await layout.records.list({
+  portals: {},
+  limit: 25
+}).fetch()
 
-### Fetch a range of records
-
-```javascript
-let layout = database.getLayout("Your layout name")
-let query = layout.records.list({
-    portals: {
-        test: {limit: 10, offset: 1} // Include results from the 'test' portal
-    },
-    limit: 10, // Limit result set to 10 records...
-    offset: 30 // ...starting from the 30th record
-})
-
-let records = await query.fetch()
-console.log(records)
+for (const record of records) {
+  console.log(record.fields.FirstName.value, record.fields.LastName.value)
+}
 ```
 
-### Searching for records
+## Important Notes
 
-Searching for records uses the same syntax as above, but with additional steps to add your search parameters.
+- FileMaker Data API is layout-based, so fields and portals must be available on the layout you use.
+- Portal data is not fetched unless you request it.
+- `recordId` and `modId` are internal FileMaker IDs. Avoid treating `recordId` as a business ID; `modId` can still be useful for change or concurrency checks.
+- Date and timestamp formatting follows the host timezone rules you configure, with defaults chosen to better match FileMaker UI expectations.
 
-```javascript
-let layout = database.getLayout("Your layout name")
-let query = layout.records.list({
-    portals: {
-        test: {limit: 10, offset: 1} // Include results from the 'test' portal
-    },
-    limit: 10, // Limit result set to 10 records...
-    offset: 30 // ...starting from the 30th record
-})
+## Documentation
 
-query.addRequest({"GroupID": "=abc"}) // Add a filter
+> Updating from v4 to v5? Check the guide here; [`docs/upgrade-to-v5.md`](./docs/upgrade-to-v5.md)
 
-let records = await query.fetch()
-console.log(records)
-```
+Start here:
 
-### Fetch a record using its record ID (NOT RECOMMENDED)
+- [`docs/getting-started.md`](./docs/getting-started.md): first connection, first find, closing sessions
+- [`docs/core-concepts.md`](./docs/core-concepts.md): host, database, layout, record, portal, IDs
 
-> Please note: When in FileMaker Pro, a record's ID is returned when using Get(RecordID). If you need to fetch a record
-> using a different ID, use the search method above.
+Task guides:
 
-```javascript
-let layout = database.getLayout("Your layout name")
-let record = await layout.records.get(164)
-console.log(record)
-```
+- [`docs/working-with-records.md`](./docs/working-with-records.md): list, create, update, duplicate, delete, portal rows
+- [`docs/query-recipes.md`](./docs/query-recipes.md): find requests, sorting, paging, script hooks
+- [`docs/authentication-and-sessions.md`](./docs/authentication-and-sessions.md): auth modes, pooling, lifecycle
+- [`docs/typescript-layouts.md`](./docs/typescript-layouts.md): typed layouts and stronger autocomplete
+- [`docs/testGuide.md`](./docs/testGuide.md): local test commands
 
-### Create a record
+API reference:
 
-```javascript
-let layout = database.getLayout("Your layout name")
-let record = await layout.records.create()
+- [`docs_out/index.html`](./docs_out/index.html): generated TypeDoc site
 
-record.fields["Field1"].value = "Value here"
-record.fields["Field2"].value = "Value here"
-record.fields["Field3"].value = "Value here"
+## Build Docs
 
-await record.commit()
+```sh
+npm run docs:build
 ```
 
-### Modify a record
-
-```javascript
-let layout = database.getLayout("Your layout name")
-let record = await layout.records.get(164)
-
-record.fields["Field1"].value = "Value here"
-record.fields["Field2"].value = "Value here"
-record.fields["Field3"].value = "Value here"
+## Test
 
-await record.commit()
+```sh
+npm test
+npm run test:unit
+npm run test:integration
 ```
 
-# Field names
-
-When interacting with FileMaker, it is important to remember how FileMaker field names work.
-
-| Field name format             | Use when....                                                                                        |
-|-------------------------------|-----------------------------------------------------------------------------------------------------|
-| `FieldName`                   | Use this when the field you are accessing is in the same table that the layout has been assigned to |
-| `RelatedTableName::FieldName` | Use this when the field **is not** in the same table that the layout has been assigned to           |
-
-> **NOTE:** You will not be able to access any fields that are not on the layout.
-
-# Portal names
-
-> Please read this section carefully if you are working with portals
-
-It is important to note that a portal's name **is not** the same as the name of the table that it links to. The name of
-a
-portal matches the object name it was assigned in FileMaker's layout editor.
-
-> **NOTE**: When no name has been manually assigned to it, it will default to the name of the related table.
-
-# Typescript Implementation
-
-`easy-fm` supports the use of TypeScript. Here's an example of how this works with `easy-fm`:
-
-```typescript
-import FMHost, {Portal, Field, Container} from "@jd-data-limited/easy-fm";
-
-interface UsersLayout {
-    fields: {
-        // Map each field on the layout to a field type.
-        first_name: Field<string>
-        age: Field<number>
-        birthdate: Field<Date>
-        profile_picture: Field<Container>
-        "MyRelatedTable::MyRelatedField": Field<string>
-    },
-    portals: {
-        Files: {
-            "Files::Field1": Field<string>
-        }
-    }
-}
-
-interface DatabaseStructure {
-    layouts: {
-        users: UsersLayout
-    }
-}
-
-const host = new FMHost("https://example_filemaker_server.com")
-const database = host.database<DatabaseStructure>({
-    database: "ExampleDatabase.fmp12",
-    credentials: {method: "filemaker", username: "test", passsword: "test"},
-    externalSources: []
-})
-await database.login()
-
-const layout = database.getLayout("users") // The UsersLayout interface will be automatically applied to all records within this layout
-const record = await layout.records.create()
-record.fields["first_name"].value = "Joe"
-record.fields["age"].value = 38
-```
+Integration tests require a working FileMaker environment and credentials.

package/dist/bin/generateTypes.js

@@ -78,7 +78,7 @@ export async function generateTypesCLI() {
             default: true,
             message: "Verify your server's identity",
             when(previousAnswers) {
-                return previousAnswers.hostname.startsWith('https://');
+                return previousAnswers.hostname?.startsWith('https://');
             }
         },
         {
@@ -98,7 +98,7 @@ export async function generateTypesCLI() {
             mask: '*'
         }
     ]);
-    const HOST = new FMHost(data.hostname, () => data.timezoneOffset, data.verify);
+    const HOST = new FMHost(data.hostname, data.verify);
     const DATABASE = HOST.database({
         database: data.database,
         credentials: {
@@ -108,7 +108,7 @@ export async function generateTypesCLI() {
         },
         externalSources: []
     });
-    await DATABASE.login();
+    // await DATABASE.login()
     // Create file write stream
     const stream = fs.createWriteStream('./types.ts');
     const layouts = await DATABASE.listLayouts();

package/dist/bin/stressSearch.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/bin/stressSearch.js

@@ -0,0 +1,243 @@
+#!/usr/bin/env node
+/*
+ * Copyright (c) 2024. See LICENSE file for more information
+ */
+import { Command, Option } from 'commander';
+import { config } from 'dotenv';
+import FMHost, { query } from '../index.js';
+config();
+function parseIntegerList(value) {
+    return value
+        .split(',')
+        .map(item => parseInt(item.trim(), 10))
+        .filter(item => Number.isFinite(item) && item > 0);
+}
+function percentile(sorted, ratio) {
+    if (sorted.length === 0)
+        return 0;
+    const index = Math.min(sorted.length - 1, Math.max(0, Math.ceil(sorted.length * ratio) - 1));
+    return sorted[index];
+}
+function summarizeDurations(durations, errors, wallClockMs) {
+    const sorted = [...durations].sort((a, b) => a - b);
+    const totalMs = sorted.reduce((sum, item) => sum + item, 0);
+    return {
+        count: sorted.length,
+        errors,
+        totalMs,
+        minMs: sorted[0] ?? 0,
+        maxMs: sorted[sorted.length - 1] ?? 0,
+        p50Ms: percentile(sorted, 0.5),
+        p95Ms: percentile(sorted, 0.95),
+        opsPerSecond: wallClockMs === 0 ? 0 : (sorted.length / wallClockMs) * 1000
+    };
+}
+function formatInteger(value) {
+    return new Intl.NumberFormat('en-US').format(value);
+}
+function formatDuration(value) {
+    return `${value.toFixed(1)} ms`;
+}
+function formatRate(value) {
+    return `${value.toFixed(2)} ops/s`;
+}
+function padCell(value, width, align = 'right') {
+    return align === 'left' ? value.padEnd(width) : value.padStart(width);
+}
+function buildTable(rows) {
+    const headers = ['conc', 'ops', 'errs', 'min', 'p50', 'p95', 'max', 'throughput'];
+    const body = rows.map(({ concurrency, stats }) => [
+        formatInteger(concurrency),
+        formatInteger(stats.count),
+        formatInteger(stats.errors),
+        formatDuration(stats.minMs),
+        formatDuration(stats.p50Ms),
+        formatDuration(stats.p95Ms),
+        formatDuration(stats.maxMs),
+        formatRate(stats.opsPerSecond)
+    ]);
+    const widths = headers.map((header, index) => Math.max(header.length, ...body.map(row => row[index].length)));
+    const headerRow = headers
+        .map((header, index) => padCell(header, widths[index], 'left'))
+        .join('  ');
+    const separatorRow = widths
+        .map(width => '-'.repeat(width))
+        .join('  ');
+    const bodyRows = body.map(row => row
+        .map((cell, index) => padCell(cell, widths[index]))
+        .join('  '));
+    return [headerRow, separatorRow, ...bodyRows].join('\n');
+}
+function printRunSummary(options) {
+    console.log('Stress Search');
+    console.log(`  host: ${options.host}`);
+    console.log(`  database: ${options.database}`);
+    console.log(`  layout: ${options.layout}`);
+    console.log(`  mode: ${options.mode}`);
+    if (options.mode === 'find')
+        console.log(`  search: ${options.field} ${options.operator} ${options.value}`);
+    console.log(`  limit: ${formatInteger(options.limit)}`);
+    console.log(`  iterations/worker: ${formatInteger(options.iterations)}`);
+    console.log(`  warmup/worker: ${formatInteger(options.warmup)}`);
+    console.log(`  concurrency sweep: ${options.concurrencyLevels.join(', ')}`);
+    console.log('  session pool: package default');
+    console.log('');
+}
+function printResultSummary(rows) {
+    if (rows.length === 0)
+        return;
+    const successfulRows = rows.filter(row => row.stats.errors === 0);
+    const throughputRows = successfulRows.length !== 0 ? successfulRows : rows;
+    const latencyRows = successfulRows.length !== 0 ? successfulRows : rows;
+    const bestThroughput = throughputRows.reduce((best, row) => (row.stats.opsPerSecond > best.stats.opsPerSecond ? row : best));
+    const bestP95 = latencyRows.reduce((best, row) => (row.stats.p95Ms < best.stats.p95Ms ? row : best));
+    console.log('');
+    console.log('Summary');
+    console.log(`  best throughput: concurrency=${bestThroughput.concurrency}, ${formatRate(bestThroughput.stats.opsPerSecond)}`);
+    console.log(`  best p95 latency: concurrency=${bestP95.concurrency}, ${formatDuration(bestP95.stats.p95Ms)}`);
+    if (rows.some(row => row.stats.errors !== 0)) {
+        console.log('  note: some runs had errors; best-row picks prefer zero-error runs when available');
+    }
+}
+function formatLiveProgress(concurrency, completed, total, running) {
+    const wallClockMs = performance.now() - running.startedAt;
+    const stats = summarizeDurations(running.durations, running.errors, wallClockMs);
+    return [
+        `conc=${concurrency}`,
+        `progress=${completed}/${total}`,
+        `avg=${formatRate(stats.opsPerSecond)}`,
+        `p50=${formatDuration(stats.p50Ms)}`,
+        `p95=${formatDuration(stats.p95Ms)}`,
+        `errs=${formatInteger(running.errors)}`
+    ].join('  ');
+}
+function printLiveProgress(concurrency, completed, total, running) {
+    const line = formatLiveProgress(concurrency, completed, total, running);
+    process.stdout.write(`\r${line}`);
+    if (completed === total)
+        process.stdout.write('\n');
+}
+function printRunStart(concurrency, iterations, warmup) {
+    console.log(`Run start: conc=${concurrency}, iterations/worker=${iterations}, warmup/worker=${warmup}`);
+}
+function printRunEnd(concurrency, stats) {
+    console.log(`Run done:  conc=${concurrency}, ${formatRate(stats.opsPerSecond)}, p50=${formatDuration(stats.p50Ms)}, p95=${formatDuration(stats.p95Ms)}, errs=${formatInteger(stats.errors)}`);
+    console.log('');
+}
+function buildFindRequest(field, operator, value) {
+    return {
+        [field]: query([operator, ''], value)
+    };
+}
+async function main() {
+    const program = new Command();
+    const argv = process.argv[2] === '--'
+        ? [process.argv[0], process.argv[1], ...process.argv.slice(3)]
+        : process.argv;
+    program
+        .description('Stress-test FileMaker search/list throughput for easy-fm')
+        .requiredOption('--layout <name>', 'layout name to query')
+        .option('--field <name>', 'field to search')
+        .option('--value <value>', 'value to search for')
+        .option('--operator <operator>', 'FileMaker query operator', '=')
+        .option('--mode <mode>', 'find or list', 'find')
+        .option('--limit <number>', 'result limit per request', '100')
+        .option('--iterations <number>', 'operations per worker', '20')
+        .option('--warmup <number>', 'warmup operations per worker', '2')
+        .addOption(new Option('--concurrency <list>', 'comma-separated concurrency levels').default('1,2,4,8'))
+        .option('--debug', 'enable easy-fm debug logging', false);
+    program.parse(argv);
+    const options = program.opts();
+    if (options.mode === 'find' && (!options.field || typeof options.value === 'undefined')) {
+        throw new Error('--field and --value are required when --mode=find');
+    }
+    const host = process.env.FM_DB_HOST;
+    const database = process.env.FM_DB_NAME;
+    const username = process.env.FM_DB_ACCOUNT;
+    const password = process.env.FM_DB_PASSWORD;
+    if (!host || !database || !username || !password) {
+        throw new Error('Missing FM_DB_HOST, FM_DB_NAME, FM_DB_ACCOUNT, or FM_DB_PASSWORD in environment');
+    }
+    const concurrencyLevels = parseIntegerList(options.concurrency);
+    const limit = parseInt(options.limit, 10);
+    const iterations = parseInt(options.iterations, 10);
+    const warmup = parseInt(options.warmup, 10);
+    printRunSummary({
+        mode: options.mode,
+        layout: options.layout,
+        database,
+        host,
+        field: options.field,
+        operator: options.operator,
+        value: options.value,
+        limit,
+        iterations,
+        warmup,
+        concurrencyLevels
+    });
+    const fmHost = new FMHost(host, false);
+    const rows = [];
+    const connection = fmHost.database({
+        database,
+        credentials: {
+            method: 'filemaker',
+            username,
+            password
+        },
+        externalSources: [],
+        debug: options.debug
+    });
+    try {
+        const layout = connection.layout(options.layout);
+        await layout.getLayoutMeta();
+        for (const concurrency of concurrencyLevels) {
+            printRunStart(concurrency, iterations, warmup);
+            const runOperation = async () => {
+                const startedAt = performance.now();
+                try {
+                    const request = layout.records.list({ portals: {}, limit });
+                    if (options.mode === 'find') {
+                        request.addRequest(buildFindRequest(options.field, options.operator, options.value));
+                    }
+                    await request.fetch();
+                    return { durationMs: performance.now() - startedAt, error: false };
+                }
+                catch {
+                    return { durationMs: performance.now() - startedAt, error: true };
+                }
+            };
+            for (let i = 0; i < warmup * concurrency; i++) {
+                await runOperation();
+            }
+            const totalOperations = concurrency * iterations;
+            let completed = 0;
+            const running = {
+                durations: [],
+                errors: 0,
+                startedAt: performance.now()
+            };
+            await Promise.all(Array.from({ length: concurrency }, async () => {
+                for (let i = 0; i < iterations; i++) {
+                    const result = await runOperation();
+                    running.durations.push(result.durationMs);
+                    if (result.error)
+                        running.errors += 1;
+                    completed += 1;
+                    printLiveProgress(concurrency, completed, totalOperations, running);
+                }
+            }));
+            const stats = summarizeDurations(running.durations, running.errors, performance.now() - running.startedAt);
+            rows.push({ concurrency, stats });
+            printRunEnd(concurrency, stats);
+        }
+    }
+    finally {
+        await connection.logout();
+    }
+    console.log(buildTable(rows));
+    printResultSummary(rows);
+}
+void main().catch(error => {
+    console.error(error);
+    process.exitCode = 1;
+});

package/dist/connection/CookieJar.d.ts

@@ -0,0 +1,19 @@
+export declare class CookieJar {
+    #private;
+    static clone(jar: CookieJar): CookieJar;
+    /**
+     * Parses a Set-Cookie header value and adds it to the jar
+     * Expected format: <name>=<value>; Attribute; Attribute=value; ...
+     * Example: session=abc123; Domain=example.com; Path=/; Secure; SameSite=Lax
+     */
+    addCookie(source: URL, cookie: string): void;
+    /**
+     * getCookies returns all cookies for a given URL
+     * @param url
+     */
+    getCookies(url: URL): Map<string, string>;
+    /**
+     * Builds the 'Cookie' header to attach to a request
+     */
+    getCookieHeader(url: URL): string;
+}

package/dist/connection/CookieJar.js

@@ -0,0 +1,99 @@
+export class CookieJar {
+    #cookies = new Map();
+    static #normalizeDomain(domain) {
+        return domain.trim().replace(/^\./, '').replace(/^www\./, '').toLowerCase();
+    }
+    static clone(jar) {
+        const newJar = new CookieJar();
+        for (const [name, cookie] of jar.#cookies) {
+            newJar.#cookies.set(name, cookie);
+        }
+        return newJar;
+    }
+    /**
+     * Parses a Set-Cookie header value and adds it to the jar
+     * Expected format: <name>=<value>; Attribute; Attribute=value; ...
+     * Example: session=abc123; Domain=example.com; Path=/; Secure; SameSite=Lax
+     */
+    addCookie(source, cookie) {
+        const parts = cookie.split(';').map(part => part.trim()).filter(Boolean);
+        const [nameValue, ...attributes] = parts;
+        const separatorIndex = nameValue.indexOf('=');
+        if (separatorIndex === -1)
+            return;
+        const name = nameValue.slice(0, separatorIndex);
+        const value = nameValue.slice(separatorIndex + 1);
+        const cookieMap = new Map();
+        for (const attribute of attributes) {
+            const index = attribute.indexOf('=');
+            if (index === -1) {
+                cookieMap.set(attribute, 'true');
+                continue;
+            }
+            cookieMap.set(attribute.slice(0, index), attribute.slice(index + 1));
+        }
+        // 2. Convert the map to a Cookie object
+        const maxAgeRaw = cookieMap.get('Max-Age');
+        const expiresRaw = cookieMap.get('Expires');
+        let expires = null;
+        if (maxAgeRaw) {
+            expires = new Date(Date.now() + parseInt(maxAgeRaw) * 1000);
+        }
+        else if (expiresRaw) {
+            const tempExpires = new Date(expiresRaw);
+            if (isNaN(tempExpires.getTime())) {
+                console.warn('Invalid Expires date:', expiresRaw);
+            }
+            else {
+                expires = tempExpires;
+            }
+        }
+        const cookieObj = {
+            name,
+            value,
+            domain: CookieJar.#normalizeDomain(cookieMap.get('Domain') ?? source.hostname),
+            path: cookieMap.get('Path') ?? '/',
+            expires: expires?.getTime() ?? null,
+            secure: cookieMap.get('Secure') === 'true',
+            httpOnly: cookieMap.get('HttpOnly') === 'true',
+            sameSite: cookieMap.get('SameSite') ?? 'Lax',
+            partitioned: cookieMap.get('Partitioned') === 'true',
+            priority: cookieMap.get('Priority') ?? 'Medium'
+        };
+        this.#cookies.set(cookieObj.name, cookieObj);
+    }
+    /**
+     * getCookies returns all cookies for a given URL
+     * @param url
+     */
+    getCookies(url) {
+        const domain = CookieJar.#normalizeDomain(url.hostname);
+        const result = new Map();
+        const now = Date.now();
+        for (const [name, cookie] of this.#cookies) {
+            if (cookie.expires !== null && cookie.expires < now) {
+                // Remove the cookie if it has expired
+                this.#cookies.delete(name);
+                continue;
+            }
+            if (cookie.domain !== domain &&
+                !domain.endsWith(`.${cookie.domain}`))
+                continue;
+            if (cookie.path && !url.pathname.startsWith(cookie.path))
+                continue;
+            if (cookie.secure && url.protocol !== 'https:')
+                continue;
+            result.set(cookie.name, cookie.value);
+        }
+        return result;
+    }
+    /**
+     * Builds the 'Cookie' header to attach to a request
+     */
+    getCookieHeader(url) {
+        const cookies = this.getCookies(url);
+        if (cookies.size === 0)
+            return '';
+        return Array.from(cookies.entries()).map(([name, value]) => `${name}=${value}`).join('; ');
+    }
+}