@onchaindb/sdk 0.4.5 → 2.0.0

package/src/query-sdk/NestedBuilders.ts

@@ -1,4 +1,4 @@
-import { LogicalOperator, FieldConditionBuilder, Condition } from './operators';
+import { LogicalOperator } from './operators';
 
 // Builder for creating nested field conditions with ORM-like syntax
 export class NestedConditionBuilder {
@@ -8,179 +8,177 @@ export class NestedConditionBuilder {
         this.path = [rootField];
     }
 
-    // Add another level to the path and create field conditions
     field(fieldName: string): NestedFieldConditionBuilder {
-        const newPath = [...this.path, fieldName];
-        return new NestedFieldConditionBuilder(newPath);
+        return new NestedFieldConditionBuilder([...this.path, fieldName]);
     }
 
-    // Create nested structure with callback
     nested(fieldName: string, builderFn: (builder: NestedConditionBuilder) => LogicalOperator): LogicalOperator {
-        const nestedPath = [...this.path, fieldName];
         const nestedBuilder = new NestedConditionBuilder('');
-        nestedBuilder.path = nestedPath;
+        nestedBuilder.path = [...this.path, fieldName];
         return builderFn(nestedBuilder);
     }
 
-    // Create logical groups
-    andGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator {
-        const conditions = builderFn(this);
+    // Logical group helpers — pass conditions as variadic args or chain on the result
+    and(...conditions: LogicalOperator[]): LogicalOperator {
         return LogicalOperator.And(conditions);
     }
 
-    orGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator {
-        const conditions = builderFn(this);
+    or(...conditions: LogicalOperator[]): LogicalOperator {
         return LogicalOperator.Or(conditions);
     }
 
-    notGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator {
-        const conditions = builderFn(this);
+    not(...conditions: LogicalOperator[]): LogicalOperator {
         return LogicalOperator.Not(conditions);
     }
-}
 
-// Builder for field conditions within nested structures
-// Only includes operators that actually exist in the Rust implementation
-export class NestedFieldConditionBuilder {
-    private fieldPath: string[];
+    // Callback-style group helpers (kept for compatibility)
+    andGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.And(builderFn(this));
+    }
+
+    orGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Or(builderFn(this));
+    }
 
-    constructor(fieldPath: string[]) {
-        this.fieldPath = fieldPath;
+    notGroup(builderFn: (builder: NestedConditionBuilder) => LogicalOperator[]): LogicalOperator {
+        return LogicalOperator.Not(builderFn(this));
     }
+}
 
-    private createCondition(operator: string, value: any): Condition {
-        const path = this.fieldPath.join('.');
-        return {
-            field: path,
+// Builder for field conditions within nested structures.
+// All methods return LogicalOperator directly — no wrapping needed at call sites.
+export class NestedFieldConditionBuilder {
+    constructor(private fieldPath: string[]) {}
+
+    private cond(operator: string, value: any): LogicalOperator {
+        return LogicalOperator.Condition({
+            field: this.fieldPath.join('.'),
             operator,
             value
-        };
+        });
     }
 
-    // ===== BASE OPERATORS (BaseOperator) =====
+    // ===== BASE OPERATORS =====
 
-    equals(value: any): Condition {
-        return this.createCondition('is', value);
+    equals(value: any): LogicalOperator {
+        return this.cond('is', value);
     }
 
-    notEquals(value: any): Condition {
-        return this.createCondition('isNot', value);
+    notEquals(value: any): LogicalOperator {
+        return this.cond('isNot', value);
     }
 
-    in(values: any[]): Condition {
-        return this.createCondition('in', values);
+    in(values: any[]): LogicalOperator {
+        return this.cond('in', values);
     }
 
-    notIn(values: any[]): Condition {
-        return this.createCondition('notIn', values);
+    notIn(values: any[]): LogicalOperator {
+        return this.cond('notIn', values);
     }
 
-    isNull(): Condition {
-        return this.createCondition('isNull', true);
+    isNull(): LogicalOperator {
+        return this.cond('isNull', true);
     }
 
-    isNotNull(): Condition {
-        return this.createCondition('isNull', false);
+    isNotNull(): LogicalOperator {
+        return this.cond('isNull', false);
     }
 
-    exists(): Condition {
-        return this.createCondition('exists', true);
+    exists(): LogicalOperator {
+        return this.cond('exists', true);
     }
 
-    notExists(): Condition {
-        return this.createCondition('exists', false);
+    notExists(): LogicalOperator {
+        return this.cond('exists', false);
     }
 
-    // ===== STRING OPERATORS (StringOperator) =====
+    // ===== STRING OPERATORS =====
 
-    startsWith(value: string): Condition {
-        return this.createCondition('startsWith', value);
+    startsWith(value: string): LogicalOperator {
+        return this.cond('startsWith', value);
     }
 
-    endsWith(value: string): Condition {
-        return this.createCondition('endsWith', value);
+    endsWith(value: string): LogicalOperator {
+        return this.cond('endsWith', value);
     }
 
-    contains(value: string): Condition {
-        return this.createCondition('includes', value);
+    contains(value: string): LogicalOperator {
+        return this.cond('includes', value);
     }
 
-    regExpMatches(pattern: string): Condition {
-        return this.createCondition('regExpMatches', pattern);
+    regExpMatches(pattern: string): LogicalOperator {
+        return this.cond('regExpMatches', pattern);
     }
 
-    includesCaseInsensitive(value: string): Condition {
-        return this.createCondition('includesCaseInsensitive', value);
+    includesCaseInsensitive(value: string): LogicalOperator {
+        return this.cond('includesCaseInsensitive', value);
     }
 
-    startsWithCaseInsensitive(value: string): Condition {
-        return this.createCondition('startsWithCaseInsensitive', value);
+    startsWithCaseInsensitive(value: string): LogicalOperator {
+        return this.cond('startsWithCaseInsensitive', value);
     }
 
-    endsWithCaseInsensitive(value: string): Condition {
-        return this.createCondition('endsWithCaseInsensitive', value);
+    endsWithCaseInsensitive(value: string): LogicalOperator {
+        return this.cond('endsWithCaseInsensitive', value);
     }
 
-    // ===== NUMBER OPERATORS (NumberOperator) =====
-
-    greaterThan(value: any): Condition {
-        return this.createCondition('greaterThan', value);
-    }
+    // ===== NUMBER OPERATORS =====
 
-    lessThan(value: any): Condition {
-        return this.createCondition('lessThan', value);
+    greaterThan(value: any): LogicalOperator {
+        return this.cond('greaterThan', value);
     }
 
-    greaterThanOrEqual(value: any): Condition {
-        return this.createCondition('greaterThanOrEqual', value);
+    lessThan(value: any): LogicalOperator {
+        return this.cond('lessThan', value);
     }
 
-    lessThanOrEqual(value: any): Condition {
-        return this.createCondition('lessThanOrEqual', value);
+    greaterThanOrEqual(value: any): LogicalOperator {
+        return this.cond('greaterThanOrEqual', value);
     }
 
-    // ===== IP OPERATORS (IpOperator) =====
-
-    isLocalIp(): Condition {
-        return this.createCondition('isLocalIp', true);
+    lessThanOrEqual(value: any): LogicalOperator {
+        return this.cond('lessThanOrEqual', value);
     }
 
-    isExternalIp(): Condition {
-        return this.createCondition('isExternalIp', true);
+    between(min: any, max: any): LogicalOperator {
+        return this.cond('betweenOp', { from: min, to: max });
     }
 
-    // ===== MISC OPERATORS (MiscOperator) =====
+    // ===== IP OPERATORS =====
 
-    b64(value: string): Condition {
-        return this.createCondition('b64', value);
+    isLocalIp(): LogicalOperator {
+        return this.cond('isLocalIp', true);
     }
 
-    inDataset(dataset: string): Condition {
-        return this.createCondition('inDataset', dataset);
+    isExternalIp(): LogicalOperator {
+        return this.cond('isExternalIp', true);
     }
 
-    inCountry(countryCode: string): Condition {
-        return this.createCondition('inCountry', countryCode);
+    // ===== MISC OPERATORS =====
+
+    b64(value: string): LogicalOperator {
+        return this.cond('b64', value);
     }
 
-    cidr(cidr: string): Condition {
-        return this.createCondition('CIDR', cidr);
+    inDataset(dataset: string): LogicalOperator {
+        return this.cond('inDataset', dataset);
     }
 
-    // ===== BETWEEN OPERATOR =====
+    inCountry(countryCode: string): LogicalOperator {
+        return this.cond('inCountry', countryCode);
+    }
 
-    between(min: any, max: any): Condition {
-        return this.createCondition('between', { from: min, to: max });
+    cidr(cidr: string): LogicalOperator {
+        return this.cond('CIDR', cidr);
     }
 
-    // ===== CONVENIENCE METHODS =====
+    // ===== CONVENIENCE =====
 
-    // Boolean checks (using base operators)
-    isTrue(): Condition {
+    isTrue(): LogicalOperator {
         return this.equals(true);
     }
 
-    isFalse(): Condition {
+    isFalse(): LogicalOperator {
         return this.equals(false);
     }
-}
+}

package/src/query-sdk/{OnChainDB.ts → OnDB.ts}

@@ -3,7 +3,7 @@ import {SelectionBuilder} from './SelectionBuilder';
 import {FieldMap, HttpClient, QueryRequest, QueryResponse, QueryValue} from "./index";
 
 // Main SDK class providing static methods for query building
-export class OnChainDB {
+export class OnDB {
     private static httpClient?: HttpClient;
     private static serverUrl?: string;
     private static apiKey?: string;

package/src/query-sdk/QueryBuilder.ts

@@ -1,11 +1,11 @@
-import {QueryRequest, QueryResponse, QueryValue, SelectionMap, Val, PaymentRequiredError} from '../index';
+import {QueryRequest, QueryResponse, SelectionMap, Val, PaymentRequiredError} from '../index';
+import {QueryValue} from './index';
 import {FieldConditionBuilder, LogicalOperator} from './operators';
 import {SelectionBuilder} from './SelectionBuilder';
 import {ConditionBuilder} from './ConditionBuilder';
 import {FieldMap, HttpClient} from "./index";
 import {AxiosError} from "axios";
 import {
-    X402PaymentRequirement,
     X402PaymentRequiredResponse,
     encodePaymentHeader,
     requirementToQuote,
@@ -68,10 +68,12 @@ export class QueryBuilder {
         return this;
     }
 
-    // Build find conditions using a builder function
-    find(builderFn: (builder: ConditionBuilder) => LogicalOperator): QueryBuilder {
+    // Build find conditions using a builder function.
+    // Return a single LogicalOperator, or an array — arrays are automatically wrapped in AND.
+    find(builderFn: (builder: ConditionBuilder) => LogicalOperator | LogicalOperator[]): QueryBuilder {
         const conditionBuilder = new ConditionBuilder();
-        this.findConditions = builderFn(conditionBuilder);
+        const result = builderFn(conditionBuilder);
+        this.findConditions = Array.isArray(result) ? LogicalOperator.And(result) : result;
         return this;
     }
 
@@ -509,6 +511,7 @@ export class QueryBuilder {
             limit: this.limitValue,
             offset: this.offsetValue,
             sortBy: this.sortBy,
+            sortDirection: this.sortDirection,
             root: `${this.app}::${this.collectionName}`
         };
     }
@@ -525,7 +528,8 @@ export class QueryBuilder {
             ...this.buildQueryValue(),
             limit: this.limitValue,
             offset: this.offsetValue,
-            sortBy: this.sortBy
+            sortBy: this.sortBy,
+            sortDirection: this.sortDirection,
         };
     }
 
@@ -538,6 +542,7 @@ export class QueryBuilder {
         cloned.limitValue = this.limitValue;
         cloned.offsetValue = this.offsetValue;
         cloned.sortBy = this.sortBy;
+        cloned.sortDirection = this.sortDirection;
         cloned.includeHistoryValue = this.includeHistoryValue;
         cloned.collectionName = this.collectionName;
         cloned.serverJoinConfigs = [...this.serverJoinConfigs]; // Deep copy server join configs
@@ -703,189 +708,47 @@ export class QueryBuilder {
     }
 }
 
-// Helper class for building where clauses with method chaining
+// Helper class for building where clauses with method chaining.
+// FieldConditionBuilder methods already return LogicalOperator — assign directly.
 export class WhereClause {
     constructor(
         private queryBuilder: QueryBuilder,
         private fieldName: string
-    ) {
-    }
-
-    equals(value: Val): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).equals(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    notEquals(value: Val): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).notEquals(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    greaterThan(value: Val): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).greaterThan(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    greaterThanOrEqual(value: Val): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).greaterThanOrEqual(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    lessThan(value: Val): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).lessThan(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    lessThanOrEqual(value: Val): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).lessThanOrEqual(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    contains(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).contains(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    startsWith(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).startsWith(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    endsWith(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).endsWith(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    in(values: Val[]): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).in(values);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    notIn(values: Val[]): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).notIn(values);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    exists(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).exists();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    notExists(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).notExists();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    isNull(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).isNull();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    isNotNull(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).isNotNull();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    regExpMatches(pattern: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).regExpMatches(pattern);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    includesCaseInsensitive(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).includesCaseInsensitive(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    startsWithCaseInsensitive(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).startsWithCaseInsensitive(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    endsWithCaseInsensitive(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).endsWithCaseInsensitive(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    // ===== IP OPERATORS =====
-
-    isLocalIp(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).isLocalIp();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    isExternalIp(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).isExternalIp();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    // ===== MISC OPERATORS =====
-
-    b64(value: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).b64(value);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    inDataset(dataset: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).inDataset(dataset);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    inCountry(countryCode: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).inCountry(countryCode);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    cidr(cidr: string): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).cidr(cidr);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    // ===== BETWEEN OPERATOR =====
-
-    between(min: any, max: any): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).between(min, max);
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
-
-    // ===== CONVENIENCE METHODS =====
+    ) {}
 
-    isTrue(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).isTrue();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
+    private set(op: LogicalOperator): QueryBuilder {
+        (this.queryBuilder as any).findConditions = op;
         return this.queryBuilder;
     }
 
-    isFalse(): QueryBuilder {
-        const condition = new FieldConditionBuilder(this.fieldName).isFalse();
-        (this.queryBuilder as any).findConditions = LogicalOperator.Condition(condition);
-        return this.queryBuilder;
-    }
+    equals(value: Val): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).equals(value)); }
+    notEquals(value: Val): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).notEquals(value)); }
+    greaterThan(value: Val): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).greaterThan(value)); }
+    greaterThanOrEqual(value: Val): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).greaterThanOrEqual(value)); }
+    lessThan(value: Val): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).lessThan(value)); }
+    lessThanOrEqual(value: Val): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).lessThanOrEqual(value)); }
+    contains(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).contains(value)); }
+    startsWith(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).startsWith(value)); }
+    endsWith(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).endsWith(value)); }
+    in(values: Val[]): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).in(values)); }
+    notIn(values: Val[]): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).notIn(values)); }
+    exists(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).exists()); }
+    notExists(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).notExists()); }
+    isNull(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).isNull()); }
+    isNotNull(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).isNotNull()); }
+    regExpMatches(pattern: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).regExpMatches(pattern)); }
+    includesCaseInsensitive(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).includesCaseInsensitive(value)); }
+    startsWithCaseInsensitive(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).startsWithCaseInsensitive(value)); }
+    endsWithCaseInsensitive(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).endsWithCaseInsensitive(value)); }
+    isLocalIp(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).isLocalIp()); }
+    isExternalIp(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).isExternalIp()); }
+    b64(value: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).b64(value)); }
+    inDataset(dataset: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).inDataset(dataset)); }
+    inCountry(countryCode: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).inCountry(countryCode)); }
+    cidr(cidr: string): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).cidr(cidr)); }
+    between(min: any, max: any): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).between(min, max)); }
+    isTrue(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).isTrue()); }
+    isFalse(): QueryBuilder { return this.set(new FieldConditionBuilder(this.fieldName).isFalse()); }
 }
 
 // Fluent builder for constructing server-side JOINs
