backbone.js - ¿Cuál es la mejor manera de unir comportamiento a una Colección Meteor?

model behavior

Question

En Meteor, cuando recuperas un registro de una base de datos, es solo un registro. Entonces, si tengo una colección llamada Dogs , un dog podría tener fur: ''brown'' o breath: ''stinky'' , pero no tiene un método de bark() .

Obviamente, podría crear algunas funciones que esperan un dog como argumento y luego realizar operaciones en ese dog . Incluso podría encapsular todas estas funciones en un solo constructor. No estoy loco por este enfoque, pero si alguien tiene una forma limpia y sensata de hacerlo, soy todo oídos.

Otra idea que tuve fue envolver al dog en un Backbone.Model . Backbone.Model . Esto podría ser interesante, ya que fetch y save podría redefinirse para find e insert o update , y también puede definir todo su comportamiento allí, pero he leído que este tipo de cosas generalmente se desaconseja.

¿Hay una forma correcta de hacerlo? ¿Hay un Meteor.Model oficialmente en las obras? ¿Cómo están otros resolviendo este problema?

Editar

Para los que llegan a esta pregunta más de un año después de la respuesta aceptada: en el momento de esta edición estoy usando el paquete minimrtgoid mrt de Exygy , que tiene algunas mejoras a la versión de Haihappen que se menciona en la publicación del blog vinculada por la respuesta aceptada.

Actualmente estoy contribuyendo al repositorio para hacer que los conjuntos de resultados tengan más relación. Con suerte, otros se aprovecharán de él y se sentirán inclinados a contribuir con una funcionalidad útil.

Editar

Otra respuesta sugirió usar la propiedad de transform al crear la colección. Aunque definitivamente prefiero algo que realmente no necesito desarrollar, esta función agrega muchas posibilidades, y espero que cualquier equipo que esté trabajando en un ORM para Meteor aproveche esto en el núcleo. .

Aquí hay una publicación en el blog que explica cómo usar la propiedad de transform .

Además, minimongoid ahora está disponible como un paquete Meteor , y todavía lo estoy usando. Tiene soporte para validación y para declarar relaciones. También he agregado algunas funcionalidades a este paquete, de modo que si una placa tiene muchas piezas, board.pieces().create(attributes) persistirá en un nuevo registro de piece con los attributes dados y se asociará automáticamente con la board . De las diversas soluciones que he visto, esta parece ser la más completa.

Answer 1

Adiciones a la respuesta de @Flavien Volken puede pasar argumentos al método que ha agregado a la colección.

Car = new Mongo.Collection(''car'', {
    transform: function(entry) {
        entry.is_watched = function(userId) {
            var is_watched = false;
            if (entry.watchList) {
                for (var i in entry.watchList) {
                    if (entry.watchList[i].userId == userId) {
                        is_watched = true;
                        break;
                    }
                }
            }
            return is_watched;
        };
        return entry;
    }
});

En la plantilla (que pasa la identificación del usuario conectado):

{{# if is_watched currentUser._id }}
    Watched
{{ else }}
    Not watched
{{/ if }}

Answer 2

Esta es una pregunta relativamente antigua en términos de Meteor, pero creo que dburles:collection-helpers ajusta a la lista de lo que quería lograr implementando lo que Flavien Volken sugirió. Tal vez sea útil para alguien que vaga por aquí recientemente.

Answer 3

Este es un comienzo para anular Meteor.Collection para apoyar métodos en objetos.

Meteor.Kollection = Meteor.Collection;
Meteor.Kollection.extend = function(constructor) {
  var parent = this;
  var child = function() {
    Meteor.Kollection.apply(this, arguments);
    constructor.apply(this, arguments);
  };

  _.extend(child, parent);

  function __proto__() { this.constructor = child; };
  __proto__.prototype = parent.prototype;
  child.prototype = new __proto__;

  return child;
};

Meteor.Collection = Meteor.Kollection.extend(function(name, options) {
  if (options && options.defaults) {
    this.defaults = options.defaults;
  }
});

Meteor.Collection.prototype.applyDefaults = function(attrs) {
  return _.defaults(attrs, this.defaults);
};

Meteor.Collection.prototype.create = function(attrs) {
  if (typeof attrs !== "object") attrs = {};
  return this.applyDefaults(attrs);
};

Meteor.Collection.prototype.findOne = function(selector, options) {
  var object = Meteor.Kollection.prototype.findOne.apply(this, arguments);
  return this.applyDefaults(object);
};

Puede observar el nuevo método de recopilación .create, y esa colección .findOne ha sido anulada. Imagino que todos los métodos de colección . * Deberán ser anulados, pero esto es un comienzo.

Entonces, ¿qué puedes hacer con esto?

var Dogs = new Meteor.Collection("dogs", { defaults: {
  barkSound: "ruff",
  bark: function() {
    console.log(this.barkSound);
  }
}});

if (Meteor.isClient) {
  var regularDog = Dogs.create();
  regularDog.bark(); // ruff

  var smallDog = Dogs.create({
    barkSound: "yip"
  });
  smallDog.bark(); // yip

  Dogs.insert(smallDog, function(error, id) {
    Dogs.findOne(id).bark(); // yip
  });
});

No estoy exactamente seguro de cómo sucede esto, pero las funciones de un objeto se eliminan cuando se insertan. Por lo tanto, podemos aplicar directamente los métodos al objeto. Primero, crea su colección pasando un objeto con la propiedad de defaults . Esta propiedad puede incluir propiedades o métodos. Para crear un nuevo objeto para una colección determinada, use collection .create (attrs), donde attrs es un argumento de opción que incluye propiedades y métodos adicionales u omitidos.

Answer 4

Puede usar el parámetro de transform en la Colección para sobrecargar el objeto con funciones personalizadas

var Dogs = new Meteor.Collection("dogs", 
{
    transform:function(entry)
    {
        entry.bark = function(){ console.log(this.barkSound);};
        return entry;
    }
});

Entonces:

var aDogID = new Dogs.insert({barkSound: "ruff"})
Dogs.find(aDogID).bark(); // "ruff"

Bonificación: si por algún motivo desea utilizar un concepto similar al propuesto por Andrew Ferk, simplemente use la función _defaults (object, * default).

var defaults = {
             barkSound: "ruff",
             bark: function() {
                        console.log(this.barkSound);
                    }
            }

Dogs = new Meteor.Collection("dogs",
        {
            transform: function(object) {
                return _.defaults(object, defaults);
            }
        });

Answer 5

Si bien puede haber un sistema modelo oficial en funcionamiento, hay algunas cosas que puede hacer ahora:

Hay uno de Mario Uhler que es como un registro activo y bastante bueno, en coffeescript: https://coderwall.com/p/_q9b1w

También hay un paquete de la comunidad hecho por Tom Coleman que es muy útil con los modelos: https://github.com/tmeasday/meteor-models , es posible que necesite un meteorite para agregarlo como un paquete.

Y, por supuesto, como sugirió Backbone. Yo personalmente uso prototipos js pero no todos pueden estar cómodos con ellos, solo los uso, así que es fácil de hacer la transición cuando el sistema modelo de meteoritos está fuera, también es fácil de compartir entre el cliente y el servidor sin demasiados paquetes para agregar.

Answer 6

Astronomy es una nueva respuesta a esta vieja pregunta sobre los modelos de Meteor. El autor tiene muchas más funciones planificadas que están en proceso y el apoyo de otros autores prominentes del paquete Meteor. El único inconveniente es que quizás sea ​​un poco deprimente.

La astronomía también está muy modularizada , un excelente ejemplo para construir en un estilo de paquete / modularizado de meteoros.