@techderos/db-orchestrator v1.0.5

@techderos/db-orchestrator

Orquestador de base de datos para microservicios TechDeros.

Instalación

npm install @techderos/db-orchestrator

Uso

import { createOrchestrator } from '@techderos/db-orchestrator';

// Crear una instancia del orquestador
const orchestrator = createOrchestrator({
    maxConnections: 10,
    connectionTimeout: 5000,
    retryAttempts: 3
});

// Crear una conexión
const client = await orchestrator.createConnection({
    type: 'prisma',
    config: {
        datasources: {
            db: {
                url: process.env.DATABASE_URL
            }
        }
    }
});

// Cerrar todas las conexiones
await orchestrator.closeAllConnections();

// Obtener estadísticas
const stats = await orchestrator.getStats();

Configuración

OrchestratorConfig

interface OrchestratorConfig {
    maxConnections: number;    // Número máximo de conexiones simultáneas
    connectionTimeout: number; // Tiempo de espera para conexiones en milisegundos
    retryAttempts: number;     // Número de intentos de reconexión
}

ConnectionConfig

interface ConnectionConfig {
    type: 'prisma';
    config: {
        datasources: {
            db: {
                url: string;   // URL de conexión a la base de datos
            };
        };
    };
}

Características

• Gestión centralizada de conexiones a la base de datos
• Control de conexiones simultáneas
• Reconexión automática
• Estadísticas de uso
• Soporte para múltiples instancias de PrismaClient

Licencia

MIT

DB Orchestrator - TechDeros

Este es el orquestador de base de datos para los microservicios de TechDeros.

Proceso de Publicación del Orquestador

1. Preparación del Paquete

1. Verificar el package.json:

{
  "name": "@techderos/db-orchestrator",
  "version": "1.0.0",
  "description": "Orquestador de base de datos para microservicios TechDeros",
  "main": "generated/client/index.js",
  "types": "generated/client/index.d.ts",
  "scripts": {
    "build": "prisma generate",
    "migrate": "prisma migrate deploy",
    "seed": "ts-node prisma/seed.ts"
  }
}

2. Generar el cliente Prisma:

npx prisma generate

3. Construir el proyecto:

npm run build

2. Publicación en npm

1. Crear cuenta en npm:

   • Registrarse en npmjs.com
   • Verificar el email

2. Iniciar sesión en npm:

npm login

3. Crear organización (si no existe):

npm org create techderos

4. Publicar el paquete:

# Primera publicación
npm publish --access public

# Para actualizaciones
npm version patch  # o minor/major según corresponda
npm publish

3. Verificación

1. Verificar la publicación:

npm view @techderos/db-orchestrator

2. Probar la instalación:

# En un directorio de prueba
npm install @techderos/db-orchestrator

4. Mantenimiento

1. Actualizaciones:

# Incrementar versión
npm version patch  # para correcciones
npm version minor  # para nuevas características
npm version major  # para cambios incompatibles

# Publicar
npm publish

2. Deprecación:

npm deprecate @techderos/db-orchestrator "mensaje de deprecación"

5. Consideraciones Importantes

1. Versionado Semántico:

   • MAJOR: Cambios incompatibles con versiones anteriores
   • MINOR: Nuevas características compatibles
   • PATCH: Correcciones de errores compatibles

2. Documentación:

   • Mantener el README.md actualizado
   • Documentar cambios importantes
   • Incluir ejemplos de uso

3. Seguridad:

   • No incluir información sensible
   • Usar .npmignore para excluir archivos innecesarios
   • Mantener las dependencias actualizadas

Publicación del Orquestador

Antes de poder instalar el orquestador como paquete npm, es necesario publicarlo:

1. Preparar el paquete:

# En el directorio del orquestador
npm login  # Iniciar sesión en npm
npm publish --access public  # Publicar el paquete

2. Verificar la publicación:

npm view @techderos/db-orchestrator

3. Para actualizaciones:

# Incrementar la versión en package.json
npm version patch  # o minor/major según corresponda
npm publish

Desarrollo Local

