@proofkit/fmodata 0.1.0-alpha.9 → 0.1.0-beta.24

package/src/client/update-builder.ts

@@ -1,66 +1,56 @@
-import type {
-  ExecutionContext,
-  ExecutableBuilder,
-  Result,
-  WithSystemFields,
-  ExecuteOptions,
-} from "../types";
-import type { TableOccurrence } from "./table-occurrence";
-import type { BaseTable } from "./base-table";
+import type { FFetchOptions } from "@fetchkit/ffetch";
+import type { FMTable, InferSchemaOutputFromFMTable } from "../orm/table";
+import { getBaseTableConfig, getTableId as getTableIdHelper, getTableName, isUsingEntityIds } from "../orm/table";
+import { transformFieldNamesToIds } from "../transform";
+import type { ExecutableBuilder, ExecuteMethodOptions, ExecuteOptions, ExecutionContext, Result } from "../types";
+import { getAcceptHeader } from "../types";
+import { validateAndTransformInput } from "../validation";
+import { parseErrorResponse } from "./error-parser";
 import { QueryBuilder } from "./query-builder";
-import { type FFetchOptions } from "@fetchkit/ffetch";
-import {
-  transformFieldNamesToIds,
-  transformTableName,
-  getTableIdentifiers,
-} from "../transform";
 
 /**
  * Initial update builder returned from EntitySet.update(data)
  * Requires calling .byId() or .where() before .execute() is available
  */
 export class UpdateBuilder<
