@plyaz/types 1.13.10 → 1.13.11

package/dist/db/audit.types.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Audit context for tracking user actions
+ */
+export interface AuditContext {
+    userId?: string;
+    requestId?: string;
+    ipAddress?: string;
+    userAgent?: string;
+}
+export interface AuditEvent {
+    operation: string;
+    table: string;
+    recordId?: string;
+    userId?: string;
+    requestId?: string;
+    changes: {
+        before?: Record<string, string | number | boolean | Date>;
+        after?: Record<string, string | number | boolean | Date>;
+        fields?: string[];
+    };
+    timestamp: Date;
+    ipAddress?: string;
+    userAgent?: string;
+}

package/dist/db/backup.types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Configuration options for backup service.
+ */
+export interface BackupConfig {
+    /** Database connection string */
+    connectionString: string;
+    /** Directory to store backup files */
+    backupDir: string;
+    /** Number of days to retain backups */
+    retentionDays: number;
+    /** Cron expression for scheduled backups */
+    schedule?: string;
+    /** Whether to compress backup files */
+    compression?: boolean;
+    /** Encryption configuration */
+    encryption?: {
+        /** Whether encryption is enabled */
+        enabled: boolean;
+        /** Encryption key */
+        key: string;
+    };
+    /** S3 configuration for cloud storage */
+    s3?: {
+        /** Whether S3 upload is enabled */
+        enabled: boolean;
+        /** S3 bucket name */
+        bucket: string;
+        /** AWS region */
+        region: string;
+        /** AWS access key */
+        accessKey: string;
+        /** AWS secret key */
+        secretKey: string;
+    };
+}
+/**
+ * Information about a backup file.
+ */
+export interface BackupInfo {
+    /** Unique backup identifier */
+    id: string;
+    /** Backup filename */
+    filename: string;
+    /** Backup file size in bytes */
+    size: number;
+    /** When the backup was created */
+    createdAt: Date;
+    /** When the backup expires */
+    expiresAt: Date;
+    /** Backup status */
+    status: 'created' | 'uploading' | 'uploaded' | 'failed';
+    /** Backup location */
+    location: 'local' | 's3';
+}

package/dist/db/database.types.d.ts

