@ductape/sdk 0.0.4-v51 → 0.0.4-v53

package/dist/database/adapters/mongodb.adapter.d.ts

@@ -1,71 +1,119 @@
 /**
- * MongoDB Database Adapter
- * Implements database operations for MongoDB
+ * MongoDB Adapter
+ *
+ * Database adapter for MongoDB databases using the 'mongodb' driver.
+ * Implements all methods from BaseAdapter with MongoDB-specific operations.
+ *
+ * Note: MongoDB uses collections instead of tables, and documents instead of rows.
+ * The adapter translates SQL-like operations to MongoDB operations.
  */
-import { BaseDatabaseAdapter } from './base.adapter';
-import { DatabaseType, IConnection, IDatabaseConfig, ITransaction, ISavepoint, ITransactionOptions } from '../types/database.types';
-import { IQueryOptions, IInsertOptions, IUpdateOptions, IDeleteOptions, IUpsertOptions, IRawQueryOptions } from '../types/query.types';
-import { ICountOptions, ISumOptions, IAvgOptions, IMinOptions, IMaxOptions, IGroupByOptions, IAggregateOptions, IGroupByResult } from '../types/aggregation.types';
-import { ITableSchema, IColumnAlteration, ICreateTableOptions, IAlterTableOptions } from '../types/schema.types';
-import { ICreateIndexOptions, IDropIndexOptions, IListIndexesOptions, IIndexInfo, IIndexStatistics } from '../types/index.types';
-import { IMigrationDefinition, IMigrationExecutionOptions, IMigrationHistory, IMigrationResult } from '../types/migration.types';
-import { IQueryResult, IInsertResult, IUpdateResult, IDeleteResult, IUpsertResult, ISchemaOperationResult, IIndexOperationResult, IRawQueryResult, IConnectionTestResult } from '../types/result.types';
+import { BaseAdapter, DatabaseFeature } from './base.adapter';
+import { DatabaseType, IsolationLevel } from '../types/enums';
+import { IAdapterConnectionOptions, IAdapterConnectionResult } from '../types/connection.interface';
+import { IQueryResult, IRawQueryOptions, IRawQueryResult, IBuiltQuery } from '../types/query.interface';
+import { IInsertOptions, IInsertResult, IUpdateOptions, IUpdateResult, IDeleteOptions, IDeleteResult, IUpsertOptions, IUpsertResult } from '../types/write.interface';
+import { ITransactionContext, ISavepoint } from '../types/transaction.interface';
+import { ICountOptions, ISumOptions, IAvgOptions, IMinMaxOptions, IAggregateResult, IGroupByResult, IBuiltAggregation } from '../types/aggregation.interface';
+import { ITableDefinition, IAlterTableOperation, ITableSchema, IIndexDefinition, IIndexInfo, IIndexStatistics, ICreateTableOptions } from '../types/schema.interface';
 /**
- * MongoDB Adapter
+ * MongoDB database adapter
+ * Provides MongoDB-specific implementations for all database operations
  */
