import { Monarch } from 'monarch-database-quantum';

const db = new Monarch();
const users = db.addCollection('users');

// Insert some data
await users.insert({ name: 'Alice', age: 30, email: 'alice@example.com' });
await users.insert({ name: 'Bob', age: 25, email: 'bob@example.com' });

// Query with MongoDB-style syntax
const adults = await users.find({ age: { $gte: 25 } });
console.log('Adult users:', adults);

// Real-time updates
users.watch().on('insert', (change) => {
  console.log('New user added:', change.doc);
});

// Ready to use! 🚀

// Create a file: app.js
import { Monarch } from 'monarch-database';

// Create database (auto-creates if doesn't exist)
const db = new Monarch();

// Create collections (like tables)
const users = db.addCollection('users');
const posts = db.addCollection('posts');

// Insert data
await users.insert({
  name: 'Alice',
  email: 'alice@example.com',
  age: 30
});

await posts.insert({
  title: 'Hello World',
  content: 'My first post!',
  author: 'alice@example.com'
});

// Query data
const user = await users.findOne({ email: 'alice@example.com' });
const userPosts = await posts.find({ author: 'alice@example.com' });

console.log('User:', user);
console.log('Posts:', userPosts);

import { Monarch } from 'monarch-database';

const db = new Monarch();

// Documents (like MongoDB)
const users = db.addCollection('users');
await users.insert({ name: 'Alice', age: 30 });
const user = await users.findOne({ name: 'Alice' });
await users.update({ name: 'Alice' }, { age: 31 });

// Key-Value (like Redis)
await db.set('session:123', { userId: 123, expires: Date.now() });
const session = await db.get('session:123');

// Lists (like Redis)
await db.lpush('queue', 'task1', 'task2');
const task = await db.lpop('queue');

// Sets
await db.sadd('tags', 'javascript', 'typescript');
const hasTag = await db.sismember('tags', 'javascript');

// Sorted Sets (leaderboards, etc.)
await db.zadd('scores', { 'Alice': 1500, 'Bob': 1200 });
const topPlayers = await db.zrange('scores', 0, 2);

const db = new Monarch({
  // File persistence
  adapter: new FileSystemAdapter('./data'),

  // Collection limits
  collections: {
    maxDocuments: 10000,
    ttl: 3600000 // 1 hour
  },

  // Performance tuning
  performance: {
    cacheSize: 1000,
    maxConcurrentOps: 100
  }
});

// server.js
import express from 'express';
import { Monarch } from 'monarch-database';

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

const db = new Monarch();
const users = db.addCollection('users');

// REST API endpoints
app.get('/users', async (req, res) => {
  const users = await db.getCollection('users').find();
  res.json(users);
});

app.post('/users', async (req, res) => {
  const user = await db.getCollection('users').insert(req.body);
  res.json(user);
});

app.get('/users/:id', async (req, res) => {
  const user = await db.getCollection('users').findOne({ _id: req.params.id });
  res.json(user);
});

app.listen(3000, () => console.log('API running on port 3000'));

// pages/api/users.js
import { Monarch } from 'monarch-database';

const db = new Monarch();
const users = db.addCollection('users');

export default async function handler(req, res) {
  if (req.method === 'GET') {
    const allUsers = await users.find();
    res.status(200).json(allUsers);
  } else if (req.method === 'POST') {
    const user = await users.insert(req.body);
    res.status(201).json(user);
  }
}

// session-store.js
import { Monarch } from 'monarch-database';

class MonarchSessionStore {
  constructor() {
    this.db = new Monarch();
    this.sessions = this.db.addCollection('sessions');
  }

  async get(sessionId) {
    const session = await this.sessions.findOne({ sessionId });
    return session?.data;
  }

  async set(sessionId, data, expiresAt) {
    await this.sessions.update(
      { sessionId },
      { data, expiresAt },
      { upsert: true }
    );
  }

  async destroy(sessionId) {
    await this.sessions.delete({ sessionId });
  }
}

export default MonarchSessionStore;

// cache.js
import { Monarch } from 'monarch-database';

class MonarchCache {
  constructor() {
    this.db = new Monarch();
  }

