Summer '20 Updates

- Converted metadata to SFDX format
- Upgraded to API v49.0
- Simplified naming convention used for classes

.forceignore

@@ -0,0 +1,12 @@
+# List files or directories below to ignore them when running force:source:push, force:source:pull, and force:source:status
+# More information: https://developer.salesforce.com/docs/atlas.en-us.sfdx_dev.meta/sfdx_dev/sfdx_dev_exclude_source.htm
+#
+
+package.xml
+
+# LWC configuration files
+**/jsconfig.json
+**/.eslintrc.json
+
+# LWC Jest
+**/__tests__/**

.gitignore

@@ -0,0 +1,9 @@
+# Folders to exclude
+.settings/
+.sfdx/
+.vscode/
+*/main/default/
+
+# Files to exclude
+*.log
+

.travis.yml

@@ -1,7 +1,27 @@
-language: node_js
-node_js:
- - "7"
-install:
- - npm install -g jsforce-metadata-tools
+sudo: true
+os: trusty
+cache: false
+
+env:
+- URL=https://developer.salesforce.com/media/salesforce-cli/sfdx-linux-amd64.tar.xz
+
+before_install:
+ #- openssl aes-256-cbc -K $encrypted_b1fbf710b918_key -iv $encrypted_b1fbf710b918_iv
+ # -in assets/server.key.enc -out assets/server.key -d
+ - export SFDX_AUTOUPDATE_DISABLE=false
+ - export SFDX_USE_GENERIC_UNIX_KEYCHAIN=true
+ - export SFDX_DOMAIN_RETRY=300
+ - export SFDX_DISABLE_APP_HUB=true
+ - export SFDX_LOG_LEVEL=DEBUG
+ - mkdir sfdx
+ - wget -qO- $URL | tar xJ -C sfdx --strip-components 1
+ - "./sfdx/install"
+ - export PATH=./sfdx/$(pwd):$PATH
+ - sfdx --version
+ - sfdx plugins --core
+ - echo $SFDX_URL > sfdx_url_file
+ - sfdx force:auth:sfdxurl:store --sfdxurlfile sfdx_url_file --setalias nebula_ci
+
 script:
- - jsforce-deploy --checkOnly -u $DEPLOYMENT_USERNAME -p $DEPLOYMENT_PASSWORD$DEPLOYMENT_TOKEN -D $TRAVIS_BUILD_DIR/src -l $DEPLOYMENT_LOGIN_URL --rollbackOnError true --testLevel $DEPLOYMENT_TEST_LEVEL --pollTimeout $POLL_TIMEOUT --pollInterval $POLL_INTERVAL--verbose
+ - sfdx force:config:set apiVersion=49.0
+ - sfdx force:source:deploy --checkonly --manifest ./manifest/package.xml --testlevel RunLocalTests --targetusername nebula_ci --verbose

README.md

@@ -21,7 +21,7 @@ A dynamic SOQL query & SOSL search library for for Salesforce Apex<br /><br />
 ## Overview
 There are 3 main builder classes
 
- &nbsp; | SObjectQueryBuilder | AggregateQueryBuilder | SearchBuilder
+ &nbsp; | Query | AggregateQuery | RecordSearch
 ------- | --------------------|-----------------------|--------------
 Super Class | Soql.cls (Queries) | Soql.cls (Queries) | Sosl.cls (Searches) | -
 Action | Queries an SObject | Queries an SObject | Searches 1 or more SObjects
@@ -31,13 +31,13 @@ Returns | `SObject` or `List<SObject>` | `AggregateResult` or `List<AggregateRes
 **Basic Usage:** Query an object & return the object's ID and display name field (typically the 'Name' field, but some objects use other fields, like Task.Subject and Case.CaseNumber). Since no filters have been added, this query would also return all accounts.
 
 ```
-List<Account> accounts = new SObjectQueryBuilder(Schema.Account.SObjectType).getResults();
+List<Account> accounts = new Query(Schema.Account.SObjectType).getResults();
 ```
 
 **Advanced Usage:** Query an object & leverage the query builder methods. The order of the builder methods does not matter - you can arrange the calls to these methods in any order that you prefer.
 
 ```
-SObjectQueryBuilder accountQuery = new SObjectQueryBuilder(Schema.Account.SObjectType) // Query the account object
+Query accountQuery = new Query(Schema.Account.SObjectType) // Query the account object
  .addField(Schema.Account.ParentId) // Include the ParentId field, using SObjectField. The current user must have at least read access to the field
  .addField(Schema.Account.Type, Soql.FieldCategory.UPDATEABLE) // Include the Type field if the current user has access to update it
  .addFields(Soql.FieldCategory.CUSTOM) // Include all custom fields - only fields that are accessible to the user are included
