@benjy2976/pmsg 0.1.0

package/.gitattributes

@@ -0,0 +1 @@
+* text=auto

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Walther Aguirre
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,247 @@
+# pinia-model-store-generator pmsg
+This is a powerful package to consume data from webservices and use it as a model, centralizing the control of routes and
+ making the call to data from the server much more friendly.
+
+este es un paquete potente para consumir datos de webservices y utilizarlo como modelo, centralizado el control de las 
+rutas y haciendo mucha mas amable la llamada a los datos desde el servidor
+
+It also provides a tool that creates a template with the main actions for state control with Pinia.
+
+tambien provee de una herramienta que crea una plantilla con las principales acciones para el control de estados con Pinia
+
+## Installing
+
+Using npm:
+
+```bash
+$ npm install 
+```
+
+
+## Example
+NOTE: if you use a md5 validation and the store functionality you can download the resource from the server once,
+an re download only if the data was changed.
+
+you can create a core/product.js file and put the next code
+
+```js
+export default {
+    alias     : 'product' ,//alias utilizado para almacenar en el localstorage
+    route     : '/api/auth/product',//ruta donde se encuentra el resource
+    hash      : false,//la condicional si se va a validar el md5
+    store     : false,//la condicional que define si se guardara en el localstorage
+    methods   : null, //define los métodos adicionales utilizados por el modelo
+
+    /*config for storeDefault*/
+    key       : 'id',//define el primary key que se usara para acceder al objeto
+    name      : 'name',//nombre del atributo name en la base de datos
+    maxRelationsResolve: 1//la cantidad de veces que resolvera la relacion default 1
+    relations : [// Relaciones con otros models
+        {
+            attribute: 'brand_id',
+            alias: 'brand',//si no se define se asume le mismo nombre que attribute
+            module: 'brands',
+            hasMany: false// si no se define se asumen como falso
+        },
+    ],
+    selectable: false,//condicional para definir si el objeto es seleccionable
+    default   : {
+        id:null,
+        brand_id:null,
+        name:null
+    },//valor del objeto por defecto,
+    params    : {modeljs: true}//aquí se configuran parámetros adicionales a enviar en los request
+   
+}
+
+```
+
+you can create a core/category.js file and put the next code
+
+```js
+export default {
+    alias     : 'brand' ,//alias utilizado para almacenar en el localstorage
+    route     : '/api/auth/brand',//ruta donde se encuentra el resource
+    hash      : false,//la condicional si se va a validar el md5
+    store     : false,//la condicional que define si se guardara en el localstorage
+    methods   : null, //define los métodos adicionales utilizados por el modelo
+
+    /*config for storeDefault*/
+    key       : 'id',//define el primary key que se usara para acceder al objeto
+    name      : 'name',//nombre del atributo name en la base de datos
+    maxRelationsResolve: 1//la cantidad de veces que resolvera la relacion default 1
+    relations : [// Relaciones con otros models
+        {
+          attribute : 'brand_id',
+          alias     : 'products',
+          module    : 'products',
+          hasMany   : true//se pone false para que busque a traves del pivot
+        },
+    ],
+    selectable: false,//condicional para definir si el objeto es seleccionable
+    default   : {
+        id:null,
+        name:null
+    },//valor del objeto por defecto,
+    params    : {modeljs: true}//aquí se configuran parámetros adicionales a enviar en los request
+   
+}
+
+```
+create core/index.js
+
+```js
+import Model from '@benjy2976/pmsg'
+import createApiService from '@/core/services/ApiService'
+const Apiservice = createApiService(import.meta.env.VITE_API_URL || 'http://localhost:8083/api')
+
+import configProduct from './product'
+import configBrand from './brand'
+export const Producto = new Model(configProduct, Apiservice)
+export const Brand = new Model(configBrand, Apiservice)
+
+```
+
+so where ever you are you can call the product Model
+
+```js
+import {Producto} from './core'
+
+Producto.show(1)
+//this code create a request to the server an return a request to the object with the id Nr 1
+```
+
+if you are using Pinia you can create the storeDefault
+crating the next structure
+```js
+/store
+/store/modules
+```
+into /store/modules you can create a products.js file
+```js
+//import {Product} from '../../models' //import if necessary
+
+
+const state = {
+    //here you can redefine or define new states
+    //by default its going to create the next stores
+    /
+    itemSelected:{},
+    items:Array[],
+    keysAsinc: [],
+    keysTemp: [],
+    key: config.key,
+    moduleAlias: config.moduleAlias,
+    maxRelationsResolve: config.maxRelationsResolve,
+    relations: config.relations,
+    syncStatus: config.sync,//here you define whether sync() or setItems() will be used
+    selectedStatus: false,
+    timeOutAsinc:null
+
+     
+    //you do not need to define it, it is going to create automatically 
+}
+
+const getters = {
+    //here you can redefine or define new getters
+    //by default its going to create the next getters
+    
+    key: 'id',
+    // Getter para obtener el nombre del objeto seleccionado
+    name: (id) => {...},
+    // Getter para obtener el objeto seleccionado
+    find: (id) => {...},
+    // Getter para obtener la lista de objetos
+    list: [...],
+    // Getter para obtener la lista de objetos filtrados
+    filter: (filter) => [...],
+    // Getter para obtener el objeto seleccionado
+    selected: {...}
+    // Getter para resolver las relaciones 
+    //** se debe de sobrecargar este metodo si se quiere poner funciones personalizadas***
+    resolve: {...}
+    
+   
+    // Getter para obtener el indice de la tabla
+    //you do not need to define it, it is going to create automatically 
+    //also you can create other getters if you need
+}
+
+const actions = {
+    //here you can redefine or define new actions
+    //by default its going to create the next actions
+    /* esta accion almacena todos los keys que con los que se le invoca en un periodo de 100ms para realizar una peticion al servicor con los datos de todas esas keys */
+    checkAsinc ({ state, getters, dispatch, commit }, key )//this action stores all the keys with which it is invoked in a period of 100ms to make a request to the service with the data of all those keys
+    /* esta accion invoca a  show del modelo y almacena la respuesta */
+    show ({ dispatch })//this action invoque at the show fron the model and store the response into the state.items
+    //*** esta acción invoca getAll(params) del modelo y almacena la respuesta en state.items. ***
+    get(params)//this action invoque at the getAll(params) from the model and store the response into a state.items 
+    //*** esta acción se invoca después de que se envía el get, puede redefinirlo si lo necesita ***
+    afterGet()//this action is called after the get is dispatched, you yo can redefine it if you need
+    //*** esta acción crea un nuevo item, llama a create(item) desde el modelo y agrega la respuesta ***
+    create(item)//this action create a new item, call to the create(item) from the model and add the response 
+    //at the state.items list
+    //*** esta acción modifica un  item, llama a update(item) desde el modelo y agrega la respuesta ***
+    update(item)//this action update a item, call to the update(item) from the model and add the response 
+    //at the state.items list
+    //*** esta acción elimina un nuevo elemento, llama a eliminar (elemento) del modelo y agrega la respuesta ***
+    delete(item)//this action delete a new item, call to the delete(item) from the model and add the response 
+    //*** action para llamar SET_ITEMS mutacion, para reemplazar todo el state.items ***
+    setItems(items)//action to call SET_ITEMS mutation, to replace all the state.items
+    //*** esta accion setea state.syncStatus ****
+    setSyncStatus(syncStatus)//this action set the state.syncStatus
+    //*** action para determinar si se actualizara un objeto o varios de acuerdo al formato de llegada de la data ***
+    sync(item/items)//action to determine if one object or several is updated according to the data arrival format
+    //*** action para sincronizar objetos (items) con los objetos almacenado en el store ***
+    syncItems(items)//action to synchronize objects (items) with the objects stored in the store
+    //*** action para sincronizar un objeto (item) con un objeto almacenado en el store ***
+    syncItem(item)//action to synchronize an object (item) with an object stored in the store
+    //at the state.items list
+    //*** estas acciones seleccionan un elemento de la lista de elementos y ponen el valor en un estado. ***
+    selectItem(id)//this actions select one item from the list of items and put the value into a state.item
+    //*** esta acción se llama después de que se envía el artículo seleccionado, puede redefinirlo si lo necesita ***
+    afterSelect()//this action is called after the selectItem is dispatched, you yo can redefine it if you need
+    //*** esta accion de seleccioan el itemSelected ***
+    deselect()//this action deselect the itemSelected
+    
+    //you do not need to define it, it is going to create automatically 
+    //also you can create other getters if you need
+}
+
+export default {
+  state,
+  getters,
+  actions,
+}
+
+
+```
+you need to create a file index.js into a /store folder you have two ways to declare the state
+
+````js
+import { defineStore } from "pinia";
+import { Producto } from '@/core/models/index.js';
+
+const {state,getters,actions} = Producto.getStore();
+const useProductosStore = defineStore(Producto.alias, {
+  state   : () => ({...state}),
+  getters : {...getters},
+  actions : {...actions},
+}
+)
+export default useProductosStore;
+````
+in your Component component.vue 
+
+in your app.js you can invoque like this
+````js
+
+
+import useProductosStore from '@/stores/auth/ProcutosStore'
+const productosStore = useProductosStore()
+
+productosStore.get().then(()=>{
+  console.log(productosStore.list)
+})
+
+````

