@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,175 @@
+/**
+ * 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",
+    TRANSACTION_ERROR = "transaction_error",
+    NOT_SUPPORTED = "not_supported"
+}
+/**
+ * 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>;

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

@@ -0,0 +1,75 @@
+"use strict";
+/**
+ * Core database type definitions for the Ductape Database ORM
+ * Provides unified interface for SQL and NoSQL databases
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionStatus = exports.TransactionIsolationLevel = exports.DatabaseError = exports.DatabaseErrorType = exports.ConnectionStatus = exports.DatabaseType = void 0;
+/**
+ * Supported database types
+ */
+var DatabaseType;
+(function (DatabaseType) {
+    DatabaseType["POSTGRESQL"] = "postgresql";
+    DatabaseType["MYSQL"] = "mysql";
+    DatabaseType["MONGODB"] = "mongodb";
+    DatabaseType["DYNAMODB"] = "dynamodb";
+    DatabaseType["SQLITE"] = "sqlite";
+})(DatabaseType || (exports.DatabaseType = DatabaseType = {}));
+/**
+ * Database connection status
+ */
+var ConnectionStatus;
+(function (ConnectionStatus) {
+    ConnectionStatus["DISCONNECTED"] = "disconnected";
+    ConnectionStatus["CONNECTING"] = "connecting";
+    ConnectionStatus["CONNECTED"] = "connected";
+    ConnectionStatus["ERROR"] = "error";
+})(ConnectionStatus || (exports.ConnectionStatus = ConnectionStatus = {}));
+/**
+ * Database error types
+ */
+var DatabaseErrorType;
+(function (DatabaseErrorType) {
+    DatabaseErrorType["CONNECTION_ERROR"] = "connection_error";
+    DatabaseErrorType["QUERY_ERROR"] = "query_error";
+    DatabaseErrorType["VALIDATION_ERROR"] = "validation_error";
+    DatabaseErrorType["MIGRATION_ERROR"] = "migration_error";
+    DatabaseErrorType["SCHEMA_ERROR"] = "schema_error";
+    DatabaseErrorType["INDEX_ERROR"] = "index_error";
+    DatabaseErrorType["TRANSACTION_ERROR"] = "transaction_error";
+    DatabaseErrorType["NOT_SUPPORTED"] = "not_supported";
+})(DatabaseErrorType || (exports.DatabaseErrorType = DatabaseErrorType = {}));
+/**
+ * Database error class
+ */
+class DatabaseError extends Error {
+    constructor(type, message, originalError) {
+        super(message);
+        this.type = type;
+        this.originalError = originalError;
+        this.name = 'DatabaseError';
+    }
+}
+exports.DatabaseError = DatabaseError;
+/**
+ * Transaction isolation levels
+ */
+var TransactionIsolationLevel;
+(function (TransactionIsolationLevel) {
+    TransactionIsolationLevel["READ_UNCOMMITTED"] = "READ_UNCOMMITTED";
+    TransactionIsolationLevel["READ_COMMITTED"] = "READ_COMMITTED";
+    TransactionIsolationLevel["REPEATABLE_READ"] = "REPEATABLE_READ";
+    TransactionIsolationLevel["SERIALIZABLE"] = "SERIALIZABLE";
+})(TransactionIsolationLevel || (exports.TransactionIsolationLevel = TransactionIsolationLevel = {}));
+/**
+ * Transaction status
+ */
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["ACTIVE"] = "active";
+    TransactionStatus["COMMITTED"] = "committed";
+    TransactionStatus["ROLLED_BACK"] = "rolled_back";
+    TransactionStatus["FAILED"] = "failed";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+//# sourceMappingURL=database.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database.types.js","sourceRoot":"","sources":["../../../src/database/types/database.types.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;AAEH;;GAEG;AACH,IAAY,YAMX;AAND,WAAY,YAAY;IACtB,yCAAyB,CAAA;IACzB,+BAAe,CAAA;IACf,mCAAmB,CAAA;IACnB,qCAAqB,CAAA;IACrB,iCAAiB,CAAA;AACnB,CAAC,EANW,YAAY,4BAAZ,YAAY,QAMvB;AAED;;GAEG;AACH,IAAY,gBAKX;AALD,WAAY,gBAAgB;IAC1B,iDAA6B,CAAA;IAC7B,6CAAyB,CAAA;IACzB,2CAAuB,CAAA;IACvB,mCAAe,CAAA;AACjB,CAAC,EALW,gBAAgB,gCAAhB,gBAAgB,QAK3B;AAiED;;GAEG;AACH,IAAY,iBASX;AATD,WAAY,iBAAiB;IAC3B,0DAAqC,CAAA;IACrC,gDAA2B,CAAA;IAC3B,0DAAqC,CAAA;IACrC,wDAAmC,CAAA;IACnC,kDAA6B,CAAA;IAC7B,gDAA2B,CAAA;IAC3B,4DAAuC,CAAA;IACvC,oDAA+B,CAAA;AACjC,CAAC,EATW,iBAAiB,iCAAjB,iBAAiB,QAS5B;AAED;;GAEG;AACH,MAAa,aAAc,SAAQ,KAAK;IACtC,YACS,IAAuB,EAC9B,OAAe,EACR,aAAqB;QAE5B,KAAK,CAAC,OAAO,CAAC,CAAC;QAJR,SAAI,GAAJ,IAAI,CAAmB;QAEvB,kBAAa,GAAb,aAAa,CAAQ;QAG5B,IAAI,CAAC,IAAI,GAAG,eAAe,CAAC;IAC9B,CAAC;CACF;AATD,sCASC;AAED;;GAEG;AACH,IAAY,yBAKX;AALD,WAAY,yBAAyB;IACnC,kEAAqC,CAAA;IACrC,8DAAiC,CAAA;IACjC,gEAAmC,CAAA;IACnC,0DAA6B,CAAA;AAC/B,CAAC,EALW,yBAAyB,yCAAzB,yBAAyB,QAKpC;AAED;;GAEG;AACH,IAAY,iBAKX;AALD,WAAY,iBAAiB;IAC3B,sCAAiB,CAAA;IACjB,4CAAuB,CAAA;IACvB,gDAA2B,CAAA;IAC3B,sCAAiB,CAAA;AACnB,CAAC,EALW,iBAAiB,iCAAjB,iBAAiB,QAK5B"}

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

