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

package/src/client/database.ts

@@ -1,44 +1,15 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
-import type { ExecutionContext } from "../types";
+import type { ExecutionContext, ExecutableBuilder, Metadata } from "../types";
 import type { BaseTable } from "./base-table";
 import type { TableOccurrence } from "./table-occurrence";
 import { EntitySet } from "./entity-set";
-
-// Type-level validation: Check if a TableOccurrence has fmtId (is TableOccurrenceWithIds)
-type HasFmtId<T> = T extends { fmtId: string } ? true : false;
-
-// Check if all occurrences in a tuple have fmtId
-type AllHaveFmtId<Occurrences extends readonly any[]> =
-  Occurrences extends readonly [infer First, ...infer Rest]
-    ? HasFmtId<First> extends true
-      ? Rest extends readonly []
-        ? true
-        : AllHaveFmtId<Rest>
-      : false
-    : true; // empty array is valid
-
-// Check if none have fmtId
-type NoneHaveFmtId<Occurrences extends readonly any[]> =
-  Occurrences extends readonly [infer First, ...infer Rest]
-    ? HasFmtId<First> extends false
-      ? Rest extends readonly []
-        ? true
-        : NoneHaveFmtId<Rest>
-      : false
-    : true; // empty array is valid
-
-// Valid if all have fmtId or none have fmtId (no mixing allowed)
-export type ValidOccurrenceMix<Occurrences extends readonly any[]> =
-  AllHaveFmtId<Occurrences> extends true
-    ? true
-    : NoneHaveFmtId<Occurrences> extends true
-      ? true
-      : false;
+import { BatchBuilder } from "./batch-builder";
+import { SchemaManager } from "./schema-manager";
 
 // Helper type to extract schema from a TableOccurrence
 type ExtractSchemaFromOccurrence<O> =
   O extends TableOccurrence<infer BT, any, any, any>
-    ? BT extends BaseTable<infer S, any>
+    ? BT extends BaseTable<infer S, any, any, any>
       ? S
       : never
     : never;
