ci: apply automated fixes

Author: autofix-ci[bot]

.changeset/auto-register-operators.md

@@ -20,11 +20,13 @@ import { defineOperator, isUnknown } from '@tanstack/db'
 // Define a custom "between" operator
 const between = defineOperator<boolean>({
   name: 'between',
-  evaluate: ([valueArg, minArg, maxArg]) => (data) => {
-    const value = valueArg!(data)
-    if (isUnknown(value)) return null
-    return value >= minArg!(data) && value <= maxArg!(data)
-  }
+  evaluate:
+    ([valueArg, minArg, maxArg]) =>
+    (data) => {
+      const value = valueArg!(data)
+      if (isUnknown(value)) return null
+      return value >= minArg!(data) && value <= maxArg!(data)
+    },
 })
 
 // Use in a query
@@ -39,19 +41,19 @@ import { defineOperator, comparison, transform, numeric } from '@tanstack/db'
 // Binary comparison with automatic null handling
 const notEquals = defineOperator<boolean>({
   name: 'notEquals',
-  evaluate: comparison((a, b) => a !== b)
+  evaluate: comparison((a, b) => a !== b),
 })
 
 // Unary transformation
 const double = defineOperator<number>({
   name: 'double',
-  evaluate: transform((v) => typeof v === 'number' ? v * 2 : v)
+  evaluate: transform((v) => (typeof v === 'number' ? v * 2 : v)),
 })
 
 // Binary numeric operation
 const modulo = defineOperator<number>({
   name: 'modulo',
-  evaluate: numeric((a, b) => b !== 0 ? a % b : null)
+  evaluate: numeric((a, b) => (b !== 0 ? a % b : null)),
 })
 ```
 
@@ -70,8 +72,8 @@ const product = defineAggregate<number>({
         for (let i = 0; i < multiplicity; i++) result *= value
       }
       return result
-    }
+    },
   }),
-  valueTransform: 'numeric'
+  valueTransform: 'numeric',
 })
 ```

packages/db/src/query/builder/operators/and.ts

@@ -5,7 +5,10 @@ import type { BasicExpression } from '../../ir.js'
 import type { ExpressionLike } from './types.js'
 
 // AND: short-circuits on false, returns true if all are true
