Add support for FIELDS() #136

Added Fields() support
updated test-cases

resolves #136

Author: paustint

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 3.0.3
+
+March 27, 2021
+
+1. Added support for the `FIELDS()` function
+
 ## 3.0.2
 
 March 6, 2021

src/models.ts

@@ -177,6 +177,11 @@ export interface FieldFunctionContext {
   fn: IToken[];
 }
 
+export interface FieldsFunctionContext {
+  fn: IToken[];
+  params: IToken[];
+}
+
 export interface LocationFunctionContext {
   location1: IToken[];
   location2: IToken[] | CstNode[];

src/parser/lexer.ts

@@ -29,6 +29,16 @@ export const LocationFunction = createToken({
   pattern: Lexer.NA,
 });
 
+export const FieldsFunction = createToken({
+  name: 'FieldsFunction',
+  pattern: Lexer.NA,
+});
+
+export const FieldsFunctionParamIdentifier = createToken({
+  name: 'FieldsFunctionParamIdentifier',
+  pattern: Lexer.NA,
+});
+
 export const OtherFunction = createToken({
   name: 'OtherFunction',
   pattern: Lexer.NA,
@@ -393,6 +403,14 @@ export const Geolocation = createToken({
   categories: [LocationFunction, Identifier],
 });
 
+// FIELDS FUNCTIONS
+export const Fields = createToken({
+  name: 'FIELDS',
+  pattern: /FIELDS/i,
+  longer_alt: Identifier,
+  categories: [FieldsFunction, Identifier],
+});
+
 // OTHER FUNCTIONS
 export const Format = createToken({
   name: 'FORMAT',
@@ -425,6 +443,28 @@ export const Grouping = createToken({
   categories: [OtherFunction, Identifier],
 });
 
+// FIELDS() PARAMETERS
+export const All = createToken({
+  name: 'ALL',
+  pattern: /ALL/i,
+  longer_alt: Identifier,
+  categories: [FieldsFunctionParamIdentifier, Identifier],
+});
+
+export const Custom = createToken({
+  name: 'CUSTOM',
+  pattern: /CUSTOM/i,
+  longer_alt: Identifier,
+  categories: [FieldsFunctionParamIdentifier, Identifier],
+});
+
+export const Standard = createToken({
+  name: 'STANDARD',
+  pattern: /STANDARD/i,
+  longer_alt: Identifier,
+  categories: [FieldsFunctionParamIdentifier, Identifier],
+});
+
 // DATE LITERALS
 export const Yesterday = createToken({
   name: 'YESTERDAY',
@@ -908,6 +948,7 @@ export const allTokens = [
   Sum,
   Distance,
   Geolocation,
+  Fields,
   Format,
   Tolabel,
   ConvertTimeZone,
@@ -959,6 +1000,10 @@ export const allTokens = [
 
   GeolocationUnit,
 
+  All,
+  Custom,
+  Standard,
+
   In,
   NotIn,
   For,

src/parser/parser.ts

@@ -131,6 +131,7 @@ export class SoqlParser extends CstParser {
           { ALT: () => this.SUBRULE(this.dateFunction, { LABEL: 'fn' }) },
           { ALT: () => this.SUBRULE(this.aggregateFunction, { LABEL: 'fn', ARGS: [true] }) },
           { ALT: () => this.SUBRULE(this.locationFunction, { LABEL: 'fn' }) },
+          { ALT: () => this.SUBRULE(this.fieldsFunction, { LABEL: 'fn' }) },
           { ALT: () => this.SUBRULE(this.otherFunction, { LABEL: 'fn' }) },
         ]),
     );
@@ -412,7 +413,7 @@ export class SoqlParser extends CstParser {
     this.SUBRULE(this.functionExpression);
   });
 
-  private aggregateFunction = this.RULE('aggregateFunction', allowAlias => {
+  private aggregateFunction = this.RULE('aggregateFunction', () => {
     this.OR(
       this.$_aggregateFunction ||
         (this.$_aggregateFunction = [
@@ -427,6 +428,13 @@ export class SoqlParser extends CstParser {
     this.SUBRULE(this.functionExpression, { ARGS: [true] });
   });
 
+  private fieldsFunction = this.RULE('fieldsFunction', () => {
+    this.CONSUME(lexer.Fields, { LABEL: 'fn' });
+    this.CONSUME(lexer.LParen);
+    this.CONSUME(lexer.FieldsFunctionParamIdentifier, { LABEL: 'params' });
+    this.CONSUME(lexer.RParen);
+  });
+
   private otherFunction = this.RULE('otherFunction', () => {
     this.OR(
       this.$_otherFunction ||

src/parser/visitor.ts

@@ -45,6 +45,7 @@ import {
   ExpressionOperatorContext,
   ExpressionTree,
   FieldFunctionContext,
+  FieldsFunctionContext,
   FromClauseContext,
   FunctionExpressionContext,
   GeoLocationFunctionContext,
@@ -550,6 +551,22 @@ class SOQLVisitor extends BaseSoqlVisitor {
     return this.$_getFieldFunction(ctx, true, options.includeType);
   }
 
+  fieldsFunction(ctx: FieldsFunctionContext, options: { includeType: boolean } = { includeType: true }) {
+    let output: any = {};
+    if (options.includeType) {
+      output.type = 'FieldFunctionExpression';
+    }
+    output = {
+      ...output,
+      ...{
+        functionName: 'FIELDS',
+        parameters: [ctx.params[0].image],
+      },
+    };
+
+    output.rawValue = `FIELDS(${output.parameters[0]})`;
+    return output;
+  }
   otherFunction(ctx: FieldFunctionContext, options: { includeType: boolean } = { includeType: true }) {
     return this.$_getFieldFunction(ctx, false, options.includeType);
   }

test/test-cases.ts

@@ -2135,6 +2135,66 @@ export const testCases: TestCase[] = [
       ],
     },
   },
+  {
+    testCase: 109,
+    soql: `SELECT FIELDS(ALL) FROM Account`,
+    output: {
+      fields: [
+        {
+          type: 'FieldFunctionExpression',
+          functionName: 'FIELDS',
+          parameters: ['ALL'],
+          rawValue: 'FIELDS(ALL)',
+        },
+      ],
+      sObject: 'Account',
+    },
+  },
+  {
+    testCase: 110,
+    soql: `SELECT FIELDS(CUSTOM), FIELDS(STANDARD) FROM Account`,
+    output: {
+      fields: [
+        {
+          type: 'FieldFunctionExpression',
+          functionName: 'FIELDS',
+          parameters: ['CUSTOM'],
+          rawValue: 'FIELDS(CUSTOM)',
+        },
+        {
+          type: 'FieldFunctionExpression',
+          functionName: 'FIELDS',
+          parameters: ['STANDARD'],
+          rawValue: 'FIELDS(STANDARD)',
+        },
+      ],
+      sObject: 'Account',
+    },
+  },
+  {
+    testCase: 110,
+    soql: `SELECT Id, (SELECT FIELDS(ALL) FROM Contacts) FROM Account`,
+    output: {
+      fields: [
+        { type: 'Field', field: 'Id' },
+        {
+          type: 'FieldSubquery',
+          subquery: {
+            fields: [
+              {
+                type: 'FieldFunctionExpression',
+                functionName: 'FIELDS',
+                parameters: ['ALL'],
+                rawValue: 'FIELDS(ALL)',
+              },
+            ],
+            relationshipName: 'Contacts',
+          },
+        },
+      ],
+      sObject: 'Account',
+    },
+  },
 ];
 
 export default testCases;

test/test.spec.ts

@@ -12,7 +12,7 @@ const replacements = [{ matching: / last /i, replace: ' LAST ' }];
 // Uncomment these to easily test one specific query - useful for troubleshooting/bugfixing
 
 // describe.only('parse queries', () => {
-//   const testCase = testCases.find(tc => tc.testCase === 87);
+//   const testCase = testCases.find(tc => tc.testCase === 109);
 //   it(`should correctly parse test case ${testCase.testCase} - ${testCase.soql}`, () => {
 //     const soqlQuery = parseQuery(testCase.soql, testCase.options);
 //     console.log(soqlQuery);