javascript - patterns - onion architecture nodejs

Diseño impulsado por dominio en la aplicación Node.js

Question

TL; DR; Estoy buscando un ejemplo trillado de la aplicación DDD node.js.

Hola,

Voy a crear la aplicación de nodo. Me pregunto si no puedo encontrar ningún ejemplo de aplicación con lógica de negocios separada en el dominio.

OK, hay algunos ejemplos como: https://github.com/adrai/node-cqrs-domain - pero esto es todo CQRS con implementación de fuentes de eventos.

Mi idea es hacer eso así.

//domain/book.js
function Book(title, author)
{
  this._title = title;
  this._author = author;
}

// domain methods ...

//infrastructure/persistance/repository/book-repository.js
function BookRepository()
{}

BookRepository.prototype.save(book)
{
  var bookModel = mappers.mapToOrm(book);
  return bookModel.save();
}

// [...] get, getAll, getNextId

//infrastructure/persistance/orm/book.js
//using http://bookshelfjs.org/
var Book = bookshelf.Model.extend({
  tableName: ''books''
});

//infrastructure/mappers/book-mapper.js
function mapToOrm(book) {
  //mapping [...]
  return new persistance.Book();
}

function mapToDomain(domain) {
  //mapping [...]
  return new domain.Book();
}

pero, por otro lado, nunca he visto una solución similar (con modelo de dominio, modelo de orm, repositorio y mapeadores). ¿Estoy pensando de la manera correcta? Tal vez no haya ninguna razón para separar la lógica empresarial en el dominio en las aplicaciones node.js. Si es así, ¿por qué? De lo contrario, ¿puede enviarme un ejemplo de implementación de DDD o mejorar mi código?

[2017/01/13]

He creado una aplicación de muestra en TypeScript. Por ahora sin repositorios y sin muchos servicios. Los problemas y las solicitudes de extracción son bienvenidos. https://github.com/dawiddominiak/ddd-typescript-bin-packing-problem-solution

Answer 1

Estoy buscando hacer lo mismo en este momento, y vengo del mundo Ruby. Entonces, déjame hacer 2 cosas:

1. Señale la mejor implementación de Ruby que he visto de Diseño impulsado por dominios que he encontrado, Hanami: http://hanamirb.org/guides/models/overview/ que puede usar como referencia.

2. Discuta lo que estoy encontrando (literalmente en este momento, mientras escribo) para intentar encontrar los análogos en Node.

He encontrado esta página: https://github.com/sindresorhus/awesome-nodejs

que cataloga una tonelada de paquetes Node de alta calidad / popularidad.

Lo primero es que necesitamos algo que vaya a realizar la validación y la construcción del esquema para nuestros modelos de dominio. Solo mirando la primera entrada en la sección de validación de datos, Joi parece ser una opción decente para eso:

https://github.com/hapijs/joi

Para la persistencia de los objetos del dominio, solo estoy configurando un objeto de código auxiliar, tomando prestado de la interfaz de Hanami:

var repo = {
  find: function(entity_name, id) {
    //  - Fetch an entity from the collection by its ID
  },
  create: function(entity_name, data) {
    //  – Create a record for the given data and return an entity
  },
  update: function(entity_name, id, data) {
    //  – Update the record corresponding to the id and return the updated entity
  },
  delete: function(entity_name, id) {
    //  – Delete the record corresponding to the given entity
  },
  all: function(entity_name) {
    //  - Fetch all the entities from the collection
  },
  query: function(entity_name, query_object) {

  },
  first: function(entity_name) {
    //  - Fetch the first entity from the collection
  },
  last: function(entity_name) {
    //  - Fetch the last entity from the collection
  },
  clear: function(entity_name) {
    //  - Delete all the records from the collection
  }
}

module.exports = repo

Ya sea que elija utilizar Bookshelf , Sequelize o incluso el marco LoopBack , puede codificar un objeto que se ajuste a la interfaz anterior que luego hace el trabajo sucio de integración con esos marcos.

Si tuviera que probar diferentes ORM, crearía un objeto repo diferente para cada uno de los anteriores. Tenga en cuenta que, como lo he escrito, el repositorio es un singleton que tiene en cuenta las diferentes entidades y cómo persistir en ellas. En muchos casos, esto sin duda se delegará en diferentes objetos del repositorio por entidad. Sin embargo, eso podría no ser siempre cierto. un simple repositorio en memoria, podría tener una matriz de objetos para cada entidad.

Eso deja a los Servicios / Interactores - Las funciones / clases que realmente funcionan. Estos son fáciles: son los que toman un objeto de dominio, realizan alguna lógica de negocios y, en los casos de CRUD, realizan una llamada al Repositorio. Un ejemplo probablemente sintácticamente incorrecto:

const repository = require(''./myFileRepository'')

function createBook(bookEntity) { 

  if(bookEntity.valid?) { 
    repository.create(''book'', bookEntity)
    return true
  }
  else {
    return { error: ''book not valid'' }
  }
}

module.exports = createBook

para las funciones de servicio, acabo de enterarme hoy de las máquinas de nodos, y parecen una idea realmente inteligente: http://node-machine.org

parecen ser un intento de JS en la mónada + documentación. así que estoy considerando escribirlos así.

De todos modos, dado que ha pasado un año desde tu publicación, probablemente te hayas mudado. Espero que esto te ayude a ti / a la comunidad!

Answer 2

Muchos argumentarían que JavaScript NO está bien adaptado para modelar un problema complejo en un modelo de dominio y luego en código. Ese es especialmente el caso si el dominio está en los negocios, la industria y el comercio, en lugar de en la ciencia informática o de datos.

No estoy diciendo que uno no pueda crear un modelo de dominio en JavaScript. Al igual que uno podría crear uno en C. ¿Pero eso significa que uno debería?

El ejemplo que usted da usa alguna terminología en el diseño impulsado por el dominio, pero pierde todo el propósito y la ética de su aplicación.

Answer 3

Soy muy nuevo en el mundo Node.js.

Pero creo que si realiza su trabajo utilizando TypeScript con nodo , puede forzar la mayoría de los principios de DDD para que se utilicen.

El problema "y la ventaja al mismo tiempo" en node.js es que no existen restricciones como las que tenemos en lenguajes OOP como C # o Java. y esta libertad "y desordenada" de JavaScript hace que la creación robusta y compleja de DomainModel y Business logic sea muy difícil