-const andFactory = /* #__PURE__*/ booleanOp({ shortCircuit: false, default: true })
+const andFactory = /* #__PURE__*/ booleanOp({
+  shortCircuit: false,
+  default: true,
+})
 
 // Overloads for and() - support 2 or more arguments, or an array
 export function and(

packages/db/src/query/builder/operators/divide.ts

@@ -5,7 +5,9 @@ import type { EvaluatorFactory } from '../../ir.js'
 import type { BinaryNumericReturnType, ExpressionLike } from './types.js'
 
 // Division returns null for division by zero
-const divideFactory = /* #__PURE__*/ numeric((a, b) => (b !== 0 ? a / b : null)) as EvaluatorFactory
+const divideFactory = /* #__PURE__*/ numeric((a, b) =>
+  b !== 0 ? a / b : null,
+) as EvaluatorFactory
 
 export function divide<T1 extends ExpressionLike, T2 extends ExpressionLike>(
   left: T1,

packages/db/src/query/builder/operators/eq.ts

@@ -28,7 +28,10 @@ export function eq<T>(
   left: ComparisonOperand<T>,
   right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
-export function eq<T>(left: Aggregate<T>, right: unknown): BasicExpression<boolean>
+export function eq<T>(
+  left: Aggregate<T>,
+  right: unknown,
+): BasicExpression<boolean>
 export function eq(left: unknown, right: unknown): BasicExpression<boolean> {
   return new Func(`eq`, [toExpression(left), toExpression(right)], eqFactory)
 }

packages/db/src/query/builder/operators/gt.ts

@@ -5,13 +5,18 @@ import type { Aggregate, BasicExpression, EvaluatorFactory } from '../../ir.js'
 import type { ComparisonOperand } from './types.js'
 
 // Factory using the comparison helper - cast to EvaluatorFactory for Func constructor
-const gtFactory = /* #__PURE__*/ comparison<number>((a, b) => a > b) as EvaluatorFactory
+const gtFactory = /* #__PURE__*/ comparison<number>(
+  (a, b) => a > b,
+) as EvaluatorFactory
 
 export function gt<T>(
   left: ComparisonOperand<T>,
   right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
-export function gt<T>(left: Aggregate<T>, right: unknown): BasicExpression<boolean>
+export function gt<T>(
+  left: Aggregate<T>,
+  right: unknown,
+): BasicExpression<boolean>
 export function gt(left: unknown, right: unknown): BasicExpression<boolean> {
   return new Func(`gt`, [toExpression(left), toExpression(right)], gtFactory)
 }

packages/db/src/query/builder/operators/gte.ts

@@ -5,13 +5,18 @@ import type { Aggregate, BasicExpression, EvaluatorFactory } from '../../ir.js'
 import type { ComparisonOperand } from './types.js'
 
 // Factory using the comparison helper - cast to EvaluatorFactory for Func constructor
-const gteFactory = /* #__PURE__*/ comparison<number>((a, b) => a >= b) as EvaluatorFactory
+const gteFactory = /* #__PURE__*/ comparison<number>(
+  (a, b) => a >= b,
+) as EvaluatorFactory
 
 export function gte<T>(
   left: ComparisonOperand<T>,
   right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
-export function gte<T>(left: Aggregate<T>, right: unknown): BasicExpression<boolean>
+export function gte<T>(
+  left: Aggregate<T>,
+  right: unknown,
+): BasicExpression<boolean>
 export function gte(left: unknown, right: unknown): BasicExpression<boolean> {
   return new Func(`gte`, [toExpression(left), toExpression(right)], gteFactory)
 }

packages/db/src/query/builder/operators/in.ts

@@ -27,9 +27,5 @@ export function inArray(
   value: ExpressionLike,
   array: ExpressionLike,
 ): BasicExpression<boolean> {
-  return new Func(
-    `in`,
-    [toExpression(value), toExpression(array)],
-    inFactory,
-  )
+  return new Func(`in`, [toExpression(value), toExpression(array)], inFactory)
 }

packages/db/src/query/builder/operators/like.ts

@@ -45,5 +45,9 @@ export function like(
   right: ExpressionLike,
 ): BasicExpression<boolean>
 export function like(left: unknown, right: unknown): BasicExpression<boolean> {
-  return new Func(`like`, [toExpression(left), toExpression(right)], likeFactory)
+  return new Func(
+    `like`,
+    [toExpression(left), toExpression(right)],
+    likeFactory,
+  )
 }

packages/db/src/query/builder/operators/lt.ts

@@ -5,13 +5,18 @@ import type { Aggregate, BasicExpression, EvaluatorFactory } from '../../ir.js'
 import type { ComparisonOperand } from './types.js'
 
 // Factory using the comparison helper - cast to EvaluatorFactory for Func constructor
-const ltFactory = /* #__PURE__*/ comparison<number>((a, b) => a < b) as EvaluatorFactory
+const ltFactory = /* #__PURE__*/ comparison<number>(
+  (a, b) => a < b,
+) as EvaluatorFactory
 
 export function lt<T>(
   left: ComparisonOperand<T>,
   right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
-export function lt<T>(left: Aggregate<T>, right: unknown): BasicExpression<boolean>
+export function lt<T>(
+  left: Aggregate<T>,
+  right: unknown,
+): BasicExpression<boolean>
 export function lt(left: unknown, right: unknown): BasicExpression<boolean> {
   return new Func(`lt`, [toExpression(left), toExpression(right)], ltFactory)
 }

packages/db/src/query/builder/operators/lte.ts

@@ -5,13 +5,18 @@ import type { Aggregate, BasicExpression, EvaluatorFactory } from '../../ir.js'
 import type { ComparisonOperand } from './types.js'
 
 // Factory using the comparison helper - cast to EvaluatorFactory for Func constructor
-const lteFactory = /* #__PURE__*/ comparison<number>((a, b) => a <= b) as EvaluatorFactory
+const lteFactory = /* #__PURE__*/ comparison<number>(
+  (a, b) => a <= b,
+) as EvaluatorFactory
 
 export function lte<T>(
   left: ComparisonOperand<T>,
   right: ComparisonOperand<T>,
 ): BasicExpression<boolean>
-export function lte<T>(left: Aggregate<T>, right: unknown): BasicExpression<boolean>
+export function lte<T>(
+  left: Aggregate<T>,
+  right: unknown,
+): BasicExpression<boolean>
 export function lte(left: unknown, right: unknown): BasicExpression<boolean> {
   return new Func(`lte`, [toExpression(left), toExpression(right)], lteFactory)
 }