@plyaz/db 0.0.0

package/dist/advanced/caching/RedisCache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RedisCache.d.ts","sourceRoot":"","sources":["../../../src/advanced/caching/RedisCache.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGtD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0MG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,KAAK,CAAQ;IACrB,OAAO,CAAC,UAAU,CAAS;IAG3B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;gBACS,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,UAAU,CAAC,EAAE,MAAM,CAAA;KAAE;IAKxD;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACG,GAAG,CAAC,CAAC,SAAS,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAyB3E;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACG,GAAG,CAAC,CAAC,SAAS,MAAM,EACxB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,CAAC,EACR,GAAG,CAAC,EAAE,MAAM,GACX,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAgBhC;;;;;;;;;;;;;;;;;OAiBG;IACG,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAqBrD;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACG,iBAAiB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAwBvE;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2BG;IACH,WAAW,CACT,KAAK,EAAE,MAAM,EACb,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,IAAI,CAAC,GACvD,MAAM;IAKT;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6BG;IACG,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,CAAC;IAoBrD;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAG7B"}

package/dist/advanced/caching/index.d.ts

@@ -0,0 +1,4 @@
+export { RedisCache } from "./RedisCache";
+export { Cacheable } from "./Cacheable.decorator";
+export { CacheEvict } from "./CacheEvict.decorator";
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/caching/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/caching/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/advanced/connection-pool/DynamicPool.d.ts