@@ -75,16 +46,19 @@ export class Database<
 > {
   private occurrenceMap: Map<string, TableOccurrence<any, any, any, any>>;
   private _useEntityIds: boolean = false;
+  public readonly schema: SchemaManager;
 
   constructor(
     private readonly databaseName: string,
     private readonly context: ExecutionContext,
     config?: {
-      occurrences?: ValidOccurrenceMix<Occurrences> extends true
-        ? Occurrences
-        : Occurrences & {
-            __type_error__: "❌ Cannot mix TableOccurrence with and without entity IDs. Either all occurrences must use TableOccurrenceWithIds (with fmtId and fmfIds) or all must be regular TableOccurrence.";
-          };
+      occurrences?: Occurrences | undefined;
+      /**
+       * Whether to use entity IDs instead of field names in the actual requests to the server
+       * Defaults to true if all occurrences use entity IDs, false otherwise
+       * If set to false but some occurrences do not use entity IDs, an error will be thrown
+       */
+      useEntityIds?: boolean;
     },
   ) {
     this.occurrenceMap = new Map();
@@ -102,7 +76,6 @@ export class Database<
         // An occurrence uses entity IDs if it has both fmtId and fmfIds
         if (hasTableId && hasFieldIds) {
           occurrencesWithIds.push(occ.name);
-          this._useEntityIds = true;
         } else if (!hasTableId && !hasFieldIds) {
           occurrencesWithoutIds.push(occ.name);
         } else {
@@ -114,21 +87,53 @@ export class Database<
         }
       }
 
-      // Check for mixed usage
-      if (occurrencesWithIds.length > 0 && occurrencesWithoutIds.length > 0) {
-        throw new Error(
-          `Cannot mix TableOccurrence instances with and without entity IDs in the same database. ` +
-            `Occurrences with entity IDs: [${occurrencesWithIds.join(", ")}]. ` +
-            `Occurrences without entity IDs: [${occurrencesWithoutIds.join(", ")}]. ` +
-            `Either all table occurrences must use entity IDs (fmtId + fmfIds) or none should.`,
-        );
+      // Determine default value: true if all occurrences use entity IDs, false otherwise
+      const allOccurrencesUseEntityIds =
+        occurrencesWithIds.length > 0 && occurrencesWithoutIds.length === 0;
+      const hasMixedUsage =
+        occurrencesWithIds.length > 0 && occurrencesWithoutIds.length > 0;
+
+      // Handle explicit useEntityIds config
+      if (config.useEntityIds !== undefined) {
+        if (config.useEntityIds === false) {
+          // If explicitly set to false, allow mixed usage and use false
+          this._useEntityIds = false;
+        } else if (config.useEntityIds === true) {
+          // If explicitly set to true, validate that all occurrences use entity IDs
+          if (hasMixedUsage || occurrencesWithoutIds.length > 0) {
+            throw new Error(
+              `useEntityIds is set to true but some occurrences do not use entity IDs. ` +
+                `Occurrences without entity IDs: [${occurrencesWithoutIds.join(", ")}]. ` +
+                `Either set useEntityIds to false or configure all occurrences with entity IDs.`,
+            );
+          }
+          this._useEntityIds = true;
+        }
+      } else {
+        // Default: true if all occurrences use entity IDs, false otherwise
+        // But throw error if there's mixed usage when using defaults
+        if (hasMixedUsage) {
+          throw new Error(
+            `Cannot mix TableOccurrence instances with and without entity IDs in the same database. ` +
+              `Occurrences with entity IDs: [${occurrencesWithIds.join(", ")}]. ` +
+              `Occurrences without entity IDs: [${occurrencesWithoutIds.join(", ")}]. ` +
+              `Either all table occurrences must use entity IDs (fmtId + fmfIds), none should, or explicitly set useEntityIds to false.`,
+          );
+        }
+        this._useEntityIds = allOccurrencesUseEntityIds;
       }
+    } else {
+      // No occurrences provided, use explicit config or default to false
+      this._useEntityIds = config?.useEntityIds ?? false;
     }
 
     // Inform the execution context whether to use entity IDs
     if (this.context._setUseEntityIds) {
       this.context._setUseEntityIds(this._useEntityIds);
     }
+
+    // Initialize schema manager
+    this.schema = new SchemaManager(this.databaseName, this.context);
   }
 
   /**
@@ -164,11 +169,11 @@ export class Database<
       type SchemaType = ExtractSchemaFromOccurrence<OccType>;
 
       return EntitySet.create<SchemaType, OccType>({
-        occurrence: occurrence as any,
+        occurrence: occurrence as OccType,
         tableName: name as string,
         databaseName: this.databaseName,
         context: this.context,
-        database: this as any,
+        database: this,
       }) as any;
     } else {
       // Return untyped EntitySet for dynamic table access
@@ -176,20 +181,44 @@ export class Database<
         tableName: name as string,
         databaseName: this.databaseName,
         context: this.context,
-        database: this as any,
+        database: this,
       }) as any;
     }
   }
 
-  // Example method showing how to use the request method
-  async getMetadata() {
-    const result = await this.context._makeRequest(
-      `/${this.databaseName}/$metadata`,
-    );
+  /**
+   * Retrieves the OData metadata for this database.
+   * @param args Optional configuration object
+   * @param args.format The format to retrieve metadata in. Defaults to "json".
+   * @returns The metadata in the specified format
+   */
+  async getMetadata(args: { format: "xml" }): Promise<string>;
+  async getMetadata(args?: { format?: "json" }): Promise<Metadata>;
+  async getMetadata(args?: {
+    format?: "xml" | "json";
+  }): Promise<string | Metadata> {
+    const result = await this.context._makeRequest<
+      Record<string, Metadata> | string
+    >(`/${this.databaseName}/$metadata`, {
+      headers: {
+        Accept: args?.format === "xml" ? "application/xml" : "application/json",
+      },
+    });
     if (result.error) {
       throw result.error;
     }
-    return result.data;
+
+    if (args?.format === "json") {
+      const data = result.data as Record<string, Metadata>;
+      const metadata = data[this.databaseName];
+      if (!metadata) {
+        throw new Error(
+          `Metadata for database "${this.databaseName}" not found in response`,
+        );
+      }
+      return metadata;
+    }
+    return result.data as string;
   }
 
   /**
@@ -277,4 +306,29 @@ export class Database<
       result: response.scriptResult.resultParameter,
     } as any;
   }
+
+  /**
+   * Create a batch operation builder that allows multiple queries to be executed together
+   * in a single atomic request. All operations succeed or fail together (transactional).
+   *
+   * @param builders - Array of executable query builders to batch
+   * @returns A BatchBuilder that can be executed
+   * @example
+   * ```ts
+   * const result = await db.batch([
+   *   db.from('contacts').list().top(5),
+   *   db.from('users').list().top(5),
+   *   db.from('contacts').insert({ name: 'John' })
+   * ]).execute();
+   *
+   * if (result.data) {
+   *   const [contacts, users, insertResult] = result.data;
+   * }
+   * ```
+   */
+  batch<const Builders extends readonly ExecutableBuilder<any>[]>(
+    builders: Builders,
+  ): BatchBuilder<Builders> {
+    return new BatchBuilder(builders, this.databaseName, this.context);
+  }
 }