package/eslint.config.js

@@ -0,0 +1,37 @@
+// eslint.config.js (CommonJS)
+import js from "@eslint/js";
+export default [
+  js.configs.recommended,
+  {
+    files           : ["**/*.js"],
+    languageOptions : {
+      ecmaVersion : "latest",
+      sourceType  : "module",
+      globals     : {
+        console        : "readonly",
+        window         : "readonly",
+        document       : "readonly",
+        setTimeout     : "readonly",
+        setInterval    : "readonly",
+        clearInterval  : "readonly",
+        localStorage   : "readonly",
+        sessionStorage : "readonly",
+        hashMd5        : "readonly",
+        __dirname      : "readonly",
+        URL            : "readonly",
+        // Agrega aquí cualquier otra global que uses
+      }
+    },
+    plugins : { vue },
+    rules   : {
+      "indent"      : ["error", 2],
+      "key-spacing" : [
+        "error",
+        {
+          "singleLine" : { beforeColon: false, afterColon: true },
+          "multiLine"  : { beforeColon: true, afterColon: true, align: "colon" }
+        }
+      ]
+    }
+  }
+];

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@benjy2976/pmsg",
+  "version": "0.1.0",
+  "description": "generator of models and store default for pinia",
+  "main": "src/Model.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/benjy2976/pmsg"
+  },
+  "keywords": [
+    "pinia",
+    "generator",
+    "model",
+    "store"
+  ],
+  "author": "Walther Raul II Benjamin Aguirre Tello",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/benjy2976/pmsg/issues"
+  },
+  "homepage": "https://github.com/benjy2976/pmsg#readme",
+  "dependencies": {
+    "axios": "^1.0.0",
+    "js-md5": "^0.8.3"
+  },
+  "devDependencies": {
+    "eslint": "^9.25.1",
+    "eslint-plugin-import": "^2.27.5",
+    "eslint-plugin-n": "^15.6.1",
+    "eslint-plugin-promise": "^6.1.1"
+  }
+}

