@ductape/sdk 0.0.4-v41 → 0.0.4-v43

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

@@ -0,0 +1,274 @@
+/**
+ * Query type definitions for database operations
+ */
+/**
+ * Comparison operators for where clauses
+ */
+export declare enum ComparisonOperator {
+    EQUALS = "=",
+    NOT_EQUALS = "!=",
+    GREATER_THAN = ">",
+    GREATER_THAN_OR_EQUAL = ">=",
+    LESS_THAN = "<",
+    LESS_THAN_OR_EQUAL = "<=",
+    LIKE = "like",
+    NOT_LIKE = "not_like",
+    IN = "in",
+    NOT_IN = "not_in",
+    BETWEEN = "between",
+    NOT_BETWEEN = "not_between",
+    IS_NULL = "is_null",
+    IS_NOT_NULL = "is_not_null",
+    CONTAINS = "contains",// For arrays/JSON
+    NOT_CONTAINS = "not_contains"
+}
+/**
+ * Logical operators for combining conditions
+ */
+export declare enum LogicalOperator {
+    AND = "and",
+    OR = "or",
+    NOT = "not"
+}
+/**
+ * Sort order
+ */
+export declare enum SortOrder {
+    ASC = "asc",
+    DESC = "desc"
+}
+/**
+ * Simple where condition
+ */
+export interface IWhereCondition {
+    /** Column name */
+    column: string;
+    /** Comparison operator */
+    operator: ComparisonOperator | string;
+    /** Value to compare */
+    value?: any;
+    /** Values for IN, NOT_IN, BETWEEN operators */
+    values?: any[];
+}
+/**
+ * Grouped where conditions
+ */
+export interface IWhereGroup {
+    /** Logical operator for this group */
+    operator: LogicalOperator;
+    /** Conditions in this group */
+    conditions: (IWhereCondition | IWhereGroup)[];
+}
+/**
+ * Where clause (can be object notation or complex conditions)
+ */
+export type WhereClause = Record<string, any> | IWhereCondition | IWhereGroup | IWhereCondition[] | IWhereGroup[];
+/**
+ * Order by clause
+ */
+export interface IOrderBy {
+    /** Column name */
+    column: string;
+    /** Sort order */
+    order: SortOrder;
+}
+/**
+ * Join type
+ */
+export declare enum JoinType {
+    INNER = "inner",
+    LEFT = "left",
+    RIGHT = "right",
+    FULL = "full",
+    CROSS = "cross"
+}
+/**
+ * Join clause
+ */
+export interface IJoinClause {
+    /** Join type */
+    type: JoinType;
+    /** Table to join */
+    table: string;
+    /** Left column (from main table) */
+    leftColumn: string;
+    /** Right column (from joined table) */
+    rightColumn: string;
+    /** Optional join condition */
+    condition?: WhereClause;
+}
+/**
+ * Pagination options
+ */
+export interface IPagination {
+    /** Number of records to skip */
+    offset?: number;
+    /** Number of records to return */
+    limit?: number;
+    /** Page number (alternative to offset) */
+    page?: number;
+    /** Page size (alternative to limit) */
+    pageSize?: number;
+}
+/**
+ * Query options
+ */
+export interface IQueryOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Columns to select (empty for all) */
+    select?: string[];
+    /** Where clause */
+    where?: WhereClause;
+    /** Order by */
+    orderBy?: IOrderBy | IOrderBy[];
+    /** Pagination */
+    limit?: number;
+    /** Offset */
+    offset?: number;
+    /** Joins (SQL only) */
+    joins?: IJoinClause[];
+    /** Group by columns */
+    groupBy?: string[];
+    /** Having clause (for grouped queries) */
+    having?: WhereClause;
+    /** Distinct results */
+    distinct?: boolean;
+    /** Transaction to execute within */
+    transaction?: any;
+}
+/**
+ * Insert options
+ */
+export interface IInsertOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Data to insert (single record or array) */
+    data: Record<string, any> | Record<string, any>[];
+    /** Return inserted records */
+    returning?: boolean | string[];
+    /** Ignore duplicate key errors */
+    ignoreErrors?: boolean;
+    /** On conflict action (PostgreSQL) */
+    onConflict?: {
+        /** Columns that define the conflict */
+        columns: string[];
+        /** Action: 'ignore' or 'update' */
+        action: 'ignore' | 'update';
+        /** Columns to update (if action is 'update') */
+        update?: string[];
+    };
+    /** Transaction to execute within */
+    transaction?: any;
+}
+/**
+ * Update options
+ */
+export interface IUpdateOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Data to update */
+    data: Record<string, any>;
+    /** Where clause */
+    where: WhereClause;
+    /** Return updated records */
+    returning?: boolean | string[];
+    /** Limit number of records to update */
+    limit?: number;
+    /** Transaction to execute within */
+    transaction?: any;
+}
+/**
+ * Delete options
+ */
+export interface IDeleteOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Where clause */
+    where: WhereClause;
+    /** Return deleted records */
+    returning?: boolean | string[];
+    /** Limit number of records to delete */
+    limit?: number;
+    /** Transaction to execute within */
+    transaction?: any;
+}
+/**
+ * Upsert options (insert or update)
+ */
+export interface IUpsertOptions {
+    /** Table/Collection name */
+    table: string;
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Data to upsert */
+    data: Record<string, any> | Record<string, any>[];
+    /** Columns that define uniqueness */
+    uniqueColumns: string[];
+    /** Columns to update on conflict */
+    updateColumns?: string[];
+    /** Return upserted records */
+    returning?: boolean | string[];
+}
+/**
+ * Transaction execution options
+ */
+export interface ITransactionExecutionOptions {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Isolation level */
+    isolationLevel?: 'READ_UNCOMMITTED' | 'READ_COMMITTED' | 'REPEATABLE_READ' | 'SERIALIZABLE';
+    /** Read only transaction */
+    readOnly?: boolean;
+    /** Timeout in milliseconds */
+    timeout?: number;
+}
+/**
+ * Raw query options
+ */
+export interface IRawQueryOptions {
+    /** Environment slug */
+    env: string;
+    /** Product tag */
+    product?: string;
+    /** Database tag */
+    database?: string;
+    /** Raw SQL/query string */
+    query: string;
+    /** Query parameters */
+    params?: any[];
+    /** Named parameters */
+    namedParams?: Record<string, any>;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+/**
+ * Query type definitions for database operations
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JoinType = exports.SortOrder = exports.LogicalOperator = exports.ComparisonOperator = void 0;
+/**
+ * Comparison operators for where clauses
+ */
+var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["EQUALS"] = "=";
+    ComparisonOperator["NOT_EQUALS"] = "!=";
+    ComparisonOperator["GREATER_THAN"] = ">";
+    ComparisonOperator["GREATER_THAN_OR_EQUAL"] = ">=";
+    ComparisonOperator["LESS_THAN"] = "<";
+    ComparisonOperator["LESS_THAN_OR_EQUAL"] = "<=";
+    ComparisonOperator["LIKE"] = "like";
+    ComparisonOperator["NOT_LIKE"] = "not_like";
+    ComparisonOperator["IN"] = "in";
+    ComparisonOperator["NOT_IN"] = "not_in";
+    ComparisonOperator["BETWEEN"] = "between";
+    ComparisonOperator["NOT_BETWEEN"] = "not_between";
+    ComparisonOperator["IS_NULL"] = "is_null";
+    ComparisonOperator["IS_NOT_NULL"] = "is_not_null";
+    ComparisonOperator["CONTAINS"] = "contains";
+    ComparisonOperator["NOT_CONTAINS"] = "not_contains";
+})(ComparisonOperator || (exports.ComparisonOperator = ComparisonOperator = {}));
+/**
+ * Logical operators for combining conditions
+ */
+var LogicalOperator;
+(function (LogicalOperator) {
+    LogicalOperator["AND"] = "and";
+    LogicalOperator["OR"] = "or";
+    LogicalOperator["NOT"] = "not";
+})(LogicalOperator || (exports.LogicalOperator = LogicalOperator = {}));
+/**
+ * Sort order
+ */
+var SortOrder;
+(function (SortOrder) {
+    SortOrder["ASC"] = "asc";
+    SortOrder["DESC"] = "desc";
+})(SortOrder || (exports.SortOrder = SortOrder = {}));
+/**
+ * Join type
+ */
+var JoinType;
+(function (JoinType) {
+    JoinType["INNER"] = "inner";
+    JoinType["LEFT"] = "left";
+    JoinType["RIGHT"] = "right";
+    JoinType["FULL"] = "full";
+    JoinType["CROSS"] = "cross";
+})(JoinType || (exports.JoinType = JoinType = {}));
+//# sourceMappingURL=query.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"query.types.js","sourceRoot":"","sources":["../../../src/database/types/query.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH;;GAEG;AACH,IAAY,kBAiBX;AAjBD,WAAY,kBAAkB;IAC5B,kCAAY,CAAA;IACZ,uCAAiB,CAAA;IACjB,wCAAkB,CAAA;IAClB,kDAA4B,CAAA;IAC5B,qCAAe,CAAA;IACf,+CAAyB,CAAA;IACzB,mCAAa,CAAA;IACb,2CAAqB,CAAA;IACrB,+BAAS,CAAA;IACT,uCAAiB,CAAA;IACjB,yCAAmB,CAAA;IACnB,iDAA2B,CAAA;IAC3B,yCAAmB,CAAA;IACnB,iDAA2B,CAAA;IAC3B,2CAAqB,CAAA;IACrB,mDAA6B,CAAA;AAC/B,CAAC,EAjBW,kBAAkB,kCAAlB,kBAAkB,QAiB7B;AAED;;GAEG;AACH,IAAY,eAIX;AAJD,WAAY,eAAe;IACzB,8BAAW,CAAA;IACX,4BAAS,CAAA;IACT,8BAAW,CAAA;AACb,CAAC,EAJW,eAAe,+BAAf,eAAe,QAI1B;AAED;;GAEG;AACH,IAAY,SAGX;AAHD,WAAY,SAAS;IACnB,wBAAW,CAAA;IACX,0BAAa,CAAA;AACf,CAAC,EAHW,SAAS,yBAAT,SAAS,QAGpB;AA8CD;;GAEG;AACH,IAAY,QAMX;AAND,WAAY,QAAQ;IAClB,2BAAe,CAAA;IACf,yBAAa,CAAA;IACb,2BAAe,CAAA;IACf,yBAAa,CAAA;IACb,2BAAe,CAAA;AACjB,CAAC,EANW,QAAQ,wBAAR,QAAQ,QAMnB"}

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

@@ -0,0 +1,218 @@
+/**
+ * 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;
+    /** 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"}