@proofkit/fmodata 0.1.0-alpha.6 → 0.1.0-alpha.7

package/README.md

@@ -2,12 +2,14 @@
 
 A strongly-typed FileMaker OData API client.
 
-⚠️ WARNING: This library is in "alpha" status. The API is subject to change. Feedback is welcome on the [community forum](https://community.ottomatic.cloud/c/proofkit/13) or on [GitHub](https://github.com/proofgeist/proofkit/issues).
+⚠️ WARNING: This library is in "alpha" status. It's still in active development and the API is subject to change. Feedback is welcome on the [community forum](https://community.ottomatic.cloud/c/proofkit/13) or on [GitHub](https://github.com/proofgeist/proofkit/issues).
 
 Roadmap:
 
 - [ ] Crossjoin support
-- [ ] Batch operations
+- [x] Batch operations
+  - [ ] Automatically chunk requests into smaller batches (e.g. max 512 inserts per batch)
+- [x] Schema updates (add/update tables and fields)
 - [ ] Proper docs at proofkit.dev
 - [ ] @proofkit/typegen integration
 
@@ -79,7 +81,7 @@ if (data) {
 
 ## Core Concepts
 
-This library relies heavily on the builder pattern for defining your queries and operations. Most operations require a final call to `execute()` to send the request to the server. The builder pattern is designed to support batch operations in the future, allowing you to execute multiple operations in a single request as supported by the FileMaker OData API. **Note:** Batch operations are not yet supported but are planned before the production release. It's also helpful for testing the library, as you can call `getQueryString()` to get the OData query string without executing the request.
+This library relies heavily on the builder pattern for defining your queries and operations. Most operations require a final call to `execute()` to send the request to the server. The builder pattern allows you to build complex queries and also supports batch operations, allowing you to execute multiple operations in a single request as supported by the FileMaker OData API. It's also helpful for testing the library, as you can call `getQueryString()` to get the OData query string without executing the request.
 
 As such, there are layers to the library to help you build your queries and operations.
 
@@ -803,6 +805,334 @@ console.log(result.result.recordId);
 
 **Note:** OData doesn't support script names with special characters (e.g., `@`, `&`, `/`) or script names beginning with a number. TypeScript will catch these at compile time.
 
+## Batch Operations
+
+Batch operations allow you to execute multiple queries and operations together in a single request. All operations in a batch are executed atomically - they all succeed or all fail together. This is both more efficient (fewer network round-trips) and ensures data consistency across related operations.
+
+### Basic Batch with Multiple Queries
+
+Execute multiple read operations in a single batch:
+
+```typescript
+// Create query builders
+const contactsQuery = db.from("contacts").list().top(5);
+const usersQuery = db.from("users").list().top(5);
+
+// Execute both queries in a single batch
+const result = await db.batch([contactsQuery, usersQuery]).execute();
+
+if (result.data) {
+  // Result is a tuple matching the input builders
+  const [contacts, users] = result.data;
+
+  console.log("Contacts:", contacts);
+  console.log("Users:", users);
+}
+```
+
+### Mixed Operations (Reads and Writes)
+
+Combine queries, inserts, updates, and deletes in a single batch:
+
+```typescript
+// Mix different operation types
+const listQuery = db.from("contacts").list().top(10);
+const insertOp = db.from("contacts").insert({
+  name: "John Doe",
+  email: "john@example.com",
+});
+const updateOp = db.from("users").update({ active: true }).byId("user-123");
+
+// All operations execute atomically
+const result = await db.batch([listQuery, insertOp, updateOp]).execute();
+
+if (result.data) {
+  const [contactsList, insertResult, updateResult] = result.data;
+
+  console.log("Fetched contacts:", contactsList);
+  console.log("Inserted contact:", insertResult);
+  console.log("Updated user:", updateResult);
+}
+```
+
+### Transactional Behavior
+
+Batch operations are transactional for write operations (inserts, updates, deletes). If any operation in the batch fails, all write operations are rolled back:
+
+```typescript
+const result = await db
+  .batch([
+    db.from("users").insert({ username: "alice", email: "alice@example.com" }),
+    db.from("users").insert({ username: "bob", email: "bob@example.com" }),
+    db.from("users").insert({ username: "charlie", email: "invalid" }), // This fails
+  ])
+  .execute();
+
+if (result.error) {
+  // All three inserts are rolled back - no users were created
+  console.error("Batch failed:", result.error);
+}
+```
+
+**Note:** Batch operations automatically group write operations (POST, PATCH, DELETE) into changesets for transactional behavior, while read operations (GET) are executed individually within the batch.
+
+## Schema Management
+
+The library provides methods for managing database schema through the `db.schema` property. You can create and delete tables, add and remove fields, and manage indexes.
+
+### Creating Tables
+
+Create a new table with field definitions:
+
+```typescript
+import type { Field } from "@proofkit/fmodata";
+
+const fields: Field[] = [
+  {
+    name: "id",
+    type: "string",
+    primary: true,
+    maxLength: 36,
+  },
+  {
+    name: "username",
+    type: "string",
+    nullable: false,
+    unique: true,
+    maxLength: 50,
+  },
+  {
+    name: "email",
+    type: "string",
+    nullable: false,
+    maxLength: 255,
+  },
+  {
+    name: "age",
+    type: "numeric",
+    nullable: true,
+  },
+  {
+    name: "created_at",
+    type: "timestamp",
+    default: "CURRENT_TIMESTAMP",
+  },
+];
+
+const tableDefinition = await db.schema.createTable("users", fields);
+console.log(tableDefinition.tableName); // "users"
+console.log(tableDefinition.fields); // Array of field definitions
+```
+
+### Field Types
+
+The library supports various field types:
+
+**String Fields:**
+
+```typescript
+{
+  name: "username",
+  type: "string",
+  maxLength: 100, // Optional: varchar(100)
+  nullable: true,
+  unique: true,
+  default: "USER" | "USERNAME" | "CURRENT_USER", // Optional
+  repetitions: 5, // Optional: for repeating fields
+}
+```
+
+**Numeric Fields:**
+
+```typescript
+{
+  name: "age",
+  type: "numeric",
+  nullable: true,
+  primary: false,
+  unique: false,
+}
+```
+
+**Date Fields:**
+
+```typescript
+{
+  name: "birth_date",
+  type: "date",
+  default: "CURRENT_DATE" | "CURDATE", // Optional
+  nullable: true,
+}
+```
+
+**Time Fields:**
+
+```typescript
+{
+  name: "start_time",
+  type: "time",
+  default: "CURRENT_TIME" | "CURTIME", // Optional
+  nullable: true,
+}
+```
+
+**Timestamp Fields:**
+
+```typescript
+{
+  name: "created_at",
+  type: "timestamp",
+  default: "CURRENT_TIMESTAMP" | "CURTIMESTAMP", // Optional
+  nullable: false,
+}
+```
+
+**Container Fields:**
+
+```typescript
+{
+  name: "avatar",
+  type: "container",
+  externalSecurePath: "/secure/path", // Optional
+  nullable: true,
+}
+```
+
+### Adding Fields to Existing Tables
+
+Add new fields to an existing table:
+
+```typescript
+const newFields: Field[] = [
+  {
+    name: "phone",
+    type: "string",
+    nullable: true,
+    maxLength: 20,
+  },
+  {
+    name: "bio",
+    type: "string",
+    nullable: true,
+    maxLength: 1000,
+  },
+];
+
+const updatedTable = await db.schema.addFields("users", newFields);
+```
+
+### Deleting Tables and Fields
+
+Delete an entire table:
+
+```typescript
+await db.schema.deleteTable("old_table");
+```
+
+Delete a specific field from a table:
+
+```typescript
+await db.schema.deleteField("users", "old_field");
+```
+
+### Managing Indexes
+
+Create an index on a field:
+
+```typescript
+const index = await db.schema.createIndex("users", "email");
+console.log(index.indexName); // "email"
+```
+
+Delete an index:
+
+```typescript
+await db.schema.deleteIndex("users", "email");
+```
+
+### Complete Example
+
+Here's a complete example of creating a table with various field types:
+
+```typescript
+const fields: Field[] = [
+  // Primary key
+  {
+    name: "id",
+    type: "string",
+    primary: true,
+    maxLength: 36,
+  },
+
+  // String fields
+  {
+    name: "username",
+    type: "string",
+    nullable: false,
+    unique: true,
+    maxLength: 50,
+  },
+  {
+    name: "email",
+    type: "string",
+    nullable: false,
+    maxLength: 255,
+  },
+
+  // Numeric field
+  {
+    name: "age",
+    type: "numeric",
+    nullable: true,
+  },
+
+  // Date/time fields
+  {
+    name: "birth_date",
+    type: "date",
+    nullable: true,
+  },
+  {
+    name: "created_at",
+    type: "timestamp",
+    default: "CURRENT_TIMESTAMP",
+    nullable: false,
+  },
+
+  // Container field
+  {
+    name: "avatar",
+    type: "container",
+    nullable: true,
+  },
+
+  // Repeating field
+  {
+    name: "tags",
+    type: "string",
+    repetitions: 5,
+    maxLength: 50,
+  },
+];
+
+// Create the table
+const table = await db.schema.createTable("users", fields);
+
+// Later, add more fields
+await db.schema.addFields("users", [
+  {
+    name: "phone",
+    type: "string",
+    nullable: true,
+  },
+]);
+
+// Create an index on email
+await db.schema.createIndex("users", "email");
+```
+
+**Note:** Schema management operations require appropriate access privileges on your FileMaker account. Operations will throw errors if you don't have the necessary permissions.
+
 ## Advanced Features
 
 ### Type Safety

package/dist/esm/client/batch-builder.d.ts

@@ -0,0 +1,54 @@
+import { ExecutableBuilder, ExecutionContext, Result, ExecuteOptions } from '../types.js';
+import { FFetchOptions } from '@fetchkit/ffetch';
+/**
+ * Helper type to extract result types from a tuple of ExecutableBuilders.
+ * Uses a mapped type which TypeScript 4.1+ can handle for tuples.
+ */
+type ExtractTupleTypes<T extends readonly ExecutableBuilder<any>[]> = {
+    [K in keyof T]: T[K] extends ExecutableBuilder<infer U> ? U : never;
+};
+/**
+ * Builder for batch operations that allows multiple queries to be executed together
+ * in a single transactional request.
+ */
+export declare class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]> implements ExecutableBuilder<ExtractTupleTypes<Builders>> {
+    private readonly databaseName;
+    private readonly context;
+    private builders;
+    private readonly originalBuilders;
+    constructor(builders: Builders, databaseName: string, context: ExecutionContext);
+    /**
+     * Add a request to the batch dynamically.
+     * This allows building up batch operations programmatically.
+     *
+     * @param builder - An executable builder to add to the batch
+     * @returns This BatchBuilder for method chaining
+     * @example
+     * ```ts
+     * const batch = db.batch([]);
+     * batch.addRequest(db.from('contacts').list());
+     * batch.addRequest(db.from('users').list());
+     * const result = await batch.execute();
+     * ```
+     */
+    addRequest<T>(builder: ExecutableBuilder<T>): this;
+    /**
+     * Get the request configuration for this batch operation.
+     * This is used internally by the execution system.
+     */
+    getRequestConfig(): {
+        method: string;
+        url: string;
+        body?: any;
+    };
+    toRequest(baseUrl: string): Request;
+    processResponse(response: Response, options?: ExecuteOptions): Promise<Result<any>>;
+    /**
+     * Execute the batch operation.
+     *
+     * @param options - Optional fetch options and batch-specific options (includes beforeRequest hook)
+     * @returns A tuple of results matching the input builders
+     */
+    execute<EO extends ExecuteOptions>(options?: RequestInit & FFetchOptions & EO): Promise<Result<ExtractTupleTypes<Builders>>>;
+}
+export {};

package/dist/esm/client/batch-builder.js

@@ -0,0 +1,179 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { formatBatchRequestFromNative, parseBatchResponse } from "./batch-request.js";
+function parsedToResponse(parsed) {
+  const headers = new Headers(parsed.headers);
+  if (parsed.body === null || parsed.body === void 0) {
+    return new Response(null, {
+      status: parsed.status,
+      statusText: parsed.statusText,
+      headers
+    });
+  }
+  const bodyString = typeof parsed.body === "string" ? parsed.body : JSON.stringify(parsed.body);
+  let status = parsed.status;
+  if (status === 204 && bodyString && bodyString.trim() !== "") {
+    status = 200;
+  }
+  return new Response(status === 204 ? null : bodyString, {
+    status,
+    statusText: parsed.statusText,
+    headers
+  });
+}
+class BatchBuilder {
+  constructor(builders, databaseName, context) {
+    __publicField(this, "builders");
+    __publicField(this, "originalBuilders");
+    this.databaseName = databaseName;
+    this.context = context;
+    this.builders = [...builders];
+    this.originalBuilders = builders;
+  }
+  /**
+   * Add a request to the batch dynamically.
+   * This allows building up batch operations programmatically.
+   *
+   * @param builder - An executable builder to add to the batch
+   * @returns This BatchBuilder for method chaining
+   * @example
+   * ```ts
+   * const batch = db.batch([]);
+   * batch.addRequest(db.from('contacts').list());
+   * batch.addRequest(db.from('users').list());
+   * const result = await batch.execute();
+   * ```
+   */
+  addRequest(builder) {
+    this.builders.push(builder);
+    return this;
+  }
+  /**
+   * Get the request configuration for this batch operation.
+   * This is used internally by the execution system.
+   */
+  getRequestConfig() {
+    return {
+      method: "POST",
+      url: `/${this.databaseName}/$batch`,
+      body: void 0
+      // Body is constructed in execute()
+    };
+  }
+  toRequest(baseUrl) {
+    const fullUrl = `${baseUrl}/${this.databaseName}/$batch`;
+    return new Request(fullUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "multipart/mixed",
+        "OData-Version": "4.0"
+      }
+    });
+  }
+  async processResponse(response, options) {
+    return {
+      data: void 0,
+      error: {
+        name: "NotImplementedError",
+        message: "Batch operations handle response processing internally",
+        timestamp: /* @__PURE__ */ new Date()
+      }
+    };
+  }
+  /**
+   * Execute the batch operation.
+   *
+   * @param options - Optional fetch options and batch-specific options (includes beforeRequest hook)
+   * @returns A tuple of results matching the input builders
+   */
+  async execute(options) {
+    var _a, _b;
+    const baseUrl = (_b = (_a = this.context)._getBaseUrl) == null ? void 0 : _b.call(_a);
+    if (!baseUrl) {
+      return {
+        data: void 0,
+        error: {
+          name: "ConfigurationError",
+          message: "Base URL not available - execution context must implement _getBaseUrl()",
+          timestamp: /* @__PURE__ */ new Date()
+        }
+      };
+    }
+    try {
+      const requests = this.builders.map(
+        (builder) => builder.toRequest(baseUrl)
+      );
+      const { body, boundary } = await formatBatchRequestFromNative(
+        requests,
+        baseUrl
+      );
+      const response = await this.context._makeRequest(
+        `/${this.databaseName}/$batch`,
+        {
+          ...options,
+          method: "POST",
+          headers: {
+            ...options == null ? void 0 : options.headers,
+            "Content-Type": `multipart/mixed; boundary=${boundary}`,
+            "OData-Version": "4.0"
+          },
+          body
+        }
+      );
+      if (response.error) {
+        return { data: void 0, error: response.error };
+      }
+      const firstLine = response.data.split("\r\n")[0] || response.data.split("\n")[0] || "";
+      const actualBoundary = firstLine.startsWith("--") ? firstLine.substring(2) : boundary;
+      const contentTypeHeader = `multipart/mixed; boundary=${actualBoundary}`;
+      const parsedResponses = parseBatchResponse(
+        response.data,
+        contentTypeHeader
+      );
+      if (parsedResponses.length !== this.builders.length) {
+        return {
+          data: void 0,
+          error: {
+            name: "BatchError",
+            message: `Expected ${this.builders.length} responses but got ${parsedResponses.length}`,
+            timestamp: /* @__PURE__ */ new Date()
+          }
+        };
+      }
+      const processedResults = [];
+      for (let i = 0; i < this.originalBuilders.length; i++) {
+        const builder = this.originalBuilders[i];
+        const parsed = parsedResponses[i];
+        if (!builder || !parsed) {
+          processedResults.push(void 0);
+          continue;
+        }
+        const nativeResponse = parsedToResponse(parsed);
+        const result = await builder.processResponse(nativeResponse, options);
+        if (result.error) {
+          processedResults.push(void 0);
+        } else {
+          processedResults.push(result.data);
+        }
+      }
+      return {
+        data: processedResults,
+        error: void 0
+      };
+    } catch (err) {
+      return {
+        data: void 0,
+        error: {
+          name: "BatchError",
+          message: err instanceof Error ? err.message : "Unknown error",
+          timestamp: /* @__PURE__ */ new Date()
+        }
+      };
+    }
+  }
+}
+export {
+  BatchBuilder
+};
+//# sourceMappingURL=batch-builder.js.map