package/src/Model.js

@@ -0,0 +1,217 @@
+import { md5 } from 'js-md5'
+import createModelStore from "./useModelStore"
+import axios from 'axios'
+export default class Model {
+
+  constructor(config, instance = null) {
+    this.instance = instance == null ? axios.create() : instance//axios instance
+    let defaultValues = {
+      alias               : null,// Alias utilizado para almacenar en el localstorage
+      route               : null,// Ruta donde se encuentra el resource
+      hash                : false,// La condicional si se va a validar el md5
+      sync                : false,// La condicional si se va sincronizar o reemplazar el state al hacer un nuevo request
+      store               : false,// La condicional que define si se guardara en el localstorage
+      methods             : null, // Define los métodos adicionales utilizados por el modelo
+      /*config for storeDefault*/
+      hasKey              : true,// Define si la tabla tiene primaryKey
+      key                 : 'id',// Define el primary key que se usara para acceder al objeto
+      name                : 'name',// Nombre del atributo name en la base de datos
+      maxRelationsResolve : 1,// Relaciones con otros models
+      relations           : [],// Relaciones con otros models
+      selectable          : false,// Condicional para definir si el objeto es seleccionable
+      default             : {},// Valor del objeto por defecto,
+      params              : { modeljs: true },// Aquí se configuran parámetros adicionales a enviar en los request excepto DELETE
+      modelGetters        : {}// Aquí se configuran parámetros adicionales a enviar en los request excepto DELETE
+    }
+    //config.hasKey=config.hasKey!=undefined?config.hasKey:config.key!=undefined
+    defaultValues = Object.assign(defaultValues, config)
+    this.alias = defaultValues.alias
+    this.route = defaultValues.route
+    this.hash = defaultValues.hash
+    this.sync = defaultValues.sync
+    this.store = defaultValues.store
+    for (const prop in defaultValues.methods) {
+      this[prop] = defaultValues.methods[prop]
+    }
+    this.singular = defaultValues.singular
+    this.plural = defaultValues.plural
+    this.key = defaultValues.key
+    this.hasKey = defaultValues.hasKey
+    this.name = defaultValues.name
+    this.maxRelationsResolve = defaultValues.maxRelationsResolve
+    this.relations = defaultValues.relations
+    this.selectable = defaultValues.selectable
+    this.default = defaultValues.default
+    this.params = defaultValues.params
+    this.modelGetters = defaultValues.modelGetters
+    this.state = {}
+    this.getters = {}
+    this.actions = {}
+  }
+
+  get(url = '', params = {}) {
+    params = Object.assign(params, this.params)
+    url = this.route + '/' + url
+    return this.instance.get(url, {
+      params : params,
+    })
+  }
+
+  post(url = '', params = {}) {
+    params = Object.assign(params, this.params)
+    url = this.route + '/' + url
+    return this.instance.post(url, params)
+  }
+
+  // Función para obtener el listado de Objetos de la base de datos
+  getAll(params = {}) {
+    params = Object.assign(params, this.params)
+    return this.instance.get(this.route, {
+      params : params,
+    })
+  }
+
+  // Función para crear un objeto en la base de datos
+  create(d) {
+    d = Object.assign(d, this.params)
+    return this.instance.post(this.route, d)
+  }
+
+  // Función para mostrar un objeto de la base de datos
+  show(params) {
+    let id = null
+    let d = this.params
+     
+    if (typeof params === 'object') {
+      id = params[this.key]
+      d = Object.assign(params, this.params)
+    } else {
+      id = params
+    }
+    return this.instance.get(this.route + '/' + id, {
+      params : d,
+    })
+  }
+
+  // Función para actualizar un objeto en la base de datos
+  update(d) {
+    d = Object.assign(d, this.params)
+    return this.instance.put(this.route + '/' + d[this.key], d)
+  }
+
+  // Función para eliminar un objeto de la base de datos
+  delete(d) {
+    return this.instance.delete(this.route + '/' + d[this.key], {
+      params : this.params,
+    })
+  }
+
+  // Función para verificar si la lista esta guardada en el local storage
+  async saved(params = {}) {
+    if (this.store) {
+      if (this.hash) {
+        await this.verificarHash(params)
+      }
+      return !!localStorage.getItem(this.alias)
+    } else
+      return this.store
+  }
+
+  // Función para almacenar la lista en el localstorage
+  save(p) {
+    if (this.store) {
+      localStorage.setItem(this.alias, JSON.stringify(p))
+    }
+  }
+
+  // Función para obtener lo almacenado en el localStorage
+  getFromLocalStorage() {
+    return JSON.parse(localStorage.getItem(this.alias))
+  }
+
+  // Función para eliminar lo  almacenado en el localstorage
+  destroy() {
+    localStorage.removeItem(this.alias)
+  }
+
+  // Función para verificar si el hash coincide con el que viene en la vista
+  async verificarHash (params = {}) {
+    let hashMd5 = await this.getAll({...params, hash: true})
+    if (!!localStorage.getItem(this.alias) && hashMd5.data !== md5(localStorage.getItem(this.alias))) {
+      localStorage.removeItem(this.alias)
+    }
+  }
+
+  // Getter para obtener el store por defecto para el modelo
+  setStore({ state = null, getters = null, actions = null }) {
+    this.state = state === null ? this.state : state
+    this.getters = getters === null ? this.getters : getters
+    this.actions = actions === null ? this.actions : actions
+    return this
+  }
+  // Getter para obtener el store por defecto para el modelo
+  getStore(state = null, getters = null, actions = null) {
+    this.state = state === null ? this.state : state
+    this.getters = getters === null ? this.getters : getters
+    this.actions = actions === null ? this.actions : actions
+    return createModelStore(this, this.state, this.getters, this.actions)
+  }
+
+  // Getter para obtener todos los parámetros de configuración del modelo
+  getConfig() {
+    return {
+      sync       : this.sync,
+      alias      : this.alias,
+      route      : this.route,
+      hash       : this.hash,
+      store      : this.store,
+      methods    : this.methods,
+      singular   : this.singular,
+      plural     : this.plural,
+      key        : this.key,
+      name       : this.name,
+      selectable : this.selectable,
+      default    : this.default
+    }
+  }
+
+  // Función para obtener los parámetros de configuración necesarios para el StoreDefault
+  getStoreConfig() {
+    return {
+      key                 : this.key,
+      hasKey              : this.hasKey,
+      moduleAlias         : this.alias,
+      maxRelationsResolve : this.maxRelationsResolve,
+      relations           : this.relations.map(relation => {
+        return {
+          ...relation,
+          ['hasMany'] : (relation.hasMany === undefined) ? false : relation.hasMany,
+          ['alias']   : (relation.alias === undefined) ? relation.attribute : relation.alias,
+
+        }
+      }),
+      sync : this.sync
+    }
+  }
+
+  // Getter para saber si se puede seleccionar un objeto de la lista de objetos
+  isSelectable() {
+    return this.selectable === true
+  }
+
+  // Getter para obtener el valor por default de el objeto
+  getDefault() {
+    //return JSON.parse(JSON.stringify(this.default))
+    //return {...Object.assign({},this.default),...this.getModelGetters()}
+    return Object.assign({}, JSON.parse(JSON.stringify(this.default)))
+  }
+  // Getter para obtener el valor por default de el objeto modelGetters
+  getModelGetters() {
+    return Object.assign({}, JSON.parse(JSON.stringify(this.modelGetters)))
+  }
+
+  // Getter para obtener el nombre del atributo que hace referencia al nombre del Objeto
+  getNameAttribute() {
+    return this.name
+  }
+}

