Vou refatorar esse meu code

factory.organism.js

const mongoose = require('mongoose')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

module.exports = (DNA, Molecule) => {

  const Organism = mongoose.model(DNA.name, Molecule) // deixar generico
  const Organelles = require('./../_config/organism/organelles.default')

  const OrganellesCell = 
    (Array.isArray(DNA.organelles))
      ? (Array.isArray(DNA.middlewares)) 
          ? DNA.organelles.concat(Organelles).concat(DNA.middlewares)
        	: DNA.organelles.concat(Organelles)
      : Organelles

  const createOrganelles = (acc, name) => 
  	Object.assign(acc, {
  		[name]: require(organellesPath+name)(Organism, DNA.populate)})

  return OrganellesCell.reduce(createOrganelles, {name: DNA.name})
}

Primeiramente irei refatorar o teste de algo eh um array verificando se possui a fn map

const mongoose = require('mongoose')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

module.exports = (DNA, Molecule) => {

  const Organism = mongoose.model(DNA.name, Molecule)
  const Organelles = require('./../_config/organism/organelles.default')

  const OrganellesCell = 
    ( DNA.organelles.map ) // Array.isArray(DNA.organelles)
      ? ( DNA.middlewares.map ) // Array.isArray(DNA.middlewares)
          ? DNA.organelles.concat(Organelles).concat(DNA.middlewares)
        	: DNA.organelles.concat(Organelles)
      : Organelles

  const createOrganelles = (acc, name) => 
  	Object.assign(acc, {
  		[name]: require(organellesPath+name)(Organism, DNA.populate)})


  return OrganellesCell.reduce(createOrganelles, {name: DNA.name})
}

Deixando os requires no topo, saudades C <3

const mongoose = require('mongoose')
const Organelles = require('./../_config/organism/organelles.default')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

Iniciamos a serie de remoçao das fns de dentro do module.exports.

const createOrganism = ( name, Molecule ) => mongoose.model( name, Molecule )

