@onchaindb/sdk 0.0.6

package/dist/query-sdk/QueryBuilder.js

@@ -0,0 +1,757 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupByQueryBuilder = exports.JoinWhereClause = exports.JoinBuilder = exports.WhereClause = exports.QueryBuilder = void 0;
+const operators_1 = require("./operators");
+const SelectionBuilder_1 = require("./SelectionBuilder");
+const ConditionBuilder_1 = require("./ConditionBuilder");
+class QueryBuilder {
+    constructor(httpClient, serverUrl, app) {
+        this.serverJoinConfigs = [];
+        this.joinConfigs = [];
+        this.httpClient = httpClient;
+        this.serverUrl = serverUrl;
+        this.app = app;
+    }
+    static new(httpClient, serverUrl, app) {
+        return new QueryBuilder(httpClient, serverUrl, app);
+    }
+    withHttpClient(httpClient) {
+        this.httpClient = httpClient;
+        return this;
+    }
+    withServerUrl(serverUrl) {
+        this.serverUrl = serverUrl;
+        return this;
+    }
+    find(builderFn) {
+        const conditionBuilder = new ConditionBuilder_1.ConditionBuilder();
+        this.findConditions = builderFn(conditionBuilder);
+        return this;
+    }
+    collection(s) {
+        this.collectionName = s;
+        return this;
+    }
+    whereField(fieldName) {
+        return new WhereClause(this, fieldName);
+    }
+    serverJoin(alias, model, resolve) {
+        this.serverJoinConfigs.push({
+            alias,
+            model,
+            resolve
+        });
+        return this;
+    }
+    joinWith(alias, model) {
+        return new JoinBuilder(this, alias, model);
+    }
+    joinOne(alias, model) {
+        return new JoinBuilder(this, alias, model, false);
+    }
+    joinMany(alias, model) {
+        return new JoinBuilder(this, alias, model, true);
+    }
+    join(parentCollection, parentField, childField, alias) {
+        console.warn('QueryBuilder.join() is deprecated. Use serverJoin(), joinOne(), or joinMany() for server-side JOINs.');
+        this.joinConfigs.push({
+            parentCollection,
+            parentField,
+            childField,
+            alias
+        });
+        return this;
+    }
+    select(builderFn) {
+        const selectionBuilder = new SelectionBuilder_1.SelectionBuilder();
+        builderFn(selectionBuilder);
+        this.selections = selectionBuilder.build();
+        return this;
+    }
+    selectFields(fields) {
+        const selectionBuilder = new SelectionBuilder_1.SelectionBuilder();
+        selectionBuilder.fields(fields);
+        this.selections = selectionBuilder.build();
+        return this;
+    }
+    selectAll() {
+        this.selections = SelectionBuilder_1.SelectionBuilder.all();
+        return this;
+    }
+    withFieldMap(fieldMap) {
+        this.fieldMap = fieldMap;
+        return this;
+    }
+    limit(limit) {
+        this.limitValue = limit;
+        return this;
+    }
+    offset(offset) {
+        this.offsetValue = offset;
+        return this;
+    }
+    orderBy(fields) {
+        this.sortBy = fields;
+        return this;
+    }
+    includeHistory(include = true) {
+        this.includeHistoryValue = include;
+        return this;
+    }
+    async execute() {
+        if (!this.httpClient) {
+            throw new Error('HTTP client is required for query execution');
+        }
+        if (!this.serverUrl) {
+            throw new Error('Server URL is required for query execution');
+        }
+        if (this.serverJoinConfigs.length > 0) {
+            return this.executeSimpleQuery();
+        }
+        if (this.joinConfigs.length > 0) {
+            console.warn('Using deprecated client-side JOINs. Consider migrating to serverJoin() for better performance.');
+            return this.executeWithJoins();
+        }
+        return this.executeSimpleQuery();
+    }
+    async executeUnique() {
+        const response = await this.execute();
+        if (!response.records || response.records.length === 0) {
+            return null;
+        }
+        const sortedRecords = [...response.records].sort((a, b) => {
+            const getTimestamp = (record) => {
+                return record.updatedAt || record.updated_at ||
+                    record.createdAt || record.created_at || null;
+            };
+            const tsA = getTimestamp(a);
+            const tsB = getTimestamp(b);
+            if (tsB && tsA)
+                return tsB.localeCompare(tsA);
+            if (tsB && !tsA)
+                return -1;
+            if (!tsB && tsA)
+                return 1;
+            return 0;
+        });
+        return sortedRecords[0];
+    }
+    async count() {
+        const response = await this.execute();
+        return response.records?.length || 0;
+    }
+    async sumBy(field) {
+        const response = await this.execute();
+        if (!response.records)
+            return 0;
+        return response.records.reduce((sum, record) => {
+            const value = record[field];
+            return sum + (typeof value === 'number' ? value : 0);
+        }, 0);
+    }
+    async avgBy(field) {
+        const response = await this.execute();
+        if (!response.records || response.records.length === 0)
+            return 0;
+        const sum = response.records.reduce((total, record) => {
+            const value = record[field];
+            return total + (typeof value === 'number' ? value : 0);
+        }, 0);
+        return sum / response.records.length;
+    }
+    async maxBy(field) {
+        const response = await this.execute();
+        if (!response.records || response.records.length === 0)
+            return null;
+        return response.records.reduce((max, record) => {
+            const value = record[field];
+            if (max === null)
+                return value;
+            return value > max ? value : max;
+        }, null);
+    }
+    async minBy(field) {
+        const response = await this.execute();
+        if (!response.records || response.records.length === 0)
+            return null;
+        return response.records.reduce((min, record) => {
+            const value = record[field];
+            if (min === null)
+                return value;
+            return value < min ? value : min;
+        }, null);
+    }
+    async distinctBy(field) {
+        const response = await this.execute();
+        if (!response.records)
+            return [];
+        const uniqueValues = new Set();
+        for (const record of response.records) {
+            const value = record[field];
+            if (value !== undefined && value !== null) {
+                uniqueValues.add(value);
+            }
+        }
+        return Array.from(uniqueValues);
+    }
+    async countDistinct(field) {
+        const distinctValues = await this.distinctBy(field);
+        return distinctValues.length;
+    }
+    groupBy(field) {
+        return new GroupByQueryBuilder(this, field);
+    }
+    async executeWithPayment(quoteId, paymentProof, network) {
+        if (!this.httpClient) {
+            throw new Error('HTTP client is required for query execution');
+        }
+        if (!this.serverUrl) {
+            throw new Error('Server URL is required for query execution');
+        }
+        const x402Payload = {
+            x402Version: 1,
+            scheme: network?.includes('sepolia') || network?.includes('ethereum') ? 'ethereum-native' : 'celestia-native',
+            network: network || 'mocha-4',
+            quoteId: quoteId,
+            payload: {
+                txHash: paymentProof.toLowerCase(),
+                sender: 'unknown',
+                timestamp: Math.floor(Date.now() / 1000)
+            }
+        };
+        const encodedPayment = Buffer.from(JSON.stringify(x402Payload)).toString('base64');
+        const request = this.getQueryRequest();
+        try {
+            const response = await this.httpClient.post(`${this.serverUrl}/list`, request, {
+                'Content-Type': 'application/json',
+                'X-PAYMENT': encodedPayment
+            });
+            if (response?.headers && response.headers['x-payment-response']) {
+                console.log('✅ Payment confirmed:', JSON.parse(response.headers['x-payment-response']));
+            }
+            return response?.data || {
+                records: [],
+                total: 0,
+                page: 0,
+                limit: 0
+            };
+        }
+        catch (error) {
+            throw new Error(`Paid query execution failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    getQueryRequest() {
+        const queryValue = this.buildQueryValue();
+        return {
+            ...queryValue,
+            limit: this.limitValue,
+            offset: this.offsetValue,
+            sortBy: this.sortBy,
+            root: `${this.app}::${this.collectionName}`
+        };
+    }
+    isValid() {
+        return this.findConditions !== undefined || this.selections !== undefined;
+    }
+    buildRawQuery() {
+        return {
+            ...this.buildQueryValue(),
+            limit: this.limitValue,
+            offset: this.offsetValue,
+            sortBy: this.sortBy
+        };
+    }
+    clone() {
+        const cloned = new QueryBuilder(this.httpClient, this.serverUrl, this.app);
+        cloned.findConditions = this.findConditions;
+        cloned.selections = this.selections ? { ...this.selections } : undefined;
+        cloned.fieldMap = this.fieldMap ? { ...this.fieldMap } : undefined;
+        cloned.limitValue = this.limitValue;
+        cloned.offsetValue = this.offsetValue;
+        cloned.sortBy = this.sortBy;
+        cloned.includeHistoryValue = this.includeHistoryValue;
+        cloned.collectionName = this.collectionName;
+        cloned.serverJoinConfigs = [...this.serverJoinConfigs];
+        cloned.joinConfigs = [...this.joinConfigs];
+        return cloned;
+    }
+    _addServerJoin(config) {
+        this.serverJoinConfigs.push(config);
+    }
+    async executeSimpleQuery() {
+        const request = this.getQueryRequest();
+        try {
+            const response = await this.httpClient.post(`${this.serverUrl}/list`, request, { 'Content-Type': 'application/json' });
+            if (response?.status === 402 && response?.data) {
+                console.log('💰 Received 402 Payment Required, converting x402 to quote');
+                const x402Response = response.data;
+                const requirement = x402Response.accepts?.[0];
+                if (requirement) {
+                    const quote = {
+                        type: 'quote',
+                        quote_id: requirement.quoteId,
+                        matched_records: parseInt(requirement.description?.match(/(\d+) records/)?.[1] || '0'),
+                        billable_fields: requirement.description?.match(/fields: (.*)/)?.[1]?.split(', ') || [],
+                        cost_breakdown: requirement.costBreakdown || {},
+                        total_cost_tia: parseInt(requirement.maxAmountRequired) / 1000000,
+                        broker_address: requirement.payTo,
+                        expires_at: requirement.expiresAt
+                    };
+                    console.log('✅ Converted x402 to quote:', quote);
+                    return quote;
+                }
+            }
+            if (response?.data && response.data.type === 'quote') {
+                return response.data;
+            }
+            return response?.data || {
+                records: [],
+                limit: 0,
+                page: 0,
+                total: 0,
+            };
+        }
+        catch (error) {
+            const response = error?.response;
+            if (response?.status === 402 && response?.data) {
+                const x402Response = response.data;
+                const requirement = x402Response.accepts?.[0];
+                if (requirement) {
+                    const quote = {
+                        type: 'quote',
+                        quote_id: requirement.quoteId,
+                        matched_records: parseInt(requirement.description?.match(/(\d+) records/)?.[1] || '0'),
+                        billable_fields: requirement.description?.match(/fields: (.*)/)?.[1]?.split(', ') || [],
+                        cost_breakdown: requirement.costBreakdown || {},
+                        total_cost_tia: parseInt(requirement.maxAmountRequired) / 1000000,
+                        broker_address: requirement.payTo,
+                        expires_at: requirement.expiresAt
+                    };
+                    return quote;
+                }
+            }
+            throw new Error(`Query execution failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+    }
+    async executeWithJoins() {
+        const mainQuery = this.clone();
+        mainQuery.joinConfigs = [];
+        const mainResults = await mainQuery.executeSimpleQuery();
+        if (mainResults.records.length === 0) {
+            return mainResults;
+        }
+        const joinResults = {};
+        for (const joinConfig of this.joinConfigs) {
+            const joinKeys = [...new Set(mainResults.records
+                    .map(record => record[joinConfig.childField])
+                    .filter(key => key !== null && key !== undefined))];
+            if (joinKeys.length > 0) {
+                const joinQuery = new QueryBuilder(this.httpClient, this.serverUrl, this.app);
+                const joinResponse = await joinQuery
+                    .collection(joinConfig.parentCollection)
+                    .whereField(joinConfig.parentField).in(joinKeys)
+                    .selectAll()
+                    .executeSimpleQuery();
+                joinResults[joinConfig.alias] = joinResponse.records;
+            }
+            else {
+                joinResults[joinConfig.alias] = [];
+            }
+        }
+        const mergedRecords = mainResults.records.map(mainRecord => {
+            const merged = { ...mainRecord };
+            for (const joinConfig of this.joinConfigs) {
+                const joinKey = mainRecord[joinConfig.childField];
+                const relatedRecords = joinResults[joinConfig.alias].filter(joinRecord => joinRecord[joinConfig.parentField] === joinKey);
+                if (joinConfig.parentCollection === this.collectionName) {
+                    merged[joinConfig.alias] = relatedRecords;
+                }
+                else {
+                    merged[joinConfig.alias] = relatedRecords.length > 0 ? relatedRecords[0] : null;
+                }
+            }
+            return merged;
+        });
+        return {
+            records: mergedRecords,
+            limit: mainResults.limit,
+            page: mainResults.page,
+            total: mainResults.total
+        };
+    }
+    buildQueryValue() {
+        let find = this.findConditions ? this.findConditions.toComposable() : {};
+        const select = this.selections || SelectionBuilder_1.SelectionBuilder.all();
+        if (this.serverJoinConfigs.length > 0) {
+            for (const join of this.serverJoinConfigs) {
+                const joinConfig = {
+                    resolve: join.resolve,
+                    model: join.model
+                };
+                if (join.many !== undefined) {
+                    joinConfig.many = join.many;
+                }
+                find[join.alias] = joinConfig;
+            }
+        }
+        const queryValue = {
+            find,
+            select
+        };
+        if (this.includeHistoryValue !== undefined) {
+            queryValue.include_history = this.includeHistoryValue;
+        }
+        return queryValue;
+    }
+}
+exports.QueryBuilder = QueryBuilder;
+class WhereClause {
+    constructor(queryBuilder, fieldName) {
+        this.queryBuilder = queryBuilder;
+        this.fieldName = fieldName;
+    }
+    equals(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).equals(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    notEquals(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).notEquals(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    greaterThan(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).greaterThan(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    greaterThanOrEqual(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).greaterThanOrEqual(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    lessThan(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).lessThan(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    lessThanOrEqual(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).lessThanOrEqual(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    contains(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).contains(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    startsWith(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).startsWith(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    endsWith(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).endsWith(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    in(values) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).in(values);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    notIn(values) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).notIn(values);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    exists() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).exists();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    notExists() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).notExists();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    isNull() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isNull();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    isNotNull() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isNotNull();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    regExpMatches(pattern) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).regExpMatches(pattern);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    includesCaseInsensitive(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).includesCaseInsensitive(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    startsWithCaseInsensitive(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).startsWithCaseInsensitive(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    endsWithCaseInsensitive(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).endsWithCaseInsensitive(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    isLocalIp() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isLocalIp();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    isExternalIp() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isExternalIp();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    b64(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).b64(value);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    inDataset(dataset) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).inDataset(dataset);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    inCountry(countryCode) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).inCountry(countryCode);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    cidr(cidr) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).cidr(cidr);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    between(min, max) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).between(min, max);
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    isTrue() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isTrue();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+    isFalse() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isFalse();
+        this.queryBuilder.findConditions = operators_1.LogicalOperator.Condition(condition);
+        return this.queryBuilder;
+    }
+}
+exports.WhereClause = WhereClause;
+class JoinBuilder {
+    constructor(parentBuilder, alias, model, many) {
+        this.findConditions = {};
+        this.nestedJoins = [];
+        this.parentBuilder = parentBuilder;
+        this.alias = alias;
+        this.model = model;
+        this.many = many;
+    }
+    on(builderFn) {
+        const conditionBuilder = new ConditionBuilder_1.ConditionBuilder();
+        this.findConditions = builderFn(conditionBuilder).toComposable();
+        return this;
+    }
+    onField(fieldName) {
+        return new JoinWhereClause(this, fieldName);
+    }
+    selecting(builderFn) {
+        const selectionBuilder = new SelectionBuilder_1.SelectionBuilder();
+        builderFn(selectionBuilder);
+        this.selections = selectionBuilder.build();
+        return this;
+    }
+    selectFields(fields) {
+        const selectionBuilder = new SelectionBuilder_1.SelectionBuilder();
+        selectionBuilder.fields(fields);
+        this.selections = selectionBuilder.build();
+        return this;
+    }
+    selectAll() {
+        this.selections = SelectionBuilder_1.SelectionBuilder.all();
+        return this;
+    }
+    joinOne(alias, model) {
+        return new JoinBuilder(this, alias, model, false);
+    }
+    joinMany(alias, model) {
+        return new JoinBuilder(this, alias, model, true);
+    }
+    build() {
+        const joinConfig = {
+            alias: this.alias,
+            model: this.model,
+            many: this.many,
+            resolve: {
+                find: this.buildFindWithNestedJoins(),
+                select: this.selections || SelectionBuilder_1.SelectionBuilder.all()
+            }
+        };
+        this.parentBuilder._addServerJoin(joinConfig);
+        return this.parentBuilder;
+    }
+    buildFindWithNestedJoins() {
+        const find = Object.keys(this.findConditions).length > 0 ? { ...this.findConditions } : {};
+        if (this.nestedJoins.length > 0) {
+            for (const nestedJoin of this.nestedJoins) {
+                const joinConfig = {
+                    resolve: nestedJoin.resolve,
+                    model: nestedJoin.model
+                };
+                if (nestedJoin.many !== undefined) {
+                    joinConfig.many = nestedJoin.many;
+                }
+                find[nestedJoin.alias] = joinConfig;
+            }
+        }
+        return Object.keys(find).length > 0 ? find : undefined;
+    }
+    _setFindConditions(conditions) {
+        this.findConditions = conditions;
+    }
+    _addServerJoin(config) {
+        this.nestedJoins.push(config);
+    }
+}
+exports.JoinBuilder = JoinBuilder;
+class JoinWhereClause {
+    constructor(joinBuilder, fieldName) {
+        this.joinBuilder = joinBuilder;
+        this.fieldName = fieldName;
+    }
+    equals(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).equals(value);
+        this.joinBuilder._setFindConditions(operators_1.LogicalOperator.Condition(condition).toComposable());
+        return this.joinBuilder;
+    }
+    in(values) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).in(values);
+        this.joinBuilder._setFindConditions(operators_1.LogicalOperator.Condition(condition).toComposable());
+        return this.joinBuilder;
+    }
+    greaterThan(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).greaterThan(value);
+        this.joinBuilder._setFindConditions(operators_1.LogicalOperator.Condition(condition).toComposable());
+        return this.joinBuilder;
+    }
+    lessThan(value) {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).lessThan(value);
+        this.joinBuilder._setFindConditions(operators_1.LogicalOperator.Condition(condition).toComposable());
+        return this.joinBuilder;
+    }
+    isNull() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isNull();
+        this.joinBuilder._setFindConditions(operators_1.LogicalOperator.Condition(condition).toComposable());
+        return this.joinBuilder;
+    }
+    isNotNull() {
+        const condition = new operators_1.FieldConditionBuilder(this.fieldName).isNotNull();
+        this.joinBuilder._setFindConditions(operators_1.LogicalOperator.Condition(condition).toComposable());
+        return this.joinBuilder;
+    }
+}
+exports.JoinWhereClause = JoinWhereClause;
+class GroupByQueryBuilder {
+    constructor(queryBuilder, groupByField) {
+        this.queryBuilder = queryBuilder;
+        this.groupByField = groupByField;
+    }
+    async count() {
+        const response = await this.queryBuilder.execute();
+        if (!response.records)
+            return {};
+        const groups = {};
+        for (const record of response.records) {
+            const key = this.getGroupKey(record);
+            groups[key] = (groups[key] || 0) + 1;
+        }
+        return groups;
+    }
+    async sumBy(field) {
+        const response = await this.queryBuilder.execute();
+        if (!response.records)
+            return {};
+        const groups = {};
+        for (const record of response.records) {
+            const key = this.getGroupKey(record);
+            const value = record[field];
+            groups[key] = (groups[key] || 0) + (typeof value === 'number' ? value : 0);
+        }
+        return groups;
+    }
+    async avgBy(field) {
+        const response = await this.queryBuilder.execute();
+        if (!response.records)
+            return {};
+        const groups = {};
+        for (const record of response.records) {
+            const key = this.getGroupKey(record);
+            const value = record[field];
+            if (!groups[key]) {
+                groups[key] = { sum: 0, count: 0 };
+            }
+            groups[key].sum += typeof value === 'number' ? value : 0;
+            groups[key].count += 1;
+        }
+        const result = {};
+        for (const [key, { sum, count }] of Object.entries(groups)) {
+            result[key] = count > 0 ? sum / count : 0;
+        }
+        return result;
+    }
+    async maxBy(field) {
+        const response = await this.queryBuilder.execute();
+        if (!response.records)
+            return {};
+        const groups = {};
+        for (const record of response.records) {
+            const key = this.getGroupKey(record);
+            const value = record[field];
+            if (!(key in groups) || value > groups[key]) {
+                groups[key] = value;
+            }
+        }
+        return groups;
+    }
+    async minBy(field) {
+        const response = await this.queryBuilder.execute();
+        if (!response.records)
+            return {};
+        const groups = {};
+        for (const record of response.records) {
+            const key = this.getGroupKey(record);
+            const value = record[field];
+            if (!(key in groups) || value < groups[key]) {
+                groups[key] = value;
+            }
+        }
+        return groups;
+    }
+    getGroupKey(record) {
+        if (this.groupByField.includes('.')) {
+            const parts = this.groupByField.split('.');
+            let current = record;
+            for (const part of parts) {
+                current = current?.[part];
+            }
+            return String(current ?? 'null');
+        }
+        return String(record[this.groupByField] ?? 'null');
+    }
+}
+exports.GroupByQueryBuilder = GroupByQueryBuilder;
+//# sourceMappingURL=QueryBuilder.js.map