package/src/helpers.js

@@ -0,0 +1,148 @@
+// helpers.js
+export function normalizeRelations(data, relations) {
+  return {
+    ...data,
+    ...relations.reduce(
+      (prev, relation) => ({
+        ...prev,
+        [relation.attribute] : Array.isArray(data[relation.attribute]) ?
+          data[relation.attribute].map(x => x.id) : data[relation.attribute].id
+      }), {}
+    )
+  };
+}
+export function resolveRelations(data, state, rootGetters, level=1) {
+  if(state.relations.length==0){
+    return data
+  }else{
+
+    return {
+      ...data,
+      ...state.relations.reduce(
+        (prev, relation) => {
+          let alias = relation.alias != undefined ? relation.alias : relation.attribute
+
+          if(state.maxRelationsResolve>=level){
+            return ({
+              ...prev,
+              [alias] : relationLinck(data, alias, relation, state.key, rootGetters, level+1)
+            })
+          }
+          else{
+            return ({
+              ...prev,
+              ['errorResolve'] : 'Max relation resolve exceded: resolved '+level+' times'
+            })
+          }
+
+        }, {}
+      )
+    };
+  }
+}
+
+function relationLinck(data, alias, relation, key, rootGetters, level) {
+  if (relation.hasMany === false) {
+    return Array.isArray(data[relation.alias]) ?
+      data[relation.alias].map(x => {return {...rootGetters[`${relation.module}/find`](x, level),pivot_id: x}}) :
+      {...rootGetters[`${relation.module}/find`](data[relation.attribute], level),pivot_id: data[relation.attribute]}
+  } else {
+    return rootGetters[`${relation.module}/filter`](d => d[relation.attribute] === data[key], level)
+  }
+}
+
+//esta funcion se usa para exportar las relaciones de un objeto
+export function exportRelations(data, state, dispatch, rootGetters) {
+  if(data.pivot!==undefined){
+    delete data.pivot
+  }
+  if(state.relations.length==0){
+    return data
+  }else
+    return {
+      ...data,
+      ...state.relations.reduce(
+        (prev, relation) => {
+          let attr = data[relation.alias]
+          if (attr !== undefined&&attr !== null) {
+            if(Array.isArray(attr)){
+              prev[relation.alias]= attr.map(obj => obj[rootGetters[`${relation.module}/key`]])
+              dispatch(`${relation.module}/syncItems`, attr, { root: true })
+            }
+            else if (typeof attr == 'object' || attr instanceof Object){
+              delete prev[relation.attribute]
+              dispatch(`${relation.module}/syncItem`, attr, { root: true })
+            }
+            return ({
+              ...prev
+            })
+          }
+          else {
+            return { ...prev }
+          }
+        }, {}
+      )
+    };
+}
+
+//esta funcion se usa para exportar las relaciones de un arreglo de objetos
+export function globalExportRelations(items, relations, dispatch, rootGetters) {
+  if(relations.length==0){
+    return items
+  }
+  relations=relations.map(d=>{return {...d,pivot: []}})
+  items=items.map(item => {
+    if(item.pivot!==undefined){
+      delete item.pivot
+    }
+    return {
+      ...item,
+      ...relations.reduce(
+        (prev, relation, currentIndex) => {
+          let attr = item[relation.alias]
+          if (attr !== undefined&&attr !== null) {
+            if(Array.isArray(attr)){
+              prev[relation.alias]= attr.map(obj => obj[rootGetters[`${relation.module}/key`]])
+              relations[currentIndex].pivot = relations[currentIndex].pivot.concat(attr)
+            }
+            else if (typeof attr == 'object' || attr instanceof Object){
+              delete prev[relation.attribute]
+              relations[currentIndex].pivot.push(attr)
+            }
+            return ({
+              ...prev
+            })
+          }
+          else {
+            return { ...prev }
+          }
+        }, {}
+      )
+    };
+  })
+  relations.forEach( (relation) =>{
+    if(relation.pivot.length>0){
+      dispatch(`${relation.module}/sync`, relation.pivot, { root: true })
+    }
+  })
+  return items
+}
+
+
+export function areObjEquals(foo, bar) {
+  let equal = true;
+
+  for (let [key, val] of Object.entries(foo)) {
+    if (Object.prototype.hasOwnProperty.call(bar, key))   {
+      if (bar[key] !== val) {
+        equal = false;
+      }
+    } else {
+      equal = false;
+    }
+
+    if (!equal) { break; }
+  }
+
+  return equal;
+}

