@obisey/nest 0.1.0

package/prototipos/baseService.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redis_on = void 0;
+exports.BaseService = BaseService;
+const chalk = require('chalk');
+const log = console.log;
+var imprimir = (texto) => {
+    // log(chalk.blue(texto))
+};
+const lodash_1 = require("lodash");
+const cachear_1 = require("./utils/cachear");
+const cifrado_1 = require("./utils/cifrado");
+const redisStore_1 = require("../redisStore");
+const keyInterface_1 = require("./utils/keyInterface");
+exports.redis_on = true;
+const paginar_1 = require("./utils/paginar");
+var isDev = false;
+var stringifWhere = (where) => (0, lodash_1.isObject)(where)
+    ? JSON.stringify(Object.entries(where).reduce((ac, [a, v]) => {
+        var valor = () => {
+            if (!v)
+                return null;
+            if ((0, lodash_1.isNumber)(v))
+                return v;
+            return Object.getOwnPropertySymbols(v).map((e) => v[e]);
+        };
+        return {
+            ...ac,
+            [a]: valor(),
+        };
+    }, {}))
+    : null;
+var stringifyInclude = ({ where, as, include }) => ({
+    where: stringifWhere(where),
+    as,
+    include: include ? include.map((n) => stringifyInclude(n)) : null,
+});
+function BaseService(modelo) {
+    return class BaseService {
+        constructor(cacheManager, receptor = null) {
+            this.cacheManager = cacheManager;
+            this.receptor = receptor;
+        }
+        buscarXid({ value: { id, cacheable }, key, Clase, repository, pagina, }) {
+            return new Promise(async (resolve, reject) => {
+                let tiempo;
+                // if (isDev) tiempo = moment();
+                try {
+                    if (['general', 'ecommerce', 'ecreator'].includes(key.universo) &&
+                        !key.IdEmpresa) {
+                        key.IdEmpresa = await this.receptor.buscarEmpresa();
+                    }
+                    let nkey = `${key.universo ? key.universo : 'pro'}:${key.IdEmpresa}:${key.fragmentos[0].nombre}:${id}`;
+                    const { resultado, cache } = await (0, cachear_1.cachear)(cacheable, this.cacheManager, (0, keyInterface_1.transformarKey)({ ...key }), (cache) => {
+                        return Promise.resolve(new repository.sequelize.models[(0, lodash_1.capitalize)(modelo)](JSON.parse(cache)));
+                    }, //Revisar
+                    (resultado) => {
+                        return Promise.resolve(resultado
+                            ? JSON.stringify(resultado.get({ plain: true }))
+                            : null);
+                    }, //transformar
+                    () => repository.findByPk(id), //Pedir
+                    () => new Promise(async (resolve) => {
+                        //observar
+                        let e = await this.cacheManager.store.hexists(nkey, 'item');
+                        if (e) {
+                            let item = await this.cacheManager.store.hget(nkey, 'item');
+                            resolve(item);
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    }), (__, resultado) => {
+                        if (resultado)
+                            return this.cacheManager.store.hset(nkey, 'item', resultado);
+                        else
+                            return false;
+                    });
+                    if (resultado)
+                        await (0, paginar_1.paginar)(this.cacheManager, key.IdEmpresa, pagina, modelo, resultado.get({ plain: true }));
+                    if (isDev)
+                        console.log(
+                        // moment().diff(moment(tiempo), 'milliseconds', true),
+                        'buscarXid', cache);
+                    resolve(resultado);
+                }
+                catch (err) {
+                    console.log('buscarXid', { modelo, id, err });
+                    reject({ modelo, id, err });
+                }
+            });
+        }
+        buscarTodos({ value, key, Clase, repository, pagina, cacheable, }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let tiempo;
+                    // if (isDev) tiempo = moment();
+                    if (['general', 'ecommerce', 'ecreator'].includes(key.universo) &&
+                        !key.IdEmpresa) {
+                        key.IdEmpresa = await this.receptor.buscarEmpresa();
+                    }
+                    let include = value.include
+                        ? value.include.map((n) => stringifyInclude(n))
+                        : '';
+                    let where = value.where ? stringifWhere(value.where) : null;
+                    let prekey = `${key.universo ? key.universo : 'pro'}:${key.IdEmpresa}:${key.fragmentos[0].nombre}`;
+                    let nkey = `${prekey}:paginacion`;
+                    let pkey = (id) => `${prekey}:${id}`;
+                    let peticion = (0, cifrado_1.cifrado)({
+                        where,
+                        include,
+                        order: value.order,
+                        limite: value.limit,
+                        pagina: value.pagina ? value.pagina : 1,
+                    });
+                    if (value.cacheable !== null ||
+                        value.cacheable !== undefined)
+                        cacheable = value.cacheable;
+                    const { resultado, cache } = await (0, cachear_1.cachear)(cacheable, this.cacheManager, (0, keyInterface_1.transformarKey)({
+                        nombre: `buscarTodos:pagina:${value.pagina ? value.pagina : 1}:limite${value.limit}`,
+                        ...key,
+                        include,
+                        where,
+                    }), (cache) => Promise.resolve(cache.map((n) => new repository.sequelize.models[(0, lodash_1.capitalize)(modelo)](JSON.parse(n)))), //Revisar
+                    (resultado) => Promise.resolve(resultado.map((n) => n.get({ plain: true }))), //transformar
+                    () => new Promise((resolve) => {
+                        resolve(repository.findAll(value)); //Pedir
+                    }), () => new Promise(async (resolve) => {
+                        let e = await this.cacheManager.store.hexists(nkey, peticion);
+                        if (e) {
+                            let ids = await this.cacheManager.store.hget(nkey, peticion);
+                            if (ids) {
+                                Promise.all(JSON.parse(ids).map(async (id) => await this.cacheManager.store.hexists(pkey(id), 'item'))).then((exists) => {
+                                    if (!exists.includes(0)) {
+                                        Promise.all(JSON.parse(ids).map(async (id) => await this.cacheManager.store.hget(pkey(id), 'item'))).then(resolve);
+                                    }
+                                    else
+                                        resolve(undefined);
+                                });
+                            }
+                            else
+                                resolve(undefined);
+                        }
+                        else
+                            resolve(undefined);
+                    }), //observar
+                    (__, resultado) => {
+                        return this.cacheManager.store.hset(nkey, peticion, JSON.stringify(resultado.map((n) => n.id)));
+                    });
+                    await (0, paginar_1.paginar)(this.cacheManager, key.IdEmpresa, pagina, modelo, resultado.map((n) => n.get({ plain: true })));
+                    if (isDev)
+                        console.log(
+                        // moment().diff(moment(tiempo), 'milliseconds', true),
+                        'paginacion', cache);
+                    resolve(resultado ? resultado : []);
+                }
+                catch (err) {
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        crear({ value, key, Clase, repository, borrarSSR, }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let IdEmpresa = key.IdEmpresa;
+                    console.log({ key: key.IdEmpresa });
+                    if (['general', 'ecommerce', 'ecreator'].includes(key.universo) &&
+                        !key.IdEmpresa) {
+                        IdEmpresa = await this.receptor.buscarEmpresa();
+                    }
+                    let item = await repository.create(value);
+                    const keys = [
+                        `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:${modelo}`,
+                        `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:${modelo}:paginacion`,
+                        `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:${modelo}:contar`,
+                        `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:sub${modelo}*`,
+                        `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:pre${modelo}`,
+                        `${key.universo ? key.universo : 'pro'}:${IdEmpresa}:arbol:${modelo}`,
+                    ];
+                    console.log(`Keys a eliminar::::`, keys);
+                    await this.eliminarCache(keys, borrarSSR);
+                    // imprimir(`${modelo} ${item.id} crear`)
+                    // let key$ : string = transformarKey({
+                    //     ...key,
+                    //     fragmentos : [
+                    //         {
+                    //             ...key.fragmentos[0], id : item.id
+                    //         }
+                    //     ]
+                    // })
+                    // await this.cacheManager.keys(`*-${modelo}*`)
+                    // .then(keys => Promise.all(keys.map(key => this.cacheManager.del(key))))
+                    // .then(() => this.cacheManager.set(key$, JSON.stringify(item), "EX", tiempo))
+                    resolve(item);
+                }
+                catch (err) {
+                    console.log({ err });
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        contar({ value, repository, key }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    let tiempo;
+                    // if (isDev) tiempo = moment();
+                    if (['general', 'ecommerce', 'ecreator'].includes(key.universo) &&
+                        !key.IdEmpresa) {
+                        key.IdEmpresa = await this.receptor.buscarEmpresa();
+                    }
+                    let include = value.include
+                        ? value.include.map((n) => stringifyInclude(n))
+                        : '';
+                    let where = value.where ? stringifWhere(value.where) : null;
+                    let nkey = `${key.universo ? key.universo : 'pro'}:${key.IdEmpresa}:${key.fragmentos[0].nombre}:contar`;
+                    let peticion = (0, cifrado_1.cifrado)({
+                        where,
+                        include,
+                        order: null,
+                        limite: null,
+                        pagina: null,
+                    });
+                    const { resultado, cache } = await (0, cachear_1.cachear)(value.cacheable, this.cacheManager, (0, keyInterface_1.transformarKey)({
+                        nombre: 'contar',
+                        ...key,
+                        include,
+                        where: stringifWhere(where),
+                    }), (cache) => Promise.resolve(JSON.parse(cache)), //Revisar
+                    (resultado) => Promise.resolve(JSON.stringify(resultado)), //transformar
+                    () => repository.count({ ...value, distinct: false }), //Pedir
+                    () => new Promise(async (resolve) => {
+                        let e = await this.cacheManager.store.hexists(nkey, peticion);
+                        if (e) {
+                            let item = await this.cacheManager.store.hget(nkey, peticion);
+                            if (item) {
+                                resolve(item);
+                            }
+                            else {
+                                resolve(undefined);
+                            }
+                        }
+                        else {
+                            resolve(undefined);
+                        }
+                    }), //observar
+                    (__, resultado) => {
+                        return this.cacheManager.store.hset(nkey, peticion, resultado);
+                    });
+                    // let key$ : string = transformarKey({ nombre : 'contar', ...key, include, where : stringifWhere(where) })
+                    // const cache = await this.cacheManager.get(key$)
+                    // if(onRedis(cache, true)){
+                    //     resultado = JSON.parse( cache )
+                    // }else{
+                    // imprimir(`${modelo} contar`),
+                    // resultado = await repository.count({...value, distinct: false }),
+                    // this.cacheManager.set(key$,  JSON.stringify(resultado), "EX", tiempo)
+                    // }
+                    if (isDev)
+                        console.log(
+                        // moment().diff(moment(tiempo), 'milliseconds', true),
+                        'contar', cache);
+                    resolve(resultado);
+                }
+                catch (err) {
+                    console.log({ err });
+                    reject({ err });
+                }
+            });
+        }
+        actualizar({ value, options, key, Clase, repository, borrarSSR, }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    if (['general', 'ecommerce', 'ecreator'].includes(key.universo) &&
+                        !key.IdEmpresa) {
+                        key.IdEmpresa = await this.receptor.buscarEmpresa();
+                    }
+                    let resultado = await repository.update(value, options);
+                    // let key$ : string = transformarKey(key)
+                    const item = await repository.findByPk(value.id);
+                    await this.eliminarCache([`*:${modelo}*`], borrarSSR);
+                    // await this.cacheManager.keys(`*:${modelo}*`) //Obten todos los keys
+                    // .then(keys => Promise.all(keys.map(key => this.cacheManager.del(key))))
+                    resolve(item);
+                }
+                catch (err) {
+                    console.log(err);
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        reescribir({ value, options, repository }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    imprimir(`${modelo} ${value.id} reescribir`);
+                    let resultado = await repository.upsert(value, options);
+                    resolve(resultado);
+                }
+                catch (err) {
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        destruir({ value, repository, borrarSSR, }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    imprimir(`${modelo} ${value.id} destruir`);
+                    let resultado = await repository.destroy(value);
+                    this.cacheManager
+                        .keys(`*:${modelo}*`) //Obten todos los keys
+                        .then((keys) => Promise.all(keys.map((key) => this.cacheManager.del(key))));
+                    resolve(resultado);
+                }
+                catch (err) {
+                    console.log({ modelo, value, err });
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        buscaryContar({ value, key, Clase, repository, pagina, }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    if (['general', 'ecommerce', 'ecreator'].includes(key.universo) &&
+                        !key.IdEmpresa) {
+                        key.IdEmpresa = await this.receptor.buscarEmpresa();
+                    }
+                    let resultado;
+                    let key$ = (0, keyInterface_1.transformarKey)(key);
+                    // const cache = await this.cacheManager.get(key$);
+                    // if(onRedis(cache, true)){
+                    //     resultado = JSON.parse( cache )
+                    // } else{
+                    resultado = await repository.findAndCountAll(value);
+                    // this.cacheManager.set(key$, JSON.stringify(resultado.get({plain : true})), "EX", tiempo)
+                    // }
+                    resolve(resultado);
+                }
+                catch (err) {
+                    console.log({ modelo, value, err });
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        buscarOcrear({ value, repository }) {
+            return new Promise(async (resolve, reject) => {
+                try {
+                    imprimir(`${modelo} buscarOcrear`);
+                    let resultado = await repository.findOrCreate(value);
+                    resolve(resultado);
+                }
+                catch (err) {
+                    console.log({ err });
+                    reject({ modelo, value, err });
+                }
+            });
+        }
+        async eliminarCache(items, borrarSSR = false) {
+            if (borrarSSR)
+                redisStore_1.clientSsr.flushdb();
+            log(chalk.red('SSR: SE ELIMINOOOO ALGOOO!!!!!!!!!!!!!!', items, borrarSSR));
+            return Promise.all(items.map(async (item) => this.cacheManager
+                .keys(`*${item}*`)
+                .then((keys) => Promise.all(keys.map((key) => this.cacheManager.del(key))))));
+        }
+    };
+}

package/prototipos/config.d.ts

@@ -0,0 +1 @@
+export declare const redis_on = true;

package/prototipos/config.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redis_on = void 0;
+exports.redis_on = true;

package/prototipos/index.d.ts

@@ -0,0 +1,8 @@
+export * from './baseService';
+export * from './baseResolver';
+export * from './baseController';
+export * from './utils/paginar';
+export * from './utils/keyInterface';
+export * from './utils/cifrado';
+export * from './utils/cachear';
+export * from './utils/activarRedis';

package/prototipos/index.js

@@ -0,0 +1,25 @@
+"use strict";
+// src/index.ts
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./baseService"), exports);
+__exportStar(require("./baseResolver"), exports);
+__exportStar(require("./baseController"), exports);
+__exportStar(require("./utils/paginar"), exports);
+__exportStar(require("./utils/keyInterface"), exports);
+__exportStar(require("./utils/cifrado"), exports);
+__exportStar(require("./utils/cachear"), exports);
+__exportStar(require("./utils/activarRedis"), exports);

package/prototipos/utils/activarRedis.d.ts

@@ -0,0 +1 @@
+export declare function onRedis(datos: any, si?: boolean): any;

package/prototipos/utils/activarRedis.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.onRedis = onRedis;
+const lodash_1 = require("lodash");
+function onRedis(datos, si = false) {
+    // return false
+    if (si && datos) {
+        return (0, lodash_1.isString)(datos);
+    }
+    return false;
+}

package/prototipos/utils/cachear.d.ts

@@ -0,0 +1,4 @@
+export declare const cachear: (cacheable: boolean, cacheManager: any, key: string, revisar: (x: any) => Promise<any>, transformar: (x: any) => Promise<any>, pedir: () => Promise<any>, observar?: (x: any) => Promise<any>, actualizar?: (x: any, datos: any) => Promise<any>) => Promise<{
+    resultado: any;
+    cache: boolean;
+}>;

package/prototipos/utils/cachear.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cachear = void 0;
+const lodash_1 = require("lodash");
+const chalk = require('chalk');
+const log = console.log;
+var imprimir = (texto) => log(chalk.blue(texto));
+var tiempo = 86400000;
+const cachear = (cacheable, cacheManager, key, revisar, transformar, pedir, observar = (key) => cacheManager.get(key), actualizar = (key, datos) => cacheManager.set(key, datos, 'EX', tiempo)) => {
+    return new Promise(async (resolve) => {
+        try {
+            const cache = await observar(key);
+            let resultado;
+            // console.log({ cache, cacheable })
+            if (!(0, lodash_1.isUndefined)(cache) && ((0, lodash_1.isUndefined)(cacheable) || cacheable)) {
+                resultado = await revisar(cache);
+                resolve({ cache: true, resultado });
+                return;
+            }
+            resultado = await pedir();
+            // console.log({resultado})
+            let datos = await transformar(resultado);
+            await actualizar(key, datos);
+            resolve({ cache: false, resultado });
+            return;
+        }
+        catch (err) {
+            console.log({ key, err });
+        }
+    });
+};
+exports.cachear = cachear;

package/prototipos/utils/cifrado.d.ts

@@ -0,0 +1,7 @@
+export declare var cifrado: ({ where, include, order, limite, pagina }: {
+    where: any;
+    include: any;
+    order: any;
+    limite: any;
+    pagina: any;
+}, origen?: any) => string;

package/prototipos/utils/cifrado.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cifrado = void 0;
+var cifrado = ({ where, include, order, limite, pagina }, origen = null) => {
+    where = where ? where : {};
+    include = include ? include : {};
+    order = order ? order : [];
+    limite = limite ? limite : null;
+    pagina = pagina ? pagina : null;
+    // console.log( `${JSON.stringify(where)}${JSON.stringify(include)}${JSON.stringify(order)}`, origen )
+    return `${JSON.stringify(where)}${JSON.stringify(include)}${JSON.stringify(order)}${JSON.stringify(limite)}${JSON.stringify(pagina)}`;
+};
+exports.cifrado = cifrado;

package/prototipos/utils/formarInclude.d.ts

@@ -0,0 +1,48 @@
+export declare const formarInclude: (include: any, mapa: any, tipo: any, conexion: any, required?: boolean) => Promise<any>;
+declare class FilterBasic {
+    is: string;
+}
+export declare class FilterString extends FilterBasic {
+    like: string;
+    notLike: string;
+    or: string[];
+    eq: string;
+}
+export declare class FilterNumber {
+    eq: number;
+    not: string;
+    or: number[];
+    gt: number;
+    gte: number;
+    lt: number;
+    lte: number;
+    between: number[];
+    notBetween: number[];
+    in: number[];
+}
+export declare class FilterFloat {
+    eq: number;
+    not: string;
+    or: number[];
+    gt: number;
+    gte: number;
+    lt: number;
+    lte: number;
+    between: number[];
+    notBetween: number[];
+    in: number[];
+}
+export declare class FilterDate {
+    between: Date[];
+    or: string;
+    gte: Date;
+    lte: Date;
+    eq: Date;
+}
+export declare class FilterBoolean extends FilterBasic {
+    eq: boolean;
+    between: number;
+    or: boolean[];
+    not: boolean;
+}
+export {};