@jitterbit/soql-parser-js/dist/esm/api/public-utils.js

Salesforce.com SOQL parser and composer

import { getParams, hasAlias, isComposeField, isComposeFieldFunction, isComposeFieldRelationship, isComposeFieldSubquery, isComposeFieldTypeof, isFieldSubquery, isGroupByField, isGroupByFn, isHavingClauseWithRightCondition, isNegationCondition, isNestedParamAggregateFunction, isOrderByField, isOrderByFn, isString, isSubquery, isValueCondition, isValueFunctionCondition, isValueQueryCondition, isValueWithDateLiteralCondition, isValueWithDateNLiteralCondition, isWhereClauseWithRightCondition, isWhereOrHavingClauseWithRightCondition, } from '../utils';
export { hasAlias, isFieldSubquery, isGroupByField, isGroupByFn, isHavingClauseWithRightCondition, isNegationCondition, isOrderByField, isOrderByFn, isString, isSubquery, isValueCondition, isValueFunctionCondition, isValueQueryCondition, isValueWithDateLiteralCondition, isValueWithDateNLiteralCondition, isWhereClauseWithRightCondition, isWhereOrHavingClauseWithRightCondition, };
export function getComposedField(input) {
    return getField(input);
}
export function getField(input) {
    if (typeof input === 'string') {
        return {
            type: 'Field',
            field: input,
        };
    }
    else if (isComposeFieldFunction(input)) {
        let parameters = [];
        if (input.parameters) {
            parameters = (Array.isArray(input.parameters) ? input.parameters : [input.parameters]);
        }
        return {
            type: 'FieldFunctionExpression',
            functionName: (input.functionName || input.fn),
            parameters,
            alias: input.alias,
        };
    }
    else if (isComposeFieldRelationship(input)) {
        return {
            type: 'FieldRelationship',
            field: input.field,
            relationships: input.relationships,
            objectPrefix: input.objectPrefix,
        };
    }
    else if (isComposeFieldSubquery(input)) {
        return {
            type: 'FieldSubquery',
            subquery: input.subquery,
        };
    }
    else if (isComposeFieldTypeof(input)) {
        return {
            type: 'FieldTypeof',
            field: input.field,
            conditions: input.conditions,
        };
    }
    else if (isComposeField(input)) {
        return {
            type: 'Field',
            field: input.field,
            objectPrefix: input.objectPrefix,
        };
    }
    else {
        throw new TypeError('The input object provided did not match any valid field types');
    }
}
export function getFlattenedFields(query, isAggregateResult) {
    if (!query) {
        return [];
    }
    query = isFieldSubquery(query) ? query.subquery : query;
    const fields = query.fields;
    if (!fields) {
        return [];
    }
    let groupByFields = {};
    if (!!query.groupBy) {
        groupByFields = (Array.isArray(query.groupBy) ? query.groupBy : [query.groupBy]).reduce((output, clause) => {
            if (isGroupByField(clause)) {
                output[clause.field.toLocaleLowerCase()] = clause.field;
            }
            return output;
        }, {});
    }
    let currUnAliasedAggExp = -1;
    let sObject = (isSubquery(query) ? query.relationshipName : query.sObject || '').toLowerCase();
    let sObjectAlias = (query.sObjectAlias || '').toLowerCase();
    const parsedFields = fields
        .flatMap(field => {
        switch (field.type) {
            case 'Field': {
                return field.alias || field.field;
            }
            case 'FieldFunctionExpression': {
                let params = getParams(field);
                params = params.map(param => {
                    if (param.includes('.')) {
                        let tempParams = param.split('.');
                        const firstParam = tempParams[0].toLowerCase();
                        if (firstParam === sObjectAlias || firstParam === sObject) {
                            tempParams = tempParams.slice(1);
                        }
                        return tempParams.join('.');
                    }
                    return param;
                });
                if (field.alias && (field.isAggregateFn || isAggregateResult)) {
                    return field.alias;
                }
                if (field.alias) {
                    const firstParam = params[0];
                    if (firstParam.includes('.')) {
                        params = firstParam.split('.').slice(0, -1);
                        params.push(field.alias);
                        return params.join('.');
                    }
                    return field.alias;
                }
                if (field.isAggregateFn || isNestedParamAggregateFunction(field) || isAggregateResult) {
                    currUnAliasedAggExp++;
                    return `expr${currUnAliasedAggExp}`;
                }
                if (params.length > 0) {
                    return params.join('.');
                }
                return field.functionName;
            }
            case 'FieldRelationship': {
                const firstRelationship = field.relationships[0].toLowerCase();
                if (hasAlias(field)) {
                    return field.alias;
                }
                if (field.rawValue && groupByFields[field.rawValue.toLocaleLowerCase()]) {
                    return field.field;
                }
                if (firstRelationship === sObjectAlias || firstRelationship === sObject) {
                    return field.relationships.concat([field.field]).slice(1).join('.');
                }
                return field.relationships.concat([field.field]).join('.');
            }
            case 'FieldSubquery': {
                return field.subquery.relationshipName;
            }
            case 'FieldTypeof': {
                const priorFields = new Set();
                const fields = [];
                field.conditions.forEach(condition => {
                    condition.fieldList.forEach(currField => {
                        if (!priorFields.has(currField)) {
                            priorFields.add(currField);
                            fields.push(`${field.field}.${currField}`);
                        }
                    });
                });
                return fields;
            }
            default:
                break;
        }
    })
        .filter(field => isString(field));
    return parsedFields;
}