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

package/dist/esm/orm/table.d.ts

@@ -0,0 +1,341 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { FieldBuilder, ContainerDbType, FieldBuilder as FieldBuilderType } from './field-builders.js';
+import { Column } from './column.js';
+/**
+ * Extract the output type from a FieldBuilder.
+ * This is what you get when reading from the database.
+ *
+ * This type extracts the TOutput type parameter, which is set by readValidator()
+ * and represents the transformed/validated output type.
+ */
+export type InferFieldOutput<F> = F extends FieldBuilder<infer TOutput, any, any, any> ? TOutput : never;
+/**
+ * Extract the input type from a FieldBuilder.
+ * This is what you pass when writing to the database.
+ *
+ * This type extracts the TInput type parameter, which is set by writeValidator()
+ * and represents the transformed/validated input type.
+ */
+type InferFieldInput<F> = F extends FieldBuilder<any, infer TInput, any, any> ? TInput : never;
+/**
+ * Build a schema type from field builders (output/read types).
+ */
+type InferSchemaFromFields<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {
+    [K in keyof TFields]: InferFieldOutput<TFields[K]>;
+};
+/**
+ * Build an input schema type from field builders (input/write types).
+ * Used for insert and update operations.
+ */
+type InferInputSchemaFromFields<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {
+    [K in keyof TFields]: InferFieldInput<TFields[K]>;
+};
+/**
+ * Check if a field is a container field by inspecting its TDbType.
+ * Container fields have a branded TDbType that extends ContainerDbType.
+ */
+type IsContainerField<F> = F extends FieldBuilder<any, any, infer TDbType, any> ? NonNullable<TDbType> extends ContainerDbType ? true : false : false;
+/**
+ * Extract only selectable (non-container) field keys from a fields record.
+ * Container fields are excluded because they cannot be selected via $select in FileMaker OData.
+ */
+type SelectableFieldKeys<TFields extends Record<string, FieldBuilder<any, any, any, any>>> = {
+    [K in keyof TFields]: IsContainerField<TFields[K]> extends true ? never : K;
+}[keyof TFields];
+/**
+ * Internal Symbols for table properties (hidden from IDE autocomplete).
+ * These are used to store internal configuration that shouldn't be visible
+ * when users access table columns.
+ * @internal - Not exported from public API, only accessible via FMTable.Symbol
+ */
+declare const FMTableName: unique symbol;
+declare const FMTableEntityId: unique symbol;
+declare const FMTableSchema: unique symbol;
+declare const FMTableFields: unique symbol;
+declare const FMTableNavigationPaths: unique symbol;
+declare const FMTableDefaultSelect: unique symbol;
+declare const FMTableBaseTableConfig: unique symbol;
+declare const FMTableUseEntityIds: unique symbol;
+/**
+ * Base table class with Symbol-based internal properties.
+ * This follows the Drizzle ORM pattern where internal configuration
+ * is stored via Symbols, keeping it hidden from IDE autocomplete.
+ */
+export declare class FMTable<TFields extends Record<string, FieldBuilder<any, any, any, any>> = any, TName extends string = string, TNavigationPaths extends readonly string[] = readonly string[]> {
+    /**
+     * Internal Symbols for accessing table metadata.
+     * @internal - Not intended for public use. Access table properties via columns instead.
+     */
+    static readonly Symbol: {
+        Name: symbol;
+        EntityId: symbol;
+        UseEntityIds: symbol;
+        Schema: symbol;
+        Fields: symbol;
+        NavigationPaths: symbol;
+        DefaultSelect: symbol;
+        BaseTableConfig: symbol;
+    };
+    /** @internal */
+    [FMTableName]: TName;
+    /** @internal */
+    [FMTableEntityId]?: `FMTID:${string}`;
+    /** @internal */
+    [FMTableUseEntityIds]?: boolean;
+    /** @internal */
+    [FMTableSchema]: StandardSchemaV1<any, InferSchemaFromFields<TFields>>;
+    /** @internal */
+    [FMTableFields]: TFields;
+    /** @internal */
+    [FMTableNavigationPaths]: TNavigationPaths;
+    /** @internal */
+    [FMTableDefaultSelect]: "all" | "schema" | Record<string, Column<any, TName>>;
+    /** @internal */
+    [FMTableBaseTableConfig]: {
+        schema: Record<keyof TFields, StandardSchemaV1>;
+        inputSchema?: Record<keyof TFields, StandardSchemaV1>;
+        idField?: keyof TFields;
+        required: readonly (keyof TFields)[];
+        readOnly: readonly (keyof TFields)[];
+        containerFields: readonly (keyof TFields)[];
+        fmfIds?: Record<keyof TFields, `FMFID:${string}`>;
+    };
+    constructor(config: {
+        name: TName;
+        entityId?: `FMTID:${string}`;
+        useEntityIds?: boolean;
+        schema: StandardSchemaV1<any, InferSchemaFromFields<TFields>>;
+        fields: TFields;
+        navigationPaths: TNavigationPaths;
+        defaultSelect: "all" | "schema" | Record<string, Column<any, TName>>;
+        baseTableConfig: {
+            schema: Record<keyof TFields, StandardSchemaV1>;
+            inputSchema?: Record<keyof TFields, StandardSchemaV1>;
+            idField?: keyof TFields;
+            required: readonly (keyof TFields)[];
+            readOnly: readonly (keyof TFields)[];
+            containerFields: readonly (keyof TFields)[];
+            fmfIds?: Record<keyof TFields, `FMFID:${string}`>;
+        };
+    });
+}
+/**
+ * Type helper to extract the column map from fields.
+ * Table name is baked into each column type for validation.
+ * Container fields are marked with IsContainer=true.
+ */
+export type ColumnMap<TFields extends Record<string, FieldBuilder<any, any, any, any>>, TName extends string> = {
+    [K in keyof TFields]: Column<InferFieldOutput<TFields[K]>, TName, IsContainerField<TFields[K]>>;
+};
+/**
+ * Extract only selectable (non-container) columns from a table.
+ * This is used to prevent selecting container fields in queries.
+ */
+export type SelectableColumnMap<TFields extends Record<string, FieldBuilder<any, any, any, any>>, TName extends string> = {
+    [K in SelectableFieldKeys<TFields>]: Column<InferFieldOutput<TFields[K]>, TName, false>;
+};
+/**
+ * Validates that a select object doesn't contain container field columns.
+ * Returns never if any container fields are found, otherwise returns the original type.
+ */
+export type ValidateNoContainerFields<TSelect extends Record<string, Column<any, any, any>>> = {
+    [K in keyof TSelect]: TSelect[K] extends Column<any, any, true> ? never : TSelect[K];
+} extends TSelect ? TSelect : {
+    [K in keyof TSelect]: TSelect[K] extends Column<any, any, true> ? "❌ Container fields cannot be selected. Use .getSingleField() instead." : TSelect[K];
+};
+/**
+ * Complete table type with both metadata (via Symbols) and column accessors.
+ * This is the return type of fmTableOccurrence - users see columns directly,
+ * but internal config is hidden via Symbols.
+ */
+export type FMTableWithColumns<TFields extends Record<string, FieldBuilder<any, any, any, any>>, TName extends string, TNavigationPaths extends readonly string[] = readonly string[]> = FMTable<TFields, TName, TNavigationPaths> & ColumnMap<TFields, TName>;
+/**
+ * Options for fmTableOccurrence function.
+ * Provides autocomplete-friendly typing while preserving inference for navigationPaths.
+ */
+export interface FMTableOccurrenceOptions<TFields extends Record<string, FieldBuilder<any, any, any, any>>, TName extends string> {
+    /** The entity ID (FMTID) for this table occurrence */
+    entityId?: `FMTID:${string}`;
+    /**
+     * Default select behavior:
+     * - "all": Select all fields (including related tables)
+     * - "schema": Select only schema-defined fields (default)
+     * - function: Custom selection from columns
+     */
+    defaultSelect?: "all" | "schema" | ((columns: ColumnMap<TFields, TName>) => Record<string, Column<any, TName>>);
+    /** Navigation paths available from this table (for expand operations) */
+    navigationPaths?: readonly string[];
+    /** Whether to use entity IDs (FMTID/FMFID) instead of names in queries */
+    useEntityIds?: boolean;
+}
+/**
+ * Create a table occurrence with field builders.
+ * This is the main API for defining tables in the new ORM style.
+ *
+ * @example
+ * const users = fmTableOccurrence("users", {
+ *   id: textField().primaryKey().entityId("FMFID:1"),
+ *   name: textField().notNull().entityId("FMFID:6"),
+ *   active: numberField()
+ *     .outputValidator(z.coerce.boolean())
+ *     .inputValidator(z.boolean().transform(v => v ? 1 : 0))
+ *     .entityId("FMFID:7"),
+ * }, {
+ *   entityId: "FMTID:100",
+ *   defaultSelect: "schema",
+ *   navigationPaths: ["contacts"],
+ * });
+ *
+ * // Access columns
+ * users.id    // Column<string, "id">
+ * users.name  // Column<string, "name">
+ *
+ * // Use in queries
+ * db.from(users).select("id", "name").where(eq(users.active, true))
+ */
+export declare function fmTableOccurrence<const TName extends string, const TFields extends Record<string, FieldBuilder<any, any, any, any>>, const TNavPaths extends readonly string[] = readonly []>(name: TName, fields: TFields, options?: FMTableOccurrenceOptions<TFields, TName> & {
+    /** Navigation paths available from this table (for expand operations) */
+    navigationPaths?: TNavPaths;
+}): FMTableWithColumns<TFields, TName, TNavPaths>;
+/**
+ * Helper to extract the schema type from a TableOccurrence or FMTable.
+ */
+export type InferTableSchema<T> = T extends FMTable<infer TFields, any> ? InferSchemaFromFields<TFields> : never;
+/**
+ * Extract the schema type from an FMTable instance.
+ * This is used to infer the schema from table objects passed to db.from(), expand(), etc.
+ */
+export type InferSchemaOutputFromFMTable<T extends FMTable<any, any>> = T extends FMTable<infer TFields, any> ? InferSchemaFromFields<TFields> : never;
+/**
+ * Extract the input schema type from an FMTable instance.
+ * This is used for insert and update operations where we need write types.
+ */
+export type InferInputSchemaFromFMTable<T extends FMTable<any, any>> = T extends FMTable<infer TFields, any> ? InferInputSchemaFromFields<TFields> : never;
+/**
+ * Helper type to check if a FieldBuilder's input type excludes null and undefined.
+ * This checks the TInput type parameter, which preserves nullability from notNull().
+ */
+type FieldInputExcludesNullish<F> = F extends FieldBuilder<any, infer TInput, any> ? null extends TInput ? false : undefined extends TInput ? false : true : false;
+/**
+ * Check if a FieldBuilder is readOnly at the type level
+ */
+type IsFieldReadOnly<F> = F extends FieldBuilderType<any, any, any, infer ReadOnly> ? ReadOnly extends true ? true : false : false;
+/**
+ * Compute insert data type from FMTable, making notNull fields required.
+ * Fields are required if their FieldBuilder's TInput type excludes null/undefined.
+ * All other fields are optional (can be omitted).
+ * readOnly fields are excluded (including primaryKey/idField since they're automatically readOnly).
+ */
+export type InsertDataFromFMTable<T extends FMTable<any, any>> = T extends FMTable<infer TFields, any> ? {
+    [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true ? never : FieldInputExcludesNullish<TFields[K]> extends true ? K : never]: InferFieldInput<TFields[K]>;
+} & {
+    [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true ? never : FieldInputExcludesNullish<TFields[K]> extends true ? never : K]?: InferFieldInput<TFields[K]>;
+} : never;
+/**
+ * Compute update data type from FMTable.
+ * All fields are optional, but readOnly fields are excluded (including primaryKey/idField).
+ */
+export type UpdateDataFromFMTable<T extends FMTable<any, any>> = T extends FMTable<infer TFields, any> ? {
+    [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true ? never : K]?: InferFieldInput<TFields[K]>;
+} : never;
+/**
+ * Extract the table name type from an FMTable.
+ * This is a workaround since we can't directly index Symbols in types.
+ */
+export type ExtractTableName<T extends FMTable<any, any>> = T extends FMTable<any, infer Name> ? Name : never;
+/**
+ * Validates that a target table's name matches one of the source table's navigationPaths.
+ * Used to ensure type-safe expand/navigate operations.
+ */
+export type ValidExpandTarget<SourceTable extends FMTable<any, any, any> | undefined, TargetTable extends FMTable<any, any, any>> = SourceTable extends FMTable<any, any, infer SourceNavPaths> ? ExtractTableName<TargetTable> extends SourceNavPaths[number] ? TargetTable : never : TargetTable;
+/**
+ * Get the table name from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns The table name
+ */
+export declare function getTableName<T extends FMTable<any, any>>(table: T): string;
+/**
+ * Get the entity ID (FMTID) from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns The entity ID or undefined if not using entity IDs
+ */
+export declare function getTableEntityId<T extends FMTable<any, any>>(table: T): string | undefined;
+/**
+ * Get the schema validator from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns The StandardSchemaV1 validator
+ */
+export declare function getTableSchema<T extends FMTable<any, any>>(table: T): StandardSchemaV1;
+/**
+ * Get the fields from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns The fields record
+ */
+export declare function getTableFields<T extends FMTable<any, any>>(table: T): any;
+/**
+ * Get the navigation paths from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns Array of navigation path names
+ */
+export declare function getNavigationPaths<T extends FMTable<any, any>>(table: T): readonly string[];
+/**
+ * Get the default select configuration from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns Default select configuration
+ */
+export declare function getDefaultSelect<T extends FMTable<any, any>>(table: T): "all" | "schema" | Record<string, Column<any, any, false>>;
+/**
+ * Get the base table configuration from an FMTable instance.
+ * This provides access to schema, idField, required fields, readOnly fields, and field IDs.
+ * @param table - FMTable instance
+ * @returns Base table configuration object
+ */
+export declare function getBaseTableConfig<T extends FMTable<any, any>>(table: T): {
+    schema: Record<string | number | symbol, StandardSchemaV1<unknown, unknown>>;
+    inputSchema?: Record<string | number | symbol, StandardSchemaV1<unknown, unknown>> | undefined;
+    idField?: string | number | symbol | undefined;
+    required: readonly (string | number | symbol)[];
+    readOnly: readonly (string | number | symbol)[];
+    containerFields: readonly (string | number | symbol)[];
+    fmfIds?: Record<string | number | symbol, `FMFID:${string}`> | undefined;
+};
+/**
+ * Check if an FMTable instance is using entity IDs (both FMTID and FMFIDs).
+ * @param table - FMTable instance
+ * @returns True if using entity IDs, false otherwise
+ */
+export declare function isUsingEntityIds<T extends FMTable<any, any>>(table: T): boolean;
+/**
+ * Get the field ID (FMFID) for a given field name, or the field name itself if not using IDs.
+ * @param table - FMTable instance
+ * @param fieldName - Field name to get the ID for
+ * @returns The FMFID string or the original field name
+ */
+export declare function getFieldId<T extends FMTable<any, any>>(table: T, fieldName: string): string;
+/**
+ * Get the field name for a given field ID (FMFID), or the ID itself if not found.
+ * @param table - FMTable instance
+ * @param fieldId - The FMFID to get the field name for
+ * @returns The field name or the original ID
+ */
+export declare function getFieldName<T extends FMTable<any, any>>(table: T, fieldId: string): string;
+/**
+ * Get the table ID (FMTID or name) from an FMTable instance.
+ * Returns the FMTID if available, otherwise returns the table name.
+ * @param table - FMTable instance
+ * @returns The FMTID string or the table name
+ */
+export declare function getTableId<T extends FMTable<any, any>>(table: T): string;
+/**
+ * Get all columns from a table as an object.
+ * Useful for selecting all fields except some using destructuring.
+ *
+ * @example
+ * const { password, ...cols } = getTableColumns(users)
+ * db.from(users).list().select(cols)
+ *
+ * @param table - FMTable instance
+ * @returns Object with all columns from the table
+ */
+export declare function getTableColumns<T extends FMTableWithColumns<any, any>>(table: T): ColumnMap<T[typeof FMTableFields], ExtractTableName<T>>;
+export {};

