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

package/dist/esm/orm/operators.js

@@ -0,0 +1,260 @@
+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);
+import { needsFieldQuoting } from "../client/builders/select-utils.js";
+import { isColumn } from "./column.js";
+class FilterExpression {
+  // biome-ignore lint/suspicious/noExplicitAny: Operands can be Column, FilterExpression, or any value type
+  constructor(operator, operands) {
+    __publicField(this, "operator");
+    // biome-ignore lint/suspicious/noExplicitAny: Operands can be Column, FilterExpression, or any value type
+    __publicField(this, "operands");
+    this.operator = operator;
+    this.operands = operands;
+  }
+  /**
+   * Convert this expression to OData filter syntax.
+   * @internal Used by QueryBuilder
+   */
+  toODataFilter(useEntityIds) {
+    switch (this.operator) {
+      // Comparison operators
+      case "eq":
+        return this._binaryOp("eq", useEntityIds);
+      case "ne":
+        return this._binaryOp("ne", useEntityIds);
+      case "gt":
+        return this._binaryOp("gt", useEntityIds);
+      case "gte":
+        return this._binaryOp("ge", useEntityIds);
+      case "lt":
+        return this._binaryOp("lt", useEntityIds);
+      case "lte":
+        return this._binaryOp("le", useEntityIds);
+      case "in":
+        return this._inOp(useEntityIds);
+      case "notIn":
+        return this._notInOp(useEntityIds);
+      // String operators
+      case "contains":
+        return this._functionOp("contains", useEntityIds);
+      case "startsWith":
+        return this._functionOp("startswith", useEntityIds);
+      case "endsWith":
+        return this._functionOp("endswith", useEntityIds);
+      // Null checks
+      case "isNull":
+        return this._isNullOp(useEntityIds);
+      case "isNotNull":
+        return this._isNotNullOp(useEntityIds);
+      // Logical operators
+      case "and":
+        return this._logicalOp("and", useEntityIds);
+      case "or":
+        return this._logicalOp("or", useEntityIds);
+      case "not":
+        return this._notOp(useEntityIds);
+      default:
+        throw new Error(`Unknown operator: ${this.operator}`);
+    }
+  }
+  _binaryOp(op, useEntityIds) {
+    const [left, right] = this.operands;
+    let columnForValue;
+    if (isColumn(left) && !isColumn(right)) {
+      columnForValue = left;
+    } else if (isColumn(right) && !isColumn(left)) {
+      columnForValue = right;
+    } else {
+      columnForValue = void 0;
+    }
+    const leftStr = this._operandToString(left, useEntityIds, columnForValue);
+    const rightStr = this._operandToString(right, useEntityIds, columnForValue);
+    return `${leftStr} ${op} ${rightStr}`;
+  }
+  _functionOp(fnName, useEntityIds) {
+    const [column, value] = this.operands;
+    const columnInstance = isColumn(column) ? column : void 0;
+    const columnStr = this._operandToString(column, useEntityIds);
+    const valueStr = this._operandToString(value, useEntityIds, columnInstance);
+    return `${fnName}(${columnStr}, ${valueStr})`;
+  }
+  _inOp(useEntityIds) {
+    const [column, values] = this.operands;
+    const columnInstance = isColumn(column) ? column : void 0;
+    const columnStr = this._operandToString(column, useEntityIds);
+    const valuesStr = values.map((v) => this._operandToString(v, useEntityIds, columnInstance)).join(", ");
+    return `${columnStr} in (${valuesStr})`;
+  }
+  _notInOp(useEntityIds) {
+    const [column, values] = this.operands;
+    const columnInstance = isColumn(column) ? column : void 0;
+    const columnStr = this._operandToString(column, useEntityIds);
+    const valuesStr = values.map((v) => this._operandToString(v, useEntityIds, columnInstance)).join(", ");
+    return `not (${columnStr} in (${valuesStr}))`;
+  }
+  _isNullOp(useEntityIds) {
+    const [column] = this.operands;
+    const columnStr = this._operandToString(column, useEntityIds);
+    return `${columnStr} eq null`;
+  }
+  _isNotNullOp(useEntityIds) {
+    const [column] = this.operands;
+    const columnStr = this._operandToString(column, useEntityIds);
+    return `${columnStr} ne null`;
+  }
+  _logicalOp(op, useEntityIds) {
+    const expressions = this.operands.map((expr) => {
+      if (expr instanceof FilterExpression) {
+        const innerExpr = expr.toODataFilter(useEntityIds);
+        if (expr.operator === "and" || expr.operator === "or") {
+          return `(${innerExpr})`;
+        }
+        return innerExpr;
+      }
+      throw new Error("Logical operators require FilterExpression operands");
+    });
+    return expressions.join(` ${op} `);
+  }
+  _notOp(useEntityIds) {
+    const [expr] = this.operands;
+    if (expr instanceof FilterExpression) {
+      return `not (${expr.toODataFilter(useEntityIds)})`;
+    }
+    throw new Error("NOT operator requires a FilterExpression operand");
+  }
+  _operandToString(operand, useEntityIds, column) {
+    if (isColumn(operand)) {
+      const fieldIdentifier = operand.getFieldIdentifier(useEntityIds);
+      return needsFieldQuoting(fieldIdentifier) ? `"${fieldIdentifier}"` : fieldIdentifier;
+    }
+    let value = operand;
+    if (column == null ? void 0 : column.inputValidator) {
+      try {
+        const result = column.inputValidator["~standard"].validate(value);
+        if (result instanceof Promise) {
+          value = operand;
+        } else if ("issues" in result && result.issues) {
+          value = operand;
+        } else if ("value" in result) {
+          value = result.value;
+        }
+      } catch (_error) {
+        value = operand;
+      }
+    }
+    if (typeof value === "string") {
+      return `'${value.replace(/'/g, "''")}'`;
+    }
+    if (value === null || value === void 0) {
+      return "null";
+    }
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    return String(value);
+  }
+}
+function eq(column, value) {
+  return new FilterExpression("eq", [column, value]);
+}
+function ne(column, value) {
+  return new FilterExpression("ne", [column, value]);
+}
+function gt(column, value) {
+  return new FilterExpression("gt", [column, value]);
+}
+function gte(column, value) {
+  return new FilterExpression("gte", [column, value]);
+}
+function lt(column, value) {
+  return new FilterExpression("lt", [column, value]);
+}
+function lte(column, value) {
+  return new FilterExpression("lte", [column, value]);
+}
+function contains(column, value) {
+  return new FilterExpression("contains", [column, value]);
+}
+function startsWith(column, value) {
+  return new FilterExpression("startsWith", [column, value]);
+}
+function endsWith(column, value) {
+  return new FilterExpression("endsWith", [column, value]);
+}
+function inArray(column, values) {
+  return new FilterExpression("in", [column, values]);
+}
+function notInArray(column, values) {
+  return new FilterExpression("notIn", [column, values]);
+}
+function isNull(column) {
+  return new FilterExpression("isNull", [column]);
+}
+function isNotNull(column) {
+  return new FilterExpression("isNotNull", [column]);
+}
+function and(...expressions) {
+  if (expressions.length === 0) {
+    throw new Error("AND operator requires at least one expression");
+  }
+  if (expressions.length === 1 && expressions[0] !== void 0) {
+    return expressions[0];
+  }
+  return new FilterExpression("and", expressions);
+}
+function or(...expressions) {
+  if (expressions.length === 0) {
+    throw new Error("OR operator requires at least one expression");
+  }
+  if (expressions.length === 1 && expressions[0] !== void 0) {
+    return expressions[0];
+  }
+  return new FilterExpression("or", expressions);
+}
+function not(expression) {
+  return new FilterExpression("not", [expression]);
+}
+class OrderByExpression {
+  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration
+  constructor(column, direction) {
+    // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration
+    __publicField(this, "column");
+    __publicField(this, "direction");
+    this.column = column;
+    this.direction = direction;
+  }
+}
+function isOrderByExpression(value) {
+  return value instanceof OrderByExpression;
+}
+function asc(column) {
+  return new OrderByExpression(column, "asc");
+}
+function desc(column) {
+  return new OrderByExpression(column, "desc");
+}
+export {
+  FilterExpression,
+  OrderByExpression,
+  and,
+  asc,
+  contains,
+  desc,
+  endsWith,
+  eq,
+  gt,
+  gte,
+  inArray,
+  isNotNull,
+  isNull,
+  isOrderByExpression,
+  lt,
+  lte,
+  ne,
+  not,
+  notInArray,
+  or,
+  startsWith
+};
+//# sourceMappingURL=operators.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"operators.js","sources":["../../../src/orm/operators.ts"],"sourcesContent":["import { needsFieldQuoting } from \"../client/builders/select-utils\";\nimport type { Column } from \"./column\";\nimport { isColumn } from \"./column\";\n\n/**\n * FilterExpression represents a filter condition that can be used in where() clauses.\n * Internal representation of operator expressions that get converted to OData filter syntax.\n */\nexport class FilterExpression {\n  readonly operator: string;\n  // biome-ignore lint/suspicious/noExplicitAny: Operands can be Column, FilterExpression, or any value type\n  readonly operands: (Column | any | FilterExpression)[];\n\n  // biome-ignore lint/suspicious/noExplicitAny: Operands can be Column, FilterExpression, or any value type\n  constructor(operator: string, operands: (Column | any | FilterExpression)[]) {\n    this.operator = operator;\n    this.operands = operands;\n  }\n\n  /**\n   * Convert this expression to OData filter syntax.\n   * @internal Used by QueryBuilder\n   */\n  toODataFilter(useEntityIds?: boolean): string {\n    switch (this.operator) {\n      // Comparison operators\n      case \"eq\":\n        return this._binaryOp(\"eq\", useEntityIds);\n      case \"ne\":\n        return this._binaryOp(\"ne\", useEntityIds);\n      case \"gt\":\n        return this._binaryOp(\"gt\", useEntityIds);\n      case \"gte\":\n        return this._binaryOp(\"ge\", useEntityIds);\n      case \"lt\":\n        return this._binaryOp(\"lt\", useEntityIds);\n      case \"lte\":\n        return this._binaryOp(\"le\", useEntityIds);\n      case \"in\":\n        return this._inOp(useEntityIds);\n      case \"notIn\":\n        return this._notInOp(useEntityIds);\n\n      // String operators\n      case \"contains\":\n        return this._functionOp(\"contains\", useEntityIds);\n      case \"startsWith\":\n        return this._functionOp(\"startswith\", useEntityIds);\n      case \"endsWith\":\n        return this._functionOp(\"endswith\", useEntityIds);\n\n      // Null checks\n      case \"isNull\":\n        return this._isNullOp(useEntityIds);\n      case \"isNotNull\":\n        return this._isNotNullOp(useEntityIds);\n\n      // Logical operators\n      case \"and\":\n        return this._logicalOp(\"and\", useEntityIds);\n      case \"or\":\n        return this._logicalOp(\"or\", useEntityIds);\n      case \"not\":\n        return this._notOp(useEntityIds);\n\n      default:\n        throw new Error(`Unknown operator: ${this.operator}`);\n    }\n  }\n\n  private _binaryOp(op: string, useEntityIds?: boolean): string {\n    const [left, right] = this.operands;\n    // For binary ops, the column is typically the first operand and value is the second\n    // But we also support column-to-column comparisons, so check both\n    let columnForValue: typeof left | typeof right | undefined;\n    if (isColumn(left) && !isColumn(right)) {\n      columnForValue = left;\n    } else if (isColumn(right) && !isColumn(left)) {\n      columnForValue = right;\n    } else {\n      columnForValue = undefined;\n    }\n    const leftStr = this._operandToString(left, useEntityIds, columnForValue);\n    const rightStr = this._operandToString(right, useEntityIds, columnForValue);\n    return `${leftStr} ${op} ${rightStr}`;\n  }\n\n  private _functionOp(fnName: string, useEntityIds?: boolean): string {\n    const [column, value] = this.operands;\n    const columnInstance = isColumn(column) ? column : undefined;\n    const columnStr = this._operandToString(column, useEntityIds);\n    const valueStr = this._operandToString(value, useEntityIds, columnInstance);\n    return `${fnName}(${columnStr}, ${valueStr})`;\n  }\n\n  private _inOp(useEntityIds?: boolean): string {\n    const [column, values] = this.operands;\n    const columnInstance = isColumn(column) ? column : undefined;\n    const columnStr = this._operandToString(column, useEntityIds);\n    // biome-ignore lint/suspicious/noExplicitAny: Dynamic array of values from user input\n    const valuesStr = (values as any[]).map((v) => this._operandToString(v, useEntityIds, columnInstance)).join(\", \");\n    return `${columnStr} in (${valuesStr})`;\n  }\n\n  private _notInOp(useEntityIds?: boolean): string {\n    const [column, values] = this.operands;\n    const columnInstance = isColumn(column) ? column : undefined;\n    const columnStr = this._operandToString(column, useEntityIds);\n    // biome-ignore lint/suspicious/noExplicitAny: Dynamic array of values from user input\n    const valuesStr = (values as any[]).map((v) => this._operandToString(v, useEntityIds, columnInstance)).join(\", \");\n    return `not (${columnStr} in (${valuesStr}))`;\n  }\n\n  private _isNullOp(useEntityIds?: boolean): string {\n    const [column] = this.operands;\n    const columnStr = this._operandToString(column, useEntityIds);\n    return `${columnStr} eq null`;\n  }\n\n  private _isNotNullOp(useEntityIds?: boolean): string {\n    const [column] = this.operands;\n    const columnStr = this._operandToString(column, useEntityIds);\n    return `${columnStr} ne null`;\n  }\n\n  private _logicalOp(op: string, useEntityIds?: boolean): string {\n    const expressions = this.operands.map((expr) => {\n      if (expr instanceof FilterExpression) {\n        const innerExpr = expr.toODataFilter(useEntityIds);\n        // Wrap in parens if it's a logical expression to ensure precedence\n        if (expr.operator === \"and\" || expr.operator === \"or\") {\n          return `(${innerExpr})`;\n        }\n        return innerExpr;\n      }\n      throw new Error(\"Logical operators require FilterExpression operands\");\n    });\n    return expressions.join(` ${op} `);\n  }\n\n  private _notOp(useEntityIds?: boolean): string {\n    const [expr] = this.operands;\n    if (expr instanceof FilterExpression) {\n      return `not (${expr.toODataFilter(useEntityIds)})`;\n    }\n    throw new Error(\"NOT operator requires a FilterExpression operand\");\n  }\n\n  private _operandToString(\n    // biome-ignore lint/suspicious/noExplicitAny: Operand can be Column, FilterExpression, or any value type\n    operand: any,\n    useEntityIds?: boolean, // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n    column?: Column<any, any, any, any>,\n  ): string {\n    if (isColumn(operand)) {\n      const fieldIdentifier = operand.getFieldIdentifier(useEntityIds);\n      // Quote field names in OData filters per FileMaker OData API requirements\n      return needsFieldQuoting(fieldIdentifier) ? `\"${fieldIdentifier}\"` : fieldIdentifier;\n    }\n\n    // If we have a column with an input validator, apply it to transform the value\n    let value = operand;\n    if (column?.inputValidator) {\n      try {\n        const result = column.inputValidator[\"~standard\"].validate(value);\n        // Handle async validators (though they shouldn't be async for filters)\n        if (result instanceof Promise) {\n          // For filters, we can't use async validators, so skip transformation\n          // This is a limitation - async validators won't work in filters\n          value = operand;\n        } else if (\"issues\" in result && result.issues) {\n          // Validation failed, use original value\n          value = operand;\n        } else if (\"value\" in result) {\n          // Validation succeeded, use transformed value\n          value = result.value;\n        }\n      } catch (_error) {\n        // If validation throws, use the original value (will likely cause a query error)\n        // This maintains backward compatibility and allows the server to handle validation\n        value = operand;\n      }\n    }\n\n    if (typeof value === \"string\") {\n      return `'${value.replace(/'/g, \"''\")}'`; // Escape single quotes\n    }\n    if (value === null || value === undefined) {\n      return \"null\";\n    }\n    if (value instanceof Date) {\n      return value.toISOString();\n    }\n    return String(value);\n  }\n}\n\n// ============================================================================\n// Comparison Operators\n// ============================================================================\n\n/**\n * Equal operator - checks if column equals a value or another column.\n *\n * @example\n * eq(users.name, \"John\")           // name equals \"John\"\n * eq(users.id, contacts.id_user)   // cross-table comparison\n */\nexport function eq<TOutput, TInput>(\n  column1: Column<TOutput, TInput>,\n  column2: Column<TOutput, TInput> | NoInfer<TInput>,\n): FilterExpression;\n// biome-ignore lint/suspicious/noExplicitAny: Implementation signature for overloads\nexport function eq(column: Column, value: any): FilterExpression {\n  return new FilterExpression(\"eq\", [column, value]);\n}\n\n/**\n * Not equal operator - checks if column does not equal a value or another column.\n *\n * @example\n * ne(users.status, \"inactive\")     // status not equal to \"inactive\"\n * ne(users.id, contacts.id_user)   // cross-table comparison\n */\nexport function ne<TOutput, TInput>(\n  column1: Column<TOutput, TInput>,\n  column2: Column<TOutput, TInput> | NoInfer<TInput>,\n): FilterExpression;\n// biome-ignore lint/suspicious/noExplicitAny: Implementation signature for overloads\nexport function ne(column: Column, value: any): FilterExpression {\n  return new FilterExpression(\"ne\", [column, value]);\n}\n\n/**\n * Greater than operator - checks if column is greater than a value.\n *\n * @example\n * gt(users.age, 18)               // age greater than 18\n */\nexport function gt<TOutput extends number | string | Date | null, TInput>(\n  column: Column<TOutput, TInput>,\n  value: NoInfer<TInput>,\n): FilterExpression {\n  return new FilterExpression(\"gt\", [column, value]);\n}\n\n/**\n * Greater than or equal operator - checks if column is >= a value.\n *\n * @example\n * gte(users.age, 18)              // age >= 18\n */\nexport function gte<TOutput extends number | string | Date | null, TInput>(\n  column: Column<TOutput, TInput>,\n  value: NoInfer<TInput>,\n): FilterExpression {\n  return new FilterExpression(\"gte\", [column, value]);\n}\n\n/**\n * Less than operator - checks if column is less than a value.\n *\n * @example\n * lt(users.age, 65)               // age less than 65\n */\nexport function lt<TOutput extends number | string | Date | null, TInput>(\n  column: Column<TOutput, TInput>,\n  value: NoInfer<TInput>,\n): FilterExpression {\n  return new FilterExpression(\"lt\", [column, value]);\n}\n\n/**\n * Less than or equal operator - checks if column is <= a value.\n *\n * @example\n * lte(users.age, 65)              // age <= 65\n */\nexport function lte<TOutput extends number | string | Date | null, TInput>(\n  column: Column<TOutput, TInput>,\n  value: NoInfer<TInput>,\n): FilterExpression {\n  return new FilterExpression(\"lte\", [column, value]);\n}\n\n// ============================================================================\n// String Operators\n// ============================================================================\n\n/**\n * Contains operator - checks if a string column contains a substring.\n *\n * @example\n * contains(users.name, \"John\")    // name contains \"John\"\n */\nexport function contains<TOutput, TInput>(column: Column<TOutput, TInput>, value: NoInfer<TInput>): FilterExpression {\n  return new FilterExpression(\"contains\", [column, value]);\n}\n\n/**\n * Starts with operator - checks if a string column starts with a prefix.\n *\n * @example\n * startsWith(users.email, \"admin\") // email starts with \"admin\"\n */\nexport function startsWith<TOutput, TInput>(column: Column<TOutput, TInput>, value: NoInfer<TInput>): FilterExpression {\n  return new FilterExpression(\"startsWith\", [column, value]);\n}\n\n/**\n * Ends with operator - checks if a string column ends with a suffix.\n *\n * @example\n * endsWith(users.email, \"@example.com\") // email ends with \"@example.com\"\n */\nexport function endsWith<TOutput, TInput>(column: Column<TOutput, TInput>, value: NoInfer<TInput>): FilterExpression {\n  return new FilterExpression(\"endsWith\", [column, value]);\n}\n\n// ============================================================================\n// Array Operators\n// ============================================================================\n\n/**\n * In array operator - checks if column value is in an array of values.\n *\n * @example\n * inArray(users.status, [\"active\", \"pending\"]) // status is \"active\" or \"pending\"\n */\nexport function inArray<TOutput, TInput>(column: Column<TOutput, TInput>, values: NoInfer<TInput>[]): FilterExpression {\n  return new FilterExpression(\"in\", [column, values]);\n}\n\n/**\n * Not in array operator - checks if column value is not in an array of values.\n *\n * @example\n * notInArray(users.status, [\"deleted\", \"banned\"]) // status is neither \"deleted\" nor \"banned\"\n */\nexport function notInArray<TOutput, TInput>(\n  column: Column<TOutput, TInput>,\n  values: NoInfer<TInput>[],\n): FilterExpression {\n  return new FilterExpression(\"notIn\", [column, values]);\n}\n\n// ============================================================================\n// Null Check Operators\n// ============================================================================\n\n/**\n * Is null operator - checks if column value is null.\n *\n * @example\n * isNull(users.deletedAt)         // deletedAt is null\n */\nexport function isNull<TOutput, TInput>(column: Column<TOutput, TInput>): FilterExpression {\n  return new FilterExpression(\"isNull\", [column]);\n}\n\n/**\n * Is not null operator - checks if column value is not null.\n *\n * @example\n * isNotNull(users.email)          // email is not null\n */\nexport function isNotNull<TOutput, TInput>(column: Column<TOutput, TInput>): FilterExpression {\n  return new FilterExpression(\"isNotNull\", [column]);\n}\n\n// ============================================================================\n// Logical Operators\n// ============================================================================\n\n/**\n * AND operator - combines multiple filter expressions with logical AND.\n * All expressions must be true for the record to match.\n *\n * @example\n * and(\n *   eq(users.active, true),\n *   gt(users.age, 18)\n * ) // active is true AND age > 18\n */\nexport function and(...expressions: FilterExpression[]): FilterExpression {\n  if (expressions.length === 0) {\n    throw new Error(\"AND operator requires at least one expression\");\n  }\n  if (expressions.length === 1 && expressions[0] !== undefined) {\n    return expressions[0];\n  }\n  return new FilterExpression(\"and\", expressions);\n}\n\n/**\n * OR operator - combines multiple filter expressions with logical OR.\n * At least one expression must be true for the record to match.\n *\n * @example\n * or(\n *   eq(users.role, \"admin\"),\n *   eq(users.role, \"moderator\")\n * ) // role is \"admin\" OR \"moderator\"\n */\nexport function or(...expressions: FilterExpression[]): FilterExpression {\n  if (expressions.length === 0) {\n    throw new Error(\"OR operator requires at least one expression\");\n  }\n  if (expressions.length === 1 && expressions[0] !== undefined) {\n    return expressions[0];\n  }\n  return new FilterExpression(\"or\", expressions);\n}\n\n/**\n * NOT operator - negates a filter expression.\n *\n * @example\n * not(eq(users.status, \"deleted\")) // status is NOT \"deleted\"\n */\nexport function not(expression: FilterExpression): FilterExpression {\n  return new FilterExpression(\"not\", [expression]);\n}\n\n// ============================================================================\n// OrderBy Operators\n// ============================================================================\n\n/**\n * OrderByExpression represents a sort order specification for a column.\n * Used in orderBy() clauses to provide type-safe sorting with direction.\n */\nexport class OrderByExpression<TableName extends string = string> {\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n  readonly column: Column<any, any, TableName>;\n  readonly direction: \"asc\" | \"desc\";\n\n  // biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\n  constructor(column: Column<any, any, TableName>, direction: \"asc\" | \"desc\") {\n    this.column = column;\n    this.direction = direction;\n  }\n}\n\n/**\n * Type guard to check if a value is an OrderByExpression instance.\n */\n// biome-ignore lint/suspicious/noExplicitAny: Type guard accepting any value type\nexport function isOrderByExpression(value: any): value is OrderByExpression {\n  return value instanceof OrderByExpression;\n}\n\n/**\n * Ascending order operator - sorts a column in ascending order.\n *\n * @example\n * asc(users.name)  // Sort by name ascending\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\nexport function asc<TableName extends string>(column: Column<any, any, TableName>): OrderByExpression<TableName> {\n  return new OrderByExpression(column, \"asc\");\n}\n\n/**\n * Descending order operator - sorts a column in descending order.\n *\n * @example\n * desc(users.age)  // Sort by age descending\n */\n// biome-ignore lint/suspicious/noExplicitAny: Generic constraint accepting any Column configuration\nexport function desc<TableName extends string>(column: Column<any, any, TableName>): OrderByExpression<TableName> {\n  return new OrderByExpression(column, \"desc\");\n}\n"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,355 @@
+import { StandardSchemaV1 } from '@standard-schema/spec';
+import { Column } from './column.js';
+import { ContainerDbType, FieldBuilder, FieldBuilder as FieldBuilderType } from './field-builders.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;
+declare const FMTableComment: 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;
+        Comment: symbol;
+    };
+    /** @internal */
+    [FMTableName]: TName;
+    /** @internal */
+    [FMTableEntityId]?: `FMTID:${string}`;
+    /** @internal */
+    [FMTableUseEntityIds]?: boolean;
+    /** @internal */
+    [FMTableComment]?: string;
+    /** @internal */
+    [FMTableSchema]: Partial<Record<keyof TFields, StandardSchemaV1>>;
+    /** @internal */
+    [FMTableFields]: TFields;
+    /** @internal */
+    [FMTableNavigationPaths]: TNavigationPaths;
+    /** @internal */
+    [FMTableDefaultSelect]: "all" | "schema" | Record<string, Column<any, any, TName>>;
+    /** @internal */
+    [FMTableBaseTableConfig]: {
+        schema: Partial<Record<keyof TFields, StandardSchemaV1>>;
+        inputSchema?: Partial<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;
+        comment?: string;
+        schema: Partial<Record<keyof TFields, StandardSchemaV1>>;
+        fields: TFields;
+        navigationPaths: TNavigationPaths;
+        defaultSelect: "all" | "schema" | Record<string, Column<any, any, TName>>;
+        baseTableConfig: {
+            schema: Partial<Record<keyof TFields, StandardSchemaV1>>;
+            inputSchema?: Partial<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.
+ * Columns include both output type (for reading) and input type (for writing/filtering).
+ */
+export type ColumnMap<TFields extends Record<string, FieldBuilder<any, any, any, any>>, TName extends string> = {
+    [K in keyof TFields]: Column<InferFieldOutput<TFields[K]>, InferFieldInput<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]>, InferFieldInput<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, any>>> = {
+    [K in keyof TSelect]: TSelect[K] extends Column<any, any, any, true> ? never : TSelect[K];
+} extends TSelect ? TSelect : {
+    [K in keyof TSelect]: TSelect[K] extends Column<any, 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}`;
+    /** The comment for this table */
+    comment?: 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, 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 record (partial - only fields with validators)
+ */
+export declare function getTableSchema<T extends FMTable<any, any>>(table: T): Partial<Record<keyof T[typeof FMTableFields], 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, 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: Partial<Record<string | number | symbol, StandardSchemaV1<unknown, unknown>>>;
+    inputSchema?: Partial<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 the comment from an FMTable instance.
+ * @param table - FMTable instance
+ * @returns The comment string or undefined if not set
+ */
+export declare function getTableComment<T extends FMTable<any, any>>(table: T): string | undefined;
+/**
+ * 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 FMTable<any, any>>(table: T): ColumnMap<T[typeof FMTableFields], ExtractTableName<T>>;
+export {};