@@ -0,0 +1,234 @@
+import { type DatabaseResult, type DatabaseHealthStatus, type DynamicPoolConfig, type PoolMetrics } from "@plyaz/types/db";
+/**
+ * Dynamic connection pool that automatically adjusts size based on load.
+ * Provides detailed metrics and health monitoring.
+ *
+ * @example
+ * ```typescript
+ * const pool = new DynamicPool('postgres://localhost:5432/db', {
+ *   min: 2,
+ *   max: 20,
+ *   scaling: {
+ *     enabled: true,
+ *     scaleUpThreshold: 80,
+ *     scaleDownThreshold: 20,
+ *     scaleInterval: 30000,
+ *     maxScale: 5
+ *   }
+ * });
+ *
+ * // Execute a query
+ * const result = await pool.query('SELECT * FROM users');
+ *
+ * // Get pool metrics
+ * const metrics = pool.getMetrics();
+ * console.log(`Active connections: ${metrics.activeConnections}`);
+ *
+ * // Health check
+ * const health = await pool.healthCheck();
+ * console.log(`Pool healthy: ${health.value?.isHealthy}`);
+ * ```
+ *
+ * @example
+ * ### High-Traffic Application
+ * ```typescript
+ * class DatabasePool {
+ *   private pool: DynamicPool;
+ *
+ *   constructor() {
+ *     this.pool = new DynamicPool(process.env.DATABASE_URL, {
+ *       min: 5,
+ *       max: 50,
+ *       scaling: {
+ *         enabled: true,
+ *         scaleUpThreshold: 75,
+ *         scaleDownThreshold: 25,
+ *         scaleInterval: 15000, // Check every 15 seconds
+ *         maxScale: 10
+ *       }
+ *     });
+ *   }
+ *
+ *   async query<T>(sql: string, params: object[] = []): Promise<DatabaseResult<T[]>> {
+ *     return this.pool.query<T>(sql, params);
+ *   }
+ *
+ *   async getHealthStatus(): Promise<DatabaseResult<HealthStatus>> {
+ *     return this.pool.healthCheck();
+ *   }
+ *
+ *   async shutdown(): Promise<void> {
+ *     await this.pool.end();
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Connection Pool Monitoring
+ * ```typescript
+ * class PoolMonitor {
+ *   constructor(private pool: DynamicPool) {}
+ *
+ *   async startMonitoring(): Promise<void> {
+ *     setInterval(() => {
+ *       const metrics = this.pool.getMetrics();
+ *       const utilization = metrics.totalConnections > 0
+ *         ? (metrics.activeConnections / metrics.totalConnections) * 100
+ *         : 0;
+ *
+ *       console.log(`Pool Utilization: ${utilization.toFixed(1)}%`);
+ *       console.log(`Active: ${metrics.activeConnections}, Idle: ${metrics.idleConnections}`);
+ *       console.log(`Waiting: ${metrics.waitingRequests}`);
+ *
+ *       // Alert if pool is under pressure
+ *       if (utilization > 90) {
+ *         console.warn('Pool utilization is very high!');
+ *       }
+ *     }, 30000); // Every 30 seconds
+ *   }
+ * }
+ * ```
+ *
+ * @example
+ * ### Auto-scaling Configuration
+ * ```typescript
+ * const poolConfig: DynamicPoolConfig = {
+ *   min: 3,
+ *   max: 30,
+ *   idleTimeoutMillis: 60000, // 1 minute
+ *   acquireTimeoutMillis: 5000, // 5 seconds
+ *   scaling: {
+ *     enabled: true,
+ *     scaleUpThreshold: 80, // Scale up when 80% utilized
+ *     scaleDownThreshold: 20, // Scale down when 20% idle
+ *     scaleInterval: 10000, // Check every 10 seconds
+ *     maxScale: 5 // Add/remove up to 5 connections at once
+ *   }
+ * };
+ *
+ * const pool = new DynamicPool('postgres://localhost:5432/myapp', poolConfig);
+ * ```
+ */
+export declare class DynamicPool {
+    private pool;
+    private config;
+    private metrics;
+    private scalingTimer?;
+    /**
+     * Creates a new DynamicPool instance.
+     * @param connectionString Database connection string
+     * @param config Pool configuration options
+     *
+     * @example
+     * ```typescript
+     * // Basic configuration
+     * const pool = new DynamicPool('postgres://localhost:5432/db');
+     *
+     * // Advanced configuration
+     * const pool = new DynamicPool('postgres://localhost:5432/db', {
+     *   min: 5,
+     *   max: 25,
+     *   scaling: {
+     *     enabled: true,
+     *     scaleUpThreshold: 75,
+     *     scaleInterval: 20000
+     *   }
+     * });
+     * ```
+     */
+    constructor(connectionString: string, config?: Partial<DynamicPoolConfig>);
+    /**
+     * Sets up event listeners for the connection pool.
+     */
+    private setupEventListeners;
+    /**
+     * Starts the auto-scaling timer.
+     */
+    private startScalingTimer;
+    /**
+     * Adjusts pool size based on current load.
+     */
+    private adjustPoolSize;
+    /**
+     * Adjusts the pool connection count.
+     * @param newCount New connection count
+     */
+    private adjustPoolCount;
+    /**
+     * Executes a database query with timing and error tracking.
+     * @param sql SQL query string
+     * @param params Query parameters
+     * @returns Query result
+     *
+     * @example
+     * ```typescript
+     * // Simple query
+     * const result = await pool.query('SELECT * FROM users');
+     *
+     * // Query with parameters
+     * const result = await pool.query(
+     *   'SELECT * FROM users WHERE id = $1 AND active = $2',
+     *   [123, true]
+     * );
+     *
+     * // Query with type safety
+     * const users = await pool.query<User>('SELECT * FROM users');
+     * ```
+     */
+    query<T extends object>(sql: string, params?: object[]): Promise<DatabaseResult<T[]>>;
+    /**
+     * Performs a health check on the connection pool.
+     * @returns Health status with detailed metrics
+     *
+     * @example
+     * ```typescript
+     * const health = await pool.healthCheck();
+     * if (health.success && health.value?.isHealthy) {
+     *   console.log('Pool is healthy');
+     *   console.log(`Response time: ${health.value.responseTime}ms`);
+     * } else {
+     *   console.log('Pool health check failed');
+     * }
+     * ```
+     */
+    healthCheck(): Promise<DatabaseResult<DatabaseHealthStatus>>;
+    /**
+     * Gets current pool metrics.
+     * @returns Pool performance metrics
+     *
+     * @example
+     * ```typescript
+     * const metrics = pool.getMetrics();
+     * console.log(`Total connections: ${metrics.totalConnections}`);
+     * console.log(`Active connections: ${metrics.activeConnections}`);
+     * console.log(`Idle connections: ${metrics.idleConnections}`);
+     * console.log(`Average acquisition time: ${metrics.averageAcquisitionTime}ms`);
+     *
+     * // Calculate utilization rate
+     * const utilizationRate = metrics.totalConnections > 0
+     *   ? (metrics.activeConnections / metrics.totalConnections) * 100
+     *   : 0;
+     * console.log(`Utilization rate: ${utilizationRate.toFixed(1)}%`);
+     * ```
+     */
+    getMetrics(): PoolMetrics;
+    /**
+     * Closes all connections in the pool.
+     *
+     * @example
+     * ```typescript
+     * // Graceful shutdown
+     * async function shutdown() {
+     *   console.log('Closing database connections...');
+     *   await pool.end();
+     *   console.log('Database connections closed');
+     * }
+     *
+     * // Handle process signals
+     * process.on('SIGTERM', shutdown);
+     * process.on('SIGINT', shutdown);
+     * ```
+     */
+    end(): Promise<void>;
+}
+//# sourceMappingURL=DynamicPool.d.ts.map