@@ -905,10 +768,13 @@ export class JoinBuilder<TParent extends QueryBuilder | JoinBuilder<any> = Query
         this.many = many;
     }
 
-    // Add filter conditions for the joined collection
-    on(builderFn: (builder: ConditionBuilder) => LogicalOperator): this {
+    // Add filter conditions for the joined collection.
+    // Return a single LogicalOperator, or an array — arrays are automatically wrapped in AND.
+    on(builderFn: (builder: ConditionBuilder) => LogicalOperator | LogicalOperator[]): this {
         const conditionBuilder = new ConditionBuilder();
-        this.findConditions = builderFn(conditionBuilder).toComposable();
+        const result = builderFn(conditionBuilder);
+        const op = Array.isArray(result) ? LogicalOperator.And(result) : result;
+        this.findConditions = op.toComposable();
         return this;
     }
 
@@ -1006,44 +872,19 @@ export class JoinWhereClause<TParent extends QueryBuilder | JoinBuilder<any> = Q
     constructor(
         private joinBuilder: JoinBuilder<TParent>,
         private fieldName: string
-    ) {
-    }
-
-    equals(value: Val): JoinBuilder<TParent> {
-        const condition = new FieldConditionBuilder(this.fieldName).equals(value);
-        this.joinBuilder._setFindConditions(LogicalOperator.Condition(condition).toComposable());
-        return this.joinBuilder;
-    }
-
-    in(values: Val[]): JoinBuilder<TParent> {
-        const condition = new FieldConditionBuilder(this.fieldName).in(values);
-        this.joinBuilder._setFindConditions(LogicalOperator.Condition(condition).toComposable());
-        return this.joinBuilder;
-    }
-
-    greaterThan(value: Val): JoinBuilder<TParent> {
-        const condition = new FieldConditionBuilder(this.fieldName).greaterThan(value);
-        this.joinBuilder._setFindConditions(LogicalOperator.Condition(condition).toComposable());
-        return this.joinBuilder;
-    }
-
-    lessThan(value: Val): JoinBuilder<TParent> {
-        const condition = new FieldConditionBuilder(this.fieldName).lessThan(value);
-        this.joinBuilder._setFindConditions(LogicalOperator.Condition(condition).toComposable());
-        return this.joinBuilder;
-    }
+    ) {}
 