Para desarrollo local, puedes usar el orquestador de dos formas:

1. Usando npm link:

# En el directorio del orquestador
npm link

# En el directorio del microservicio
npm link @techderos/db-orchestrator

2. Usando una ruta local en package.json:

{
  "dependencies": {
    "@techderos/db-orchestrator": "file:../ruta/al/orquestador"
  }
}

Dependencias en el Microservicio

Al instalar el orquestador por cualquiera de los métodos, se agregará automáticamente la dependencia en el package.json del microservicio:

1. Instalación vía npm:

{
  "dependencies": {
    "@techderos/db-orchestrator": "^1.0.0"
  }
}

2. Instalación vía git submodule:

{
  "dependencies": {
    "@techderos/db-orchestrator": "file:./prisma"
  }
}

3. Instalación vía npm link:

{
  "dependencies": {
    "@techderos/db-orchestrator": "link"
  }
}

Después de la instalación, es importante ejecutar:

npm install

para asegurar que todas las dependencias se instalen correctamente.

Instalación

Como paquete npm (recomendado)

npm install @techderos/db-orchestrator

Como submódulo git

git submodule add <url-del-repositorio> prisma

Instalación en Microservicios

Para instalar y configurar el orquestador en cada microservicio, sigue estos pasos:

1. Instalar el paquete en el microservicio:

# Dentro del directorio del microservicio
npm install @techderos/db-orchestrator

2. Crear la estructura de configuración:

# Crear directorio para la configuración
mkdir -p src/config

3. Crear el archivo de configuración del cliente Prisma:

// src/config/prisma.ts
import { PrismaClient } from '@techderos/db-orchestrator';

const prisma = new PrismaClient({
  log: ['query', 'info', 'warn', 'error'],
  datasources: {
    db: {
      url: process.env.DATABASE_URL
    }
  },
});

export default prisma;

4. Configurar las variables de entorno:

# .env en el microservicio
DATABASE_URL="postgresql://usuario:contraseña@host:puerto/base_de_datos?schema=techderosdb"

Consideraciones Importantes para Microservicios

1. Cada microservicio debe tener:

   • Su propia instalación del orquestador
   • Su propio archivo de configuración
   • Sus propias variables de entorno

2. Base de datos:

   • Todos los microservicios apuntan a la misma base de datos
   • Cada microservicio puede tener su propio usuario de base de datos
   • Los permisos se manejan a nivel de base de datos

3. Migraciones:

   • Las migraciones se ejecutan desde el orquestador
   • Los microservicios solo consumen las migraciones, no las crean

Ejemplo de Uso en un Microservicio

// src/services/order.service.ts
import prisma from '../config/prisma';

export class OrderService {
  async createOrder(data: {
    userId: string;
    empresaId: number;
    // ... otros datos
  }) {
    return await prisma.order.create({
      data: {
        ...data,
        status: 'PENDING'
      }
    });
  }
}

Configuración

1. Agregar las variables de entorno necesarias en tu archivo .env:

DATABASE_URL="postgresql://usuario:contraseña@host:puerto/base_de_datos?schema=techderosdb"

2. En tu microservicio, crear un archivo de configuración para Prisma:

// prisma/client.ts
import { PrismaClient } from '@techderos/db-orchestrator';

const prisma = new PrismaClient({
  log: ['query', 'info', 'warn', 'error'],
  datasources: {
    db: {
      url: process.env.DATABASE_URL
    }
  },
});

export default prisma;

Uso

import prisma from './prisma/client';

// Ejemplo de uso
async function ejemplo() {
  const usuarios = await prisma.user.findMany();
  console.log(usuarios);
}

Migraciones

Para ejecutar las migraciones en tu microservicio:

npx prisma migrate deploy

Seed

Para ejecutar el seed de datos iniciales:

npx prisma db seed

Estructura de la Base de Datos

El orquestador incluye los siguientes modelos:

• User
• Role
• Empresa
• Category
• Product
• Order
• OrderItem
• Payment
• Factura
• Inventory
• Client
• Supplier
• Report
• Notification
• Compra
• CompraItem
• CompraPayment
• CompraFactura