@@ -51,10 +51,8 @@
  *   console.error('Error:', result.error.message);
  * }
  * ```
- *
- * @author Plyaz Engineering Team
- * @since 1.0.0
  */
+import type { PaginationOptions } from "./databsePagination";
 /**
  * Input type for creating records
  */
@@ -105,39 +103,6 @@ export interface SortOptions<TRecord extends object = object> {
     /** Sort direction */
     direction: 'asc' | 'desc';
 }
-/**
- * Pagination options for queries
- */
-export interface PaginationOptions {
-    /** Number of items to return */
-    limit?: number;
-    /** Number of items to skip */
-    offset?: number;
-    /** Cursor for cursor-based pagination */
-    cursor?: string;
-}
-/**
- * Paginated result type
- */
-export interface PaginatedResult<T> {
-    /** Array of results */
-    data: T[];
-    /** Total count of items */
-    total: number;
-    /** Pagination metadata */
-    pagination: {
-        /** Current page number */
-        page?: number;
-        /** Number of items per page */
-        limit?: number;
-        /** Total number of pages */
-        totalPages?: number;
-        /** Next cursor for cursor-based pagination */
-        nextCursor?: string;
-        /** Previous cursor for cursor-based pagination */
-        prevCursor?: string;
-    };
-}
 /**
  * Database health status
  */
@@ -160,3 +125,134 @@ export interface DatabaseResult<T> {
     /** The error if unsuccessful */
     error?: Error | null;
 }
+/**
+ * Options for the @Cacheable decorator.
+ */
+export interface CacheableOptions {
+    /** Time to live in seconds */
+    ttl?: number;
+    /** Custom cache key (auto-generated if not specified) */
+    key?: string;
+    /** Condition function to determine if result should be cached */
+    condition?: <T>(result: T) => boolean;
+}
+/**
+ * Options for the @CacheEvict decorator.
+ */
+export interface CacheEvictOptions {
+    /** Specific cache key to evict */
+    key?: string;
+    /** Cache pattern to evict (e.g., 'users:*') */
+    pattern?: string;
+    /** Whether to evict all cache entries */
+    allEntries?: boolean;
+}
+/**
+ * Configuration options for dynamic connection pool.
+ */
+export interface DynamicPoolConfig {
+    /** Minimum number of connections in the pool */
+    min: number;
+    /** Maximum number of connections in the pool */
+    max: number;
+    /** Time in milliseconds after which idle connections are closed */
+    idleTimeoutMillis: number;
+    /** Time in milliseconds to wait for a connection to become available */
+    acquireTimeoutMillis: number;
+    /** Auto-scaling configuration */
+    scaling: {
+        /** Whether auto-scaling is enabled */
+        enabled: boolean;
+        /** Percentage threshold for scaling up (default: 80) */
+        scaleUpThreshold: number;
+        /** Percentage threshold for scaling down (default: 20) */
+        scaleDownThreshold: number;
+        /** Interval in milliseconds for scaling checks (default: 30000) */
+        scaleInterval: number;
+        /** Maximum number of connections to add/remove at once */
+        maxScale: number;
+    };
+}
+/**
+ * Database alert with detailed information.
+ */
+export interface Alert {
+    /** Unique alert identifier */
+    id: string;
+    /** Alert message */
+    message: string;
+    /** Alert severity level */
+    severity: 'info' | 'warning' | 'error' | 'critical';
+    /** When the alert was triggered */
+    timestamp: Date;
+    /** Whether the alert has been resolved */
+    resolved: boolean;
+    /** When the alert was resolved (if applicable) */
+    resolvedAt?: Date;
+    /** Source of the alert */
+    source: 'database' | 'pool' | 'replica' | 'cache' | 'backup';
+}
+/**
+ * Rule for generating alerts based on metrics.
+ */
+export interface AlertRule {
+    /** Unique rule identifier */
+    id: string;
+    /** Condition function that returns true if alert should be triggered */
+    condition: (metrics: Record<string, object>) => boolean;
+    /** Function that generates alert message */
+    message: (metrics: Record<string, object>) => string;
+    /** Alert severity level */
+    severity: 'info' | 'warning' | 'error' | 'critical';
+    /** Alert source category */
+    source: 'database' | 'pool' | 'replica' | 'cache' | 'backup';
+}
+/**
+ * Metrics collected for database queries.
+ */
+export interface QueryMetrics {
+    /** SQL query string */
+    query: string;
+    /** Query execution time in milliseconds */
+    duration: number;
+    /** Timestamp when query was executed */
+    timestamp: Date;
+    /** Whether query was successful */
+    success: boolean;
+    /** Error message if query failed */
+    error?: string;
+    /** Database table name */
+    table?: string;
+    /** Database operation type */
+    operation?: string;
+}
+/**
+ * Metrics collected for connection pool.
+ */
+export interface PoolMetrics {
+    totalReleased: number;
+    totalAcquired: number;
+    /** Total number of connections */
+    totalConnections: number;
+    /** Number of active connections */
+    activeConnections: number;
+    /** Number of idle connections */
+    idleConnections: number;
+    /** Number of requests waiting for connections */
+    waitingRequests: number;
+    /** Average time to acquire a connection */
+    averageAcquisitionTime: number;
+}
+/**
+ * Information about the current tenant.
+ */
+export interface TenantInfo {
+    /** Unique tenant identifier */
+    id: string;
+    /** Tenant display name */
+    name: string;
+    /** Database schema for the tenant (optional) */
+    schema?: string;
+    /** Tenant role for permissions (optional) */
+    role?: string;
+}

package/dist/db/databsePagination.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pagination options for queries
+ */
+export interface PaginationOptions {
+    /** Number of items to return */
+    limit?: number;
+    /** Number of items to skip */
+    offset?: number;
+    /** Cursor for cursor-based pagination */
+    cursor?: string;
+}
+/**
+ * Paginated result type
+ */
+export interface PaginatedResult<T> {
+    /** Array of results */
+    data: T[];
+    /** Total count of items */
+    total: number;
+    /** Pagination metadata */
+    pagination: {
+        /** Current page number */
+        page?: number;
+        /** Number of items per page */
+        limit?: number;
+        /** Total number of pages */
+        totalPages?: number;
+        /** Next cursor for cursor-based pagination */
+        nextCursor?: string;
+        /** Previous cursor for cursor-based pagination */
+        prevCursor?: string;
+    };
+}
+/**
+ * Pagination information
+ */
+export interface PaginationInfo {
+    /** Current page number */
+    page?: number;
+    /** Number of items per page */
+    limit?: number;
+    /** Number of items skipped (offset) */
+    offset: number;
+    /** Total number of pages */
+    totalPages?: number;
+}

package/dist/db/features-config.types.d.ts

@@ -69,6 +69,8 @@
  * };
  * ```
  */
