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

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

@@ -0,0 +1,175 @@
+import { Column } from './column.js';
+/**
+ * FilterExpression represents a filter condition that can be used in where() clauses.
+ * Internal representation of operator expressions that get converted to OData filter syntax.
+ */
+export declare class FilterExpression {
+    readonly operator: string;
+    readonly operands: (Column | any | FilterExpression)[];
+    constructor(operator: string, operands: (Column | any | FilterExpression)[]);
+    /**
+     * Convert this expression to OData filter syntax.
+     * @internal Used by QueryBuilder
+     */
+    toODataFilter(useEntityIds?: boolean): string;
+    private _binaryOp;
+    private _functionOp;
+    private _inOp;
+    private _notInOp;
+    private _isNullOp;
+    private _isNotNullOp;
+    private _logicalOp;
+    private _notOp;
+    private _operandToString;
+}
+/**
+ * Equal operator - checks if column equals a value or another column.
+ *
+ * @example
+ * eq(users.name, "John")           // name equals "John"
+ * eq(users.id, contacts.id_user)   // cross-table comparison
+ */
+export declare function eq<T>(column: Column<T>, value: T): FilterExpression;
+export declare function eq<T>(column1: Column<T>, column2: Column<T>): FilterExpression;
+/**
+ * Not equal operator - checks if column does not equal a value or another column.
+ *
+ * @example
+ * ne(users.status, "inactive")     // status not equal to "inactive"
+ * ne(users.id, contacts.id_user)   // cross-table comparison
+ */
+export declare function ne<T>(column: Column<T>, value: T): FilterExpression;
+export declare function ne<T>(column1: Column<T>, column2: Column<T>): FilterExpression;
+/**
+ * Greater than operator - checks if column is greater than a value.
+ *
+ * @example
+ * gt(users.age, 18)               // age greater than 18
+ */
+export declare function gt<T extends number | string | Date | null>(column: Column<T>, value: T): FilterExpression;
+/**
+ * Greater than or equal operator - checks if column is >= a value.
+ *
+ * @example
+ * gte(users.age, 18)              // age >= 18
+ */
+export declare function gte<T extends number | string | Date | null>(column: Column<T>, value: T): FilterExpression;
+/**
+ * Less than operator - checks if column is less than a value.
+ *
+ * @example
+ * lt(users.age, 65)               // age less than 65
+ */
+export declare function lt<T extends number | string | Date | null>(column: Column<T>, value: T): FilterExpression;
+/**
+ * Less than or equal operator - checks if column is <= a value.
+ *
+ * @example
+ * lte(users.age, 65)              // age <= 65
+ */
+export declare function lte<T extends number | string | Date | null>(column: Column<T>, value: T): FilterExpression;
+/**
+ * Contains operator - checks if a string column contains a substring.
+ *
+ * @example
+ * contains(users.name, "John")    // name contains "John"
+ */
+export declare function contains(column: Column<string | null>, value: string): FilterExpression;
+/**
+ * Starts with operator - checks if a string column starts with a prefix.
+ *
+ * @example
+ * startsWith(users.email, "admin") // email starts with "admin"
+ */
+export declare function startsWith(column: Column<string | null>, value: string): FilterExpression;
+/**
+ * Ends with operator - checks if a string column ends with a suffix.
+ *
+ * @example
+ * endsWith(users.email, "@example.com") // email ends with "@example.com"
+ */
+export declare function endsWith(column: Column<string | null>, value: string): FilterExpression;
+/**
+ * In array operator - checks if column value is in an array of values.
+ *
+ * @example
+ * inArray(users.status, ["active", "pending"]) // status is "active" or "pending"
+ */
+export declare function inArray<T>(column: Column<T | null>, values: T[]): FilterExpression;
+/**
+ * Not in array operator - checks if column value is not in an array of values.
+ *
+ * @example
+ * notInArray(users.status, ["deleted", "banned"]) // status is neither "deleted" nor "banned"
+ */
+export declare function notInArray<T>(column: Column<T>, values: T[]): FilterExpression;
+/**
+ * Is null operator - checks if column value is null.
+ *
+ * @example
+ * isNull(users.deletedAt)         // deletedAt is null
+ */
+export declare function isNull<T>(column: Column<T>): FilterExpression;
+/**
+ * Is not null operator - checks if column value is not null.
+ *
+ * @example
+ * isNotNull(users.email)          // email is not null
+ */
+export declare function isNotNull<T>(column: Column<T>): FilterExpression;
+/**
+ * AND operator - combines multiple filter expressions with logical AND.
+ * All expressions must be true for the record to match.
+ *
+ * @example
+ * and(
+ *   eq(users.active, true),
+ *   gt(users.age, 18)
+ * ) // active is true AND age > 18
+ */
+export declare function and(...expressions: FilterExpression[]): FilterExpression;
+/**
+ * OR operator - combines multiple filter expressions with logical OR.
+ * At least one expression must be true for the record to match.
+ *
+ * @example
+ * or(
+ *   eq(users.role, "admin"),
+ *   eq(users.role, "moderator")
+ * ) // role is "admin" OR "moderator"
+ */
+export declare function or(...expressions: FilterExpression[]): FilterExpression;
+/**
+ * NOT operator - negates a filter expression.
+ *
+ * @example
+ * not(eq(users.status, "deleted")) // status is NOT "deleted"
+ */
+export declare function not(expression: FilterExpression): FilterExpression;
+/**
+ * OrderByExpression represents a sort order specification for a column.
+ * Used in orderBy() clauses to provide type-safe sorting with direction.
+ */
+export declare class OrderByExpression<TableName extends string = string> {
+    readonly column: Column<any, TableName>;
+    readonly direction: "asc" | "desc";
+    constructor(column: Column<any, TableName>, direction: "asc" | "desc");
+}
+/**
+ * Type guard to check if a value is an OrderByExpression instance.
+ */
+export declare function isOrderByExpression(value: any): value is OrderByExpression;
+/**
+ * Ascending order operator - sorts a column in ascending order.
+ *
+ * @example
+ * asc(users.name)  // Sort by name ascending
+ */
+export declare function asc<TableName extends string>(column: Column<any, TableName>): OrderByExpression<TableName>;
+/**
+ * Descending order operator - sorts a column in descending order.
+ *
+ * @example
+ * desc(users.age)  // Sort by age descending
+ */
+export declare function desc<TableName extends string>(column: Column<any, TableName>): OrderByExpression<TableName>;

