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

package/src/client/insert-builder.ts

@@ -1,62 +1,64 @@
+import type { FFetchOptions } from "@fetchkit/ffetch";
+import { InvalidLocationHeaderError } from "../errors";
+import type { FMTable } from "../orm/table";
+import { getBaseTableConfig, getTableId as getTableIdHelper, getTableName, isUsingEntityIds } from "../orm/table";
+import { transformFieldNamesToIds, transformResponseFields } from "../transform";
 import type {
-  ExecutionContext,
+  ConditionallyWithODataAnnotations,
   ExecutableBuilder,
-  Result,
-  ODataRecordMetadata,
-  InferSchemaType,
+  ExecuteMethodOptions,
   ExecuteOptions,
-  ConditionallyWithODataAnnotations,
+  ExecutionContext,
+  Result,
 } from "../types";
-import type { TableOccurrence } from "./table-occurrence";
-import { validateSingleResponse } from "../validation";
-import { type FFetchOptions } from "@fetchkit/ffetch";
-import {
-  transformFieldNamesToIds,
-  transformTableName,
-  transformResponseFields,
-  getTableIdentifiers,
-} from "../transform";
-import { InvalidLocationHeaderError } from "../errors";
+import { getAcceptHeader } from "../types";
+import { validateAndTransformInput, validateSingleResponse } from "../validation";
+import { parseErrorResponse } from "./error-parser";
+import { safeJsonParse } from "./sanitize-json";
+
+const ROWID_MATCH_REGEX = /ROWID=(\d+)/;
+const PAREN_VALUE_REGEX = /\(['"]?([^'"]+)['"]?\)/;
 
-export type InsertOptions = {
+export interface InsertOptions {
   return?: "minimal" | "representation";
-};
+}
+
+import type { InferSchemaOutputFromFMTable } from "../orm/table";
 
 export class InsertBuilder<
-  T extends Record<string, any>,
-  Occ extends TableOccurrence<any, any, any, any> | undefined = undefined,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  Occ extends FMTable<any, any> | undefined = undefined,
   ReturnPreference extends "minimal" | "representation" = "representation",
 > implements
     ExecutableBuilder<
