@progress/sitefinity-webservices-sdk 0.3.1 → 1.0.3

package/src/Sitefinity.ts

@@ -1,183 +1,114 @@
 import { RequestFactory } from './Requests/RequestFactory';
-import { Authentication } from './Authentication';
 import { Data } from './Data';
 import { Query } from './Query';
 import { utils } from './utils';
+import { ResponseHandlers } from "./Requests/ExecutableRequest";
+import { BatchRequest } from "./Requests/BatchRequest";
 
-/**
-* @class Sitefinity
-* @classdesc The constructor of the Sitefinity JavaScript SDK. This is the entry point for the SDK.
-* @property {Object} authentication - The authentication object used for authenticating to Sitefinity. See {@link Authentication}
-* @param {object} options - An object containing configuration options for the Setup object.
-* @param {string} options.serviceUrl - Your service url that points to the configured instance of Sitefinity service.
-* @param {string} options.siteId - The ID of the site, for which the query will be executed.
-* @param {string} options.handlers - The global handlers for request execution
-* @param {string} options.handlers.successCb - The success handler.
-* @param {string} options.handlers.failureCb - The failure handler.
-*/
 export class Sitefinity {
+    public static Query: typeof Query = Query;
+
     private factory: RequestFactory;
-    private authentication: Authentication;
-    private profileUrl: string;
+    private baseUrl: string;
     private siteId: string;
-    public static Query: typeof Query = Query;
 
-    constructor(options: any) {
-        this.profileUrl = utils.addTrailingSlash(options.serviceUrl);
+    /**
+    * The constructor of the Sitefinity JavaScript SDK. This is the entry point for the SDK.
+    */
+    constructor(options: SDKOptions) {
+        this.baseUrl = options.baseUrl;
         this.siteId = options.siteId;
-        this.factory = new RequestFactory({
-            handlers: options.handlers,
-            enableUnlimitedChoices: options.enableUnlimitedChoices,
-            integrationMode: options.integrationMode
-        });
-
-        this.authentication = new Authentication({
-            serviceUrl: this.profileUrl,
-            factory: this.factory
-        });
+        this.factory = new RequestFactory(options);
     }
 
-    /**
-* Creates a new {@link Data} class.
-* @memberOf Sitefinity
-* @instance
-* @param {object} options - An object containing configuration options for the Setup object.
-* @param {string} options.urlName - The URL name of the type..
-* @param {string} [options.providerName] - The name of the provider. If empty the default provider for the site will be used.
-* @param {string} [options.cultureName] - The name of the culture. If empty the default culture for the site will be used.
-* @example
-* var data = sf.data({
-*     urlName: "newsitems",
-*     providerName: "OpenAccessDataProvider",
-*     cultureName: "en"
-* });
-* @returns {Data}
-*/
-    data(options: any) {
-        var optionsServiceUrl = options.serviceUrl ? utils.addTrailingSlash(options.serviceUrl) : options.serviceUrl;
-        var dataOptions = {
-            baseUrl: optionsServiceUrl || this.profileUrl,
-            SFParams: {
-                provider: options.providerName,
-                culture: options.cultureName,
-                siteId: options.siteId || this.siteId
-            },
+    data(options: TypeOptions): Data {
+        const urlOptions: TypeOptions = {
+            baseUrl: utils.addTrailingSlash(options.baseUrl || this.baseUrl),
+            provider: options.provider,
+            culture: options.culture,
+            siteId: options.siteId || this.siteId,
             additionalQueryParams: options.additionalQueryParams,
-            entitySet: options.urlName
+            entitySet: options.entitySet
         }
 
-        this.factory.token = this.authentication.getToken();
-        return new Data(dataOptions, this.factory);
+        return new Data(urlOptions, this.factory);
     }
 
-    /**
-    * Creates a new {@link BatchRequest} class. OData batch requests -> {@link http://docs.oasis-open.org/odata/odata/v4.0/os/part1-protocol/odata-v4.0-os-part1-protocol.html#_Toc372793748}
-    * @memberOf Sitefinity
-    * @instance
-    * @param {Function} success - The success callback of the batch execution.
-    * @param {string} options.urlName - The URL name of the type..
-    * @param {string} [options.providerName] - The name of the provider. If empty the default provider for the site will be used.
-    * @param {string} [options.cultureName] - The name of the culture. If empty the default culture for the site will be used.
-    * @example
-    * var sf = new Sitefinity({
-    *   serviceUrl: 'http://mydomain/route/service/'
-    * });
-    *
-    * var batch = sf.batch(successCbBatch, failureCb);
-    * batch.get({
-    *     entitySet: entitySet,
-    *     query: query8
-    * });
-    *
-    * var transaction = batch.beginTransaction();
-    * var createId = transaction.create({
-    *     entitySet: entitySet,
-    *     data: newsItem
-    * });
-    *
-    * batch.endTransaction(transaction);
-    *
-    * var transaction2 = batch.beginTransaction();
-    * var createId2 = transaction2.create({
-    *     entitySet: entitySet,
-    *     data: newsItem
-    * });
-    *
-    * var updateId2 = transaction2.update({
-    *     entitySet: entitySet,
-    *     key: createId2,
-    *     data: newsItemUpdate
-    * });
-    *
-    * batch.endTransaction(transaction2);
-    *
-    * batch.get({
-    *     entitySet: entitySet
-    * });
-    *
-    * batch.execute();
-    * @returns {BatchRequest}
-    */
-    batch(success: any, failure: any, progress: any, options: any) {
-        if (typeof progress !== 'function') {
-            options = progress;
-            progress = null;
-        }
-
+    batch(success?: Function, failure?: Function, progress?: Function, options?: TypeOptions): BatchRequest {
         if (!options)
             options = {};
 
-        this.factory.token = this.authentication.getToken();
-
-        var optionsServiceUrl = options.serviceUrl ? utils.addTrailingSlash(options.serviceUrl) : options.serviceUrl;
-        var batch = this.factory.batch({
+        const batch = this.factory.batch({
             successCb: success,
             failureCb: failure,
             progressCb: progress,
             urlOptions: {
-                baseUrl: optionsServiceUrl || this.profileUrl,
-                SFParams: {
-                    provider: options.providerName,
-                    culture: options.cultureName,
-                    siteId: options.siteId || this.siteId
-                },
+                baseUrl: utils.addTrailingSlash(options.baseUrl || this.baseUrl),
+                provider: options.provider,
+                culture: options.culture,
+                siteId: options.siteId || this.siteId,
                 additionalQueryParams: options.additionalQueryParams
             }
         });
 
-        var executor: any = this.factory.createExecutor(batch);
-        executor.beginTransaction = () => {
-            return batch.beginTransaction();
-        }
+        return batch;
+    }
 
-        executor.endTransaction = (transaction) => {
-            batch.endTransaction(transaction);
-        }
+    /**
+    * Sets the authentication token.
+    */
+    setToken(token: Token) {
+        this.factory.token = token;
+    }
+}
 
-        executor.get = (options) => {
-            batch.constructor.prototype.get.call(batch, options);
-        }
+interface OptionsBase {
+    /**
+    * Your service url that points to the configured instance of Sitefinity service.
+    */
+    baseUrl?: string;
 
-        executor.getOperations = (options) => {
-            batch.constructor.prototype.getOperations.call(batch, options);
-        }
+    /**
+    * The ID of the site, for which the queries will be executed.
+    */
+    siteId?: string;
+}
 
-        executor.getSingle = (options) => {
-            batch.constructor.prototype.getSingle.call(batch, options);
-        }
+/**
+* Defines an object containing configuration options for the SDK object.
+*/
+export interface SDKOptions extends OptionsBase {
+    /**
+    * The global handlers for request execution
+    */
+    handlers?: ResponseHandlers;
 
-        executor.getProperty = (options) => {
-            batch.constructor.prototype.getProperty.call(batch, options);
-        }
+    enableUnlimitedChoices?: boolean;
+    integrationMode?: boolean;
+}
 
-        executor.getRelated = (options) => {
-            batch.constructor.prototype.getRelated.call(batch, options);
-        }
+/**
+* Defines an object containing configuration options related to a specific type.
+*/
+export interface TypeOptions extends OptionsBase {
+    /**
+    * The URL name of the type.
+    */
+    entitySet?: string;
 
-        executor.getRelatedById = (options) => {
-            batch.constructor.prototype.getRelatedById.call(batch, options);
-        }
+    /**
+    * The name of the provider. If empty the default provider for the site will be used.
+    */
+    provider?: string;
 
-        return executor;
-    }
+    /**
+    * The name of the culture. If empty the default culture for the site will be used.
+    */
+    culture?: string;
+    additionalQueryParams?: { [key: string]: string };
+}
+
+export interface Token {
+    type: string;
+    value: string;
 }

package/src/WhereQuery.ts

@@ -1,198 +1,138 @@
 import { ComplexExpression, BinaryExpression } from './Expression';
-const OperatorType = require('./constants').default.ExpressionType;
+import { EXPRESSION_TYPE } from "./constants";
 
 /**
- * @classdesc A fluent API operation for creating a filter for a query by chaining different rules.
- * @class WhereQuery
- * @protected
+ * A fluent API operation for creating a filter for a query by chaining different rules.
  */
-export class WhereQuery {
-
+export class WhereQuery<QueryType> {
     private expression: ComplexExpression;
-    constructor(private parent: any, type: string = OperatorType.and) {
+
+    constructor(private parent: QueryType, type: string = EXPRESSION_TYPE.and) {
         this.expression = new ComplexExpression(type, []);
     }
 
     /**
     * Adds an `and` clause to the current condition and returns it for further chaining.
-    * @method and
-    * @memberOf WhereQuery.prototype
-    * @returns {WhereQuery}
     */
-    and(): WhereQuery {
-        return new WhereQuery(this, OperatorType.and);
+    and(): WhereQuery<WhereQuery<QueryType>> {
+        return new WhereQuery(this, EXPRESSION_TYPE.and);
     }
+
     /**
      * Adds an `or` clause to the current condition and returns it for further chaining.
-     * @method or
-     * @memberOf WhereQuery.prototype
-     * @returns {WhereQuery}
      */
-    or(): WhereQuery {
-        return new WhereQuery(this, OperatorType.or);
+    or(): WhereQuery<WhereQuery<QueryType>> {
+        return new WhereQuery(this, EXPRESSION_TYPE.or);
     }
 
     /**
      * Adds an `any` clause to the current condition and returns it for further chaining.
-     * @method any
-     * @memberOf WhereQuery.prototype
-     * @returns {WhereQuery}
      */
-    any(): WhereQuery {
-        return new WhereQuery(this, OperatorType.any);
+    any(): WhereQuery<WhereQuery<QueryType>> {
+        return new WhereQuery(this, EXPRESSION_TYPE.any);
     }
+
     /**
      * Adds a `not` clause to the current condition and returns it for further chaining.
-     * @method not
-     * @memberOf WhereQuery.prototype
-     * @returns {WhereQuery}
      */
-    not(): WhereQuery {
-        return new WhereQuery(this, OperatorType.not);
-    }
-
-    private _simple(type: string, parameter: string, constant: any, caseSensitive: boolean = true): WhereQuery {
-        var currentExpr = new BinaryExpression(type, parameter, constant, caseSensitive);
-        var subExpressions = this.expression.getExpressions();
-        subExpressions.push(currentExpr);
-
-        if (this.expression.getType() === OperatorType.not && subExpressions.length > 1)
-            throw new Error("Invalid operators count!");
-
-        return this;
+    not(): WhereQuery<WhereQuery<QueryType>> {
+        return new WhereQuery(this, EXPRESSION_TYPE.not);
     }
 
     /**
      * Adds a condition that a field must be equal to a specific value.
-     * @method eq
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {*} value Comparison value (to which the fields must be equal).
-     * @returns {WhereQuery}
      */
-    eq(parameter: string, constant: any): WhereQuery {
-        return this._simple(OperatorType.eq, parameter, constant);
+    eq(parameter: string, constant: any): WhereQuery<QueryType> {
+        return this.simple(EXPRESSION_TYPE.eq, parameter, constant);
     }
+
     /**
      * Adds a condition that a field must *not* be equal to a specific value.
-     * @method ne
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {*} value Comparison value (to which the field must not be equal).
-     * @returns {WhereQuery}
      */
-    ne(parameter: string, constant: any): WhereQuery {
-        return this._simple(OperatorType.ne, parameter, constant);
+    ne(parameter: string, constant: any): WhereQuery<QueryType> {
+        return this.simple(EXPRESSION_TYPE.ne, parameter, constant);
     }
+
     /**
      * Adds a condition that a field must be `greater than` a certain value. Applicable to Number, String, and Date fields.
-     * @method gt
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {*} value Comparison value (that the field should be greater than).
-     * @returns {WhereQuery}
      */
     gt(parameter: string, constant: any) {
-        return this._simple(OperatorType.gt, parameter, constant);
+        return this.simple(EXPRESSION_TYPE.gt, parameter, constant);
     }
+
     /**
      * Adds a condition that a field must be `greater than or equal` to a certain value. Applicable to Number, String, and Date fields.
-     * @method gte
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {*} value Comparison value (that the field should be greater than or equal to).
-     * @returns {WhereQuery}
      */
     gte(parameter: string, constant: any) {
-        return this._simple(OperatorType.ge, parameter, constant);
+        return this.simple(EXPRESSION_TYPE.ge, parameter, constant);
     }
+
     /**
      * Adds a condition that a field must be `less than` a certain value. Applicable to Number, String, and Date fields.
-     * @method lt
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {*} value Comparison value (that the field should be less than).
-     * @returns {WhereQuery}
      */
     lt(parameter: string, constant: any) {
-        return this._simple(OperatorType.lt, parameter, constant);
+        return this.simple(EXPRESSION_TYPE.lt, parameter, constant);
     }
+
     /**
      * Adds a condition that a field must be `less than or equal` to a certain value. Applicable to Number, String, and Date fields.
-     * @method lte
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {*} value Comparison value (that the field should be less than or equal to).
-     * @returns {WhereQuery}
      */
     lte(parameter: string, constant: any) {
-        return this._simple(OperatorType.le, parameter, constant);
+        return this.simple(EXPRESSION_TYPE.le, parameter, constant);
     }
+
     /**
      * Adds a condition that a field value must *start* with a specified string.
-     * @method startsWith
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {string} value The string that the field should start with.
-     * @param {boolean} caseSensitive A flag indicating if tolower should be applied to the parameter
-     * @param {string} [options] A string of regex options to use. See [specs](http://docs.mongodb.org/manual/reference/operator/query/regex/#op._S_options) for a description of available options.
-     * @returns {WhereQuery}
      */
-    startsWith(parameter: string, constant: any, caseSensitive: boolean = true): WhereQuery {
-        return this._simple(OperatorType.startsWith, parameter, constant, caseSensitive);
+    startsWith(parameter: string, constant: any, caseSensitive = true) {
+        return this.simple(EXPRESSION_TYPE.startsWith, parameter, constant, caseSensitive);
     }
 
     /**
      * Adds a condition that a field value must *contain* a specified string.
-     * @method startsWith
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {string} value The string that the field should start with.
-     * @param {boolean} caseSensitive A flag indicating if tolower should be applied to the parameter
-     * @param {string} [options] A string of regex options to use. See [specs](http://docs.mongodb.org/manual/reference/operator/query/regex/#op._S_options) for a description of available options.
-     * @returns {WhereQuery}
      */
-    contains(parameter: string, constant: any, caseSensitive: boolean = true) {
-        return this._simple(OperatorType.contains, parameter, constant, caseSensitive);
+    contains(parameter: string, constant: any, caseSensitive = true) {
+        return this.simple(EXPRESSION_TYPE.contains, parameter, constant, caseSensitive);
     }
 
     /**
      * Adds a condition that a field value must *end* with a specified string.
-     * @method endsWith
-     * @memberOf WhereQuery.prototype
-     * @param {string} field Field name.
-     * @param {string} value The string that the field should end with.
-     * @param {boolean} caseSensitive A flag indicating if tolower should be applied to the parameter
-     * @param {string} [options] A string of  regex options to use. See [specs](http://docs.mongodb.org/manual/reference/operator/query/regex/#op._S_options) for a description of available options.
-     * @returns {WhereQuery}
      */
-    endsWith(parameter: string, constant: any, caseSensitive: boolean = true) {
-        return this._simple(OperatorType.endsWith, parameter, constant, caseSensitive);
+    endsWith(parameter: string, constant: any, caseSensitive = true) {
+        return this.simple(EXPRESSION_TYPE.endsWith, parameter, constant, caseSensitive);
     }
 
     /**
      * Ends the definition of the current WhereQuery. You need to call this method in order to continue with the definition of the parent {@link QueryBase}. All other `WhereQuery` methods return the current instance of `WhereQuery` to allow chaining.
-     * @method done
-     * @memberOf WhereQuery.prototype
-     * @returns {Query}
      */
-    done() {
+    done(): QueryType {
         if (this.parent instanceof WhereQuery) {
-            this.parent._addComplexExpression(this);
+            this.parent.addComplexExpression(this);
             // TODO: If has and() || or() must call done() twice
-            if (this.expression.getType() === OperatorType.not)
+            if (this.expression.getType() === EXPRESSION_TYPE.not)
                 return this.parent;
         }
 
         return this.parent;
     }
 
-    _getExpression() {
+    getExpression(): ComplexExpression {
         return this.expression;
     }
 
-    private _addComplexExpression(subQuery): void {
-        var subExpression = subQuery._getExpression();
+    private simple(type: string, parameter: string, constant: any, caseSensitive = true): WhereQuery<QueryType> {
+        const currentExpr = new BinaryExpression(type, parameter, constant, caseSensitive);
+        const subExpressions = this.expression.getExpressions();
+        subExpressions.push(currentExpr);
+
+        if (this.expression.getType() === EXPRESSION_TYPE.not && subExpressions.length > 1)
+            throw new Error("Invalid operators count!");
+
+        return this;
+    }
+
+    private addComplexExpression(subQuery: WhereQuery<QueryType>): void {
+        const subExpression = subQuery.getExpression();
         this.expression.getExpressions().push(subExpression);
     }
 }

package/src/constants.ts

@@ -1,41 +1,60 @@
-const constants = {
-    ExpressionType: {
-        query: 1,
-        where: 100,
-        and: 'and',
-        or: 'or',
-        not: 'not',
-        eq: 'eq',
-        ne: 'ne',
-        lt: 'lt',
-        le: 'le',
-        gt: 'gt',
-        ge: 'ge',
-        any: 'any',
-        /*isin: 126,
-        notin: 127,
-        all: 128,
-        size: 129,
-        regex: 130,*/
-        contains: 'contains',
-        startsWith: 'startsWith',
-        endsWith: 'endsWith'
-    },
-    ODataParams: {
-        $filter: '$filter',
-        $select: '$select',
-        $expand: '$expand',
-        $orderby: '$orderby',
-        $skip: '$skip',
-        $top: '$top',
-        $count: '$count',
-        $search: '$search'
-    },
-    SfParams: {
-        provider: 'sf_provider',
-        culture: 'sf_culture',
-        siteId: 'sf_site'
-    }
+export const EXPRESSION_TYPE = {
+    query: 1,
+    where: 100,
+    and: 'and',
+    or: 'or',
+    not: 'not',
+    eq: 'eq',
+    ne: 'ne',
+    lt: 'lt',
+    le: 'le',
+    gt: 'gt',
+    ge: 'ge',
+    any: 'any',
+    contains: 'contains',
+    startsWith: 'startsWith',
+    endsWith: 'endsWith'
+}
+
+export const ODATA_PARAMS = {
+    $filter: '$filter',
+    $select: '$select',
+    $expand: '$expand',
+    $orderby: '$orderby',
+    $skip: '$skip',
+    $top: '$top',
+    $count: '$count',
+    $search: '$search'
+}
+
+export const SF_PARAMS = {
+    provider: 'sf_provider',
+    culture: 'sf_culture',
+    siteId: 'sf_site',
+    fallbackParams: "sf_fallback_prop_names",
+    parentId: "parentId"
+}
+
+export const HEADER_NAMES = {
+    contentType: "Content-Type",
+    authorization: "Authorization",
+    contentEncoding: "Content-Encoding",
+    operation: "X-Operation",
+    properties: "X-Sf-Properties",
+    fileName: "X-File-Name",
+    serviceRequest: "X-SF-Service-Request",
+    choicesBinaryRepresentation: "X-SF-Binary-Choice-Representation",
+    integrationMode: "X-SF-Integration-Mode"
+}
+
+export const HTTP_METHODS = {
+    get: "GET",
+    put: "PUT",
+    post: "POST",
+    patch: "PATCH",
+    delete: "DELETE"
 };
 
-export default constants;
+export const CONTENT_TYPES = {
+    json: "application/json"
+}