@@ -74,9 +74,9 @@ System.debug(accountQuery.getQuery());
 **Basic Usage:** Search a single object
 
 ```
-SObjectQueryBuilder userQuery = new SObjectQueryBuilder(Schema.User.SObjectType); // Create an instance of SObjectQueryBuilder for an SObject - you can include additional fields, filters, etc
-SearchBuilder userSearch = new SearchBuilder('my search term', userQuery); // Create a new SearchBuilder instance with a search term & instance of SObjectQueryBuilder
-List<User> userSearchResults = userSearch.getFirstResults(); // SearchBuilder returns a list of lists of sobjects - getFirstResults() returns the first list
+Query userQuery = new Query(Schema.User.SObjectType); // Create an instance of Query for an SObject - you can include additional fields, filters, etc
+RecordSearch userSearch = new RecordSearch('my search term', userQuery); // Create a new RecordSearch instance with a search term & instance of Query
+List<User> userSearchResults = userSearch.getFirstResults(); // RecordSearch returns a list of lists of sobjects - getFirstResults() returns the first list
 
 /****** Resulting output *******
 FIND 'my search term' IN ALL FIELDS RETURNING User(Id, Name)
@@ -88,12 +88,12 @@ System.debug(userSearch.getSearch());
 **Advanced Usage:** Search several objects
 
 ```
-SObjectQueryBuilder accountQuery = new SObjectQueryBuilder(Schema.Account.SObjectType); // Create an instance of SObjectQueryBuilder for the Account object
-SObjectQueryBuilder contactQuery = new SObjectQueryBuilder(Schema.Contact.SObjectType); // Create an instance of SObjectQueryBuilder for the Contact object
-SObjectQueryBuilder leadQuery = new SObjectQueryBuilder(Schema.Lead.SObjectType); // Create an instance of SObjectQueryBuilder for the Lead object
-List<SObjectQueryBuilder> queries = new List<SObjectQueryBuilder>{contactQuery, accountQuery, leadQuery}; // Add the SObjectQueryBuilder queries to a list
+Query accountQuery = new Query(Schema.Account.SObjectType); // Create an instance of Query for the Account object
+Query contactQuery = new Query(Schema.Contact.SObjectType); // Create an instance of Query for the Contact object
+Query leadQuery = new Query(Schema.Lead.SObjectType); // Create an instance of Query for the Lead object
+List<Query> queries = new List<Query>{contactQuery, accountQuery, leadQuery}; // Add the Query queries to a list
 
-SearchBuilder mySearch = new SearchBuilder('my search term', queries); // Create a new SearchBuilder instance with a search term & the list of SObjectQueryBuilder queries
+RecordSearch mySearch = new RecordSearch('my search term', queries); // Create a new RecordSearch instance with a search term & the list of Query queries
 List<List<SObject>> searchResults = mySearch.getResults(); // Returns all search results
 
 /****** Resulting output *******

manifest/package.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Package xmlns="http://soap.sforce.com/2006/04/metadata">
+ <fullName>NebulaQueryAndSearch</fullName>
+ <types>
+ <members>AggregateQuery</members>
+ <members>AggregateQuery_Tests</members>
+ <members>Query</members>
+ <members>Query_Tests</members>
+ <members>RecordSearch</members>
+ <members>RecordSearch_Tests</members>
+ <members>Soql</members>
+ <members>Sosl</members>
+ <name>ApexClass</name>
+ </types>
+ <version>49.0</version>
+</Package>

src/classes/AggregateQueryBuilder.cls → nebula-app-framework/main/query-and-search/classes/AggregateQuery.cls

@@ -2,162 +2,162 @@
 * This file is part of the Nebula Query & Search project, released under the MIT License. *
 * See LICENSE file or go to https://github.com/jongpie/NebulaQueryAndSearch for full license details. *
 ******************************************************************************************************/
