### Making a GET Request with o.js in Node.js

Source: https://context7.com/janhommes/o.js/llms.txt

Demonstrates how to initialize the o.js handler with a service URL and perform a GET request to fetch resources. This example uses the TripPinServiceRW as a target.

```javascript
// Node.js example
const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');
oHandler.get('People').query().then((data) => console.log(data));
```

--------------------------------

### Read (GET) Example

Source: https://github.com/janhommes/o.js/blob/master/README.md

Perform a GET request to retrieve resources, with an optional filter. The response will be the exact user if only one matches, otherwise an array of users. Requires wrapping in an async function or using promises.

```javascript
const response = await o('http://my.url')
  .get('User')
  .query({$filter: `UserName eq 'foobar'`}); 

console.log(response); // If one -> the exact user, otherwise an array of users
```

--------------------------------

### Install o.js with npm

Source: https://github.com/janhommes/o.js/blob/master/README.md

Install the o.js package using npm. This command installs the 'odata' package, which is the same as 'o.js'.

```bash
npm install odata
```

--------------------------------

### Usage in Node.js

Source: https://github.com/janhommes/o.js/blob/master/README.md

Require the 'o' function from the 'odata' package in a Node.js environment. This example demonstrates a simple GET request using promises.

```javascript
const o = require('odata').o;

// promise example
o('http://my.url')
  .get('resource')
  .then((data) => console.log(data));
```

--------------------------------

### Create (POST) Example

Source: https://github.com/janhommes/o.js/blob/master/README.md

Perform a POST request to create a new resource. The data object is sent in the request body. Requires wrapping in an async function or using promises.

```javascript
const data = {
  FirstName: "Bar",
  LastName: "Foo",
  UserName: "foobar",
}

const response = await o('http://my.url')
  .post('User', data)
  .query(); 

console.log(response); // E.g. the user 
```

--------------------------------

### Delete Example

Source: https://github.com/janhommes/o.js/blob/master/README.md

Perform a DELETE request to remove a resource. Requires wrapping in an async function or using promises.

```javascript
const response = await o('http://my.url')
  .delete(`User('foobar')`)
  .query(); 

console.log(response); // The status code
```

--------------------------------

### `OHandler.get(resource?)` — Queue a GET request

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a GET request for a specified resource. Chaining multiple `.get()` calls before executing with `.query()` or `.fetch()` allows for sequential execution of requests, returning an array of results.

```APIDOC
## `OHandler.get(resource?)` — Queue a GET request

### Description
Appends a GET request for the given resource path to the handler's internal queue. Multiple `.get()` calls can be chained before calling `.query()` or `.fetch()` — all queued requests are then executed sequentially and their results returned as an array.

### Parameters
#### Path Parameters
- **resource** (string) - Optional - The resource path to request. If omitted, the request is made to the handler's base URL.

### Query Parameters
- **queryOptions** (object) - Optional - OData query options to append to the request URL.

### Request Example
```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Single resource — returns object (not array)
const person = await oHandler.get("People('russellwhyte')").query();
console.log(person.FirstName); // 'Russell'

// Collection — returns array
const people = await oHandler.get('People').query({ $top: 4, $orderby: 'LastName' });
console.log(people.length); // 4

// Multiple chained GETs — returns array of results
const [russell, allPeople] = await oHandler
  .get("People('russellwhyte')")
  .get('People')
  .query({ $top: 2 });
console.log(russell.UserName);   // 'russellwhyte'
console.log(allPeople.length);   // 2

// Error handling — throws Response on HTTP 4xx/5xx
try {
  await oHandler.get("People('nonexistent')").query();
} catch (res) {
  console.log(res.status); // 404
}
```
```

--------------------------------

### Update (PATCH) Example

Source: https://github.com/janhommes/o.js/blob/master/README.md

Perform a PATCH request to update an existing resource. The data object contains the fields to update. Requires wrapping in an async function or using promises.

```javascript
const data = {
  FirstName: 'John'
}

const response = await o('http://my.url')
  .patch(`User('foobar')`, data)
  .query(); 

console.log(response); // The result of the patch, e.g. the status code
```

--------------------------------

### Batch Mixed GET and PATCH Requests with OHandler.batch()

Source: https://context7.com/janhommes/o.js/llms.txt

Demonstrates batching mixed GET and PATCH requests using OHandler.batch(). Setting `oHandler.config.batch.useChangset = true` enables changesets for operations like PATCH. The results array contains status codes for changesets and bodies for GET requests.

```typescript
// Batch with mixed GET and PATCH (using changesets)
oHandler.config.batch.useChangset = true;
const mixed = await oHandler
  .patch("Airlines('AA')", { Name: 'American Airlines' })
  .get("Airlines('AA')")
  .batch();

console.log(mixed[0].status);         // 204
console.log(mixed[1].body.Name);      // 'American Airlines'
```

