@proofkit/fmodata 0.1.0-alpha.13 → 0.1.0-alpha.15

package/src/client/builders/shared-types.ts

@@ -0,0 +1,41 @@
+import type { QueryOptions } from "odata-query";
+import type { ExecutionContext } from "../../types";
+import type { FMTable } from "../../orm/table";
+
+/**
+ * Expand configuration used by both QueryBuilder and RecordBuilder
+ */
+export type ExpandConfig = {
+  relation: string;
+  options?: Partial<QueryOptions<any>>;
+  targetTable?: FMTable<any, any>;
+};
+
+/**
+ * Type to represent expanded relations in return types
+ */
+export type ExpandedRelations = Record<string, { schema: any; selected: any }>;
+
+/**
+ * Navigation context shared between builders
+ */
+export interface NavigationContext {
+  isNavigate?: boolean;
+  navigateRecordId?: string | number;
+  navigateRelation?: string;
+  navigateSourceTableName?: string;
+  navigateBaseRelation?: string;
+  navigateBasePath?: string;
+}
+
+/**
+ * Common builder configuration
+ */
+export interface BuilderConfig<Occ extends FMTable<any, any> | undefined> {
+  occurrence?: Occ;
+  tableName: string;
+  databaseName: string;
+  context: ExecutionContext;
+  databaseUseEntityIds?: boolean;
+}
+

package/src/client/builders/table-utils.ts

@@ -0,0 +1,87 @@
+import type { ExecutionContext } from "../../types";
+import { getAcceptHeader } from "../../types";
+import type { FMTable } from "../../orm/table";
+import {
+  getTableName,
+  getTableId as getTableIdHelper,
+  isUsingEntityIds,
+} from "../../orm/table";
+import type { FFetchOptions } from "@fetchkit/ffetch";
+import type { ExecuteOptions } from "../../types";
+
+/**
+ * Resolves table identifier based on entity ID settings.
+ * Used by both QueryBuilder and RecordBuilder.
+ */
+export function resolveTableId(
+  table: FMTable<any, any> | undefined,
+  fallbackTableName: string,
+  context: ExecutionContext,
+  useEntityIdsOverride?: boolean,
+): string {
+  if (!table) {
+    return fallbackTableName;
+  }
+
+  const contextDefault = context._getUseEntityIds?.() ?? false;
+  const shouldUseIds = useEntityIdsOverride ?? contextDefault;
+
+  if (shouldUseIds) {
+    if (!isUsingEntityIds(table)) {
+      throw new Error(
+        `useEntityIds is true but table "${getTableName(table)}" does not have entity IDs configured`,
+      );
+    }
+    return getTableIdHelper(table);
+  }
+
+  return getTableName(table);
+}
+
+/**
+ * Merges database-level useEntityIds with per-request options.
+ */
+export function mergeEntityIdOptions<T extends Record<string, any>>(
+  options: T | undefined,
+  databaseDefault: boolean,
+): T & { useEntityIds?: boolean } {
+  return {
+    ...options,
+    useEntityIds: (options as any)?.useEntityIds ?? databaseDefault,
+  } as T & { useEntityIds?: boolean };
+}
+
+/**
+ * Type-safe helper for merging execute options with entity ID settings
+ */
+export function mergeExecuteOptions(
+  options: (RequestInit & FFetchOptions & ExecuteOptions) | undefined,
+  databaseUseEntityIds: boolean,
+): RequestInit & FFetchOptions & { useEntityIds?: boolean } {
+  return mergeEntityIdOptions(options, databaseUseEntityIds);
+}
+
+/**
+ * Creates an OData Request object with proper headers.
+ * Used by both QueryBuilder and RecordBuilder to eliminate duplication.
+ *
+ * @param baseUrl - Base URL for the request
+ * @param config - Request configuration with method and url
+ * @param options - Optional execution options
+ * @returns Request object ready to use
+ */
+export function createODataRequest(
+  baseUrl: string,
+  config: { method: string; url: string },
+  options?: { includeODataAnnotations?: boolean },
+): Request {
+  const fullUrl = `${baseUrl}${config.url}`;
+
+  return new Request(fullUrl, {
+    method: config.method,
+    headers: {
+      "Content-Type": "application/json",
+      Accept: getAcceptHeader(options?.includeODataAnnotations),
+    },
+  });
+}

package/src/client/database.ts

@@ -1,50 +1,11 @@
 import type { StandardSchemaV1 } from "@standard-schema/spec";
 import type { ExecutionContext, ExecutableBuilder, Metadata } from "../types";