module.exports = (DNA, Molecule) => {

  const Organism = createOrganism( DNA.name, Molecule )

Criei a createCell que cria a Cell, antiga OrganellesCell

const mongoose = require('mongoose')
const Organelles = require('./../_config/organism/organelles.default')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

const createOrganism = ( name, Molecule ) => 
  mongoose.model( name, Molecule )

const createCell = ( DNA, Organelles ) =>
  ( DNA.organelles.map ) // Array.isArray(DNA.organelles)
    ? ( DNA.middlewares.map ) // Array.isArray(DNA.middlewares)
        ? DNA.organelles.concat(Organelles).concat(DNA.middlewares)
        : DNA.organelles.concat(Organelles)
    : Organelles

module.exports = (DNA, Molecule) => {

  const Organism = createOrganism( DNA.name, Molecule )
  const Cell = createCell( DNA, Organelles )

  const createOrganelles = (acc, name) => 
  	Object.assign(acc, {
  		[name]: require(organellesPath+name)(Organism, DNA.populate)})


  return Cell.reduce(createOrganelles, {name: DNA.name})
}

Separei a fn createOrganelles onde injeto Organism e DNA.populate para que ela nao acesse vars globais/fora do seu escopo.

return Cell.reduce(createOrganelles( Organism, DNA.populate), {name: DNA.name} )

const mongoose = require('mongoose')
const Organelles = require('./../_config/organism/organelles.default')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

const createOrganism = ( name, Molecule ) => 
  mongoose.model( name, Molecule )

const createCell = ( DNA, Organelles ) =>
  ( DNA.organelles.map ) // Array.isArray(DNA.organelles)
    ? ( DNA.middlewares.map ) // Array.isArray(DNA.middlewares)
        ? DNA.organelles.concat(Organelles).concat(DNA.middlewares)
        : DNA.organelles.concat(Organelles)
    : Organelles

const createOrganelles = ( Organism, populate ) => ( acc, name ) => 
  Object.assign( acc, {
    [name]: require( organellesPath+name )( Organism, populate )
  } )

module.exports = (DNA, Molecule) => {

  const Organism = createOrganism( DNA.name, Molecule )
  const Cell = createCell( DNA, Organelles )

  return Cell.reduce(createOrganelles( Organism, DNA.populate ), {name: DNA.name} )
}

Entao apenas substitui as fns createOrganism e createCell onde tinha seus valores salvos em suas consts.

const mongoose = require('mongoose')
const Organelles = require('./../_config/organism/organelles.default')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

const createOrganism = ( name, Molecule ) => 
  mongoose.model( name, Molecule )

const createCell = ( DNA, Organelles ) =>
  ( DNA.organelles.map ) // Array.isArray(DNA.organelles)
    ? ( DNA.middlewares.map ) // Array.isArray(DNA.middlewares)
        ? DNA.organelles.concat(Organelles).concat(DNA.middlewares)
        : DNA.organelles.concat(Organelles)
    : Organelles

const createOrganelles = ( Organism, populate ) => ( acc, name ) => 
  Object.assign( acc, {
    [name]: require( organellesPath+name )( Organism, populate )
  } )

module.exports = (DNA, Molecule) => 
  createCell( DNA, Organelles )
    .reduce( createOrganelles( createOrganism( DNA.name, Molecule ), 
                                DNA.populate), 
                                {name: DNA.name} 
                              )

Para finalizar encapsulei as fns chamadas no module.exports para deixar mais legivel, agora a fn mestre eh aMakeLife que executa a Mitosis na Cell.

Foi coisa simples, mas espero que possa ajudar alguem e claro se vc quiser comentar com a sua refatoraçao eu agradeço.

const mongoose = require('mongoose')
const Organelles = require('./../_config/organism/organelles.default')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

const createOrganism = ( name, Molecule ) => 
  mongoose.model( name, Molecule )

const createCell = ( DNA, Organelles ) =>
  ( DNA.organelles.map ) // Array.isArray(DNA.organelles)
    ? ( DNA.middlewares.map ) // Array.isArray(DNA.middlewares)
        ? DNA.organelles.concat(Organelles).concat(DNA.middlewares)
        : DNA.organelles.concat(Organelles)
    : Organelles

const createOrganelles = ( Organism, populate ) => ( acc, name ) => 
  Object.assign( acc, {
    [name]: require( organellesPath+name )( Organism, populate )
  } )

const Mitosis = ( DNA, Molecule ) => ( Cell ) => 
  Cell.reduce( createOrganelles(  createOrganism( DNA.name, Molecule ), 
                                  DNA.populate ), 
                                {name: DNA.name} 
                                )

const MakeLife = ( DNA, Molecule, Organelles ) => 
  Mitosis( DNA, Molecule )(createCell( DNA, Organelles ))
    
module.exports = ( DNA, Molecule ) => MakeLife( DNA, Molecule, Organelles ) 

po curti essa ideia de mostrar refatoração no git em passo a passo.

Beautiful Suissa Sensei!

Coisa linda... hehe

top...

Renomei algumas coisas para melhorar a conceituaçao biológica

const mongoose = require('mongoose')
const Organelles = require('./../_config/organism/organelles.default')
const moleculesPath = './../modules/'
const organellesPath = './../_organelles/'

const createCytoplasm = ( name, Molecule ) => 
  mongoose.model( name, Molecule )

const createCell = ( DNA, Organelles ) =>
  ( DNA.organelles.map ) // Array.isArray(DNA.organelles)
    ? ( DNA.middlewares.map ) // Array.isArray(DNA.middlewares)
        ? Transcript( DNA, Organelles, `with middlewares` )
        : Transcript( DNA, Organelles )
    : Organelles

const createOrganelles = ( Organism, organellesPath ) => 
  ( acc, name ) => 
    Object.assign( acc, {
      [ name ]: require( organellesPath+name )( Organism )
    } )

const Transcript = ( DNA, Organelles, middlewares = false ) => 
  ( middlewares )
    ? DNA.organelles.concat(Organelles)
    : DNA.organelles.concat(Organelles).concat(DNA.middlewares)

const Synthesis = ( DNA, Molecule ) => 
  createOrganelles( createCytoplasm( DNA.name, Molecule ), organellesPath )

const Mitosis = ( DNA, Molecule ) => ( Cell ) => 
  Cell.reduce( Synthesis( DNA, Molecule ), {name: DNA.name} )

const MakeLife = ( DNA, Molecule, Organelles ) => 
  Mitosis( DNA, Molecule )( createCell( DNA, Organelles ) )
    
module.exports = ( DNA, Molecule ) => MakeLife( DNA, Molecule, Organelles )

Galero da Biologia preciso de sugestoes p/ nomear os middlewares das rotas conceituando com alguma organela existente.

Q q vcs acham de nomear os middlewares como Complexo de Golgi?

analisem vcs mesmos.

https://pt.wikipedia.org/wiki/Complexo_de_Golgi

Essas vesículas que brotam de regiões do RE que não estão recobertas por ribossomos levam as proteínas para outra organela limitada por membrana, o aparato de Golgi, mais especificamente em sua rede cis.
Depois que as proteínas secretadas e as de membrana passam por modificações no Golgi, são transportadas para fora por uma série de vesículas que parecem brotar da porção trans. Algumas vesículas transportam proteínas de membrana destinadas para membrana plasmática ou proteínas solúveis que serão liberadas da superfície celular; outras levam proteínas solúveis ou de membrana aos lisossomos e outras organelas.

https://github.com/suissa/OpenBills/blob/master/api/_factories/organism.js

/**
IN:
DNA { name: 'Bill',
  organelles: 
   [ 'find',
     'find',
     'create',
     'getSchema',
     'findByFilter',
     'findAllPopulate',
     'findById',
     'findByIdPopulate',
     'update',
     'remove' ],
  middlewares: [ 'test' ] }
Molecule {
  obj: 
   { active: 
      { type: [Function: Boolean],
        ATOM_NAME: 'active',
        required: true,
        default: true },
     name: { type: [Function: String], ATOM_NAME: 'name' },
     type: 
      { type: [Function: String],
        ATOM_NAME: 'type',
        required: true,
        enum: [Object],
        default: 'mercado' },
     amount: { type: [Function: Number], ATOM_NAME: 'amount', min: 0 },
     deadline: { type: [Function: Date], ATOM_NAME: 'deadline' },
     interest: { type: [Function: Number], ATOM_NAME: 'interest', default: 0 },
     paid_at: { type: [Function: Date], ATOM_NAME: 'paid_at' },
     created_at: 
      { type: [Function: Date],
        ATOM_NAME: 'created_at',
        default: [Function: now] } },
  paths: 
   { active: 
      SchemaBoolean {
        path: 'active',
        instance: 'Boolean',
        validators: [Object],
        setters: [],
        getters: [],
        options: [Object],
        _index: null,
        isRequired: true,
        requiredValidator: [Function],
        originalRequiredValue: true,
        defaultValue: true },
     name: 
      SchemaString {
        enumValues: [],
        regExp: null,
        path: 'name',
        instance: 'String',
        validators: [],
        setters: [],
        getters: [],
        options: [Object],
        _index: null },
     type: 
      SchemaString {
        enumValues: [Object],
        regExp: null,
        path: 'type',
        instance: 'String',
        validators: [Object],
        setters: [],
        getters: [],
        options: [Object],
        _index: null,
        isRequired: true,
        requiredValidator: [Function],
        originalRequiredValue: true,
        enumValidator: [Function],
        defaultValue: 'mercado' },
     amount: 
      SchemaNumber {
        path: 'amount',
        instance: 'Number',
        validators: [Object],
        setters: [],
        getters: [],
        options: [Object],
        _index: null,
        minValidator: [Function] },
     deadline: 
      SchemaDate {
        path: 'deadline',
        instance: 'Date',
        validators: [],
        setters: [],
        getters: [],
        options: [Object],
        _index: null },
     interest: 
      SchemaNumber {
        path: 'interest',
        instance: 'Number',
        validators: [],
        setters: [],
        getters: [],
        options: [Object],
        _index: null,
        defaultValue: 0 },
     paid_at: 
      SchemaDate {
        path: 'paid_at',
        instance: 'Date',
        validators: [],
        setters: [],
        getters: [],
        options: [Object],
        _index: null },
     created_at: 
      SchemaDate {
        path: 'created_at',
        instance: 'Date',
        validators: [],
        setters: [],
        getters: [],
        options: [Object],
        _index: null,
        defaultValue: [Function: now] },
     _id: 
      ObjectId {
        path: '_id',
        instance: 'ObjectID',
        validators: [],
        setters: [Object],
        getters: [],
        options: [Object],
        _index: null,
        defaultValue: [Function: defaultId] } },
  subpaths: {},
  virtuals: { id: VirtualType { path: 'id', getters: [Object], setters: [], options: {} } },
  singleNestedPaths: {},
  nested: {},
  inherits: {},
  callQueue: 
   [ [ 'pre', [Object] ],
     [ 'pre', [Object] ],
     [ 'pre', [Object] ],
     [ 'pre', [Object] ] ],
  _indexes: [],
  methods: {},
  statics: {},
  tree: 
   { active: 
      { default: true,
        required: true,
        ATOM_NAME: 'active',
        type: [Function: Boolean] },
     name: { ATOM_NAME: 'name', type: [Function: String] },
     type: 
      { default: 'mercado',
        enum: [Object],
        required: true,
        ATOM_NAME: 'type',
        type: [Function: String] },
     amount: { min: 0, ATOM_NAME: 'amount', type: [Function: Number] },
     deadline: { ATOM_NAME: 'deadline', type: [Function: Date] },
     interest: { default: 0, ATOM_NAME: 'interest', type: [Function: Number] },
     paid_at: { ATOM_NAME: 'paid_at', type: [Function: Date] },
     created_at: 
      { default: [Function: now],
        ATOM_NAME: 'created_at',
        type: [Function: Date] },
     _id: { type: [Object], auto: true },
     id: VirtualType { path: 'id', getters: [Object], setters: [], options: {} } },
  query: {},
  childSchemas: [],
  s: 
   { hooks: Kareem { _pres: {}, _posts: {} },
     kareemHooks: 
      { count: true,
        find: true,
        findOne: true,
        findOneAndUpdate: true,
        findOneAndRemove: true,
        insertMany: true,
        update: true,
        updateMany: true,
        updateOne: true } },
  options: 
   { retainKeyOrder: false,
     typeKey: 'type',
     id: true,
     noVirtualId: false,
     _id: true,
     noId: false,
     validateBeforeSave: true,
     read: null,
     shardKey: null,
     autoIndex: null,
     minimize: true,
     discriminatorKey: '__t',
     versionKey: '__v',
     capped: false,
     bufferCommands: true,
     strict: true } }
*/

/** 
OUT:
MakeLife { name: 'Bill',
   find: [Function],
   create: [Function],
   getSchema: [Function],
   findByFilter: [Function],
   findAllPopulate: [Function],
   findById: [Function],
   findByIdPopulate: [Function],
   update: [Function],
   remove: [Function],
   findOne: [Function],
   test: [Function] }
*/

MakeLife tirou onda!