@ductape/sdk 0.0.4-v42 → 0.0.4-v43

package/dist/database/index.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * Database module index
+ * Exports the main database service and all types
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertValidColumn = exports.assertValidTableSchema = exports.validateIndexDefinition = exports.validateColumnDefinition = exports.validateTableSchema = exports.assertValidConnection = exports.validateConnection = exports.deepClone = exports.snakeToCamel = exports.camelToSnake = exports.sanitizeTableName = exports.retryOperation = exports.isForeignKeyError = exports.isDuplicateKeyError = exports.isConnectionError = exports.formatDatabaseError = exports.escapeValue = exports.escapeIdentifier = exports.buildMongoQuery = exports.buildWhereClause = exports.mapColumnTypeToNative = exports.generateMigrationTemplate = exports.generateMigrationFileContent = exports.SchemaHelpers = exports.addIndexMigration = exports.addColumnMigration = exports.createTableMigration = exports.rawSql = exports.dropConstraint = exports.addConstraint = exports.dropIndex = exports.addIndex = exports.renameColumn = exports.modifyColumn = exports.dropColumn = exports.addColumn = exports.dropTable = exports.createTable = exports.createMigration = exports.generateMigrationTimestamp = exports.generateMigrationTag = exports.TransactionFactory = exports.Savepoint = exports.Transaction = exports.DynamoDBAdapter = exports.MySQLAdapter = exports.MongoDBAdapter = exports.PostgreSQLAdapter = exports.BaseDatabaseAdapter = exports.DatabaseService = void 0;
+exports.assertValidUpdateData = exports.assertValidInsertData = exports.assertValidQueryOptions = exports.validateUpdateData = exports.validateInsertData = exports.validateQueryOptions = exports.assertValidIndex = void 0;
+// Export main service
+var database_service_1 = require("./database.service");
+Object.defineProperty(exports, "DatabaseService", { enumerable: true, get: function () { return database_service_1.DatabaseService; } });
+// Export all types
+__exportStar(require("./types"), exports);
+// Export adapters (for advanced usage)
+var base_adapter_1 = require("./adapters/base.adapter");
+Object.defineProperty(exports, "BaseDatabaseAdapter", { enumerable: true, get: function () { return base_adapter_1.BaseDatabaseAdapter; } });
+var postgresql_adapter_1 = require("./adapters/postgresql.adapter");
+Object.defineProperty(exports, "PostgreSQLAdapter", { enumerable: true, get: function () { return postgresql_adapter_1.PostgreSQLAdapter; } });
+var mongodb_adapter_1 = require("./adapters/mongodb.adapter");
+Object.defineProperty(exports, "MongoDBAdapter", { enumerable: true, get: function () { return mongodb_adapter_1.MongoDBAdapter; } });
+var mysql_adapter_1 = require("./adapters/mysql.adapter");
+Object.defineProperty(exports, "MySQLAdapter", { enumerable: true, get: function () { return mysql_adapter_1.MySQLAdapter; } });
+var dynamodb_adapter_1 = require("./adapters/dynamodb.adapter");
+Object.defineProperty(exports, "DynamoDBAdapter", { enumerable: true, get: function () { return dynamodb_adapter_1.DynamoDBAdapter; } });
+// Export utilities
+var transaction_1 = require("./utils/transaction");
+Object.defineProperty(exports, "Transaction", { enumerable: true, get: function () { return transaction_1.Transaction; } });
+Object.defineProperty(exports, "Savepoint", { enumerable: true, get: function () { return transaction_1.Savepoint; } });
+Object.defineProperty(exports, "TransactionFactory", { enumerable: true, get: function () { return transaction_1.TransactionFactory; } });
+var migration_utils_1 = require("./utils/migration.utils");
+Object.defineProperty(exports, "generateMigrationTag", { enumerable: true, get: function () { return migration_utils_1.generateMigrationTag; } });
+Object.defineProperty(exports, "generateMigrationTimestamp", { enumerable: true, get: function () { return migration_utils_1.generateMigrationTimestamp; } });
+Object.defineProperty(exports, "createMigration", { enumerable: true, get: function () { return migration_utils_1.createMigration; } });
+Object.defineProperty(exports, "createTable", { enumerable: true, get: function () { return migration_utils_1.createTable; } });
+Object.defineProperty(exports, "dropTable", { enumerable: true, get: function () { return migration_utils_1.dropTable; } });
+Object.defineProperty(exports, "addColumn", { enumerable: true, get: function () { return migration_utils_1.addColumn; } });
+Object.defineProperty(exports, "dropColumn", { enumerable: true, get: function () { return migration_utils_1.dropColumn; } });
+Object.defineProperty(exports, "modifyColumn", { enumerable: true, get: function () { return migration_utils_1.modifyColumn; } });
+Object.defineProperty(exports, "renameColumn", { enumerable: true, get: function () { return migration_utils_1.renameColumn; } });
+Object.defineProperty(exports, "addIndex", { enumerable: true, get: function () { return migration_utils_1.addIndex; } });
+Object.defineProperty(exports, "dropIndex", { enumerable: true, get: function () { return migration_utils_1.dropIndex; } });
+Object.defineProperty(exports, "addConstraint", { enumerable: true, get: function () { return migration_utils_1.addConstraint; } });
+Object.defineProperty(exports, "dropConstraint", { enumerable: true, get: function () { return migration_utils_1.dropConstraint; } });
+Object.defineProperty(exports, "rawSql", { enumerable: true, get: function () { return migration_utils_1.rawSql; } });
+Object.defineProperty(exports, "createTableMigration", { enumerable: true, get: function () { return migration_utils_1.createTableMigration; } });
+Object.defineProperty(exports, "addColumnMigration", { enumerable: true, get: function () { return migration_utils_1.addColumnMigration; } });
+Object.defineProperty(exports, "addIndexMigration", { enumerable: true, get: function () { return migration_utils_1.addIndexMigration; } });
+Object.defineProperty(exports, "SchemaHelpers", { enumerable: true, get: function () { return migration_utils_1.SchemaHelpers; } });
+Object.defineProperty(exports, "generateMigrationFileContent", { enumerable: true, get: function () { return migration_utils_1.generateMigrationFileContent; } });
+Object.defineProperty(exports, "generateMigrationTemplate", { enumerable: true, get: function () { return migration_utils_1.generateMigrationTemplate; } });
+var helpers_1 = require("./utils/helpers");
+Object.defineProperty(exports, "mapColumnTypeToNative", { enumerable: true, get: function () { return helpers_1.mapColumnTypeToNative; } });
+Object.defineProperty(exports, "buildWhereClause", { enumerable: true, get: function () { return helpers_1.buildWhereClause; } });
+Object.defineProperty(exports, "buildMongoQuery", { enumerable: true, get: function () { return helpers_1.buildMongoQuery; } });
+Object.defineProperty(exports, "escapeIdentifier", { enumerable: true, get: function () { return helpers_1.escapeIdentifier; } });
+Object.defineProperty(exports, "escapeValue", { enumerable: true, get: function () { return helpers_1.escapeValue; } });
+Object.defineProperty(exports, "formatDatabaseError", { enumerable: true, get: function () { return helpers_1.formatDatabaseError; } });
+Object.defineProperty(exports, "isConnectionError", { enumerable: true, get: function () { return helpers_1.isConnectionError; } });
+Object.defineProperty(exports, "isDuplicateKeyError", { enumerable: true, get: function () { return helpers_1.isDuplicateKeyError; } });
+Object.defineProperty(exports, "isForeignKeyError", { enumerable: true, get: function () { return helpers_1.isForeignKeyError; } });
+Object.defineProperty(exports, "retryOperation", { enumerable: true, get: function () { return helpers_1.retryOperation; } });
+Object.defineProperty(exports, "sanitizeTableName", { enumerable: true, get: function () { return helpers_1.sanitizeTableName; } });
+Object.defineProperty(exports, "camelToSnake", { enumerable: true, get: function () { return helpers_1.camelToSnake; } });
+Object.defineProperty(exports, "snakeToCamel", { enumerable: true, get: function () { return helpers_1.snakeToCamel; } });
+Object.defineProperty(exports, "deepClone", { enumerable: true, get: function () { return helpers_1.deepClone; } });
+// Export validators
+var connection_validator_1 = require("./validators/connection.validator");
+Object.defineProperty(exports, "validateConnection", { enumerable: true, get: function () { return connection_validator_1.validateConnection; } });
+Object.defineProperty(exports, "assertValidConnection", { enumerable: true, get: function () { return connection_validator_1.assertValidConnection; } });
+var schema_validator_1 = require("./validators/schema.validator");
+Object.defineProperty(exports, "validateTableSchema", { enumerable: true, get: function () { return schema_validator_1.validateTableSchema; } });
+Object.defineProperty(exports, "validateColumnDefinition", { enumerable: true, get: function () { return schema_validator_1.validateColumnDefinition; } });
+Object.defineProperty(exports, "validateIndexDefinition", { enumerable: true, get: function () { return schema_validator_1.validateIndexDefinition; } });
+Object.defineProperty(exports, "assertValidTableSchema", { enumerable: true, get: function () { return schema_validator_1.assertValidTableSchema; } });
+Object.defineProperty(exports, "assertValidColumn", { enumerable: true, get: function () { return schema_validator_1.assertValidColumn; } });
+Object.defineProperty(exports, "assertValidIndex", { enumerable: true, get: function () { return schema_validator_1.assertValidIndex; } });
+var query_validator_1 = require("./validators/query.validator");
+Object.defineProperty(exports, "validateQueryOptions", { enumerable: true, get: function () { return query_validator_1.validateQueryOptions; } });
+Object.defineProperty(exports, "validateInsertData", { enumerable: true, get: function () { return query_validator_1.validateInsertData; } });
+Object.defineProperty(exports, "validateUpdateData", { enumerable: true, get: function () { return query_validator_1.validateUpdateData; } });
+Object.defineProperty(exports, "assertValidQueryOptions", { enumerable: true, get: function () { return query_validator_1.assertValidQueryOptions; } });
+Object.defineProperty(exports, "assertValidInsertData", { enumerable: true, get: function () { return query_validator_1.assertValidInsertData; } });
+Object.defineProperty(exports, "assertValidUpdateData", { enumerable: true, get: function () { return query_validator_1.assertValidUpdateData; } });
+//# sourceMappingURL=index.js.map