-import type { BaseTable } from "./base-table";
-import type { TableOccurrence } from "./table-occurrence";
 import { EntitySet } from "./entity-set";
 import { BatchBuilder } from "./batch-builder";
 import { SchemaManager } from "./schema-manager";
+import { FMTable } from "../orm/table";
 
-// 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, any, any>
-      ? S
-      : never
-    : never;
-
-// Helper type to find an occurrence by name in the occurrences tuple
-type FindOccurrenceByName<
-  Occurrences extends readonly TableOccurrence<any, any, any, any>[],
-  Name extends string,
-> = Occurrences extends readonly [
-  infer First,
-  ...infer Rest extends readonly TableOccurrence<any, any, any, any>[],
-]
-  ? First extends TableOccurrence<any, any, any, any>
-    ? First["name"] extends Name
-      ? First
-      : FindOccurrenceByName<Rest, Name>
-    : never
-  : never;
-
-// Helper type to extract all occurrence names from the tuple
-type ExtractOccurrenceNames<
-  Occurrences extends readonly TableOccurrence<any, any, any, any>[],
-> = Occurrences extends readonly []
-  ? string // If no occurrences, allow any string
-  : Occurrences[number]["name"]; // Otherwise, extract union of names
-
-export class Database<
-  Occurrences extends readonly TableOccurrence<
-    any,
-    any,
-    any,
-    any
-  >[] = readonly [],
-> {
-  private occurrenceMap: Map<string, TableOccurrence<any, any, any, any>>;
+export class Database {
   private _useEntityIds: boolean = false;
   public readonly schema: SchemaManager;
 
@@ -52,7 +13,6 @@ export class Database<
     private readonly databaseName: string,
     private readonly context: ExecutionContext,
     config?: {
-      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
@@ -61,129 +21,28 @@ export class Database<
       useEntityIds?: boolean;
     },
   ) {
-    this.occurrenceMap = new Map();
-    if (config?.occurrences) {
-      // Validate consistency: either all occurrences use entity IDs or none do
-      const occurrencesWithIds: string[] = [];
-      const occurrencesWithoutIds: string[] = [];
-
-      for (const occ of config.occurrences) {
-        this.occurrenceMap.set(occ.name, occ);
-
-        const hasTableId = occ.isUsingTableId();
-        const hasFieldIds = occ.baseTable.isUsingFieldIds();
-
-        // An occurrence uses entity IDs if it has both fmtId and fmfIds
-        if (hasTableId && hasFieldIds) {
-          occurrencesWithIds.push(occ.name);
-        } else if (!hasTableId && !hasFieldIds) {
-          occurrencesWithoutIds.push(occ.name);
-        } else {
-          // Partial entity ID usage (only one of fmtId or fmfIds) - this is an error
-          throw new Error(
-            `TableOccurrence "${occ.name}" has inconsistent entity ID configuration. ` +
-              `Both fmtId (${hasTableId ? "present" : "missing"}) and fmfIds (${hasFieldIds ? "present" : "missing"}) must be defined together.`,
-          );
-        }
-      }
-
-      // 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);
+    this._useEntityIds = config?.useEntityIds ?? false;
   }
 
-  /**
-   * Returns true if any table occurrence in this database is using entity IDs.
-   */
-  isUsingEntityIds(): boolean {
-    return this._useEntityIds;
-  }
-
-  /**
-   * Gets a table occurrence by name.
-   * @internal
-   */
-  getOccurrence(name: string): TableOccurrence<any, any, any, any> | undefined {
-    return this.occurrenceMap.get(name);
-  }
-
-  from<Name extends ExtractOccurrenceNames<Occurrences> | (string & {})>(
-    name: Name,
-  ): Occurrences extends readonly []
-    ? EntitySet<Record<string, StandardSchemaV1>, undefined>
-    : Name extends ExtractOccurrenceNames<Occurrences>
-      ? EntitySet<
-          ExtractSchemaFromOccurrence<FindOccurrenceByName<Occurrences, Name>>,
-          FindOccurrenceByName<Occurrences, Name>
-        >
-      : EntitySet<Record<string, StandardSchemaV1>, undefined> {
-    const occurrence = this.occurrenceMap.get(name as string);
-
-    if (occurrence) {
-      // Use EntitySet.create to preserve types better
-      type OccType = FindOccurrenceByName<Occurrences, Name>;
-      type SchemaType = ExtractSchemaFromOccurrence<OccType>;
-
-      return EntitySet.create<SchemaType, OccType>({
-        occurrence: occurrence as OccType,
-        tableName: name as string,
-        databaseName: this.databaseName,
-        context: this.context,
-        database: this,
-      }) as any;
-    } else {
-      // Return untyped EntitySet for dynamic table access
-      return new EntitySet<Record<string, StandardSchemaV1>, undefined>({
-        tableName: name as string,
-        databaseName: this.databaseName,
-        context: this.context,
-        database: this,
-      }) as any;
+  from<T extends FMTable<any, any>>(table: T): EntitySet<T> {
+    // Only override database-level useEntityIds if table explicitly sets it
+    // (not if it's undefined, which would override the database setting)
+    if (
+      Object.prototype.hasOwnProperty.call(table, FMTable.Symbol.UseEntityIds)
+    ) {
+      const tableUseEntityIds = (table as any)[FMTable.Symbol.UseEntityIds];
+      if (typeof tableUseEntityIds === "boolean") {
+        this._useEntityIds = tableUseEntityIds;
+      }
     }
+    return new EntitySet<T>({
+      occurrence: table as T,
+      databaseName: this.databaseName,
+      context: this.context,
+      database: this,
+    });
   }
 
   /**

package/src/client/delete-builder.ts

@@ -4,33 +4,36 @@ import type {
   Result,
   WithSystemFields,
   ExecuteOptions,
+  ExecuteMethodOptions,
 } from "../types";
 import { getAcceptHeader } from "../types";
-import type { TableOccurrence } from "./table-occurrence";
+import type { FMTable, InferSchemaOutputFromFMTable } from "../orm/table";
+import {
+  getTableName,
+  getTableId as getTableIdHelper,
+  isUsingEntityIds,
+} from "../orm/table";
 import { QueryBuilder } from "./query-builder";
 import { type FFetchOptions } from "@fetchkit/ffetch";
-import { getTableIdentifiers } from "../transform";
+import { parseErrorResponse } from "./error-parser";
 
 /**
  * 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;
+export class DeleteBuilder<Occ extends FMTable<any, any>> {
   private databaseName: string;
   private context: ExecutionContext;
-  private occurrence?: TableOccurrence<any, any, any, any>;
+  private table: Occ;
   private databaseUseEntityIds: boolean;
 
   constructor(config: {
-    occurrence?: TableOccurrence<any, any, any, any>;
-    tableName: string;
+    occurrence: Occ;
     databaseName: string;
     context: ExecutionContext;
     databaseUseEntityIds?: 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;
@@ -39,10 +42,9 @@ export class DeleteBuilder<T extends Record<string, any>> {
   /**
    * 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",
@@ -56,20 +58,11 @@ export class DeleteBuilder<T extends Record<string, any>> {
    * @param fn Callback that receives a QueryBuilder for building the filter
    */
   where(
-    fn: (
-      q: QueryBuilder<WithSystemFields<T>>,
-    ) => QueryBuilder<WithSystemFields<T>>,
-  ): ExecutableDeleteBuilder<T> {
+    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,
     });
@@ -77,9 +70,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",
@@ -93,30 +85,27 @@ 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>>
+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 table: Occ;
   private mode: "byId" | "byFilter";
   private recordId?: string | number;
-  private queryBuilder?: QueryBuilder<any>;
+  private queryBuilder?: QueryBuilder<Occ>;
   private 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;
@@ -143,28 +132,23 @@ 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 },
+    options?: ExecuteMethodOptions<ExecuteOptions>,
   ): Promise<Result<{ deletedCount: number }>> {
     // Merge database-level useEntityIds with per-request options
     const mergedOptions = this.mergeExecuteOptions(options);
@@ -186,10 +170,11 @@ 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 tableName = getTableName(this.table);
       const queryParams = queryString.startsWith(`/${tableId}`)
         ? queryString.slice(`/${tableId}`.length)
-        : queryString.startsWith(`/${this.tableName}`)
-          ? queryString.slice(`/${this.tableName}`.length)
+        : queryString.startsWith(`/${tableName}`)
+          ? queryString.slice(`/${tableName}`.length)
           : queryString;
 
       url = `/${this.databaseName}/${tableId}${queryParams}`;
@@ -236,10 +221,11 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
       }
 
       const queryString = this.queryBuilder.getQueryString();
+      const tableName = getTableName(this.table);
       const queryParams = queryString.startsWith(`/${tableId}`)
         ? queryString.slice(`/${tableId}`.length)
-        : queryString.startsWith(`/${this.tableName}`)
-          ? queryString.slice(`/${this.tableName}`.length)
+        : queryString.startsWith(`/${tableName}`)
+          ? queryString.slice(`/${tableName}`.length)
           : queryString;
 
       url = `/${this.databaseName}/${tableId}${queryParams}`;
@@ -267,6 +253,16 @@ export class ExecutableDeleteBuilder<T extends Record<string, any>>
     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() === "") {