+import type { AuditEvent } from "./audit.types";
+import type { ReadReplicaConfig } from "./replica.types";
 /**
  * Configuration for soft delete functionality
  */
@@ -136,19 +138,6 @@ export interface DBCacheConfig {
     /** Cache invalidation strategy */
     invalidation?: 'write' | 'ttl' | 'manual';
 }
-/**
- * Configuration for read replicas
- */
-export interface ReadReplicaConfig {
-    /** Whether read replicas are enabled */
-    enabled: boolean;
-    /** Replica connection configs */
-    replicas: AdapterConfig[];
-    /** Load balancing strategy */
-    strategy?: 'round-robin' | 'random' | 'least-connections';
-    /** Fallback to primary if all replicas unhealthy */
-    fallbackToPrimary?: boolean;
-}
 /**
  * Connection pool configuration
  */
@@ -207,21 +196,6 @@ export interface AfterReadEvent {
     duration: number;
     timestamp: Date;
 }
-export interface AuditEvent {
-    operation: string;
-    table: string;
-    recordId?: string;
-    userId?: string;
-    requestId?: string;
-    changes: {
-        before?: Record<string, string | number | boolean | Date>;
-        after?: Record<string, string | number | boolean | Date>;
-        fields?: string[];
-    };
-    timestamp: Date;
-    ipAddress?: string;
-    userAgent?: string;
-}
 /**
  * Adapter-specific configuration types
  */

package/dist/db/index.cjs

@@ -11,6 +11,16 @@ var ADAPTERS = /* @__PURE__ */ ((ADAPTERS2) => {
   return ADAPTERS2;
 })(ADAPTERS || {});
 
+// src/db/replicaStrategy.ts
+var REPLICA_STRATEGY = /* @__PURE__ */ ((REPLICA_STRATEGY2) => {
+  REPLICA_STRATEGY2["PRIMARY"] = "primary";
+  REPLICA_STRATEGY2["REPLICA"] = "replica";
+  REPLICA_STRATEGY2["CLOSEST"] = "closest";
+  REPLICA_STRATEGY2["FASTEST"] = "fastest";
+  return REPLICA_STRATEGY2;
+})(REPLICA_STRATEGY || {});
+
 exports.ADAPTERS = ADAPTERS;
+exports.REPLICA_STRATEGY = REPLICA_STRATEGY;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map

