# soql-parser-js > A JavaScript and TypeScript library for parsing, composing and formatting Salesforce SOQL queries. Parses a query into a typed Query data structure, composes that structure back into SOQL, validates syntax, and formats queries. Zero runtime dependencies. This file contains all documentation content in a single document following the llmstxt.org standard. ## API ### Core #### ParseQuery Parse a SOQL query string into a Query data structure. `function parseQuery(soql: string, options?: ParseQueryConfig): Query` **ParseQueryConfig** - `allowPartialQuery?: boolean;` - If provided, you can provide an incomplete soql query. This is useful if you need to parse WHERE clauses, for example. Subqueries are required to be valid. - `allowApexBindVariables?: boolean;` - Determines if apex variables are allowed in parsed query. Example: `WHERE Id IN :accountIds`. Only simple Apex is supported. Function calls are not supported. (e.x. `accountMap.keyset()` is not supported) - `ignoreParseErrors?: boolean;` - If set to true, then queries with partially invalid syntax will still be parsed, but any clauses with invalid parts will be omitted. The SELECT clause and FROM clause must always be valid, but all other clauses can contain invalid parts. - `logErrors?: boolean;` - If true, parsing and lexing errors will be logged to the console. #### ComposeQuery `function composeQuery(soql: Query, config?: Partial): string` - `format?: boolean` - Apply formatting to the composed query. This will result in a multi-line soql statement. - `formatOptions?: FormatOptions` - Only applies if `format` is set to true. Options to apply to the formatter. - `numIndent: number` - Number of times `indentString` is repeated for each level of indentation. Defaults to `1`. - `indentString: string` - The string used for one unit of indentation. Defaults to a tab (`'\t'`). e.g. `{ indentString: ' ', numIndent: 2 }` indents with two spaces per level. Must be whitespace only (spaces and/or tabs); other values are ignored. - `fieldMaxLineLength: number` - Number of characters before wrapping fields (also applies to GROUP BY and ORDER BY items). Defaults to `60`. - `fieldSubqueryParensOnOwnLine: boolean` - If true and the query includes a subquery, parentheses will be on their own line . - `whereClauseOperatorsIndented: boolean` - **Deprecated** - this is always applied and the option is ignored. - `newLineAfterKeywords: boolean` - If true, a new line will be inserted after keywords - `logging: boolean` - **Deprecated** - this is ignored and will be removed in a future version. - `autoCompose?: boolean` - (superseded by `allowPartialQuery`, you normally don't need to change this setting.) If you need to compose just part of a query, you can create your own instance of the Compose class and set this to false, then call any methods that you need to just for what you would like to turn into a SOQL query. - `logging?: boolean` - Print out logging statements to the console about the format operation. #### IsQueryValid Return a boolean if the query was able to be parsed. Same options as `parseQuery`. `function isQueryValid(soql: string, options?: ParseQueryConfig): boolean` #### FormatQuery Format a provided query. This parses the query then composes the query again to apply formatting. `function formatQuery(soql: string, formatOptions?: FormatOptions, parseOptions?: ParseQueryConfig): string` ### Utility Refer to the [playground](/playground) for usage examples. ##### `getFlattenedFields(value)` Turn a query object into a list of fields using dot notation. This is useful if you want to flatten a Salesforce record and display in a table, this function will provide the fields based on the query. ##### `getField(value)` Helper function easily get a a field for a compose function `function getField(input: string | ComposeFieldInput): SoqlModels.FieldType` ```typescript const soqlQuery: Query = { fields: [ getField('Id'), getField('Name'), getField({ functionName: 'FORMAT', parameters: 'Amount', alias: 'MyFormattedAmount', }), getField({ subquery: oppLineItemsSubquery }), ], sObject: 'Opportunity', where: { left: { field: 'CreatedDate', operator: '>', value: 'LAST_N_YEARS:1', }, operator: 'AND', right: { left: { field: 'StageName', operator: '=', value: 'Closed Won', // literalType is optional, but if set to STRING and our value is not already wrapped in "'", they will be added // All other literalType values are ignored when composing a query literalType: 'STRING', }, }, }, limit: 150, }; ``` ##### Other utility functions The following functions are generally useful for typescript type narrowing. These are used internally in the compose function but can be used to aid in processing a query object. - `hasAlias(value)` - `isSubquery(value)` - `isFieldSubquery(value)` - `isFormulaFunction(value)` - `isWhereClauseWithRightCondition(value)` - `isHavingClauseWithRightCondition(value)` - `isWhereOrHavingClauseWithRightCondition(value)` - `isValueCondition(value)` - `isValueWithDateLiteralCondition(value)` - `isValueWithDateNLiteralCondition(value)` - `isValueFunctionCondition(value)` - `isNegationCondition(value)` - `isValueQueryCondition(value)` - `isOrderByField(value)` - `isOrderByFn(value)` - `isGroupByField(value)` - `isGroupByFn(value)` --- ## CLI Install globally or use `npx` to interact with the cli. #### Available Commands - `soql-parser-js --help` (or using `npx`: `npx soql-parser-js --help`) - `soql-parser-js parse --help` - `soql-parser-js compose --help` - `soql-parser-js format --help` #### Examples ##### Parse `npx soql-parser-js parse "SELECT Id FROM Account"` ```bash {"fields":[{"type":"Field","field":"Id"}],"sObject":"Account"} ``` ##### Compose `npx soql-parser-js compose "{\"fields\":[{\"type\":\"Field\",\"field\":\"Id\"}],\"sObject\":\"Account\"}"` ```bash SELECT Id FROM Account ``` `npx soql-parser-js compose "{\"fields\":[{\"type\":\"Field\",\"field\":\"Id\"}],\"sObject\":\"Account\"}" --json` or -j ```json { "query": "SELECT Id FROM Account" } ``` ##### Format `npx soql-parser-js format "SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 1"` ```bash SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 1 ``` `npx soql-parser-js format "SELECT Name, COUNT(Id) FROM Account GROUP BY Name HAVING COUNT(Id) > 1 -j` ```json { "query": "SELECT Name, COUNT(Id)\nFROM Account\nGROUP BY Name\nHAVING COUNT(Id) > 1" } ``` ##### Is Valid `npx soql-parser-js valid "SELECT Id FROM Account"` ```bash true ``` `npx soql-parser-js valid "SELECT Id invalid FROM Account"` ℹ️ this returns an exit code of 1 ```bash false ``` `npx soql-parser-js valid "SELECT Id FROM Account" -j` ```json { "isValid": true } ``` `npx soql-parser-js valid "SELECT Id invalid invalid FROM Account" -j` ℹ️ this returns an exit code of 0 ```json { "isValid": false } ``` #### List of options `soql-parser-js --help` ```bash Usage: soql-parser-js [options] [command] Options: -h, --help output usage information Commands: parse [options] compose [options] format [options] valid ``` `soql-parser-js parse --help` ```bash Usage: parse [options] Options: -a, --allow-apex allow apex bind variables -p, --allow-partial allow partial queries -i, --ignore-errors ignore parse errors, return as much of query as possible -h, --help output usage information ``` `soql-parser-js compose --help` ```bash Usage: compose [options] Options: -f, --format format output -i --indent number of times the indent string is repeated per level (default: 1) -t --indent-string string used for one unit of indentation (default: tab), e.g. --indent-string " " -m --line-length max number of characters per line (default: 60) -s --subquery-parens-new-line subquery parens on own line -k --keywords-new-line new line after keywords -j, --json output as JSON -h, --help output usage information ``` `soql-parser-js format --help` ```bash Usage: format [options] Options: -a, --allow-apex allow apex bind variables -p, --allow-partial allow partial queries -i --indent number of times the indent string is repeated per level (default: 1) -t --indent-string string used for one unit of indentation (default: tab), e.g. --indent-string " " -m --line-length max number of characters per line (default: 60) -s --subquery-parens-new-line subquery parens on own line -k --keywords-new-line new line after keywords -j, --json output as JSON -h, --help output usage information ``` `soql-parser-js valid --help` ```bash Usage: valid [options] Options: -a, --allow-apex allow apex bind variables -p, --allow-partial allow partial queries -j, --json output as JSON -h, --help output usage information ``` --- ## Other Examples #### Parsing Queries Parsing a SOQL query can be completed by calling `parseQuery(soqlQueryString)`. A `Query` data structure will be returned. ```typescript import { parseQuery } from '@jetstreamapp/soql-parser-js'; const soql = ` SELECT UserId, COUNT(Id) FROM LoginHistory WHERE LoginTime > 2010-09-20T22:16:30.000Z AND LoginTime < 2010-09-21T22:16:30.000Z GROUP BY UserId `; console.log(JSON.stringify(soqlQuery, null, 2)); ```
Results (click to show) ```json { "fields": [ { "type": "Field", "field": "UserId" }, { "type": "FieldFunctionExpression", "functionName": "COUNT", "parameters": ["Id"], "isAggregateFn": true, "rawValue": "COUNT(Id)" } ], "sObject": "LoginHistory", "where": { "left": { "field": "LoginTime", "operator": ">", "value": "2010-09-20T22:16:30.000Z", "literalType": "DATETIME" }, "operator": "AND", "right": { "left": { "field": "LoginTime", "operator": "<", "value": "2010-09-21T22:16:30.000Z", "literalType": "DATETIME" } } }, "groupBy": { "field": "UserId" } } ```
#### Parsing a partial query Added support for `allowPartialQuery` in version `4.4.0` ```typescript import { parseQuery } from '@jetstreamapp/soql-parser-js'; const soql = ` WHERE LoginTime > 2010-09-20T22:16:30.000Z AND LoginTime < 2010-09-21T22:16:30.000Z GROUP BY UserId `; const soqlQuery = parseQuery(soql, { allowPartialQuery: true }); console.log(JSON.stringify(soqlQuery, null, 2)); ```
Results (click to show) ```json { "where": { "left": { "field": "LoginTime", "operator": ">", "value": "2010-09-20T22:16:30.000Z", "literalType": "DATETIME" }, "operator": "AND", "right": { "left": { "field": "LoginTime", "operator": "<", "value": "2010-09-21T22:16:30.000Z", "literalType": "DATETIME" } } }, "groupBy": { "field": "UserId" } } ```
#### Validating Queries ```typescript import { isQueryValid } from '@jetstreamapp/soql-parser-js'; const invalidSoql = `SELECT UserId, COUNT(Id) Account`; const validSoql = `SELECT UserId, COUNT(Id) Account`; console.log(isQueryValid(soql)); console.log(isQueryValid(soql)); ``` #### Composing Queries Build a `Query` data structure to have it converted back into a SOQL query. Composing a query will turn a Query object back to a SOQL query string. The exact same data structure returned from `parseQuery()` can be used, but depending on your use-case, you may need to build your own data structure to compose a query. These examples show building your own Query object with the minimum required fields. Some utility methods have been provided to make it easier to build the field data structures. **Note:** Some operators may be converted to uppercase (e.x. NOT, AND) **Note:** There are a number of fields populated on the Query object when `parseQuery()` is called that are not required to compose a query. Look at the examples below and the comments in the data model for more information. ```typescript import { composeQuery, getField, Query } from '@jetstreamapp/soql-parser-js'; // Build a subquery const oppLineItemsSubquery = { fields: [ getField('Quantity'), getField('ListPrice'), getField({ field: 'UnitPrice', relationships: ['PricebookEntry'], }), getField({ field: 'Name', relationships: ['PricebookEntry'], }), ], relationshipName: 'OpportunityLineItems', }; // build the main query and add the subquery as a field const soqlQuery: Query = { fields: [ getField('Id'), getField('Name'), getField({ functionName: 'FORMAT', parameters: 'Amount', alias: 'MyFormattedAmount', }), getField({ subquery: oppLineItemsSubquery }), ], sObject: 'Opportunity', where: { left: { field: 'CreatedDate', operator: '>', value: 'LAST_N_YEARS:1', }, operator: 'AND', right: { left: { field: 'StageName', operator: '=', value: 'Closed Won', // literalType is optional, but if set to STRING and our value is not already wrapped in "'", they will be added // All other literalType values are ignored when composing a query literalType: 'STRING', }, }, }, limit: 150, }; const composedQuery = composeQuery(soqlQuery, { format: true }); console.log(composedQuery); ``` **Results** ```sql SELECT Id, Name, FORMAT(Amount) MyFormattedAmount, ( SELECT Quantity, ListPrice, PricebookEntry.UnitPrice, PricebookEntry.Name FROM OpportunityLineItems ) FROM Opportunity WHERE CreatedDate > LAST_N_YEARS:1 AND StageName = 'Closed Won' LIMIT 150 ``` #### Composing a partial query Starting in version `4.4`, compose will not fail if there are missing `SELECT` and `FROM` clauses in your query. Partial compose support it supported without any additional steps. ```typescript import { Compose, parseQuery } from '@jetstreamapp/soql-parser-js'; const soql = `WHERE Name LIKE 'A%' AND MailingCity = 'California`; const parsedQuery = parseQuery(soql, { allowPartialQuery: true }); // Results of Parsed Query: /** { where: { left: { field: 'Name', operator: 'LIKE', value: "'A%'", literalType: 'STRING' }, operator: 'AND', right: { left: { field: 'MailingCity', operator: '=', value: "'California'", literalType: 'STRING' } }, }, } */ const composedQuery = composeQuery(soqlQuery, { format: true }); console.log(composedQuery); ``` **Results** ```sql WHERE Name LIKE 'A%' AND MailingCity = 'California ```
See the alternate way to compose partial queries by calling the Compose class directly If you need to compose just a part of a query instead of the entire query, you can create an instance of the Compose class directly. For example, if you just need the `WHERE` clause from a query as a string, you can do the following: ```typescript import { Compose, parseQuery } from '@jetstreamapp/soql-parser-js'; const soql = `SELECT Id FROM Account WHERE Name = 'Foo'`; const parsedQuery = parseQuery(soql); // Results of Parsed Query: // const parsedQuery = { // fields: [ // { // type: 'Field', // field: 'Id', // }, // ], // sObject: 'Account', // where: { // left: { // field: 'Name', // operator: '=', // value: "'Foo'", // literalType: 'STRING', // }, // }, // }; // Create a new instance of the compose class and set the autoCompose to false to avoid composing the entire query const composer = new Compose(parsedQuery, { autoCompose: false }); const whereClause = composer.parseWhereOrHavingClause(parsedQuery.where); console.log(whereClause); } ``` ##### Available methods on the `Compose` class These are used internally, but are public and available for use. ```typescript parseQuery(query: Query | Subquery): string; parseFields(fields: FieldType[]): { text: string; typeOfClause?: string[] }[]; parseTypeOfField(typeOfField: FieldTypeOf): string[]; parseWhereOrHavingClause(whereOrHaving: WhereClause | HavingClause, indent = 0): string; // indent only applies when format is enabled parseGroupByClause(groupBy: GroupByClause | GroupByClause[]): string; parseOrderBy(orderBy: OrderByClause | OrderByClause[]): string; parseWithDataCategory(withDataCategory: WithDataCategoryClause): string; ```
### Format Query This function is provided as a convenience and just calls parse and compose. [Check out the playground](/playground) to see the outcome of the various format options. ```typescript import { formatQuery } from '@jetstreamapp/soql-parser-js'; const query = `SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, BillingCity, BillingCountry, BillingGeocodeAccuracy, ShippingStreet, Sic, SicDesc, Site, SystemModstamp, TickerSymbol, Type, Website, (SELECT Id, Name, AccountId, Amount, CampaignId, CloseDate, CreatedById, Type FROM Opportunities), (SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, Website FROM ChildAccounts) FROM Account WHERE Name LIKE 'a%' OR Name LIKE 'b%' OR Name LIKE 'c%'`; const formattedQuery1 = formatQuery(query); const formattedQuery2 = formatQuery(query, { fieldMaxLineLength: 20, fieldSubqueryParensOnOwnLine: false }); const formattedQuery3 = formatQuery(query, { newLineAfterKeywords: true }); const formattedQuery4 = formatQuery(query, { indentString: ' ', numIndent: 2, fieldMaxLineLength: 40 }); ``` ```sql -- formattedQuery1 SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, BillingCity, BillingCountry, BillingGeocodeAccuracy, ShippingStreet, Sic, SicDesc, Site, SystemModstamp, TickerSymbol, Type, Website, ( SELECT Id, Name, AccountId, Amount, CampaignId, CloseDate, CreatedById, Type FROM Opportunities ), ( SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, Website FROM ChildAccounts ) FROM Account WHERE Name LIKE 'a%' OR Name LIKE 'b%' OR Name LIKE 'c%' -- formattedQuery2 SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, BillingCity, BillingCountry, BillingGeocodeAccuracy, ShippingStreet, Sic, SicDesc, Site, SystemModstamp, TickerSymbol, Type, Website, (SELECT Id, Name, AccountId, Amount, CampaignId, CloseDate, CreatedById, Type FROM Opportunities), (SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, Website FROM ChildAccounts) FROM Account WHERE Name LIKE 'a%' OR Name LIKE 'b%' OR Name LIKE 'c%' -- formattedQuery3 SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, BillingCity, BillingCountry, BillingGeocodeAccuracy, ShippingStreet, Sic, SicDesc, Site, SystemModstamp, TickerSymbol, Type, Website, ( SELECT Id, Name, AccountId, Amount, CampaignId, CloseDate, CreatedById, Type FROM Opportunities ), ( SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, Website FROM ChildAccounts ) FROM Account WHERE Name LIKE 'a%' OR Name LIKE 'b%' OR Name LIKE 'c%' -- formattedQuery4 SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, BillingCity, BillingCountry, BillingGeocodeAccuracy, ShippingStreet, Sic, SicDesc, Site, SystemModstamp, TickerSymbol, Type, Website, ( SELECT Id, Name, AccountId, Amount, CampaignId, CloseDate, CreatedById, Type FROM Opportunities ), ( SELECT Id, Name, AccountNumber, AccountSource, AnnualRevenue, BillingAddress, Website FROM ChildAccounts ) FROM Account WHERE Name LIKE 'a%' OR Name LIKE 'b%' OR Name LIKE 'c%' ``` --- ## Overview **This library allows parsing and composing (aka generating) SOQL queries from Salesforce using JavaScript or Typescript.** The [playground](/playground) is a great place to get familiar with soql-parser-js. ## Quick Start These are the most common functions exported by the library: | Function | Description | Arguments | | ------------ | ------------------------------------------------------ | -------------------------------------------- | | parseQuery | Parse a SOQL query string into a Query data structure. | `soql: string`, `config?: ParseQueryConfig` | | composeQuery | Turn a Query object back into a SOQL statement. | `query: Query`, `config?: SoqlComposeConfig` | | isQueryValid | Returns true if the query was able to be parsed. | `soql: string`, `config?: ParseQueryConfig` | | formatQuery | Format a SOQL query string. | `soql: string`, `config?: FormatOptions` | ### Parse a query ```typescript import { parseQuery, Query } from '@jetstreamapp/soql-parser-js'; const query = parseQuery(`SELECT Id FROM Account WHERE Name = 'foo'`); console.log(query); // Generated Query // { // fields: [ // { // type: 'Field', // field: 'Id', // }, // ], // sObject: 'Account', // where: { // left: { // field: 'Name', // operator: '=', // value: "'Foo'", // literalType: 'STRING', // }, // }, // } ``` ### Compose a query from an object Composing a query will take a query object and return a soql query. ```typescript import { composeQuery, Query } from '@jetstreamapp/soql-parser-js'; const query = { fields: [ { type: 'Field', field: 'Id', }, ], sObject: 'Account', where: { left: { field: 'Name', operator: '=', value: "'Foo'", literalType: 'STRING', }, }, }; const soql = composeQuery(query); console.log(soql); // SELECT Id FROM Account WHERE Name = 'foo' ``` #### Compose using helper functions You can use the `getField` helper function to simplify the field generation. Read the api docs for more information. ```typescript import { composeQuery, getField } from '@jetstreamapp/soql-parser-js'; const soql = composeQuery({ fields: [ getField('Id'), getField('Name'), getField('EntityDefinitionId'), getField('EntityDefinition.QualifiedApiName'), getField('IsIdLookup'), getField('DataType'), getField('ValueTypeId'), getField('ReferenceTo'), getField('IsCreatable'), getField('IsUpdatable'), getField('Label'), getField('MasterLabel'), getField('QualifiedApiName'), getField('RelationshipName'), ], sObject: 'EntityParticle', where: { left: { field: 'EntityDefinition.QualifiedApiName', operator: 'IN', value: sobjects, literalType: 'STRING', }, operator: 'AND', right: { left: { field: 'QualifiedApiName', operator: '!=', value: 'Id', literalType: 'STRING', }, operator: 'AND', right: { left: { field: 'DataType', operator: 'IN', value: ['string', 'phone', 'url', 'email'], literalType: 'STRING', }, }, }, }, orderBy: [ { field: 'EntityDefinitionId', }, { field: 'Label' }, ], }); ``` ### `FORMULA()` in `WHERE` The parser supports Salesforce's arithmetic [`FORMULA()` WHERE function](https://developer.salesforce.com/docs/atlas.en-us.264.0.soql_sosl.meta/soql_sosl/sforce_api_calls_soql_select_formula.htm). The quoted expression must contain two field references separated by `+` or `-`. The expression is parsed into its own nested AST rather than retained as a raw string. Only comparison operators may follow `FORMULA()`, and Apex bind variables are rejected because Salesforce does not support them there. Salesforce ships this function as a Beta feature as of Summer '26. ```typescript const query = parseQuery("SELECT Id FROM Opportunity WHERE FORMULA('Amount - ExpectedRevenue') > 100"); console.log(query.where?.left); // { // fn: { // functionName: 'FORMULA', // parameters: ["'Amount - ExpectedRevenue'"], // rawValue: "FORMULA('Amount - ExpectedRevenue')", // formula: { // type: 'BinaryExpression', // operator: '-', // left: { type: 'FieldReference', parts: ['Amount'] }, // right: { type: 'FieldReference', parts: ['ExpectedRevenue'] }, // }, // }, // operator: '>', // value: '100', // literalType: 'INTEGER', // } ``` `FORMULA()` is only accepted in `WHERE`, not in `SELECT`, `HAVING`, `GROUP BY`, or `ORDER BY`. When `formula` is present the composer rebuilds `FORMULA()` from that AST and ignores `rawValue`; a `FORMULA` function without `formula` composes from `rawValue` like any other function. `parameters` holds the normalized expression and `rawValue` keeps the original text. The parser validates the arithmetic shape but cannot check Salesforce metadata-dependent restrictions, including field data types and compatibility. ### Contributing All contributions are welcome on the project. Please read the [contribution guidelines](https://github.com/jetstreamapp/soql-parser-js/blob/master/CONTRIBUTING.md). ### Data Models #### Query ```typescript export type LogicalOperator = 'AND' | 'OR' | 'NOT'; export type Operator = '=' | '!=' | '<=' | '>=' | '>' | '<' | 'LIKE' | 'IN' | 'NOT IN' | 'INCLUDES' | 'EXCLUDES'; export type FieldTypeOfConditionType = 'WHEN' | 'ELSE'; export type GroupSelector = 'ABOVE' | 'AT' | 'BELOW' | 'ABOVE_OR_BELOW'; export type ForClause = 'VIEW' | 'UPDATE' | 'REFERENCE'; export type UpdateClause = 'TRACKING' | 'VIEWSTAT'; export type LiteralType = | 'STRING' | 'INTEGER' | 'DECIMAL' | 'INTEGER_WITH_CURRENCY_PREFIX' | 'DECIMAL_WITH_CURRENCY_PREFIX' | 'BOOLEAN' | 'NULL' | 'DATETIME' | 'DATE' | 'DATE_LITERAL' | 'DATE_N_LITERAL' | 'APEX_BIND_VARIABLE'; export type FieldType = Field | FieldWithAlias | FieldFunctionExpression | FieldRelationship | FieldRelationshipWithAlias | FieldSubquery | FieldTypeOf; export type OrderByCriterion = 'ASC' | 'DESC'; export type NullsOrder = 'FIRST' | 'LAST'; export type GroupByType = 'CUBE' | 'ROLLUP'; export type DateLiteral = | 'YESTERDAY' | 'TODAY' | 'TOMORROW' | 'LAST_WEEK' | 'THIS_WEEK' | 'NEXT_WEEK' | 'LAST_MONTH' | 'THIS_MONTH' | 'NEXT_MONTH' | 'LAST_90_DAYS' | 'NEXT_90_DAYS' | 'THIS_QUARTER' | 'LAST_QUARTER' | 'NEXT_QUARTER' | 'THIS_YEAR' | 'LAST_YEAR' | 'NEXT_YEAR' | 'THIS_FISCAL_QUARTER' | 'LAST_FISCAL_QUARTER' | 'NEXT_FISCAL_QUARTER' | 'THIS_FISCAL_YEAR' | 'LAST_FISCAL_YEAR' | 'NEXT_FISCAL_YEAR'; export type DateNLiteral = | 'YESTERDAY' | 'NEXT_N_DAYS' | 'LAST_N_DAYS' | 'N_DAYS_AGO' | 'NEXT_N_WEEKS' | 'LAST_N_WEEKS' | 'N_WEEKS_AGO' | 'NEXT_N_MONTHS' | 'LAST_N_MONTHS' | 'N_MONTHS_AGO' | 'NEXT_N_QUARTERS' | 'LAST_N_QUARTERS' | 'N_QUARTERS_AGO' | 'NEXT_N_YEARS' | 'LAST_N_YEARS' | 'N_YEARS_AGO' | 'NEXT_N_FISCAL_QUARTERS' | 'LAST_N_FISCAL_QUARTERS' | 'N_FISCAL_QUARTERS_AGO' | 'NEXT_N_FISCAL_YEARS' | 'LAST_N_FISCAL_YEARS' | 'N_FISCAL_YEARS_AGO'; export interface Field { type: 'Field'; field: string; alias?: string; } export interface FieldWithAlias extends Field { objectPrefix: string; rawValue: string; } export interface FieldFunctionExpression { type: 'FieldFunctionExpression'; functionName: string; parameters: (string | FieldFunctionExpression)[]; alias?: string; isAggregateFn?: boolean; // not required for compose, will be populated if SOQL is parsed rawValue?: string; // not required for compose, will be populated if SOQL is parsed } export interface FieldRelationship { type: 'FieldRelationship'; field: string; relationships: string[]; rawValue?: string; // not required for compose, will be populated if SOQL is parsed with the raw value of the entire field } export interface FieldRelationshipWithAlias extends FieldRelationship { objectPrefix: string; alias: string; } export interface FieldSubquery { type: 'FieldSubquery'; subquery: Subquery; } export interface FieldTypeOf { type: 'FieldTypeof'; field: string; conditions: FieldTypeOfCondition[]; } export interface FieldTypeOfCondition { type: FieldTypeOfConditionType; objectType?: string; // not present when ELSE fieldList: string[]; } export interface QueryBase { fields?: FieldType[]; sObjectAlias?: string; usingScope?: string; where?: WhereClause; limit?: number; offset?: number; groupBy?: GroupByClause; orderBy?: OrderByClause | OrderByClause[]; withDataCategory?: WithDataCategoryClause; withSecurityEnforced?: boolean; withAccessLevel?: boolean; for?: ForClause; update?: UpdateClause; } export interface Query extends QueryBase { sObject?: string; } export interface Subquery extends QueryBase { relationshipName: string; sObjectPrefix?: string[]; } export type WhereClause = WhereClauseWithoutOperator | WhereClauseWithRightCondition; export interface WhereClauseWithoutOperator { left: ConditionWithValueQuery; } export interface WhereClauseWithRightCondition extends WhereClauseWithoutOperator { operator: LogicalOperator; right: WhereClause; } export type Condition = ValueCondition | ValueWithDateLiteralCondition | ValueWithDateNLiteralCondition | ValueFunctionCondition | NegationCondition; export type ConditionWithValueQuery = Condition | ValueQueryCondition; export interface OptionalParentheses { openParen?: number; closeParen?: number; } export interface ValueCondition extends OptionalParentheses { field: string; operator: Operator; value: string | string[]; literalType?: LiteralType | LiteralType[]; } export interface ValueWithDateLiteralCondition extends OptionalParentheses { field: string; operator: Operator; value: DateLiteral | DateLiteral[]; literalType?: 'DATE_LITERAL' | 'DATE_LITERAL'[]; } export interface ValueWithDateNLiteralCondition extends OptionalParentheses { field: string; operator: Operator; value: string | string[]; literalType?: 'DATE_N_LITERAL' | 'DATE_N_LITERAL'[]; dateLiteralVariable: number | number[]; } export interface ValueQueryCondition extends OptionalParentheses { field: string; operator: Operator; valueQuery: Query; } export interface ValueFunctionCondition extends OptionalParentheses { fn: FunctionExp | FormulaFunctionExp; // narrow with isFormulaFunction(); checking functionName alone does not narrow the type operator: Operator; value: string | string[]; literalType?: LiteralType | LiteralType[]; } export interface NegationCondition { openParen: number; } export type OrderByClause = OrderByFieldClause | OrderByFnClause; export interface OrderByOptionalFieldsClause { order?: OrderByCriterion; nulls?: NullsOrder; } export interface OrderByFieldClause extends OrderByOptionalFieldsClause { field: string; } export interface OrderByFnClause extends OrderByOptionalFieldsClause { fn: FunctionExp; } export type GroupByClause = GroupByFieldClause | GroupByFnClause; export interface GroupByOptionalFieldsClause { having?: HavingClause; } export interface GroupByFieldClause extends GroupByOptionalFieldsClause { field: string | string[]; } export interface GroupByFnClause extends GroupByOptionalFieldsClause { fn: FunctionExp; } export type HavingClause = HavingClauseWithoutOperator | HavingClauseWithRightCondition; export interface HavingClauseWithoutOperator { left: Condition; } export interface HavingClauseWithRightCondition extends HavingClauseWithoutOperator { operator: LogicalOperator; right: HavingClause; } export interface FunctionExp { rawValue?: string; // only used for compose fields if useRawValueForFn=true. Should be formatted like this: Count(Id) functionName?: string; // only used for compose fields if useRawValueForFn=false, will be populated if SOQL is parsed alias?: string; parameters?: (string | FunctionExp)[]; // only used for compose fields if useRawValueForFn=false, will be populated if SOQL is parsed isAggregateFn?: boolean; // not used for compose, will be populated if SOQL is parsed } export type FormulaArithmeticOperator = '+' | '-'; export interface FormulaFieldReference { type: 'FieldReference'; parts: string[]; } export interface FormulaBinaryExpression { type: 'BinaryExpression'; operator: FormulaArithmeticOperator; left: FormulaFieldReference; right: FormulaFieldReference; } export interface FormulaFunctionExp extends FunctionExp { functionName: 'FORMULA'; formula: FormulaBinaryExpression; } export interface WithDataCategoryClause { conditions: WithDataCategoryCondition[]; } export interface WithDataCategoryCondition { groupName: string; selector: GroupSelector; parameters: string[]; } ```