--------------------------------

### Read (GET)

Source: https://github.com/janhommes/o.js/blob/master/README.md

Retrieves resources using an HTTP GET request. Supports filtering and other OData query options.

```APIDOC
## GET /resource

### Description
Retrieves resources based on the specified criteria.

### Method
GET

### Endpoint
`/{resource}`

### Parameters
#### Query Parameters
- **$filter** (string) - Optional - OData filter expression.

### Request Example
```javascript
const response = await o('http://my.url')
  .get('User')
  .query({$filter: `UserName eq 'foobar'`}); 

console.log(response);
```

### Response
#### Success Response (200)
- **response** (array | object) - If one resource matches, it returns the exact user; otherwise, it returns an array of users.
```

--------------------------------

### Queue GET Request with OHandler.get()

Source: https://context7.com/janhommes/o.js/llms.txt

Appends a GET request for a resource to the handler's queue. Chaining multiple .get() calls before .query() executes them sequentially. Handles single resources (returns object) and collections (returns array). Throws Response on HTTP 4xx/5xx errors.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Single resource — returns object (not array)
const person = await oHandler.get("People('russellwhyte')").query();
console.log(person.FirstName); // 'Russell'
```

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Collection — returns array
const people = await oHandler.get('People').query({ $top: 4, $orderby: 'LastName' });
console.log(people.length); // 4
```

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Multiple chained GETs — returns array of results
const [russell, allPeople] = await oHandler
  .get("People('russellwhyte')")
  .get('People')
  .query({ $top: 2 });
console.log(russell.UserName);   // 'russellwhyte'
console.log(allPeople.length);   // 2
```

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Error handling — throws Response on HTTP 4xx/5xx
try {
  await oHandler.get("People('nonexistent')").query();
} catch (res) {
  console.log(res.status); // 404
}
```

--------------------------------

### Batch Multiple GET Requests with OHandler.batch()

Source: https://context7.com/janhommes/o.js/llms.txt

Combines multiple GET requests into a single HTTP batch request. The endpoint and boundary prefix can be configured via OdataConfig.batch. Each individual response is parsed and returned as { contentId, status, body }.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

// Batch multiple GETs into one HTTP request
const results = await oHandler
  .get('People')
  .get('Airlines')
  .batch({ $top: 2 });

console.log(results.length);           // 2
console.log(results[0].status);        // 200
console.log(results[0].body.length);   // 2 (People)
console.log(results[1].body.length);   // 2 (Airlines)
```

--------------------------------

### Importing o.js in Different Environments

Source: https://context7.com/janhommes/o.js/llms.txt

Shows how to import the o.js library for use in ESM/TypeScript, CommonJS (Node.js), and browser environments via a script tag. Ensure the correct import method is used based on your project setup.

```typescript
// ESM / TypeScript
import { o } from 'odata';
```

```javascript
// CommonJS (Node.js)
const { o } = require('odata');
```

```html
// Browser script tag (UMD)
// <script src="node_modules/odata/dist/umd/o.js"></script>
// window.odata.o('http://my.url').get('resource').query().then(console.log);
```

--------------------------------

### Queue PATCH request with OHandler.patch

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a PATCH request to update an entity with partial data. Can be chained with GET to confirm the update.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

// PATCH then GET to confirm the update
const [patchResponse, updated] = await oHandler
  .patch("People('russellwhyte')", { FirstName: 'Russ' })
  .get("People('russellwhyte')")
  .query();

console.log(patchResponse.status);   // 204 (No Content)
console.log(updated.FirstName);      // 'Russ'
```

--------------------------------

### Retrieve Count Only

Source: https://github.com/janhommes/o.js/blob/master/README.md

To retrieve only the count of a resource, query the `$count` endpoint directly. This is useful for getting the total number of items without fetching the data.

```typescript
oHandler.get('People/$count').query().then((count) => {})
```

--------------------------------

### OHandler.patch

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a PATCH request to update an existing entity with partial data. This method can be chained with GET requests to update and then re-fetch the modified entity in a single sequential operation.

```APIDOC
## `OHandler.patch(resource, body)` — Queue a PATCH request

Queues a PATCH request to update an existing entity with partial data. Can be combined with GET in a single chain to update and then re-fetch the modified entity, all in sequential execution.

### Parameters

- **resource** (string): The resource path to update (e.g., "People('russellwhyte')").
- **body** (object): An object containing the partial data to update.

### Request Example

```typescript
const [patchResponse, updated] = await oHandler
  .patch("People('russellwhyte')", { FirstName: 'Russ' })
  .get("People('russellwhyte')")
  .query();
```

### Response

- **patchResponse**: The raw `Response` object for the PATCH request.
- **updated**: The parsed response data after the update and subsequent GET.

### Response Example

```typescript
console.log(patchResponse.status);   // 204 (No Content)
console.log(updated.FirstName);      // 'Russ'
```
```

