@proofkit/fmodata 0.1.0-alpha.8 → 0.1.0-beta.23

package/src/client/batch-builder.ts

@@ -1,20 +1,20 @@
+import { BatchTruncatedError } from "../errors";
 import type {
+  BatchItemResult,
+  BatchResult,
   ExecutableBuilder,
+  ExecuteMethodOptions,
+  ExecuteOptions,
   ExecutionContext,
   Result,
-  ExecuteOptions,
 } from "../types";
-import { type FFetchOptions } from "@fetchkit/ffetch";
-import {
-  formatBatchRequestFromNative,
-  parseBatchResponse,
-  type ParsedBatchResponse,
-} from "./batch-request";
+import { formatBatchRequestFromNative, type ParsedBatchResponse, parseBatchResponse } from "./batch-request";
 
 /**
  * Helper type to extract result types from a tuple of ExecutableBuilders.
  * Uses a mapped type which TypeScript 4.1+ can handle for tuples.
  */
+// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any ExecutableBuilder result type
 type ExtractTupleTypes<T extends readonly ExecutableBuilder<any>[]> = {
   [K in keyof T]: T[K] extends ExecutableBuilder<infer U> ? U : never;
 };
@@ -37,8 +37,7 @@ function parsedToResponse(parsed: ParsedBatchResponse): Response {
   }
 
   // Convert body to string if it's not already
-  const bodyString =
-    typeof parsed.body === "string" ? parsed.body : JSON.stringify(parsed.body);
+  const bodyString = typeof parsed.body === "string" ? parsed.body : JSON.stringify(parsed.body);
 
   // Handle 204 No Content status - it cannot have a body per HTTP spec
   // If FileMaker returns 204 with a body, treat it as 200
@@ -48,7 +47,7 @@ function parsedToResponse(parsed: ParsedBatchResponse): Response {
   }
 
   return new Response(status === 204 ? null : bodyString, {
-    status: status,
+    status,
     statusText: parsed.statusText,
     headers,
   });
@@ -57,22 +56,23 @@ function parsedToResponse(parsed: ParsedBatchResponse): Response {
 /**
  * Builder for batch operations that allows multiple queries to be executed together
  * in a single transactional request.
+ *
+ * Note: BatchBuilder does not implement ExecutableBuilder because execute() returns
+ * BatchResult instead of Result, which is a different return type structure.
  */
-export class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]>
-  implements ExecutableBuilder<ExtractTupleTypes<Builders>>
-{
-  private builders: ExecutableBuilder<any>[];
-  private readonly originalBuilders: Builders;
+// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any ExecutableBuilder result type
+export class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]> {
+  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any ExecutableBuilder result type
+  private readonly builders: ExecutableBuilder<any>[];
+  private readonly databaseName: string;
+  private readonly context: ExecutionContext;
 
-  constructor(
-    builders: Builders,
-    private readonly databaseName: string,
-    private readonly context: ExecutionContext,
-  ) {
+  constructor(builders: Builders, databaseName: string, context: ExecutionContext) {
     // Convert readonly tuple to mutable array for dynamic additions
     this.builders = [...builders];
     // Store original tuple for type preservation
-    this.originalBuilders = builders;
+    this.databaseName = databaseName;
+    this.context = context;
   }
 
   /**
@@ -98,6 +98,7 @@ export class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]>
    * Get the request configuration for this batch operation.
    * This is used internally by the execution system.
    */
+  // biome-ignore lint/suspicious/noExplicitAny: Request body can be any JSON-serializable value
   getRequestConfig(): { method: string; url: string; body?: any } {
     // Note: This method is kept for compatibility but batch operations
     // should use execute() directly which handles the full Request/Response flow
@@ -108,7 +109,7 @@ export class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]>
     };
   }
 
-  toRequest(baseUrl: string): Request {
+  toRequest(baseUrl: string, _options?: ExecuteOptions): Request {
     // Batch operations are not designed to be nested, but we provide
     // a basic implementation for interface compliance
     const fullUrl = `${baseUrl}/${this.databaseName}/$batch`;
@@ -121,114 +122,148 @@ export class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]>
     });
   }
 
