@progress/sitefinity-webservices-sdk 0.2.72 → 1.0.0

package/src/Query.ts

@@ -4,28 +4,26 @@ import { OrderProperty } from './OrderProperty';
 import { QueryBuilder } from './QueryBuilder';
 
 /**
- * @classdesc The query class is used for constructing queries.
- * @class Query
- * @augments QueryBase
+ * The query class is used for constructing queries.
  * @example
- * var query = new Sitefinity.Query();
- * var query0 = query.where().and().endsWith("Title", "Record").done().or().startsWith('Title', 'asd').done().done();
- * var query1 = query.where().or().endsWith("Record", "Title").ne('age', '15').eq('Content', 'test').done().done();
- * var query2 = query.where().and().endsWith("Title", "Record").done().done();
- * var query3 = query.where().endsWith("Record", "Title").or().ne('age', '15').eq('Content', 'test').done().done();
- * var query4 = query.where().not().endsWith("Record", "Title").done().and().not().eq('Content', 'test').done().done().done();
- * var query5 = query.where().not().and().endsWith("Record", "Title").eq('Content', 'test').done().done().done();
- * var query6 = query.select("Id", "Title", "Content").expand('Tags').order("Title desc").where().ne('Title', 'zzz').eq('Title', 'newTitle').done()//.count();
- * var query7 = query.order("Title desc").where().eq('Title', 'newTitleUPDATE1').done().select("Title", "Content");
- * var query8 = query.where().eq('Title', 'newTitleN11').done();
+ * const query = new Sitefinity.Query();
+ * const query0 = query.where().and().endsWith("Title", "Record").done().or().startsWith('Title', 'asd').done().done();
+ * const query1 = query.where().or().endsWith("Record", "Title").ne('age', '15').eq('Content', 'test').done().done();
+ * const query2 = query.where().and().endsWith("Title", "Record").done().done();
+ * const query3 = query.where().endsWith("Record", "Title").or().ne('age', '15').eq('Content', 'test').done().done();
+ * const query4 = query.where().not().endsWith("Record", "Title").done().and().not().eq('Content', 'test').done().done().done();
+ * const query5 = query.where().not().and().endsWith("Record", "Title").eq('Content', 'test').done().done().done();
+ * const query6 = query.select("Id", "Title", "Content").expand('Tags').order("Title desc").where().ne('Title', 'zzz').eq('Title', 'newTitle').done()//.count();
+ * const query7 = query.order("Title desc").where().eq('Title', 'newTitleUPDATE1').done().select("Title", "Content");
+ * const query8 = query.where().eq('Title', 'newTitleN11').done();
  */
 export class Query extends QueryBase {
-    protected _order: any = null;
-    protected _skip: any = null;
-    protected _take: any = null;
-    protected _search: any = null;
-    protected _count: any = null;
-    private expr: any = null;
+    orderProperties: OrderProperty[] = null;
+    skipValue: number = null;
+    takeValue: number = null;
+    searchValue: string = null;
+    returnCount: boolean;
+    filter: WhereQuery<Query> = null;
 
     constructor() {
         super();
@@ -33,99 +31,75 @@ export class Query extends QueryBase {
 
     /**
     * Begins a where clause for filtering the items.
-    * @memberOf Query
-    * @returns {@link WhereQuery}
     */
-    where() {
-        var clone = this._clone((newObj) => {
-            newObj.expr = new WhereQuery(newObj);
+    where(): WhereQuery<Query> {
+        const clone: Query = this.clone((newObj: Query) => {
+            newObj.filter = new WhereQuery(newObj);
         });
 
-        return clone.expr;
+        return clone.filter;
     }
 
-
     /**
     * Specifies the order by clause.
-    * @memberOf Query
     * @example
-    * // filter by single field
+    * order by single field
     * order("Title desc")
     * @example
-    * // filter by multiple fields
+    * order by multiple fields
     * order("Title desc", "Description asc")
-    * @returns {@link Query}
     */
-    order() {
-        var orderPropPaths = this._extractArguments(arguments);
-        this._validatePropertyPaths(orderPropPaths);
+    order(...properties: string[]): Query {
+        properties = properties ?? [];
+        this.validatePropertyPaths(properties);
 
-        return this._clone(function (newObj) {
-            var orderItems = [];
-            for (var i = 0; i < orderPropPaths.length; i++) {
-                var member = orderPropPaths[i];
-                var orderProp = new OrderProperty(member);
+        return this.clone((newObj: Query) => {
+            const orderItems: OrderProperty[] = [];
+            for (let i = 0; i < properties.length; i++) {
+                const member = properties[i];
+                const orderProp = new OrderProperty(member);
                 orderItems.push(orderProp);
             }
-            newObj._order = orderItems;
+            newObj.orderProperties = orderItems;
         });
     }
 
-    /** Skips a certain number of items from the beginning before returning the rest of the items. Used for paging.
-    * @memberOf Query.prototype
-    * @method skip
-    * @see [query.take]{@link query.take}
-    * @param {number} value The number of items to skip.
-    * @returns {Query}
+    /**
+    * Skips a certain number of items from the beginning before returning the rest of the items. Used for paging.
     */
-    skip(value: number) {
-        // validate
-        return this._clone((newObj) => {
-            newObj._skip = value;
+    skip(value: number): Query {
+        return this.clone((newObj: Query) => {
+            newObj.skipValue = value;
         });
     }
 
-    /** Takes a specified number of items from the query result. Used for paging.
-    * @memberOf Query.prototype
-    * @param {number} value The number of items to take.
-    * @returns {Query}
+    /**
+    * Takes a specified number of items from the query result. Used for paging.
     */
-    take(value: number) {
-        return this._clone(function (newObj) {
-            newObj._take = value;
+    take(value: number): Query {
+        return this.clone((newObj: Query) => {
+            newObj.takeValue = value;
         });
     }
 
-    /** Searches for the items matching the specified expression.
-    * @memberOf Query.prototype
-    * @param {string} value The search expression.
-    * @returns {Query}
+    /**
+    * Searches for the items matching the specified expression.
     */
-    search(value: string) {
-        return this._clone(function (newObj) {
-            newObj._search = value;
+    search(value: string): Query {
+        return this.clone((newObj: Query) => {
+            newObj.searchValue = value;
         });
     }
 
-    /** Returns the total item count with the result. Used for paging.
-    * @memberOf Query.prototype
-    * @param {inline} inline Whether to return only the count of the items with or without their JSON representation.
-    * @returns {Query}
+    /**
+    * Returns the total item count with the result. Used for paging.
     */
-    count(inline: boolean = true) {
-        return this._clone(function (newObj) {
-            newObj._count = inline;
+    count(returnCount = true): Query {
+        return this.clone((newObj: Query) => {
+            newObj.returnCount = returnCount;
         });
     }
 
-    _getFilter() {
-        return this.expr;
-    }
-
-    _getOrderBy() {
-        return this._order;
-    }
-
     build() {
         return new QueryBuilder(this).build();
     }

package/src/QueryBase.ts

@@ -1,70 +1,45 @@
 import { utils } from './utils';
 
 /**
- * @classdesc The base class for dealing with queries.
- * @class QueryBase
+ * The base class for dealing with queries.
  */
 export class QueryBase {
-    private _select: any;
-    private _expand: any;
+    selectProperties: string[];
+    expandProperties: string[];
+
     constructor() {
-        this._select = null;
-        this._expand = null;
+        this.selectProperties = null;
+        this.expandProperties = null;
     }
 
     /**
     * Selects which fields will be returned when querying the service.
-    * @memberOf QueryBase
-    * @instance
-    * @param {string} arguments - an array of fields to include in the $select statement.
-    * @returns {QueryBase}
     */
-   select() {
-        var selectPropPaths = this._extractArguments(arguments);
+    select(...properties: string[]): QueryBase {
+        properties = properties ?? [];
 
-        this._validatePropertyPaths(selectPropPaths);
+        this.validatePropertyPaths(properties);
 
-        return this._clone((newObj) => {
-            newObj._select = selectPropPaths.filter((prop, index, props) => props.indexOf(prop) === index);
+        return this.clone((newObj: QueryBase) => {
+            newObj.selectProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);
         });
     }
 
     /**
     * Selects which navigation properties will be returned when querying the service.
-    * @memberOf QueryBase
-    * @instance
-    * @param {string} arguments - an array of fields to include in the $expand statement.
-    * @returns {QueryBase}
     */
-    expand() {
-        var propPaths = this._extractArguments(arguments);
-        this._validatePropertyPaths(propPaths);
+    expand(...properties: string[]): QueryBase {
+        properties = properties ?? [];
+        this.validatePropertyPaths(properties);
 
-        return this._clone(function (newObj) {
-            newObj._expand = propPaths.filter((prop, index, props) => props.indexOf(prop) === index);
+        return this.clone((newObj: QueryBase) => {
+            newObj.expandProperties = properties.filter((prop, index, props) => props.indexOf(prop) === index);
         });
     }
 
-    _extractArguments(arg: IArguments) {
-        var values = [];
-        for (var index = 0; index < arg.length; index++) {
-            values.push(arg[index]);
-        }
-
-        return values;
-    }
-
-    _getSelect() {
-        return this._select;
-    }
-
-    _getExpand() {
-        return this._expand;
-    }
-
-    _validatePropertyPaths(propPaths: any, allowNested: boolean = false) {
-        for (var i = 0; i < propPaths.length; i++) {
-            var member = propPaths[i];
+    protected validatePropertyPaths(propPaths: string[], allowNested = false) {
+        for (let i = 0; i < propPaths.length; i++) {
+            const member = propPaths[i];
             if (!utils.isString(member)) {
                 throw new Error('Invalid argument in clause');
             }
@@ -75,9 +50,8 @@ export class QueryBase {
         }
     }
 
-    _clone(setter: any = null) {
-        var newObj = utils.clone(this, new QueryBase(), setter);
-
+    protected clone(setter: Function = null) {
+        const newObj = utils.clone(this, new QueryBase(), setter);
         return newObj;
     }
 }

package/src/QueryBuilder.ts

@@ -2,109 +2,97 @@
 import { ComplexExpression, BinaryExpression } from './Expression';
 import { OrderProperty } from './OrderProperty';
 import { utils } from './utils';
-
-var constants = require('./constants').default;
+import { ODATA_PARAMS, EXPRESSION_TYPE } from "./constants";
+import { Query } from "./Query";
 
 export class QueryBuilder {
-    constructor(private query: any) {
-
-    }
-
-    build(): any {
-        var queryParameters = {};
-        this._buildODataQueryParams(this.query, queryParameters);
-        return queryParameters;
+    constructor(private query: Query) {
     }
 
-    private _buildODataQueryParams(query, queryParameters) {
-        var queryParams = constants.ODataParams;
-
-        var whereClause = query._getFilter();
+    build(): { [key: string]: string } {
+        const queryParameters = {};
+        const whereClause = this.query.filter;
         if (whereClause instanceof WhereQuery) {
-            var expression = whereClause._getExpression();
+            const expression = whereClause.getExpression();
             if (expression instanceof ComplexExpression) {
-                var result = this._buildComplexExpression(expression, null);
+                const result = this.buildComplexExpression(expression, null);
                 if (result) {
-                    queryParameters[queryParams.$filter] = result;
+                    queryParameters[ODATA_PARAMS.$filter] = result;
                 }
             }
         }
 
-        var selectClause = query._getSelect();
+        const selectClause = this.query.selectProperties;
         if (selectClause instanceof Array) {
-            queryParameters[queryParams.$select] = selectClause.join(', ');
+            queryParameters[ODATA_PARAMS.$select] = selectClause.join(', ');
         }
 
-        var expandClause = query._getExpand();
+        const expandClause = this.query.expandProperties;
         if (expandClause instanceof Array)
-            queryParameters[queryParams.$expand] = expandClause.join(', ');
+            queryParameters[ODATA_PARAMS.$expand] = expandClause.join(', ');
 
-        var orderByClause = query._order;
+        const orderByClause = this.query.orderProperties;
         if (orderByClause instanceof Array) {
-            var order = [];
-            for (var i in orderByClause) {
+            const order = [];
+            for (const i in orderByClause) {
                 if (orderByClause[i] instanceof OrderProperty)
                     order.push(orderByClause[i].getValue());
             }
-            queryParameters[queryParams.$orderby] = order.join(', ');
+            queryParameters[ODATA_PARAMS.$orderby] = order.join(', ');
         }
 
-        var take = query._take;
+        const take = this.query.takeValue;
         if (utils.isNumber(take))
-            queryParameters[queryParams.$top] = take;
+            queryParameters[ODATA_PARAMS.$top] = take;
 
-        var skip = query._skip;
+        const skip = this.query.skipValue;
         if (utils.isNumber(skip))
-            queryParameters[queryParams.$skip] = skip;
+            queryParameters[ODATA_PARAMS.$skip] = skip;
 
-        var search = query._search;
+        const search = this.query.searchValue;
         if (search)
-            queryParameters[queryParams.$search] = search;
+            queryParameters[ODATA_PARAMS.$search] = search;
 
-        var count = query._count;
-
-        // means that the count is required inline
-        if (count !== null) {
-            queryParameters[queryParams.$count] = count;
+        if (this.query.returnCount) {
+            queryParameters[ODATA_PARAMS.$count] = true;
         }
 
         return queryParameters;
     }
 
-    private _buildComplexExpression(expression, parent) {
+    private buildComplexExpression(expression: ComplexExpression, parent: string): string {
         if (!(expression instanceof ComplexExpression))
             throw new Error('Invalid complex expression');
 
-        var OperatorType = constants.ExpressionType;
-        var counter = 0;
-        var result = '';
-        var subExpressions = expression.getExpressions();
+        let counter = 0;
+        let result = '';
+        const subExpressions = expression.getExpressions();
         if (!subExpressions.length) {
             return result;
         }
 
         while (true) {
-            var currentExp = subExpressions[counter];
+            const currentExp = subExpressions[counter];
             if (currentExp instanceof BinaryExpression) {
-                result += this._buildBinaryExpression(currentExp);
+                result += this.buildBinaryExpression(currentExp);
             }
             else if (currentExp instanceof ComplexExpression) {
-                var complexResult = this._buildComplexExpression(currentExp, expression.type);
+                const complexResult = this.buildComplexExpression(currentExp, expression.type);
                 if (complexResult) {
                     result += '(' + complexResult + ')';
                 }
             }
 
-            if (expression.getType() === OperatorType.not)
+            if (expression.getType() === EXPRESSION_TYPE.not)
                 result = expression.getType() + ' ' + result;
             // TODOSDK: Rethink this!
-            if (expression.getType() === OperatorType.any) {
-                var exprVal = [];
-                for (var index = 0; index < subExpressions.length; index++) {
-                    if (subExpressions[index].type == OperatorType.contains || subExpressions[index].type == OperatorType.startsWith || subExpressions[index].type == OperatorType.endsWith)
+            if (expression.getType() === EXPRESSION_TYPE.any) {
+                const exprVal = [];
+                for (let index = 0; index < subExpressions.length; index++) {
+                    if (subExpressions[index].type == EXPRESSION_TYPE.contains || subExpressions[index].type == EXPRESSION_TYPE.startsWith || subExpressions[index].type == EXPRESSION_TYPE.endsWith)
                         exprVal.push(subExpressions[index].type.toLowerCase() + "(x, '" + (subExpressions[index] as BinaryExpression).constant + "')");
                     else
-                        exprVal.push('x ' + subExpressions[index].type.toLowerCase() + ' ' + this._checkType((subExpressions[index] as BinaryExpression).constant));
+                        exprVal.push('x ' + subExpressions[index].type.toLowerCase() + ' ' + this.checkType((subExpressions[index] as BinaryExpression).constant));
                 }
                 result = (currentExp as BinaryExpression).parameter + '/' + expression.getType() + '(x:' + exprVal.join(' ' + parent + ' ') + ')';
             }
@@ -119,59 +107,65 @@ export class QueryBuilder {
         return result;
     }
 
-    private _buildBinaryExpression(expression) {
-        if (!(expression instanceof BinaryExpression))
-            throw new Error('Invalid binary expression');
-
-        var ExpressionType = constants.ExpressionType;
-        var result = null;
-        var type = expression.getType();
+    private buildBinaryExpression(expression: BinaryExpression): string {
+        let result: string = null;
+        const type = expression.getType();
         switch (type) {
-            case ExpressionType.eq:
-            case ExpressionType.ne:
-            case ExpressionType.lt:
-            case ExpressionType.le:
-            case ExpressionType.gt:
-            case ExpressionType.ge:
-                var constant = expression.getConstant();
-                /*var template = '({0} {1} \'{2}\')';
-                if (/^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(constant))
-                    template = '({0} {1} {2})';*/
-
-                result = `(${expression.getParameter()} ${type} ${this._checkType(constant)})`;
+            case EXPRESSION_TYPE.eq:
+            case EXPRESSION_TYPE.ne:
+            case EXPRESSION_TYPE.lt:
+            case EXPRESSION_TYPE.le:
+            case EXPRESSION_TYPE.gt:
+            case EXPRESSION_TYPE.ge: {
+                const constant = expression.getConstant();
+                result = `(${expression.getParameter()} ${type} ${this.checkType(constant)})`;
                 break;
-                // TODO contains is substringOf in Odata ?
-            case ExpressionType.contains:
-            case ExpressionType.startsWith:
-            case ExpressionType.endsWith:
-                result = `${type.toLowerCase()}(${expression.getParameter()}, ${this._checkType(expression.getConstant())})`;
+            }
+            case EXPRESSION_TYPE.contains:
+            case EXPRESSION_TYPE.startsWith:
+            case EXPRESSION_TYPE.endsWith: {
+                const expressionParameter = this.applyCaseSensitiveSettings(expression, expression.getParameter());
+                const expressionConstant =  this.checkType(expression.getConstant());
+                const expressionValue = this.applyCaseSensitiveSettings(expression, expressionConstant);
+
+                result = `${type.toLowerCase()}(${expressionParameter}, ${expressionValue})`;
                 break;
-            default:
-                var msg = `Unsupported operator ${type}`;
+            }
+            default: {
+                const msg = `Unsupported operator ${type}`;
                 throw new Error(msg);
+            }
         }
 
         return result;
     }
 
-    private _checkType(constant: any) {
-        if (this._isGuid(constant))
+    private applyCaseSensitiveSettings(expression: BinaryExpression, value: string): string {
+        if (expression.isCaseSensitive()) {
+            return value;
+        }
+
+        return `tolower(${value})`;
+    }
+
+    private checkType(constant: any): string {
+        if (this.isGuid(constant))
             return constant;
 
         if (constant == null)
             return null;
 
-        constant = constant.replace(/[+/?%#&]/g, function($0) {
+        constant = constant.replace(/[+/?%#&]/g, function ($0) {
             return encodeURIComponent($0);
         });
 
-         // escapes the apostrophes
-        constant = constant.replace(/'/g,"''");
+        // escapes the apostrophes
+        constant = constant.replace(/'/g, "''");
 
         return "'" + constant + "'";
     }
 
-    private _isGuid(constant: string) {
+    private isGuid(constant: string): boolean {
         return /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/.test(constant);
     }
 }