--------------------------------

### o(rootUrl, config?)

Source: https://github.com/janhommes/o.js/blob/master/README.md

Initializes the o.js library. Can be used to set the root URL for requests or provide configuration options.

```APIDOC
## o(rootUrl, config?)

### Description
Initializes the o.js library, setting the base URL for OData requests and optional configuration.

### Parameters
#### Path Parameters
- **rootUrl** (string | URL) - The base URL for OData requests.
- **config** (OdataConfig | any) - Optional configuration object. Can include `rootUrl` for handler-based requests.

### Request Example
```javascript
// Using rootUrl directly
o('http://my.url/some-resource').query().then();

// Using handler with rootUrl in config
const oHandler = o('', { rootUrl: 'http://my.url' });
oHandler.get('some-resource').query().then();

// Merging rootUrl from constructor and config
const oHandler = o('v1', { rootUrl: 'http://my.url' });
// requests http://my.url/v1/some-resource
oHandler.get('some-resource').query().then();

// In browser, using relative path
const oHandler = o('v1');
// requests http://current-url/v1/some-resource
oHandler.get('some-resource').query().then();
```
```

--------------------------------

### Create (POST)

Source: https://github.com/janhommes/o.js/blob/master/README.md

Creates a new resource using an HTTP POST request. Accepts a resource path and a data object.

```APIDOC
## POST /resource

### Description
Creates a new resource.

### Method
POST

### Endpoint
`/{resource}`

### Request Body
- **data** (object) - Required - The data to be sent for creating the resource.

### Request Example
```javascript
const data = {
  FirstName: "Bar",
  LastName: "Foo",
  UserName: "foobar",
}

const response = await o('http://my.url')
  .post('User', data)
  .query(); 

console.log(response);
```

### Response
#### Success Response (200)
- **response** (any) - The result of the POST operation, typically the created resource.
```

--------------------------------

### Querying a specific resource

Source: https://github.com/janhommes/o.js/blob/master/README.md

Use the 'o' constructor with a specific resource URL to directly query it. This is an alternative to specifying the resource in the .get() or .post() methods.

```javascript
o('http://my.url/some-resource').query().then();
```

--------------------------------

### `o(rootUrl, config?)` — Initialize an OData handler

Source: https://context7.com/janhommes/o.js/llms.txt

Initializes an OData handler with a root URL and optional configuration. The handler can be reused for multiple requests, which are executed sequentially or as a batch.

```APIDOC
## `o(rootUrl, config?)` — Initialize an OData handler

### Description
Creates and returns an `OHandler` configured with the given root URL and optional `OdataConfig`. The handler is reusable: you can call HTTP-verb methods on it multiple times, queuing requests, then flush them all with `query()`, `fetch()`, or `batch()`. When `rootUrl` is a relative path and `config.rootUrl` is provided, the two are merged into an absolute URL.

### Parameters
#### Path Parameters
- **rootUrl** (string) - Required - The base URL for OData service requests.
#### Query Parameters
- **config** (OdataConfig) - Optional - Configuration object for the OData handler.
  - **rootUrl** (string) - Optional - Merged with `rootUrl` if `rootUrl` is relative.
  - **headers** (object) - Optional - Default headers to include in requests.
  - **onStart** (function) - Optional - Callback function executed when a request starts.
  - **onFinish** (function) - Optional - Callback function executed when a request finishes.
  - **onError** (function) - Optional - Callback function executed on request error.

### Request Example
```typescript
import { o } from 'odata';

// One-shot chaining (browser or Node.js)
const people = await o('https://services.odata.org/V4/TripPinServiceRW/')
  .get('People')
  .query({ $top: 3, $filter: "FirstName eq 'Russell'" });
// => [{ UserName: 'russellwhyte', FirstName: 'Russell', ... }]

// Reusable handler with base URL in config
const oHandler = o('', {
  rootUrl: 'https://services.odata.org/V4/TripPinServiceRW/',
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
  onStart: (handler) => console.log('Request started', handler.pending),
  onFinish: (handler, res) => console.log('Done', res?.status),
  onError: (handler, res) => console.error('Error', res),
});

// Reuse handler for multiple independent calls
const airlines = await oHandler.get('Airlines').query({ $top: 5 });
const airports = await oHandler.get('Airports').query({ $top: 5 });
```
```

--------------------------------

### Usage in Browser (Script Tag)

Source: https://github.com/janhommes/o.js/blob/master/README.md

Include the o.js library via a script tag in HTML. The library will be available on the `window.odata` object.

```html
<script src="node_modules/odata/dist/umd/o.js">
```

```javascript
window.odata
  .o('http://my.url')
  .get('resource')
  .query({ $top: 3 })
  .then(function (data) {});
```

--------------------------------

### Configure OData Client with OdataConfig

Source: https://context7.com/janhommes/o.js/llms.txt