package/dist/advanced/connection-pool/DynamicPool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DynamicPool.d.ts","sourceRoot":"","sources":["../../../src/advanced/connection-pool/DynamicPool.ts"],"names":[],"mappings":"AAMA,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAIzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6GG;AAEH,qBAAa,WAAW;IACtB,OAAO,CAAC,IAAI,CAAO;IACnB,OAAO,CAAC,MAAM,CAAoB;IAClC,OAAO,CAAC,OAAO,CAOE;IACjB,OAAO,CAAC,YAAY,CAAC,CAAiC;IAEtD;;;;;;;;;;;;;;;;;;;;;OAqBG;gBAED,gBAAgB,EAAE,MAAM,EACxB,MAAM,GAAE,OAAO,CAAC,iBAAiB,CAAM;IAqBzC;;OAEG;IACH,OAAO,CAAC,mBAAmB;IA2C3B;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAMzB;;OAEG;IACH,OAAO,CAAC,cAAc;IA4BtB;;;OAGG;IACH,OAAO,CAAC,eAAe;IAuBvB;;;;;;;;;;;;;;;;;;;;OAoBG;IACG,KAAK,CAAC,CAAC,SAAS,MAAM,EAC1B,GAAG,EAAE,MAAM,EACX,MAAM,GAAE,MAAM,EAAO,GACpB,OAAO,CAAC,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC;IA6C/B;;;;;;;;;;;;;;OAcG;IACG,WAAW,IAAI,OAAO,CAAC,cAAc,CAAC,oBAAoB,CAAC,CAAC;IA2ClE;;;;;;;;;;;;;;;;;;OAkBG;IACH,UAAU,IAAI,WAAW;IAIzB;;;;;;;;;;;;;;;;OAgBG;IACG,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAqB3B"}

package/dist/advanced/connection-pool/index.d.ts

@@ -0,0 +1,2 @@
+export { DynamicPool } from "./DynamicPool";
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/connection-pool/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/connection-pool/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC"}

package/dist/advanced/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./read-replica";
+export * from "./caching";
+export * from "./connection-pool";
+export * from "./monitoring";
+export * from "./backup";
+export * from "./multi-tenancy";
+export * from "./sharding";
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/advanced/index.ts"],"names":[],"mappings":"AACA,cAAc,gBAAgB,CAAC;AAG/B,cAAc,WAAW,CAAC;AAG1B,cAAc,mBAAmB,CAAC;AAGlC,cAAc,cAAc,CAAC;AAG7B,cAAc,UAAU,CAAC;AAGzB,cAAc,iBAAiB,CAAC;AAGhC,cAAc,YAAY,CAAC"}

package/dist/advanced/monitoring/AlertManager.d.ts

