@harishreddym/baqend/lib/binding/ManagedFactory.js

Baqend JavaScript SDK

'use strict';

const Factory = require('./Factory');
const deprecated = require('../util/deprecated');

/**
 * @class binding.ManagedFactory<T>
 * @extends binding.Factory<T>
 *
 * @param {Object=} properties initial properties to set on the instance
 * @param {...*} args Additional constructor params passed through the type constructor
 * @return {T} The new managed instance
 */
const ManagedFactory = Factory.extend(/** @lends binding.ManagedFactory<T>.prototype */ {

  /**
   * Creates a new ManagedFactory for the given type
   * @param {metamodel.ManagedType} managedType The metadata of type T
   * @param {EntityManager} db
   * @return {binding.ManagedFactory<*>} A new object factory to created instances of T
   * @static
   * @ignore
   */
  create(managedType, db) {
    // invoke super method
    const factory = Factory.create.call(this, managedType.typeConstructor);
    factory.methods = factory.prototype;

    factory.managedType = managedType;
    factory.db = db;

    return factory;
  },

  /**
   * Creates a new instance of the factory type
   *
   * @param {Array<*>=} args Constructor arguments used for instantiation, the constructor will not be called
   * when no arguments are passed
   * @return {T} A new created instance of T
   */
  newInstance(args) {
    const instance = Factory.newInstance.call(this, args);
    instance._metadata.db = this.db;
    return instance;
  },

  /**
   * Creates a new instance and sets the Managed Object to the given json
   * @param {json} json
   * @return {T} instance
   */
  fromJSON(json) {
    const instance = this.newInstance();
    const metadata = instance._metadata;
    return this.managedType.fromJsonValue(metadata, json, instance, {});
  },

  /**
   * Adds methods to instances of this factories type
   * @param {Object<string, Function>} methods The methods to add
   * @return {void}
   */
  addMethods(methods) {
    Object.assign(this.methods, methods);
  },

  /**
   * Add a method to instances of this factories type
   * @param {string} name The method name to add
   * @param {Function} fn The Method to add
   * @return {void}
   */
  addMethod(name, fn) {
    this.methods[name] = fn;
  },
});

/**
 * Methods that are added to object instances
 * This property is an alias for this factory type prototype
 * @name methods
 * @type {Object<string, Function>}
 * @memberOf binding.ManagedFactory<T>.prototype
 */

/**
 * The managed type of this factory
 * @name managedType
 * @type metamodel.ManagedType
 * @protected
 * @readonly
 * @memberOf binding.ManagedFactory<T>.prototype
 */

/**
 * The owning EntityManager where this factory belongs to
 * @name db
 * @type EntityManager
 * @protected
 * @readonly
 * @memberOf binding.ManagedFactory<T>.prototype
 */

/**
 * Creates a new instance of the of this type
 * @function
 * @name new
 * @param {Object<string, *>} properties Additional properties which will be applied to the created instance
 * @return {T} A new created instance of this class
 * @memberOf binding.ManagedFactory<T>.prototype
 */

deprecated(ManagedFactory, '_db', 'db');
deprecated(ManagedFactory, '_managedType', 'managedType');

module.exports = ManagedFactory;