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

package/src/client/delete-builder.ts

@@ -1,47 +1,43 @@
-import type {
-  ExecutionContext,
-  ExecutableBuilder,
-  Result,
-  WithSystemFields,
-  ExecuteOptions,
-} from "../types";
-import type { TableOccurrence } from "./table-occurrence";
+import type { FFetchOptions } from "@fetchkit/ffetch";
+import type { FMTable } from "../orm/table";
+import { getTableId as getTableIdHelper, getTableName, isUsingEntityIds } from "../orm/table";
+import type { ExecutableBuilder, ExecuteMethodOptions, ExecuteOptions, ExecutionContext, Result } from "../types";
+import { getAcceptHeader } from "../types";
+import { parseErrorResponse } from "./error-parser";
 import { QueryBuilder } from "./query-builder";
-import { type FFetchOptions } from "@fetchkit/ffetch";
-import { getTableIdentifiers } from "../transform";
 
 /**
  * Initial delete builder returned from EntitySet.delete()
  * Requires calling .byId() or .where() before .execute() is available
  */
-export class DeleteBuilder<T extends Record<string, any>> {
-  private tableName: string;
-  private databaseName: string;
-  private context: ExecutionContext;
-  private occurrence?: TableOccurrence<any, any, any, any>;
-  private databaseUseEntityIds: boolean;
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export class DeleteBuilder<Occ extends FMTable<any, any>> {
+  private readonly databaseName: string;
+  private readonly context: ExecutionContext;
+  private readonly table: Occ;
+  private readonly databaseUseEntityIds: boolean;
+  private readonly databaseIncludeSpecialColumns: boolean;
 
   constructor(config: {
-    occurrence?: TableOccurrence<any, any, any, any>;
-    tableName: string;
+    occurrence: Occ;
     databaseName: string;
     context: ExecutionContext;
     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.databaseUseEntityIds = config.databaseUseEntityIds ?? false;
+    this.databaseIncludeSpecialColumns = config.databaseIncludeSpecialColumns ?? false;
   }
 
   /**
    * Delete a single record by ID
    */
-  byId(id: string | number): ExecutableDeleteBuilder<T> {
-    return new ExecutableDeleteBuilder<T>({
-      occurrence: this.occurrence,
-      tableName: this.tableName,
+  byId(id: string | number): ExecutableDeleteBuilder<Occ> {
+    return new ExecutableDeleteBuilder<Occ>({
+      occurrence: this.table,
       databaseName: this.databaseName,
       context: this.context,
       mode: "byId",
@@ -54,21 +50,10 @@ export class DeleteBuilder<T extends Record<string, any>> {
    * Delete records matching a filter query
    * @param fn Callback that receives a QueryBuilder for building the filter
    */
-  where(
-    fn: (
-      q: QueryBuilder<WithSystemFields<T>>,
-    ) => QueryBuilder<WithSystemFields<T>>,
-  ): ExecutableDeleteBuilder<T> {
+  where(fn: (q: QueryBuilder<Occ>) => QueryBuilder<Occ>): ExecutableDeleteBuilder<Occ> {
     // 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,
     });
@@ -76,9 +61,8 @@ export class DeleteBuilder<T extends Record<string, any>> {
     // Let the user configure it
     const configuredBuilder = fn(queryBuilder);
 
-    return new ExecutableDeleteBuilder<T>({
-      occurrence: this.occurrence,
-      tableName: this.tableName,
+    return new ExecutableDeleteBuilder<Occ>({
+      occurrence: this.table,
       databaseName: this.databaseName,
       context: this.context,
       mode: "byFilter",
@@ -92,30 +76,28 @@ export class DeleteBuilder<T extends Record<string, any>> {
  * Executable delete builder - has execute() method
  * Returned after calling .byId() or .where()
  */
-export class ExecutableDeleteBuilder<T extends Record<string, any>>
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export class ExecutableDeleteBuilder<Occ extends FMTable<any, any>>
   implements ExecutableBuilder<{ deletedCount: number }>
 {
-  private tableName: string;
-  private databaseName: string;
-  private context: ExecutionContext;
-  private occurrence?: TableOccurrence<any, any, any, any>;
-  private mode: "byId" | "byFilter";
-  private recordId?: string | number;
-  private queryBuilder?: QueryBuilder<any>;
-  private databaseUseEntityIds: boolean;
+  private readonly databaseName: string;
+  private readonly context: ExecutionContext;
+  private readonly table: Occ;
+  private readonly mode: "byId" | "byFilter";
+  private readonly recordId?: string | number;
+  private readonly queryBuilder?: QueryBuilder<Occ>;
+  private readonly databaseUseEntityIds: boolean;
 
   constructor(config: {
-    occurrence?: TableOccurrence<any, any, any, any>;
-    tableName: string;
+    occurrence: Occ;
     databaseName: string;
     context: ExecutionContext;
     mode: "byId" | "byFilter";
     recordId?: string | number;
-    queryBuilder?: QueryBuilder<any>;
+    queryBuilder?: QueryBuilder<Occ>;
     databaseUseEntityIds?: boolean;
   }) {
-    this.occurrence = config.occurrence;
-    this.tableName = config.tableName;
+    this.table = config.occurrence;
     this.databaseName = config.databaseName;
     this.context = config.context;
     this.mode = config.mode;
@@ -142,29 +124,22 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
    * @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 },
-  ): Promise<Result<{ deletedCount: number }>> {
+  async execute(options?: ExecuteMethodOptions<ExecuteOptions>): Promise<Result<{ deletedCount: number }>> {
     // Merge database-level useEntityIds with per-request options
     const mergedOptions = this.mergeExecuteOptions(options);
 
@@ -185,11 +160,15 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
       // Get the query string from the configured QueryBuilder
       const queryString = this.queryBuilder.getQueryString();
       // 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}`;
     }
@@ -215,12 +194,14 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
       deletedCount = 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
       deletedCount = (response as any).deletedCount || 0;
     }
 
     return { data: { deletedCount }, 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)
     const tableId = this.getTableId(this.databaseUseEntityIds);
@@ -235,11 +216,15 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
       }
 
       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}`;
     }
@@ -250,28 +235,32 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
     };
   }
 
-  toRequest(baseUrl: string): Request {
+  toRequest(baseUrl: string, options?: ExecuteOptions): Request {
     const config = this.getRequestConfig();
     const fullUrl = `${baseUrl}${config.url}`;
 
     return new Request(fullUrl, {
       method: config.method,
       headers: {
-        Accept: "application/json",
+        Accept: getAcceptHeader(options?.includeODataAnnotations),
       },
     });
   }
 
-  async processResponse(
-    response: Response,
-    options?: ExecuteOptions,
-  ): Promise<Result<{ deletedCount: number }>> {
+  async processResponse(response: Response, _options?: ExecuteOptions): Promise<Result<{ deletedCount: number }>> {
+    // 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 deletedCount = affectedRows ? parseInt(affectedRows, 10) : 1;
+      const deletedCount = affectedRows ? Number.parseInt(affectedRows, 10) : 1;
       return { data: { deletedCount }, error: undefined };
     }
 
@@ -286,6 +275,7 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
       deletedCount = 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
       deletedCount = (rawResponse as any).deletedCount || 0;
     }