The OdataConfig interface extends RequestInit with OData-specific options. It allows setting HTTP settings, OData-specific options like rootUrl and fragment, default query parameters, lifecycle callbacks, and batch configurations.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/', {
  // HTTP settings (from RequestInit)
  credentials: 'include',
  mode: 'cors',
  headers: { 'Content-Type': 'application/json', Authorization: 'Bearer <token>' },

  // OData-specific options
  rootUrl: 'https://services.odata.org/V4/TripPinServiceRW/',
  fragment: 'value',           // key used to unwrap OData JSON envelope
  query: { $top: 10 },         // default query params applied to all requests

  // Lifecycle hooks
  onStart: (handler) => console.log(`Starting ${handler.pending} request(s)...`),
  onFinish: (handler, res) => console.log(`Finished with status ${res?.status}`),
  onError: (handler, res) => console.error(`Request failed:`, res),

  // Batch configuration
  batch: {
    endpoint: '$batch',
    boundaryPrefix: 'batch_',
    changsetBoundaryPrefix: 'changset_',
    useChangset: false,
    useRelativeURLs: false,
    headers: new Headers({ 'Content-Type': 'multipart/mixed' }),
  },
});

const people = await oHandler.get('People').query();
console.log(people); // array of people, max 10 (from default query)
```

--------------------------------

### Merging rootUrl from constructor and options

Source: https://github.com/janhommes/o.js/blob/master/README.md

When both the constructor and the options object provide a `rootUrl`, they are merged. The constructor's argument is treated as a prefix to the `rootUrl` in the options.

```javascript
const oHandler = o('v1', { rootUrl: 'http://my.url' });
// requesting http://my.url/v1/some-resource
oHandler.get('some-resource').query().then();
```

--------------------------------

### OdataConfig

Source: https://context7.com/janhommes/o.js/llms.txt

Configuration interface for the OData client. Extends the native RequestInit interface with OData-specific options including lifecycle callbacks, batch settings, default query parameters, and the OData response fragment key.

```APIDOC
## `OdataConfig` — Configuration interface

Full configuration object passed as the second argument to `o()`. Extends the native `RequestInit` interface with OData-specific options including lifecycle callbacks, batch settings, default query parameters, and the OData response fragment key.

### Example Usage:
```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/', {
  // HTTP settings (from RequestInit)
  credentials: 'include',
  mode: 'cors',
  headers: { 'Content-Type': 'application/json', Authorization: 'Bearer <token>' },

  // OData-specific options
  rootUrl: 'https://services.odata.org/V4/TripPinServiceRW/',
  fragment: 'value',           // key used to unwrap OData JSON envelope
  query: { $top: 10 },         // default query params applied to all requests

  // Lifecycle hooks
  onStart: (handler) => console.log(`Starting ${handler.pending} request(s)...`),
  onFinish: (handler, res) => console.log(`Finished with status ${res?.status}`),
  onError: (handler, res) => console.error(`Request failed:`, res),

  // Batch configuration
  batch: {
    endpoint: '$batch',
    boundaryPrefix: 'batch_',
    changsetBoundaryPrefix: 'changset_',
    useChangset: false,
    useRelativeURLs: false,
    headers: new Headers({ 'Content-Type': 'multipart/mixed' }),
  },
});

const people = await oHandler.get('People').query();
console.log(people); // array of people, max 10 (from default query)
```
```

--------------------------------

### Configuring rootUrl in handler

Source: https://github.com/janhommes/o.js/blob/master/README.md

Create an oHandler with a configured `rootUrl` in the options. This allows for multiple requests to the same base URL without repeating it.

```javascript
const oHandler = o('', { rootUrl: 'http://my.url' });
// requesting http://my.url/some-resource
oHandler.get('some-resource').query().then();
```

--------------------------------

### Browser-specific rootUrl configuration

Source: https://github.com/janhommes/o.js/blob/master/README.md

In a browser environment, if only a resource is provided to the 'o' constructor, it attempts to use the current browser URL as the base.

```javascript
const oHandler = o('v1');
// requesting http://current-url/v1/some-resource
oHandler.get('some-resource').query().then();
```

--------------------------------

### Build Query with odata-query

Source: https://github.com/janhommes/o.js/blob/master/README.md

Use the `buildQuery` property from 'odata-query' to construct complex filters for `query()` and `fetch()` requests. Ensure 'odata-query' is imported.

```typescript
import buildQuery from 'odata-query'

const filter = {
  not: {
    and:[
      { SomeProp: 1 }, 
      { AnotherProp: 2 }
    ]
  }
};

// using only filter in query() or fetch():
oHandler.get('People')
  .query(buildQuery({ filter }))
  .then((filteredPeople) => {});


// using more features of odata-query in get:
oHandler.get('People' + buildQuery({ filter, key: 1, top: 10 }))
  .query()
  .then((filteredPeople) => {});
