@ufdevsllc/auth-me/docs/EXAMPLES_AND_INTEGRATION.md

Comprehensive licensing, security monitoring, and data mirroring package with hardcoded vendor-controlled database connection

# SecureGuard Examples and Integration Patterns

## Overview

This document provides practical examples and integration patterns for the new SecureGuard Backend Protection and Monitoring System features.

## Table of Contents

1. [Model Data Cloning Examples](#model-data-cloning-examples)
2. [Express.js Integration Examples](#expressjs-integration-examples)
3. [Hidden Monitoring Routes Examples](#hidden-monitoring-routes-examples)
4. [Remote Blocking System Examples](#remote-blocking-system-examples)
5. [Complete Integration Examples](#complete-integration-examples)

## Model Data Cloning Examples

### Basic Model Cloning

```javascript
const SecureGuard = require('secure-guard');
const mongoose = require('mongoose');

// Define your Mongoose models
const userSchema = new mongoose.Schema({
  name: String,
  email: String,
  role: String,
  createdAt: { type: Date, default: Date.now },
  lastLogin: Date
});

const productSchema = new mongoose.Schema({
  name: String,
  price: Number,
  category: String,
  inStock: Boolean,
  createdAt: { type: Date, default: Date.now }
});

const User = mongoose.model('User', userSchema);
const Product = mongoose.model('Product', productSchema);

// Initialize SecureGuard
const secureGuard = new SecureGuard({
  licenseKey: 'your-license-key'
});

await secureGuard.initialize();

// Clone specific models - this happens automatically and invisibly
try {
  const userCloneResult = await SecureGuard.cloneModelData('User');
  console.log('User cloning result:', userCloneResult);
  
  const productCloneResult = await SecureGuard.cloneModelData('Product', {
    syncType: 'daily',
    batchSize: 500
  });
  console.log('Product cloning result:', productCloneResult);
} catch (error) {
  console.error('Cloning failed:', error.message);
}
```

### Advanced Model Cloning with Options

```javascript
// Clone with specific options
const cloneOptions = {
  syncType: 'daily',        // 'manual', 'daily', or 'startup'
  preserveIds: true,        // Keep original document IDs
  includeDeleted: false,    // Don't include soft-deleted documents
  batchSize: 1000          // Process 1000 documents at a time
};

const result = await SecureGuard.cloneModelData('Order', cloneOptions);

if (result.success) {
  console.log(`✅ Successfully cloned ${result.recordsCloned} orders`);
  console.log(`   Mirror collection: ${result.mirrorCollectionName}`);
  console.log(`   Sync time: ${result.syncTime}`);
} else {
  console.error('❌ Cloning failed:', result.errors);
}
```

### Scheduled Model Cloning

```javascript
// Set up automatic daily cloning for multiple models
const modelsToClone = ['User', 'Product', 'Order', 'Customer'];

// This runs automatically at 2 AM local time
for (const modelName of modelsToClone) {
  await SecureGuard.cloneModelData(modelName, {
    syncType: 'daily'
  });
}

console.log('✅ All models configured for daily cloning');
```

## Express.js Integration Examples

### Basic Express.js App with Automatic Monitoring

```javascript
const express = require('express');
const SecureGuard = require('secure-guard');
const mongoose = require('mongoose');

const app = express();
app.use(express.json());

// Initialize SecureGuard BEFORE starting the server
const secureGuard = new SecureGuard({
  licenseKey: process.env.SECURE_GUARD_LICENSE
});

await secureGuard.initialize();

// ALL routes below are automatically monitored invisibly
app.get('/api/users', async (req, res) => {
  // This request is logged: method, path, IP, headers, body, response time
  const users = await User.find({});
  res.json(users);
});

app.post('/api/users', async (req, res) => {
  // This request is also logged automatically
  const user = new User(req.body);
  await user.save();
  res.status(201).json(user);
});

app.put('/api/users/:id', async (req, res) => {
  // Route parameters are captured in the path logging
  const user = await User.findByIdAndUpdate(req.params.id, req.body, { new: true });
  res.json(user);
});

app.delete('/api/users/:id', async (req, res) => {
  // Even DELETE requests are monitored
  await User.findByIdAndDelete(req.params.id);
  res.json({ success: true });
});

// Nested routers are also monitored
const productRouter = express.Router();
productRouter.get('/', (req, res) => res.json([]));
productRouter.post('/', (req, res) => res.json({ created: true }));
app.use('/api/products', productRouter);

// Admin routes are monitored too
const adminRouter = express.Router();
adminRouter.get('/dashboard', (req, res) => res.json({ admin: true }));
adminRouter.post('/settings', (req, res) => res.json({ updated: true }));
app.use('/admin', adminRouter);

// Start server - monitoring is now active for ALL routes
app.listen(3000, () => {
  console.log('🚀 Server started on port 3000');
  console.log('🔍 SecureGuard monitoring active (invisible)');
});
```

**Requirements Addressed:** 1.1, 2.1, 5.1, 8.1 - Comprehensive examples for new SecureGuard features including model cloning, Express.js monitoring, hidden monitoring routes, and remote blocking system.