@@ -0,0 +1,12 @@
+/**
+ * Database types index
+ * Exports all type definitions for the Ductape Database ORM
+ */
+export * from './database.types';
+export * from './connection.types';
+export * from './schema.types';
+export * from './migration.types';
+export * from './query.types';
+export * from './aggregation.types';
+export * from './result.types';
+export * from './index.types';

package/dist/database/types/index.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Database types index
+ * Exports all type definitions for the Ductape Database ORM
+ */
+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 });
+// Core database types
+__exportStar(require("./database.types"), exports);
+// Connection types
+__exportStar(require("./connection.types"), exports);
+// Schema types
+__exportStar(require("./schema.types"), exports);
+// Migration types
+__exportStar(require("./migration.types"), exports);
+// Query types
+__exportStar(require("./query.types"), exports);
+// Aggregation types
+__exportStar(require("./aggregation.types"), exports);
+// Result types
+__exportStar(require("./result.types"), exports);
+// Index types
+__exportStar(require("./index.types"), exports);
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/database/types/index.ts"],"names":[],"mappings":";AAAA;;;GAGG;;;;;;;;;;;;;;;;AAEH,sBAAsB;AACtB,mDAAiC;AAEjC,mBAAmB;AACnB,qDAAmC;AAEnC,eAAe;AACf,iDAA+B;AAE/B,kBAAkB;AAClB,oDAAkC;AAElC,cAAc;AACd,gDAA8B;AAE9B,oBAAoB;AACpB,sDAAoC;AAEpC,eAAe;AACf,iDAA+B;AAE/B,cAAc;AACd,gDAA8B"}

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