```

--------------------------------

### Initialize OData Handler with o()

Source: https://context7.com/janhommes/o.js/llms.txt

Initializes an OData handler with a root URL and optional configuration. The handler can be reused for multiple requests. Supports one-shot chaining or reusable handlers with base URL and custom headers/callbacks.

```typescript
import { o } from 'odata';

// One-shot chaining (browser or Node.js)
const people = await o('https://services.odata.org/V4/TripPinServiceRW/')
  .get('People')
  .query({ $top: 3, $filter: "FirstName eq 'Russell'" });
// => [{ UserName: 'russellwhyte', FirstName: 'Russell', ... }]
```

```typescript
import { o } from 'odata';

// Reusable handler with base URL in config
const oHandler = o('', {
  rootUrl: 'https://services.odata.org/V4/TripPinServiceRW/',
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
  onStart: (handler) => console.log('Request started', handler.pending),
  onFinish: (handler, res) => console.log('Done', res?.status),
  onError: (handler, res) => console.error('Error', res),
});

// Reuse handler for multiple independent calls
const airlines = await oHandler.get('Airlines').query({ $top: 5 });
const airports = await oHandler.get('Airports').query({ $top: 5 });
```

--------------------------------

### Execute queued requests with OHandler.query

Source: https://context7.com/janhommes/o.js/llms.txt

Executes all queued requests sequentially, automatically parses JSON responses, and unwraps the OData `value` fragment. Throws the `Response` object if any request returns HTTP 400 or higher. Accepts an optional `OdataQuery` object or query string.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// With OdataQuery object
const top5 = await oHandler.get('People').query({
  $top: 5,
  $select: 'UserName,FirstName,LastName',
  $filter: "Gender eq 'Female'",
  $orderby: 'LastName asc',
});
console.log(top5.length); // up to 5

// With raw query string
const raw = await oHandler.get('People').query('$top=2&$skip=1');
console.log(raw.length); // 2

// Count via $count resource
const count = await oHandler.get('People/$count').query();
console.log(count); // e.g. 20
```

--------------------------------

### OHandler.query

Source: https://context7.com/janhommes/o.js/llms.txt

Executes all queued requests sequentially, automatically parses JSON responses, and unwraps the OData `value` fragment. Returns a single object if one request was queued, or an array if multiple were queued. Throws the `Response` object if any request returns HTTP 400 or higher. Accepts an optional `OdataQuery` object or query string to append as URL search parameters.

```APIDOC
## `OHandler.query(query?)` — Execute queued requests with auto-parsing

Executes all queued requests sequentially, automatically parses JSON responses, and unwraps the OData `value` fragment. Returns a single object if one request was queued, or an array if multiple were queued. Throws the `Response` object if any request returns HTTP 400 or higher. Accepts an optional `OdataQuery` object or query string to append as URL search parameters.

### Parameters

- **query** (object | string, optional): An `OdataQuery` object or a raw query string to append to the request URL.

### Request Example (with OdataQuery object)

```typescript
const top5 = await oHandler.get('People').query({
  $top: 5,
  $select: 'UserName,FirstName,LastName',
  $filter: "Gender eq 'Female'",
  $orderby: 'LastName asc',
});
```

### Request Example (with raw query string)

```typescript
const raw = await oHandler.get('People').query('$top=2&$skip=1');
```

### Request Example (count via $count resource)

```typescript
const count = await oHandler.get('People/$count').query();
```

### Response

- **response**: Parsed JSON response data, or an array if multiple requests were queued. Unwraps the OData `value` fragment.

### Response Example

```typescript
console.log(top5.length); // up to 5
console.log(raw.length); // 2
console.log(count); // e.g. 20
```
```

--------------------------------

### OHandler.fetch

Source: https://context7.com/janhommes/o.js/llms.txt

Works like `.query()` but returns raw `Response` objects instead of parsed data. This is useful when you need access to HTTP status codes, response headers, or raw OData metadata. A single-request chain returns one `Response`; a multi-request chain returns `Response[]`.

```APIDOC
## `OHandler.fetch(query?)` — Execute requests without response parsing

Works like `.query()` but returns raw `Response` objects instead of parsed data. Useful when you need HTTP status codes, response headers, or access to raw OData metadata. A single-request chain returns one `Response`; a multi-request chain returns `Response[]`.

### Parameters

- **query** (object | string, optional): An `OdataQuery` object or a raw query string to append to the request URL.

### Request Example (Access raw Response)

```typescript
const res = await oHandler.get('People').fetch({ $top: 1 });
```

### Request Example (Use with string query)

```typescript
const res2 = await oHandler
  .get('People')
  .fetch("?$top=1&$filter=FirstName eq 'john'");