-public class AggregateQueryBuilder extends Soql {
+public class AggregateQuery extends Soql {
 
  private Soql.GroupingDimension groupingDimension;
  private List<AggregateField> aggregateFields;
  private List<String> havingConditions;
 
- public AggregateQueryBuilder(Schema.SObjectType sobjectType) {
+ public AggregateQuery(Schema.SObjectType sobjectType) {
  super(sobjectType, false);
 
  this.aggregateFields = new List<AggregateField>();
  this.havingConditions = new List<String>();
  }
 
- public AggregateQueryBuilder groupByField(Schema.SObjectField field) {
+ public AggregateQuery groupByField(Schema.SObjectField field) {
  return this.groupByFields(new List<Schema.SObjectField>{field});
  }
 
- public AggregateQueryBuilder groupByField(Soql.QueryField queryField) {
+ public AggregateQuery groupByField(Soql.QueryField queryField) {
  return this.groupByFields(new List<Soql.QueryField>{queryField});
  }
 
- public AggregateQueryBuilder groupByFields(List<Schema.SObjectField> fields) {
+ public AggregateQuery groupByFields(List<Schema.SObjectField> fields) {
  List<Soql.QueryField> queryFields = new List<Soql.QueryField>();
  for(Schema.SObjectField field : fields) {
  queryFields.add(new Soql.QueryField(field));
  }
  return this.groupByFields(queryFields);
  }
 
- public AggregateQueryBuilder groupByFields(List<Soql.QueryField> queryFields) {
+ public AggregateQuery groupByFields(List<Soql.QueryField> queryFields) {
  super.doAddFields(queryFields, null);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder groupByFieldSet(Schema.FieldSet fieldSet) {
+ public AggregateQuery groupByFieldSet(Schema.FieldSet fieldSet) {
  List<Soql.QueryField> queryFields = new List<Soql.QueryField>();
  for(Schema.FieldSetMember fieldSetMember : fieldSet.getFields()) {
  queryFields.add(new Soql.QueryField(this.sobjectType, fieldSetMember.getFieldPath()));
  }
  return this.groupByFields(queryFields);
  }
 
- public AggregateQueryBuilder usingGroupingDimension(Soql.GroupingDimension groupingDimension) {
+ public AggregateQuery usingGroupingDimension(Soql.GroupingDimension groupingDimension) {
  this.groupingDimension = groupingDimension;
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder addAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field) {
+ public AggregateQuery addAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field) {
  return this.addAggregate(aggregateFunction, field, null);
  }
 
- public AggregateQueryBuilder addAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, String fieldAlias) {
+ public AggregateQuery addAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, String fieldAlias) {
  return this.addAggregate(aggregateFunction, new Soql.QueryField(field), fieldAlias);
  }
 
- public AggregateQueryBuilder addAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField) {
+ public AggregateQuery addAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField) {
  return this.addAggregate(aggregateFunction, queryField, null);
  }
 
- public AggregateQueryBuilder addAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, String fieldAlias) {
+ public AggregateQuery addAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, String fieldAlias) {
  this.aggregateFields.add(new AggregateField(this.getSObjectType(), aggregateFunction, queryField, fieldAlias));
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder havingAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, Soql.Operator operator, Object value) {
+ public AggregateQuery havingAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, Soql.Operator operator, Object value) {
  return this.havingAggregate(aggregateFunction, new Soql.QueryField(field), operator, value);
  }
 
- public AggregateQueryBuilder havingAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, Soql.Operator operator, Object value) {
+ public AggregateQuery havingAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, Soql.Operator operator, Object value) {
  this.havingConditions.add(aggregateFunction.name() + '(' + queryField + ') ' + Soql.getOperatorValue(operator) + ' ' + value);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder filterWhere(Schema.SObjectField field, Soql.Operator operator, Object value) {
+ public AggregateQuery filterWhere(Schema.SObjectField field, Soql.Operator operator, Object value) {
  return this.filterWhere(new Soql.QueryField(field), operator, value);
  }
 
- public AggregateQueryBuilder filterWhere(Soql.QueryField queryField, Soql.Operator operator, Object value) {
+ public AggregateQuery filterWhere(Soql.QueryField queryField, Soql.Operator operator, Object value) {
  return this.filterWhere(new Soql.QueryFilter(queryField, operator, value));
  }
 
- public AggregateQueryBuilder filterWhere(Soql.QueryFilter filter) {
+ public AggregateQuery filterWhere(Soql.QueryFilter filter) {
  return this.filterWhere(new List<Soql.QueryFilter>{filter});
  }
 
- public AggregateQueryBuilder filterWhere(List<Soql.QueryFilter> filters) {
+ public AggregateQuery filterWhere(List<Soql.QueryFilter> filters) {
  super.doFilterWhere(filters);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder orFilterWhere(List<Soql.QueryFilter> filters) {
+ public AggregateQuery orFilterWhere(List<Soql.QueryFilter> filters) {
  super.doOrFilterWhere(filters);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder orderByField(Schema.SObjectField field) {
+ public AggregateQuery orderByField(Schema.SObjectField field) {
  return this.orderByField(field, null);
  }
 
- public AggregateQueryBuilder orderByField(Soql.QueryField queryField) {
+ public AggregateQuery orderByField(Soql.QueryField queryField) {
  return this.orderByField(queryField, null);
  }
 
- public AggregateQueryBuilder orderByField(Schema.SObjectField field, Soql.SortOrder sortOrder) {
+ public AggregateQuery orderByField(Schema.SObjectField field, Soql.SortOrder sortOrder) {
  return this.orderByField(field, sortOrder, null);
  }
 
- public AggregateQueryBuilder orderByField(Soql.QueryField queryField, Soql.SortOrder sortOrder) {
+ public AggregateQuery orderByField(Soql.QueryField queryField, Soql.SortOrder sortOrder) {
  return this.orderByField(queryField, sortOrder, null);
  }
 
- public AggregateQueryBuilder orderByField(Schema.SObjectField field, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
+ public AggregateQuery orderByField(Schema.SObjectField field, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
  return this.orderByField(new Soql.QueryField(field), sortOrder, sortNullsFirst);
  }
 
- public AggregateQueryBuilder orderByField(Soql.QueryField queryField, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
+ public AggregateQuery orderByField(Soql.QueryField queryField, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
  super.doOrderBy(queryField, sortOrder, sortNullsFirst);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder orderByAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field) {
+ public AggregateQuery orderByAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field) {
  return this.orderByAggregate(aggregateFunction, field, null);
  }
 
- public AggregateQueryBuilder orderByAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, Soql.SortOrder sortOrder) {
+ public AggregateQuery orderByAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, Soql.SortOrder sortOrder) {
  return this.orderByAggregate(aggregateFunction, field, sortOrder, null);
  }
 
- public AggregateQueryBuilder orderByAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
+ public AggregateQuery orderByAggregate(Soql.Aggregate aggregateFunction, Schema.SObjectField field, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
  return this.orderByAggregate(aggregateFunction, new Soql.QueryField(field), sortOrder, sortNullsFirst);
  }
 
- public AggregateQueryBuilder orderByAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField) {
+ public AggregateQuery orderByAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField) {
  return this.orderByAggregate(aggregateFunction, queryField, null);
  }
 
- public AggregateQueryBuilder orderByAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, Soql.SortOrder sortOrder) {
+ public AggregateQuery orderByAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, Soql.SortOrder sortOrder) {
  return this.orderByAggregate(aggregateFunction, queryField, sortOrder, null);
  }
 
- public AggregateQueryBuilder orderByAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
+ public AggregateQuery orderByAggregate(Soql.Aggregate aggregateFunction, Soql.QueryField queryField, Soql.SortOrder sortOrder, Boolean sortNullsFirst) {
  super.doOrderBy(aggregateFunction.name() + '(' + queryField + ')', sortOrder, sortNullsFirst);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder limitTo(Integer numberOfRecords) {
+ public AggregateQuery limitTo(Integer numberOfRecords) {
  super.doLimitTo(numberOfRecords);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder offsetBy(Integer offset) {
+ public AggregateQuery offsetBy(Integer offset) {
  super.doOffsetBy(offset);
  return this.setHasChanged();
  }
 
- public AggregateQueryBuilder cacheResults() {
+ public AggregateQuery cacheResults() {
  super.doCacheResults();
  return this;
  }
@@ -210,7 +210,7 @@ public class AggregateQueryBuilder extends Soql {
  return (List<AggregateResult>)super.doGetResults();
  }
 
- private AggregateQueryBuilder setHasChanged() {
+ private AggregateQuery setHasChanged() {
  this.hasChanged = true;
  return this;
  }
@@ -219,7 +219,7 @@ public class AggregateQueryBuilder extends Soql {
  if(this.aggregateFields.isEmpty()) return '';
 
  List<String> aggregateFieldStrings = new List<String>();
- for(AggregateQueryBuilder.AggregateField aggregatedField : this.aggregateFields) {
+ for(AggregateQuery.AggregateField aggregatedField : this.aggregateFields) {
  aggregateFieldStrings.add(aggregatedField.toString());
  }
  aggregateFieldStrings.sort();

src/classes/SObjectQueryBuilder.cls-meta.xml → nebula-app-framework/main/query-and-search/classes/AggregateQuery.cls-meta.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ApexClass xmlns="http://soap.sforce.com/2006/04/metadata">
- <apiVersion>46.0</apiVersion>
+ <apiVersion>49.0</apiVersion>
  <status>Active</status>
 </ApexClass>