package/dist/esm/orm/operators.js

@@ -0,0 +1,221 @@
+import { isColumn } from "./column.js";
+class FilterExpression {
+  constructor(operator, 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;
+    const leftStr = this._operandToString(left, useEntityIds);
+    const rightStr = this._operandToString(right, useEntityIds);
+    return `${leftStr} ${op} ${rightStr}`;
+  }
+  _functionOp(fnName, useEntityIds) {
+    const [column, value] = this.operands;
+    const columnStr = this._operandToString(column, useEntityIds);
+    const valueStr = this._operandToString(value, useEntityIds);
+    return `${fnName}(${columnStr}, ${valueStr})`;
+  }
+  _inOp(useEntityIds) {
+    const [column, values] = this.operands;
+    const columnStr = this._operandToString(column, useEntityIds);
+    const valuesStr = values.map((v) => this._operandToString(v, useEntityIds)).join(", ");
+    return `${columnStr} in (${valuesStr})`;
+  }
+  _notInOp(useEntityIds) {
+    const [column, values] = this.operands;
+    const columnStr = this._operandToString(column, useEntityIds);
+    const valuesStr = values.map((v) => this._operandToString(v, useEntityIds)).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) {
+    if (isColumn(operand)) {
+      return operand.getFieldIdentifier(useEntityIds);
+    }
+    if (typeof operand === "string") {
+      return `'${operand.replace(/'/g, "''")}'`;
+    }
+    if (operand === null || operand === void 0) {
+      return "null";
+    }
+    if (operand instanceof Date) {
+      return operand.toISOString();
+    }
+    return String(operand);
+  }
+}
+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 {
+  constructor(column, 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 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  constructor(\n    public readonly operator: string,\n    public readonly operands: (Column | any | FilterExpression)[],\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    const leftStr = this._operandToString(left, useEntityIds);\n    const rightStr = this._operandToString(right, useEntityIds);\n    return `${leftStr} ${op} ${rightStr}`;\n  }\n\n  private _functionOp(fnName: string, useEntityIds?: boolean): string {\n    const [column, value] = this.operands;\n    const columnStr = this._operandToString(column, useEntityIds);\n    const valueStr = this._operandToString(value, useEntityIds);\n    return `${fnName}(${columnStr}, ${valueStr})`;\n  }\n\n  private _inOp(useEntityIds?: boolean): string {\n    const [column, values] = this.operands;\n    const columnStr = this._operandToString(column, useEntityIds);\n    const valuesStr = (values as any[])\n      .map((v) => this._operandToString(v, useEntityIds))\n      .join(\", \");\n    return `${columnStr} in (${valuesStr})`;\n  }\n\n  private _notInOp(useEntityIds?: boolean): string {\n    const [column, values] = this.operands;\n    const columnStr = this._operandToString(column, useEntityIds);\n    const valuesStr = (values as any[])\n      .map((v) => this._operandToString(v, useEntityIds))\n      .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(operand: any, useEntityIds?: boolean): string {\n    if (isColumn(operand)) {\n      return operand.getFieldIdentifier(useEntityIds);\n    }\n    if (typeof operand === \"string\") {\n      return `'${operand.replace(/'/g, \"''\")}'`; // Escape single quotes\n    }\n    if (operand === null || operand === undefined) {\n      return \"null\";\n    }\n    if (operand instanceof Date) {\n      return operand.toISOString();\n    }\n    return String(operand);\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<T>(column: Column<T>, value: T): FilterExpression;\nexport function eq<T>(column1: Column<T>, column2: Column<T>): FilterExpression;\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<T>(column: Column<T>, value: T): FilterExpression;\nexport function ne<T>(column1: Column<T>, column2: Column<T>): FilterExpression;\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<T extends number | string | Date | null>(\n  column: Column<T>,\n  value: T,\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<T extends number | string | Date | null>(\n  column: Column<T>,\n  value: T,\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<T extends number | string | Date | null>(\n  column: Column<T>,\n  value: T,\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<T extends number | string | Date | null>(\n  column: Column<T>,\n  value: T,\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(\n  column: Column<string | null>,\n  value: string,\n): 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(\n  column: Column<string | null>,\n  value: string,\n): 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(\n  column: Column<string | null>,\n  value: string,\n): 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<T>(\n  column: Column<T | null>,\n  values: T[],\n): 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<T>(\n  column: Column<T>,\n  values: T[],\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<T>(column: Column<T>): 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<T>(column: Column<T>): 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  constructor(\n    public readonly column: Column<any, TableName>,\n    public readonly direction: \"asc\" | \"desc\",\n  ) {}\n}\n\n/**\n * Type guard to check if a value is an OrderByExpression instance.\n */\nexport function isOrderByExpression(\n  value: any,\n): 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 */\nexport function asc<TableName extends string>(\n  column: Column<any, TableName>,\n): 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 */\nexport function desc<TableName extends string>(\n  column: Column<any, TableName>,\n): OrderByExpression<TableName> {\n  return new OrderByExpression(column, \"desc\");\n}\n"],"names":[],"mappings":"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"}