package/src/client/delete-builder.ts

@@ -3,11 +3,12 @@ import type {
   ExecutableBuilder,
   Result,
   WithSystemFields,
+  ExecuteOptions,
 } from "../types";
 import type { TableOccurrence } from "./table-occurrence";
 import { QueryBuilder } from "./query-builder";
 import { type FFetchOptions } from "@fetchkit/ffetch";
-import buildQuery from "odata-query";
+import { getTableIdentifiers } from "../transform";
 
 /**
  * Initial delete builder returned from EntitySet.delete()
@@ -18,17 +19,20 @@ export class DeleteBuilder<T extends Record<string, any>> {
   private databaseName: string;
   private context: ExecutionContext;
   private occurrence?: TableOccurrence<any, any, any, any>;
+  private databaseUseEntityIds: boolean;
 
   constructor(config: {
     occurrence?: TableOccurrence<any, any, any, any>;
     tableName: string;
     databaseName: string;
     context: ExecutionContext;
+    databaseUseEntityIds?: boolean;
   }) {
     this.occurrence = config.occurrence;
     this.tableName = config.tableName;
     this.databaseName = config.databaseName;
     this.context = config.context;
+    this.databaseUseEntityIds = config.databaseUseEntityIds ?? false;
   }
 
   /**
@@ -42,6 +46,7 @@ export class DeleteBuilder<T extends Record<string, any>> {
       context: this.context,
       mode: "byId",
       recordId: id,
+      databaseUseEntityIds: this.databaseUseEntityIds,
     });
   }
 
@@ -78,6 +83,7 @@ export class DeleteBuilder<T extends Record<string, any>> {
       context: this.context,
       mode: "byFilter",
       queryBuilder: configuredBuilder,
+      databaseUseEntityIds: this.databaseUseEntityIds,
     });
   }
 }
@@ -96,6 +102,7 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
   private mode: "byId" | "byFilter";
   private recordId?: string | number;
   private queryBuilder?: QueryBuilder<any>;
+  private databaseUseEntityIds: boolean;
 
   constructor(config: {
     occurrence?: TableOccurrence<any, any, any, any>;
@@ -105,6 +112,7 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
     mode: "byId" | "byFilter";
     recordId?: string | number;
     queryBuilder?: QueryBuilder<any>;
+    databaseUseEntityIds?: boolean;
   }) {
     this.occurrence = config.occurrence;
     this.tableName = config.tableName;
@@ -113,16 +121,61 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
     this.mode = config.mode;
     this.recordId = config.recordId;
     this.queryBuilder = config.queryBuilder;
+    this.databaseUseEntityIds = config.databaseUseEntityIds ?? false;
+  }
+
+  /**
+   * Helper to merge database-level useEntityIds with per-request options
+   */
+  private mergeExecuteOptions(
+    options?: RequestInit & FFetchOptions & ExecuteOptions,
+  ): RequestInit & FFetchOptions & { useEntityIds?: boolean } {
+    // If useEntityIds is not set in options, use the database-level setting
+    return {
+      ...options,
+      useEntityIds: options?.useEntityIds ?? this.databaseUseEntityIds,
+    };
+  }
+
+  /**
+   * Gets the table ID (FMTID) if using entity IDs, otherwise returns the table name
+   * @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) {
+        throw new Error(
+          `useEntityIds is true but TableOccurrence "${identifiers.name}" does not have an fmtId defined`,
+        );
+      }
+      return identifiers.id;
+    }
+
+    return this.occurrence.getTableName();
   }
 
   async execute(
-    options?: RequestInit & FFetchOptions,
+    options?: RequestInit & FFetchOptions & { useEntityIds?: boolean },
   ): Promise<Result<{ deletedCount: number }>> {
+    // Merge database-level useEntityIds with per-request options
+    const mergedOptions = this.mergeExecuteOptions(options);
+
+    // Get table identifier with override support
+    const tableId = this.getTableId(mergedOptions.useEntityIds);
+
     let url: string;
 
     if (this.mode === "byId") {
       // Delete single record by ID: DELETE /{database}/{table}('id')
-      url = `/${this.databaseName}/${this.tableName}('${this.recordId}')`;
+      url = `/${this.databaseName}/${tableId}('${this.recordId}')`;
     } else {
       // Delete by filter: DELETE /{database}/{table}?$filter=...
       if (!this.queryBuilder) {
@@ -131,18 +184,20 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
 
       // Get the query string from the configured QueryBuilder
       const queryString = this.queryBuilder.getQueryString();
-      // Remove the leading "/" from the query string as we'll build our own URL
-      const queryParams = queryString.startsWith(`/${this.tableName}`)
-        ? queryString.slice(`/${this.tableName}`.length)
-        : queryString;
+      // 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;
 
-      url = `/${this.databaseName}/${this.tableName}${queryParams}`;
+      url = `/${this.databaseName}/${tableId}${queryParams}`;
     }
 
     // Make DELETE request
     const result = await this.context._makeRequest(url, {
       method: "DELETE",
-      ...options,
+      ...mergedOptions,
     });
 
     if (result.error) {
@@ -167,21 +222,26 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
   }
 
   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);
+
     let url: string;
 
     if (this.mode === "byId") {
-      url = `/${this.databaseName}/${this.tableName}('${this.recordId}')`;
+      url = `/${this.databaseName}/${tableId}('${this.recordId}')`;
     } else {
       if (!this.queryBuilder) {
         throw new Error("Query builder is required for filter-based delete");
       }
 
       const queryString = this.queryBuilder.getQueryString();
-      const queryParams = queryString.startsWith(`/${this.tableName}`)
-        ? queryString.slice(`/${this.tableName}`.length)
-        : queryString;
+      const queryParams = queryString.startsWith(`/${tableId}`)
+        ? queryString.slice(`/${tableId}`.length)
+        : queryString.startsWith(`/${this.tableName}`)
+          ? queryString.slice(`/${this.tableName}`.length)
+          : queryString;
 
-      url = `/${this.databaseName}/${this.tableName}${queryParams}`;
+      url = `/${this.databaseName}/${tableId}${queryParams}`;
     }
 
     return {
@@ -189,4 +249,46 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
       url,
     };
   }
+
+  toRequest(baseUrl: string): Request {
+    const config = this.getRequestConfig();
+    const fullUrl = `${baseUrl}${config.url}`;
+
+    return new Request(fullUrl, {
+      method: config.method,
+      headers: {
+        Accept: "application/json",
+      },
+    });
+  }
+
+  async processResponse(
+    response: Response,
+    options?: ExecuteOptions,
+  ): Promise<Result<{ deletedCount: number }>> {
+    // 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;
+      return { data: { deletedCount }, error: undefined };
+    }
+
+    const rawResponse = JSON.parse(text);
+
+    // OData returns 204 No Content with fmodata.affected_rows header
+    // The _makeRequest should handle extracting the header value
+    // For now, we'll check if response contains the count
+    let deletedCount = 0;
+
+    if (typeof rawResponse === "number") {
+      deletedCount = rawResponse;
+    } else if (rawResponse && typeof rawResponse === "object") {
+      // Check if the response has a count property (fallback)
+      deletedCount = (rawResponse as any).deletedCount || 0;
+    }
+
+    return { data: { deletedCount }, error: undefined };
+  }
 }