package/dist/db/index.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/db/adapter.ts"],"names":["ADAPTERS"],"mappings":";;;;;AAiFO,IAAK,QAAA,qBAAAA,SAAAA,KAAL;AAEL,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,SAAA,CAAA,GAAU,SAAA;AAGV,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,KAAA,CAAA,GAAM,KAAA;AAXI,EAAA,OAAAA,SAAAA;AAAA,CAAA,EAAA,QAAA,IAAA,EAAA","file":"index.cjs","sourcesContent":["/**\n * @fileoverview Database adapter type definitions\n *\n * Defines the enumeration of supported database adapter types used throughout\n * the database package. This enum provides type-safe identification of different\n * database integrations and is used in configuration, factory methods, and\n * adapter selection logic.\n *\n * **Application Flow Context:**\n * ```\n * Configuration → ADAPTERS Enum → AdapterFactory → Concrete Adapter\n *      ↓             ↓              ↓               ↓\n * User Config  → Type Safety   → Adapter Creation → Database Connection\n * ```\n *\n * **Adapter Types:**\n * - **DRIZZLE**: Type-safe ORM with excellent TypeScript support\n * - **SUPABASE**: Hosted PostgreSQL with real-time capabilities\n * - **SQL**: Raw SQL execution for maximum control\n * - **DATABASE**: Generic fallback adapter\n *\n * @example\n * ```typescript\n * // Adapter selection in configuration\n * const config = {\n *   adapter: ADAPTERS.DRIZZLE,\n *   connectionString: process.env.DATABASE_URL\n * };\n *\n * // Type-safe adapter factory usage\n * const adapter = AdapterFactory.create(ADAPTERS.SUPABASE, supabaseConfig);\n *\n * // Switch statement with exhaustive checking\n * switch (config.adapter) {\n *   case ADAPTERS.DRIZZLE:\n *     // Handle Drizzle-specific logic\n *     break;\n *   case ADAPTERS.SUPABASE:\n *     // Handle Supabase-specific logic\n *     break;\n *   case ADAPTERS.SQL:\n *     // Handle SQL-specific logic\n *     break;\n *   default:\n *     // TypeScript ensures all cases are handled\n *     throw new Error(`Unsupported adapter: ${config.adapter}`);\n * }\n * ```\n *\n */\n/**\n * @enum ADAPTERS\n * @description\n * Enumeration of supported database adapter types.\n *\n * This enum provides type-safe identification of different database integrations\n * and is used throughout the package for configuration, factory methods, and\n * adapter selection. Each adapter type represents a different approach to\n * database connectivity and operations.\n *\n * **Adapter Characteristics:**\n * - **DATABASE**: Generic fallback, minimal functionality\n * - **DRIZZLE**: Full ORM with type safety and query building\n * - **SUPABASE**: Hosted solution with real-time and auth features\n * - **SQL**: Raw SQL for performance-critical applications\n *\n * @example\n * ```typescript\n * // Configuration with adapter selection\n * const configs = {\n *   development: { adapter: ADAPTERS.DRIZZLE },\n *   production: { adapter: ADAPTERS.SUPABASE },\n *   performance: { adapter: ADAPTERS.SQL }\n * };\n *\n * // Type-safe adapter validation\n * function validateAdapter(adapter: ADAPTERS): boolean {\n *   return Object.values(ADAPTERS).includes(adapter);\n * }\n * ```\n */\nexport enum ADAPTERS {\n  /** Generic database adapter (default when no specific integration is set) */\n  DATABASE = 'database',\n\n  /** Drizzle ORM adapter (PostgreSQL, MySQL, SQLite, etc.) */\n  DRIZZLE = 'drizzle',\n\n  /** Supabase adapter (PostgreSQL backend with REST + Realtime APIs) */\n  SUPABASE = 'supabase',\n\n  /** Raw SQL adapter (direct database queries without ORM) */\n  SQL = 'sql',\n}\n"]}
+{"version":3,"sources":["../../src/db/adapter.ts","../../src/db/replicaStrategy.ts"],"names":["ADAPTERS","REPLICA_STRATEGY"],"mappings":";;;;;AAiFO,IAAK,QAAA,qBAAAA,SAAAA,KAAL;AAEL,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,SAAA,CAAA,GAAU,SAAA;AAGV,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,KAAA,CAAA,GAAM,KAAA;AAXI,EAAA,OAAAA,SAAAA;AAAA,CAAA,EAAA,QAAA,IAAA,EAAA;;;AC9EL,IAAK,gBAAA,qBAAAC,iBAAAA,KAAL;AAEL,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AARA,EAAA,OAAAA,iBAAAA;AAAA,CAAA,EAAA,gBAAA,IAAA,EAAA","file":"index.cjs","sourcesContent":["/**\n * @fileoverview Database adapter type definitions\n *\n * Defines the enumeration of supported database adapter types used throughout\n * the database package. This enum provides type-safe identification of different\n * database integrations and is used in configuration, factory methods, and\n * adapter selection logic.\n *\n * **Application Flow Context:**\n * ```\n * Configuration → ADAPTERS Enum → AdapterFactory → Concrete Adapter\n *      ↓             ↓              ↓               ↓\n * User Config  → Type Safety   → Adapter Creation → Database Connection\n * ```\n *\n * **Adapter Types:**\n * - **DRIZZLE**: Type-safe ORM with excellent TypeScript support\n * - **SUPABASE**: Hosted PostgreSQL with real-time capabilities\n * - **SQL**: Raw SQL execution for maximum control\n * - **DATABASE**: Generic fallback adapter\n *\n * @example\n * ```typescript\n * // Adapter selection in configuration\n * const config = {\n *   adapter: ADAPTERS.DRIZZLE,\n *   connectionString: process.env.DATABASE_URL\n * };\n *\n * // Type-safe adapter factory usage\n * const adapter = AdapterFactory.create(ADAPTERS.SUPABASE, supabaseConfig);\n *\n * // Switch statement with exhaustive checking\n * switch (config.adapter) {\n *   case ADAPTERS.DRIZZLE:\n *     // Handle Drizzle-specific logic\n *     break;\n *   case ADAPTERS.SUPABASE:\n *     // Handle Supabase-specific logic\n *     break;\n *   case ADAPTERS.SQL:\n *     // Handle SQL-specific logic\n *     break;\n *   default:\n *     // TypeScript ensures all cases are handled\n *     throw new Error(`Unsupported adapter: ${config.adapter}`);\n * }\n * ```\n *\n */\n/**\n * @enum ADAPTERS\n * @description\n * Enumeration of supported database adapter types.\n *\n * This enum provides type-safe identification of different database integrations\n * and is used throughout the package for configuration, factory methods, and\n * adapter selection. Each adapter type represents a different approach to\n * database connectivity and operations.\n *\n * **Adapter Characteristics:**\n * - **DATABASE**: Generic fallback, minimal functionality\n * - **DRIZZLE**: Full ORM with type safety and query building\n * - **SUPABASE**: Hosted solution with real-time and auth features\n * - **SQL**: Raw SQL for performance-critical applications\n *\n * @example\n * ```typescript\n * // Configuration with adapter selection\n * const configs = {\n *   development: { adapter: ADAPTERS.DRIZZLE },\n *   production: { adapter: ADAPTERS.SUPABASE },\n *   performance: { adapter: ADAPTERS.SQL }\n * };\n *\n * // Type-safe adapter validation\n * function validateAdapter(adapter: ADAPTERS): boolean {\n *   return Object.values(ADAPTERS).includes(adapter);\n * }\n * ```\n */\nexport enum ADAPTERS {\n  /** Generic database adapter (default when no specific integration is set) */\n  DATABASE = 'database',\n\n  /** Drizzle ORM adapter (PostgreSQL, MySQL, SQLite, etc.) */\n  DRIZZLE = 'drizzle',\n\n  /** Supabase adapter (PostgreSQL backend with REST + Realtime APIs) */\n  SUPABASE = 'supabase',\n\n  /** Raw SQL adapter (direct database queries without ORM) */\n  SQL = 'sql',\n}\n","/**\n * Strategy options for replica selection.\n */\nexport enum REPLICA_STRATEGY {\n  /** Always use primary database */\n  PRIMARY = 'primary',\n  /** Use any available replica */\n  REPLICA = 'replica',\n  /** Use geographically closest replica */\n  CLOSEST = 'closest',\n  /** Use fastest responding replica */\n  FASTEST = 'fastest'\n}"]}

