relution-sdk
Version:
Relution Software Development Kit for TypeScript and JavaScript
267 lines • 33.3 kB
JavaScript
/*
* @file livedata/Store.ts
* Relution SDK
*
* Created by Thomas Beckmann on 24.06.2015
* Copyright 2016 M-Way Solutions GmbH
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/**
* @module livedata
*/
/** */
"use strict";
var Backbone = require('backbone');
var _ = require('lodash');
var Q = require('q');
var diag = require('../core/diag');
var Model_1 = require('./Model');
var Collection_1 = require('./Collection');
/**
* tests whether a given object is a Store.
*
* @param {object} object to check.
* @return {boolean} whether object is a Store.
*/
function isStore(object) {
if (!object || typeof object !== 'object') {
return false;
}
else if ('isStore' in object) {
diag.debug.assert(function () { return object.isStore === Store.prototype.isPrototypeOf(object); });
return object.isStore;
}
else {
return Store.prototype.isPrototypeOf(object);
}
}
exports.isStore = isStore;
/**
* base class to build a custom data store.
*/
var Store = (function () {
function Store(options) {
/**
* stores Model and Collection constructors by entity name.
*
* @see Store#makeModel
* @see Store#makeCollection
*/
this.implementations = {};
if (options) {
// copy options values into the object
_.extend(this, options);
}
}
Store.prototype.close = function () {
// nothing to do
};
/**
* factory method creating new Model instance bound to this Store.
*
* @param modelType to instantiate.
* @param attributes of new instance.
* @param options at creation time.
* @return new Model instance.
*
* @see Store#createCollection
*/
Store.prototype.createModel = function (modelType, attributes, options) {
return new (this.extendModel(modelType))(attributes, options);
};
/**
* factory method creating new Collection instance bound to this Store.
*
* @param collectionType to instantiate.
* @param models of new instance.
* @param options at creation time.
* @return new Collection instance.
*
* @see Store#createModel
*/
Store.prototype.createCollection = function (collectionType, models, options) {
return new (this.extendCollection(collectionType))(models, options);
};
/**
* additional initialization of Model instance.
*
* @see Store#initCollection
*
* @internal API only to be called by Model constructor.
*/
Store.prototype.initModel = function (model, options) {
// may be overwritten
};
/**
* additional initialization of Collection instance.
*
* @see Store#initModel
*
* @internal API only to be called by Collection constructor.
*/
Store.prototype.initCollection = function (collection, options) {
// may be overwritten
};
/**
* subclasses a Model type such that it is linked to this Store.
*
* @param modelType to subclass.
* @return subclassed Model implementation.
*
* @see Store#createModel
* @see Store#defaultsModel
* @see Store#extendCollection
*
* @internal API only to be called by Store#createModel.
*/
Store.prototype.extendModel = function (modelType) {
diag.debug.assert(function () { return Model_1.isModel(modelType.prototype); });
var entity = modelType.prototype.entity;
var implementation = this.implementations[entity];
if (implementation && implementation.modelCtor && implementation.modelCtor.prototype.__proto__.constructor === modelType) {
diag.debug.assert(implementation.modelCtor.prototype.store === this);
}
else {
if (implementation && implementation.modelCtor) {
diag.debug.warn('redefinition of model ' + entity + ' might not work as expected as existing collections remain bound to previous model type!');
}
// collectionType is reset so that newly created collections get bound to new model implementation
this.implementations[entity] = implementation = {
modelCtor: modelType['extend'](this.defaultsModel(modelType))
};
}
diag.debug.assert(function () { return Model_1.isModel(implementation.modelCtor.prototype); });
return implementation.modelCtor;
};
/**
* subclasses a Collection type such that it is linked to this Store.
*
* @param collectionType to subclass.
* @return subclassed Collection implementation.
*
* @see Store#createCollection
* @see Store#defaultsCollection
* @see Store#extendModel
*
* @internal API only to be called by Store#createCollection.
*/
Store.prototype.extendCollection = function (collectionType) {
diag.debug.assert(function () { return Collection_1.isCollection(collectionType.prototype); });
var modelType = this.extendModel(collectionType.prototype.model);
var entity = modelType.prototype.entity;
var implementation = this.implementations[entity];
diag.debug.assert(implementation && implementation.modelCtor === modelType);
if (implementation.collectionCtor && implementation.collectionCtor.prototype.__proto__.constructor === collectionType) {
diag.debug.assert(implementation.collectionCtor.prototype.store === this);
}
else {
if (implementation && implementation.collectionCtor) {
diag.debug.warn('redefinition of collection ' + entity + ' might not work as expected as existing collections might exist!');
}
implementation.collectionCtor = collectionType['extend'](this.defaultsCollection(collectionType, modelType));
}
diag.debug.assert(function () { return Collection_1.isCollection(implementation.collectionCtor.prototype); });
return implementation.collectionCtor;
};
/**
* defines prototype properties used for a given Model type.
*
* @param modelType being subclassed.
* @return prototype properties of Model.
*
* @see Store#defaultsCollection
*/
Store.prototype.defaultsModel = function (modelType) {
// may be overwritten
return {
urlRoot: this.resolveUrl(_.result(modelType.prototype, 'urlRoot')),
store: this
};
};
;
/**
* defines prototype properties used for a given Collection type.
*
* @param collectionType being subclassed.
* @param modelType that was subclassed already, do not apply Store#extendModel on it!
* @return prototype properties of Collection.
*
* @see Store#defaultsModel
*/
Store.prototype.defaultsCollection = function (collectionType, modelType) {
// may be overwritten
return {
model: modelType,
url: modelType.prototype.urlRoot,
store: this
};
};
/**
* may be overwritten to resolve relative URLs against the actual server.
*
* @param url to resolve.
* @return resolved url.
*/
Store.prototype.resolveUrl = function (url) {
// may be overwritten
return url;
};
Store.prototype.sync = function (method, model, options) {
// must be overwritten
return Q.reject(new Error('not implemented!')); // purely abstract
};
/**
*
* @param collection usually a collection, but can also be a model
* @param options
*/
Store.prototype.fetch = function (collection, options) {
var opts = _.extend({}, options || {}, { store: this });
return collection.fetch(opts);
};
Store.prototype.create = function (collection, models, options) {
var opts = _.extend({}, options || {}, { store: this });
return new collection(models, opts);
};
Store.prototype.save = function (model, attributes, options) {
var opts = _.extend({}, options || {}, { store: this });
return model.save(attributes, opts);
};
Store.prototype.destroy = function (model, options) {
var opts = _.extend({}, options || {}, { store: this });
model.destroy(opts);
};
Store.prototype.handleSuccess = function (options, result) {
if (options.success) {
return options.success.call(this, result);
}
};
Store.prototype.handleError = function (options, error) {
if (options.error) {
return options.error.call(this, error);
}
};
return Store;
}());
exports.Store = Store;
// mixins
var store = _.extend(Store.prototype, Backbone.Events, {
_type: 'Relution.livedata.Store',
isModel: false,
isCollection: false,
isStore: true,
name: 'relution-livedata'
});
diag.debug.assert(function () { return Store.prototype.isPrototypeOf(Object.create(store)); });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Store.js","sourceRoot":"","sources":["../../src/livedata/Store.ts"],"names":[],"mappings":"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","sourcesContent":["/*\r\n * @file livedata/Store.ts\r\n * Relution SDK\r\n *\r\n * Created by Thomas Beckmann on 24.06.2015\r\n * Copyright 2016 M-Way Solutions GmbH\r\n *\r\n * Licensed under the Apache License, Version 2.0 (the \"License\");\r\n * you may not use this file except in compliance with the License.\r\n * You may obtain a copy of the License at\r\n *\r\n * http://www.apache.org/licenses/LICENSE-2.0\r\n *\r\n * Unless required by applicable law or agreed to in writing, software\r\n * distributed under the License is distributed on an \"AS IS\" BASIS,\r\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n * See the License for the specific language governing permissions and\r\n * limitations under the License.\r\n */\r\n/**\r\n * @module livedata\r\n */\r\n/** */\r\n\r\nimport * as Backbone from 'backbone';\r\nimport * as _ from 'lodash';\r\nimport * as Q from 'q';\r\nimport * as diag from '../core/diag';\r\n\r\nimport {Model, ModelCtor, ModelCtorT, ModelProps, isModel} from './Model';\r\nimport {Collection, CollectionCtor, CollectionCtorT, CollectionProps, isCollection} from './Collection';\r\n\r\n/**\r\n * constructor function of Store.\r\n */\r\nexport interface StoreCtor {\r\n  /**\r\n   * @see Store#constructor\r\n   */\r\n  new(options?: any): Store;\r\n}\r\n\r\n/**\r\n * tests whether a given object is a Store.\r\n *\r\n * @param {object} object to check.\r\n * @return {boolean} whether object is a Store.\r\n */\r\nexport function isStore(object: any): object is Store {\r\n  if (!object || typeof object !== 'object') {\r\n    return false;\r\n  } else if ('isStore' in object) {\r\n    diag.debug.assert(() => object.isStore === Store.prototype.isPrototypeOf(object));\r\n    return object.isStore;\r\n  } else {\r\n    return Store.prototype.isPrototypeOf(object);\r\n  }\r\n}\r\n\r\n/**\r\n * base class to build a custom data store.\r\n */\r\nexport class Store {\r\n\r\n  public _type: string;         // constant 'Relution.livedata.Store' on prototype\r\n  public isModel: boolean;      // constant false on prototype\r\n  public isCollection: boolean; // constant false on prototype\r\n  public isStore: boolean;      // constant true on prototype\r\n\r\n  // following are store-specific options, defaults stored in prototype at end of this file\r\n  protected name: string;\r\n\r\n  /**\r\n   * stores Model and Collection constructors by entity name.\r\n   * \r\n   * @see Store#makeModel\r\n   * @see Store#makeCollection\r\n   */\r\n  private implementations: _.Dictionary<{\r\n    /**\r\n     * subclassed Model constructor.\r\n     * \r\n     * @see Store#extendModel\r\n     */\r\n    modelCtor: any,\r\n\r\n    /**\r\n     * subclassed Collection constructor.\r\n     * \r\n     * @see Store#extendCollection\r\n     */\r\n    collectionCtor?: any\r\n  }> = {\r\n    // initially empty\r\n  };\r\n\r\n  protected entities: any;\r\n  public endpoints: any;\r\n\r\n  constructor(options?: any) {\r\n    if (options) {\r\n      // copy options values into the object\r\n      _.extend(this, options);\r\n    }\r\n  }\r\n\r\n  public close() {\r\n    // nothing to do\r\n  }\r\n\r\n  /**\r\n   * factory method creating new Model instance bound to this Store.\r\n   * \r\n   * @param  modelType to instantiate.\r\n   * @param  attributes of new instance.\r\n   * @param  options at creation time.\r\n   * @return new Model instance.\r\n   * \r\n   * @see Store#createCollection\r\n   */\r\n  public createModel<ModelType extends Model, AttributesType, OptionsType>(modelType: ModelCtorT<ModelType, AttributesType, OptionsType>, attributes?: AttributesType, options?: OptionsType): ModelType {\r\n    return new (this.extendModel(modelType))(attributes, options);\r\n  }\r\n\r\n  /**\r\n   * factory method creating new Collection instance bound to this Store.\r\n   * \r\n   * @param  collectionType to instantiate.\r\n   * @param  models of new instance.\r\n   * @param  options at creation time.\r\n   * @return new Collection instance.\r\n   * \r\n   * @see Store#createModel\r\n   */\r\n  public createCollection<CollectionType extends Collection, ModelType extends Model, OptionsType>(collectionType: CollectionCtorT<CollectionType, ModelType, OptionsType>, models?: ModelType[] | Object[], options?: any): CollectionType {\r\n    return new (this.extendCollection(collectionType))(models, options);\r\n  }\r\n\r\n  /**\r\n   * additional initialization of Model instance.\r\n   * \r\n   * @see Store#initCollection\r\n   *\r\n   * @internal API only to be called by Model constructor.\r\n   */\r\n  initModel(model: Model, options?: any): void {\r\n    // may be overwritten\r\n  }\r\n\r\n  /**\r\n   * additional initialization of Collection instance.\r\n   * \r\n   * @see Store#initModel\r\n   * \r\n   * @internal API only to be called by Collection constructor.\r\n   */\r\n  initCollection(collection: Collection, options?: any): void {\r\n    // may be overwritten\r\n  }\r\n\r\n  /**\r\n   * subclasses a Model type such that it is linked to this Store.\r\n   * \r\n   * @param modelType to subclass.\r\n   * @return subclassed Model implementation.\r\n   * \r\n   * @see Store#createModel\r\n   * @see Store#defaultsModel\r\n   * @see Store#extendCollection\r\n   * \r\n   * @internal API only to be called by Store#createModel.\r\n   */\r\n  private extendModel<ModelType extends Model, AttributesType, OptionsType>(modelType: ModelCtorT<ModelType, AttributesType, OptionsType>): ModelCtorT<ModelType, AttributesType, OptionsType> {\r\n    diag.debug.assert(() => isModel(modelType.prototype));\r\n    const entity = modelType.prototype.entity;\r\n    let implementation = this.implementations[entity];\r\n    if (implementation && implementation.modelCtor && implementation.modelCtor.prototype.__proto__.constructor === modelType) {\r\n      diag.debug.assert(implementation.modelCtor.prototype.store === this);\r\n    } else {\r\n      if (implementation && implementation.modelCtor) {\r\n        diag.debug.warn('redefinition of model ' + entity + ' might not work as expected as existing collections remain bound to previous model type!');\r\n      }\r\n      // collectionType is reset so that newly created collections get bound to new model implementation\r\n      this.implementations[entity] = implementation = {\r\n        modelCtor: modelType['extend'](this.defaultsModel(modelType))\r\n      };\r\n    }\r\n    diag.debug.assert(() => isModel(implementation.modelCtor.prototype));\r\n    return implementation.modelCtor;\r\n  }\r\n\r\n  /**\r\n   * subclasses a Collection type such that it is linked to this Store.\r\n   * \r\n   * @param collectionType to subclass.\r\n   * @return subclassed Collection implementation.\r\n   * \r\n   * @see Store#createCollection\r\n   * @see Store#defaultsCollection\r\n   * @see Store#extendModel\r\n   * \r\n   * @internal API only to be called by Store#createCollection.\r\n   */\r\n  private extendCollection<CollectionType extends Collection, ModelType extends Model, OptionsType>(collectionType: CollectionCtorT<CollectionType, ModelType, OptionsType>): CollectionCtorT<CollectionType, ModelType, OptionsType> {\r\n    diag.debug.assert(() => isCollection(collectionType.prototype));\r\n    const modelType = this.extendModel(collectionType.prototype.model);\r\n    const entity = modelType.prototype.entity;\r\n    let implementation = this.implementations[entity];\r\n    diag.debug.assert(implementation && implementation.modelCtor === modelType);\r\n    if (implementation.collectionCtor && implementation.collectionCtor.prototype.__proto__.constructor === collectionType) {\r\n      diag.debug.assert(implementation.collectionCtor.prototype.store === this);\r\n    } else {\r\n      if (implementation && implementation.collectionCtor) {\r\n        diag.debug.warn('redefinition of collection ' + entity + ' might not work as expected as existing collections might exist!');\r\n      }\r\n      implementation.collectionCtor = collectionType['extend'](this.defaultsCollection(collectionType, modelType));\r\n    }\r\n    diag.debug.assert(() => isCollection(implementation.collectionCtor.prototype));\r\n    return implementation.collectionCtor;\r\n  }\r\n\r\n  /**\r\n   * defines prototype properties used for a given Model type.\r\n   * \r\n   * @param modelType being subclassed.\r\n   * @return prototype properties of Model.\r\n   * \r\n   * @see Store#defaultsCollection\r\n   */\r\n  protected defaultsModel<ModelType extends Model, AttributesType, OptionsType>(modelType: ModelCtorT<ModelType, AttributesType, OptionsType>): ModelProps {\r\n    // may be overwritten\r\n    return {\r\n      urlRoot: this.resolveUrl(<string>_.result(modelType.prototype, 'urlRoot')),\r\n      store: this\r\n    };\r\n  };\r\n\r\n  /**\r\n   * defines prototype properties used for a given Collection type.\r\n   * \r\n   * @param collectionType being subclassed.\r\n   * @param modelType that was subclassed already, do not apply Store#extendModel on it!\r\n   * @return prototype properties of Collection.\r\n   * \r\n   * @see Store#defaultsModel\r\n   */\r\n  protected defaultsCollection<CollectionType extends Collection, ModelType extends Model, OptionsType, AttributesType, ModelOptionsType>(collectionType: CollectionCtorT<CollectionType, ModelType, OptionsType>, modelType: ModelCtorT<ModelType, AttributesType, ModelOptionsType>): CollectionProps {\r\n    // may be overwritten\r\n    return {\r\n      model: modelType,\r\n      url: modelType.prototype.urlRoot,\r\n      store: this\r\n    };\r\n  }\r\n\r\n  /**\r\n   * may be overwritten to resolve relative URLs against the actual server.\r\n   * \r\n   * @param url to resolve.\r\n   * @return resolved url.\r\n   */\r\n  protected resolveUrl(url: string) {\r\n    // may be overwritten\r\n    return url;\r\n  }\r\n\r\n  sync(method: string, model: Model | Collection, options?: any): Q.Promise<any> {\r\n    // must be overwritten\r\n    return Q.reject(new Error('not implemented!')); // purely abstract\r\n  }\r\n\r\n  fetch(collection: Model, options: Backbone.ModelFetchOptions): Q.Promise<any>;\r\n  fetch(collection: Collection, options: Backbone.CollectionFetchOptions): Q.Promise<any>;\r\n  /**\r\n   *\r\n   * @param collection usually a collection, but can also be a model\r\n   * @param options\r\n   */\r\n  fetch(collection: Model | Collection, options: Backbone.ModelFetchOptions | Backbone.CollectionFetchOptions) {\r\n    var opts = _.extend({}, options || {}, { store: this });\r\n    return (<any>collection).fetch(opts);\r\n  }\r\n\r\n  create(collection: CollectionCtor, models: Model[], options?: any) {\r\n    var opts = _.extend({}, options || {}, { store: this });\r\n    return new collection(models, opts);\r\n  }\r\n\r\n  save(model: Model, attributes?: any, options?: Backbone.ModelSaveOptions) {\r\n    var opts = _.extend({}, options || {}, { store: this });\r\n    return model.save(attributes, opts);\r\n  }\r\n\r\n  destroy(model: Model, options?: Backbone.ModelDestroyOptions) {\r\n    var opts = _.extend({}, options || {}, { store: this });\r\n    model.destroy(opts);\r\n  }\r\n\r\n  protected trigger: typeof Backbone.Events.prototype.trigger;\r\n\r\n  protected handleSuccess(options: {\r\n    success?: Function\r\n  }, result: any): any {\r\n    if (options.success) {\r\n      return options.success.call(this, result);\r\n    }\r\n  }\r\n\r\n  protected handleError(options: {\r\n    error?: Function\r\n  }, error: Error): any {\r\n    if (options.error) {\r\n      return options.error.call(this, error);\r\n    }\r\n  }\r\n}\r\n\r\n// mixins\r\nlet store = _.extend(Store.prototype, Backbone.Events, {\r\n  _type: 'Relution.livedata.Store',\r\n  isModel: false,\r\n  isCollection: false,\r\n  isStore: true,\r\n\r\n  name: 'relution-livedata'\r\n});\r\ndiag.debug.assert(() => Store.prototype.isPrototypeOf(Object.create(store)));\r\n"]}