@krunal_tarale-5/ultimate-streaming-package/docs/integration/README.md

🚀 Ultimate Real-Time Streaming Package v2.1.9 - Multi-Platform, Multi-Collection Architecture with Native MongoDB & MySQL Support, 99.96% Performance Improvement. Enterprise-grade real-time data streaming with Socket.IO integration, dynamic schema evolut

# 🔧 Integration Guide

**Complete integration guide for Ultimate Streaming Package v2.1.4**

## 🚀 **Framework Integration**

### Express.js Integration

```javascript
const express = require('express');
const UltimateStreamer = require('@krunal_tarale-5/ultimate-streaming-package');
const app = express();

// Initialize streaming package
async function initializeStreamer() {
  try {
    await UltimateStreamer.init({
      dbType: 'mysql',
      host: 'localhost',
      port: 3306,
      database: 'myapp',
      user: 'root',
      password: '',
      enableCache: true
    });

    console.log('✅ Streaming package initialized');

    // Set up real-time listeners
    UltimateStreamer.on('orders', (data, meta) => {
      console.log('Order update:', data.orderId, meta.changeType);
    });

    UltimateStreamer.on('users', (data, meta) => {
      console.log('User update:', data.userId, meta.changeType);
    });

  } catch (error) {
    console.error('Failed to initialize streamer:', error);
  }
}

// Initialize on app start
initializeStreamer();

// API Routes
app.post('/api/orders', async (req, res) => {
  try {
    const result = await UltimateStreamer.push('orders', req.body);
    res.json({ success: true, data: result });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.get('/api/orders', async (req, res) => {
  try {
    const orders = await UltimateStreamer.get('orders', {
      where: { status: req.query.status || 'pending' }
    });
    res.json(orders);
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.put('/api/orders/:orderId', async (req, res) => {
  try {
    const result = await UltimateStreamer.update('orders', 
      { orderId: req.params.orderId },
      req.body
    );
    res.json({ success: true, updated: result.found });
  } catch (error) {
    res.status(500).json({ error: error.message });
  }
});

app.listen(3000, () => {
  console.log('Server running on port 3000');
});
```

### React Integration

```javascript
// App.js
import React, { useState, useEffect } from 'react';
import io from 'socket.io-client';

function App() {
  const [orders, setOrders] = useState([]);
  const [users, setUsers] = useState([]);
  const [socket, setSocket] = useState(null);

  useEffect(() => {
    // Connect to Socket.IO server
    const newSocket = io('http://localhost:3000');
    setSocket(newSocket);

    // Listen for real-time updates
    newSocket.on('orders', (data) => {
      setOrders(prev => [...prev, data]);
    });

    newSocket.on('users', (data) => {
      setUsers(prev => [...prev, data]);
    });

    return () => newSocket.close();
  }, []);

  const createOrder = async (orderData) => {
    try {
      const response = await fetch('/api/orders', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(orderData)
      });
      const result = await response.json();
      console.log('Order created:', result);
    } catch (error) {
      console.error('Error creating order:', error);
    }
  };

  return (
    <div>
      <h1>Real-time Dashboard</h1>
      
      <div>
        <h2>Orders ({orders.length})</h2>
        {orders.map(order => (
          <div key={order.orderId}>
            Order {order.orderId}: {order.status}
          </div>
        ))}
      </div>

      <div>
        <h2>Users ({users.length})</h2>
        {users.map(user => (
          <div key={user.userId}>
            {user.name} ({user.email})
          </div>
        ))}
      </div>

      <button onClick={() => createOrder({
        orderId: 'ORD-' + Date.now(),
        customerId: 'CUST-001',
        total: 1500.00,
        status: 'pending'
      })}>
        Create New Order
      </button>
    </div>
  );
}

export default App;
```

### Next.js Integration

