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

package/dist/esm/orm/table.js

@@ -0,0 +1,202 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var _a, _b, _c, _d, _e, _f, _g, _h, _i;
+import { Column } from "./column.js";
+const FMTableName = Symbol.for("fmodata:FMTableName");
+const FMTableEntityId = Symbol.for("fmodata:FMTableEntityId");
+const FMTableSchema = Symbol.for("fmodata:FMTableSchema");
+const FMTableFields = Symbol.for("fmodata:FMTableFields");
+const FMTableNavigationPaths = Symbol.for("fmodata:FMTableNavigationPaths");
+const FMTableDefaultSelect = Symbol.for("fmodata:FMTableDefaultSelect");
+const FMTableBaseTableConfig = Symbol.for("fmodata:FMTableBaseTableConfig");
+const FMTableUseEntityIds = Symbol.for("fmodata:FMTableUseEntityIds");
+const FMTableComment = Symbol.for("fmodata:FMTableComment");
+_i = FMTableName, _h = FMTableEntityId, _g = FMTableUseEntityIds, _f = FMTableComment, _e = FMTableSchema, _d = FMTableFields, _c = FMTableNavigationPaths, _b = FMTableDefaultSelect, _a = FMTableBaseTableConfig;
+class FMTable {
+  constructor(config) {
+    /** @internal */
+    __publicField(this, _i);
+    /** @internal */
+    __publicField(this, _h);
+    /** @internal */
+    __publicField(this, _g);
+    /** @internal */
+    __publicField(this, _f);
+    /** @internal */
+    __publicField(this, _e);
+    /** @internal */
+    __publicField(this, _d);
+    /** @internal */
+    __publicField(this, _c);
+    /** @internal */
+    // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration
+    __publicField(this, _b);
+    /** @internal */
+    __publicField(this, _a);
+    this[FMTableName] = config.name;
+    this[FMTableEntityId] = config.entityId;
+    this[FMTableUseEntityIds] = config.useEntityIds;
+    this[FMTableComment] = config.comment;
+    this[FMTableSchema] = config.schema;
+    this[FMTableFields] = config.fields;
+    this[FMTableNavigationPaths] = config.navigationPaths;
+    this[FMTableDefaultSelect] = config.defaultSelect;
+    this[FMTableBaseTableConfig] = config.baseTableConfig;
+  }
+}
+/**
+ * Internal Symbols for accessing table metadata.
+ * @internal - Not intended for public use. Access table properties via columns instead.
+ */
+__publicField(FMTable, "Symbol", {
+  Name: FMTableName,
+  EntityId: FMTableEntityId,
+  UseEntityIds: FMTableUseEntityIds,
+  Schema: FMTableSchema,
+  Fields: FMTableFields,
+  NavigationPaths: FMTableNavigationPaths,
+  DefaultSelect: FMTableDefaultSelect,
+  BaseTableConfig: FMTableBaseTableConfig,
+  Comment: FMTableComment
+});
+function fmTableOccurrence(name, fields, options) {
+  const fieldConfigs = Object.entries(fields).map(([fieldName, builder]) => ({
+    fieldName,
+    // biome-ignore lint/suspicious/noExplicitAny: Internal property access for builder pattern
+    config: builder._getConfig()
+  }));
+  const primaryKeyField = fieldConfigs.find((f) => f.config.primaryKey);
+  const idField = primaryKeyField == null ? void 0 : primaryKeyField.fieldName;
+  const required = fieldConfigs.filter((f) => f.config.notNull).map((f) => f.fieldName);
+  const readOnly = fieldConfigs.filter((f) => f.config.readOnly).map((f) => f.fieldName);
+  const containerFields = fieldConfigs.filter((f) => f.config.fieldType === "container").map((f) => f.fieldName);
+  const fmfIds = {};
+  for (const { fieldName, config } of fieldConfigs) {
+    if (config.entityId) {
+      fmfIds[fieldName] = config.entityId;
+    }
+  }
+  const outputSchema = {};
+  const inputSchema = {};
+  for (const { fieldName, config } of fieldConfigs) {
+    if (config.outputValidator) {
+      outputSchema[fieldName] = config.outputValidator;
+    }
+    if (config.inputValidator) {
+      inputSchema[fieldName] = config.inputValidator;
+    }
+  }
+  const baseTableConfig = {
+    schema: outputSchema,
+    inputSchema: Object.keys(inputSchema).length > 0 ? inputSchema : void 0,
+    idField,
+    required,
+    readOnly,
+    containerFields,
+    fmfIds: Object.keys(fmfIds).length > 0 ? fmfIds : void 0
+  };
+  const columns = {};
+  for (const [fieldName, builder] of Object.entries(fields)) {
+    const config = builder._getConfig();
+    columns[fieldName] = new Column({
+      fieldName: String(fieldName),
+      entityId: config.entityId,
+      tableName: name,
+      tableEntityId: options == null ? void 0 : options.entityId,
+      inputValidator: config.inputValidator
+    });
+  }
+  const defaultSelectOption = (options == null ? void 0 : options.defaultSelect) ?? "schema";
+  const resolvedDefaultSelect = typeof defaultSelectOption === "function" ? defaultSelectOption(columns) : defaultSelectOption;
+  const navigationPaths = (options == null ? void 0 : options.navigationPaths) ?? [];
+  const table = new FMTable({
+    name,
+    entityId: options == null ? void 0 : options.entityId,
+    useEntityIds: options == null ? void 0 : options.useEntityIds,
+    comment: options == null ? void 0 : options.comment,
+    schema: outputSchema,
+    fields,
+    navigationPaths,
+    defaultSelect: resolvedDefaultSelect,
+    baseTableConfig
+  });
+  Object.assign(table, columns);
+  return table;
+}
+function getTableName(table) {
+  return table[FMTableName];
+}
+function getTableSchema(table) {
+  return table[FMTableSchema];
+}
+function getNavigationPaths(table) {
+  return table[FMTableNavigationPaths];
+}
+function getDefaultSelect(table) {
+  return table[FMTableDefaultSelect];
+}
+function getBaseTableConfig(table) {
+  return table[FMTableBaseTableConfig];
+}
+function isUsingEntityIds(table) {
+  return table[FMTableEntityId] !== void 0 && table[FMTableBaseTableConfig].fmfIds !== void 0;
+}
+function getFieldId(table, fieldName) {
+  const config = table[FMTableBaseTableConfig];
+  if (config.fmfIds && fieldName in config.fmfIds) {
+    const fieldId = config.fmfIds[fieldName];
+    if (fieldId) {
+      return fieldId;
+    }
+  }
+  return fieldName;
+}
+function getFieldName(table, fieldId) {
+  const config = table[FMTableBaseTableConfig];
+  if (config.fmfIds) {
+    for (const [fieldName, fmfId] of Object.entries(config.fmfIds)) {
+      if (fmfId === fieldId) {
+        return fieldName;
+      }
+    }
+  }
+  return fieldId;
+}
+function getTableId(table) {
+  return table[FMTableEntityId] ?? table[FMTableName];
+}
+function getTableColumns(table) {
+  var _a2;
+  const fields = table[FMTableFields];
+  const tableName = table[FMTableName];
+  const tableEntityId = table[FMTableEntityId];
+  const baseConfig = table[FMTableBaseTableConfig];
+  const columns = {};
+  for (const [fieldName, builder] of Object.entries(fields)) {
+    const config = builder._getConfig();
+    columns[fieldName] = new Column({
+      fieldName: String(fieldName),
+      entityId: (_a2 = baseConfig.fmfIds) == null ? void 0 : _a2[fieldName],
+      tableName,
+      tableEntityId,
+      inputValidator: config.inputValidator
+    });
+  }
+  return columns;
+}
+export {
+  FMTable,
+  fmTableOccurrence,
+  getBaseTableConfig,
+  getDefaultSelect,
+  getFieldId,
+  getFieldName,
+  getNavigationPaths,
+  getTableColumns,
+  getTableId,
+  getTableName,
+  getTableSchema,
+  isUsingEntityIds
+};
+//# sourceMappingURL=table.js.map