-    isNull(): JoinBuilder<TParent> {
-        const condition = new FieldConditionBuilder(this.fieldName).isNull();
-        this.joinBuilder._setFindConditions(LogicalOperator.Condition(condition).toComposable());
+    private set(op: LogicalOperator): JoinBuilder<TParent> {
+        this.joinBuilder._setFindConditions(op.toComposable());
         return this.joinBuilder;
     }
 
-    isNotNull(): JoinBuilder<TParent> {
-        const condition = new FieldConditionBuilder(this.fieldName).isNotNull();
-        this.joinBuilder._setFindConditions(LogicalOperator.Condition(condition).toComposable());
-        return this.joinBuilder;
-    }
+    equals(value: Val): JoinBuilder<TParent> { return this.set(new FieldConditionBuilder(this.fieldName).equals(value)); }
+    in(values: Val[]): JoinBuilder<TParent> { return this.set(new FieldConditionBuilder(this.fieldName).in(values)); }
+    greaterThan(value: Val): JoinBuilder<TParent> { return this.set(new FieldConditionBuilder(this.fieldName).greaterThan(value)); }
+    lessThan(value: Val): JoinBuilder<TParent> { return this.set(new FieldConditionBuilder(this.fieldName).lessThan(value)); }
+    isNull(): JoinBuilder<TParent> { return this.set(new FieldConditionBuilder(this.fieldName).isNull()); }
+    isNotNull(): JoinBuilder<TParent> { return this.set(new FieldConditionBuilder(this.fieldName).isNotNull()); }
 }
 
 /**