```javascript
// pages/api/orders.js
import UltimateStreamer from '@krunal_tarale-5/ultimate-streaming-package';

export default async function handler(req, res) {
  if (req.method === 'POST') {
    try {
      const result = await UltimateStreamer.push('orders', req.body);
      res.status(200).json({ success: true, data: result });
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  } else if (req.method === 'GET') {
    try {
      const orders = await UltimateStreamer.get('orders', {
        where: { status: req.query.status || 'pending' }
      });
      res.status(200).json(orders);
    } catch (error) {
      res.status(500).json({ error: error.message });
    }
  } else {
    res.setHeader('Allow', ['GET', 'POST']);
    res.status(405).end(`Method ${req.method} Not Allowed`);
  }
}

// pages/index.js
import { useState, useEffect } from 'react';

export default function Home() {
  const [orders, setOrders] = useState([]);

  useEffect(() => {
    fetchOrders();
  }, []);

  const fetchOrders = async () => {
    const response = await fetch('/api/orders');
    const data = await response.json();
    setOrders(data);
  };

  const createOrder = async () => {
    const orderData = {
      orderId: 'ORD-' + Date.now(),
      customerId: 'CUST-001',
      total: 1500.00,
      status: 'pending'
    };

    await fetch('/api/orders', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(orderData)
    });

    fetchOrders(); // Refresh the list
  };

  return (
    <div>
      <h1>Orders Dashboard</h1>
      <button onClick={createOrder}>Create Order</button>
      
      {orders.map(order => (
        <div key={order.orderId}>
          Order {order.orderId}: {order.status} - ${order.total}
        </div>
      ))}
    </div>
  );
}
```

### Vue.js Integration

```javascript
// main.js
import { createApp } from 'vue';
import App from './App.vue';
import io from 'socket.io-client';

const app = createApp(App);

// Provide Socket.IO instance
app.provide('socket', io('http://localhost:3000'));

app.mount('#app');

// App.vue
<template>
  <div>
    <h1>Real-time Dashboard</h1>
    
    <div>
      <h2>Orders ({{ orders.length }})</h2>
      <div v-for="order in orders" :key="order.orderId">
        Order {{ order.orderId }}: {{ order.status }}
      </div>
    </div>

    <button @click="createOrder">Create Order</button>
  </div>
</template>

<script>
import { ref, onMounted, inject } from 'vue';

export default {
  setup() {
    const orders = ref([]);
    const socket = inject('socket');

    onMounted(() => {
      // Listen for real-time updates
      socket.on('orders', (data) => {
        orders.value.push(data);
      });
    });

    const createOrder = async () => {
      const orderData = {
        orderId: 'ORD-' + Date.now(),
        customerId: 'CUST-001',
        total: 1500.00,
        status: 'pending'
      };

      try {
        const response = await fetch('/api/orders', {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify(orderData)
        });
        const result = await response.json();
        console.log('Order created:', result);
      } catch (error) {
        console.error('Error creating order:', error);
      }
    };

    return {
      orders,
      createOrder
    };
  }
};
</script>
```

## 🔌 **Socket.IO Integration**

### Server Setup

```javascript
const express = require('express');
const http = require('http');
const socketIo = require('socket.io');
const UltimateStreamer = require('@krunal_tarale-5/ultimate-streaming-package');

const app = express();
const server = http.createServer(app);
const io = socketIo(server, {
  cors: {
    origin: "http://localhost:3000",
    methods: ["GET", "POST"]
  }
});

// Initialize streaming package
async function initializeStreamer() {
  try {
    await UltimateStreamer.init({
      dbType: 'mysql',
      host: 'localhost',
      port: 3306,
      database: 'myapp',
      user: 'root',
      password: '',
      enableCache: true
    });

    console.log('✅ Streaming package initialized');

    // Set up real-time listeners and emit to Socket.IO clients
    UltimateStreamer.on('orders', (data, meta) => {
      console.log('Order update:', data.orderId, meta.changeType);
      io.emit('orders', { data, meta });
    });

    UltimateStreamer.on('users', (data, meta) => {
      console.log('User update:', data.userId, meta.changeType);
      io.emit('users', { data, meta });
    });

  } catch (error) {
    console.error('Failed to initialize streamer:', error);
  }
}

// Socket.IO connection handling
io.on('connection', (socket) => {
  console.log('Client connected:', socket.id);

  socket.on('disconnect', () => {
    console.log('Client disconnected:', socket.id);
  });

  // Handle client requests
  socket.on('createOrder', async (orderData) => {
    try {
      const result = await UltimateStreamer.push('orders', orderData);
      socket.emit('orderCreated', { success: true, data: result });
    } catch (error) {
      socket.emit('orderCreated', { success: false, error: error.message });
    }
  });

  socket.on('getOrders', async (query) => {
    try {
      const orders = await UltimateStreamer.get('orders', query);
      socket.emit('ordersData', orders);
    } catch (error) {
      socket.emit('ordersData', { error: error.message });
    }
  });
});

initializeStreamer();

server.listen(3001, () => {
  console.log('Server running on port 3001');
});
```