package/dist/esm/orm/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sources":["../../../src/orm/table.ts"],"sourcesContent":["import type { StandardSchemaV1 } from \"@standard-schema/spec\";\nimport { Column } from \"./column\";\nimport type { ContainerDbType, FieldBuilder, FieldBuilder as FieldBuilderType } from \"./field-builders\";\n// import { z } from \"zod/v4\";\n\n/**\n * Extract the output type from a FieldBuilder.\n * This is what you get when reading from the database.\n *\n * This type extracts the TOutput type parameter, which is set by readValidator()\n * and represents the transformed/validated output type.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\nexport type InferFieldOutput<F> = F extends FieldBuilder<infer TOutput, any, any, any> ? TOutput : never;\n\n/**\n * Extract the input type from a FieldBuilder.\n * This is what you pass when writing to the database.\n *\n * This type extracts the TInput type parameter, which is set by writeValidator()\n * and represents the transformed/validated input type.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\ntype InferFieldInput<F> = F extends FieldBuilder<any, infer TInput, any, any> ? TInput : never;\n\n/**\n * Build a schema type from field builders (output/read types).\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\ntype InferSchemaFromFields<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {\n  [K in keyof TFields]: InferFieldOutput<TFields[K]>;\n};\n\n/**\n * Build an input schema type from field builders (input/write types).\n * Used for insert and update operations.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\ntype InferInputSchemaFromFields<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {\n  [K in keyof TFields]: InferFieldInput<TFields[K]>;\n};\n\n/**\n * Check if a field is a container field by inspecting its TDbType.\n * Container fields have a branded TDbType that extends ContainerDbType.\n */\ntype IsContainerField<F> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  F extends FieldBuilder<any, any, infer TDbType, any>\n    ? NonNullable<TDbType> extends ContainerDbType\n      ? true\n      : false\n    : false;\n\n/**\n * Extract only selectable (non-container) field keys from a fields record.\n * Container fields are excluded because they cannot be selected via $select in FileMaker OData.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\ntype SelectableFieldKeys<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {\n  [K in keyof TFields]: IsContainerField<TFields[K]> extends true ? never : K;\n}[keyof TFields];\n\n/**\n * Build a schema type excluding container fields (for query return types).\n * This is used to ensure container fields don't appear in the return type\n * when using defaultSelect: \"schema\" or \"all\".\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\ntype _InferSelectableSchemaFromFields<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {\n  [K in SelectableFieldKeys<TFields>]: InferFieldOutput<TFields[K]>;\n};\n\n/**\n * Internal Symbols for table properties (hidden from IDE autocomplete).\n * These are used to store internal configuration that shouldn't be visible\n * when users access table columns.\n * @internal - Not exported from public API, only accessible via FMTable.Symbol\n */\nconst FMTableName = Symbol.for(\"fmodata:FMTableName\");\nconst FMTableEntityId = Symbol.for(\"fmodata:FMTableEntityId\");\nconst FMTableSchema = Symbol.for(\"fmodata:FMTableSchema\");\nconst FMTableFields = Symbol.for(\"fmodata:FMTableFields\");\nconst FMTableNavigationPaths = Symbol.for(\"fmodata:FMTableNavigationPaths\");\nconst FMTableDefaultSelect = Symbol.for(\"fmodata:FMTableDefaultSelect\");\nconst FMTableBaseTableConfig = Symbol.for(\"fmodata:FMTableBaseTableConfig\");\nconst FMTableUseEntityIds = Symbol.for(\"fmodata:FMTableUseEntityIds\");\nconst FMTableComment = Symbol.for(\"fmodata:FMTableComment\");\n\n/**\n * Base table class with Symbol-based internal properties.\n * This follows the Drizzle ORM pattern where internal configuration\n * is stored via Symbols, keeping it hidden from IDE autocomplete.\n */\nexport class FMTable<\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration, default allows untyped tables\n  TFields extends Record<string, FieldBuilder<any, any, any, any>> = any,\n  TName extends string = string,\n  TNavigationPaths extends readonly string[] = readonly string[],\n> {\n  /**\n   * Internal Symbols for accessing table metadata.\n   * @internal - Not intended for public use. Access table properties via columns instead.\n   */\n  static readonly Symbol = {\n    Name: FMTableName,\n    EntityId: FMTableEntityId,\n    UseEntityIds: FMTableUseEntityIds,\n    Schema: FMTableSchema,\n    Fields: FMTableFields,\n    NavigationPaths: FMTableNavigationPaths,\n    DefaultSelect: FMTableDefaultSelect,\n    BaseTableConfig: FMTableBaseTableConfig,\n    Comment: FMTableComment,\n  };\n\n  /** @internal */\n  [FMTableName]: TName;\n\n  /** @internal */\n  [FMTableEntityId]?: `FMTID:${string}`;\n\n  /** @internal */\n  [FMTableUseEntityIds]?: boolean;\n\n  /** @internal */\n  [FMTableComment]?: string;\n\n  /** @internal */\n  [FMTableSchema]: Partial<Record<keyof TFields, StandardSchemaV1>>;\n\n  /** @internal */\n  [FMTableFields]: TFields;\n\n  /** @internal */\n  [FMTableNavigationPaths]: TNavigationPaths;\n\n  /** @internal */\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n  [FMTableDefaultSelect]: \"all\" | \"schema\" | Record<string, Column<any, any, TName>>;\n\n  /** @internal */\n  [FMTableBaseTableConfig]: {\n    schema: Partial<Record<keyof TFields, StandardSchemaV1>>;\n    inputSchema?: Partial<Record<keyof TFields, StandardSchemaV1>>;\n    idField?: keyof TFields;\n    required: readonly (keyof TFields)[];\n    readOnly: readonly (keyof TFields)[];\n    containerFields: readonly (keyof TFields)[];\n    fmfIds?: Record<keyof TFields, `FMFID:${string}`>;\n  };\n\n  constructor(config: {\n    name: TName;\n    entityId?: `FMTID:${string}`;\n    useEntityIds?: boolean;\n    comment?: string;\n    schema: Partial<Record<keyof TFields, StandardSchemaV1>>;\n    fields: TFields;\n    navigationPaths: TNavigationPaths;\n    // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n    defaultSelect: \"all\" | \"schema\" | Record<string, Column<any, any, TName>>;\n    baseTableConfig: {\n      schema: Partial<Record<keyof TFields, StandardSchemaV1>>;\n      inputSchema?: Partial<Record<keyof TFields, StandardSchemaV1>>;\n      idField?: keyof TFields;\n      required: readonly (keyof TFields)[];\n      readOnly: readonly (keyof TFields)[];\n      containerFields: readonly (keyof TFields)[];\n      fmfIds?: Record<keyof TFields, `FMFID:${string}`>;\n    };\n  }) {\n    this[FMTableName] = config.name;\n    this[FMTableEntityId] = config.entityId;\n    this[FMTableUseEntityIds] = config.useEntityIds;\n    this[FMTableComment] = config.comment;\n    this[FMTableSchema] = config.schema;\n    this[FMTableFields] = config.fields;\n    this[FMTableNavigationPaths] = config.navigationPaths;\n    this[FMTableDefaultSelect] = config.defaultSelect;\n    this[FMTableBaseTableConfig] = config.baseTableConfig;\n  }\n}\n\n/**\n * Type helper to extract the column map from fields.\n * Table name is baked into each column type for validation.\n * Container fields are marked with IsContainer=true.\n * Columns include both output type (for reading) and input type (for writing/filtering).\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\nexport type ColumnMap<TFields extends Record<string, FieldBuilder<any, any, any, any>>, TName extends string> = {\n  [K in keyof TFields]: Column<\n    InferFieldOutput<TFields[K]>,\n    InferFieldInput<TFields[K]>,\n    TName,\n    IsContainerField<TFields[K]>\n  >;\n};\n\n/**\n * Extract only selectable (non-container) columns from a table.\n * This is used to prevent selecting container fields in queries.\n */\nexport type SelectableColumnMap<\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  TName extends string,\n> = {\n  [K in SelectableFieldKeys<TFields>]: Column<InferFieldOutput<TFields[K]>, InferFieldInput<TFields[K]>, TName, false>;\n};\n\n/**\n * Validates that a select object doesn't contain container field columns.\n * Returns never if any container fields are found, otherwise returns the original type.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\nexport type ValidateNoContainerFields<TSelect extends Record<string, Column<any, any, any, any>>> = {\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n  [K in keyof TSelect]: TSelect[K] extends Column<any, any, any, true> ? never : TSelect[K];\n} extends TSelect\n  ? TSelect\n  : {\n      // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n      [K in keyof TSelect]: TSelect[K] extends Column<any, any, any, true>\n        ? \"❌ Container fields cannot be selected. Use .getSingleField() instead.\"\n        : TSelect[K];\n    };\n\n/**\n * Extract the keys from a defaultSelect function's return type.\n * Used to infer which fields are selected by default for type narrowing.\n */\ntype _ExtractDefaultSelectKeys<\n  TDefaultSelect,\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  TName extends string,\n> = TDefaultSelect extends (columns: ColumnMap<TFields, TName>) => infer R\n  ? keyof R\n  : TDefaultSelect extends \"schema\"\n    ? keyof TFields\n    : keyof TFields; // \"all\" defaults to all keys\n\n/**\n * Complete table type with both metadata (via Symbols) and column accessors.\n * This is the return type of fmTableOccurrence - users see columns directly,\n * but internal config is hidden via Symbols.\n */\nexport type FMTableWithColumns<\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  TName extends string,\n  TNavigationPaths extends readonly string[] = readonly string[],\n> = FMTable<TFields, TName, TNavigationPaths> & ColumnMap<TFields, TName>;\n\n/**\n * Options for fmTableOccurrence function.\n * Provides autocomplete-friendly typing while preserving inference for navigationPaths.\n */\nexport interface FMTableOccurrenceOptions<\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  TName extends string,\n> {\n  /** The entity ID (FMTID) for this table occurrence */\n  entityId?: `FMTID:${string}`;\n\n  /** The comment for this table */\n  comment?: string;\n\n  /**\n   * Default select behavior:\n   * - \"all\": Select all fields (including related tables)\n   * - \"schema\": Select only schema-defined fields (default)\n   * - function: Custom selection from columns\n   */\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n  defaultSelect?: \"all\" | \"schema\" | ((columns: ColumnMap<TFields, TName>) => Record<string, Column<any, any, TName>>);\n\n  /** Navigation paths available from this table (for expand operations) */\n  navigationPaths?: readonly string[];\n\n  /** Whether to use entity IDs (FMTID/FMFID) instead of names in queries */\n  useEntityIds?: boolean;\n}\n\n/**\n * Create a table occurrence with field builders.\n * This is the main API for defining tables in the new ORM style.\n *\n * @example\n * const users = fmTableOccurrence(\"users\", {\n *   id: textField().primaryKey().entityId(\"FMFID:1\"),\n *   name: textField().notNull().entityId(\"FMFID:6\"),\n *   active: numberField()\n *     .outputValidator(z.coerce.boolean())\n *     .inputValidator(z.boolean().transform(v => v ? 1 : 0))\n *     .entityId(\"FMFID:7\"),\n * }, {\n *   entityId: \"FMTID:100\",\n *   defaultSelect: \"schema\",\n *   navigationPaths: [\"contacts\"],\n * });\n *\n * // Access columns\n * users.id    // Column<string, \"id\">\n * users.name  // Column<string, \"name\">\n *\n * // Use in queries\n * db.from(users).select(\"id\", \"name\").where(eq(users.active, true))\n */\nexport function fmTableOccurrence<\n  const TName extends string,\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any FieldBuilder configuration\n  const TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  const TNavPaths extends readonly string[] = readonly [],\n>(\n  name: TName,\n  fields: TFields,\n  options?: FMTableOccurrenceOptions<TFields, TName> & {\n    /** Navigation paths available from this table (for expand operations) */\n    navigationPaths?: TNavPaths;\n  },\n): FMTableWithColumns<TFields, TName, TNavPaths> {\n  // Extract configuration from field builders\n  const fieldConfigs = Object.entries(fields).map(([fieldName, builder]) => ({\n    fieldName,\n    // biome-ignore lint/suspicious/noExplicitAny: Internal property access for builder pattern\n    config: (builder as any)._getConfig(),\n  }));\n\n  // Find primary key field\n  const primaryKeyField = fieldConfigs.find((f) => f.config.primaryKey);\n  const idField = primaryKeyField?.fieldName;\n\n  // Collect required fields (notNull fields)\n  const required = fieldConfigs.filter((f) => f.config.notNull).map((f) => f.fieldName);\n\n  // Collect read-only fields\n  const readOnly = fieldConfigs.filter((f) => f.config.readOnly).map((f) => f.fieldName);\n\n  // Collect container fields (cannot be selected via $select)\n  const containerFields = fieldConfigs.filter((f) => f.config.fieldType === \"container\").map((f) => f.fieldName);\n\n  // Collect entity IDs\n  const fmfIds: Record<string, `FMFID:${string}`> = {};\n  for (const { fieldName, config } of fieldConfigs) {\n    if (config.entityId) {\n      fmfIds[fieldName] = config.entityId;\n    }\n  }\n\n  // Build Zod schema from field builders (output/read validators)\n  const outputSchema: Partial<Record<keyof TFields, StandardSchemaV1>> = {};\n  // Build input schema from field builders (input/write validators)\n  const inputSchema: Record<string, StandardSchemaV1> = {};\n\n  for (const { fieldName, config } of fieldConfigs) {\n    // Use outputValidator if provided\n    if (config.outputValidator) {\n      outputSchema[fieldName as keyof TFields] = config.outputValidator;\n    }\n\n    // Store inputValidator if provided (for write operations)\n    if (config.inputValidator) {\n      inputSchema[fieldName] = config.inputValidator;\n    }\n  }\n\n  // Build BaseTable-compatible config\n  const baseTableConfig = {\n    schema: outputSchema as Partial<Record<keyof TFields, StandardSchemaV1>>,\n    inputSchema:\n      Object.keys(inputSchema).length > 0\n        ? (inputSchema as Partial<Record<keyof TFields, StandardSchemaV1>>)\n        : undefined,\n    idField: idField as keyof TFields | undefined,\n    required: required as readonly (keyof TFields)[],\n    readOnly: readOnly as readonly (keyof TFields)[],\n    containerFields: containerFields as readonly (keyof TFields)[],\n    fmfIds: (Object.keys(fmfIds).length > 0 ? fmfIds : undefined) as\n      | Record<keyof TFields, `FMFID:${string}`>\n      | undefined,\n  };\n\n  // Create column instances\n  const columns = {} as ColumnMap<TFields, TName>;\n  for (const [fieldName, builder] of Object.entries(fields)) {\n    // biome-ignore lint/suspicious/noExplicitAny: Internal property access for builder pattern\n    const config = (builder as any)._getConfig();\n    // biome-ignore lint/suspicious/noExplicitAny: Mutation of readonly properties for builder pattern\n    (columns as any)[fieldName] = new Column({\n      fieldName: String(fieldName),\n      entityId: config.entityId,\n      tableName: name,\n      tableEntityId: options?.entityId,\n      inputValidator: config.inputValidator,\n    });\n  }\n\n  // Resolve defaultSelect: if it's a function, call it with columns; otherwise use as-is\n  const defaultSelectOption = options?.defaultSelect ?? \"schema\";\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n  const resolvedDefaultSelect: \"all\" | \"schema\" | Record<string, Column<any, any, TName>> =\n    typeof defaultSelectOption === \"function\"\n      ? defaultSelectOption(columns as ColumnMap<TFields, TName>)\n      : defaultSelectOption;\n\n  // Create the FMTable instance with Symbol-based internal properties\n  const navigationPaths = (options?.navigationPaths ?? []) as TNavPaths;\n  const table = new FMTable<TFields, TName, TNavPaths>({\n    name,\n    entityId: options?.entityId,\n    useEntityIds: options?.useEntityIds,\n    comment: options?.comment,\n    schema: outputSchema,\n    fields,\n    navigationPaths,\n    defaultSelect: resolvedDefaultSelect,\n    baseTableConfig,\n  });\n\n  // Assign columns to the table instance (making them accessible directly)\n  Object.assign(table, columns);\n\n  return table as FMTableWithColumns<TFields, TName, TNavPaths>;\n}\n\n// /**\n//  * Type guard to check if a value is a TableOccurrence or FMTable.\n//  * Supports both Symbol-based (new) and underscore-prefixed (legacy) formats.\n//  */\n// function isTableOccurrence(value: any): value is TableOccurrence {\n//   if (!value || typeof value !== \"object\") {\n//     return false;\n//   }\n\n//   // Check for Symbol-based format (new FMTable class)\n//   if (\n//     FMTableName in value &&\n//     FMTableSchema in value &&\n//     FMTableFields in value\n//   ) {\n//     return typeof value[FMTableName] === \"string\";\n//   }\n\n//   // Check for underscore-prefixed format (legacy interface)\n//   if (\"_name\" in value && \"_schema\" in value && \"_fields\" in value) {\n//     return typeof value._name === \"string\";\n//   }\n\n//   return false;\n// }\n\n/**\n * Helper to extract the schema type from a TableOccurrence or FMTable.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\nexport type InferTableSchema<T> = T extends FMTable<infer TFields, any> ? InferSchemaFromFields<TFields> : never;\n\n/**\n * Extract the schema type from an FMTable instance.\n * This is used to infer the schema from table objects passed to db.from(), expand(), etc.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport type InferSchemaOutputFromFMTable<T extends FMTable<any, any>> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  T extends FMTable<infer TFields, any> ? InferSchemaFromFields<TFields> : never;\n\n/**\n * Extract the input schema type from an FMTable instance.\n * This is used for insert and update operations where we need write types.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport type InferInputSchemaFromFMTable<T extends FMTable<any, any>> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  T extends FMTable<infer TFields, any> ? InferInputSchemaFromFields<TFields> : never;\n\n/**\n * Helper type to check if a FieldBuilder's input type excludes null and undefined.\n * This checks the TInput type parameter, which preserves nullability from notNull().\n */\ntype FieldInputExcludesNullish<F> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  F extends FieldBuilder<any, infer TInput, any>\n    ? null extends TInput\n      ? false\n      : undefined extends TInput\n        ? false\n        : true\n    : false;\n\n/**\n * Check if a FieldBuilder is readOnly at the type level\n */\ntype IsFieldReadOnly<F> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  F extends FieldBuilderType<any, any, any, infer ReadOnly> ? (ReadOnly extends true ? true : false) : false;\n\n/**\n * Compute insert data type from FMTable, making notNull fields required.\n * Fields are required if their FieldBuilder's TInput type excludes null/undefined.\n * All other fields are optional (can be omitted).\n * readOnly fields are excluded (including primaryKey/idField since they're automatically readOnly).\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport type InsertDataFromFMTable<T extends FMTable<any, any>> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  T extends FMTable<infer TFields, any>\n    ? {\n        [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true\n          ? never\n          : FieldInputExcludesNullish<TFields[K]> extends true\n            ? K\n            : never]: InferFieldInput<TFields[K]>;\n      } & {\n        [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true\n          ? never\n          : FieldInputExcludesNullish<TFields[K]> extends true\n            ? never\n            : K]?: InferFieldInput<TFields[K]>;\n      }\n    : never;\n\n/**\n * Compute update data type from FMTable.\n * All fields are optional, but readOnly fields are excluded (including primaryKey/idField).\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport type UpdateDataFromFMTable<T extends FMTable<any, any>> =\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n  T extends FMTable<infer TFields, any>\n    ? {\n        [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true ? never : K]?: InferFieldInput<TFields[K]>;\n      }\n    : never;\n\n/**\n * Extract the table name type from an FMTable.\n * This is a workaround since we can't directly index Symbols in types.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration, required for type inference with infer\nexport type ExtractTableName<T extends FMTable<any, any>> = T extends FMTable<any, infer Name> ? Name : never;\n\n/**\n * Validates that a target table's name matches one of the source table's navigationPaths.\n * Used to ensure type-safe expand/navigate operations.\n */\nexport type ValidExpandTarget<\n  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n  SourceTable extends FMTable<any, any, any> | undefined,\n  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n  TargetTable extends FMTable<any, any, any>,\n  // biome-ignore lint/suspicious/noExplicitAny: Required for type inference with infer\n> = SourceTable extends FMTable<any, any, infer SourceNavPaths>\n  ? ExtractTableName<TargetTable> extends SourceNavPaths[number]\n    ? TargetTable\n    : never\n  : TargetTable;\n\n// ============================================================================\n// Helper Functions for Accessing FMTable Internal Properties\n// ============================================================================\n\n/**\n * Get the table name from an FMTable instance.\n * @param table - FMTable instance\n * @returns The table name\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableName<T extends FMTable<any, any>>(table: T): string {\n  return table[FMTableName];\n}\n\n/**\n * Get the entity ID (FMTID) from an FMTable instance.\n * @param table - FMTable instance\n * @returns The entity ID or undefined if not using entity IDs\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableEntityId<T extends FMTable<any, any>>(table: T): string | undefined {\n  return table[FMTableEntityId];\n}\n\n/**\n * Get the schema validator from an FMTable instance.\n * @param table - FMTable instance\n * @returns The StandardSchemaV1 validator record (partial - only fields with validators)\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableSchema<T extends FMTable<any, any>>(\n  table: T,\n): Partial<Record<keyof T[typeof FMTableFields], StandardSchemaV1>> {\n  return table[FMTableSchema];\n}\n\n/**\n * Get the fields from an FMTable instance.\n * @param table - FMTable instance\n * @returns The fields record\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableFields<T extends FMTable<any, any>>(table: T) {\n  return table[FMTableFields];\n}\n\n/**\n * Get the navigation paths from an FMTable instance.\n * @param table - FMTable instance\n * @returns Array of navigation path names\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getNavigationPaths<T extends FMTable<any, any>>(table: T): readonly string[] {\n  return table[FMTableNavigationPaths];\n}\n\n/**\n * Get the default select configuration from an FMTable instance.\n * @param table - FMTable instance\n * @returns Default select configuration\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getDefaultSelect<T extends FMTable<any, any>>(table: T) {\n  return table[FMTableDefaultSelect];\n}\n\n/**\n * Get the base table configuration from an FMTable instance.\n * This provides access to schema, idField, required fields, readOnly fields, and field IDs.\n * @param table - FMTable instance\n * @returns Base table configuration object\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getBaseTableConfig<T extends FMTable<any, any>>(table: T) {\n  return table[FMTableBaseTableConfig];\n}\n\n/**\n * Check if an FMTable instance is using entity IDs (both FMTID and FMFIDs).\n * @param table - FMTable instance\n * @returns True if using entity IDs, false otherwise\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function isUsingEntityIds<T extends FMTable<any, any>>(table: T): boolean {\n  return table[FMTableEntityId] !== undefined && table[FMTableBaseTableConfig].fmfIds !== undefined;\n}\n\n/**\n * Get the field ID (FMFID) for a given field name, or the field name itself if not using IDs.\n * @param table - FMTable instance\n * @param fieldName - Field name to get the ID for\n * @returns The FMFID string or the original field name\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getFieldId<T extends FMTable<any, any>>(table: T, fieldName: string): string {\n  const config = table[FMTableBaseTableConfig];\n  if (config.fmfIds && fieldName in config.fmfIds) {\n    const fieldId = config.fmfIds[fieldName];\n    if (fieldId) {\n      return fieldId;\n    }\n  }\n  return fieldName;\n}\n\n/**\n * Get the field name for a given field ID (FMFID), or the ID itself if not found.\n * @param table - FMTable instance\n * @param fieldId - The FMFID to get the field name for\n * @returns The field name or the original ID\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getFieldName<T extends FMTable<any, any>>(table: T, fieldId: string): string {\n  const config = table[FMTableBaseTableConfig];\n  if (config.fmfIds) {\n    for (const [fieldName, fmfId] of Object.entries(config.fmfIds)) {\n      if (fmfId === fieldId) {\n        return fieldName;\n      }\n    }\n  }\n  return fieldId;\n}\n/**\n * Get the table ID (FMTID or name) from an FMTable instance.\n * Returns the FMTID if available, otherwise returns the table name.\n * @param table - FMTable instance\n * @returns The FMTID string or the table name\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableId<T extends FMTable<any, any>>(table: T): string {\n  return table[FMTableEntityId] ?? table[FMTableName];\n}\n\n/**\n * Get the comment from an FMTable instance.\n * @param table - FMTable instance\n * @returns The comment string or undefined if not set\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableComment<T extends FMTable<any, any>>(table: T): string | undefined {\n  return table[FMTableComment];\n}\n\n/**\n * Get all columns from a table as an object.\n * Useful for selecting all fields except some using destructuring.\n *\n * @example\n * const { password, ...cols } = getTableColumns(users)\n * db.from(users).list().select(cols)\n *\n * @param table - FMTable instance\n * @returns Object with all columns from the table\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableColumns<T extends FMTable<any, any>>(\n  table: T,\n): ColumnMap<T[typeof FMTableFields], ExtractTableName<T>> {\n  const fields = table[FMTableFields];\n  const tableName = table[FMTableName];\n  const tableEntityId = table[FMTableEntityId];\n  const baseConfig = table[FMTableBaseTableConfig];\n\n  const columns = {} as ColumnMap<T[typeof FMTableFields], ExtractTableName<T>>;\n  for (const [fieldName, builder] of Object.entries(fields)) {\n    // biome-ignore lint/suspicious/noExplicitAny: Internal property access for builder pattern\n    const config = (builder as any)._getConfig();\n    // biome-ignore lint/suspicious/noExplicitAny: Mutation of readonly properties for builder pattern\n    (columns as any)[fieldName] = new Column({\n      fieldName: String(fieldName),\n      entityId: baseConfig.fmfIds?.[fieldName],\n      tableName,\n      tableEntityId,\n      inputValidator: config.inputValidator,\n    });\n  }\n\n  return columns;\n}\n"],"names":["_a"],"mappings":"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"}