package/dist/db/index.d.ts

@@ -1,9 +1,11 @@
-export type * from './DatabaseService';
-export type * from './EventEmitter';
-export type * from './config.types';
-export type * from './DatabaseAdapter';
 export type * from './features-config.types';
 export type * from './database.types';
 export * from './adapter';
 export type * from './Transaction';
 export type * from './event.types';
+export * from './replicaStrategy';
+export type * from './databsePagination';
+export type * from './shard';
+export type * from './audit.types';
+export type * from './backup.types';
+export type * from './replica.types';

package/dist/db/index.js

@@ -9,6 +9,15 @@ var ADAPTERS = /* @__PURE__ */ ((ADAPTERS2) => {
   return ADAPTERS2;
 })(ADAPTERS || {});
 
-export { ADAPTERS };
+// src/db/replicaStrategy.ts
+var REPLICA_STRATEGY = /* @__PURE__ */ ((REPLICA_STRATEGY2) => {
+  REPLICA_STRATEGY2["PRIMARY"] = "primary";
+  REPLICA_STRATEGY2["REPLICA"] = "replica";
+  REPLICA_STRATEGY2["CLOSEST"] = "closest";
+  REPLICA_STRATEGY2["FASTEST"] = "fastest";
+  return REPLICA_STRATEGY2;
+})(REPLICA_STRATEGY || {});
+
+export { ADAPTERS, REPLICA_STRATEGY };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map