-      ReturnPreference extends "minimal" ? { ROWID: number } : T
+      ReturnPreference extends "minimal" ? { ROWID: number } : InferSchemaOutputFromFMTable<NonNullable<Occ>>
     >
 {
-  private occurrence?: Occ;
-  private tableName: string;
-  private databaseName: string;
-  private context: ExecutionContext;
-  private data: Partial<T>;
-  private returnPreference: ReturnPreference;
+  private readonly table?: Occ;
+  private readonly databaseName: string;
+  private readonly context: ExecutionContext;
+  private readonly data: Partial<InferSchemaOutputFromFMTable<NonNullable<Occ>>>;
+  private readonly returnPreference: ReturnPreference;
 
-  private databaseUseEntityIds: boolean;
+  private readonly databaseUseEntityIds: boolean;
+  private readonly databaseIncludeSpecialColumns: boolean;
 
   constructor(config: {
     occurrence?: Occ;
-    tableName: string;
     databaseName: string;
     context: ExecutionContext;
-    data: Partial<T>;
+    data: Partial<InferSchemaOutputFromFMTable<NonNullable<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 ||
-      "representation") as ReturnPreference;
+    this.returnPreference = (config.returnPreference || "representation") as ReturnPreference;
     this.databaseUseEntityIds = config.databaseUseEntityIds ?? false;
+    this.databaseIncludeSpecialColumns = config.databaseIncludeSpecialColumns ?? false;
   }
 
   /**
@@ -72,23 +74,6 @@ export class InsertBuilder<
     };
   }
 
-  /**
-   * Helper to conditionally strip OData annotations based on options
-   */
-  private stripODataAnnotationsIfNeeded<T extends Record<string, any>>(
-    data: T,
-    options?: ExecuteOptions,
-  ): T {
-    // Only include annotations if explicitly requested
-    if (options?.includeODataAnnotations === true) {
-      return data;
-    }
-
-    // Strip OData annotations
-    const { "@id": _id, "@editLink": _editLink, ...rest } = data;
-    return rest as T;
-  }
-
   /**
    * Parse ROWID from Location header
    * Expected formats:
@@ -97,23 +82,21 @@ export class InsertBuilder<
    */
   private parseLocationHeader(locationHeader: string | undefined): number {
     if (!locationHeader) {
-      throw new InvalidLocationHeaderError(
-        "Location header is required but was not provided",
-      );
+      throw new InvalidLocationHeaderError("Location header is required but was not provided");
     }
 
     // Try to match ROWID=number pattern
-    const rowidMatch = locationHeader.match(/ROWID=(\d+)/);
-    if (rowidMatch && rowidMatch[1]) {
-      return parseInt(rowidMatch[1], 10);
+    const rowidMatch = locationHeader.match(ROWID_MATCH_REGEX);
+    if (rowidMatch?.[1]) {
+      return Number.parseInt(rowidMatch[1], 10);
     }
 
     // Try to extract value from parentheses and parse as number
-    const parenMatch = locationHeader.match(/\(['"]?([^'"]+)['"]?\)/);
-    if (parenMatch && parenMatch[1]) {
+    const parenMatch = locationHeader.match(PAREN_VALUE_REGEX);
+    if (parenMatch?.[1]) {
       const value = parenMatch[1];
-      const numValue = parseInt(value, 10);
-      if (!isNaN(numValue)) {
+      const numValue = Number.parseInt(value, 10);
+      if (!Number.isNaN(numValue)) {
         return numValue;
       }
     }
@@ -129,65 +112,80 @@ export class InsertBuilder<
    * @param useEntityIds - Optional override for entity ID usage
    */
   private getTableId(useEntityIds?: boolean): string {
-    if (!this.occurrence) {
-      return this.tableName;
+    if (!this.table) {
+      throw new Error("Table occurrence is required");
     }
 
     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<EO extends ExecuteOptions>(
-    options?: RequestInit & FFetchOptions & EO,
+    options?: ExecuteMethodOptions<EO>,
   ): Promise<
     Result<
       ReturnPreference extends "minimal"
         ? { ROWID: number }
         : ConditionallyWithODataAnnotations<
-            T,
+            InferSchemaOutputFromFMTable<NonNullable<Occ>>,
             EO["includeODataAnnotations"] extends true ? true : false
           >
     >
   > {
     // 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);
     const url = `/${this.databaseName}/${tableId}`;
 
+    // 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;
+
+    const transformedData =
+      this.table && shouldUseIds ? transformFieldNamesToIds(validatedData, this.table) : validatedData;
 
     // Set Prefer header based on return preference
-    const preferHeader =
-      this.returnPreference === "minimal"
-        ? "return=minimal"
-        : "return=representation";
+    const preferHeader = this.returnPreference === "minimal" ? "return=minimal" : "return=representation";
 
     // Make POST request with JSON body
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic response type from OData API
     const result = await this.context._makeRequest<any>(url, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         Prefer: preferHeader,
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for headers object
         ...((mergedOptions as any)?.headers || {}),
       },
       body: JSON.stringify(transformedData),
@@ -202,15 +200,17 @@ export class InsertBuilder<
     if (this.returnPreference === "minimal") {
       // The response should be empty (204 No Content)
       // _makeRequest will return { _location: string } when there's a Location header
+      // biome-ignore lint/suspicious/noExplicitAny: Dynamic response type from OData API
       const responseData = result.data as any;
 
-      if (!responseData || !responseData._location) {
+      if (!responseData?._location) {
         throw new InvalidLocationHeaderError(
           "Location header is required when using return=minimal but was not found in response",
         );
       }
 
       const rowid = this.parseLocationHeader(responseData._location);
+      // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
       return { data: { ROWID: rowid } as any, error: undefined };
     }
 
@@ -218,19 +218,30 @@ export class InsertBuilder<
 
     // Transform response field IDs back to names if using entity IDs
     // Only transform if useEntityIds resolves to true (respects per-request override)
-    if (this.occurrence?.baseTable && shouldUseIds) {
+    if (this.table && shouldUseIds) {
       response = transformResponseFields(
         response,
-        this.occurrence.baseTable,
+        this.table,
         undefined, // No expand configs for insert
       );
     }
 
-    // Get schema from occurrence if available
-    const schema = this.occurrence?.baseTable?.schema;
+    // Get schema from table if available, excluding container fields
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic schema shape from table configuration
+    let schema: Record<string, any> | undefined;
+    if (this.table) {
+      const baseTableConfig = getBaseTableConfig(this.table);
+      const containerFields = baseTableConfig.containerFields || [];
+
+      // Filter out container fields from schema
+      schema = { ...baseTableConfig.schema };
+      for (const containerField of containerFields) {
+        delete schema[containerField as string];
+      }
+    }
 
     // Validate the response (FileMaker returns the created record)
-    const validation = await validateSingleResponse<T>(
+    const validation = await validateSingleResponse<InferSchemaOutputFromFMTable<NonNullable<Occ>>>(
       response,
       schema,
       undefined, // No selected fields for insert
@@ -250,23 +261,19 @@ export class InsertBuilder<
       };
     }
 
-    // Strip OData annotations unless explicitly requested
-    const finalData = this.stripODataAnnotationsIfNeeded(
-      validation.data,
-      options,
-    );
-
-    return { data: finalData as any, error: undefined };
+    // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
+    return { data: validation.data as any, 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;
+    const transformedData =
+      this.table && this.databaseUseEntityIds ? transformFieldNamesToIds(this.data, this.table) : this.data;
 
     return {
       method: "POST",
@@ -275,21 +282,18 @@ export class InsertBuilder<
     };
   }
 
-  toRequest(baseUrl: string): Request {
+  toRequest(baseUrl: string, options?: ExecuteOptions): Request {
     const config = this.getRequestConfig();
     const fullUrl = `${baseUrl}${config.url}`;
 
     // Set Prefer header based on return preference
-    const preferHeader =
-      this.returnPreference === "minimal"
-        ? "return=minimal"
-        : "return=representation";
+    const preferHeader = this.returnPreference === "minimal" ? "return=minimal" : "return=representation";
 
     return new Request(fullUrl, {
       method: config.method,
       headers: {
         "Content-Type": "application/json",
-        Accept: "application/json",
+        Accept: getAcceptHeader(options?.includeODataAnnotations),
         Prefer: preferHeader,
       },
       body: config.body,
@@ -300,17 +304,24 @@ export class InsertBuilder<
     response: Response,
     options?: ExecuteOptions,
   ): Promise<
-    Result<ReturnPreference extends "minimal" ? { ROWID: number } : T>
+    Result<ReturnPreference extends "minimal" ? { ROWID: number } : InferSchemaOutputFromFMTable<NonNullable<Occ>>>
   > {
+    // Check for error responses (important for batch operations)
+    if (!response.ok) {
+      const tableName = this.table ? getTableName(this.table) : "unknown";
+      const error = await parseErrorResponse(response, response.url || `/${this.databaseName}/${tableName}`);
+      return { data: undefined, error };
+    }
+
     // Handle 204 No Content (common in batch/changeset operations)
     // FileMaker uses return=minimal for changeset operations regardless of Prefer header
     if (response.status === 204) {
       // Check for Location header (for return=minimal)
       if (this.returnPreference === "minimal") {
-        const locationHeader =
-          response.headers.get("Location") || response.headers.get("location");
+        const locationHeader = response.headers.get("Location") || response.headers.get("location");
         if (locationHeader) {
           const rowid = this.parseLocationHeader(locationHeader);
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
           return { data: { ROWID: rowid } as any, error: undefined };
         }
         throw new InvalidLocationHeaderError(
@@ -322,6 +333,7 @@ export class InsertBuilder<
       // This is valid OData behavior for changeset operations
       // We return a success indicator but no actual data
       return {
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
         data: {} as any,
         error: undefined,
       };
@@ -334,13 +346,15 @@ export class InsertBuilder<
       );
     }
 
-    let rawResponse;
+    // Use safeJsonParse to handle FileMaker's invalid JSON with unquoted ? values
+    let rawResponse: unknown;
     try {
-      rawResponse = await response.json();
+      rawResponse = await safeJsonParse(response);
     } catch (err) {
       // If parsing fails with 204, handle it gracefully
       if (response.status === 204) {
         return {
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
           data: {} as any,
           error: undefined,
         };
@@ -351,28 +365,58 @@ export class InsertBuilder<
           name: "ResponseParseError",
           message: `Failed to parse response JSON: ${err instanceof Error ? err.message : "Unknown error"}`,
           timestamp: new Date(),
+          // biome-ignore lint/suspicious/noExplicitAny: Type assertion for error object
         } as any,
       };
     }
 
+    // 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;
+      }
+    }
+
     // Transform response field IDs back to names if using entity IDs
     // Only transform if useEntityIds resolves to true (respects per-request override)
     const shouldUseIds = options?.useEntityIds ?? this.databaseUseEntityIds;
-    
+
     let transformedResponse = rawResponse;
-    if (this.occurrence?.baseTable && shouldUseIds) {
+    if (this.table && shouldUseIds) {
       transformedResponse = transformResponseFields(
         rawResponse,
-        this.occurrence.baseTable,
+        this.table,
         undefined, // No expand configs for insert
       );
     }
 
-    // Get schema from occurrence if available
-    const schema = this.occurrence?.baseTable?.schema;
+    // Get schema from table if available, excluding container fields
+    // biome-ignore lint/suspicious/noExplicitAny: Dynamic schema shape from table configuration
+    let schema: Record<string, any> | undefined;
+    if (this.table) {
+      const baseTableConfig = getBaseTableConfig(this.table);
+      const containerFields = baseTableConfig.containerFields || [];
+
+      // Filter out container fields from schema
+      schema = { ...baseTableConfig.schema };
+      for (const containerField of containerFields) {
+        delete schema[containerField as string];
+      }
+    }
 
     // Validate the response (FileMaker returns the created record)
-    const validation = await validateSingleResponse<T>(
+    const validation = await validateSingleResponse<InferSchemaOutputFromFMTable<NonNullable<Occ>>>(
       transformedResponse,
       schema,
       undefined, // No selected fields for insert
@@ -392,12 +436,7 @@ export class InsertBuilder<
       };
     }
 
-    // Strip OData annotations unless explicitly requested
-    const finalData = this.stripODataAnnotationsIfNeeded(
-      validation.data,
-      options,
-    );
-
-    return { data: finalData as any, error: undefined };
+    // biome-ignore lint/suspicious/noExplicitAny: Type assertion for generic return type
+    return { data: validation.data as any, error: undefined };
   }
 }

package/src/client/query/expand-builder.ts

@@ -0,0 +1,160 @@
+import type { StandardSchemaV1 } from "@standard-schema/spec";
+import buildQuery, { type QueryOptions } from "odata-query";
+import { FMTable } from "../../orm/table";
+import type { ExpandValidationConfig } from "../../validation";
+import { formatSelectFields } from "../builders/select-utils";
+
+const FILTER_QUERY_REGEX = /\$filter=([^&]+)/;
+
+/**
+ * Internal type for expand configuration
+ */
+export interface ExpandConfig {
+  relation: string;
+  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any QueryOptions configuration
+  options?: Partial<QueryOptions<any>>;
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  targetTable?: FMTable<any, any>;
+}
+
+/**
+ * Builds OData expand query strings and validation configs.
+ * Handles nested expands recursively and transforms relation names to FMTIDs
+ * when using entity IDs.
+ */
+export class ExpandBuilder {
+  private readonly useEntityIds: boolean;
+
+  constructor(useEntityIds: boolean) {
+    this.useEntityIds = useEntityIds;
+  }
+
+  /**
+   * Builds OData expand query string from expand configurations.
+   * Handles nested expands recursively.
+   * Transforms relation names to FMTIDs if using entity IDs.
+   */
+  buildExpandString(configs: ExpandConfig[]): string {
+    if (configs.length === 0) {
+      return "";
+    }
+
+    return configs.map((config) => this.buildSingleExpand(config)).join(",");
+  }
+
+  /**
+   * Builds a single expand string with its options.
+   */
+  private buildSingleExpand(config: ExpandConfig): string {
+    // Get target table/occurrence from config (stored during expand call)
+    const targetTable = config.targetTable;
+
+    // When using entity IDs, use the target table's FMTID in the expand parameter
+    // FileMaker expects FMTID in $expand when Prefer header is set
+    // Only use FMTID if databaseUseEntityIds is enabled
+    let relationName = config.relation;
+    if (this.useEntityIds && targetTable && FMTable.Symbol.EntityId in targetTable) {
+      // biome-ignore lint/suspicious/noExplicitAny: Type assertion for Symbol property access
+      const tableId = (targetTable as any)[FMTable.Symbol.EntityId] as `FMTID:${string}` | undefined;
+      if (tableId) {
+        relationName = tableId;
+      }
+    }
+
+    if (!config.options || Object.keys(config.options).length === 0) {
+      // Simple expand without options
+      return relationName;
+    }
+
+    // Build query options for this expand
+    const parts: string[] = [];
+
+    if (config.options.select) {
+      // Use shared formatSelectFields function for consistent id field quoting
+      const selectArray = Array.isArray(config.options.select)
+        ? config.options.select.map(String)
+        : [String(config.options.select)];
+      const selectFields = formatSelectFields(selectArray, targetTable, this.useEntityIds);
+      parts.push(`$select=${selectFields}`);
+    }
+
+    if (config.options.filter) {
+      // Filter should already be transformed by the nested builder
+      // Use odata-query to build filter string
+      const filterQuery = buildQuery({ filter: config.options.filter });
+      const filterMatch = filterQuery.match(FILTER_QUERY_REGEX);
+      if (filterMatch) {
+        parts.push(`$filter=${filterMatch[1]}`);
+      }
+    }
+
+    if (config.options.orderBy) {
+      // OrderBy should already be transformed by the nested builder
+      const orderByValue = Array.isArray(config.options.orderBy)
+        ? config.options.orderBy.join(",")
+        : config.options.orderBy;
+      parts.push(`$orderby=${String(orderByValue)}`);
+    }
+
+    if (config.options.top !== undefined) {
+      parts.push(`$top=${config.options.top}`);
+    }
+
+    if (config.options.skip !== undefined) {
+      parts.push(`$skip=${config.options.skip}`);
+    }
+
+    // Handle nested expands (from expand configs)
+    if (config.options.expand && typeof config.options.expand === "string") {
+      // If expand is a string, it's already been built
+      parts.push(`$expand=${config.options.expand}`);
+    }
+
+    if (parts.length === 0) {
+      return relationName;
+    }
+
+    return `${relationName}(${parts.join(";")})`;
+  }
+
+  /**
+   * Builds expand validation configs from internal expand configurations.
+   * These are used to validate expanded navigation properties.
+   */
+  buildValidationConfigs(configs: ExpandConfig[]): ExpandValidationConfig[] {
+    return configs.map((config) => {
+      // Get target table/occurrence from config (stored during expand call)
+      const targetTable = config.targetTable;
+
+      // Extract schema from target table/occurrence
+      let targetSchema: Record<string, StandardSchemaV1> | undefined;
+      if (targetTable) {
+        // biome-ignore lint/suspicious/noExplicitAny: Type assertion for Symbol property access
+        const tableSchema = (targetTable as any)[FMTable.Symbol.Schema];
+        if (tableSchema) {
+          const zodSchema = tableSchema["~standard"]?.schema;
+          if (zodSchema && typeof zodSchema === "object" && "shape" in zodSchema) {
+            targetSchema = zodSchema.shape as Record<string, StandardSchemaV1>;
+          }
+        }
+      }
+
+      // Extract selected fields from options
+      let selectedFields: string[] | undefined;
+      if (config.options?.select) {
+        selectedFields = Array.isArray(config.options.select)
+          ? config.options.select.map((f) => String(f))
+          : [String(config.options.select)];
+      }
+
+      return {
+        relation: config.relation,
+        targetSchema,
+        targetTable,
+        table: targetTable, // For transformation
+        selectedFields,
+        nestedExpands: undefined, // TODO: Handle nested expands if needed
+      };
+    });
+  }
+}

package/src/client/query/index.ts

@@ -0,0 +1,14 @@
+/** biome-ignore-all lint/performance/noBarrelFile: Re-exporting QueryBuilder and types */
+
+// Re-export QueryBuilder as the main export
+
+// Export ExpandConfig from expand-builder
+export type { ExpandConfig } from "./expand-builder";
+
+// Export types
+export type {
+  ExpandedRelations,
+  QueryReturnType,
+  TypeSafeOrderBy,
+} from "./query-builder";
+export { QueryBuilder } from "./query-builder";