-  T extends Record<string, any>,
-  BT extends BaseTable<any, any, any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  Occ extends FMTable<any, any>,
   ReturnPreference extends "minimal" | "representation" = "minimal",
 > {
-  private tableName: string;
-  private databaseName: string;
-  private context: ExecutionContext;
-  private occurrence?: TableOccurrence<any, any, any, any>;
-  private data: Partial<T>;
-  private returnPreference: ReturnPreference;
+  private readonly databaseName: string;
+  private readonly context: ExecutionContext;
+  private readonly table: Occ;
+  private readonly data: Partial<InferSchemaOutputFromFMTable<Occ>>;
+  private readonly returnPreference: ReturnPreference;
 
-  private databaseUseEntityIds: boolean;
+  private readonly databaseUseEntityIds: boolean;
+  private readonly databaseIncludeSpecialColumns: boolean;
 
   constructor(config: {
-    occurrence?: TableOccurrence<any, any, any, any>;
-    tableName: string;
+    occurrence: Occ;
     databaseName: string;
     context: ExecutionContext;
-    data: Partial<T>;
+    data: Partial<InferSchemaOutputFromFMTable<Occ>>;
     returnPreference: ReturnPreference;
     databaseUseEntityIds?: boolean;
+    databaseIncludeSpecialColumns?: boolean;
   }) {
-    this.occurrence = config.occurrence;
-    this.tableName = config.tableName;
+    this.table = config.occurrence;
     this.databaseName = config.databaseName;
     this.context = config.context;
     this.data = config.data;
     this.returnPreference = config.returnPreference;
     this.databaseUseEntityIds = config.databaseUseEntityIds ?? false;
+    this.databaseIncludeSpecialColumns = config.databaseIncludeSpecialColumns ?? false;
   }
 
   /**
    * Update a single record by ID
    * Returns updated count by default, or full record if returnFullRecord was set to true
    */
-  byId(
-    id: string | number,
-  ): ExecutableUpdateBuilder<T, true, ReturnPreference> {
-    return new ExecutableUpdateBuilder<T, true, ReturnPreference>({
-      occurrence: this.occurrence,
-      tableName: this.tableName,
+  byId(id: string | number): ExecutableUpdateBuilder<Occ, true, ReturnPreference> {
+    return new ExecutableUpdateBuilder<Occ, true, ReturnPreference>({
+      occurrence: this.table,
       databaseName: this.databaseName,
       context: this.context,
       data: this.data,
@@ -76,21 +66,10 @@ export class UpdateBuilder<
    * Returns updated count by default, or full record if returnFullRecord was set to true
    * @param fn Callback that receives a QueryBuilder for building the filter
    */
-  where(
-    fn: (
-      q: QueryBuilder<WithSystemFields<T>>,
-    ) => QueryBuilder<WithSystemFields<T>>,
-  ): ExecutableUpdateBuilder<T, true, ReturnPreference> {
+  where(fn: (q: QueryBuilder<Occ>) => QueryBuilder<Occ>): ExecutableUpdateBuilder<Occ, true, ReturnPreference> {
     // Create a QueryBuilder for the user to configure
-    const queryBuilder = new QueryBuilder<
-      WithSystemFields<T>,
-      keyof WithSystemFields<T>,
-      false,
-      false,
-      undefined
-    >({
-      occurrence: undefined,
-      tableName: this.tableName,
+    const queryBuilder = new QueryBuilder<Occ>({
+      occurrence: this.table,
       databaseName: this.databaseName,
       context: this.context,
     });
@@ -98,9 +77,8 @@ export class UpdateBuilder<
     // Let the user configure it
     const configuredBuilder = fn(queryBuilder);
 
-    return new ExecutableUpdateBuilder<T, true, ReturnPreference>({
-      occurrence: this.occurrence,
-      tableName: this.tableName,
+    return new ExecutableUpdateBuilder<Occ, true, ReturnPreference>({
+      occurrence: this.table,
       databaseName: this.databaseName,
       context: this.context,
       data: this.data,
@@ -118,39 +96,35 @@ export class UpdateBuilder<
  * Can return either updated count or full record based on returnFullRecord option
  */
 export class ExecutableUpdateBuilder<
-  T extends Record<string, any>,
-  IsByFilter extends boolean,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  Occ extends FMTable<any, any>,
+  _IsByFilter extends boolean,
   ReturnPreference extends "minimal" | "representation" = "minimal",
 > implements
-    ExecutableBuilder<
-      ReturnPreference extends "minimal" ? { updatedCount: number } : T
-    >
+    ExecutableBuilder<ReturnPreference extends "minimal" ? { updatedCount: number } : InferSchemaOutputFromFMTable<Occ>>
 {
-  private tableName: string;
-  private databaseName: string;
-  private context: ExecutionContext;
-  private occurrence?: TableOccurrence<any, any, any, any>;
-  private data: Partial<T>;
-  private mode: "byId" | "byFilter";
-  private recordId?: string | number;
-  private queryBuilder?: QueryBuilder<any>;
-  private returnPreference: ReturnPreference;
-  private databaseUseEntityIds: boolean;
+  private readonly databaseName: string;
+  private readonly context: ExecutionContext;
+  private readonly table: Occ;
+  private readonly data: Partial<InferSchemaOutputFromFMTable<Occ>>;
+  private readonly mode: "byId" | "byFilter";
+  private readonly recordId?: string | number;
+  private readonly queryBuilder?: QueryBuilder<Occ>;
+  private readonly returnPreference: ReturnPreference;
+  private readonly databaseUseEntityIds: boolean;
 
   constructor(config: {
-    occurrence?: TableOccurrence<any, any, any, any>;
-    tableName: string;
+    occurrence: Occ;
     databaseName: string;
     context: ExecutionContext;
-    data: Partial<T>;
+    data: Partial<InferSchemaOutputFromFMTable<Occ>>;
     mode: "byId" | "byFilter";
     recordId?: string | number;
-    queryBuilder?: QueryBuilder<any>;
+    queryBuilder?: QueryBuilder<Occ>;
     returnPreference: ReturnPreference;
     databaseUseEntityIds?: boolean;
   }) {
-    this.occurrence = config.occurrence;
-    this.tableName = config.tableName;
+    this.table = config.occurrence;
     this.databaseName = config.databaseName;
     this.context = config.context;
     this.data = config.data;
@@ -179,30 +153,25 @@ export class ExecutableUpdateBuilder<
    * @param useEntityIds - Optional override for entity ID usage
    */
   private getTableId(useEntityIds?: boolean): string {
-    if (!this.occurrence) {
-      return this.tableName;
-    }
-
     const contextDefault = this.context._getUseEntityIds?.() ?? false;
     const shouldUseIds = useEntityIds ?? contextDefault;
 
     if (shouldUseIds) {
-      const identifiers = getTableIdentifiers(this.occurrence);
-      if (!identifiers.id) {
+      if (!isUsingEntityIds(this.table)) {
         throw new Error(
-          `useEntityIds is true but TableOccurrence "${identifiers.name}" does not have an fmtId defined`,
+          `useEntityIds is true but table "${getTableName(this.table)}" does not have entity IDs configured`,
         );
       }
-      return identifiers.id;
+      return getTableIdHelper(this.table);
     }
 
-    return this.occurrence.getTableName();
+    return getTableName(this.table);
   }
 
   async execute(
-    options?: RequestInit & FFetchOptions & { useEntityIds?: boolean },
+    options?: ExecuteMethodOptions<ExecuteOptions>,
   ): Promise<
-    Result<ReturnPreference extends "minimal" ? { updatedCount: number } : T>
+    Result<ReturnPreference extends "minimal" ? { updatedCount: number } : InferSchemaOutputFromFMTable<Occ>>
   > {
     // Merge database-level useEntityIds with per-request options
     const mergedOptions = this.mergeExecuteOptions(options);
@@ -210,14 +179,30 @@ export class ExecutableUpdateBuilder<
     // Get table identifier with override support
     const tableId = this.getTableId(mergedOptions.useEntityIds);
 
+    // Validate and transform input data using input validators (writeValidators)
+    let validatedData = this.data;
+    if (this.table) {
+      const baseTableConfig = getBaseTableConfig(this.table);
+      const inputSchema = baseTableConfig.inputSchema;
+
+      try {
+        validatedData = await validateAndTransformInput(this.data, inputSchema);
+      } catch (error) {
+        // If validation fails, return error immediately
+        return {
+          data: undefined,
+          error: error instanceof Error ? error : new Error(String(error)),
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
+        } as any;
+      }
+    }
+
     // Transform field names to FMFIDs if using entity IDs
     // Only transform if useEntityIds resolves to true (respects per-request override)
     const shouldUseIds = mergedOptions.useEntityIds ?? false;
 
     const transformedData =
-      this.occurrence?.baseTable && shouldUseIds
-        ? transformFieldNamesToIds(this.data, this.occurrence.baseTable)
-        : this.data;
+      this.table && shouldUseIds ? transformFieldNamesToIds(validatedData, this.table) : validatedData;
 
     let url: string;
 
@@ -234,11 +219,15 @@ export class ExecutableUpdateBuilder<
       const queryString = this.queryBuilder.getQueryString();
       // The query string will have the tableId already transformed by QueryBuilder
       // Remove the leading "/" and table name from the query string as we'll build our own URL
-      const queryParams = queryString.startsWith(`/${tableId}`)
-        ? queryString.slice(`/${tableId}`.length)
-        : queryString.startsWith(`/${this.tableName}`)
-          ? queryString.slice(`/${this.tableName}`.length)
-          : queryString;
+      const tableName = getTableName(this.table);
+      let queryParams: string;
+      if (queryString.startsWith(`/${tableId}`)) {
+        queryParams = queryString.slice(`/${tableId}`.length);
+      } else if (queryString.startsWith(`/${tableName}`)) {
+        queryParams = queryString.slice(`/${tableName}`.length);
+      } else {
+        queryParams = queryString;
+      }
 
       url = `/${this.databaseName}/${tableId}${queryParams}`;
     }
@@ -249,7 +238,7 @@ export class ExecutableUpdateBuilder<
     };
 
     if (this.returnPreference === "representation") {
-      headers["Prefer"] = "return=representation";
+      headers.Prefer = "return=representation";
     }
 
     // Make PATCH request with JSON body
@@ -272,38 +261,38 @@ export class ExecutableUpdateBuilder<
       return {
         data: response as ReturnPreference extends "minimal"
           ? { updatedCount: number }
-          : T,
-        error: undefined,
-      };
-    } else {
-      // Return updated count (minimal)
-      let updatedCount = 0;
-
-      if (typeof response === "number") {
-        updatedCount = response;
-      } else if (response && typeof response === "object") {
-        // Check if the response has a count property (fallback)
-        updatedCount = (response as any).updatedCount || 0;
-      }
-
-      return {
-        data: { updatedCount } as ReturnPreference extends "minimal"
-          ? { updatedCount: number }
-          : T,
+          : InferSchemaOutputFromFMTable<Occ>,
         error: undefined,
       };
     }
+    // Return updated count (minimal)
+    let updatedCount = 0;
+
+    if (typeof response === "number") {
+      updatedCount = response;
+    } else if (response && typeof response === "object") {
+      // Check if the response has a count property (fallback)
+      // biome-ignore lint/suspicious/noExplicitAny: Dynamic response type from OData API
+      updatedCount = (response as any).updatedCount || 0;
+    }
+
+    return {
+      data: { updatedCount } as ReturnPreference extends "minimal"
+        ? { updatedCount: number }
+        : InferSchemaOutputFromFMTable<Occ>,
+      error: undefined,
+    };
   }
 
+  // biome-ignore lint/suspicious/noExplicitAny: Request body can be any JSON-serializable value
   getRequestConfig(): { method: string; url: string; body?: any } {
     // For batch operations, use database-level setting (no per-request override available here)
+    // Note: Input validation happens in execute() and processResponse() for batch operations
     const tableId = this.getTableId(this.databaseUseEntityIds);
 
     // Transform field names to FMFIDs if using entity IDs
     const transformedData =
-      this.occurrence?.baseTable && this.databaseUseEntityIds
-        ? transformFieldNamesToIds(this.data, this.occurrence.baseTable)
-        : this.data;
+      this.table && this.databaseUseEntityIds ? transformFieldNamesToIds(this.data, this.table) : this.data;
 
     let url: string;
 
@@ -315,11 +304,15 @@ export class ExecutableUpdateBuilder<
       }
 
       const queryString = this.queryBuilder.getQueryString();
-      const queryParams = queryString.startsWith(`/${tableId}`)
-        ? queryString.slice(`/${tableId}`.length)
-        : queryString.startsWith(`/${this.tableName}`)
-          ? queryString.slice(`/${this.tableName}`.length)
-          : queryString;
+      const tableName = getTableName(this.table);
+      let queryParams: string;
+      if (queryString.startsWith(`/${tableId}`)) {
+        queryParams = queryString.slice(`/${tableId}`.length);
+      } else if (queryString.startsWith(`/${tableName}`)) {
+        queryParams = queryString.slice(`/${tableName}`.length);
+      } else {
+        queryParams = queryString;
+      }
 
       url = `/${this.databaseName}/${tableId}${queryParams}`;
     }
@@ -331,7 +324,7 @@ export class ExecutableUpdateBuilder<
     };
   }
 
-  toRequest(baseUrl: string): Request {
+  toRequest(baseUrl: string, options?: ExecuteOptions): Request {
     const config = this.getRequestConfig();
     const fullUrl = `${baseUrl}${config.url}`;
 
@@ -339,7 +332,7 @@ export class ExecutableUpdateBuilder<
       method: config.method,
       headers: {
         "Content-Type": "application/json",
-        Accept: "application/json",
+        Accept: getAcceptHeader(options?.includeODataAnnotations),
       },
       body: config.body,
     });
@@ -347,52 +340,77 @@ export class ExecutableUpdateBuilder<
 
   async processResponse(
     response: Response,
-    options?: ExecuteOptions,
+    _options?: ExecuteOptions,
   ): Promise<
-    Result<ReturnPreference extends "minimal" ? { updatedCount: number } : T>
+    Result<ReturnPreference extends "minimal" ? { updatedCount: number } : InferSchemaOutputFromFMTable<Occ>>
   > {
+    // Check for error responses (important for batch operations)
+    if (!response.ok) {
+      const tableName = getTableName(this.table);
+      const error = await parseErrorResponse(response, response.url || `/${this.databaseName}/${tableName}`);
+      return { data: undefined, error };
+    }
+
     // Check for empty response (204 No Content)
     const text = await response.text();
     if (!text || text.trim() === "") {
       // For 204 No Content, check the fmodata.affected_rows header
       const affectedRows = response.headers.get("fmodata.affected_rows");
-      const updatedCount = affectedRows ? parseInt(affectedRows, 10) : 1;
+      const updatedCount = affectedRows ? Number.parseInt(affectedRows, 10) : 1;
       return {
         data: { updatedCount } as ReturnPreference extends "minimal"
           ? { updatedCount: number }
-          : T,
+          : InferSchemaOutputFromFMTable<Occ>,
         error: undefined,
       };
     }
 
     const rawResponse = JSON.parse(text);
 
+    // Validate and transform input data using input validators (writeValidators)
+    // This is needed for processResponse because it's called from batch operations
+    // where the data hasn't been validated yet
+    let _validatedData = this.data;
+    if (this.table) {
+      const baseTableConfig = getBaseTableConfig(this.table);
+      const inputSchema = baseTableConfig.inputSchema;
+      try {
+        _validatedData = await validateAndTransformInput(this.data, inputSchema);
+      } catch (error) {
+        return {
+          data: undefined,
+          error: error instanceof Error ? error : new Error(String(error)),
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
+        } as any;
+      }
+    }
+
     // Handle based on return preference
     if (this.returnPreference === "representation") {
       // Return the full updated record
       return {
         data: rawResponse as ReturnPreference extends "minimal"
           ? { updatedCount: number }
-          : T,
-        error: undefined,
-      };
-    } else {
-      // Return updated count (minimal)
-      let updatedCount = 0;
-
-      if (typeof rawResponse === "number") {
-        updatedCount = rawResponse;
-      } else if (rawResponse && typeof rawResponse === "object") {
-        // Check if the response has a count property (fallback)
-        updatedCount = (rawResponse as any).updatedCount || 0;
-      }
-
-      return {
-        data: { updatedCount } as ReturnPreference extends "minimal"
-          ? { updatedCount: number }
-          : T,
+          : InferSchemaOutputFromFMTable<Occ>,
         error: undefined,
       };
     }
+    // Return updated count (minimal)
+    let updatedCount = 0;
+
+    if (typeof rawResponse === "number") {
+      updatedCount = rawResponse;
+    } else if (rawResponse && typeof rawResponse === "object") {
+      // Check if the response has a count property (fallback)
+      // biome-ignore lint/suspicious/noExplicitAny: Dynamic response type from OData API
+      updatedCount = (rawResponse as any).updatedCount || 0;
+    }
+
+    return {
+      data: { updatedCount } as ReturnPreference extends "minimal"
+        ? { updatedCount: number }
+        : InferSchemaOutputFromFMTable<Occ>,
+      error: undefined,
+    };
   }
 }