package/dist/db/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../src/db/adapter.ts"],"names":["ADAPTERS"],"mappings":";;;AAiFO,IAAK,QAAA,qBAAAA,SAAAA,KAAL;AAEL,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,SAAA,CAAA,GAAU,SAAA;AAGV,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,KAAA,CAAA,GAAM,KAAA;AAXI,EAAA,OAAAA,SAAAA;AAAA,CAAA,EAAA,QAAA,IAAA,EAAA","file":"index.js","sourcesContent":["/**\n * @fileoverview Database adapter type definitions\n *\n * Defines the enumeration of supported database adapter types used throughout\n * the database package. This enum provides type-safe identification of different\n * database integrations and is used in configuration, factory methods, and\n * adapter selection logic.\n *\n * **Application Flow Context:**\n * ```\n * Configuration → ADAPTERS Enum → AdapterFactory → Concrete Adapter\n *      ↓             ↓              ↓               ↓\n * User Config  → Type Safety   → Adapter Creation → Database Connection\n * ```\n *\n * **Adapter Types:**\n * - **DRIZZLE**: Type-safe ORM with excellent TypeScript support\n * - **SUPABASE**: Hosted PostgreSQL with real-time capabilities\n * - **SQL**: Raw SQL execution for maximum control\n * - **DATABASE**: Generic fallback adapter\n *\n * @example\n * ```typescript\n * // Adapter selection in configuration\n * const config = {\n *   adapter: ADAPTERS.DRIZZLE,\n *   connectionString: process.env.DATABASE_URL\n * };\n *\n * // Type-safe adapter factory usage\n * const adapter = AdapterFactory.create(ADAPTERS.SUPABASE, supabaseConfig);\n *\n * // Switch statement with exhaustive checking\n * switch (config.adapter) {\n *   case ADAPTERS.DRIZZLE:\n *     // Handle Drizzle-specific logic\n *     break;\n *   case ADAPTERS.SUPABASE:\n *     // Handle Supabase-specific logic\n *     break;\n *   case ADAPTERS.SQL:\n *     // Handle SQL-specific logic\n *     break;\n *   default:\n *     // TypeScript ensures all cases are handled\n *     throw new Error(`Unsupported adapter: ${config.adapter}`);\n * }\n * ```\n *\n */\n/**\n * @enum ADAPTERS\n * @description\n * Enumeration of supported database adapter types.\n *\n * This enum provides type-safe identification of different database integrations\n * and is used throughout the package for configuration, factory methods, and\n * adapter selection. Each adapter type represents a different approach to\n * database connectivity and operations.\n *\n * **Adapter Characteristics:**\n * - **DATABASE**: Generic fallback, minimal functionality\n * - **DRIZZLE**: Full ORM with type safety and query building\n * - **SUPABASE**: Hosted solution with real-time and auth features\n * - **SQL**: Raw SQL for performance-critical applications\n *\n * @example\n * ```typescript\n * // Configuration with adapter selection\n * const configs = {\n *   development: { adapter: ADAPTERS.DRIZZLE },\n *   production: { adapter: ADAPTERS.SUPABASE },\n *   performance: { adapter: ADAPTERS.SQL }\n * };\n *\n * // Type-safe adapter validation\n * function validateAdapter(adapter: ADAPTERS): boolean {\n *   return Object.values(ADAPTERS).includes(adapter);\n * }\n * ```\n */\nexport enum ADAPTERS {\n  /** Generic database adapter (default when no specific integration is set) */\n  DATABASE = 'database',\n\n  /** Drizzle ORM adapter (PostgreSQL, MySQL, SQLite, etc.) */\n  DRIZZLE = 'drizzle',\n\n  /** Supabase adapter (PostgreSQL backend with REST + Realtime APIs) */\n  SUPABASE = 'supabase',\n\n  /** Raw SQL adapter (direct database queries without ORM) */\n  SQL = 'sql',\n}\n"]}
+{"version":3,"sources":["../../src/db/adapter.ts","../../src/db/replicaStrategy.ts"],"names":["ADAPTERS","REPLICA_STRATEGY"],"mappings":";;;AAiFO,IAAK,QAAA,qBAAAA,SAAAA,KAAL;AAEL,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,SAAA,CAAA,GAAU,SAAA;AAGV,EAAAA,UAAA,UAAA,CAAA,GAAW,UAAA;AAGX,EAAAA,UAAA,KAAA,CAAA,GAAM,KAAA;AAXI,EAAA,OAAAA,SAAAA;AAAA,CAAA,EAAA,QAAA,IAAA,EAAA;;;AC9EL,IAAK,gBAAA,qBAAAC,iBAAAA,KAAL;AAEL,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AAEV,EAAAA,kBAAA,SAAA,CAAA,GAAU,SAAA;AARA,EAAA,OAAAA,iBAAAA;AAAA,CAAA,EAAA,gBAAA,IAAA,EAAA","file":"index.js","sourcesContent":["/**\n * @fileoverview Database adapter type definitions\n *\n * Defines the enumeration of supported database adapter types used throughout\n * the database package. This enum provides type-safe identification of different\n * database integrations and is used in configuration, factory methods, and\n * adapter selection logic.\n *\n * **Application Flow Context:**\n * ```\n * Configuration → ADAPTERS Enum → AdapterFactory → Concrete Adapter\n *      ↓             ↓              ↓               ↓\n * User Config  → Type Safety   → Adapter Creation → Database Connection\n * ```\n *\n * **Adapter Types:**\n * - **DRIZZLE**: Type-safe ORM with excellent TypeScript support\n * - **SUPABASE**: Hosted PostgreSQL with real-time capabilities\n * - **SQL**: Raw SQL execution for maximum control\n * - **DATABASE**: Generic fallback adapter\n *\n * @example\n * ```typescript\n * // Adapter selection in configuration\n * const config = {\n *   adapter: ADAPTERS.DRIZZLE,\n *   connectionString: process.env.DATABASE_URL\n * };\n *\n * // Type-safe adapter factory usage\n * const adapter = AdapterFactory.create(ADAPTERS.SUPABASE, supabaseConfig);\n *\n * // Switch statement with exhaustive checking\n * switch (config.adapter) {\n *   case ADAPTERS.DRIZZLE:\n *     // Handle Drizzle-specific logic\n *     break;\n *   case ADAPTERS.SUPABASE:\n *     // Handle Supabase-specific logic\n *     break;\n *   case ADAPTERS.SQL:\n *     // Handle SQL-specific logic\n *     break;\n *   default:\n *     // TypeScript ensures all cases are handled\n *     throw new Error(`Unsupported adapter: ${config.adapter}`);\n * }\n * ```\n *\n */\n/**\n * @enum ADAPTERS\n * @description\n * Enumeration of supported database adapter types.\n *\n * This enum provides type-safe identification of different database integrations\n * and is used throughout the package for configuration, factory methods, and\n * adapter selection. Each adapter type represents a different approach to\n * database connectivity and operations.\n *\n * **Adapter Characteristics:**\n * - **DATABASE**: Generic fallback, minimal functionality\n * - **DRIZZLE**: Full ORM with type safety and query building\n * - **SUPABASE**: Hosted solution with real-time and auth features\n * - **SQL**: Raw SQL for performance-critical applications\n *\n * @example\n * ```typescript\n * // Configuration with adapter selection\n * const configs = {\n *   development: { adapter: ADAPTERS.DRIZZLE },\n *   production: { adapter: ADAPTERS.SUPABASE },\n *   performance: { adapter: ADAPTERS.SQL }\n * };\n *\n * // Type-safe adapter validation\n * function validateAdapter(adapter: ADAPTERS): boolean {\n *   return Object.values(ADAPTERS).includes(adapter);\n * }\n * ```\n */\nexport enum ADAPTERS {\n  /** Generic database adapter (default when no specific integration is set) */\n  DATABASE = 'database',\n\n  /** Drizzle ORM adapter (PostgreSQL, MySQL, SQLite, etc.) */\n  DRIZZLE = 'drizzle',\n\n  /** Supabase adapter (PostgreSQL backend with REST + Realtime APIs) */\n  SUPABASE = 'supabase',\n\n  /** Raw SQL adapter (direct database queries without ORM) */\n  SQL = 'sql',\n}\n","/**\n * Strategy options for replica selection.\n */\nexport enum REPLICA_STRATEGY {\n  /** Always use primary database */\n  PRIMARY = 'primary',\n  /** Use any available replica */\n  REPLICA = 'replica',\n  /** Use geographically closest replica */\n  CLOSEST = 'closest',\n  /** Use fastest responding replica */\n  FASTEST = 'fastest'\n}"]}