### Client Setup

```javascript
// Client-side Socket.IO integration
import io from 'socket.io-client';

class RealTimeClient {
  constructor() {
    this.socket = io('http://localhost:3001');
    this.setupListeners();
  }

  setupListeners() {
    this.socket.on('connect', () => {
      console.log('Connected to server');
    });

    this.socket.on('orders', (data) => {
      console.log('Order update received:', data);
      this.handleOrderUpdate(data);
    });

    this.socket.on('users', (data) => {
      console.log('User update received:', data);
      this.handleUserUpdate(data);
    });

    this.socket.on('orderCreated', (result) => {
      if (result.success) {
        console.log('Order created successfully:', result.data);
      } else {
        console.error('Failed to create order:', result.error);
      }
    });
  }

  createOrder(orderData) {
    this.socket.emit('createOrder', orderData);
  }

  getOrders(query = {}) {
    this.socket.emit('getOrders', query);
  }

  handleOrderUpdate(data) {
    // Update your UI here
    console.log('Processing order update:', data);
  }

  handleUserUpdate(data) {
    // Update your UI here
    console.log('Processing user update:', data);
  }
}

// Usage
const client = new RealTimeClient();

// Create an order
client.createOrder({
  orderId: 'ORD-001',
  customerId: 'CUST-001',
  total: 1500.00,
  status: 'pending'
});

// Get orders
client.getOrders({ where: { status: 'pending' } });
```

## 🚀 **Production Deployment**

### Docker Setup

```dockerfile
# Dockerfile
FROM node:18-alpine

WORKDIR /app

# Copy package files
COPY package*.json ./

# Install dependencies
RUN npm ci --only=production

# Copy application code
COPY . .

# Expose port
EXPOSE 3000

# Start the application
CMD ["npm", "start"]
```

```yaml
# docker-compose.yml
version: '3.8'

services:
  app:
    build: .
    ports:
      - "3000:3000"
    environment:
      - DB_HOST=mysql
      - DB_PORT=3306
      - DB_NAME=myapp
      - DB_USER=root
      - DB_PASSWORD=password
    depends_on:
      - mysql
    networks:
      - app-network

  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: password
      MYSQL_DATABASE: myapp
    ports:
      - "3306:3306"
    volumes:
      - mysql-data:/var/lib/mysql
    networks:
      - app-network

volumes:
  mysql-data:

networks:
  app-network:
    driver: bridge
```

### Environment Configuration

```javascript
// config/database.js
const config = {
  development: {
    dbType: 'mysql',
    host: 'localhost',
    port: 3306,
    database: 'myapp_dev',
    user: 'root',
    password: '',
    enableCache: true,
    debug: true
  },
  production: {
    dbType: 'mysql',
    host: process.env.DB_HOST,
    port: parseInt(process.env.DB_PORT),
    database: process.env.DB_NAME,
    user: process.env.DB_USER,
    password: process.env.DB_PASSWORD,
    enableCache: true,
    debug: false,
    maxConnections: 20,
    acquireTimeout: 60000
  }
};

module.exports = config[process.env.NODE_ENV || 'development'];
```

### PM2 Configuration

```javascript
// ecosystem.config.js
module.exports = {
  apps: [{
    name: 'ultimate-streaming-app',
    script: 'server.js',
    instances: 'max',
    exec_mode: 'cluster',
    env: {
      NODE_ENV: 'development',
      DB_HOST: 'localhost',
      DB_PORT: 3306,
      DB_NAME: 'myapp',
      DB_USER: 'root',
      DB_PASSWORD: ''
    },
    env_production: {
      NODE_ENV: 'production',
      DB_HOST: process.env.DB_HOST,
      DB_PORT: process.env.DB_PORT,
      DB_NAME: process.env.DB_NAME,
      DB_USER: process.env.DB_USER,
      DB_PASSWORD: process.env.DB_PASSWORD
    }
  }]
};
```

### Nginx Configuration

```nginx
# nginx.conf
server {
    listen 80;
    server_name your-domain.com;

    location / {
        proxy_pass http://localhost:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_cache_bypass $http_upgrade;
    }

    location /socket.io/ {
        proxy_pass http://localhost:3001;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}
```

## 🔒 **Security Considerations**

### Authentication & Authorization

