@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,220 @@
+/**
+ * Result type definitions for database operations
+ */
+/**
+ * Query result
+ */
+export interface IQueryResult<T = any> {
+    /** Result rows/documents */
+    data: T[];
+    /** Total count (if available) */
+    count?: number;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Database type that executed the query */
+    databaseType?: string;
+}
+/**
+ * Insert result
+ */
+export interface IInsertResult<T = any> {
+    /** Number of rows inserted */
+    insertedCount: number;
+    /** Inserted row IDs */
+    insertedIds?: (string | number)[];
+    /** Inserted rows (if returning option was used) */
+    data?: T[];
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Update result
+ */
+export interface IUpdateResult<T = any> {
+    /** Number of rows updated */
+    updatedCount: number;
+    /** Number of rows matched by the where clause */
+    matchedCount?: number;
+    /** Updated rows (if returning option was used) */
+    data?: T[];
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Delete result
+ */
+export interface IDeleteResult<T = any> {
+    /** Number of rows deleted */
+    deletedCount: number;
+    /** Deleted rows (if returning option was used) */
+    data?: T[];
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Upsert result
+ */
+export interface IUpsertResult<T = any> {
+    /** Number of rows inserted */
+    insertedCount: number;
+    /** Number of rows updated */
+    updatedCount: number;
+    /** Total affected rows */
+    affectedCount: number;
+    /** Operation performed ('insert' or 'update') - only applicable for single-row upserts */
+    operation?: 'insert' | 'update';
+    /** Upserted rows (if returning option was used) */
+    data?: T[];
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Bulk operation result
+ */
+export interface IBulkOperationResult {
+    /** Number of successful operations */
+    successCount: number;
+    /** Number of failed operations */
+    failedCount: number;
+    /** Total operations */
+    totalCount: number;
+    /** Errors (if any) */
+    errors?: Array<{
+        index: number;
+        error: string;
+    }>;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Success flag */
+    success: boolean;
+}
+/**
+ * Transaction result
+ */
+export interface ITransactionResult {
+    /** Transaction ID */
+    transactionId?: string;
+    /** Operations executed */
+    operationsCount: number;
+    /** Success flag */
+    success: boolean;
+    /** Error message (if failed) */
+    error?: string;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+}
+/**
+ * Schema operation result
+ */
+export interface ISchemaOperationResult {
+    /** Success flag */
+    success: boolean;
+    /** Operation type */
+    operation: 'create' | 'alter' | 'drop' | 'rename';
+    /** Table/Collection name */
+    table: string;
+    /** Error message (if failed) */
+    error?: string;
+    /** Migration generated (if applicable) */
+    migration?: {
+        tag: string;
+        name: string;
+    };
+    /** Execution time in milliseconds */
+    executionTime?: number;
+}
+/**
+ * Index operation result
+ */
+export interface IIndexOperationResult {
+    /** Success flag */
+    success: boolean;
+    /** Operation type */
+    operation: 'create' | 'drop';
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Error message (if failed) */
+    error?: string;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+}
+/**
+ * Raw query result
+ */
+export interface IRawQueryResult<T = any> {
+    /** Result rows/documents */
+    rows: T[];
+    /** Row count */
+    rowCount: number;
+    /** Fields/columns info */
+    fields?: Array<{
+        name: string;
+        type: string;
+    }>;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+}
+/**
+ * Paginated result
+ */
+export interface IPaginatedResult<T = any> {
+    /** Current page data */
+    data: T[];
+    /** Pagination metadata */
+    pagination: {
+        /** Current page number */
+        page: number;
+        /** Page size */
+        pageSize: number;
+        /** Total records */
+        totalRecords: number;
+        /** Total pages */
+        totalPages: number;
+        /** Has next page */
+        hasNext: boolean;
+        /** Has previous page */
+        hasPrevious: boolean;
+    };
+    /** Execution time in milliseconds */
+    executionTime?: number;
+}
+/**
+ * Batch operation result item
+ */
+export interface IBatchOperationResultItem {
+    /** Operation index */
+    index: number;
+    /** Success flag */
+    success: boolean;
+    /** Result data */
+    result?: any;
+    /** Error (if failed) */
+    error?: string;
+}
+/**
+ * Connection test result
+ */
+export interface IConnectionTestResult {
+    /** Is connection successful */
+    connected: boolean;
+    /** Connection message */
+    message: string;
+    /** Database type */
+    databaseType: string;
+    /** Database version */
+    version?: string;
+    /** Response time in milliseconds */
+    responseTime: number;
+    /** Error (if failed) */
+    error?: string;
+}

package/dist/database/types/result.types.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Result type definitions for database operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=result.types.js.map

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

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

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

@@ -0,0 +1,190 @@
+/**
+ * Schema type definitions for tables, columns, and data types
+ * Provides unified interface for SQL and NoSQL schema operations
+ */
+import type { IIndexDefinition } from './index.types';
+/**
+ * Column data types (unified across SQL and NoSQL)
+ */
+export declare enum ColumnType {
+    STRING = "string",
+    TEXT = "text",
+    VARCHAR = "varchar",
+    CHAR = "char",
+    INTEGER = "integer",
+    BIGINT = "bigint",
+    SMALLINT = "smallint",
+    DECIMAL = "decimal",
+    NUMERIC = "numeric",
+    FLOAT = "float",
+    DOUBLE = "double",
+    REAL = "real",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    TIME = "time",
+    DATETIME = "datetime",
+    TIMESTAMP = "timestamp",
+    JSON = "json",
+    JSONB = "jsonb",
+    OBJECT = "object",
+    ARRAY = "array",
+    BINARY = "binary",
+    BLOB = "blob",
+    UUID = "uuid",
+    ENUM = "enum"
+}
+/**
+ * Column constraint types
+ */
+export declare enum ConstraintType {
+    PRIMARY_KEY = "primary_key",
+    FOREIGN_KEY = "foreign_key",
+    UNIQUE = "unique",
+    NOT_NULL = "not_null",
+    DEFAULT = "default",
+    CHECK = "check",
+    INDEX = "index"
+}
+/**
+ * Column definition
+ */
+export interface IColumnDefinition {
+    /** Column name */
+    name: string;
+    /** Column type */
+    type: ColumnType;
+    /** Is column nullable */
+    nullable?: boolean;
+    /** Default value */
+    defaultValue?: any;
+    /** Is primary key */
+    primaryKey?: boolean;
+    /** Is unique */
+    unique?: boolean;
+    /** Is auto-increment */
+    autoIncrement?: boolean;
+    /** Column length (for string types) */
+    length?: number;
+    /** Precision (for decimal/numeric) */
+    precision?: number;
+    /** Scale (for decimal/numeric) */
+    scale?: number;
+    /** Enum values (for enum type) */
+    enumValues?: string[];
+    /** Foreign key reference */
+    foreignKey?: IForeignKeyDefinition;
+    /** Check constraint */
+    check?: string;
+    /** Comment */
+    comment?: string;
+    /** For nested objects (NoSQL) */
+    nested?: INestedFieldDefinition;
+}
+/**
+ * Foreign key definition
+ */
+export interface IForeignKeyDefinition {
+    /** Referenced table */
+    table: string;
+    /** Referenced column */
+    column: string;
+    /** On delete action */
+    onDelete?: 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'RESTRICT';
+    /** On update action */
+    onUpdate?: 'CASCADE' | 'SET NULL' | 'NO ACTION' | 'RESTRICT';
+}
+/**
+ * Nested field definition (for NoSQL/JSON columns)
+ */
+export interface INestedFieldDefinition {
+    /** Nested field type */
+    type: ColumnType;
+    /** Is array of values */
+    isArray?: boolean;
+    /** Child fields (for nested objects) */
+    fields?: Record<string, INestedFieldDefinition>;
+}
+/**
+ * Table schema definition
+ */
+export interface ITableSchema {
+    /** Table/Collection name */
+    name: string;
+    /** Column definitions */
+    columns: IColumnDefinition[];
+    /** Primary key columns (composite keys) */
+    primaryKeys?: string[];
+    /** Indexes */
+    indexes?: IIndexDefinition[];
+    /** Unique constraints */
+    uniqueConstraints?: string[][];
+    /** Check constraints */
+    checkConstraints?: Array<{
+        name: string;
+        expression: string;
+    }>;
+    /** Table comment */
+    comment?: string;
+    /** Table options (engine, charset, etc.) */
+    options?: Record<string, any>;
+}
+/**
+ * Column alteration types
+ */
+export declare enum ColumnAlterationType {
+    ADD = "add",
+    MODIFY = "modify",
+    DROP = "drop",
+    RENAME = "rename"
+}
+/**
+ * Column alteration operation
+ */
+export interface IColumnAlteration {
+    /** Type of alteration */
+    type: ColumnAlterationType;
+    /** Column definition (for ADD/MODIFY) */
+    column?: IColumnDefinition;
+    /** Old column name (for RENAME) */
+    oldName?: string;
+    /** New column name (for RENAME) */
+    newName?: string;
+}
+/**
+ * Schema validation result
+ */
+export interface ISchemaValidationResult {
+    /** Is schema valid */
+    valid: boolean;
+    /** Validation errors */
+    errors: Array<{
+        field: string;
+        message: string;
+    }>;
+}
+/**
+ * Table creation options
+ */
+export interface ICreateTableOptions {
+    /** Create if not exists */
+    ifNotExists?: boolean;
+    /** Table comment */
+    comment?: string;
+    /** Table engine (MySQL) */
+    engine?: string;
+    /** Character set (MySQL) */
+    charset?: string;
+    /** Collation */
+    collate?: string;
+    /** Additional options */
+    options?: Record<string, any>;
+}
+/**
+ * Table alteration options
+ */
+export interface IAlterTableOptions {
+    /** Generate migration */
+    generateMigration?: boolean;
+    /** Migration name */
+    migrationName?: string;
+}

package/dist/database/types/schema.types.js

@@ -0,0 +1,69 @@
+"use strict";
+/**
+ * Schema type definitions for tables, columns, and data types
+ * Provides unified interface for SQL and NoSQL schema operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnAlterationType = exports.ConstraintType = exports.ColumnType = void 0;
+/**
+ * Column data types (unified across SQL and NoSQL)
+ */
+var ColumnType;
+(function (ColumnType) {
+    // String types
+    ColumnType["STRING"] = "string";
+    ColumnType["TEXT"] = "text";
+    ColumnType["VARCHAR"] = "varchar";
+    ColumnType["CHAR"] = "char";
+    // Number types
+    ColumnType["INTEGER"] = "integer";
+    ColumnType["BIGINT"] = "bigint";
+    ColumnType["SMALLINT"] = "smallint";
+    ColumnType["DECIMAL"] = "decimal";
+    ColumnType["NUMERIC"] = "numeric";
+    ColumnType["FLOAT"] = "float";
+    ColumnType["DOUBLE"] = "double";
+    ColumnType["REAL"] = "real";
+    // Boolean
+    ColumnType["BOOLEAN"] = "boolean";
+    // Date/Time types
+    ColumnType["DATE"] = "date";
+    ColumnType["TIME"] = "time";
+    ColumnType["DATETIME"] = "datetime";
+    ColumnType["TIMESTAMP"] = "timestamp";
+    // JSON/Object types
+    ColumnType["JSON"] = "json";
+    ColumnType["JSONB"] = "jsonb";
+    ColumnType["OBJECT"] = "object";
+    ColumnType["ARRAY"] = "array";
+    // Binary
+    ColumnType["BINARY"] = "binary";
+    ColumnType["BLOB"] = "blob";
+    // Special types
+    ColumnType["UUID"] = "uuid";
+    ColumnType["ENUM"] = "enum";
+})(ColumnType || (exports.ColumnType = ColumnType = {}));
+/**
+ * Column constraint types
+ */
+var ConstraintType;
+(function (ConstraintType) {
+    ConstraintType["PRIMARY_KEY"] = "primary_key";
+    ConstraintType["FOREIGN_KEY"] = "foreign_key";
+    ConstraintType["UNIQUE"] = "unique";
+    ConstraintType["NOT_NULL"] = "not_null";
+    ConstraintType["DEFAULT"] = "default";
+    ConstraintType["CHECK"] = "check";
+    ConstraintType["INDEX"] = "index";
+})(ConstraintType || (exports.ConstraintType = ConstraintType = {}));
+/**
+ * Column alteration types
+ */
+var ColumnAlterationType;
+(function (ColumnAlterationType) {
+    ColumnAlterationType["ADD"] = "add";
+    ColumnAlterationType["MODIFY"] = "modify";
+    ColumnAlterationType["DROP"] = "drop";
+    ColumnAlterationType["RENAME"] = "rename";
+})(ColumnAlterationType || (exports.ColumnAlterationType = ColumnAlterationType = {}));
+//# sourceMappingURL=schema.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.types.js","sourceRoot":"","sources":["../../../src/database/types/schema.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAIH;;GAEG;AACH,IAAY,UAuCX;AAvCD,WAAY,UAAU;IACpB,eAAe;IACf,+BAAiB,CAAA;IACjB,2BAAa,CAAA;IACb,iCAAmB,CAAA;IACnB,2BAAa,CAAA;IAEb,eAAe;IACf,iCAAmB,CAAA;IACnB,+BAAiB,CAAA;IACjB,mCAAqB,CAAA;IACrB,iCAAmB,CAAA;IACnB,iCAAmB,CAAA;IACnB,6BAAe,CAAA;IACf,+BAAiB,CAAA;IACjB,2BAAa,CAAA;IAEb,UAAU;IACV,iCAAmB,CAAA;IAEnB,kBAAkB;IAClB,2BAAa,CAAA;IACb,2BAAa,CAAA;IACb,mCAAqB,CAAA;IACrB,qCAAuB,CAAA;IAEvB,oBAAoB;IACpB,2BAAa,CAAA;IACb,6BAAe,CAAA;IACf,+BAAiB,CAAA;IACjB,6BAAe,CAAA;IAEf,SAAS;IACT,+BAAiB,CAAA;IACjB,2BAAa,CAAA;IAEb,gBAAgB;IAChB,2BAAa,CAAA;IACb,2BAAa,CAAA;AACf,CAAC,EAvCW,UAAU,0BAAV,UAAU,QAuCrB;AAED;;GAEG;AACH,IAAY,cAQX;AARD,WAAY,cAAc;IACxB,6CAA2B,CAAA;IAC3B,6CAA2B,CAAA;IAC3B,mCAAiB,CAAA;IACjB,uCAAqB,CAAA;IACrB,qCAAmB,CAAA;IACnB,iCAAe,CAAA;IACf,iCAAe,CAAA;AACjB,CAAC,EARW,cAAc,8BAAd,cAAc,QAQzB;AAyFD;;GAEG;AACH,IAAY,oBAKX;AALD,WAAY,oBAAoB;IAC9B,mCAAW,CAAA;IACX,yCAAiB,CAAA;IACjB,qCAAa,CAAA;IACb,yCAAiB,CAAA;AACnB,CAAC,EALW,oBAAoB,oCAApB,oBAAoB,QAK/B"}

package/dist/database/utils/helpers.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Database Helper Utilities
+ * Type mapping, query building, and error handling utilities
+ */
+import { ColumnType } from '../types/schema.types';
+import { DatabaseType } from '../types/database.types';
+import { WhereClause } from '../types/query.types';
+/**
+ * Map generic column types to database-specific types
+ */
+export declare function mapColumnTypeToNative(type: ColumnType, dbType: DatabaseType): string;
+/**
+ * Build WHERE clause string for SQL databases from WhereClause
+ */
+export declare function buildWhereClause(where: WhereClause, paramIndex?: number): {
+    sql: string;
+    params: any[];
+};
+/**
+ * Build MongoDB query from WhereClause
+ */
+export declare function buildMongoQuery(where: WhereClause): any;
+/**
+ * Escape identifier (table/column name) for SQL
+ */
+export declare function escapeIdentifier(identifier: string, dbType: DatabaseType): string;
+/**
+ * Escape string value for SQL
+ */
+export declare function escapeValue(value: any): string;
+/**
+ * Format error message with context
+ */
+export declare function formatDatabaseError(error: any, operation: string, tableName?: string): Error;
+/**
+ * Check if error is a connection error
+ */
+export declare function isConnectionError(error: any): boolean;
+/**
+ * Check if error is a duplicate key error
+ */
+export declare function isDuplicateKeyError(error: any): boolean;
+/**
+ * Check if error is a foreign key constraint error
+ */
+export declare function isForeignKeyError(error: any): boolean;
+/**
+ * Retry a database operation with exponential backoff
+ */
+export declare function retryOperation<T>(operation: () => Promise<T>, maxRetries?: number, initialDelay?: number): Promise<T>;
+/**
+ * Sanitize table name to prevent SQL injection
+ */
+export declare function sanitizeTableName(tableName: string): string;
+/**
+ * Convert camelCase to snake_case
+ */
+export declare function camelToSnake(str: string): string;
+/**
+ * Convert snake_case to camelCase
+ */
+export declare function snakeToCamel(str: string): string;
+/**
+ * Deep clone an object
+ */
+export declare function deepClone<T>(obj: T): T;