package/dist/database/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/database/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;;;AAEH,sBAAsB;AACtB,uDAAqD;AAA5C,mHAAA,eAAe,OAAA;AAExB,mBAAmB;AACnB,0CAAwB;AAExB,uCAAuC;AACvC,wDAA8D;AAArD,mHAAA,mBAAmB,OAAA;AAC5B,oEAAkE;AAAzD,uHAAA,iBAAiB,OAAA;AAC1B,8DAA4D;AAAnD,iHAAA,cAAc,OAAA;AACvB,0DAAwD;AAA/C,6GAAA,YAAY,OAAA;AACrB,gEAA8D;AAArD,mHAAA,eAAe,OAAA;AAExB,mBAAmB;AACnB,mDAAiF;AAAxE,0GAAA,WAAW,OAAA;AAAE,wGAAA,SAAS,OAAA;AAAE,iHAAA,kBAAkB,OAAA;AACnD,2DAqBiC;AApB/B,uHAAA,oBAAoB,OAAA;AACpB,6HAAA,0BAA0B,OAAA;AAC1B,kHAAA,eAAe,OAAA;AACf,8GAAA,WAAW,OAAA;AACX,4GAAA,SAAS,OAAA;AACT,4GAAA,SAAS,OAAA;AACT,6GAAA,UAAU,OAAA;AACV,+GAAA,YAAY,OAAA;AACZ,+GAAA,YAAY,OAAA;AACZ,2GAAA,QAAQ,OAAA;AACR,4GAAA,SAAS,OAAA;AACT,gHAAA,aAAa,OAAA;AACb,iHAAA,cAAc,OAAA;AACd,yGAAA,MAAM,OAAA;AACN,uHAAA,oBAAoB,OAAA;AACpB,qHAAA,kBAAkB,OAAA;AAClB,oHAAA,iBAAiB,OAAA;AACjB,gHAAA,aAAa,OAAA;AACb,+HAAA,4BAA4B,OAAA;AAC5B,4HAAA,yBAAyB,OAAA;AAE3B,2CAeyB;AAdvB,gHAAA,qBAAqB,OAAA;AACrB,2GAAA,gBAAgB,OAAA;AAChB,0GAAA,eAAe,OAAA;AACf,2GAAA,gBAAgB,OAAA;AAChB,sGAAA,WAAW,OAAA;AACX,8GAAA,mBAAmB,OAAA;AACnB,4GAAA,iBAAiB,OAAA;AACjB,8GAAA,mBAAmB,OAAA;AACnB,4GAAA,iBAAiB,OAAA;AACjB,yGAAA,cAAc,OAAA;AACd,4GAAA,iBAAiB,OAAA;AACjB,uGAAA,YAAY,OAAA;AACZ,uGAAA,YAAY,OAAA;AACZ,oGAAA,SAAS,OAAA;AAGX,oBAAoB;AACpB,0EAA8F;AAArF,0HAAA,kBAAkB,OAAA;AAAE,6HAAA,qBAAqB,OAAA;AAElD,kEAOuC;AANrC,uHAAA,mBAAmB,OAAA;AACnB,4HAAA,wBAAwB,OAAA;AACxB,2HAAA,uBAAuB,OAAA;AACvB,0HAAA,sBAAsB,OAAA;AACtB,qHAAA,iBAAiB,OAAA;AACjB,oHAAA,gBAAgB,OAAA;AAElB,gEAOsC;AANpC,uHAAA,oBAAoB,OAAA;AACpB,qHAAA,kBAAkB,OAAA;AAClB,qHAAA,kBAAkB,OAAA;AAClB,0HAAA,uBAAuB,OAAA;AACvB,wHAAA,qBAAqB,OAAA;AACrB,wHAAA,qBAAqB,OAAA"}

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