@@ -0,0 +1,220 @@
+/**
+ * Index type definitions for database indexes
+ */
+/**
+ * Index type
+ */
+export declare enum IndexType {
+    /** B-Tree index (default for most databases) */
+    BTREE = "btree",
+    /** Hash index */
+    HASH = "hash",
+    /** GIN (Generalized Inverted Index) - PostgreSQL */
+    GIN = "gin",
+    /** GiST (Generalized Search Tree) - PostgreSQL */
+    GIST = "gist",
+    /** Full-text index */
+    FULLTEXT = "fulltext",
+    /** Spatial index */
+    SPATIAL = "spatial",
+    /** Unique index */
+    UNIQUE = "unique"
+}
+/**
+ * Index column definition
+ */
+export interface IIndexColumn {
+    /** Column name */
+    name: string;
+    /** Sort order */
+    order?: 'ASC' | 'DESC';
+    /** Length (for partial indexes on string columns) */
+    length?: number;
+    /** Expression (for expression-based indexes) */
+    expression?: string;
+}
+/**
+ * Index definition
+ */
+export interface IIndexDefinition {
+    /** Index name */
+    name: string;
+    /** Table name */
+    table: string;
+    /** Columns in the index */
+    columns: IIndexColumn[];
+    /** Index type */
+    type?: IndexType;
+    /** Is unique index */
+    unique?: boolean;
+    /** Partial index condition (WHERE clause) */
+    where?: string;
+    /** Index method (database-specific) */
+    method?: string;
+    /** Include columns (PostgreSQL covering indexes) */
+    include?: string[];
+    /** Comment */
+    comment?: string;
+    /** Storage parameters */
+    storageParams?: Record<string, any>;
+}
+/**
+ * Create index options
+ */
+export interface ICreateIndexOptions {
+    /** Table name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Index definition */
+    index: IIndexDefinition;
+    /** Create if not exists */
+    ifNotExists?: boolean;
+    /** Create concurrently (PostgreSQL - doesn't lock table) */
+    concurrent?: boolean;
+    /** Generate migration */
+    generateMigration?: boolean;
+}
+/**
+ * Drop index options
+ */
+export interface IDropIndexOptions {
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Drop if exists */
+    ifExists?: boolean;
+    /** Drop concurrently (PostgreSQL) */
+    concurrent?: boolean;
+    /** Cascade drop (also drop dependent objects) */
+    cascade?: boolean;
+    /** Generate migration */
+    generateMigration?: boolean;
+}
+/**
+ * List indexes options
+ */
+export interface IListIndexesOptions {
+    /** Table name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Include system indexes */
+    includeSystem?: boolean;
+}
+/**
+ * Index info (returned when listing indexes)
+ */
+export interface IIndexInfo {
+    /** Index name */
+    name: string;
+    /** Table name */
+    table: string;
+    /** Column names */
+    columns: string[];
+    /** Column definitions with details */
+    columnDetails: IIndexColumn[];
+    /** Is unique */
+    unique: boolean;
+    /** Is primary key */
+    primaryKey: boolean;
+    /** Index type */
+    type: string;
+    /** Index size (in bytes, if available) */
+    size?: number;
+    /** Number of rows in index */
+    rowCount?: number;
+    /** Partial index condition */
+    where?: string;
+    /** Comment */
+    comment?: string;
+    /** Additional metadata */
+    metadata?: Record<string, any>;
+}
+/**
+ * Index statistics
+ */
+export interface IIndexStatistics {
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Number of index scans */
+    scans?: number;
+    /** Number of tuples/rows read */
+    tuplesRead?: number;
+    /** Number of tuples fetched */
+    tuplesFetched?: number;
+    /** Index size in bytes */
+    size: number;
+    /** Index size (human-readable) */
+    sizeFormatted?: string;
+    /** Last used timestamp */
+    lastUsed?: Date | string;
+    /** Is index bloated */
+    bloated?: boolean;
+    /** Bloat percentage */
+    bloatPercentage?: number;
+}
+/**
+ * Analyze index options
+ */
+export interface IAnalyzeIndexOptions {
+    /** Index name */
+    indexName?: string;
+    /** Table name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+}
+/**
+ * Rebuild index options
+ */
+export interface IRebuildIndexOptions {
+    /** Index name */
+    indexName: string;
+    /** Table name */
+    table: string;
+    /** Environment slug (optional if connection is already established) */
+    env?: string;
+    /** Product tag (optional if connection is already established) */
+    product?: string;
+    /** Database tag (optional if connection is already established) */
+    database?: string;
+    /** Rebuild concurrently (PostgreSQL) */
+    concurrent?: boolean;
+}
+/**
+ * Index recommendation
+ */
+export interface IIndexRecommendation {
+    /** Recommended index definition */
+    index: IIndexDefinition;
+    /** Reason for recommendation */
+    reason: string;
+    /** Estimated performance impact */
+    impact: 'high' | 'medium' | 'low';
+    /** Query patterns that would benefit */
+    affectedQueries?: string[];
+    /** Estimated index size */
+    estimatedSize?: number;
+}

package/dist/database/types/index.types.js

@@ -0,0 +1,27 @@
+"use strict";
+/**
+ * Index type definitions for database indexes
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IndexType = void 0;
+/**
+ * Index type
+ */
+var IndexType;
+(function (IndexType) {
+    /** B-Tree index (default for most databases) */
+    IndexType["BTREE"] = "btree";
+    /** Hash index */
+    IndexType["HASH"] = "hash";
+    /** GIN (Generalized Inverted Index) - PostgreSQL */
+    IndexType["GIN"] = "gin";
+    /** GiST (Generalized Search Tree) - PostgreSQL */
+    IndexType["GIST"] = "gist";
+    /** Full-text index */
+    IndexType["FULLTEXT"] = "fulltext";
+    /** Spatial index */
+    IndexType["SPATIAL"] = "spatial";
+    /** Unique index */
+    IndexType["UNIQUE"] = "unique";
+})(IndexType || (exports.IndexType = IndexType = {}));
+//# sourceMappingURL=index.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.types.js","sourceRoot":"","sources":["../../../src/database/types/index.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH;;GAEG;AACH,IAAY,SAeX;AAfD,WAAY,SAAS;IACnB,gDAAgD;IAChD,4BAAe,CAAA;IACf,iBAAiB;IACjB,0BAAa,CAAA;IACb,oDAAoD;IACpD,wBAAW,CAAA;IACX,kDAAkD;IAClD,0BAAa,CAAA;IACb,sBAAsB;IACtB,kCAAqB,CAAA;IACrB,oBAAoB;IACpB,gCAAmB,CAAA;IACnB,mBAAmB;IACnB,8BAAiB,CAAA;AACnB,CAAC,EAfW,SAAS,yBAAT,SAAS,QAepB"}