@ductape/sdk 0.0.4-v51 → 0.0.4-v52

package/dist/database/adapters/base.adapter.js

@@ -1,31 +1,150 @@
 "use strict";
 /**
- * Base database adapter interface
- * All database-specific adapters must implement this interface
+ * Base Adapter - Abstract interface for database adapters
+ *
+ * All database-specific adapters (PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra)
+ * must extend this base class and implement all abstract methods.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseDatabaseAdapter = void 0;
+exports.DatabaseFeature = exports.BaseAdapter = void 0;
 /**
- * Base database adapter abstract class
- * Provides common functionality and defines required methods
+ * Abstract base class for all database adapters
+ *
+ * Each database type (PostgreSQL, MySQL, MongoDB, DynamoDB, MariaDB, Cassandra)
+ * must implement all abstract methods to provide consistent behavior across
+ * the ORM layer.
  */
-class BaseDatabaseAdapter {
+class BaseAdapter {
+    constructor() {
+        /** Native client instance (database-specific) */
+        this.client = null;
+        /** Connection state */
+        this.connected = false;
+        /** Connection URL */
+        this.connectionUrl = '';
+    }
+    // ==================== CONNECTION METHODS ====================
+    /**
+     * Get the database type this adapter handles
+     */
+    getDatabaseType() {
+        return this.databaseType;
+    }
+    /**
+     * Check if adapter is currently connected
+     */
+    isConnected() {
+        return this.connected;
+    }
+    /**
+     * Get the native client instance
+     */
+    getClient() {
+        return this.client;
+    }
     /**
-     * Execute a callback within a transaction
-     * Automatically commits on success or rolls back on error
+     * Check if the database supports a specific feature
+     * @param feature Feature name
+     * @returns Whether the feature is supported
      */
-    async executeTransaction(connection, callback, options) {
-        const transaction = await this.beginTransaction(connection, options);
-        try {
-            const result = await callback(transaction);
-            await this.commitTransaction(connection, transaction);
-            return result;
-        }
-        catch (error) {
-            await this.rollbackTransaction(connection, transaction);
-            throw error;
-        }
+    supportsFeature(feature) {
+        const supportedFeatures = this.getSupportedFeatures();
+        return supportedFeatures.includes(feature);
     }
 }
-exports.BaseDatabaseAdapter = BaseDatabaseAdapter;
+exports.BaseAdapter = BaseAdapter;
+/**
+ * Database features that may or may not be supported by each adapter
+ */
+var DatabaseFeature;
+(function (DatabaseFeature) {
+    /** Transaction support */
+    DatabaseFeature["TRANSACTIONS"] = "TRANSACTIONS";
+    /** Savepoint support within transactions */
+    DatabaseFeature["SAVEPOINTS"] = "SAVEPOINTS";
+    /** JSONB data type (PostgreSQL) */
+    DatabaseFeature["JSONB"] = "JSONB";
+    /** JSON data type */
+    DatabaseFeature["JSON"] = "JSON";
+    /** Array data type */
+    DatabaseFeature["ARRAYS"] = "ARRAYS";
+    /** UUID data type */
+    DatabaseFeature["UUID"] = "UUID";
+    /** Full-text search */
+    DatabaseFeature["FULLTEXT_SEARCH"] = "FULLTEXT_SEARCH";
+    /** GIN index type */
+    DatabaseFeature["GIN_INDEX"] = "GIN_INDEX";
+    /** GIST index type */
+    DatabaseFeature["GIST_INDEX"] = "GIST_INDEX";
+    /** Hash index type */
+    DatabaseFeature["HASH_INDEX"] = "HASH_INDEX";
+    /** Partial/conditional indexes */
+    DatabaseFeature["PARTIAL_INDEX"] = "PARTIAL_INDEX";
+    /** Covering indexes (INCLUDE clause) */
+    DatabaseFeature["COVERING_INDEX"] = "COVERING_INDEX";
+    /** Concurrent index creation */
+    DatabaseFeature["CONCURRENT_INDEX"] = "CONCURRENT_INDEX";
+    /** Common Table Expressions (WITH clause) */
+    DatabaseFeature["CTE"] = "CTE";
+    /** Window functions */
+    DatabaseFeature["WINDOW_FUNCTIONS"] = "WINDOW_FUNCTIONS";
+    /** RETURNING clause for insert/update/delete */
+    DatabaseFeature["RETURNING"] = "RETURNING";
+    /** UPSERT / ON CONFLICT */
+    DatabaseFeature["UPSERT"] = "UPSERT";
+    /** Foreign keys */
+    DatabaseFeature["FOREIGN_KEYS"] = "FOREIGN_KEYS";
+    /** Check constraints */
+    DatabaseFeature["CHECK_CONSTRAINTS"] = "CHECK_CONSTRAINTS";
+    /** Stored procedures */
+    DatabaseFeature["STORED_PROCEDURES"] = "STORED_PROCEDURES";
+    /** Views */
+    DatabaseFeature["VIEWS"] = "VIEWS";
+    /** Materialized views */
+    DatabaseFeature["MATERIALIZED_VIEWS"] = "MATERIALIZED_VIEWS";
+    /** Triggers */
+    DatabaseFeature["TRIGGERS"] = "TRIGGERS";
+    /** Schema/namespace support */
+    DatabaseFeature["SCHEMAS"] = "SCHEMAS";
+    /** Table inheritance */
+    DatabaseFeature["TABLE_INHERITANCE"] = "TABLE_INHERITANCE";
+    /** Read replicas */
+    DatabaseFeature["READ_REPLICAS"] = "READ_REPLICAS";
+    /** Streaming replication */
+    DatabaseFeature["STREAMING_REPLICATION"] = "STREAMING_REPLICATION";
+    /** Point in time recovery */
+    DatabaseFeature["PITR"] = "PITR";
+    /** LIKE/ILIKE pattern matching */
+    DatabaseFeature["LIKE"] = "LIKE";
+    /** Case-insensitive LIKE */
+    DatabaseFeature["ILIKE"] = "ILIKE";
+    /** Regular expression matching */
+    DatabaseFeature["REGEX"] = "REGEX";
+    /** BETWEEN operator */
+    DatabaseFeature["BETWEEN"] = "BETWEEN";
+    /** Array contains operator */
+    DatabaseFeature["ARRAY_CONTAINS"] = "ARRAY_CONTAINS";
+    /** LIMIT/OFFSET pagination */
+    DatabaseFeature["LIMIT_OFFSET"] = "LIMIT_OFFSET";
+    /** Cursor-based pagination */
+    DatabaseFeature["CURSOR_PAGINATION"] = "CURSOR_PAGINATION";
+    /** Aggregation framework (MongoDB) */
+    DatabaseFeature["AGGREGATION_PIPELINE"] = "AGGREGATION_PIPELINE";
+    /** Secondary indexes */
+    DatabaseFeature["SECONDARY_INDEXES"] = "SECONDARY_INDEXES";
+    /** Global secondary indexes (DynamoDB) */
+    DatabaseFeature["GLOBAL_SECONDARY_INDEXES"] = "GLOBAL_SECONDARY_INDEXES";
+    /** Local secondary indexes (DynamoDB) */
+    DatabaseFeature["LOCAL_SECONDARY_INDEXES"] = "LOCAL_SECONDARY_INDEXES";
+    /** TTL (Time to Live) for records */
+    DatabaseFeature["TTL"] = "TTL";
+    /** Change streams / CDC */
+    DatabaseFeature["CHANGE_STREAMS"] = "CHANGE_STREAMS";
+    /** Batch operations */
+    DatabaseFeature["BATCH_OPERATIONS"] = "BATCH_OPERATIONS";
+    /** Atomic counters */
+    DatabaseFeature["ATOMIC_COUNTERS"] = "ATOMIC_COUNTERS";
+    /** Deferrable transactions (PostgreSQL) */
+    DatabaseFeature["DEFERRABLE_TRANSACTIONS"] = "DEFERRABLE_TRANSACTIONS";
+})(DatabaseFeature || (exports.DatabaseFeature = DatabaseFeature = {}));
 //# sourceMappingURL=base.adapter.js.map

package/dist/database/adapters/base.adapter.js.map

@@ -1 +1 @@
-{"version":3,"file":"base.adapter.js","sourceRoot":"","sources":["../../../src/database/adapters/base.adapter.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AA2DH;;;GAGG;AACH,MAAsB,mBAAmB;IAoEvC;;;OAGG;IACH,KAAK,CAAC,kBAAkB,CACtB,UAAuB,EACvB,QAAmD,EACnD,OAA6B;QAE7B,MAAM,WAAW,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,UAAU,EAAE,OAAO,CAAC,CAAC;QAErE,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,WAAW,CAAC,CAAC;YAC3C,MAAM,IAAI,CAAC,iBAAiB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YACtD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,MAAM,IAAI,CAAC,mBAAmB,CAAC,UAAU,EAAE,WAAW,CAAC,CAAC;YACxD,MAAM,KAAK,CAAC;QACd,CAAC;IACH,CAAC;CAmOF;AA1TD,kDA0TC"}
+{"version":3,"file":"base.adapter.js","sourceRoot":"","sources":["../../../src/database/adapters/base.adapter.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAuDH;;;;;;GAMG;AACH,MAAsB,WAAW;IAAjC;QAIE,iDAAiD;QACvC,WAAM,GAAQ,IAAI,CAAC;QAE7B,uBAAuB;QACb,cAAS,GAAY,KAAK,CAAC;QAErC,qBAAqB;QACX,kBAAa,GAAW,EAAE,CAAC;IAiWvC,CAAC;IA/VC,+DAA+D;IAE/D;;OAEG;IACH,eAAe;QACb,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IAED;;OAEG;IACH,WAAW;QACT,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;OAEG;IACH,SAAS;QACP,OAAO,IAAI,CAAC,MAAM,CAAC;IACrB,CAAC;IA8SD;;;;OAIG;IACH,eAAe,CAAC,OAAwB;QACtC,MAAM,iBAAiB,GAAG,IAAI,CAAC,oBAAoB,EAAE,CAAC;QACtD,OAAO,iBAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC;IAC7C,CAAC;CAoBF;AA5WD,kCA4WC;AAED;;GAEG;AACH,IAAY,eAoIX;AApID,WAAY,eAAe;IACzB,0BAA0B;IAC1B,gDAA6B,CAAA;IAE7B,4CAA4C;IAC5C,4CAAyB,CAAA;IAEzB,mCAAmC;IACnC,kCAAe,CAAA;IAEf,qBAAqB;IACrB,gCAAa,CAAA;IAEb,sBAAsB;IACtB,oCAAiB,CAAA;IAEjB,qBAAqB;IACrB,gCAAa,CAAA;IAEb,uBAAuB;IACvB,sDAAmC,CAAA;IAEnC,qBAAqB;IACrB,0CAAuB,CAAA;IAEvB,sBAAsB;IACtB,4CAAyB,CAAA;IAEzB,sBAAsB;IACtB,4CAAyB,CAAA;IAEzB,kCAAkC;IAClC,kDAA+B,CAAA;IAE/B,wCAAwC;IACxC,oDAAiC,CAAA;IAEjC,gCAAgC;IAChC,wDAAqC,CAAA;IAErC,6CAA6C;IAC7C,8BAAW,CAAA;IAEX,uBAAuB;IACvB,wDAAqC,CAAA;IAErC,gDAAgD;IAChD,0CAAuB,CAAA;IAEvB,2BAA2B;IAC3B,oCAAiB,CAAA;IAEjB,mBAAmB;IACnB,gDAA6B,CAAA;IAE7B,wBAAwB;IACxB,0DAAuC,CAAA;IAEvC,wBAAwB;IACxB,0DAAuC,CAAA;IAEvC,YAAY;IACZ,kCAAe,CAAA;IAEf,yBAAyB;IACzB,4DAAyC,CAAA;IAEzC,eAAe;IACf,wCAAqB,CAAA;IAErB,+BAA+B;IAC/B,sCAAmB,CAAA;IAEnB,wBAAwB;IACxB,0DAAuC,CAAA;IAEvC,oBAAoB;IACpB,kDAA+B,CAAA;IAE/B,4BAA4B;IAC5B,kEAA+C,CAAA;IAE/C,6BAA6B;IAC7B,gCAAa,CAAA;IAEb,kCAAkC;IAClC,gCAAa,CAAA;IAEb,4BAA4B;IAC5B,kCAAe,CAAA;IAEf,kCAAkC;IAClC,kCAAe,CAAA;IAEf,uBAAuB;IACvB,sCAAmB,CAAA;IAEnB,8BAA8B;IAC9B,oDAAiC,CAAA;IAEjC,8BAA8B;IAC9B,gDAA6B,CAAA;IAE7B,8BAA8B;IAC9B,0DAAuC,CAAA;IAEvC,sCAAsC;IACtC,gEAA6C,CAAA;IAE7C,wBAAwB;IACxB,0DAAuC,CAAA;IAEvC,0CAA0C;IAC1C,wEAAqD,CAAA;IAErD,yCAAyC;IACzC,sEAAmD,CAAA;IAEnD,qCAAqC;IACrC,8BAAW,CAAA;IAEX,2BAA2B;IAC3B,oDAAiC,CAAA;IAEjC,uBAAuB;IACvB,wDAAqC,CAAA;IAErC,sBAAsB;IACtB,sDAAmC,CAAA;IAEnC,2CAA2C;IAC3C,sEAAmD,CAAA;AACrD,CAAC,EApIW,eAAe,+BAAf,eAAe,QAoI1B"}

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

@@ -0,0 +1,90 @@
+/**
+ * Cassandra Adapter
+ *
+ * Database adapter for Apache Cassandra using the 'cassandra-driver' library.
+ * Implements all methods from BaseAdapter with Cassandra-specific operations.
+ *
+ * Key Cassandra concepts:
+ * - Keyspace (like a database/schema)
+ * - Column family/Table
+ * - Partition key and clustering columns
+ * - No JOINs - denormalized data model
+ * - No transactions in the traditional sense (uses lightweight transactions)
+ * - Eventual consistency by default
+ */
+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';
+/**
+ * Cassandra database adapter
+ * Provides Cassandra-specific implementations for all database operations
+ */
+export declare class CassandraAdapter extends BaseAdapter {
+    protected readonly databaseType = DatabaseType.CASSANDRA;
+    private cassandraClient;
+    private keyspace;
+    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>;
+    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;
+    /**
+     * Check if value is an update operator object
+     */
+    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 getClusterVersion;
+    private buildWhereClause;
+    private buildColumnDefinition;
+}