  async get(key) {
    const result = await this.db.get(key);
    return result ? JSON.parse(result) : null;
  }

  async set(key, value, ttlSeconds = 3600) {
    const expiresAt = Date.now() + (ttlSeconds * 1000);
    await this.db.set(key, JSON.stringify(value), 'EX', ttlSeconds);
  }

  async invalidate(pattern) {
    // Delete keys matching pattern
    const keys = await this.db.keys(pattern);
    if (keys.length > 0) {
      await this.db.del(...keys);
    }
  }
}

export default MonarchCache;

import { Monarch } from 'monarch-database';

const db = new Monarch();
const users = db.addCollection('users');
const sessions = db.addCollection('sessions');

// User registration
async function registerUser(email, password, profile) {
  // Check if user exists
  const existing = await users.findOne({ email });
  if (existing) throw new Error('User already exists');

  // Create user
  const user = await users.insert({
    email,
    password: await hashPassword(password), // Implement hashing
    profile,
    createdAt: new Date(),
    status: 'active'
  });

  return user;
}

// User login
async function loginUser(email, password) {
  const user = await users.findOne({ email });
  if (!user) throw new Error('User not found');

  if (!(await verifyPassword(password, user.password))) {
    throw new Error('Invalid password');
  }

  // Create session
  const session = await sessions.insert({
    userId: user._id,
    token: generateToken(),
    expiresAt: new Date(Date.now() + 24 * 60 * 60 * 1000) // 24 hours
  });

  return { user, session };
}

import { Monarch } from 'monarch-database';

const db = new Monarch();
const products = db.addCollection('products');
const orders = db.addCollection('orders');
const inventory = db.addCollection('inventory');

// Add product with search capabilities
async function addProduct(productData) {
  const product = await products.insert({
    ...productData,
    searchTerms: `${productData.name} ${productData.description} ${productData.tags.join(' ')}`.toLowerCase(),
    createdAt: new Date()
  });

  // Update inventory
  await inventory.insert({
    productId: product._id,
    quantity: productData.initialStock || 0,
    reserved: 0
  });

  return product;
}

// Search products
async function searchProducts(query, filters = {}) {
  const searchQuery = {
    searchTerms: { $regex: query.toLowerCase() },
    ...filters
  };

  return await products.find(searchQuery)
    .sort({ createdAt: -1 })
    .limit(20);
}

// Place order with inventory check
async function placeOrder(userId, items) {
  // Check inventory
  for (const item of items) {
    const stock = await inventory.findOne({ productId: item.productId });
    if (!stock || stock.quantity - stock.reserved < item.quantity) {
      throw new Error(`Insufficient inventory for product ${item.productId}`);
    }
  }

  // Reserve inventory
  for (const item of items) {
    await inventory.update(
      { productId: item.productId },
      { reserved: item.quantity } // Note: Use remove+insert for complex updates
    );
  }

  // Create order
  const order = await orders.insert({
    userId,
    items,
    status: 'pending',
    createdAt: new Date(),
    total: calculateTotal(items)
  });

  return order;
}

import { Monarch } from 'monarch-database';

const db = new Monarch();
const messages = db.addCollection('messages');
const channels = db.addCollection('channels');
const users = db.addCollection('users');

// Send message
async function sendMessage(channelId, userId, content) {
  const message = await messages.insert({
    channelId,
    userId,
    content,
    timestamp: new Date(),
    type: 'text'
  });

  // Update channel last activity
  await channels.update(
    { _id: channelId },
    { lastMessageAt: new Date(), lastMessage: content }
  );

  return message;
}

// Get channel messages with pagination
async function getChannelMessages(channelId, before = null, limit = 50) {
  const query = { channelId };
  if (before) {
    query.timestamp = { $lt: before };
  }

  return await messages.find(query)
    .sort({ timestamp: -1 })
    .limit(limit);
}

// Real-time message subscription (polling approach)
async function pollMessages(channelId, since) {
  return await messages.find({
    channelId,
    timestamp: { $gt: since }
  }).sort({ timestamp: 1 });
}

const users = db.addCollection('users');