package/dist/esm/client/batch-builder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-builder.js","sources":["../../../src/client/batch-builder.ts"],"sourcesContent":["import type {\n  ExecutableBuilder,\n  ExecutionContext,\n  Result,\n  ExecuteOptions,\n} from \"../types\";\nimport { type FFetchOptions } from \"@fetchkit/ffetch\";\nimport {\n  formatBatchRequestFromNative,\n  parseBatchResponse,\n  type ParsedBatchResponse,\n} from \"./batch-request\";\n\n/**\n * Helper type to extract result types from a tuple of ExecutableBuilders.\n * Uses a mapped type which TypeScript 4.1+ can handle for tuples.\n */\ntype ExtractTupleTypes<T extends readonly ExecutableBuilder<any>[]> = {\n  [K in keyof T]: T[K] extends ExecutableBuilder<infer U> ? U : never;\n};\n\n/**\n * Converts a ParsedBatchResponse to a native Response object\n * @param parsed - The parsed batch response\n * @returns A native Response object\n */\nfunction parsedToResponse(parsed: ParsedBatchResponse): Response {\n  const headers = new Headers(parsed.headers);\n\n  // Handle null body\n  if (parsed.body === null || parsed.body === undefined) {\n    return new Response(null, {\n      status: parsed.status,\n      statusText: parsed.statusText,\n      headers,\n    });\n  }\n\n  // Convert body to string if it's not already\n  const bodyString =\n    typeof parsed.body === \"string\" ? parsed.body : JSON.stringify(parsed.body);\n\n  // Handle 204 No Content status - it cannot have a body per HTTP spec\n  // If FileMaker returns 204 with a body, treat it as 200\n  let status = parsed.status;\n  if (status === 204 && bodyString && bodyString.trim() !== \"\") {\n    status = 200;\n  }\n\n  return new Response(status === 204 ? null : bodyString, {\n    status: status,\n    statusText: parsed.statusText,\n    headers,\n  });\n}\n\n/**\n * Builder for batch operations that allows multiple queries to be executed together\n * in a single transactional request.\n */\nexport class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]>\n  implements ExecutableBuilder<ExtractTupleTypes<Builders>>\n{\n  private builders: ExecutableBuilder<any>[];\n  private readonly originalBuilders: Builders;\n\n  constructor(\n    builders: Builders,\n    private readonly databaseName: string,\n    private readonly context: ExecutionContext,\n  ) {\n    // Convert readonly tuple to mutable array for dynamic additions\n    this.builders = [...builders];\n    // Store original tuple for type preservation\n    this.originalBuilders = builders;\n  }\n\n  /**\n   * Add a request to the batch dynamically.\n   * This allows building up batch operations programmatically.\n   *\n   * @param builder - An executable builder to add to the batch\n   * @returns This BatchBuilder for method chaining\n   * @example\n   * ```ts\n   * const batch = db.batch([]);\n   * batch.addRequest(db.from('contacts').list());\n   * batch.addRequest(db.from('users').list());\n   * const result = await batch.execute();\n   * ```\n   */\n  addRequest<T>(builder: ExecutableBuilder<T>): this {\n    this.builders.push(builder);\n    return this;\n  }\n\n  /**\n   * Get the request configuration for this batch operation.\n   * This is used internally by the execution system.\n   */\n  getRequestConfig(): { method: string; url: string; body?: any } {\n    // Note: This method is kept for compatibility but batch operations\n    // should use execute() directly which handles the full Request/Response flow\n    return {\n      method: \"POST\",\n      url: `/${this.databaseName}/$batch`,\n      body: undefined, // Body is constructed in execute()\n    };\n  }\n\n  toRequest(baseUrl: string): Request {\n    // Batch operations are not designed to be nested, but we provide\n    // a basic implementation for interface compliance\n    const fullUrl = `${baseUrl}/${this.databaseName}/$batch`;\n    return new Request(fullUrl, {\n      method: \"POST\",\n      headers: {\n        \"Content-Type\": \"multipart/mixed\",\n        \"OData-Version\": \"4.0\",\n      },\n    });\n  }\n\n  async processResponse(\n    response: Response,\n    options?: ExecuteOptions,\n  ): Promise<Result<any>> {\n    // This should not typically be called for batch operations\n    // as they handle their own response processing\n    return {\n      data: undefined,\n      error: {\n        name: \"NotImplementedError\",\n        message: \"Batch operations handle response processing internally\",\n        timestamp: new Date(),\n      } as any,\n    };\n  }\n\n  /**\n   * Execute the batch operation.\n   *\n   * @param options - Optional fetch options and batch-specific options (includes beforeRequest hook)\n   * @returns A tuple of results matching the input builders\n   */\n  async execute<EO extends ExecuteOptions>(\n    options?: RequestInit & FFetchOptions & EO,\n  ): Promise<Result<ExtractTupleTypes<Builders>>> {\n    const baseUrl = this.context._getBaseUrl?.();\n    if (!baseUrl) {\n      return {\n        data: undefined,\n        error: {\n          name: \"ConfigurationError\",\n          message:\n            \"Base URL not available - execution context must implement _getBaseUrl()\",\n          timestamp: new Date(),\n        } as any,\n      };\n    }\n\n    try {\n      // Convert builders to native Request objects\n      const requests: Request[] = this.builders.map((builder) =>\n        builder.toRequest(baseUrl),\n      );\n\n      // Format batch request (automatically groups mutations into changesets)\n      const { body, boundary } = await formatBatchRequestFromNative(\n        requests,\n        baseUrl,\n      );\n\n      // Execute the batch request\n      const response = await this.context._makeRequest<string>(\n        `/${this.databaseName}/$batch`,\n        {\n          ...options,\n          method: \"POST\",\n          headers: {\n            ...options?.headers,\n            \"Content-Type\": `multipart/mixed; boundary=${boundary}`,\n            \"OData-Version\": \"4.0\",\n          },\n          body,\n        },\n      );\n\n      if (response.error) {\n        return { data: undefined, error: response.error };\n      }\n\n      // Extract the actual boundary from the response\n      // FileMaker uses its own boundary, not the one we sent\n      const firstLine =\n        response.data.split(\"\\r\\n\")[0] || response.data.split(\"\\n\")[0] || \"\";\n      const actualBoundary = firstLine.startsWith(\"--\")\n        ? firstLine.substring(2)\n        : boundary;\n\n      // Parse the multipart response\n      const contentTypeHeader = `multipart/mixed; boundary=${actualBoundary}`;\n      const parsedResponses = parseBatchResponse(\n        response.data,\n        contentTypeHeader,\n      );\n\n      // Check if we got the expected number of responses\n      if (parsedResponses.length !== this.builders.length) {\n        return {\n          data: undefined,\n          error: {\n            name: \"BatchError\",\n            message: `Expected ${this.builders.length} responses but got ${parsedResponses.length}`,\n            timestamp: new Date(),\n          } as any,\n        };\n      }\n\n      // Process each response using the corresponding builder\n      // Build tuple by processing each builder in order\n      type ResultTuple = ExtractTupleTypes<Builders>;\n\n      // Process builders sequentially to preserve tuple order\n      const processedResults: any[] = [];\n      for (let i = 0; i < this.originalBuilders.length; i++) {\n        const builder = this.originalBuilders[i];\n        const parsed = parsedResponses[i];\n\n        if (!builder || !parsed) {\n          processedResults.push(undefined);\n          continue;\n        }\n\n        // Convert parsed response to native Response\n        const nativeResponse = parsedToResponse(parsed);\n\n        // Let the builder process its own response\n        const result = await builder.processResponse(nativeResponse, options);\n\n        if (result.error) {\n          processedResults.push(undefined);\n        } else {\n          processedResults.push(result.data);\n        }\n      }\n\n      // Use a type assertion that TypeScript will respect\n      // ExtractTupleTypes ensures this is a proper tuple type\n      return {\n        data: processedResults as unknown as ResultTuple,\n        error: undefined,\n      };\n    } catch (err) {\n      return {\n        data: undefined,\n        error: {\n          name: \"BatchError\",\n          message: err instanceof Error ? err.message : \"Unknown error\",\n          timestamp: new Date(),\n        } as any,\n      };\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/dist/esm/client/batch-request.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Batch Request Utilities
+ *
+ * Utilities for formatting and parsing OData batch requests using multipart/mixed format.
+ * OData batch requests allow bundling multiple operations into a single HTTP request,
+ * with support for transactional changesets.
+ */
+export interface RequestConfig {
+    method: string;
+    url: string;
+    body?: string;
+    headers?: Record<string, string>;
+}
+export interface ParsedBatchResponse {
+    status: number;
+    statusText: string;
+    headers: Record<string, string>;
+    body: any;
+}
+/**
+ * Generates a random boundary string for multipart requests
+ * @param prefix - Prefix for the boundary (e.g., "batch_" or "changeset_")
+ * @returns A boundary string with the prefix and 32 random hex characters
+ */
+export declare function generateBoundary(prefix?: string): string;
+/**
+ * Formats multiple requests into a batch request body
+ * @param requests - Array of request configurations
+ * @param baseUrl - The base URL to prepend to relative URLs
+ * @param batchBoundary - Optional boundary string for the batch (generated if not provided)
+ * @returns Object containing the formatted body and boundary
+ */
+export declare function formatBatchRequest(requests: RequestConfig[], baseUrl: string, batchBoundary?: string): {
+    body: string;
+    boundary: string;
+};
+/**
+ * Formats multiple Request objects into a batch request body
+ * Supports explicit changesets via Request arrays
+ * @param requests - Array of Request objects or Request arrays (for explicit changesets)
+ * @param baseUrl - The base URL to prepend to relative URLs
+ * @param batchBoundary - Optional boundary string for the batch (generated if not provided)
+ * @returns Promise resolving to object containing the formatted body and boundary
+ */
+export declare function formatBatchRequestFromNative(requests: Array<Request | Request[]>, baseUrl: string, batchBoundary?: string): Promise<{
+    body: string;
+    boundary: string;
+}>;
+/**
+ * Extracts the boundary from a Content-Type header
+ * @param contentType - The Content-Type header value
+ * @returns The boundary string, or null if not found
+ */
+export declare function extractBoundary(contentType: string): string | null;
+/**
+ * Parses a batch response into individual responses
+ * @param responseText - The raw batch response text
+ * @param contentType - The Content-Type header from the response
+ * @returns Array of parsed responses in the same order as the request
+ */
+export declare function parseBatchResponse(responseText: string, contentType: string): ParsedBatchResponse[];