@@ -0,0 +1,202 @@
+/**
+ * Aggregation type definitions for database operations
+ */
+import { WhereClause, IOrderBy } from './query.types';
+/**
+ * Aggregation function types
+ */
+export declare enum AggregationFunction {
+    COUNT = "count",
+    SUM = "sum",
+    AVG = "avg",
+    MIN = "min",
+    MAX = "max",
+    GROUP_CONCAT = "group_concat",// MySQL
+    STRING_AGG = "string_agg",// PostgreSQL
+    ARRAY_AGG = "array_agg"
+}
+/**
+ * Single aggregation operation
+ */
+export interface IAggregationOperation {
+    /** Aggregation function */
+    function: AggregationFunction;
+    /** Column to aggregate */
+    column: string;
+    /** Alias for the result */
+    alias?: string;
+    /** Distinct values only */
+    distinct?: boolean;
+}
+/**
+ * Count options
+ */
+export interface ICountOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Where clause */
+    where?: WhereClause;
+    /** Column to count (default: '*') */
+    column?: string;
+    /** Count distinct values only */
+    distinct?: boolean;
+}
+/**
+ * Sum options
+ */
+export interface ISumOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Column to sum */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Average options
+ */
+export interface IAvgOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Column to average */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Min options
+ */
+export interface IMinOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Column to find minimum */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Max options
+ */
+export interface IMaxOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Column to find maximum */
+    column: string;
+    /** Where clause */
+    where?: WhereClause;
+}
+/**
+ * Group by options
+ */
+export interface IGroupByOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Columns to group by */
+    groupBy: string[];
+    /** Aggregation operations */
+    aggregate?: Record<string, IAggregationOperation>;
+    /** Where clause (applied before grouping) */
+    where?: WhereClause;
+    /** Having clause (applied after grouping) */
+    having?: WhereClause;
+    /** Order by */
+    orderBy?: IOrderBy | IOrderBy[];
+    /** Limit results */
+    limit?: number;
+    /** Offset */
+    offset?: number;
+}
+/**
+ * Aggregate options (multiple aggregations)
+ */
+export interface IAggregateOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Aggregation operations */
+    operations: Record<string, IAggregationOperation>;
+    /** Where clause */
+    where?: WhereClause;
+    /** Group by columns (optional) */
+    groupBy?: string[];
+    /** Having clause */
+    having?: WhereClause;
+}
+/**
+ * Aggregation result for a single operation
+ */
+export interface IAggregationResult {
+    /** Result value */
+    value: number | string | null;
+    /** Column that was aggregated */
+    column?: string;
+    /** Function used */
+    function: AggregationFunction;
+}
+/**
+ * Group by result
+ */
+export interface IGroupByResult {
+    /** Grouped columns and their values */
+    groupedBy: Record<string, any>;
+    /** Aggregated values */
+    aggregates: Record<string, number | string | null>;
+}
+/**
+ * Statistics result (multiple aggregations)
+ */
+export interface IStatisticsResult {
+    /** Count */
+    count?: number;
+    /** Sum */
+    sum?: number;
+    /** Average */
+    avg?: number;
+    /** Minimum */
+    min?: number | string;
+    /** Maximum */
+    max?: number | string;
+    /** Additional custom aggregations */
+    [key: string]: any;
+}