// CRUD Operations
await users.insert(document);           // Insert one document
await users.insert([doc1, doc2]);       // Insert multiple documents
await users.insertMany(docs, options);  // Bulk insert (high performance)
await users.find(query);                // Find documents
await users.findOne(query);             // Find one document
await users.update(query, update);      // Update documents (shallow)
await users.updateDeep(query, update);  // Update with nested objects
await users.remove(query);             // Remove documents
await users.removeMany(query, options); // Bulk remove
await users.count(query);               // Count documents

// Advanced Operations
await users.aggregate(pipeline);        // Aggregation framework
await users.createIndex(fields, options); // Advanced indexing

// Database Operations
await db.getStats();                   // Database statistics
await db.createCollection(name);       // Create collection
await db.dropCollection(name);         // Drop collection
await db.exportDatabase();             // Backup database

// Full-Text Search
await db.createTextIndex(collection, fields, options);
const results = await db.searchTextIndex(indexName, query, options);

// Schema Management
db.registerSchema(collection, schema);
const valid = await db.validateDocument(collection, doc);

### Update Patterns

Monarch Database supports **shallow updates only** - you cannot update nested objects directly.

#### ✅ Supported Update Patterns

```javascript
// Direct field updates (primitives, arrays, dates)
await users.update({ _id: 'user1' }, { age: 31 });
await users.update({ _id: 'user1' }, { tags: ['admin', 'moderator'] });
await users.update({ _id: 'user1' }, { lastLogin: new Date() });

// Multiple field updates
await users.update({ status: 'active' }, {
  lastActivity: new Date(),
  loginCount: 5
});

// Nested object updates (will throw error)
await users.update({ _id: 'user1' }, {
  profile: { bio: 'New bio' }  // ❌ ERROR: Nested object updates not supported
});

// MongoDB-style operators (not implemented)
await users.update({ _id: 'user1' }, { $set: { age: 31 } });  // ❌ Not supported
await users.update({ _id: 'user1' }, { $inc: { age: 1 } });   // ❌ Not supported

// 1. Find the current document
const user = await users.findOne({ _id: 'user1' });

// 2. Create updated version (immutable update)
const updatedUser = {
  ...user,
  profile: {
    ...user.profile,
    bio: 'Senior Developer',
    preferences: {
      ...user.profile.preferences,
      theme: 'dark'
    }
  },
  lastUpdated: new Date()
};

// 3. Remove old document
await users.remove({ _id: 'user1' });

// 4. Insert updated document
await users.insert(updatedUser);

// Insert thousands of documents efficiently
const documents = Array.from({ length: 10000 }, (_, i) => ({
  _id: `user_${i}`,
  name: `User ${i}`,
  email: `user${i}@example.com`,
  createdAt: new Date()
}));

const result = await users.insertMany(documents, {
  batchSize: 5000,     // Process in batches of 5k
  skipValidation: false, // Validate each document
  emitEvents: true,     // Emit change events
  timeout: 300000       // 5 minute timeout for bulk operations
});

console.log(`Inserted ${result.insertedCount} documents`);
// Output: Inserted 10000 documents

// Delete multiple documents with advanced options
const result = await users.removeMany(
  { status: 'inactive' },
  {
    limit: 1000,        // Limit deletions
    emitEvents: true,   // Emit change events
    timeout: 120000     // 2 minute timeout
  }
);

console.log(`Deleted ${result.deletedCount} documents`);
// Output: Deleted 1000 documents

// Update nested objects directly (NEW!)
await users.updateDeep(
  { _id: 'user1' },
  {
    profile: {
      bio: 'Senior Developer',
      preferences: {
        theme: 'dark',
        notifications: true
      }
    },
    lastUpdated: new Date()
  }
);

const pipeline = [
  { $match: { status: 'active', age: { $gte: 18 } } },
  { $group: {
      _id: '$department',
      totalEmployees: { $sum: 1 },
      avgSalary: { $avg: '$salary' },
      maxSalary: { $max: '$salary' },
      employees: { $push: '$name' }
    }
  },
  { $sort: { totalEmployees: -1 } }
];

const results = await employees.aggregate(pipeline);

// Create text index
await db.createTextIndex('articles', ['title', 'content'], {
  weights: { title: 10, content: 1 }
});

// Search with scoring
const results = await db.searchTextIndex('articles', 'quantum computing', {
  limit: 10,
  scoreField: 'relevanceScore'
});

console.log(results[0]); // { document: {...}, score: 0.85, highlights: [...] }

// Store locations
await places.insert({
  name: 'Central Park',
  location: { type: 'Point', coordinates: [-73.968, 40.782] }
});

// Find nearby places
const nearby = await places.find({
  location: {
    $near: {
      $geometry: { type: 'Point', coordinates: [-73.985, 40.758] },
      $maxDistance: 5000 // 5km
    }
  }
});

// Find places within polygon
const inArea = await places.find({
  location: {
    $geoWithin: {
      $geometry: polygonDefinition
    }
  }
});

// Compound index
await users.createIndex(['email', 'status'], { unique: true });

// Text index for full-text search
await articles.createIndex(['title', 'content'], {
  text: true,
  weights: { title: 10, content: 1 }
});

// TTL (Time-To-Live) index
await sessions.createIndex(['expiresAt'], {
  expireAfterSeconds: 3600 // Auto-delete after 1 hour
});

// Sparse index (only indexes non-null values)
await users.createIndex(['lastLogin'], { sparse: true });

// Regular expressions
await users.find({ email: { $regex: '@company\.com$' } });

// Type checking
await documents.find({ score: { $type: 'number' } });

// Existence checks
await users.find({ profile: { $exists: true } });

// Array operations
await posts.find({ tags: { $all: ['javascript', 'typescript'] } });
await posts.find({ tags: { $size: 3 } });

// Element matching
await orders.find({
  items: {
    $elemMatch: { price: { $gt: 100 }, category: 'electronics' }
  }
});

// Logical operators
await users.find({
  $and: [
    { age: { $gte: 18 } },
    { $or: [{ status: 'active' }, { role: 'admin' }] }
  ]
});

// Database-wide statistics
const stats = await db.getStats();
console.log(`Collections: ${stats.collections}`);
console.log(`Total Documents: ${stats.documents}`);
console.log(`Operations/sec: ${stats.operationsPerSecond}`);

// Collection-specific stats
const userStats = await db.getCollectionStats('users');
console.log(`Users: ${userStats.documentCount}`);
console.log(`Avg Size: ${userStats.avgDocumentSize} bytes`);

// Query profiling
const profile = await db.profileQuery(query, executionTime, examined, returned);
console.log(`Query took ${profile.executionTime}ms`);
console.log(`Optimization hints:`, profile.optimizationHints);

// Define schema
const userSchema = {
  name: { type: 'string', required: true, min: 2, max: 50 },
  email: { type: 'string', required: true, pattern: /^[^@]+@[^@]+\.[^@]+$/ },
  age: { type: 'number', min: 0, max: 150 },
  role: { type: 'string', enum: ['user', 'admin', 'moderator'] },
  tags: { type: ['string'], max: 10 } // Array of strings
};

// Register schema
db.registerSchema('users', userSchema);

// Validate documents
const result = await db.validateDocument('user1');
if (!result.valid) {
  console.log('Validation errors:', result.errors);
}

// Auto-generate schema from existing data
const inferredSchema = db.generateSchemaFromDocuments('products', sampleProducts);

// Evolve schema safely
const success = db.evolveSchema('users', newSchema, {
  allowBreakingChanges: false, // Prevent breaking changes
  migrateExisting: true        // Migrate existing data
});

if (!success) {
  console.log('Schema evolution blocked - would break existing data');
}

// Collection management
await db.createCollection('newCollection');
await db.renameCollection('oldName', 'newName');
const dropped = await db.dropCollection('tempCollection');

// Database maintenance
const maintenance = await db.runMaintenance();
console.log(`Optimized ${maintenance.collectionsOptimized} collections`);

// Backup and restore
const backup = await db.exportDatabase();
// ... save backup ...
await db.importDatabase(backup);

// Custom timeouts for different operations
globalMonitor.startWithTimeout('bulkImport', 600000); // 10 minutes
globalMonitor.startWithTimeout('complexQuery', 30000); // 30 seconds

// Configure connection pool
const db = new Monarch({
  connectionPool: {
    minConnections: 2,
    maxConnections: 10,
    acquireTimeoutMillis: 30000
  }
});

// Bulk operations have extended timeouts by default
await users.insertMany(documents, { timeout: 600000 }); // 10 minutes
await users.removeMany(query, { timeout: 300000 });     // 5 minutes

// Custom timeout for regular operations
import { globalMonitor } from 'monarch-database-quantum';
globalMonitor.startWithTimeout('customOperation', 120000); // 2 minutes

// Real-time notifications
db.watch('orders', (change) => {
  console.log('New order:', change.document);
});

// Geospatial queries
await db.geoadd('restaurants', -122.4194, 37.7749, 'Golden Gate Cafe');
const nearby = await db.georadius('restaurants', -122.4, 37.8, 5000); // 5km radius

// Time-series data
await db.tsadd('temperature', Date.now(), 23.5, { sensor: 'living-room' });
const history = await db.tsrange('temperature', startTime, endTime);

const db = new Monarch({
  // Persistence adapter
  adapter: new FileSystemAdapter('./data'),

  // Custom configuration
  config: {
    limits: {
      maxDocumentSize: 50 * 1024 * 1024, // 50MB
      maxDocumentsPerCollection: 100000
    },
    performance: {
      maxConcurrentOperations: 100,
      queryCacheSize: 2000
    }
  }
});

import { Monarch } from 'monarch-database-quantum';

const db = new Monarch();

// Initialize quantum engine
await db.initializeQuantumEngine();

// Create social network with 100+ users
// See examples/quantum-social-network-analysis.ts for complete implementation

// Find influencers using quantum centrality
const centralityResults = await db.calculateQuantumCentrality();
console.log('Top influencers:', Object.entries(centralityResults)
  .sort(([,a], [,b]) => b - a)
  .slice(0, 5));

// Detect communities with quantum community detection
const communities = await db.detectCommunitiesQuantum();
console.log('Community analysis complete');

// Predict missing connections
const predictions = analyzeConnectionPatterns(users, interactions);
console.log('Connection predictions:', predictions.slice(0, 3));

// Use collections with limits
const users = db.addCollection('users', {
  maxDocuments: 10000,
  ttl: 3600000 // 1 hour
});

// Or use the memory optimizer
import { MemoryOptimizer } from 'monarch-database';
const optimizer = new MemoryOptimizer();
optimizer.optimize(db);

// Add indexes to frequently queried fields
await users.createIndex('email');
await users.createIndex(['age', 'city']);

// Use query optimization
const results = await users.find(query)
  .explain(); // Shows query execution plan

// Use file system persistence
import { FileSystemAdapter } from 'monarch-database';

const db = new Monarch({
  adapter: new FileSystemAdapter('./data')
});

// Or use the CLI to manage persistence
npm run cli init ./my-data
npm run cli create users ./my-data

// Redis code
await redis.set('user:123', JSON.stringify(user));
const user = JSON.parse(await redis.get('user:123'));

// Monarch equivalent
await db.set('user:123', user);  // Automatic JSON handling
const user = await db.get('user:123');

// MongoDB code
await collection.insertOne(doc);
const docs = await collection.find({ age: { $gte: 18 } }).toArray();

// Monarch equivalent
await collection.insert(doc);  // Same API
const docs = await collection.find({ age: { $gte: 18 } });

// Browser storage
localStorage.setItem('user', JSON.stringify(user));
const user = JSON.parse(localStorage.getItem('user'));

// Monarch equivalent
const db = new Monarch(); // Works in browser too!
await db.set('user', user);
const user = await db.get('user');

// Programmatic migration example
import { RedisMigrationTool } from './migration-tools/redis-migration.js';
import { MongoDBMigrationTool } from './migration-tools/mongodb-migration.js';

const redisMigrator = new RedisMigrationTool({
  redisHost: 'localhost',
  redisPort: 6379,
  monarchPath: './migrated-data'
});

await redisMigrator.migrate();