-  async processResponse(
-    response: Response,
-    options?: ExecuteOptions,
-  ): Promise<Result<any>> {
+  // biome-ignore lint/suspicious/noExplicitAny: Generic return type for interface compliance
+  processResponse(_response: Response, _options?: ExecuteOptions): Promise<Result<any>> {
     // This should not typically be called for batch operations
     // as they handle their own response processing
-    return {
+    return Promise.resolve({
       data: undefined,
       error: {
         name: "NotImplementedError",
         message: "Batch operations handle response processing internally",
         timestamp: new Date(),
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for error object
       } as 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
+   * @returns A BatchResult containing individual results for each operation
    */
   async execute<EO extends ExecuteOptions>(
-    options?: RequestInit & FFetchOptions & EO,
-  ): Promise<Result<ExtractTupleTypes<Builders>>> {
+    options?: ExecuteMethodOptions<EO>,
+  ): Promise<BatchResult<ExtractTupleTypes<Builders>>> {
     const baseUrl = this.context._getBaseUrl?.();
     if (!baseUrl) {
-      return {
+      // Return BatchResult with all operations marked as failed
+      const errorCount = this.builders.length;
+      // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any result type
+      const results: BatchItemResult<any>[] = this.builders.map((_, _i) => ({
         data: undefined,
         error: {
           name: "ConfigurationError",
-          message:
-            "Base URL not available - execution context must implement _getBaseUrl()",
+          message: "Base URL not available - execution context must implement _getBaseUrl()",
           timestamp: new Date(),
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for error object
         } as any,
+        status: 0,
+      }));
+
+      return {
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for complex generic return type
+        results: results as any,
+        successCount: 0,
+        errorCount,
+        truncated: false,
+        firstErrorIndex: 0,
       };
     }
 
     try {
       // Convert builders to native Request objects
-      const requests: Request[] = this.builders.map((builder) =>
-        builder.toRequest(baseUrl),
-      );
+      const requests: Request[] = this.builders.map((builder) => builder.toRequest(baseUrl, options));
 
       // Format batch request (automatically groups mutations into changesets)
-      const { body, boundary } = await formatBatchRequestFromNative(
-        requests,
-        baseUrl,
-      );
+      const { body, boundary } = await formatBatchRequestFromNative(requests, baseUrl);
 
       // Execute the batch request
-      const response = await this.context._makeRequest<string>(
-        `/${this.databaseName}/$batch`,
-        {
-          ...options,
-          method: "POST",
-          headers: {
-            ...options?.headers,
-            "Content-Type": `multipart/mixed; boundary=${boundary}`,
-            "OData-Version": "4.0",
-          },
-          body,
+      const response = await this.context._makeRequest<string>(`/${this.databaseName}/$batch`, {
+        ...options,
+        method: "POST",
+        headers: {
+          ...options?.headers,
+          "Content-Type": `multipart/mixed; boundary=${boundary}`,
+          "OData-Version": "4.0",
         },
-      );
+        body,
+      });
 
       if (response.error) {
-        return { data: undefined, error: response.error };
+        // Return BatchResult with all operations marked as failed
+        const errorCount = this.builders.length;
+        // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any result type
+        const results: BatchItemResult<any>[] = this.builders.map((_, _i) => ({
+          data: undefined,
+          error: response.error,
+          status: 0,
+        }));
+
+        return {
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for complex generic return type
+          results: results as any,
+          successCount: 0,
+          errorCount,
+          truncated: false,
+          firstErrorIndex: 0,
+        };
       }
 
       // Extract the actual boundary from the response
       // FileMaker uses its own boundary, not the one we sent
-      const firstLine =
-        response.data.split("\r\n")[0] || response.data.split("\n")[0] || "";
-      const actualBoundary = firstLine.startsWith("--")
-        ? firstLine.substring(2)
-        : boundary;
+      const firstLine = response.data.split("\r\n")[0] || response.data.split("\n")[0] || "";
+      const actualBoundary = firstLine.startsWith("--") ? firstLine.substring(2) : boundary;
 
       // Parse the multipart response
       const contentTypeHeader = `multipart/mixed; boundary=${actualBoundary}`;
-      const parsedResponses = parseBatchResponse(
-        response.data,
-        contentTypeHeader,
-      );
-
-      // Check if we got the expected number of responses
-      if (parsedResponses.length !== this.builders.length) {
-        return {
-          data: undefined,
-          error: {
-            name: "BatchError",
-            message: `Expected ${this.builders.length} responses but got ${parsedResponses.length}`,
-            timestamp: new Date(),
-          } as any,
-        };
-      }
+      const parsedResponses = parseBatchResponse(response.data, contentTypeHeader);
 
       // Process each response using the corresponding builder
-      // Build tuple by processing each builder in order
-      type ResultTuple = ExtractTupleTypes<Builders>;
+      // Build BatchResult with per-item results
+      type _ResultTuple = ExtractTupleTypes<Builders>;
+
+      // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any result type
+      const results: BatchItemResult<any>[] = [];
+      let successCount = 0;
+      let errorCount = 0;
+      let firstErrorIndex: number | null = null;
+      const truncated = parsedResponses.length < this.builders.length;
 
       // Process builders sequentially to preserve tuple order
-      const processedResults: any[] = [];
-      for (let i = 0; i < this.originalBuilders.length; i++) {
-        const builder = this.originalBuilders[i];
+      for (let i = 0; i < this.builders.length; i++) {
+        const builder = this.builders[i];
         const parsed = parsedResponses[i];
 
-        if (!builder || !parsed) {
-          processedResults.push(undefined);
+        if (!parsed) {
+          // Truncated - operation never executed
+          const failedAtIndex = firstErrorIndex ?? i;
+          results.push({
+            data: undefined,
+            error: new BatchTruncatedError(i, failedAtIndex),
+            status: 0,
+          });
+          errorCount++;
+          continue;
+        }
+
+        if (!builder) {
+          // Should not happen, but handle gracefully
+          results.push({
+            data: undefined,
+            error: {
+              name: "BatchError",
+              message: `Builder at index ${i} is undefined`,
+              timestamp: new Date(),
+              // biome-ignore lint/suspicious/noExplicitAny: Type assertion for error object
+            } as any,
+            status: parsed.status,
+          });
+          errorCount++;
+          if (firstErrorIndex === null) {
+            firstErrorIndex = i;
+          }
           continue;
         }
 
@@ -239,26 +274,55 @@ export class BatchBuilder<Builders extends readonly ExecutableBuilder<any>[]>
         const result = await builder.processResponse(nativeResponse, options);
 
         if (result.error) {
-          processedResults.push(undefined);
+          results.push({
+            data: undefined,
+            error: result.error,
+            status: parsed.status,
+          });
+          errorCount++;
+          if (firstErrorIndex === null) {
+            firstErrorIndex = i;
+          }
         } else {
-          processedResults.push(result.data);
+          results.push({
+            data: result.data,
+            error: undefined,
+            status: parsed.status,
+          });
+          successCount++;
         }
       }
 
-      // Use a type assertion that TypeScript will respect
-      // ExtractTupleTypes ensures this is a proper tuple type
       return {
-        data: processedResults as unknown as ResultTuple,
-        error: undefined,
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for complex generic return type
+        results: results as any,
+        successCount,
+        errorCount,
+        truncated,
+        firstErrorIndex,
       };
     } catch (err) {
-      return {
+      // On exception, return a BatchResult with all operations marked as failed
+      const errorCount = this.builders.length;
+      // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any result type
+      const results: BatchItemResult<any>[] = this.builders.map((_, _i) => ({
         data: undefined,
         error: {
           name: "BatchError",
           message: err instanceof Error ? err.message : "Unknown error",
           timestamp: new Date(),
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for error object
         } as any,
+        status: 0,
+      }));
+
+      return {
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for complex generic return type
+        results: results as any,
+        successCount: 0,
+        errorCount,
+        truncated: false,
+        firstErrorIndex: 0,
       };
     }
   }

package/src/client/batch-request.ts

@@ -6,6 +6,11 @@
  * with support for transactional changesets.
  */
 
+const BOUNDARY_REGEX = /boundary=([^;]+)/;
+const HTTP_STATUS_LINE_REGEX = /HTTP\/\d\.\d\s+(\d+)\s*(.*)/;
+const CRLF_REGEX = /\r\n/;
+const CHANGESET_CONTENT_TYPE_REGEX = /Content-Type: multipart\/mixed;\s*boundary=([^\r\n]+)/;
+
 export interface RequestConfig {
   method: string;
   url: string;
@@ -17,6 +22,7 @@ export interface ParsedBatchResponse {
   status: number;
   statusText: string;
   headers: Record<string, string>;
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic response body type from OData API
   body: any;
 }
 
@@ -25,10 +31,8 @@ export interface ParsedBatchResponse {
  * @param prefix - Prefix for the boundary (e.g., "batch_" or "changeset_")
  * @returns A boundary string with the prefix and 32 random hex characters
  */
-export function generateBoundary(prefix: string = "batch_"): string {
-  const randomHex = Array.from({ length: 32 }, () =>
-    Math.floor(Math.random() * 16).toString(16),
-  ).join("");
+export function generateBoundary(prefix = "batch_"): string {
+  const randomHex = Array.from({ length: 32 }, () => Math.floor(Math.random() * 16).toString(16)).join("");
   return `${prefix}${randomHex}`;
 }
 
@@ -77,9 +81,7 @@ function formatSubRequest(request: RequestConfig, baseUrl: string): string {
   lines.push(""); // Empty line after multipart headers
 
   // Construct full URL (convert relative to absolute)
-  const fullUrl = request.url.startsWith("http")
-    ? request.url
-    : `${baseUrl}${request.url}`;
+  const fullUrl = request.url.startsWith("http") ? request.url : `${baseUrl}${request.url}`;
 
   // Add HTTP request line
   lines.push(`${request.method} ${fullUrl} HTTP/1.1`);
@@ -97,10 +99,7 @@ function formatSubRequest(request: RequestConfig, baseUrl: string): string {
 
     // Check if Content-Type is already set
     const hasContentType =
-      request.headers &&
-      Object.keys(request.headers).some(
-        (k) => k.toLowerCase() === "content-type",
-      );
+      request.headers && Object.keys(request.headers).some((k) => k.toLowerCase() === "content-type");
 
     if (!hasContentType) {
       lines.push("Content-Type: application/json");
@@ -108,10 +107,7 @@ function formatSubRequest(request: RequestConfig, baseUrl: string): string {
 
     // Add Content-Length (required for FileMaker to read the body)
     const hasContentLength =
-      request.headers &&
-      Object.keys(request.headers).some(
-        (k) => k.toLowerCase() === "content-length",
-      );
+      request.headers && Object.keys(request.headers).some((k) => k.toLowerCase() === "content-length");
 
     if (!hasContentLength) {
       lines.push(`Content-Length: ${request.body.length}`);
@@ -136,11 +132,7 @@ function formatSubRequest(request: RequestConfig, baseUrl: string): string {
  * @param changesetBoundary - Boundary string for the changeset
  * @returns Formatted changeset string with CRLF line endings
  */
-function formatChangeset(
-  requests: RequestConfig[],
-  baseUrl: string,
-  changesetBoundary: string,
-): string {
+function formatChangeset(requests: RequestConfig[], baseUrl: string, changesetBoundary: string): string {
   const lines: string[] = [];
 
   lines.push(`Content-Type: multipart/mixed; boundary=${changesetBoundary}`);
@@ -183,9 +175,7 @@ export function formatBatchRequest(
         // Close and add the current changeset
         const changesetBoundary = generateBoundary("changeset_");
         lines.push(`--${boundary}`);
-        lines.push(
-          formatChangeset(currentChangeset, baseUrl, changesetBoundary),
-        );
+        lines.push(formatChangeset(currentChangeset, baseUrl, changesetBoundary));
         currentChangeset = null;
       }
 
@@ -277,8 +267,8 @@ export async function formatBatchRequestFromNative(
  * @returns The boundary string, or null if not found
  */
 export function extractBoundary(contentType: string): string | null {
-  const match = contentType.match(/boundary=([^;]+)/);
-  return match && match[1] ? match[1].trim() : null;
+  const match = contentType.match(BOUNDARY_REGEX);
+  return match?.[1] ? match[1].trim() : null;
 }
 
 /**
@@ -290,12 +280,12 @@ function parseStatusLine(line: string): {
   status: number;
   statusText: string;
 } {
-  const match = line.match(/HTTP\/\d\.\d\s+(\d+)\s*(.*)/);
-  if (!match || !match[1]) {
+  const match = line.match(HTTP_STATUS_LINE_REGEX);
+  if (!match?.[1]) {
     return { status: 0, statusText: "" };
   }
   return {
-    status: parseInt(match[1], 10),
+    status: Number.parseInt(match[1], 10),
     statusText: match[2]?.trim() || "",
   };
 }
@@ -324,13 +314,13 @@ function parseHeaders(lines: string[]): Record<string, string> {
  * @returns Parsed response object
  */
 function parseHttpResponse(part: string): ParsedBatchResponse {
-  const lines = part.split(/\r\n/);
+  const lines = part.split(CRLF_REGEX);
 
   // Find the HTTP status line (skip multipart headers)
   let statusLineIndex = -1;
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
-    if (line && line.startsWith("HTTP/")) {
+    if (line?.startsWith("HTTP/")) {
       statusLineIndex = i;
       break;
     }
@@ -370,7 +360,7 @@ function parseHttpResponse(part: string): ParsedBatchResponse {
       break;
     }
     // Stop at boundary markers (for responses without bodies like 204)
-    if (line && line.startsWith("--")) {
+    if (line?.startsWith("--")) {
       break;
     }
     if (line) {
@@ -395,6 +385,7 @@ function parseHttpResponse(part: string): ParsedBatchResponse {
     bodyText = bodyLinesFiltered.join("\r\n").trim();
   }
 
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic response body type from OData API
   let body: any = null;
   if (bodyText) {
     try {
@@ -419,10 +410,7 @@ function parseHttpResponse(part: string): ParsedBatchResponse {
  * @param contentType - The Content-Type header from the response
  * @returns Array of parsed responses in the same order as the request
  */
-export function parseBatchResponse(
-  responseText: string,
-  contentType: string,
-): ParsedBatchResponse[] {
+export function parseBatchResponse(responseText: string, contentType: string): ParsedBatchResponse[] {
   const boundary = extractBoundary(contentType);
   if (!boundary) {
     throw new Error("Could not extract boundary from Content-Type header");
@@ -445,9 +433,7 @@ export function parseBatchResponse(
     // Check if this part is a changeset (nested multipart)
     if (trimmedPart.includes("Content-Type: multipart/mixed")) {
       // Extract the changeset boundary
-      const changesetContentTypeMatch = trimmedPart.match(
-        /Content-Type: multipart\/mixed;\s*boundary=([^\r\n]+)/,
-      );
+      const changesetContentTypeMatch = trimmedPart.match(CHANGESET_CONTENT_TYPE_REGEX);
       if (changesetContentTypeMatch) {
         const changesetBoundary = changesetContentTypeMatch?.[1]?.trim();
         const changesetPattern = `--${changesetBoundary}`;
@@ -460,9 +446,7 @@ export function parseBatchResponse(
           }
 
           // Skip the changeset header
-          if (
-            trimmedChangesetPart.startsWith("Content-Type: multipart/mixed")
-          ) {
+          if (trimmedChangesetPart.startsWith("Content-Type: multipart/mixed")) {
             continue;
           }
 

package/src/client/builders/default-select.ts

@@ -0,0 +1,75 @@
+import { isColumn } from "../../orm/column";
+import type { FMTable } from "../../orm/table";
+import { FMTable as FMTableClass, getBaseTableConfig } from "../../orm/table";
+
+/**
+ * Helper function to get container field names from a table.
+ * Container fields cannot be selected via $select in FileMaker OData API.
+ */
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+function getContainerFieldNames(table: FMTable<any, any>): string[] {
+  const baseTableConfig = getBaseTableConfig(table);
+  if (!baseTableConfig?.containerFields) {
+    return [];
+  }
+  return baseTableConfig.containerFields as string[];
+}
+
+/**
+ * Gets default select fields from a table definition.
+ * Returns undefined if defaultSelect is "all".
+ * Automatically filters out container fields since they cannot be selected via $select.
+ *
+ * @param table - The table occurrence
+ * @param includeSpecialColumns - If true, includes ROWID and ROWMODID when defaultSelect is "schema"
+ */
+export function getDefaultSelectFields(
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  table: FMTable<any, any> | undefined,
+  includeSpecialColumns?: boolean,
+): string[] | undefined {
+  if (!table) {
+    return undefined;
+  }
+
+  // biome-ignore lint/suspicious/noExplicitAny: Type assertion for Symbol property access
+  const defaultSelect = (table as any)[FMTableClass.Symbol.DefaultSelect];
+  const containerFields = getContainerFieldNames(table);
+
+  if (defaultSelect === "schema") {
+    const baseTableConfig = getBaseTableConfig(table);
+    const allFields = Object.keys(baseTableConfig.schema);
+    // Filter out container fields
+    const fields = [...new Set(allFields.filter((f) => !containerFields.includes(f)))];
+
+    // Add special columns if requested
+    if (includeSpecialColumns) {
+      fields.push("ROWID", "ROWMODID");
+    }
+
+    return fields;
+  }
+
+  if (Array.isArray(defaultSelect)) {
+    // Filter out container fields
+    return [...new Set(defaultSelect.filter((f) => !containerFields.includes(f)))];
+  }
+
+  // Check if defaultSelect is a Record<string, Column> (resolved from function)
+  if (typeof defaultSelect === "object" && defaultSelect !== null && !Array.isArray(defaultSelect)) {
+    // Extract field names from Column instances
+    const fieldNames: string[] = [];
+    for (const value of Object.values(defaultSelect)) {
+      if (isColumn(value)) {
+        fieldNames.push(value.fieldName);
+      }
+    }
+    if (fieldNames.length > 0) {
+      // Filter out container fields
+      return [...new Set(fieldNames.filter((f) => !containerFields.includes(f)))];
+    }
+  }
+
+  // defaultSelect is "all" or undefined
+  return undefined;
+}