```

### Response

- **res** / **res2**: The raw `Response` object(s) from the HTTP request.

### Response Example

```typescript
console.log(res.status);                    // 200
console.log(res.headers.get('odata-version')); // '4.0'
const raw = await res.json();
console.log(raw['@odata.context']);         // OData metadata URL
console.log(raw.value.length);             // 1
console.log(decodeURIComponent(res2.url));  // URL includes filter
```
```

--------------------------------

### `OHandler.post(resource, body)` — Queue a POST request

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a POST request to a specified resource with a given body. The body is automatically serialized to JSON. This method can be chained with other HTTP verb methods for multi-step operations executed in a single call.

```APIDOC
## `OHandler.post(resource, body)` — Queue a POST request

### Description
Queues a POST request to the given resource with the provided body data. Object bodies are automatically serialized to JSON. Can be chained with other HTTP-verb methods to compose multi-step operations executed in a single `.query()` call.

### Parameters
#### Path Parameters
- **resource** (string) - Required - The resource path to post to.
- **body** (object) - Required - The data to send in the request body. Will be JSON serialized.

### Request Example
```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

const newUser = {
  FirstName: 'Jane',
  LastName: 'Doe',
  UserName: 'janedoe123',
};

// POST then immediately GET the created resource
const [created, fetched] = await oHandler
  .post('People', newUser)
  .get("People('janedoe123')")
  .query();

console.log(created.FirstName); // 'Jane'
console.log(fetched.UserName);  // 'janedoe123'
```
```

--------------------------------

### OHandler.batch()

Source: https://context7.com/janhommes/o.js/llms.txt

Combines all queued requests into a single OData $batch multipart HTTP request. Each individual response is parsed and returned as { contentId, status, body }. Dramatically reduces network round-trips when making multiple independent requests. Batch endpoint and boundary prefix are configurable via OdataConfig.batch.

```APIDOC
## `OHandler.batch(query?)` — Send all queued requests as one HTTP batch

Combines all queued requests into a single OData `$batch` multipart HTTP request. Each individual response is parsed and returned as `{ contentId, status, body }`. Dramatically reduces network round-trips when making multiple independent requests. Batch endpoint and boundary prefix are configurable via `OdataConfig.batch`.

### Example Usage:
```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

// Batch multiple GETs into one HTTP request
const results = await oHandler
  .get('People')
  .get('Airlines')
  .batch({ $top: 2 });

console.log(results.length);           // 2
console.log(results[0].status);        // 200
console.log(results[0].body.length);   // 2 (People)
console.log(results[1].body.length);   // 2 (Airlines)

// Batch with mixed GET and PATCH (using changesets)
oHandler.config.batch.useChangset = true;
const mixed = await oHandler
  .patch("Airlines('AA')", { Name: 'American Airlines' })
  .get("Airlines('AA')")
  .batch();

console.log(mixed[0].status);         // 204
console.log(mixed[1].body.Name);      // 'American Airlines'
```
```

--------------------------------

### Queue POST Request with OHandler.post()

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a POST request to a resource with a JSON body. Can be chained with other HTTP-verb methods for multi-step operations executed in a single .query() call. Automatically serializes object bodies to JSON.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

const newUser = {
  FirstName: 'Jane',
  LastName: 'Doe',
  UserName: 'janedoe123',
};

// POST then immediately GET the created resource
const [created, fetched] = await oHandler
  .post('People', newUser)
  .get("People('janedoe123')")
  .query();

console.log(created.FirstName); // 'Jane'
console.log(fetched.UserName);  // 'janedoe123'
```

--------------------------------

### Supported Query Options

Source: https://github.com/janhommes/o.js/blob/master/README.md

These query options can be added to `query()`, `fetch()`, and `batch()` requests as an object. The `$count` flag enables inline counts.

```typescript
$filter?: string;
$orderby?: string;
$expand?: string;
$select?: string;

$skip?: number;
$top?: number;
$count?: boolean;
$search?: string;
$format?: string;
$compute?: string;
$index?: number;
[key: string]: any; // allows to add anything that is missing
```

--------------------------------

### Construct OData Queries with OdataQuery Interface

Source: https://context7.com/janhommes/o.js/llms.txt

The OdataQuery interface supports standard OData query options for filtering, sorting, selecting, and pagination. It can be passed directly to .query(), .fetch(), or .batch(). Complex filters can be built using the 'odata-query' package.

```typescript
import { o } from 'odata';
import buildQuery from 'odata-query';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Standard OdataQuery object
const results = await oHandler.get('People').query({
  $filter: "LastName eq 'Whyte'",
  $orderby: 'FirstName desc',
  $select: 'UserName,FirstName,LastName',
  $top: 5,
  $skip: 0,
  $count: true,
  $expand: 'Trips',
});

// Using odata-query for complex filters
const filter = {
  not: {
    and: [
      { FirstName: 'John' },
      { LastName: 'Doe' },
    ],
  },
};