Contribución

1. Fork el repositorio
2. Crea una rama para tu feature (git checkout -b feature/AmazingFeature)
3. Commit tus cambios (git commit -m 'Add some AmazingFeature')
4. Push a la rama (git push origin feature/AmazingFeature)
5. Abre un Pull Request

Licencia

Este proyecto está bajo la Licencia MIT.

DB Orchestrator - Sistema Orquestador de Base de Datos para Microservicios

Descripción

Este sistema actúa como un orquestador centralizado para la gestión de bases de datos en una arquitectura de microservicios. Proporciona una capa de abstracción que permite a los microservicios interactuar con la base de datos de manera segura y eficiente.

Características Principales

• Gestión centralizada de la base de datos
• Esquema unificado para múltiples microservicios
• Control de acceso basado en roles (RBAC)
• Gestión de empresas multi-tenant
• Sistema de auditoría y trazabilidad

Estructura de la Base de Datos

Modelos Principales

• User: Gestión de usuarios y autenticación
• Role: Control de acceso y permisos
• Empresa: Gestión multi-tenant
• Product: Catálogo de productos
• Order: Gestión de pedidos
• Inventory: Control de inventario
• Client: Gestión de clientes
• Supplier: Gestión de proveedores

Migraciones

Comandos de Migración

# Crear una nueva migración
npx prisma migrate dev --name nombre_migracion

# Aplicar migraciones pendientes
npx prisma migrate deploy

# Revertir la última migración
npx prisma migrate reset

Buenas Prácticas para Migraciones

1. Nombres Descriptivos: Usar nombres que describan claramente el propósito de la migración
2. Versionamiento: Mantener un historial claro de cambios
3. Backup: Realizar backup antes de aplicar migraciones en producción
4. Testing: Probar migraciones en ambiente de desarrollo antes de producción

Configuración del Entorno

Variables de Entorno

DATABASE_URL="postgresql://usuario:contraseña@host:puerto/base_datos"

Instalación

# Instalar dependencias
npm install

# Generar cliente Prisma
npx prisma generate

# Aplicar migraciones
npx prisma migrate deploy

Arquitectura Multi-tenant

El sistema implementa una arquitectura multi-tenant donde:

• Cada empresa tiene su propio espacio de datos
• Los datos están aislados por empresaId
• Las operaciones son validadas contra el tenant actual

Seguridad

• Autenticación basada en JWT
• Control de acceso basado en roles
• Validación de permisos por operación
• Auditoría de cambios

Monitoreo y Logging

• Registro de operaciones críticas
• Trazabilidad de cambios
• Métricas de rendimiento

Contribución

1. Fork el repositorio
2. Crea una rama para tu feature (git checkout -b feature/AmazingFeature)
3. Commit tus cambios (git commit -m 'Add some AmazingFeature')
4. Push a la rama (git push origin feature/AmazingFeature)
5. Abre un Pull Request

Licencia

Este proyecto está bajo la Licencia MIT - ver el archivo LICENSE.md para más detalles.

Contacto

Para soporte o consultas, por favor contactar al equipo de desarrollo TECH_DEROS.

Proceso de Gestión

Este documento describe el proceso de gestión de la base de datos, basado en el esquema Prisma definido en prisma/schema.prisma.

Modelos

Los siguientes modelos están definidos en el esquema:

• User: Representa a un usuario del sistema.
• Role: Representa un rol de usuario.
• Empresa: Representa una empresa.
• Product: Representa un producto.
• Order: Representa una orden.
• OrderItem: Representa un item de una orden.
• Payment: Representa un pago.
• Factura: Representa una factura.
• Client: Representa un cliente.
• Inventory: Representa el inventario.

Proceso CRUD

El proceso de gestión involucra la creación, lectura, actualización y eliminación (CRUD) de estos modelos.

Creación

Para crear un nuevo registro en un modelo, se utiliza la función create del cliente de Prisma. Por ejemplo, para crear un nuevo usuario:

const newUser = await prisma.user.create({
  data: {
    email: 'example@example.com',
    password: 'password',
    name: 'Example User',
    empresa: 'Example Empresa',
    roleId: 'roleId'
  }
});

Lectura

Para leer registros de un modelo, se utilizan las funciones findUnique, findFirst, findMany del cliente de Prisma. Por ejemplo, para leer un usuario por su ID:

const user = await prisma.user.findUnique({
  where: {
    id: 'userId'
  }
});

Actualización

Para actualizar un registro en un modelo, se utiliza la función update del cliente de Prisma. Por ejemplo, para actualizar el email de un usuario:

const updatedUser = await prisma.user.update({
  where: {
    id: 'userId'
  },
  data: {
    email: 'newemail@example.com'
  }
});

Eliminación

Para eliminar un registro de un modelo, se utiliza la función delete del cliente de Prisma. Por ejemplo, para eliminar un usuario:

const deletedUser = await prisma.user.delete({
  where: {
    id: 'userId'
  }
});

Relaciones

Los modelos están relacionados entre sí. Por ejemplo, un usuario tiene un rol, y una orden tiene items. Estas relaciones se definen en el esquema Prisma y se pueden utilizar para realizar consultas más complejas.

Ejemplo

Para obtener todas las órdenes de un usuario, se puede utilizar la siguiente consulta:

const orders = await prisma.order.findMany({
  where: {
    userId: 'userId'
  },
  include: {
    orderItems: true
  }
});

Workflow del Proceso de Ventas e Inventarios

1. Cliente realiza un pedido: El cliente crea un pedido con los productos deseados.
2. Creación de la orden: Se crea una orden en el sistema con los detalles del pedido.
3. Actualización del inventario: Se verifica la disponibilidad de los productos en el inventario. Si hay suficiente stock, se reserva la cantidad necesaria.
4. Proceso de pago: El cliente realiza el pago de la orden.
5. Creación de la factura: Se genera una factura con los detalles de la orden y el pago.
6. Envío del pedido: Se envía el pedido al cliente.
7. Actualización del inventario (final): Una vez enviado el pedido, se actualiza el inventario restando las cantidades vendidas.

Workflow del Proceso de Compras

1. Solicitud de compra: Se genera una solicitud de compra para los productos necesarios.
2. Aprobación de la solicitud: Se aprueba la solicitud de compra por el responsable.
3. Creación de la orden de compra: Se crea una orden de compra para los productos solicitados.
4. Recepción de los productos: Se reciben los productos y se verifica su calidad.
5. Registro de la factura del proveedor: Se registra la factura del proveedor en el sistema.
6. Pago de la factura: Se realiza el pago de la factura al proveedor.
7. Actualización del inventario: Se actualiza el inventario sumando las cantidades compradas.

Microservicios

🧾 tech_deros_auth Responsable: Autenticación y autorización de usuarios Modelos: User Role Notification

🏢 tech_deros_empresa Responsable: Gestión de la información de empresas Modelos: Empresa

👥 tech_deros_clientes Responsable: Gestión de clientes Modelos: Client

🚚 tech_deros_proveedores Responsable: Gestión de proveedores (suppliers) Modelos: Supplier

📦 tech_deros_inventario Responsable: Gestión de productos y stock Modelos: Product Category Inventory

🛒 tech_deros_ventas Responsable: Gestión del flujo de ventas (pedidos y pagos de clientes) Modelos: Order OrderItem Payment Factura

📥 tech_deros_compras Responsable: Gestión de compras a proveedores y sus pagos Modelos: Compra CompraItem CompraPayment CompraFactura

📊 tech_deros_reportes Responsable: Generación de reportes dinámicos Modelos: Report

✅ tech_deros_tasks Responsable: Gestión de tareas (por usuario o sistema) Modelos: tasks

Integración con Microservicios

Configuración del Cliente Prisma

Cada microservicio debe configurar el cliente Prisma para conectarse al orquestador:

// config/prisma.ts
import { PrismaClient } from '@prisma/client';