@@ -0,0 +1,72 @@
+import { EventEmitter } from "events";
+import type { Alert, AlertRule } from "@plyaz/types";
+/**
+ * Manages database alerts with configurable rules and automatic resolution.
+ * Provides real-time alerting for various database issues.
+ *
+ * @example
+ * ```typescript
+ * const alertManager = new AlertManager();
+ *
+ * // Add custom alert rule
+ * alertManager.addRule({
+ *   id: 'high-error-rate',
+ *   condition: (metrics) => (metrics.errorRate as number) > 5,
+ *   message: (metrics) => `High error rate: ${metrics.errorRate}%`,
+ *   severity: 'error',
+ *   source: 'database'
+ * });
+ *
+ * // Evaluate metrics against rules
+ * const metrics = { errorRate: 7.2, poolUtilization: 85 };
+ * alertManager.evaluate(metrics);
+ *
+ * // Get active alerts
+ * const activeAlerts = alertManager.getActiveAlerts();
+ *
+ * // Resolve an alert
+ * alertManager.resolveAlert('alert-id');
+ * ```
+ */
+export declare class AlertManager extends EventEmitter {
+    private alerts;
+    private alertRules;
+    private readonly logger;
+    constructor();
+    /**
+     * Sets up default alert rules for common database issues.
+     */
+    private setupDefaultRules;
+    /**
+     * Adds a custom alert rule.
+     * @param rule Alert rule definition
+     */
+    addRule(rule: AlertRule): void;
+    /**
+     * Evaluates metrics against all alert rules.
+     * @param metrics Database and pool metrics
+     */
+    evaluate(metrics: Record<string, object>): void;
+    /**
+     * Triggers an alert based on a rule.
+     * @param rule Alert rule that was triggered
+     * @param metrics Current metrics
+     */
+    private triggerAlert;
+    /**
+     * Marks an alert as resolved.
+     * @param alertId ID of the alert to resolve
+     */
+    resolveAlert(alertId: string): void;
+    /**
+     * Gets all currently active (unresolved) alerts.
+     * @returns Array of active alerts
+     */
+    getActiveAlerts(): Alert[];
+    /**
+     * Gets all alerts (both active and resolved).
+     * @returns Array of all alerts
+     */
+    getAllAlerts(): Alert[];
+}
+//# sourceMappingURL=AlertManager.d.ts.map

package/dist/advanced/monitoring/AlertManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AlertManager.d.ts","sourceRoot":"","sources":["../../../src/advanced/monitoring/AlertManager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAA6B,MAAM,cAAc,CAAC;AAGhF;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,YAAa,SAAQ,YAAY;IAC5C,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,UAAU,CAAmB;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;;IAOjC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAkEzB;;;OAGG;IACH,OAAO,CAAC,IAAI,EAAE,SAAS,GAAG,IAAI;IAI9B;;;OAGG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,IAAI;IAQ/C;;;;OAIG;IACH,OAAO,CAAC,YAAY;IA2BpB;;;OAGG;IACH,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI;IASnC;;;OAGG;IACH,eAAe,IAAI,KAAK,EAAE;IAI1B;;;OAGG;IACH,YAAY,IAAI,KAAK,EAAE;CAGxB"}

package/dist/advanced/monitoring/MetricsCollector.d.ts

@@ -0,0 +1,81 @@
+import type { PoolMetrics, QueryMetrics } from "@plyaz/types";
+import { EventEmitter } from "events";
+/**
+ * Collects and analyzes database performance metrics.
+ * Provides insights into query performance, pool usage, and potential issues.
+ *
+ * @example
+ * ```typescript
+ * const collector = new MetricsCollector();
+ *
+ * // Record a query metric
+ * collector.recordQuery({
+ *   query: 'SELECT * FROM users WHERE id = $1',
+ *   duration: 45,
+ *   timestamp: new Date(),
+ *   success: true,
+ *   table: 'users',
+ *   operation: 'findById'
+ * });
+ *
+ * // Get top slow queries
+ * const slowQueries = collector.getTopSlowQueries(10);
+ *
+ * // Detect N+1 queries
+ * const nPlusOneQueries = collector.detectNPlusOneQueries();
+ *
+ * // Get query frequency
+ * const frequency = collector.getQueryFrequency();
+ * ```
+ */
+export declare class MetricsCollector extends EventEmitter {
+    private queryMetrics;
+    private poolMetrics;
+    private alerts;
+    private readonly logger;
+    private readonly SLOW_QUERY_THRESHOLD;
+    private readonly POOL_EXHAUSTION_THRESHOLD;
+    private readonly REPLICA_LAG_THRESHOLD;
+    private readonly DISK_SPACE_THRESHOLD;
+    /**
+     * Records query execution metrics.
+     * @param metrics Query execution metrics
+     */
+    recordQuery(metrics: QueryMetrics): void;
+    /**
+     * Records connection pool metrics.
+     * @param metrics Pool performance metrics
+     */
+    recordPoolMetrics(metrics: PoolMetrics): void;
+    /**
+     * Gets the top slow queries.
+     * @param limit Number of queries to return
+     * @returns Array of slowest queries
+     */
+    getTopSlowQueries(limit?: number): QueryMetrics[];
+    /**
+     * Gets query frequency statistics.
+     * @returns Object mapping normalized queries to frequency counts
+     */
+    getQueryFrequency(): Record<string, number>;
+    /**
+     * Detects potential N+1 query patterns.
+     * @returns Array of suspicious queries with their execution counts
+     */
+    detectNPlusOneQueries(): {
+        query: string;
+        count: number;
+    }[];
+    /**
+     * Normalizes a query for frequency analysis.
+     * @param query Original SQL query
+     * @returns Normalized query string
+     */
+    private normalizeQuery;
+    /**
+     * Emits an alert event.
+     * @param message Alert message
+     */
+    private emitAlert;
+}
+//# sourceMappingURL=MetricsCollector.d.ts.map