```javascript
// middleware/auth.js
const jwt = require('jsonwebtoken');

const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1];

  if (!token) {
    return res.sendStatus(401);
  }

  jwt.verify(token, process.env.JWT_SECRET, (err, user) => {
    if (err) return res.sendStatus(403);
    req.user = user;
    next();
  });
};

module.exports = { authenticateToken };

// Usage in routes
app.post('/api/orders', authenticateToken, async (req, res) => {
  // Only authenticated users can create orders
  const result = await UltimateStreamer.push('orders', {
    ...req.body,
    createdBy: req.user.id
  });
  res.json({ success: true, data: result });
});
```

### Rate Limiting

```javascript
const rateLimit = require('express-rate-limit');

const limiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP'
});

app.use('/api/', limiter);
```

### Input Validation

```javascript
const Joi = require('joi');

const orderSchema = Joi.object({
  orderId: Joi.string().required(),
  customerId: Joi.string().required(),
  total: Joi.number().positive().required(),
  status: Joi.string().valid('pending', 'shipped', 'delivered').required()
});

app.post('/api/orders', async (req, res) => {
  const { error, value } = orderSchema.validate(req.body);
  
  if (error) {
    return res.status(400).json({ error: error.details[0].message });
  }

  const result = await UltimateStreamer.push('orders', value);
  res.json({ success: true, data: result });
});
```

## 📊 **Monitoring & Logging**

### Application Monitoring

```javascript
const winston = require('winston');

const logger = winston.createLogger({
  level: 'info',
  format: winston.format.combine(
    winston.format.timestamp(),
    winston.format.json()
  ),
  transports: [
    new winston.transports.File({ filename: 'error.log', level: 'error' }),
    new winston.transports.File({ filename: 'combined.log' })
  ]
});

if (process.env.NODE_ENV !== 'production') {
  logger.add(new winston.transports.Console({
    format: winston.format.simple()
  }));
}

// Usage in streaming package
UltimateStreamer.on('orders', (data, meta) => {
  logger.info('Order update', { 
    orderId: data.orderId, 
    changeType: meta.changeType,
    timestamp: new Date()
  });
});
```

### Performance Monitoring

```javascript
const performance = require('perf_hooks');

// Monitor streaming performance
const streamStart = performance.now();

UltimateStreamer.on('orders', (data, meta) => {
  const streamTime = performance.now() - streamStart;
  logger.info('Streaming performance', {
    orderId: data.orderId,
    streamTime: streamTime,
    changeType: meta.changeType
  });
});
```

## 🔧 **Troubleshooting**

### Common Issues

**1. Connection Timeout**
```javascript
// Increase timeout settings
await UltimateStreamer.init({
  // ... other config
  acquireTimeout: 120000, // 2 minutes
  maxConnections: 50
});
```

**2. Memory Issues**
```javascript
// Monitor memory usage
setInterval(() => {
  const memUsage = process.memoryUsage();
  console.log('Memory usage:', {
    rss: `${Math.round(memUsage.rss / 1024 / 1024)} MB`,
    heapTotal: `${Math.round(memUsage.heapTotal / 1024 / 1024)} MB`,
    heapUsed: `${Math.round(memUsage.heapUsed / 1024 / 1024)} MB`
  });
}, 60000);
```

**3. Socket.IO Connection Issues**
```javascript
// Client-side reconnection
const socket = io('http://localhost:3001', {
  reconnection: true,
  reconnectionDelay: 1000,
  reconnectionDelayMax: 5000,
  maxReconnectionAttempts: 5
});

socket.on('connect_error', (error) => {
  console.error('Connection error:', error);
});

socket.on('reconnect', (attemptNumber) => {
  console.log('Reconnected after', attemptNumber, 'attempts');
});
```

## 📚 **Next Steps**

1. **Choose your framework** from the examples above
2. **Set up Socket.IO** for real-time communication
3. **Deploy to production** using the deployment guides
4. **Monitor performance** with the monitoring tools
5. **Secure your application** with authentication and validation

## 🤝 **Need Help?**

- **Documentation**: [Complete Documentation](../)
- **GitHub Issues**: [Report bugs or request features](https://github.com/krunal-tarale/ultimate-streaming-package/issues)
- **Email Support**: [krunaltarale555@gmail.com](mailto:krunaltarale555@gmail.com)

---

**Ready to integrate Ultimate Streaming Package into your application?** 🚀

```bash
npm install @krunal_tarale-5/ultimate-streaming-package@2.1.4
```