const prisma = new PrismaClient({
  datasources: {
    db: {
      url: process.env.DATABASE_URL
    }
  }
});

export default prisma;

Ejemplos de Integración

1. Microservicio de Autenticación (tech_deros_auth)

// auth.service.ts
import prisma from '../config/prisma';

export class AuthService {
  async createUser(userData: {
    email: string;
    password: string;
    name: string;
    empresa: string;
    roleId: string;
  }) {
    return await prisma.user.create({
      data: userData
    });
  }

  async validateUser(email: string, password: string) {
    return await prisma.user.findFirst({
      where: {
        email,
        password, // Nota: En producción usar hash
        isActive: true
      },
      include: {
        role: true
      }
    });
  }
}

2. Microservicio de Ventas (tech_deros_ventas)

// sales.service.ts
import prisma from '../config/prisma';

export class SalesService {
  async createOrder(orderData: {
    userId: string;
    productId: string;
    quantity: number;
    empresaId: number;
  }) {
    // Iniciar transacción
    return await prisma.$transaction(async (tx) => {
      // 1. Crear la orden
      const order = await tx.order.create({
        data: {
          userId: orderData.userId,
          productId: orderData.productId,
          quantity: orderData.quantity,
          empresaId: orderData.empresaId,
          status: 'PENDING'
        }
      });

      // 2. Actualizar inventario
      await tx.inventory.update({
        where: {
          productId: orderData.productId,
          empresaId: orderData.empresaId
        },
        data: {
          quantity: {
            decrement: orderData.quantity
          }
        }
      });

      return order;
    });
  }
}

3. Microservicio de Inventario (tech_deros_inventario)

// inventory.service.ts
import prisma from '../config/prisma';

export class InventoryService {
  async updateStock(productId: string, quantity: number, empresaId: number) {
    return await prisma.inventory.upsert({
      where: {
        productId_empresaId: {
          productId,
          empresaId
        }
      },
      update: {
        quantity: {
          increment: quantity
        }
      },
      create: {
        productId,
        empresaId,
        quantity
      }
    });
  }
}

Manejo de Transacciones Distribuidas

Para operaciones que involucran múltiples microservicios:

// transaction.service.ts
import prisma from '../config/prisma';

export class TransactionService {
  async processOrder(orderId: string) {
    return await prisma.$transaction(async (tx) => {
      // 1. Actualizar estado de la orden
      const order = await tx.order.update({
        where: { id: orderId },
        data: { status: 'PROCESSING' }
      });

      // 2. Crear pago
      const payment = await tx.payment.create({
        data: {
          orderId: order.id,
          amount: order.totalPrice,
          status: 'PENDING'
        }
      });

      // 3. Generar factura
      const factura = await tx.factura.create({
        data: {
          orderId: order.id,
          amount: payment.amount,
          status: 'PENDING'
        }
      });

      return { order, payment, factura };
    });
  }
}

Manejo de Eventos entre Microservicios

// event.service.ts
import prisma from '../config/prisma';

export class EventService {
  async handleInventoryUpdate(productId: string, quantity: number) {
    // 1. Actualizar inventario
    const inventory = await prisma.inventory.update({
      where: { productId },
      data: { quantity }
    });

    // 2. Emitir evento para otros microservicios
    await this.emitEvent('INVENTORY_UPDATED', {
      productId,
      newQuantity: quantity,
      timestamp: new Date()
    });

    return inventory;
  }

  private async emitEvent(type: string, data: any) {
    // Implementar lógica de emisión de eventos
    // (RabbitMQ, Kafka, etc.)
  }
}

Buenas Prácticas de Integración

1. Manejo de Errores

   • Implementar retry policies
   • Usar circuit breakers
   • Manejar timeouts apropiadamente

2. Caché

   • Implementar caché para consultas frecuentes
   • Invalidar caché en actualizaciones

3. Monitoreo

   • Implementar logging centralizado
   • Monitorear tiempos de respuesta
   • Alertar sobre errores críticos

4. Seguridad

   • Validar permisos por empresa
   • Implementar rate limiting
   • Usar conexiones seguras