package/dist/esm/transform.d.ts

@@ -1,38 +1,37 @@
-import { BaseTable } from './client/base-table.js';
-import { TableOccurrence } from './client/table-occurrence.js';
+import { FMTable } from './orm/table.js';
 /**
  * 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
  */
-export declare function transformFieldNamesToIds<T extends Record<string, any>>(data: T, baseTable: BaseTable<any, any, any, any>): Record<string, any>;
+export declare function transformFieldNamesToIds<T extends Record<string, any>>(data: T, table: FMTable<any, any>): 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
  */
-export declare function transformFieldIdsToNames<T extends Record<string, any>>(data: T, baseTable: BaseTable<any, any, any, any>): Record<string, any>;
+export declare function transformFieldIdsToNames<T extends Record<string, any>>(data: T, table: FMTable<any, any>): 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 declare function transformFieldName(fieldName: string, baseTable: BaseTable<any, any, any, any>): string;
+export declare function transformFieldName(fieldName: string, table: FMTable<any, any>): string;
 /**
- * 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 declare function transformTableName(occurrence: TableOccurrence<any, any, any, any>): string;
+export declare function transformTableName(table: FMTable<any, any>): string;
 /**
- * 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 declare function getTableIdentifiers(occurrence: TableOccurrence<any, any, any, any>): {
+export declare function getTableIdentifiers(table: FMTable<any, any>): {
     name: string;
     id: string | undefined;
 };
@@ -41,25 +40,25 @@ export declare function getTableIdentifiers(occurrence: TableOccurrence<any, any
  * 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 declare function transformResponseFields(data: any, baseTable: BaseTable<any, any, any, any>, expandConfigs?: Array<{
+export declare function transformResponseFields(data: any, table: FMTable<any, any>, expandConfigs?: Array<{
     relation: string;
-    occurrence?: TableOccurrence<any, any, any, any>;
+    table?: FMTable<any, any>;
 }>): any;
 /**
  * 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 declare function transformFieldNamesArray(fieldNames: string[], baseTable: BaseTable<any, any, any, any>): string[];
+export declare function transformFieldNamesArray(fieldNames: string[], table: FMTable<any, any>): string[];
 /**
  * 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 declare function transformOrderByField(orderByString: string, baseTable: BaseTable<any, any, any, any>): string;
+export declare function transformOrderByField(orderByString: string, table: FMTable<any, any> | undefined): string;

package/dist/esm/transform.js

@@ -1,28 +1,20 @@
-function transformFieldNamesToIds(data, baseTable) {
-  if (!baseTable.isUsingFieldIds()) {
+import { getBaseTableConfig, getFieldId, isUsingEntityIds, getTableId, getFieldName } from "./orm/table.js";
+const WHITESPACE_SPLIT_REGEX = /\s+/;
+function transformFieldNamesToIds(data, table) {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return data;
   }
   const transformed = {};
   for (const [fieldName, value] of Object.entries(data)) {
-    const fieldId = baseTable.getFieldId(fieldName);
+    const fieldId = getFieldId(table, fieldName);
     transformed[fieldId] = value;
   }
   return transformed;
 }
-function transformFieldName(fieldName, baseTable) {
-  return baseTable.getFieldId(fieldName);
-}
-function transformTableName(occurrence) {
-  return occurrence.getTableId();
-}
-function getTableIdentifiers(occurrence) {
-  return {
-    name: occurrence.getTableName(),
-    id: occurrence.isUsingTableId() ? occurrence.getTableId() : void 0
-  };
-}
-function transformResponseFields(data, baseTable, expandConfigs) {
-  if (!baseTable.isUsingFieldIds()) {
+function transformResponseFields(data, table, expandConfigs) {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return data;
   }
   if (data === null || data === void 0) {
@@ -31,19 +23,16 @@ function transformResponseFields(data, baseTable, expandConfigs) {
   if (data.value && Array.isArray(data.value)) {
     return {
       ...data,
-      value: data.value.map(
-        (record) => transformSingleRecord(record, baseTable, expandConfigs)
-      )
+      // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation
+      value: data.value.map((record) => transformSingleRecord(record, table, expandConfigs))
     };
   }
   if (Array.isArray(data)) {
-    return data.map(
-      (record) => transformSingleRecord(record, baseTable, expandConfigs)
-    );
+    return data.map((record) => transformSingleRecord(record, table, expandConfigs));
   }
-  return transformSingleRecord(data, baseTable, expandConfigs);
+  return transformSingleRecord(data, table, expandConfigs);
 }
-function transformSingleRecord(record, baseTable, expandConfigs) {
+function transformSingleRecord(record, table, expandConfigs) {
   if (!record || typeof record !== "object") {
     return record;
   }
@@ -56,59 +45,69 @@ function transformSingleRecord(record, baseTable, expandConfigs) {
     let expandConfig = expandConfigs == null ? void 0 : expandConfigs.find((ec) => ec.relation === key);
     if (!expandConfig && key.startsWith("FMTID:")) {
       expandConfig = expandConfigs == null ? void 0 : 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 == null ? void 0 : expandConfig.table) {
       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,
             void 0
             // Don't pass nested expand configs for now
           )
         );
       } else if (value && typeof value === "object") {
-        transformed[relationKey] = transformSingleRecord(
-          value,
-          expandConfig.occurrence.baseTable,
-          void 0
-        );
+        if (!expandConfig.table) {
+          transformed[relationKey] = value;
+          continue;
+        }
+        transformed[relationKey] = transformSingleRecord(value, expandConfig.table, void 0);
       } else {
         transformed[relationKey] = value;
       }
       continue;
     }
-    const fieldName = baseTable.getFieldName(key);
+    const fieldName = getFieldName(table, key);
     transformed[fieldName] = value;
   }
   return transformed;
 }
-function transformFieldNamesArray(fieldNames, baseTable) {
-  if (!baseTable.isUsingFieldIds()) {
+function transformFieldNamesArray(fieldNames, table) {
+  const config = getBaseTableConfig(table);
+  if (!config.fmfIds) {
     return fieldNames;
   }
-  return fieldNames.map((fieldName) => baseTable.getFieldId(fieldName));
+  return fieldNames.map((fieldName) => getFieldId(table, fieldName));
 }
-function transformOrderByField(orderByString, baseTable) {
-  if (!baseTable.isUsingFieldIds()) {
+function transformOrderByField(orderByString, table) {
+  if (!table) {
     return orderByString;
   }
-  const parts = orderByString.trim().split(/\s+/);
+  const config = getBaseTableConfig(table);
+  if (!(config == null ? void 0 : config.fmfIds)) {
+    return orderByString;
+  }
+  const parts = orderByString.trim().split(WHITESPACE_SPLIT_REGEX);
   const fieldName = parts[0];
+  if (!fieldName) {
+    return orderByString;
+  }
   const direction = parts[1];
-  const fieldId = baseTable.getFieldId(fieldName);
+  const fieldId = getFieldId(table, fieldName);
   return direction ? `${fieldId} ${direction}` : fieldId;
 }
 export {
-  getTableIdentifiers,
-  transformFieldName,
   transformFieldNamesArray,
   transformFieldNamesToIds,
   transformOrderByField,
-  transformResponseFields,
-  transformTableName
+  transformResponseFields
 };
 //# sourceMappingURL=transform.js.map

package/dist/esm/transform.js.map

@@ -1 +1 @@
-{"version":3,"file":"transform.js","sources":["../../src/transform.ts"],"sourcesContent":["import type { BaseTable } from \"./client/base-table\";\nimport type { TableOccurrence } from \"./client/table-occurrence\";\nimport type { StandardSchemaV1 } from \"@standard-schema/spec\";\n\n/**\n * Transforms field names to FileMaker field IDs (FMFID) in an object\n * @param data - Object with field names as keys\n * @param baseTable - BaseTable instance to get field IDs from\n * @returns Object with FMFID keys instead of field names\n */\nexport function transformFieldNamesToIds<T extends Record<string, any>>(\n  data: T,\n  baseTable: BaseTable<any, any, any, any>,\n): Record<string, any> {\n  if (!baseTable.isUsingFieldIds()) {\n    return data;\n  }\n\n  const transformed: Record<string, any> = {};\n  for (const [fieldName, value] of Object.entries(data)) {\n    const fieldId = baseTable.getFieldId(fieldName as any);\n    transformed[fieldId] = value;\n  }\n  return transformed;\n}\n\n/**\n * Transforms FileMaker field IDs (FMFID) to field names in an object\n * @param data - Object with FMFID keys\n * @param baseTable - BaseTable instance to get field names from\n * @returns Object with field names as keys instead of FMFIDs\n */\nexport function transformFieldIdsToNames<T extends Record<string, any>>(\n  data: T,\n  baseTable: BaseTable<any, any, any, any>,\n): Record<string, any> {\n  if (!baseTable.isUsingFieldIds()) {\n    return data;\n  }\n\n  const transformed: Record<string, any> = {};\n  for (const [key, value] of Object.entries(data)) {\n    // Check if this is an OData metadata field (starts with @)\n    if (key.startsWith(\"@\")) {\n      transformed[key] = value;\n      continue;\n    }\n\n    const fieldName = baseTable.getFieldName(key);\n    transformed[fieldName] = value;\n  }\n  return transformed;\n}\n\n/**\n * Transforms a field name to FMFID or returns the field name if not using IDs\n * @param fieldName - The field name to transform\n * @param baseTable - BaseTable instance to get field ID from\n * @returns The FMFID or field name\n */\nexport function transformFieldName(\n  fieldName: string,\n  baseTable: BaseTable<any, any, any, any>,\n): string {\n  return baseTable.getFieldId(fieldName as any);\n}\n\n/**\n * Transforms a table occurrence name to FMTID or returns the name if not using IDs\n * @param occurrence - TableOccurrence instance to get table ID from\n * @returns The FMTID or table name\n */\nexport function transformTableName(\n  occurrence: TableOccurrence<any, any, any, any>,\n): string {\n  return occurrence.getTableId();\n}\n\n/**\n * Gets both table name and ID from an occurrence\n * @param occurrence - TableOccurrence instance\n * @returns Object with name (always present) and id (may be undefined if not using IDs)\n */\nexport function getTableIdentifiers(\n  occurrence: TableOccurrence<any, any, any, any>,\n): { name: string; id: string | undefined } {\n  return {\n    name: occurrence.getTableName(),\n    id: occurrence.isUsingTableId() ? occurrence.getTableId() : undefined,\n  };\n}\n\n/**\n * Transforms response data by converting field IDs back to field names recursively.\n * Handles both single records and arrays of records, as well as nested expand relationships.\n *\n * @param data - Response data from FileMaker (can be single record, array, or wrapped in value property)\n * @param baseTable - BaseTable instance for the main table\n * @param expandConfigs - Configuration for expanded relations (optional)\n * @returns Transformed data with field names instead of IDs\n */\nexport function transformResponseFields(\n  data: any,\n  baseTable: BaseTable<any, any, any, any>,\n  expandConfigs?: Array<{\n    relation: string;\n    occurrence?: TableOccurrence<any, any, any, any>;\n  }>,\n): any {\n  if (!baseTable.isUsingFieldIds()) {\n    return data;\n  }\n\n  // Handle null/undefined\n  if (data === null || data === undefined) {\n    return data;\n  }\n\n  // Handle OData list response with value array\n  if (data.value && Array.isArray(data.value)) {\n    return {\n      ...data,\n      value: data.value.map((record: any) =>\n        transformSingleRecord(record, baseTable, expandConfigs),\n      ),\n    };\n  }\n\n  // Handle array of records\n  if (Array.isArray(data)) {\n    return data.map((record) =>\n      transformSingleRecord(record, baseTable, expandConfigs),\n    );\n  }\n\n  // Handle single record\n  return transformSingleRecord(data, baseTable, expandConfigs);\n}\n\n/**\n * Transforms a single record, converting field IDs to names and handling nested expands\n */\nfunction transformSingleRecord(\n  record: any,\n  baseTable: BaseTable<any, any, any, any>,\n  expandConfigs?: Array<{\n    relation: string;\n    occurrence?: TableOccurrence<any, any, any, any>;\n  }>,\n): any {\n  if (!record || typeof record !== \"object\") {\n    return record;\n  }\n\n  const transformed: Record<string, any> = {};\n\n  for (const [key, value] of Object.entries(record)) {\n    // Preserve OData metadata fields\n    if (key.startsWith(\"@\")) {\n      transformed[key] = value;\n      continue;\n    }\n\n    // Check if this is an expanded relation (by relation name)\n    let expandConfig = expandConfigs?.find((ec) => ec.relation === key);\n\n    // If not found by relation name, check if this key is a FMTID\n    // (FileMaker returns expanded relations with FMTID keys when using entity IDs)\n    if (!expandConfig && key.startsWith(\"FMTID:\")) {\n      expandConfig = expandConfigs?.find(\n        (ec) =>\n          ec.occurrence &&\n          ec.occurrence.isUsingTableId() &&\n          ec.occurrence.getTableId() === key,\n      );\n    }\n\n    if (expandConfig && expandConfig.occurrence) {\n      // Transform the expanded relation data recursively\n      // Use the relation name (not the FMTID) as the key\n      const relationKey = expandConfig.relation;\n\n      if (Array.isArray(value)) {\n        transformed[relationKey] = value.map((nestedRecord) =>\n          transformSingleRecord(\n            nestedRecord,\n            expandConfig.occurrence!.baseTable,\n            undefined, // Don't pass nested expand configs for now\n          ),\n        );\n      } else if (value && typeof value === \"object\") {\n        transformed[relationKey] = transformSingleRecord(\n          value,\n          expandConfig.occurrence.baseTable,\n          undefined,\n        );\n      } else {\n        transformed[relationKey] = value;\n      }\n      continue;\n    }\n\n    // Transform field ID to field name\n    const fieldName = baseTable.getFieldName(key);\n    transformed[fieldName] = value;\n  }\n\n  return transformed;\n}\n\n/**\n * Transforms an array of field names to FMFIDs\n * @param fieldNames - Array of field names\n * @param baseTable - BaseTable instance to get field IDs from\n * @returns Array of FMFIDs or field names\n */\nexport function transformFieldNamesArray(\n  fieldNames: string[],\n  baseTable: BaseTable<any, any, any, any>,\n): string[] {\n  if (!baseTable.isUsingFieldIds()) {\n    return fieldNames;\n  }\n\n  return fieldNames.map((fieldName) => baseTable.getFieldId(fieldName as any));\n}\n\n/**\n * Transforms a field name in an orderBy string (e.g., \"name desc\" -> \"FMFID:1 desc\")\n * @param orderByString - The orderBy string (field name with optional asc/desc)\n * @param baseTable - BaseTable instance to get field ID from\n * @returns Transformed orderBy string with FMFID\n */\nexport function transformOrderByField(\n  orderByString: string,\n  baseTable: BaseTable<any, any, any, any>,\n): string {\n  if (!baseTable.isUsingFieldIds()) {\n    return orderByString;\n  }\n\n  // Parse the orderBy string to extract field name and direction\n  const parts = orderByString.trim().split(/\\s+/);\n  const fieldName = parts[0];\n  const direction = parts[1]; // \"asc\" or \"desc\" or undefined\n\n  const fieldId = baseTable.getFieldId(fieldName as any);\n  return direction ? `${fieldId} ${direction}` : fieldId;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"transform.js","sources":["../../src/transform.ts"],"sourcesContent":["import type { FMTable } from \"./orm/table\";\nimport { getBaseTableConfig, getFieldId, getFieldName, getTableId, getTableName, isUsingEntityIds } from \"./orm/table\";\n\nconst WHITESPACE_SPLIT_REGEX = /\\s+/;\n\n/**\n * Transforms field names to FileMaker field IDs (FMFID) in an object\n * @param data - Object with field names as keys\n * @param table - FMTable instance to get field IDs from\n * @returns Object with FMFID keys instead of field names\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any record shape\nexport function transformFieldNamesToIds<T extends Record<string, any>>(\n  data: T,\n  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n  table: FMTable<any, any>,\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation\n): Record<string, any> {\n  const config = getBaseTableConfig(table);\n  if (!config.fmfIds) {\n    return data;\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation\n  const transformed: Record<string, any> = {};\n  for (const [fieldName, value] of Object.entries(data)) {\n    const fieldId = getFieldId(table, fieldName);\n    transformed[fieldId] = value;\n  }\n  return transformed;\n}\n\n/**\n * Transforms FileMaker field IDs (FMFID) to field names in an object\n * @param data - Object with FMFID keys\n * @param table - FMTable instance to get field names from\n * @returns Object with field names as keys instead of FMFIDs\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any record shape\nexport function transformFieldIdsToNames<T extends Record<string, any>>(\n  data: T,\n  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n  table: FMTable<any, any>,\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation\n): Record<string, any> {\n  const config = getBaseTableConfig(table);\n  if (!config.fmfIds) {\n    return data;\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation\n  const transformed: Record<string, any> = {};\n  for (const [key, value] of Object.entries(data)) {\n    // Check if this is an OData metadata field (starts with @)\n    if (key.startsWith(\"@\")) {\n      transformed[key] = value;\n      continue;\n    }\n\n    const fieldName = getFieldName(table, key);\n    transformed[fieldName] = value;\n  }\n  return transformed;\n}\n\n/**\n * Transforms a field name to FMFID or returns the field name if not using IDs\n * @param fieldName - The field name to transform\n * @param table - FMTable instance to get field ID from\n * @returns The FMFID or field name\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function transformFieldName(fieldName: string, table: FMTable<any, any>): string {\n  return getFieldId(table, fieldName);\n}\n\n/**\n * Transforms a table name to FMTID or returns the name if not using IDs\n * @param table - FMTable instance to get table ID from\n * @returns The FMTID or table name\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function transformTableName(table: FMTable<any, any>): string {\n  return getTableId(table);\n}\n\n/**\n * Gets both table name and ID from a table\n * @param table - FMTable instance\n * @returns Object with name (always present) and id (may be undefined if not using IDs)\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function getTableIdentifiers(table: FMTable<any, any>): { name: string; id: string | undefined } {\n  return {\n    name: getTableName(table),\n    id: isUsingEntityIds(table) ? getTableId(table) : undefined,\n  };\n}\n\n/**\n * Transforms response data by converting field IDs back to field names recursively.\n * Handles both single records and arrays of records, as well as nested expand relationships.\n *\n * @param data - Response data from FileMaker (can be single record, array, or wrapped in value property)\n * @param table - FMTable instance for the main table\n * @param expandConfigs - Configuration for expanded relations (optional)\n * @returns Transformed data with field names instead of IDs\n */\nexport function transformResponseFields(\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic response data transformation\n  data: any,\n  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n  table: FMTable<any, any>,\n  expandConfigs?: Array<{\n    relation: string;\n    // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n    table?: FMTable<any, any>;\n  }>,\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic response data transformation\n): any {\n  const config = getBaseTableConfig(table);\n  if (!config.fmfIds) {\n    return data;\n  }\n\n  // Handle null/undefined\n  if (data === null || data === undefined) {\n    return data;\n  }\n\n  // Handle OData list response with value array\n  if (data.value && Array.isArray(data.value)) {\n    return {\n      ...data,\n      // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation\n      value: data.value.map((record: any) => transformSingleRecord(record, table, expandConfigs)),\n    };\n  }\n\n  // Handle array of records\n  if (Array.isArray(data)) {\n    return data.map((record) => transformSingleRecord(record, table, expandConfigs));\n  }\n\n  // Handle single record\n  return transformSingleRecord(data, table, expandConfigs);\n}\n\n/**\n * Transforms a single record, converting field IDs to names and handling nested expands\n */\nfunction transformSingleRecord(\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation\n  record: any,\n  // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n  table: FMTable<any, any>,\n  expandConfigs?: Array<{\n    relation: string;\n    // biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\n    table?: FMTable<any, any>;\n  }>,\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic record transformation\n): any {\n  if (!record || typeof record !== \"object\") {\n    return record;\n  }\n\n  // biome-ignore lint/suspicious/noExplicitAny: Dynamic field transformation\n  const transformed: Record<string, any> = {};\n\n  for (const [key, value] of Object.entries(record)) {\n    // Preserve OData metadata fields\n    if (key.startsWith(\"@\")) {\n      transformed[key] = value;\n      continue;\n    }\n\n    // Check if this is an expanded relation (by relation name)\n    let expandConfig = expandConfigs?.find((ec) => ec.relation === key);\n\n    // If not found by relation name, check if this key is a FMTID\n    // (FileMaker returns expanded relations with FMTID keys when using entity IDs)\n    if (!expandConfig && key.startsWith(\"FMTID:\")) {\n      expandConfig = expandConfigs?.find(\n        (ec) => ec.table && isUsingEntityIds(ec.table) && getTableId(ec.table) === key,\n      );\n    }\n\n    if (expandConfig?.table) {\n      // Transform the expanded relation data recursively\n      // Use the relation name (not the FMTID) as the key\n      const relationKey = expandConfig.relation;\n\n      if (Array.isArray(value)) {\n        if (!expandConfig.table) {\n          transformed[relationKey] = value;\n          continue;\n        }\n        const nestedTable = expandConfig.table;\n        transformed[relationKey] = value.map((nestedRecord) =>\n          transformSingleRecord(\n            nestedRecord,\n            nestedTable,\n            undefined, // Don't pass nested expand configs for now\n          ),\n        );\n      } else if (value && typeof value === \"object\") {\n        if (!expandConfig.table) {\n          transformed[relationKey] = value;\n          continue;\n        }\n        transformed[relationKey] = transformSingleRecord(value, expandConfig.table, undefined);\n      } else {\n        transformed[relationKey] = value;\n      }\n      continue;\n    }\n\n    // Transform field ID to field name\n    const fieldName = getFieldName(table, key);\n    transformed[fieldName] = value;\n  }\n\n  return transformed;\n}\n\n/**\n * Transforms an array of field names to FMFIDs\n * @param fieldNames - Array of field names\n * @param table - FMTable instance to get field IDs from\n * @returns Array of FMFIDs or field names\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function transformFieldNamesArray(fieldNames: string[], table: FMTable<any, any>): string[] {\n  const config = getBaseTableConfig(table);\n  if (!config.fmfIds) {\n    return fieldNames;\n  }\n\n  return fieldNames.map((fieldName) => getFieldId(table, fieldName));\n}\n\n/**\n * Transforms a field name in an orderBy string (e.g., \"name desc\" -> \"FMFID:1 desc\")\n * @param orderByString - The orderBy string (field name with optional asc/desc)\n * @param table - FMTable instance to get field ID from\n * @returns Transformed orderBy string with FMFID\n */\n// biome-ignore lint/suspicious/noExplicitAny: Accepts any FMTable configuration\nexport function transformOrderByField(orderByString: string, table: FMTable<any, any> | undefined): string {\n  if (!table) {\n    return orderByString;\n  }\n  const config = getBaseTableConfig(table);\n  if (!config?.fmfIds) {\n    return orderByString;\n  }\n\n  // Parse the orderBy string to extract field name and direction\n  const parts = orderByString.trim().split(WHITESPACE_SPLIT_REGEX);\n  const fieldName = parts[0];\n  if (!fieldName) {\n    return orderByString;\n  }\n  const direction = parts[1]; // \"asc\" or \"desc\" or undefined\n\n  const fieldId = getFieldId(table, fieldName);\n  return direction ? `${fieldId} ${direction}` : fieldId;\n}\n"],"names":[],"mappings":"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"}