package/dist/advanced/monitoring/MetricsCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MetricsCollector.d.ts","sourceRoot":"","sources":["../../../src/advanced/monitoring/MetricsCollector.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC9D,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAGtC;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,gBAAiB,SAAQ,YAAY;IAChD,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,WAAW,CAAqB;IACxC,OAAO,CAAC,MAAM,CAAgB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAU;IAEjC,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAQ;IAC7C,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAM;IAChD,OAAO,CAAC,QAAQ,CAAC,qBAAqB,CAAQ;IAC9C,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAAM;IAE3C;;;OAGG;IACH,WAAW,CAAC,OAAO,EAAE,YAAY,GAAG,IAAI;IAkBxC;;;OAGG;IACH,iBAAiB,CAAC,OAAO,EAAE,WAAW,GAAG,IAAI;IA2B7C;;;;OAIG;IACH,iBAAiB,CAAC,KAAK,GAAE,MAAW,GAAG,YAAY,EAAE;IAOrD;;;OAGG;IACH,iBAAiB,IAAI,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;IAW3C;;;OAGG;IACH,qBAAqB,IAAI;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE;IAa3D;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAKtB;;;OAGG;IACH,OAAO,CAAC,SAAS;CASlB"}

package/dist/advanced/monitoring/index.d.ts

@@ -0,0 +1,3 @@
+export { MetricsCollector } from "./MetricsCollector";
+export { AlertManager } from "./AlertManager";
+//# sourceMappingURL=index.d.ts.map

package/dist/advanced/monitoring/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/advanced/monitoring/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/advanced/multi-tenancy/TenantContext.d.ts

@@ -0,0 +1,52 @@
+import type { TenantInfo } from "@plyaz/types";
+/**
+ * Manages tenant context throughout the application using AsyncLocalStorage.
+ * Provides a way to isolate tenant-specific data and operations.
+ *
+ * @example
+ * ```typescript
+ * const tenant: TenantInfo = {
+ *   id: 'tenant-123',
+ *   name: 'Acme Corp',
+ *   schema: 'acme_corp'
+ * };
+ *
+ * // Run code within tenant context
+ * const result = await TenantContext.run(tenant, async () => {
+ *   // This code has access to the tenant context
+ *   const currentTenant = TenantContext.current();
+ *   console.log(`Running as tenant: ${currentTenant?.name}`);
+ *
+ *   // Perform tenant-specific operations
+ *   return await userService.getUsers();
+ * });
+ *
+ * // Access current tenant from anywhere
+ * const current = TenantContext.current();
+ * if (current) {
+ *   console.log(`Current tenant: ${current.name}`);
+ * }
+ * ```
+ */
+export declare class TenantContext {
+    private static storage;
+    /**
+     * Runs a function within a specific tenant context.
+     * @param tenant Tenant information
+     * @param callback Function to execute within tenant context
+     * @returns Result of the callback function
+     */
+    static run<T>(tenant: TenantInfo, callback: () => Promise<T>): Promise<T>;
+    /**
+     * Gets the current tenant context.
+     * @returns Current tenant information or undefined if no context is set
+     */
+    static current(): TenantInfo | undefined;
+    /**
+     * Gets the current tenant context or throws an error if none is set.
+     * @returns Current tenant information
+     * @throws Error if no tenant context is available
+     */
+    static requireCurrent(): TenantInfo;
+}
+//# sourceMappingURL=TenantContext.d.ts.map

package/dist/advanced/multi-tenancy/TenantContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TenantContext.d.ts","sourceRoot":"","sources":["../../../src/advanced/multi-tenancy/TenantContext.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,MAAM,CAAC,OAAO,CAAuC;IAE7D;;;;;OAKG;IACH,MAAM,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;IAIzE;;;OAGG;IACH,MAAM,CAAC,OAAO,IAAI,UAAU,GAAG,SAAS;IAIxC;;;;OAIG;IACH,MAAM,CAAC,cAAc,IAAI,UAAU;CAepC"}