package/dist/esm/orm/table.js

@@ -0,0 +1,211 @@
+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;
+import { Column } from "./column.js";
+import { z } from "zod/v4";
+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");
+_h = FMTableName, _g = FMTableEntityId, _f = FMTableUseEntityIds, _e = FMTableSchema, _d = FMTableFields, _c = FMTableNavigationPaths, _b = FMTableDefaultSelect, _a = FMTableBaseTableConfig;
+class FMTable {
+  constructor(config) {
+    /** @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 */
+    __publicField(this, _b);
+    /** @internal */
+    __publicField(this, _a);
+    this[FMTableName] = config.name;
+    this[FMTableEntityId] = config.entityId;
+    this[FMTableUseEntityIds] = config.useEntityIds;
+    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
+});
+function fmTableOccurrence(name, fields, options) {
+  const fieldConfigs = Object.entries(fields).map(([fieldName, builder]) => ({
+    fieldName,
+    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 zodSchema = {};
+  const inputSchema = {};
+  for (const { fieldName, config } of fieldConfigs) {
+    if (config.outputValidator) {
+      zodSchema[fieldName] = config.outputValidator;
+    } else {
+      let validator;
+      switch (config.fieldType) {
+        case "text":
+        case "date":
+        case "time":
+        case "timestamp":
+        case "container":
+        case "calculated":
+          validator = z.string();
+          break;
+        case "number":
+          validator = z.number();
+          break;
+        default:
+          validator = z.unknown();
+      }
+      if (!config.notNull) {
+        validator = validator.nullable();
+      }
+      zodSchema[fieldName] = validator;
+    }
+    if (config.inputValidator) {
+      inputSchema[fieldName] = config.inputValidator;
+    }
+  }
+  const tableSchema = z.object(zodSchema);
+  const baseTableConfig = {
+    schema: zodSchema,
+    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
+    });
+  }
+  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,
+    schema: tableSchema,
+    fields,
+    navigationPaths,
+    defaultSelect: resolvedDefaultSelect,
+    baseTableConfig
+  });
+  Object.assign(table, columns);
+  return table;
+}
+function getTableName(table) {
+  return table[FMTableName];
+}
+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)) {
+    builder._getConfig();
+    columns[fieldName] = new Column({
+      fieldName: String(fieldName),
+      entityId: (_a2 = baseConfig.fmfIds) == null ? void 0 : _a2[fieldName],
+      tableName,
+      tableEntityId
+    });
+  }
+  return columns;
+}
+export {
+  FMTable,
+  fmTableOccurrence,
+  getBaseTableConfig,
+  getDefaultSelect,
+  getFieldId,
+  getFieldName,
+  getNavigationPaths,
+  getTableColumns,
+  getTableId,
+  getTableName,
+  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 { FieldBuilder, type ContainerDbType } from \"./field-builders\";\nimport type { FieldBuilder as FieldBuilderType } from \"./field-builders\";\nimport { Column } from \"./column\";\nimport { 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 */\nexport type InferFieldOutput<F> =\n  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 */\ntype InferFieldInput<F> =\n  F extends FieldBuilder<any, infer TInput, any, any> ? TInput : never;\n\n/**\n * Build a schema type from field builders (output/read types).\n */\ntype InferSchemaFromFields<\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n> = {\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 */\ntype InferInputSchemaFromFields<\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n> = {\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  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 */\ntype SelectableFieldKeys<\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n> = {\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 */\ntype InferSelectableSchemaFromFields<\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n> = {\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\");\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  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  };\n\n  /** @internal */\n  [FMTableName]: TName;\n\n  /** @internal */\n  [FMTableEntityId]?: `FMTID:${string}`;\n\n  /** @internal */\n  [FMTableUseEntityIds]?: boolean;\n\n  /** @internal */\n  [FMTableSchema]: StandardSchemaV1<any, InferSchemaFromFields<TFields>>;\n\n  /** @internal */\n  [FMTableFields]: TFields;\n\n  /** @internal */\n  [FMTableNavigationPaths]: TNavigationPaths;\n\n  /** @internal */\n  [FMTableDefaultSelect]: \"all\" | \"schema\" | Record<string, Column<any, TName>>;\n\n  /** @internal */\n  [FMTableBaseTableConfig]: {\n    schema: Record<keyof TFields, StandardSchemaV1>;\n    inputSchema?: 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    schema: StandardSchemaV1<any, InferSchemaFromFields<TFields>>;\n    fields: TFields;\n    navigationPaths: TNavigationPaths;\n    defaultSelect: \"all\" | \"schema\" | Record<string, Column<any, TName>>;\n    baseTableConfig: {\n      schema: Record<keyof TFields, StandardSchemaV1>;\n      inputSchema?: 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[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 */\nexport type ColumnMap<\n  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  TName extends string,\n> = {\n  [K in keyof TFields]: Column<\n    InferFieldOutput<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  TFields extends Record<string, FieldBuilder<any, any, any, any>>,\n  TName extends string,\n> = {\n  [K in SelectableFieldKeys<TFields>]: Column<\n    InferFieldOutput<TFields[K]>,\n    TName,\n    false\n  >;\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 */\nexport type ValidateNoContainerFields<\n  TSelect extends Record<string, Column<any, any, any>>,\n> = {\n  [K in keyof TSelect]: TSelect[K] extends Column<any, any, true>\n    ? never\n    : TSelect[K];\n} extends TSelect\n  ? TSelect\n  : {\n      [K in keyof TSelect]: TSelect[K] extends Column<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  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  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  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  /**\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  defaultSelect?:\n    | \"all\"\n    | \"schema\"\n    | ((\n        columns: ColumnMap<TFields, TName>,\n      ) => Record<string, Column<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  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    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\n    .filter((f) => f.config.notNull)\n    .map((f) => f.fieldName);\n\n  // Collect read-only fields\n  const readOnly = fieldConfigs\n    .filter((f) => f.config.readOnly)\n    .map((f) => f.fieldName);\n\n  // Collect container fields (cannot be selected via $select)\n  const containerFields = fieldConfigs\n    .filter((f) => f.config.fieldType === \"container\")\n    .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 zodSchema: Record<string, 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, otherwise create a basic validator\n    if (config.outputValidator) {\n      zodSchema[fieldName] = config.outputValidator;\n    } else {\n      // Create a default validator based on field type and nullability\n      let validator: any;\n      switch (config.fieldType) {\n        case \"text\":\n        case \"date\":\n        case \"time\":\n        case \"timestamp\":\n        case \"container\":\n        case \"calculated\":\n          validator = z.string();\n          break;\n        case \"number\":\n          validator = z.number();\n          break;\n        default:\n          validator = z.unknown();\n      }\n\n      // Add nullability if not marked as notNull\n      if (!config.notNull) {\n        validator = validator.nullable();\n      }\n\n      zodSchema[fieldName] = validator;\n    }\n\n    // Store inputValidator if provided (for write operations)\n    if (config.inputValidator) {\n      inputSchema[fieldName] = config.inputValidator;\n    }\n  }\n\n  // Create a schema validator for the entire table\n  const tableSchema = z.object(zodSchema) as unknown as StandardSchemaV1<\n    any,\n    InferSchemaFromFields<TFields>\n  >;\n\n  // Build BaseTable-compatible config\n  const baseTableConfig = {\n    schema: zodSchema as Record<keyof TFields, StandardSchemaV1>,\n    inputSchema: (Object.keys(inputSchema).length > 0\n      ? inputSchema\n      : undefined) as Record<keyof TFields, StandardSchemaV1> | 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: Record<string, Column> = {};\n  for (const [fieldName, builder] of Object.entries(fields)) {\n    const config = (builder as any)._getConfig();\n    columns[fieldName] = new Column({\n      fieldName: String(fieldName),\n      entityId: config.entityId,\n      tableName: name,\n      tableEntityId: options?.entityId,\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  const resolvedDefaultSelect:\n    | \"all\"\n    | \"schema\"\n    | Record<string, Column<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    schema: tableSchema,\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 */\nexport type InferTableSchema<T> =\n  T extends FMTable<infer TFields, any>\n    ? InferSchemaFromFields<TFields>\n    : 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 */\nexport type InferSchemaOutputFromFMTable<T extends FMTable<any, any>> =\n  T extends FMTable<infer TFields, any>\n    ? InferSchemaFromFields<TFields>\n    : 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 */\nexport type InferInputSchemaFromFMTable<T extends FMTable<any, any>> =\n  T extends FMTable<infer TFields, any>\n    ? InferInputSchemaFromFields<TFields>\n    : 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  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  F extends FieldBuilderType<any, any, any, infer ReadOnly>\n    ? ReadOnly extends true\n      ? true\n      : false\n    : 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 */\nexport type InsertDataFromFMTable<T extends FMTable<any, any>> =\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 */\nexport type UpdateDataFromFMTable<T extends FMTable<any, any>> =\n  T extends FMTable<infer TFields, any>\n    ? {\n        [K in keyof TFields as IsFieldReadOnly<TFields[K]> extends true\n          ? never\n          : 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 */\nexport type ExtractTableName<T extends FMTable<any, any>> =\n  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  SourceTable extends FMTable<any, any, any> | undefined,\n  TargetTable extends FMTable<any, any, any>,\n> =\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 */\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 */\nexport function getTableEntityId<T extends FMTable<any, any>>(\n  table: T,\n): 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\n */\nexport function getTableSchema<T extends FMTable<any, any>>(\n  table: T,\n): 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 */\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 */\nexport function getNavigationPaths<T extends FMTable<any, any>>(\n  table: T,\n): 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 */\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 */\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 */\nexport function isUsingEntityIds<T extends FMTable<any, any>>(\n  table: T,\n): boolean {\n  return (\n    table[FMTableEntityId] !== undefined &&\n    table[FMTableBaseTableConfig].fmfIds !== undefined\n  );\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 */\nexport function getFieldId<T extends FMTable<any, any>>(\n  table: T,\n  fieldName: string,\n): 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 */\nexport function getFieldName<T extends FMTable<any, any>>(\n  table: T,\n  fieldId: string,\n): 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 */\nexport function getTableId<T extends FMTable<any, any>>(table: T): string {\n  return table[FMTableEntityId] ?? table[FMTableName];\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 */\nexport function getTableColumns<T extends FMTableWithColumns<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: Record<string, Column> = {};\n  for (const [fieldName, builder] of Object.entries(fields)) {\n    const config = (builder as any)._getConfig();\n    columns[fieldName] = new Column({\n      fieldName: String(fieldName),\n      entityId: baseConfig.fmfIds?.[fieldName],\n      tableName: tableName,\n      tableEntityId: tableEntityId,\n    });\n  }\n\n  return columns as ColumnMap<T[typeof FMTableFields], ExtractTableName<T>>;\n}\n"],"names":["_a"],"mappings":"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"}