@ductape/sdk 0.0.4-v5 → 0.0.4-v51

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

@@ -0,0 +1,205 @@
+/**
+ * Migration type definitions for database schema versioning
+ */
+/**
+ * Migration status
+ */
+export declare enum MigrationStatus {
+    PENDING = "pending",
+    RUNNING = "running",
+    COMPLETED = "completed",
+    FAILED = "failed",
+    ROLLED_BACK = "rolled_back"
+}
+/**
+ * Migration direction
+ */
+export declare enum MigrationDirection {
+    UP = "up",
+    DOWN = "down"
+}
+/**
+ * Migration operation type
+ */
+export declare enum MigrationOperationType {
+    CREATE_TABLE = "create_table",
+    DROP_TABLE = "drop_table",
+    ALTER_TABLE = "alter_table",
+    ADD_COLUMN = "add_column",
+    DROP_COLUMN = "drop_column",
+    MODIFY_COLUMN = "modify_column",
+    RENAME_COLUMN = "rename_column",
+    ADD_INDEX = "add_index",
+    DROP_INDEX = "drop_index",
+    ADD_CONSTRAINT = "add_constraint",
+    DROP_CONSTRAINT = "drop_constraint",
+    RAW_SQL = "raw_sql"
+}
+/**
+ * Migration operation
+ */
+export interface IMigrationOperation {
+    /** Operation type */
+    type: MigrationOperationType;
+    /** Table name */
+    table?: string;
+    /** Raw SQL (for RAW_SQL type) */
+    sql?: string;
+    /** Operation parameters */
+    params?: Record<string, any>;
+}
+/**
+ * Migration definition
+ */
+export interface IMigrationDefinition {
+    /** Migration name */
+    name: string;
+    /** Migration description */
+    description?: string;
+    /** Migration tag/identifier */
+    tag: string;
+    /** Up operations */
+    up: IMigrationOperation[];
+    /** Down operations (rollback) */
+    down: IMigrationOperation[];
+    /** Migration dependencies (tags of migrations that must run first) */
+    dependencies?: string[];
+    /** Created timestamp */
+    createdAt?: Date | string;
+}
+/**
+ * Migration execution result
+ */
+export interface IMigrationResult {
+    /** Migration tag */
+    tag: string;
+    /** Execution status */
+    status: MigrationStatus;
+    /** Direction executed */
+    direction: MigrationDirection;
+    /** Executed at timestamp */
+    executedAt: Date | string;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Error message (if failed) */
+    error?: string;
+    /** SQL statements executed */
+    statements?: string[];
+}
+/**
+ * Migration history entry
+ */
+export interface IMigrationHistory {
+    /** Migration tag */
+    tag: string;
+    /** Migration name */
+    name: 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;
+    /** Status */
+    status: MigrationStatus;
+    /** Last direction executed */
+    direction: MigrationDirection;
+    /** Applied at timestamp */
+    appliedAt: Date | string;
+    /** Duration in milliseconds */
+    duration?: number;
+    /** Error details (if failed) */
+    error?: {
+        message: string;
+        stack?: string;
+    };
+    /** Batch number (for grouping migrations) */
+    batch?: number;
+}
+/**
+ * Migration generation options
+ */
+export interface IMigrationGenerationOptions {
+    /** Migration name */
+    name: string;
+    /** Table name (if applicable) */
+    table?: string;
+    /** Description */
+    description?: string;
+    /** Auto-generate based on schema changes */
+    autoGenerate?: boolean;
+    /** Include timestamp in filename */
+    timestamp?: boolean;
+}
+/**
+ * Migration execution options
+ */
+export interface IMigrationExecutionOptions {
+    /** 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;
+    /** Run specific migration tag */
+    tag?: string;
+    /** Run up to specific migration */
+    to?: string;
+    /** Batch mode */
+    batch?: boolean;
+    /** Dry run (don't execute, just show what would run) */
+    dryRun?: boolean;
+    /** Force execution even if migration already ran */
+    force?: boolean;
+}
+/**
+ * Migration rollback options
+ */
+export interface IMigrationRollbackOptions {
+    /** 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;
+    /** Rollback specific migration */
+    tag?: string;
+    /** Rollback last N migrations */
+    steps?: number;
+    /** Rollback last batch */
+    batch?: boolean;
+    /** Dry run */
+    dryRun?: boolean;
+}
+/**
+ * Pending migration info
+ */
+export interface IPendingMigration {
+    /** Migration tag */
+    tag: string;
+    /** Migration name */
+    name: string;
+    /** Description */
+    description?: string;
+    /** Created at */
+    createdAt: Date | string;
+    /** Dependencies */
+    dependencies?: string[];
+}
+/**
+ * Migration status summary
+ */
+export interface IMigrationStatus {
+    /** Total migrations */
+    total: number;
+    /** Completed migrations */
+    completed: number;
+    /** Pending migrations */
+    pending: number;
+    /** Failed migrations */
+    failed: number;
+    /** Last migration applied */
+    lastApplied?: IMigrationHistory;
+    /** Pending migrations list */
+    pendingMigrations: IPendingMigration[];
+}

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

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Migration type definitions for database schema versioning
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationOperationType = exports.MigrationDirection = exports.MigrationStatus = void 0;
+/**
+ * Migration status
+ */
+var MigrationStatus;
+(function (MigrationStatus) {
+    MigrationStatus["PENDING"] = "pending";
+    MigrationStatus["RUNNING"] = "running";
+    MigrationStatus["COMPLETED"] = "completed";
+    MigrationStatus["FAILED"] = "failed";
+    MigrationStatus["ROLLED_BACK"] = "rolled_back";
+})(MigrationStatus || (exports.MigrationStatus = MigrationStatus = {}));
+/**
+ * Migration direction
+ */
+var MigrationDirection;
+(function (MigrationDirection) {
+    MigrationDirection["UP"] = "up";
+    MigrationDirection["DOWN"] = "down";
+})(MigrationDirection || (exports.MigrationDirection = MigrationDirection = {}));
+/**
+ * Migration operation type
+ */
+var MigrationOperationType;
+(function (MigrationOperationType) {
+    MigrationOperationType["CREATE_TABLE"] = "create_table";
+    MigrationOperationType["DROP_TABLE"] = "drop_table";
+    MigrationOperationType["ALTER_TABLE"] = "alter_table";
+    MigrationOperationType["ADD_COLUMN"] = "add_column";
+    MigrationOperationType["DROP_COLUMN"] = "drop_column";
+    MigrationOperationType["MODIFY_COLUMN"] = "modify_column";
+    MigrationOperationType["RENAME_COLUMN"] = "rename_column";
+    MigrationOperationType["ADD_INDEX"] = "add_index";
+    MigrationOperationType["DROP_INDEX"] = "drop_index";
+    MigrationOperationType["ADD_CONSTRAINT"] = "add_constraint";
+    MigrationOperationType["DROP_CONSTRAINT"] = "drop_constraint";
+    MigrationOperationType["RAW_SQL"] = "raw_sql";
+})(MigrationOperationType || (exports.MigrationOperationType = MigrationOperationType = {}));
+//# sourceMappingURL=migration.types.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"migration.types.js","sourceRoot":"","sources":["../../../src/database/types/migration.types.ts"],"names":[],"mappings":";AAAA;;GAEG;;;AAEH;;GAEG;AACH,IAAY,eAMX;AAND,WAAY,eAAe;IACzB,sCAAmB,CAAA;IACnB,sCAAmB,CAAA;IACnB,0CAAuB,CAAA;IACvB,oCAAiB,CAAA;IACjB,8CAA2B,CAAA;AAC7B,CAAC,EANW,eAAe,+BAAf,eAAe,QAM1B;AAED;;GAEG;AACH,IAAY,kBAGX;AAHD,WAAY,kBAAkB;IAC5B,+BAAS,CAAA;IACT,mCAAa,CAAA;AACf,CAAC,EAHW,kBAAkB,kCAAlB,kBAAkB,QAG7B;AAED;;GAEG;AACH,IAAY,sBAaX;AAbD,WAAY,sBAAsB;IAChC,uDAA6B,CAAA;IAC7B,mDAAyB,CAAA;IACzB,qDAA2B,CAAA;IAC3B,mDAAyB,CAAA;IACzB,qDAA2B,CAAA;IAC3B,yDAA+B,CAAA;IAC/B,yDAA+B,CAAA;IAC/B,iDAAuB,CAAA;IACvB,mDAAyB,CAAA;IACzB,2DAAiC,CAAA;IACjC,6DAAmC,CAAA;IACnC,6CAAmB,CAAA;AACrB,CAAC,EAbW,sBAAsB,sCAAtB,sBAAsB,QAajC"}

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