package/dist/database/types/aggregation.types.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * Aggregation type definitions for database operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AggregationFunction = void 0;
+/**
+ * Aggregation function types
+ */
+var AggregationFunction;
+(function (AggregationFunction) {
+    AggregationFunction["COUNT"] = "count";
+    AggregationFunction["SUM"] = "sum";
+    AggregationFunction["AVG"] = "avg";
+    AggregationFunction["MIN"] = "min";
+    AggregationFunction["MAX"] = "max";
+    AggregationFunction["GROUP_CONCAT"] = "group_concat";
+    AggregationFunction["STRING_AGG"] = "string_agg";
+    AggregationFunction["ARRAY_AGG"] = "array_agg";
+})(AggregationFunction || (exports.AggregationFunction = AggregationFunction = {}));
+//# sourceMappingURL=aggregation.types.js.map

package/dist/database/types/aggregation.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"aggregation.types.js","sourceRoot":"","sources":["../../../src/database/types/aggregation.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAIH;;GAEG;AACH,IAAY,mBASX;AATD,WAAY,mBAAmB;IAC7B,sCAAe,CAAA;IACf,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,kCAAW,CAAA;IACX,oDAA6B,CAAA;IAC7B,gDAAyB,CAAA;IACzB,8CAAuB,CAAA;AACzB,CAAC,EATW,mBAAmB,mCAAnB,mBAAmB,QAS9B"}

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