-export declare class MongoDBAdapter extends BaseDatabaseAdapter {
-    readonly type = DatabaseType.MONGODB;
-    private connectionPool;
-    connect(config: IDatabaseConfig): Promise<IConnection>;
-    disconnect(connection: IConnection): Promise<void>;
-    testConnection(connection: IConnection): Promise<IConnectionTestResult>;
-    beginTransaction(connection: IConnection, options?: ITransactionOptions): Promise<ITransaction>;
-    commitTransaction(connection: IConnection, transaction: ITransaction): Promise<void>;
-    rollbackTransaction(connection: IConnection, transaction: ITransaction): Promise<void>;
-    createSavepoint(_connection: IConnection, _transaction: ITransaction, _savepointName: string): Promise<ISavepoint>;
-    rollbackToSavepoint(_connection: IConnection, _transaction: ITransaction, _savepoint: ISavepoint): Promise<void>;
-    releaseSavepoint(_connection: IConnection, _transaction: ITransaction, _savepoint: ISavepoint): Promise<void>;
-    query<T = any>(connection: IConnection, options: IQueryOptions): Promise<IQueryResult<T>>;
-    insert<T = any>(connection: IConnection, options: IInsertOptions): Promise<IInsertResult<T>>;
-    update<T = any>(connection: IConnection, options: IUpdateOptions): Promise<IUpdateResult<T>>;
-    delete<T = any>(connection: IConnection, options: IDeleteOptions): Promise<IDeleteResult<T>>;
-    upsert<T = any>(connection: IConnection, options: IUpsertOptions): Promise<IUpsertResult<T>>;
-    executeRaw<T = any>(connection: IConnection, options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
-    count(connection: IConnection, options: ICountOptions): Promise<number>;
-    sum(connection: IConnection, options: ISumOptions): Promise<number>;
-    avg(connection: IConnection, options: IAvgOptions): Promise<number>;
-    min(connection: IConnection, options: IMinOptions): Promise<number | string>;
-    max(connection: IConnection, options: IMaxOptions): Promise<number | string>;
-    groupBy(connection: IConnection, options: IGroupByOptions): Promise<IGroupByResult[]>;
-    aggregate(connection: IConnection, options: IAggregateOptions): Promise<Record<string, any>>;
-    createTable(connection: IConnection, schema: ITableSchema, options?: ICreateTableOptions): Promise<ISchemaOperationResult>;
-    dropTable(connection: IConnection, tableName: string): Promise<ISchemaOperationResult>;
-    alterTable(connection: IConnection, tableName: string, alterations: IColumnAlteration[], options?: IAlterTableOptions): Promise<ISchemaOperationResult>;
-    getTableSchema(connection: IConnection, tableName: string): Promise<ITableSchema>;
-    listTables(connection: IConnection): Promise<string[]>;
-    tableExists(connection: IConnection, tableName: string): Promise<boolean>;
-    createIndex(connection: IConnection, options: ICreateIndexOptions): Promise<IIndexOperationResult>;
-    dropIndex(connection: IConnection, options: IDropIndexOptions): Promise<IIndexOperationResult>;
-    listIndexes(connection: IConnection, options: IListIndexesOptions): Promise<IIndexInfo[]>;
-    getIndexStatistics(connection: IConnection, tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
-    runMigration(connection: IConnection, migration: IMigrationDefinition, options: IMigrationExecutionOptions): Promise<IMigrationResult>;
-    rollbackMigration(connection: IConnection, migration: IMigrationDefinition, options: IMigrationExecutionOptions): Promise<IMigrationResult>;
-    getMigrationHistory(connection: IConnection, options: IMigrationExecutionOptions): Promise<IMigrationHistory[]>;
+export declare class MongoDBAdapter extends BaseAdapter {
+    protected readonly databaseType = DatabaseType.MONGODB;
+    private mongoClient;
+    private db;
+    private databaseName;
+    connect(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
+    testConnection(options: IAdapterConnectionOptions): Promise<IAdapterConnectionResult>;
+    disconnect(): Promise<void>;
+    query<T = any>(query: IBuiltQuery): Promise<IQueryResult<T>>;
+    raw<T = any>(options: IRawQueryOptions): Promise<IRawQueryResult<T>>;
+    insert<T = any>(options: IInsertOptions): Promise<IInsertResult<T>>;
+    update<T = any>(options: IUpdateOptions): Promise<IUpdateResult<T>>;
+    delete(options: IDeleteOptions): Promise<IDeleteResult>;
+    upsert<T = any>(options: IUpsertOptions): Promise<IUpsertResult<T>>;
+    count(options: ICountOptions): Promise<number>;
+    sum(options: ISumOptions): Promise<number>;
+    avg(options: IAvgOptions): Promise<number>;
+    min(options: IMinMaxOptions): Promise<any>;
+    max(options: IMinMaxOptions): Promise<any>;
+    aggregate(builtAggregation: IBuiltAggregation): Promise<IAggregateResult>;
+    groupBy<T = any>(builtGroupBy: IBuiltAggregation): Promise<IGroupByResult<T>[]>;
+    beginTransaction(isolationLevel?: IsolationLevel, readOnly?: boolean, timeout?: number): Promise<ITransactionContext>;
+    commitTransaction(context: ITransactionContext): Promise<void>;
+    rollbackTransaction(context: ITransactionContext): Promise<void>;
+    createSavepoint(context: ITransactionContext, name: string): Promise<ISavepoint>;
+    releaseSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
+    rollbackToSavepoint(context: ITransactionContext, savepoint: ISavepoint): Promise<void>;
+    supportsSavepoints(): boolean;
+    createTable(definition: ITableDefinition, options?: ICreateTableOptions): Promise<void>;
     /**
-     * Build MongoDB filter from where clause
-     * Supports both simplified syntax (GT, LT, AND, OR, etc.) and legacy $ prefix operators
+     * Register an auto-increment field in the counters collection.
+     * This creates/updates the counter document for the given collection and field.
      */
-    private buildMongoFilter;
+    private registerAutoIncrementField;
     /**
-     * Escape identifier (collection/field name)
+     * Get the next auto-increment value atomically.
+     * Uses findOneAndUpdate with $inc to ensure atomic increment even under high concurrency.
      */
-    escapeIdentifier(identifier: string): string;
+    private getNextAutoIncrementValue;
+    /**
+     * Get all auto-increment fields for a collection from the counters collection.
+     */
+    private getAutoIncrementFields;
+    /**
+     * Store schema metadata for a collection (including default values).
+     * MongoDB doesn't have native schema enforcement, so we store this for application-level use.
+     */
+    private storeSchemaMetadata;
+    /**
+     * Get schema metadata for a collection to apply defaults during insert.
+     */
+    private getSchemaMetadata;
     /**
-     * Escape value
+     * Resolve a default value to its actual value.
+     * Handles special values like 'now', 'NOW()', true, false, etc.
      */
+    private resolveDefaultValue;
+    /**
+     * Generate a UUID v4.
+     */
+    private generateUUID;
+    alterTable(tableName: string, operations: IAlterTableOperation[]): Promise<void>;
+    dropTable(tableName: string, ifExists?: boolean, cascade?: boolean): Promise<void>;
+    listTables(): Promise<string[]>;
+    tableExists(tableName: string): Promise<boolean>;
+    getTableSchema(tableName: string): Promise<ITableSchema>;
+    createIndex(index: IIndexDefinition, ifNotExists?: boolean, concurrent?: boolean): Promise<void>;
+    dropIndex(tableName: string, indexName: string, ifExists?: boolean, concurrent?: boolean, cascade?: boolean): Promise<void>;
+    listIndexes(tableName: string, includeSystem?: boolean): Promise<IIndexInfo[]>;
+    getIndexStatistics(tableName: string, indexName?: string): Promise<IIndexStatistics[]>;
+    escapeIdentifier(identifier: string): string;
     escapeValue(value: any): string;
     /**
-     * Get database version
+     * Check if value is an update operator object
      */
-    getDatabaseVersion(connection: IConnection): Promise<string>;
+    private isUpdateOperator;
+    getParameterPlaceholder(index: number): string;
+    getColumnTypeString(columnType: string, options?: {
+        minLength?: number;
+        maxLength?: number;
+        precision?: number;
+        scale?: number;
+        enumValues?: string[];
+        arrayType?: string;
+    }): string;
+    getSupportedFeatures(): DatabaseFeature[];
+    parseError(error: any): {
+        type: string;
+        message: string;
+        code?: string;
+        details?: Record<string, any>;
+    };
+    private ensureConnected;
+    private buildMongoFilter;
+    private extractFieldTypes;
+    private getJsType;
+    private formatBytes;
 }