@@ -0,0 +1,305 @@
+/**
+ * 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;
+}
+/**
+ * Include options for relationship lookups
+ */
+export interface IInclude {
+    /** Relationship name/table to include */
+    relation: string;
+    /** Fields to select from the related table */
+    select?: string[];
+    /** Where clause for the related table */
+    where?: WhereClause;
+    /** Nested includes (for deep relationships) */
+    include?: IInclude | IInclude[];
+    /** Limit results from the relationship */
+    limit?: number;
+    /** Order results from the relationship */
+    orderBy?: IOrderBy | IOrderBy[];
+    /** Foreign key column in the main table (defaults to relation_id) */
+    foreignKey?: string;
+    /** Primary key column in the related table (defaults to id) */
+    primaryKey?: string;
+    /** Relationship type */
+    type?: 'one-to-one' | 'one-to-many' | 'many-to-one' | 'many-to-many';
+    /** For many-to-many: junction table name */
+    through?: string;
+    /** For many-to-many: foreign key in junction table pointing to main table */
+    throughForeignKey?: string;
+    /** For many-to-many: foreign key in junction table pointing to related table */
+    throughRelatedKey?: string;
+}
+/**
+ * Query options
+ */
+export interface IQueryOptions {
+    /** Table/Collection 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;
+    /** 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[];
+    /** Include related data (relationship lookups) */
+    include?: IInclude | IInclude[];
+    /** 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 (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;
+    /** 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 (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;
+    /** 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 (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;
+    /** 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 (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;
+    /** 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 (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;
+    /** 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 (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;
+    /** 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"}