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

package/src/transform.ts

@@ -1,24 +1,30 @@
-import type { BaseTable } from "./client/base-table";
-import type { TableOccurrence } from "./client/table-occurrence";
-import type { StandardSchemaV1 } from "@standard-schema/spec";
+import type { FMTable } from "./orm/table";
+import { getBaseTableConfig, getFieldId, getFieldName, getTableId, getTableName, isUsingEntityIds } from "./orm/table";
+
+const WHITESPACE_SPLIT_REGEX = /\s+/;
 
 /**
  * Transforms field names to FileMaker field IDs (FMFID) in an object
  * @param data - Object with field names as keys
- * @param baseTable - BaseTable instance to get field IDs from
+ * @param table - FMTable instance to get field IDs from
  * @returns Object with FMFID keys instead of field names
  */
+// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any record shape
 export function transformFieldNamesToIds<T extends Record<string, any>>(
   data: T,
-  baseTable: BaseTable<any, any, any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  table: FMTable<any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation
 ): Record<string, any> {
-  if (!baseTable.isUsingFieldIds()) {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return data;
   }
 
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation
   const transformed: Record<string, any> = {};
   for (const [fieldName, value] of Object.entries(data)) {
-    const fieldId = baseTable.getFieldId(fieldName as any);
+    const fieldId = getFieldId(table, fieldName);
     transformed[fieldId] = value;
   }
   return transformed;
@@ -27,17 +33,22 @@ export function transformFieldNamesToIds<T extends Record<string, any>>(
 /**
  * Transforms FileMaker field IDs (FMFID) to field names in an object
  * @param data - Object with FMFID keys
- * @param baseTable - BaseTable instance to get field names from
+ * @param table - FMTable instance to get field names from
  * @returns Object with field names as keys instead of FMFIDs
  */
+// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any record shape
 export function transformFieldIdsToNames<T extends Record<string, any>>(
   data: T,
-  baseTable: BaseTable<any, any, any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  table: FMTable<any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation
 ): Record<string, any> {
-  if (!baseTable.isUsingFieldIds()) {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return data;
   }
 
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation
   const transformed: Record<string, any> = {};
   for (const [key, value] of Object.entries(data)) {
     // Check if this is an OData metadata field (starts with @)
@@ -46,7 +57,7 @@ export function transformFieldIdsToNames<T extends Record<string, any>>(
       continue;
     }
 
-    const fieldName = baseTable.getFieldName(key);
+    const fieldName = getFieldName(table, key);
     transformed[fieldName] = value;
   }
   return transformed;
@@ -55,38 +66,34 @@ export function transformFieldIdsToNames<T extends Record<string, any>>(
 /**
  * Transforms a field name to FMFID or returns the field name if not using IDs
  * @param fieldName - The field name to transform
- * @param baseTable - BaseTable instance to get field ID from
+ * @param table - FMTable instance to get field ID from
  * @returns The FMFID or field name
  */
-export function transformFieldName(
-  fieldName: string,
-  baseTable: BaseTable<any, any, any, any>,
-): string {
-  return baseTable.getFieldId(fieldName as any);
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export function transformFieldName(fieldName: string, table: FMTable<any, any>): string {
+  return getFieldId(table, fieldName);
 }
 
 /**
- * Transforms a table occurrence name to FMTID or returns the name if not using IDs
- * @param occurrence - TableOccurrence instance to get table ID from
+ * Transforms a table name to FMTID or returns the name if not using IDs
+ * @param table - FMTable instance to get table ID from
  * @returns The FMTID or table name
  */
-export function transformTableName(
-  occurrence: TableOccurrence<any, any, any, any>,
-): string {
-  return occurrence.getTableId();
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export function transformTableName(table: FMTable<any, any>): string {
+  return getTableId(table);
 }
 
 /**
- * Gets both table name and ID from an occurrence
- * @param occurrence - TableOccurrence instance
+ * Gets both table name and ID from a table
+ * @param table - FMTable instance
  * @returns Object with name (always present) and id (may be undefined if not using IDs)
  */
-export function getTableIdentifiers(
-  occurrence: TableOccurrence<any, any, any, any>,
-): { name: string; id: string | undefined } {
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export function getTableIdentifiers(table: FMTable<any, any>): { name: string; id: string | undefined } {
   return {
-    name: occurrence.getTableName(),
-    id: occurrence.isUsingTableId() ? occurrence.getTableId() : undefined,
+    name: getTableName(table),
+    id: isUsingEntityIds(table) ? getTableId(table) : undefined,
   };
 }
 
@@ -95,19 +102,24 @@ export function getTableIdentifiers(
  * Handles both single records and arrays of records, as well as nested expand relationships.
  *
  * @param data - Response data from FileMaker (can be single record, array, or wrapped in value property)
- * @param baseTable - BaseTable instance for the main table
+ * @param table - FMTable instance for the main table
  * @param expandConfigs - Configuration for expanded relations (optional)
  * @returns Transformed data with field names instead of IDs
  */
 export function transformResponseFields(
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic response data transformation
   data: any,
-  baseTable: BaseTable<any, any, any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  table: FMTable<any, any>,
   expandConfigs?: Array<{
     relation: string;
-    occurrence?: TableOccurrence<any, any, any, any>;
+    // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+    table?: FMTable<any, any>;
   }>,
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic response data transformation
 ): any {
-  if (!baseTable.isUsingFieldIds()) {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return data;
   }
 
@@ -120,38 +132,40 @@ export function transformResponseFields(
   if (data.value && Array.isArray(data.value)) {
     return {
       ...data,
-      value: data.value.map((record: any) =>
-        transformSingleRecord(record, baseTable, expandConfigs),
-      ),
+      // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation
+      value: data.value.map((record: any) => transformSingleRecord(record, table, expandConfigs)),
     };
   }
 
   // Handle array of records
   if (Array.isArray(data)) {
-    return data.map((record) =>
-      transformSingleRecord(record, baseTable, expandConfigs),
-    );
+    return data.map((record) => transformSingleRecord(record, table, expandConfigs));
   }
 
   // Handle single record
-  return transformSingleRecord(data, baseTable, expandConfigs);
+  return transformSingleRecord(data, table, expandConfigs);
 }
 
 /**
  * Transforms a single record, converting field IDs to names and handling nested expands
  */
 function transformSingleRecord(
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation
   record: any,
-  baseTable: BaseTable<any, any, any, any>,
+  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+  table: FMTable<any, any>,
   expandConfigs?: Array<{
     relation: string;
-    occurrence?: TableOccurrence<any, any, any, any>;
+    // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+    table?: FMTable<any, any>;
   }>,
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation
 ): any {
   if (!record || typeof record !== "object") {
     return record;
   }
 
+  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation
   const transformed: Record<string, any> = {};
 
   for (const [key, value] of Object.entries(record)) {
@@ -168,32 +182,34 @@ function transformSingleRecord(
     // (FileMaker returns expanded relations with FMTID keys when using entity IDs)
     if (!expandConfig && key.startsWith("FMTID:")) {
       expandConfig = expandConfigs?.find(
-        (ec) =>
-          ec.occurrence &&
-          ec.occurrence.isUsingTableId() &&
-          ec.occurrence.getTableId() === key,
+        (ec) => ec.table && isUsingEntityIds(ec.table) && getTableId(ec.table) === key,
       );
     }
 
-    if (expandConfig && expandConfig.occurrence) {
+    if (expandConfig?.table) {
       // Transform the expanded relation data recursively
       // Use the relation name (not the FMTID) as the key
       const relationKey = expandConfig.relation;
 
       if (Array.isArray(value)) {
+        if (!expandConfig.table) {
+          transformed[relationKey] = value;
+          continue;
+        }
+        const nestedTable = expandConfig.table;
         transformed[relationKey] = value.map((nestedRecord) =>
           transformSingleRecord(
             nestedRecord,
-            expandConfig.occurrence!.baseTable,
+            nestedTable,
             undefined, // Don't pass nested expand configs for now
           ),
         );
       } else if (value && typeof value === "object") {
-        transformed[relationKey] = transformSingleRecord(
-          value,
-          expandConfig.occurrence.baseTable,
-          undefined,
-        );
+        if (!expandConfig.table) {
+          transformed[relationKey] = value;
+          continue;
+        }
+        transformed[relationKey] = transformSingleRecord(value, expandConfig.table, undefined);
       } else {
         transformed[relationKey] = value;
       }
@@ -201,7 +217,7 @@ function transformSingleRecord(
     }
 
     // Transform field ID to field name
-    const fieldName = baseTable.getFieldName(key);
+    const fieldName = getFieldName(table, key);
     transformed[fieldName] = value;
   }
 
@@ -211,39 +227,43 @@ function transformSingleRecord(
 /**
  * Transforms an array of field names to FMFIDs
  * @param fieldNames - Array of field names
- * @param baseTable - BaseTable instance to get field IDs from
+ * @param table - FMTable instance to get field IDs from
  * @returns Array of FMFIDs or field names
  */
-export function transformFieldNamesArray(
-  fieldNames: string[],
-  baseTable: BaseTable<any, any, any, any>,
-): string[] {
-  if (!baseTable.isUsingFieldIds()) {
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export function transformFieldNamesArray(fieldNames: string[], table: FMTable<any, any>): string[] {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return fieldNames;
   }
 
-  return fieldNames.map((fieldName) => baseTable.getFieldId(fieldName as any));
+  return fieldNames.map((fieldName) => getFieldId(table, fieldName));
 }
 
 /**
  * Transforms a field name in an orderBy string (e.g., "name desc" -> "FMFID:1 desc")
  * @param orderByString - The orderBy string (field name with optional asc/desc)
- * @param baseTable - BaseTable instance to get field ID from
+ * @param table - FMTable instance to get field ID from
  * @returns Transformed orderBy string with FMFID
  */
-export function transformOrderByField(
-  orderByString: string,
-  baseTable: BaseTable<any, any, any, any>,
-): string {
-  if (!baseTable.isUsingFieldIds()) {
+// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration
+export function transformOrderByField(orderByString: string, table: FMTable<any, any> | undefined): string {
+  if (!table) {
+    return orderByString;
+  }
+  const config = getBaseTableConfig(table);
+  if (!config?.fmfIds) {
     return orderByString;
   }
 
   // Parse the orderBy string to extract field name and direction
-  const parts = orderByString.trim().split(/\s+/);
+  const parts = orderByString.trim().split(WHITESPACE_SPLIT_REGEX);
   const fieldName = parts[0];
+  if (!fieldName) {
+    return orderByString;
+  }
   const direction = parts[1]; // "asc" or "desc" or undefined
 
-  const fieldId = baseTable.getFieldId(fieldName as any);
+  const fieldId = getFieldId(table, fieldName);
   return direction ? `${fieldId} ${direction}` : fieldId;
 }