@progress/sitefinity-webservices-sdk 1.0.4 → 1.1.3

package/src/QueryBuilder.ts

@@ -1,7 +1,7 @@
-import { WhereQuery } from './WhereQuery';
-import { ComplexExpression, BinaryExpression } from './Expression';
-import { OrderProperty } from './OrderProperty';
-import { utils } from './utils';
+import { WhereQuery } from "./WhereQuery";
+import { ComplexExpression, BinaryExpression } from "./Expression";
+import { OrderProperty } from "./OrderProperty";
+import { utils } from "./utils";
 import { ODATA_PARAMS, EXPRESSION_TYPE } from "./constants";
 import { Query } from "./Query";
 
@@ -24,12 +24,12 @@ export class QueryBuilder {
 
         const selectClause = this.query.selectProperties;
         if (selectClause instanceof Array) {
-            queryParameters[ODATA_PARAMS.$select] = selectClause.join(', ');
+            queryParameters[ODATA_PARAMS.$select] = selectClause.join(", ");
         }
 
         const expandClause = this.query.expandProperties;
         if (expandClause instanceof Array)
-            queryParameters[ODATA_PARAMS.$expand] = expandClause.join(', ');
+            queryParameters[ODATA_PARAMS.$expand] = expandClause.join(", ");
 
         const orderByClause = this.query.orderProperties;
         if (orderByClause instanceof Array) {
@@ -38,7 +38,7 @@ export class QueryBuilder {
                 if (orderByClause[i] instanceof OrderProperty)
                     order.push(orderByClause[i].getValue());
             }
-            queryParameters[ODATA_PARAMS.$orderby] = order.join(', ');
+            queryParameters[ODATA_PARAMS.$orderby] = order.join(", ");
         }
 
         const take = this.query.takeValue;
@@ -62,10 +62,10 @@ export class QueryBuilder {
 
     private buildComplexExpression(expression: ComplexExpression, parent: string): string {
         if (!(expression instanceof ComplexExpression))
-            throw new Error('Invalid complex expression');
+            throw new Error("Invalid complex expression");
 
         let counter = 0;
-        let result = '';
+        let result = "";
         const subExpressions = expression.getExpressions();
         if (!subExpressions.length) {
             return result;
@@ -79,12 +79,12 @@ export class QueryBuilder {
             else if (currentExp instanceof ComplexExpression) {
                 const complexResult = this.buildComplexExpression(currentExp, expression.type);
                 if (complexResult) {
-                    result += '(' + complexResult + ')';
+                    result += "(" + complexResult + ")";
                 }
             }
 
             if (expression.getType() === EXPRESSION_TYPE.not)
-                result = expression.getType() + ' ' + result;
+                result = expression.getType() + " " + result;
             // TODOSDK: Rethink this!
             if (expression.getType() === EXPRESSION_TYPE.any) {
                 const exprVal = [];
@@ -92,16 +92,16 @@ export class QueryBuilder {
                     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 + ' ') + ')';
+                result = (currentExp as BinaryExpression).parameter + "/" + expression.getType() + "(x:" + exprVal.join(" " + parent + " ") + ")";
             }
 
             counter++;
             if (counter == subExpressions.length)
                 break;
 
-            result += ' ' + expression.getType() + ' ';
+            result += " " + expression.getType() + " ";
         }
 
         return result;
@@ -111,30 +111,30 @@ export class QueryBuilder {
         let result: string = null;
         const type = expression.getType();
         switch (type) {
-            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;
-            }
-            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: {
-                const msg = `Unsupported operator ${type}`;
-                throw new Error(msg);
-            }
+        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;
+        }
+        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: {
+            const msg = `Unsupported operator ${type}`;
+            throw new Error(msg);
+        }
         }
 
         return result;

package/src/Requests/BatchRequest.ts

@@ -1,6 +1,6 @@
 import { RequestFactory } from "./RequestFactory";
-import { BlobBuilder } from '../BlobBuilder';
-import { utils } from '../utils';
+import { BlobBuilder } from "../BlobBuilder";
+import { utils } from "../utils";
 import { HEADER_NAMES, HTTP_METHODS } from "../constants";
 import { ExecutableRequest } from "./ExecutableRequest";
 import { SDKOptions, Token, TypeOptions } from "../Sitefinity";
@@ -77,13 +77,13 @@ export class Transaction {
         const options: PostRequestOptionsExtended = {
             urlOptions: urlOptions,
             key: parameters.key,
-            action: 'operation',
+            action: "operation",
             data: parameters.data
         };
 
         const request = this.factory.create(options);
 
-        this.overrideUrlGeneration(request, parameters.key, 'operation', options.urlOptions, options.query);
+        this.overrideUrlGeneration(request, parameters.key, "operation", options.urlOptions, options.query);
         this.addRequest(request);
     }
 
@@ -147,7 +147,7 @@ export class Transaction {
 
         const request = this.factory.destroyRelated(options);
 
-        const propertyURL = (request as any).property + '/$ref';
+        const propertyURL = (request as any).property + "/$ref";
         this.overrideUrlGeneration(request, parameters.key, propertyURL, options.urlOptions, options.query);
 
         this.addRequest(request);
@@ -191,8 +191,8 @@ export class Transaction {
         }
 
         const data = {
-            '@odata.id': parameters.link
-        }
+            "@odata.id": parameters.link
+        };
 
         const options: RelatedRequestOptionsExtended = {
             urlOptions: urlOptions,
@@ -202,7 +202,7 @@ export class Transaction {
         };
 
         const request = this.factory.createRelated(options);
-        const propertyURL = (request as any).property + '/$ref';
+        const propertyURL = (request as any).property + "/$ref";
         this.overrideUrlGeneration(request, parameters.key, propertyURL, options.urlOptions, options.query);
 
         return this.addRequest(request);
@@ -216,7 +216,7 @@ export class Transaction {
                 request.buildUrl = function () {
                     let uri = "$" + key;
                     if (additionalPropertyURL !== undefined) {
-                        uri = uri + '/' + additionalPropertyURL;
+                        uri = uri + "/" + additionalPropertyURL;
                     }
 
                     if (urlOptions) {
@@ -227,7 +227,7 @@ export class Transaction {
                     }
 
                     return uri;
-                }
+                };
             }
         }
     }
@@ -258,7 +258,7 @@ export class BatchRequest extends ExecutableRequest {
 
 
     public static constants = {
-        newLine: '\r\n'
+        newLine: "\r\n"
     };
 
     constructor(requestOptions: BatchRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
@@ -415,7 +415,7 @@ export class BatchRequest extends ExecutableRequest {
         const queryString = this.getQueryString(this.urlOptions, this.query);
 
         if (queryString) {
-            url += queryString
+            url += queryString;
         }
 
         return url;
@@ -470,7 +470,7 @@ export class BatchRequest extends ExecutableRequest {
                 const responseCheck = function (r) {
                     let success = true;
                     if (r.data && r.data.hasOwnProperty("Success")) {
-                        success = r.data.Success
+                        success = r.data.Success;
                     }
 
                     return success;
@@ -582,10 +582,10 @@ export class BatchRequest extends ExecutableRequest {
         let i, len;
         for (i = 1, len = contentTypeParts.length; i < len; i++) {
             const contentTypeParams = contentTypeParts[i].split("=");
-            properties[contentTypeParams[0].replace(/^\s+|\s+$/g, '')] = contentTypeParams[1];
+            properties[contentTypeParams[0].replace(/^\s+|\s+$/g, "")] = contentTypeParams[1];
         }
 
-        return { mediaType: contentTypeParts[0].replace(/^\s+|\s+$/g, ''), properties: properties };
+        return { mediaType: contentTypeParts[0].replace(/^\s+|\s+$/g, ""), properties: properties };
     }
 
     private readTo(text, str, context) {
@@ -657,7 +657,7 @@ export class BatchRequest extends ExecutableRequest {
 
     private buildRequestBody() {
         const builder = new BlobBuilder();
-        builder.append('');
+        builder.append("");
 
         for (let index = 0; index < this.requests.length; index += 1) {
 
@@ -681,12 +681,12 @@ export class BatchRequest extends ExecutableRequest {
 
     private buildRequest(request: RequestBase): Blob {
         const builder = new BlobBuilder();
-        builder.append(BatchRequest.constants.newLine + 'Content-Type: application/http' +
-                    BatchRequest.constants.newLine + 'Content-Transfer-Encoding: binary' +
+        builder.append(BatchRequest.constants.newLine + "Content-Type: application/http" +
+                    BatchRequest.constants.newLine + "Content-Transfer-Encoding: binary" +
                     BatchRequest.constants.newLine +
                     BatchRequest.constants.newLine +
                     request.getMethod() +
-                    ' ' + request.buildUrl() + ' HTTP/1.1');
+                    " " + request.buildUrl() + " HTTP/1.1");
 
         return builder.build();
     }
@@ -699,7 +699,7 @@ export class BatchRequest extends ExecutableRequest {
         builder.append(BatchRequest.constants.newLine);
 
         const changeset = this.createBoundary("sf_changeset_");
-        builder.append('Content-Type: multipart/mixed; boundary=' + changeset);
+        builder.append("Content-Type: multipart/mixed; boundary=" + changeset);
 
         const changesetRequests = transaction.requests;
         for (let index = 0; index < changesetRequests.length; index += 1) {
@@ -708,12 +708,12 @@ export class BatchRequest extends ExecutableRequest {
             // we shouldn't add new lines after blob content. Otherwise they are added to the blob and corrupt it
             const shouldAddNewLine = index === 0 || !utils.isBlob(changesetRequests[index - 1].request.getBody());
             builder.append(this.createDelimeter(changeset, false, shouldAddNewLine) +
-                        BatchRequest.constants.newLine + 'Content-Type: application/http' +
-                        BatchRequest.constants.newLine + 'Content-Transfer-Encoding: binary' +
-                        BatchRequest.constants.newLine + 'Content-ID: ' + changesetRequests[index].id);
+                        BatchRequest.constants.newLine + "Content-Type: application/http" +
+                        BatchRequest.constants.newLine + "Content-Transfer-Encoding: binary" +
+                        BatchRequest.constants.newLine + "Content-ID: " + changesetRequests[index].id);
 
             const requestUrl = currentRequest.buildUrl();
-            builder.append(BatchRequest.constants.newLine + BatchRequest.constants.newLine + currentRequest.getMethod() + ' ' + requestUrl + ' HTTP/1.1');
+            builder.append(BatchRequest.constants.newLine + BatchRequest.constants.newLine + currentRequest.getMethod() + " " + requestUrl + " HTTP/1.1");
 
             const headers = currentRequest.getHeaders();
             const headerNames = Object.keys(headers);
@@ -749,7 +749,7 @@ export class BatchRequest extends ExecutableRequest {
     }
 
     private createBoundary(prefix) {
-        return prefix + utils.hex16() + '-' + utils.hex16() + '-' + utils.hex16();
+        return prefix + utils.hex16() + "-" + utils.hex16() + "-" + utils.hex16();
     }
 
     private addRequest(request: RequestBase) {

package/src/Requests/ExecutableRequest.ts

@@ -1,11 +1,13 @@
-import { RequestBase, RequestOptionsBaseExtended } from './RequestBase';
-import { utils } from '../utils';
+import { RequestBase, RequestOptionsBaseExtended } from "./RequestBase";
+import { utils } from "../utils";
 import { HEADER_NAMES } from "../constants";
 import { SDKOptions, Token } from "../Sitefinity";
 
 const XMLHttpRequestDone = 4;
 
 export class ExecutableRequest extends RequestBase {
+    protected http: XMLHttpRequest;
+
     private token: Token;
     private enableUnlimitedChoices: boolean;
     private integrationMode: boolean;
@@ -20,20 +22,19 @@ export class ExecutableRequest extends RequestBase {
     }
 
     execute() {
-        const http = new XMLHttpRequest();
-
-        http.onreadystatechange = () => {
-            if (http.readyState === XMLHttpRequestDone) {
-                if (http.status > 0) {
-                    let data = this.parseResponse(http);
+        this.http = new XMLHttpRequest();
 
-                    if (http.status >= 200 && http.status <= 206) {
+        this.http.onreadystatechange = () => {
+            if (this.http.readyState === XMLHttpRequestDone) {
+                if (this.http.status > 0) {
+                    let data = this.parseResponse(this.http);
 
-                        if (utils.isFunction(this.successCb)) {
+                    if (this.http.status >= 200 && this.http.status <= 206) {
+                        if (this.successCb && utils.isFunction(this.successCb)) {
                             this.successCb(data);
                         }
                     }
-                    else if (http.status >= 400) {
+                    else if (this.http.status >= 400) {
                         // When the data is string, we save the string as message
                         // and convert the data to normal object with message property
                         if (utils.isString(data)) {
@@ -42,10 +43,10 @@ export class ExecutableRequest extends RequestBase {
                             };
                         }
 
-                        data.status = http.status;
+                        data.status = this.http.status;
 
                         // in case of errors we would like there to be one handler for all of the errors
-                        if (utils.isFunction(this.failureCb)) {
+                        if (this.failureCb && utils.isFunction(this.failureCb)) {
                             this.failureCb(data);
                         }
                     }
@@ -53,20 +54,25 @@ export class ExecutableRequest extends RequestBase {
             }
         };
 
-        if (utils.isFunction(this.progressCb)) {
-            if (http.upload) {
-                http.upload.onprogress = (event) => {
-                    this.progressCb(event);
-                };
-            }
-        }
+
+        this.executeProgressEvent();
 
         const method = this.getMethod();
         const url = this.buildUrl();
-        http.open(method, url, true);
-        this.setHeaders(http, this.getHeaders());
+        this.http.open(method, url, true);
+        this.setHeaders(this.http, this.getHeaders());
 
-        http.send(utils.serializeToJSON(this.getBody()));
+        this.http.send(utils.serializeToJSON(this.getBody()));
+    }
+
+    protected executeProgressEvent() {
+        if (this.http.upload) {
+            this.http.upload.onprogress = (event) => {
+                if (this.progressCb && utils.isFunction(this.progressCb)) {
+                    this.progressCb(event);
+                }
+            };
+        }
     }
 
     private setHeaders(http: XMLHttpRequest, headers: { [key: string]: string }) {
@@ -77,7 +83,7 @@ export class ExecutableRequest extends RequestBase {
         }
 
         if (this.token) {
-            if (typeof this.token === 'string') {
+            if (typeof this.token === "string") {
                 // for backward compatibility
                 http.setRequestHeader(HEADER_NAMES.authorization, this.token);
             } else {

package/src/Requests/Request.ts

@@ -1,6 +1,6 @@
 import { HEADER_NAMES, HTTP_METHODS } from "../constants";
 import { SDKOptions, Token } from "../Sitefinity";
-import { utils } from '../utils';
+import { utils } from "../utils";
 import { ExecutableRequest } from "./ExecutableRequest";
 import { RequestOptionsBaseExtended } from "./RequestBase";
 
@@ -120,7 +120,7 @@ export class DeleteRelatedRequest extends DeleteRequest {
     }
 
     buildUrl(): string {
-        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "/$ref"
+        const url = this.urlOptions.baseUrl + this.urlOptions.entitySet + "(" + this.key + ")/" + this.property + "/$ref";
         return this.addQueryParameters(url);
     }
 }
@@ -190,6 +190,91 @@ export class UploadRequest extends CreateRequest {
     }
 }
 
+export class UploadChunkRequest extends CreateRequest {
+    contentType: string;
+    chunkOrdinal: number;
+    chunkSize: number;
+    chunkedFileUploadSessionId: string;
+    numberOfChunks: number;
+    positionInQueue: number;
+    blobStorageProviderName: string;
+
+    constructor(requestOptions: UploadChunkRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+        this.contentType = requestOptions.fileMimeType;
+        this.chunkOrdinal = requestOptions.chunkOrdinal;
+        this.chunkedFileUploadSessionId = requestOptions.chunkedFileUploadSessionId;
+        this.chunkSize = requestOptions.chunkSize;
+        this.numberOfChunks = requestOptions.numberOfChunks;
+        this.positionInQueue = requestOptions.positionOfChunkInQueue;
+        this.blobStorageProviderName = requestOptions.blobStorageProviderName;
+        this.data = requestOptions.chunkBlob;
+    }
+
+    getHeaders(): { [key: string]: string } {
+        const headers = super.getHeaders();
+        headers[HEADER_NAMES.contentEncoding] = "identity";
+        headers[HEADER_NAMES.contentType] = this.contentType || "application/octet-stream";
+        headers[HEADER_NAMES.chunkOrdinal] = this.chunkOrdinal.toString();
+        headers[HEADER_NAMES.chunkedFileUploadSessionId] = this.chunkedFileUploadSessionId;
+        headers[HEADER_NAMES.chunkSize] = this.chunkSize.toString();
+        headers[HEADER_NAMES.blobStorageProviderName] = this.blobStorageProviderName.toString();
+
+        return headers;
+    }
+
+    getBody(): object {
+        return this.data;
+    }
+
+    getMethod(): string {
+        return HTTP_METHODS.post;
+    }
+
+    protected override executeProgressEvent(): void {
+        if (this.http.upload) {
+            this.http.upload.onprogress = () => {
+                const payload = {
+                    lengthComputable: true,
+                    loaded: this.positionInQueue,
+                    total: this.numberOfChunks
+                };
+
+                if (this.progressCb && utils.isFunction(this.progressCb)) {
+                    this.progressCb(payload);
+                }
+            };
+        }
+    }
+}
+
+export class CommitChunksRequest extends CreateRequest {
+    constructor(requestOptions: CommitChunksRequestOptionsExtended, token: Token, sdkOptions: SDKOptions) {
+        super(requestOptions, token, sdkOptions);
+
+        this.action = "Default.CommitChunks";
+
+        this.data = {
+            // ! this must be the param name that the operation provider on the server accepts
+            commitChunksDto: {
+                chunkedFileUploadSessionId: requestOptions.chunkedFileUploadSessionId,
+                contentType: requestOptions.contentType,
+                fileTotalSize: requestOptions.fileTotalSize,
+                numberOfChunks: requestOptions.numberOfChunks,
+                fileName: requestOptions.fileName,
+                blobStorageProviderName: requestOptions.blobStorageProviderName,
+                itemId: requestOptions.itemId || null,
+                // ! must be named properties
+                properties: requestOptions.uploadProperties
+            }
+        };
+    }
+
+    getMethod(): string {
+        return HTTP_METHODS.post;
+    }
+}
+
 export interface PostRequestOptionsExtended extends RequestOptionsBaseExtended {
     data?: object;
 }
@@ -211,3 +296,25 @@ export interface UploadRequestOptionsExtended extends PostRequestOptionsExtended
     contentType: string;
     uploadProperties: { [key: string]: string };
 }
+
+export interface UploadChunkRequestOptionsExtended extends PostRequestOptionsExtended {
+    fileMimeType: string;
+    chunkedFileUploadSessionId: string;
+    chunkSize: number;
+    chunkOrdinal: number;
+    numberOfChunks: number;
+    chunkBlob: Blob;
+    blobStorageProviderName: string;
+    positionOfChunkInQueue?: number;
+}
+
+export interface CommitChunksRequestOptionsExtended extends PostRequestOptionsExtended {
+    chunkedFileUploadSessionId: string
+    blobStorageProviderName: string;
+    contentType: string;
+    fileTotalSize: number;
+    numberOfChunks: number;
+    fileName: string;
+    uploadProperties: { [key: string]: string };
+    itemId?: string;
+}

package/src/Requests/RequestBase.ts

@@ -2,7 +2,7 @@ import { CONTENT_TYPES, HEADER_NAMES, ODATA_PARAMS, SF_PARAMS } from "../constan
 import { RequestOptionsBase } from "../Data";
 import { Query } from "../Query";
 import { TypeOptions } from "../Sitefinity";
-import { utils } from '../utils';
+import { utils } from "../utils";
 
 export class RequestBase {
     public successCb: Function;
@@ -11,14 +11,14 @@ export class RequestBase {
     public key: string | number;
     public urlOptions: TypeOptions;
     protected query: Query;
-    private action: string;
+    protected action: string;
     private fallbackProperties: string[];
 
     constructor(options: RequestOptionsBaseExtended) {
         this.successCb = options.successCb;
         this.failureCb = options.failureCb;
-        this.urlOptions = options.urlOptions;
         this.progressCb = options.progressCb;
+        this.urlOptions = options.urlOptions;
         this.key = options.key;
         this.action = options.action;
         this.fallbackProperties = options.fallbackProperties;
@@ -156,6 +156,5 @@ export class RequestBase {
 }
 
 export interface RequestOptionsBaseExtended extends RequestOptionsBase {
-    progressCb?: Function;
     urlOptions: TypeOptions;
 }

package/src/Requests/RequestFactory.ts

@@ -1,4 +1,4 @@
-import { GetRequest, GetByIdRequest, CreateRequest, UpdateRequest, DeleteRequest, GetRelatedRequest, GetRelatedByIdRequest, DeleteRelatedRequest, DeleteRelatedByIdRequest, CreateRelatedRequest, UploadRequest, PostRequestOptionsExtended, PutRequestOptionsExtended, RelatedRequestOptionsExtended, RelatedByIdRequestOptionsExtended, UploadRequestOptionsExtended } from "./Request";
+import { GetRequest, GetByIdRequest, CreateRequest, UpdateRequest, DeleteRequest, GetRelatedRequest, GetRelatedByIdRequest, DeleteRelatedRequest, DeleteRelatedByIdRequest, CreateRelatedRequest, UploadRequest, PostRequestOptionsExtended, PutRequestOptionsExtended, RelatedRequestOptionsExtended, RelatedByIdRequestOptionsExtended, UploadRequestOptionsExtended, UploadChunkRequest, CommitChunksRequest, CommitChunksRequestOptionsExtended, UploadChunkRequestOptionsExtended } from "./Request";
 import { SDKOptions, Token } from "../Sitefinity";
 import { BatchRequest, BatchRequestOptionsExtended } from "./BatchRequest";
 import { RequestOptionsBaseExtended } from "./RequestBase";
@@ -59,6 +59,14 @@ export class RequestFactory {
         return new UploadRequest(parameters, this.token, this.options);
     }
 
+    uploadChunk(parameters: UploadChunkRequestOptionsExtended) {
+        return new UploadChunkRequest(parameters, this.token, this.options);
+    }
+
+    commitChunks(parameters: CommitChunksRequestOptionsExtended) {
+        return new CommitChunksRequest(parameters, this.token, this.options);
+    }
+
     batch(parameters: RequestOptionsBaseExtended) {
         const batchParams = parameters as BatchRequestOptionsExtended;
         batchParams.factory = this;

package/src/Requests/request.spec.ts

@@ -2,7 +2,7 @@ import { Query } from "../Query";
 import { Sitefinity } from "../Sitefinity";
 
 describe("SDK basic tests", () => {
-    const baseUrl = "http://www.mysite.com/api/default/"
+    const baseUrl = "http://www.mysite.com/api/default/";
     let sitefinity: Sitefinity;
     let query: Query;
 
@@ -23,13 +23,13 @@ describe("SDK basic tests", () => {
     });
 
     it("query assert", () => {
-        const testQuery = (query.where().and().endsWith("Title", "Record").done() as any).or().startsWith('Title', 'asd').done().done();
+        const testQuery = (query.where().and().endsWith("Title", "Record").done() as any).or().startsWith("Title", "asd").done().done();
         const resultingQuery = testQuery.build();
         expect(resultingQuery.$filter).toEqual("(endswith(Title, 'Record')) and (startswith(Title, 'asd'))");
     });
 
     it("complex query assert", () => {
-        const testQuery = query.where().not().endsWith("Record", "Title").done().and().not().eq('Content', 'test').done().done().done();
+        const testQuery = query.where().not().endsWith("Record", "Title").done().and().not().eq("Content", "test").done().done().done();
         const resultingQuery = testQuery.build();
         expect(resultingQuery.$filter).toEqual("(not endswith(Record, 'Title')) and ((not (Content eq 'test')))");
     });
@@ -42,12 +42,12 @@ describe("SDK basic tests", () => {
         data.get({query: query.count(false)});
 
         let request = jasmine.Ajax.requests.mostRecent();
-        expect(request.url).toBe('http://www.mysite.com/api/default/newsitems/$count');
+        expect(request.url).toBe("http://www.mysite.com/api/default/newsitems/$count");
 
         data.get({query: query.count(true)});
 
         request = jasmine.Ajax.requests.mostRecent();
-        expect(request.url).toBe('http://www.mysite.com/api/default/newsitems?$count=true');
+        expect(request.url).toBe("http://www.mysite.com/api/default/newsitems?$count=true");
     });
 
     it("request assert", () => {
@@ -58,14 +58,14 @@ describe("SDK basic tests", () => {
         }).get({query: null});
 
         const request = jasmine.Ajax.requests.mostRecent();
-        expect(request.url).toBe('http://www.mysite.com/api/default/newsitems?sf_provider=newsProvider&sf_culture=en-US');
-        expect(request.method).toBe('GET');
+        expect(request.url).toBe("http://www.mysite.com/api/default/newsitems?sf_provider=newsProvider&sf_culture=en-US");
+        expect(request.method).toBe("GET");
         expect(request.data()).toEqual({});
     });
 
     it("batch assert", async () => {
         const batch = sitefinity.batch();
-        const getQuery = query.where().eq('Title', 'newTitleN11').done();
+        const getQuery = query.where().eq("Title", "newTitleN11").done();
 
         batch.get({
             entitySet: "newsitems",
@@ -83,8 +83,8 @@ describe("SDK basic tests", () => {
         (batch as any).execute();
 
         const request = jasmine.Ajax.requests.mostRecent();
-        expect(request.url).toBe('http://www.mysite.com/api/default/$batch');
-        expect(request.method).toBe('POST');
+        expect(request.url).toBe("http://www.mysite.com/api/default/$batch");
+        expect(request.method).toBe("POST");
 
         await readBlobAsText(request.params).then((result) => {
             expect(result).toContain("{\"title\":\"Test\"}");