// Pass buildQuery result to fetch()
const res = await oHandler
  .get('People')
  .fetch(buildQuery({ filter, top: 3 }));
console.log(decodeURIComponent((res as Response).url));
// => ...People?$filter=not(((FirstName eq 'John') and (LastName eq 'Doe')))&$top=3

// Embed buildQuery directly in get() resource path
const data = await oHandler
  .get('People' + buildQuery({ filter, top: 3 }))
  .query();
console.log(data.length); // up to 3
```

--------------------------------

### OHandler.request(req)

Source: https://context7.com/janhommes/o.js/llms.txt

Allows adding any arbitrary request (including non-standard HTTP methods like HEAD) to the execution queue. Accepts an ORequest instance with a fully-qualified URL and RequestInit config.

```APIDOC
## `OHandler.request(req)` — Queue a custom ORequest

Allows adding any arbitrary request (including non-standard HTTP methods like HEAD) to the execution queue. Accepts an `ORequest` instance with a fully-qualified URL and `RequestInit` config.

### Example Usage:
```typescript
import { o, ORequest } from 'odata';

// Add a HEAD request to check resource availability
const req = new ORequest('https://services.odata.org/V4/TripPinServiceRW/', {
  method: 'HEAD',
});

const res = await o('https://services.odata.org/V4/TripPinServiceRW/')
  .request(req)
  .fetch();

console.log((res as Response).status); // 200
```
```

--------------------------------

### Queue PUT request with OHandler.put

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a full-replacement PUT request for a resource. The entire entity must be supplied in the body. Follows the same chainable pattern as other mutation methods.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

const fullEntity = {
  UserName: 'russellwhyte',
  FirstName: 'Russell',
  LastName: 'Whyte',
  Emails: ['Russell@example.com'],
  AddressInfo: [],
  Gender: 'Male',
};

const response = await oHandler
  .put("People('russellwhyte')", fullEntity)
  .query();

console.log(response.status); // 204
```

--------------------------------

### OHandler.put

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a full-replacement PUT request for a resource. The entire entity must be supplied in the body. This method follows the same chainable pattern as other mutation methods.

```APIDOC
## `OHandler.put(resource, body)` — Queue a PUT request

Queues a full-replacement PUT request for a resource. The entire entity must be supplied in the body. Follows the same chainable pattern as other mutation methods.

### Parameters

- **resource** (string): The resource path to update (e.g., "People('russellwhyte')").
- **body** (object): The complete entity object to replace the existing resource.

### Request Example

```typescript
const fullEntity = {
  UserName: 'russellwhyte',
  FirstName: 'Russell',
  LastName: 'Whyte',
  Emails: ['Russell@example.com'],
  AddressInfo: [],
  Gender: 'Male',
};

const response = await oHandler
  .put("People('russellwhyte')", fullEntity)
  .query();
```

### Response

- **response**: The raw `Response` object for the PUT request.

### Response Example

```typescript
console.log(response.status); // 204
```
```

--------------------------------

### Usage in Browser (Module/TypeScript)

Source: https://github.com/janhommes/o.js/blob/master/README.md

Import and use the 'o' function in a module or TypeScript environment. Supports chaining requests or using a handler for multiple requests to the same URL.

```javascript
import { o } from 'odata';

(async () => {
  // chaining
  const data1 = await o('http://my.url')
    .get('resource')
    .query({ $top: 3 });

  // handler
  const oHandler = o('http://my.url');
  const data2 = await oHandler
    .get('resource')
    .query({ $top: 3 });
})();
```

--------------------------------

### OdataQuery

Source: https://context7.com/janhommes/o.js/llms.txt

Typed interface for OData query options. Passed to `.query()`, `.fetch()`, or `.batch()` to append parameters to the request URL as URLSearchParams. Also supports the `odata-query` builder package for complex filter expressions.

```APIDOC
## `OdataQuery` — Query parameter interface

Typed interface for all supported OData query options. Passed to `.query()`, `.fetch()`, or `.batch()` to append parameters to the request URL as `URLSearchParams`. Also supports the `odata-query` builder package for complex filter expressions.

### Example Usage:
```typescript
import { o } from 'odata';
import buildQuery from 'odata-query';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Standard OdataQuery object
const results = await oHandler.get('People').query({
  $filter: "LastName eq 'Whyte'",
  $orderby: 'FirstName desc',
  $select: 'UserName,FirstName,LastName',
  $top: 5,
  $skip: 0,
  $count: true,
  $expand: 'Trips',
});

// Using odata-query for complex filters
const filter = {
  not: {
    and: [
      { FirstName: 'John' },
      { LastName: 'Doe' },
    ],
  },
};

// Pass buildQuery result to fetch()
const res = await oHandler
  .get('People')
  .fetch(buildQuery({ filter, top: 3 }));
console.log(decodeURIComponent((res as Response).url));
// => ...People?$filter=not(((FirstName eq 'John') and (LastName eq 'Doe')))&$top=3