@@ -0,0 +1,132 @@
+/**
+ * Connection configuration types for different database systems
+ */
+import { DatabaseType } from './database.types';
+/**
+ * Base connection configuration
+ */
+export interface IBaseConnectionConfig {
+    /** Database type */
+    type: DatabaseType;
+    /** Environment slug */
+    env: string;
+    /** Optional connection tag */
+    connectionTag?: string;
+}
+/**
+ * Product-based connection configuration
+ * Connects using a configured database in a product
+ */
+export interface IProductConnectionConfig {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product: string;
+    /** Database tag within the product */
+    database: string;
+}
+/**
+ * PostgreSQL connection configuration
+ */
+export interface IPostgreSQLConfig extends IBaseConnectionConfig {
+    type: DatabaseType.POSTGRESQL;
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl?: boolean | {
+        [key: string]: any;
+    };
+    poolSize?: number;
+    connectionTimeout?: number;
+}
+/**
+ * MySQL connection configuration
+ */
+export interface IMySQLConfig extends IBaseConnectionConfig {
+    type: DatabaseType.MYSQL;
+    host: string;
+    port?: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl?: boolean | {
+        [key: string]: any;
+    };
+    poolSize?: number;
+    connectionTimeout?: number;
+    charset?: string;
+}
+/**
+ * MongoDB connection configuration
+ */
+export interface IMongoDBConfig extends IBaseConnectionConfig {
+    type: DatabaseType.MONGODB;
+    uri: string;
+    database: string;
+    options?: {
+        useNewUrlParser?: boolean;
+        useUnifiedTopology?: boolean;
+        poolSize?: number;
+        serverSelectionTimeoutMS?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * DynamoDB connection configuration
+ */
+export interface IDynamoDBConfig extends IBaseConnectionConfig {
+    type: DatabaseType.DYNAMODB;
+    region: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    endpoint?: string;
+    options?: {
+        maxRetries?: number;
+        httpOptions?: {
+            timeout?: number;
+        };
+        [key: string]: any;
+    };
+}
+/**
+ * SQLite connection configuration
+ */
+export interface ISQLiteConfig extends IBaseConnectionConfig {
+    type: DatabaseType.SQLITE;
+    filename: string;
+    mode?: number;
+    options?: {
+        readonly?: boolean;
+        fileMustExist?: boolean;
+        timeout?: number;
+        [key: string]: any;
+    };
+}
+/**
+ * Union type for all connection configurations
+ */
+export type DatabaseConnectionConfig = IPostgreSQLConfig | IMySQLConfig | IMongoDBConfig | IDynamoDBConfig | ISQLiteConfig | IProductConnectionConfig;
+/**
+ * Connection pool configuration
+ */
+export interface IConnectionPoolConfig {
+    min?: number;
+    max?: number;
+    idleTimeoutMillis?: number;
+    connectionTimeoutMillis?: number;
+}
+/**
+ * Connection options
+ */
+export interface IConnectionOptions {
+    /** Auto-retry connection on failure */
+    autoRetry?: boolean;
+    /** Max retry attempts */
+    maxRetries?: number;
+    /** Retry delay in milliseconds */
+    retryDelay?: number;
+    /** Connection pool configuration */
+    pool?: IConnectionPoolConfig;
+}

package/dist/database/types/connection.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Connection configuration types for different database systems
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=connection.types.js.map

package/dist/database/types/connection.types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connection.types.js","sourceRoot":"","sources":["../../../src/database/types/connection.types.ts"],"names":[],"mappings":";AAAA;;GAEG"}

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

@@ -0,0 +1,173 @@
+/**
+ * Core database type definitions for the Ductape Database ORM
+ * Provides unified interface for SQL and NoSQL databases
+ */
+/**
+ * Supported database types
+ */
+export declare enum DatabaseType {
+    POSTGRESQL = "postgresql",
+    MYSQL = "mysql",
+    MONGODB = "mongodb",
+    DYNAMODB = "dynamodb",
+    SQLITE = "sqlite"
+}
+/**
+ * Database connection status
+ */
+export declare enum ConnectionStatus {
+    DISCONNECTED = "disconnected",
+    CONNECTING = "connecting",
+    CONNECTED = "connected",
+    ERROR = "error"
+}
+/**
+ * Base database configuration
+ */
+export interface IDatabaseConfig {
+    /** Database type */
+    type: DatabaseType;
+    /** Environment slug */
+    env: string;
+    /** Optional connection tag for reusing existing connections */
+    connectionTag?: string;
+    /** Optional database name */
+    database?: string;
+    /** Custom connection options */
+    options?: Record<string, any>;
+}
+/**
+ * Database connection interface
+ */
+export interface IConnection {
+    /** Unique connection ID */
+    id: string;
+    /** Database type */
+    type: DatabaseType;
+    /** Connection status */
+    status: ConnectionStatus;
+    /** Connect to database */
+    connect(): Promise<void>;
+    /** Disconnect from database */
+    disconnect(): Promise<void>;
+    /** Check if connected */
+    isConnected(): boolean;
+    /** Get native client */
+    getClient<T = any>(): T;
+}
+/**
+ * Base database adapter interface
+ * All database-specific adapters must implement this interface
+ */
+export interface IDatabaseAdapter {
+    /** Database type this adapter handles */
+    readonly type: DatabaseType;
+    /** Create a connection */
+    createConnection(config: IDatabaseConfig): Promise<IConnection>;
+    /** Close a connection */
+    closeConnection(connection: IConnection): Promise<void>;
+    /** Execute a query */
+    executeQuery(connection: IConnection, query: string, params?: any[]): Promise<any>;
+    /** Begin transaction */
+    beginTransaction(connection: IConnection): Promise<any>;
+    /** Commit transaction */
+    commitTransaction(connection: IConnection, transaction: any): Promise<void>;
+    /** Rollback transaction */
+    rollbackTransaction(connection: IConnection, transaction: any): Promise<void>;
+}
+/**
+ * Database error types
+ */
+export declare enum DatabaseErrorType {
+    CONNECTION_ERROR = "connection_error",
+    QUERY_ERROR = "query_error",
+    VALIDATION_ERROR = "validation_error",
+    MIGRATION_ERROR = "migration_error",
+    SCHEMA_ERROR = "schema_error",
+    INDEX_ERROR = "index_error"
+}
+/**
+ * Database error class
+ */
+export declare class DatabaseError extends Error {
+    type: DatabaseErrorType;
+    originalError?: Error;
+    constructor(type: DatabaseErrorType, message: string, originalError?: Error);
+}
+/**
+ * Transaction isolation levels
+ */
+export declare enum TransactionIsolationLevel {
+    READ_UNCOMMITTED = "READ_UNCOMMITTED",
+    READ_COMMITTED = "READ_COMMITTED",
+    REPEATABLE_READ = "REPEATABLE_READ",
+    SERIALIZABLE = "SERIALIZABLE"
+}
+/**
+ * Transaction status
+ */
+export declare enum TransactionStatus {
+    ACTIVE = "active",
+    COMMITTED = "committed",
+    ROLLED_BACK = "rolled_back",
+    FAILED = "failed"
+}
+/**
+ * Transaction interface
+ */
+export interface ITransaction {
+    /** Unique transaction ID */
+    id: string;
+    /** Connection this transaction belongs to */
+    connection: IConnection;
+    /** Transaction status */
+    status: TransactionStatus;
+    /** Isolation level */
+    isolationLevel?: TransactionIsolationLevel;
+    /** Parent transaction (for nested transactions) */
+    parent?: ITransaction;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Native transaction object */
+    native: any;
+    /** Commit the transaction */
+    commit(): Promise<void>;
+    /** Rollback the transaction */
+    rollback(): Promise<void>;
+    /** Create a savepoint (for nested transactions) */
+    savepoint(name: string): Promise<ISavepoint>;
+    /** Check if transaction is active */
+    isActive(): boolean;
+}
+/**
+ * Savepoint interface
+ */
+export interface ISavepoint {
+    /** Savepoint name */
+    name: string;
+    /** Transaction this savepoint belongs to */
+    transaction: ITransaction;
+    /** Created timestamp */
+    createdAt: Date;
+    /** Rollback to this savepoint */
+    rollback(): Promise<void>;
+    /** Release this savepoint */
+    release(): Promise<void>;
+}
+/**
+ * Transaction options
+ */
+export interface ITransactionOptions {
+    /** Isolation level */
+    isolationLevel?: TransactionIsolationLevel;
+    /** Read only transaction */
+    readOnly?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+    /** Deferrable (PostgreSQL) */
+    deferrable?: boolean;
+}
+/**
+ * Transaction callback function
+ */
+export type TransactionCallback<T> = (transaction: ITransaction) => Promise<T>;