package/src/useModelStore.js

@@ -0,0 +1,325 @@
+//import { resolveRelations, exportRelations, globalExportRelations, areObjEquals } from "./helpers"
+import { areObjEquals } from "./helpers";
+// import {  reactive, computed } from 'vue';
+
+
+export default function createModelStore (model, state = {}, getters = {}, actions = {}) {
+  const defData = {
+    key : 'id',
+  }
+  const config = Object.assign(defData, model.getStoreConfig())
+  let check =(d,data)=>{return d[config.key] === data[config.key]}
+  if ( config.hasKey){
+    if(Array.isArray(config.key)){
+      let check_str = config.key.reduce((a, key)=>a+` d['${key}'] === data['${key}'] &&`,'(d,data)=>{return')
+      check_str = check_str.substring(0, check_str.length-2)
+      check_str+='}'
+      check = eval(check_str)
+    }
+  }else{
+    console.warn(`El modulo ${config.moduleAlias} no tiene Keys, esto reducira el rendimiento` )
+    check=(d,data)=>{
+      return areObjEquals(d,data)
+    }
+  }
+  const resolveR = (item) => item
+  return {
+    state : {
+      itemSelected        : { loading: false, ...model.getDefault() },
+      items               : [],
+      keysAsinc           : [],
+      keysTemp            : [],
+      key                 : config.key,
+      moduleAlias         : config.moduleAlias,
+      maxRelationsResolve : config.maxRelationsResolve,
+      relations           : config.relations,
+      syncStatus          : config.sync,
+      selectedStatus      : false,
+      timeOutAsinc        : null,
+      check               : check,
+      ...state
+    },
+    getters : {
+      // Getter para obtener el indice de la tabla
+      //key     : ({key}) => { return key },
+      // Getter para obtener el indice de la tabla
+      default : () => { return model.getDefault() },
+      // Getter para obtener el nombre del objeto seleccionado
+      name    : ({ items, key }) => (id) => {
+        const item = items.find(d => d[key] === id)
+        return item ? item[model.getNameAttribute()] : null
+      },
+      // Getter para obtener el objeto seleccionado
+      find : ({ items, key }) => (id, level = 1) => {
+        const item = items.find(d => d[key] === id)
+        return item ? resolveR(item, level):model.getDefault()
+      },
+      // Getter para obtener la lista de objetos
+      list : ({items}) => {
+        return items.map(resolveR)
+      },
+      // Getter para obtener la lista de objetos filtrados
+      filter : ({items}) => (filter, level = 1) => {
+        return items.filter(filter).map(item => resolveR(item, level))
+      },
+      // Getter para obtener el objeto seleccionado o falso si no hay seleccion
+      selected : ({ itemSelected, selectedStatus }) => {
+        return selectedStatus ? resolveR(itemSelected) : selectedStatus
+      },
+      ...getters
+    },
+
+    actions : {
+
+      checkAsinc( key ){
+        return new Promise((resolve) => {
+          const fTime = () => {
+            let keys=[]
+            keys=keys.concat(this.keysTemp)
+            if (Array.isArray(keys)) {
+              this.keysAsinc = this.keysAsinc.concat(keys)
+            } else {
+              this.keysAsinc.push(keys)
+            }
+            this.keysTemp=[]
+            let params={}
+            params[this.key]=['IN'].concat(keys)
+            this.getSome(params)
+            this.timeOutAsinc = null
+          }
+          if (Array.isArray(key)) {
+            let keys=key
+            key.forEach((d,i)=>{
+              if((this.items.findIndex(d1=>(d1[this.key]==d))!=-1)||(this.keysAsinc.indexOf(d)!=-1)||(this.keysTemp.indexOf(d)!=-1))
+              {
+                keys.splice(i,1)
+              }
+            })
+            if(keys.length>0){
+              this.keysTemp=this.keysTemp.concat(keys)
+            }
+            if(this.timeOutAsinc == null){
+              this.timeOutAsinc = setTimeout(fTime, 100)
+            }
+            resolve( keys)
+          }
+          else{
+            const item = this.find(key)
+            if(item[this.key]==null){
+              if(!this.keysAsinc.find(d=>d==key)&&!this.keysTemp.find(d=>d==key)){
+                this.keysTemp.push(key)
+              }
+              if(this.timeOutAsinc == null){
+                this.timeOutAsinc = setTimeout(fTime, 100)
+              }
+            }
+            resolve(item)
+          }
+        })
+      },
+      // Action para obtener un registro por el (key) del servicor
+      show(id){
+        //var commit = store.commit
+        return new Promise((resolve, reject) => {
+          model.show(id).then(response => {
+            this.syncItem(response.data)
+            resolve(response);
+          }).catch(reject);
+        })
+      },
+      // Action para obtener la lista de objetos de el servidor
+      async get (params = {}) {
+      //var commit = store.commit
+        const action = this.syncStatus ? 'sync' : 'setItems';
+
+        if (!(await model.saved(params))) {
+          return new Promise((resolve, reject) => {
+            model.getAll(params).then(response => {
+              const data = response.data;
+              model.save(data.data);
+              this[action](data.data);
+              this.afterGet();
+              resolve(response);
+            }).catch(reject);
+          })
+        } else {
+          this[action](model.getFromLocalStorage());
+          this.afterGet();
+        }
+      },
+
+      // Action para obtener la lista de algunos objetos de el servidor sin consultar ni almacenar en el localstorage
+      getSome( params = {}){
+        //var commit = store.commit
+        return new Promise((resolve, reject) => {
+          model.getAll(params).then(response => {
+            this.sync(response.data);
+            this.afterGet();
+            resolve(response);
+          }).catch(reject);
+        })
+      },
+      // Action para limpiar el state y  obtener la lista de algunos objetos de el servidor
+      clearAndGet(params = {}){
+        return new Promise((resolve, reject) => {
+          //  se agrega esta linea "dispatch('setItems', [])" para que al momento de cargar los nuevos datos la reactividad sea mas veloz
+          // divide y vencceras
+          this.setItems([]);
+          model.getAll(params).then(response => {
+            this.setItems(response.data);
+            this.afterGet();
+            resolve(response);
+          }).catch(reject);
+        })
+      },
+      // Action que se ejecuta después de obtener la lista de objetos
+      afterGet(){
+        //
+      },
+
+      // Action para crear un objeto en la base de datos y en la lista de objetos
+      create( data){
+        return new Promise((resolve, reject) => {
+          model.create(data).then(response => {
+            this.syncItem(response.data.data);
+            resolve(response)
+          }).catch(error => {
+            reject(error)
+          })
+        })
+      },
+
+      // Action para actualizar un objeto en la base de datos y en la lista de objetos
+      update( data){
+        return new Promise((resolve, reject) => {
+          model.update(data).then(response => {
+            this.syncItem(response.data.data);
+            resolve(response)
+          }).catch(error => {
+            reject(error)
+          })
+        })
+      },
+
+      // Action para eliminar un objeto de la base de datos y de la lista de objetos
+      delete(data){
+        return new Promise((resolve, reject) => {
+          model.delete(data).then(response => {
+            let index = this.items.findIndex(d => this.check(d,data))
+            this.items.splice(index, 1)
+            resolve(response)
+          }).catch(error => {
+            reject(error)
+          })
+        })
+      },
+      /*
+      ***** action para setear objetos (items)  en el store ***
+      */
+      setItems (items)  {
+
+        /* if(state.relations.length>0&&items.length>0){
+        let relations = state.relations
+        relations = relations.filter(relation=>{
+          let alias = relation.alias != undefined ? relation.alias : relation.attribute
+          return items[0][alias]!=undefined
+        })
+        //items = globalExportRelations(items, relations, dispatch, rootGetters)
+      } */
+        this.items = items
+      },
+      /*
+      ***** action para setear el syncStatus ***
+      */
+      setSyncStatus( syncStatus){
+        this.syncStatus = syncStatus
+      },
+      /*
+      ***** action para determinar si se actualizara un objeto o varios de acuerdo al formato de llegada de la data ***
+      */
+      sync(data){
+        if (typeof data === 'object' && data !== null) {
+          if (Array.isArray(data)) {
+            this.syncItems(data);
+          } else {
+            this.syncItem(data);
+          }
+        }
+      },
+
+      addToRelation({relation, id, relations}){
+        if (this.relations.some(r=>r.alias==relation)) {
+          let index = this.items.findIndex(d => d[this.key] === id)
+          if(Array.isArray(relations)){
+            this.items[index][relation] = this.items[index][relation].cocat(relations)
+          }else{
+            this.items[index][relation].push(relations)
+          }
+        }
+      },
+      /*
+      ***** action para sincronizar objetos (items) con los objetos almacenado en el store ***
+      */
+      syncItems(items){
+        //este filter elimina los valores duplicados
+        items=items.filter((data, index, array)=>array.findIndex(d=>this.check(d,data)) === index)
+        /* if(this.state.relations.length>0&&items.length>0){
+          let relations = this.state.relations
+          relations = relations.filter(relation=>{
+            let alias = relation.alias != undefined ? relation.alias : relation.attribute
+            return items[0][alias]!=undefined
+          })
+          items = globalExportRelations(items, relations, dispatch, rootGetters)
+        } */
+        let insert = items.filter( (item) =>{
+          let i = this.items.findIndex(d=>this.check(d,item))
+          if (i > -1) {
+            this.items[i] = Object.assign(this.items[i], item)
+            return false
+          }else{
+            return true
+          }
+        });
+        this.items = this.items.concat(insert)
+      },
+      /*
+      ***** action para sincronizar un objeto (item) con un objeto almacenado en el store ***
+      */
+      syncItem(item){
+        // cambio this.state.items por this.items
+        //item = resolveRelations(item, this.state, dispatch, rootGetters));
+        if (this.find(item[this.key])[this.key] !== null && this.find(item[this.key])[this.key] !== undefined) {
+          //UPDATE
+          let index = this.items.findIndex(d => this.check(d,item))
+          this.items[index] = Object.assign(this.items[index], item)
+        } else {
+          //CREATE
+          this.items.push(item)
+        }
+      },
+      
+      /********* MUTACIONES COMO ACTIONS */
+      // Mutation para setear el listado de objetos
+      SET_ITEMS( items ){
+        /* if(state.relations.length>0&&items.length>0){
+          let relations = state.relations
+          relations = relations.filter(relation=>{
+            let alias = relation.alias != undefined ? relation.alias : relation.attribute
+            return items[0][alias]!=undefined
+          })
+          items = globalExportRelations(items, relations, dispatch, rootGetters)
+        } */
+        this.items = items
+      },
+
+      ADD_ITEMS(items){
+        if (Array.isArray(items)) {
+          this.items = this.items.concat(items)
+        } else {
+          this.items.push(items)
+        }
+      },
+      ...actions
+    }
+  };
+}