// Embed buildQuery directly in get() resource path
const data = await oHandler
  .get('People' + buildQuery({ filter, top: 3 }))
  .query();
console.log(data.length); // up to 3
```
```

--------------------------------

### Queue Custom ORequest with OHandler.request()

Source: https://context7.com/janhommes/o.js/llms.txt

Allows adding arbitrary requests, including non-standard HTTP methods like HEAD, to the execution queue. Accepts an ORequest instance with a fully-qualified URL and RequestInit config. The response is a standard Response object.

```typescript
import { o, ORequest } from 'odata';

// Add a HEAD request to check resource availability
const req = new ORequest('https://services.odata.org/V4/TripPinServiceRW/', {
  method: 'HEAD',
});

const res = await o('https://services.odata.org/V4/TripPinServiceRW/')
  .request(req)
  .fetch();

console.log((res as Response).status); // 200
```

--------------------------------

### Execute requests without parsing using OHandler.fetch

Source: https://context7.com/janhommes/o.js/llms.txt

Works like `.query()` but returns raw `Response` objects instead of parsed data. Useful for accessing HTTP status codes, response headers, or raw OData metadata. A single-request chain returns one `Response`; a multi-request chain returns `Response[]`.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/TripPinServiceRW/');

// Access raw Response
const res = await oHandler.get('People').fetch({ $top: 1 });
console.log(res.status);                    // 200
console.log(res.headers.get('odata-version')); // '4.0'

const raw = await res.json();
console.log(raw['@odata.context']);         // OData metadata URL
console.log(raw.value.length);             // 1

// Use with string query for flexible param building
const res2 = await oHandler
  .get('People')
  .fetch("?$top=1&$filter=FirstName eq 'john'");
console.log(decodeURIComponent(res2.url));  // URL includes filter
```

--------------------------------

### Update (PATCH)

Source: https://github.com/janhommes/o.js/blob/master/README.md

Updates an existing resource using an HTTP PATCH request. Requires the resource identifier and the data to update.

```APIDOC
## PATCH /resource(id)

### Description
Updates an existing resource.

### Method
PATCH

### Endpoint
`/{resource}('{id}')`

### Request Body
- **data** (object) - Required - The data to be used for updating the resource.

### Request Example
```javascript
const data = {
  FirstName: 'John'
}

const response = await o('http://my.url')
  .patch(`User('foobar')`, data)
  .query(); 

console.log(response);
```

### Response
#### Success Response (200)
- **response** (any) - The result of the PATCH operation, e.g., the status code.
```

--------------------------------

### Queue DELETE request with OHandler.delete

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a DELETE request for the specified resource. The resolved value is the raw `Response` object (status 204 on success). Chainable with other requests for multi-step workflows like POST-then-DELETE.

```typescript
import { o } from 'odata';

const oHandler = o('https://services.odata.org/V4/(S(session))/TripPinServiceRW/', {
  headers: { 'If-Match': '*', 'Content-Type': 'application/json' },
});

const tempUser = { FirstName: 'Temp', LastName: 'User', UserName: 'tempuser99' };

// Create then delete in one chain
const [created, deleted] = await oHandler
  .post('People', tempUser)
  .delete("People('tempuser99')")
  .query();

console.log(created.UserName);  // 'tempuser99'
console.log(deleted.status);   // 204
```

--------------------------------

### OHandler.delete

Source: https://context7.com/janhommes/o.js/llms.txt

Queues a DELETE request for the specified resource. The resolved value is the raw `Response` object, typically with a status of 204 on success. This method is chainable with other requests for multi-step workflows.

```APIDOC
## `OHandler.delete(resource)` — Queue a DELETE request

Queues a DELETE request for the specified resource. The resolved value is the raw `Response` object (status 204 on success). Chainable with other requests for multi-step workflows like POST-then-DELETE.

### Parameters

- **resource** (string): The resource path to delete (e.g., "People('tempuser99')").

### Request Example

```typescript
// Create then delete in one chain
const [created, deleted] = await oHandler
  .post('People', tempUser)
  .delete("People('tempuser99')")
  .query();
```

### Response

- **deleted**: The raw `Response` object for the DELETE request.

### Response Example

```typescript
console.log(deleted.status);   // 204
```
```

--------------------------------

### Delete

Source: https://github.com/janhommes/o.js/blob/master/README.md

Deletes a resource using an HTTP DELETE request. Requires the resource identifier.

```APIDOC
## DELETE /resource(id)

### Description
Deletes a resource.

### Method
DELETE

### Endpoint
`/{resource}('{id}')`

### Request Example
```javascript
const response = await o('http://my.url')
  .delete(`User('foobar')`)
  .query(); 

console.log(response);
```

### Response
#### Success Response (200)
- **response** (any) - The status code of the delete operation.
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.