package/dist/db/replica.types.d.ts

@@ -0,0 +1,26 @@
+import type { AdapterConfig } from "./features-config.types";
+import type { REPLICA_STRATEGY } from "./replicaStrategy";
+/**
+ * Options for the @UseReplica decorator.
+ */
+export interface UseReplicaOptions {
+    /** Replica selection strategy */
+    strategy?: REPLICA_STRATEGY;
+    /** Specific replica index to use */
+    replicaIndex?: number;
+    /** Whether to fallback to primary if replicas are unavailable */
+    fallbackToPrimary?: boolean;
+}
+/**
+ * Configuration for read replicas
+ */
+export interface ReadReplicaConfig {
+    /** Whether read replicas are enabled */
+    enabled: boolean;
+    /** Replica connection configs */
+    replicas: AdapterConfig[];
+    /** Load balancing strategy */
+    strategy?: 'round-robin' | 'random' | 'least-connections';
+    /** Fallback to primary if all replicas unhealthy */
+    fallbackToPrimary?: boolean;
+}

package/dist/db/replicaStrategy.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Strategy options for replica selection.
+ */
+export declare enum REPLICA_STRATEGY {
+    /** Always use primary database */
+    PRIMARY = "primary",
+    /** Use any available replica */
+    REPLICA = "replica",
+    /** Use geographically closest replica */
+    CLOSEST = "closest",
+    /** Use fastest responding replica */
+    FASTEST = "fastest"
+}

package/dist/db/shard.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Configuration for a shard key.
+ */
+export interface ShardKey {
+    /** Name of the shard key */
+    name: string;
+    /** Type of sharding strategy */
+    type: 'hash' | 'range' | 'consistent_hash';
+    /** Columns that make up the shard key */
+    columns: string[];
+    /** Sharding strategy to use */
+    strategy: 'modulus' | 'hash' | 'range';
+    /** Number of shards */
+    shardCount: number;
+}
+/**
+ * Configuration for a database shard.
+ */
+export interface ShardConfig {
+    /** Unique shard identifier */
+    id: number;
+    /** Database connection string */
+    connectionString: string;
+    /** Whether this is the primary shard */
+    isPrimary: boolean;
+    /** Geographic region of the shard (optional) */
+    region?: string;
+}