@ductape/sdk 0.0.4-v51 → 0.0.4-v52

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

@@ -0,0 +1,686 @@
+/**
+ * Migration-related type definitions
+ *
+ * Platform-independent migrations that work across SQL and NoSQL databases.
+ * Migrations are translated to database-specific operations by adapters.
+ */
+import { IndexType } from './enums';
+import { IConnectionConfig } from './connection.interface';
+import { IIndexDefinition, IAlterTableOperation } from './schema.interface';
+/**
+ * Migration definition
+ * Platform-independent - works across all supported databases
+ */
+export interface IMigration {
+    /** Unique migration tag */
+    tag: string;
+    /** Human-readable name */
+    name: string;
+    /** Description of what this migration does */
+    description?: string;
+    /** Operations to apply (up migration) */
+    up: IMigrationOperation[];
+    /** Operations to rollback (down migration) */
+    down: IMigrationOperation[];
+    /** Dependencies - migrations that must run first */
+    dependencies?: string[];
+    /** Timestamp when migration was created */
+    createdAt?: Date;
+}
+/**
+ * Types of migration operations
+ * Unified across SQL and NoSQL databases
+ */
+export type IMigrationOperation = ICreateCollectionMigration | IDropCollectionMigration | ICreateIndexMigration | IDropIndexMigration | IAddFieldMigration | IDropFieldMigration | IRenameFieldMigration | IModifyFieldMigration | IAddConstraintMigration | IDropConstraintMigration | ICreateMongoValidationMigration | IDropMongoValidationMigration | IShardCollectionMigration | ICreateDynamoTableMigration | IUpdateDynamoThroughputMigration | IAddDynamoGSIMigration | IRemoveDynamoGSIMigration | IEnableDynamoStreamMigration | IEnableDynamoTTLMigration | IAlterCassandraTableMigration | ICreateCassandraMaterializedViewMigration | IDropCassandraMaterializedViewMigration | IRawOperationMigration;
+/**
+ * Create collection/table migration
+ * Works for: SQL tables, MongoDB collections, DynamoDB tables, Cassandra tables
+ */
+export interface ICreateCollectionMigration {
+    type: 'createCollection';
+    /** Collection/table name */
+    name: string;
+    /** Field/column definitions */
+    fields: IFieldDefinition[];
+    /** Index definitions */
+    indexes?: IIndexDefinition[];
+    /** Only create if doesn't exist */
+    ifNotExists?: boolean;
+    /** SQL-specific: table options */
+    sqlOptions?: {
+        /** Primary key columns (for composite keys) */
+        primaryKey?: string[];
+        /** Constraints */
+        constraints?: IConstraintDefinition[];
+        /** Temporary table */
+        temporary?: boolean;
+        /** Unlogged table (PostgreSQL) */
+        unlogged?: boolean;
+    };
+    /** MongoDB-specific options */
+    mongoOptions?: {
+        /** Capped collection */
+        capped?: boolean;
+        /** Max size in bytes (for capped) */
+        size?: number;
+        /** Max documents (for capped) */
+        max?: number;
+        /** Validation rules */
+        validator?: object;
+        /** Validation level */
+        validationLevel?: 'off' | 'strict' | 'moderate';
+    };
+    /** DynamoDB-specific options */
+    dynamoOptions?: {
+        /** Partition key */
+        partitionKey: {
+            name: string;
+            type: 'S' | 'N' | 'B';
+        };
+        /** Sort key (optional) */
+        sortKey?: {
+            name: string;
+            type: 'S' | 'N' | 'B';
+        };
+        /** Billing mode */
+        billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST';
+        /** Read capacity units (for PROVISIONED) */
+        readCapacity?: number;
+        /** Write capacity units (for PROVISIONED) */
+        writeCapacity?: number;
+        /** Global secondary indexes */
+        globalSecondaryIndexes?: IDynamoGSI[];
+        /** Local secondary indexes */
+        localSecondaryIndexes?: IDynamoLSI[];
+        /** Enable streams */
+        streamEnabled?: boolean;
+        /** Stream view type */
+        streamViewType?: 'KEYS_ONLY' | 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES';
+    };
+    /** Cassandra-specific options */
+    cassandraOptions?: {
+        /** Partition key columns */
+        partitionKey: string[];
+        /** Clustering columns */
+        clusteringColumns?: string[];
+        /** Clustering order */
+        clusteringOrder?: {
+            column: string;
+            order: 'ASC' | 'DESC';
+        }[];
+        /** Compaction strategy */
+        compaction?: object;
+        /** Compression options */
+        compression?: object;
+        /** TTL in seconds */
+        defaultTTL?: number;
+    };
+}
+/**
+ * Drop collection/table migration
+ */
+export interface IDropCollectionMigration {
+    type: 'dropCollection';
+    /** Collection/table name */
+    name: string;
+    /** Only drop if exists */
+    ifExists?: boolean;
+    /** Cascade to dependent objects (SQL) */
+    cascade?: boolean;
+}
+/**
+ * Platform-independent field/column definition
+ */
+export interface IFieldDefinition {
+    /** Field name */
+    name: string;
+    /**
+     * Field type - platform independent
+     * Use abstract types that map to each database's native types
+     */
+    type: FieldType;
+    /** Minimum length for string types (validation constraint) */
+    minLength?: number;
+    /** Maximum length for string types (database column size) */
+    maxLength?: number;
+    /** Precision (for decimal) */
+    precision?: number;
+    /** Scale (for decimal) */
+    scale?: number;
+    /** Allow null values */
+    nullable?: boolean;
+    /** Primary key */
+    primaryKey?: boolean;
+    /** Auto increment/generated */
+    autoGenerate?: boolean;
+    /** Unique constraint */
+    unique?: boolean;
+    /** Default value */
+    defaultValue?: any;
+    /** Enum values (for enum type) */
+    enumValues?: string[];
+    /** Array element type */
+    arrayElementType?: FieldType;
+    /** Nested object schema (for document DBs) */
+    nestedSchema?: IFieldDefinition[];
+    /** Field comment/description */
+    comment?: string;
+}
+/**
+ * Platform-independent field types
+ * These are translated to database-specific types by adapters
+ */
+export type FieldType = 'integer' | 'bigint' | 'smallint' | 'decimal' | 'float' | 'double' | 'string' | 'text' | 'uuid' | 'boolean' | 'date' | 'time' | 'datetime' | 'timestamp' | 'binary' | 'blob' | 'json' | 'object' | 'array' | 'enum' | 'any';
+/**
+ * Create index migration
+ * Works for all databases with index support
+ */
+export interface ICreateIndexMigration {
+    type: 'createIndex';
+    /** Collection/table name */
+    collection: string;
+    /** Index name */
+    name: string;
+    /** Fields to index */
+    fields: IIndexFieldDefinition[];
+    /** Unique index */
+    unique?: boolean;
+    /** Sparse index (skip null values) */
+    sparse?: boolean;
+    /** Only create if doesn't exist */
+    ifNotExists?: boolean;
+    /** SQL-specific options */
+    sqlOptions?: {
+        /** Index method (BTREE, HASH, GIN, GIST, etc.) */
+        method?: IndexType | string;
+        /** Partial index condition */
+        where?: string;
+        /** Include columns (covering index) */
+        include?: string[];
+        /** Create concurrently (no lock) */
+        concurrent?: boolean;
+    };
+    /** MongoDB-specific options */
+    mongoOptions?: {
+        /** Background build */
+        background?: boolean;
+        /** TTL in seconds (for date fields) */
+        expireAfterSeconds?: number;
+        /** Text index weights */
+        weights?: Record<string, number>;
+        /** 2dsphere index options */
+        '2dsphereIndexVersion'?: number;
+    };
+    /** Cassandra-specific options */
+    cassandraOptions?: {
+        /** SASI index options */
+        sasiOptions?: {
+            mode?: 'PREFIX' | 'CONTAINS' | 'SPARSE';
+            analyzerClass?: string;
+            caseSensitive?: boolean;
+        };
+    };
+}
+/**
+ * Index field definition
+ */
+export interface IIndexFieldDefinition {
+    /** Field name */
+    name: string;
+    /** Sort order */
+    order?: 'asc' | 'desc';
+    /** Index type for this field (MongoDB: text, 2dsphere, etc.) */
+    type?: string;
+}
+/**
+ * Drop index migration
+ */
+export interface IDropIndexMigration {
+    type: 'dropIndex';
+    /** Collection/table name */
+    collection: string;
+    /** Index name */
+    name: string;
+    /** Only drop if exists */
+    ifExists?: boolean;
+    /** Drop concurrently (SQL) */
+    concurrent?: boolean;
+}
+/**
+ * Add field/column migration
+ */
+export interface IAddFieldMigration {
+    type: 'addField';
+    /** Collection/table name */
+    collection: string;
+    /** Field definition */
+    field: IFieldDefinition;
+}
+/**
+ * Drop field/column migration
+ */
+export interface IDropFieldMigration {
+    type: 'dropField';
+    /** Collection/table name */
+    collection: string;
+    /** Field name */
+    fieldName: string;
+    /** Cascade (SQL) */
+    cascade?: boolean;
+}
+/**
+ * Rename field/column migration
+ */
+export interface IRenameFieldMigration {
+    type: 'renameField';
+    /** Collection/table name */
+    collection: string;
+    /** Current field name */
+    oldName: string;
+    /** New field name */
+    newName: string;
+}
+/**
+ * Modify field/column migration
+ */
+export interface IModifyFieldMigration {
+    type: 'modifyField';
+    /** Collection/table name */
+    collection: string;
+    /** Field name */
+    fieldName: string;
+    /** New field definition (partial - only changed properties) */
+    changes: Partial<IFieldDefinition>;
+}
+/**
+ * Constraint definition
+ */
+export interface IConstraintDefinition {
+    /** Constraint name */
+    name: string;
+    /** Constraint type */
+    type: 'primaryKey' | 'foreignKey' | 'unique' | 'check';
+    /** Columns involved */
+    columns: string[];
+    /** Foreign key reference */
+    references?: {
+        table: string;
+        columns: string[];
+        onDelete?: 'CASCADE' | 'SET_NULL' | 'SET_DEFAULT' | 'RESTRICT' | 'NO_ACTION';
+        onUpdate?: 'CASCADE' | 'SET_NULL' | 'SET_DEFAULT' | 'RESTRICT' | 'NO_ACTION';
+    };
+    /** Check expression */
+    expression?: string;
+}
+/**
+ * Add constraint migration (SQL only)
+ */
+export interface IAddConstraintMigration {
+    type: 'addConstraint';
+    /** Table name */
+    collection: string;
+    /** Constraint definition */
+    constraint: IConstraintDefinition;
+}
+/**
+ * Drop constraint migration (SQL only)
+ */
+export interface IDropConstraintMigration {
+    type: 'dropConstraint';
+    /** Table name */
+    collection: string;
+    /** Constraint name */
+    constraintName: string;
+    /** Cascade */
+    cascade?: boolean;
+}
+/**
+ * Create/update MongoDB validation schema
+ */
+export interface ICreateMongoValidationMigration {
+    type: 'createMongoValidation';
+    /** Collection name */
+    collection: string;
+    /** JSON Schema validator */
+    validator: object;
+    /** Validation level */
+    validationLevel?: 'off' | 'strict' | 'moderate';
+    /** Validation action */
+    validationAction?: 'error' | 'warn';
+}
+/**
+ * Remove MongoDB validation schema
+ */
+export interface IDropMongoValidationMigration {
+    type: 'dropMongoValidation';
+    /** Collection name */
+    collection: string;
+}
+/**
+ * Shard a MongoDB collection
+ */
+export interface IShardCollectionMigration {
+    type: 'shardCollection';
+    /** Collection name */
+    collection: string;
+    /** Shard key */
+    shardKey: Record<string, 1 | -1 | 'hashed'>;
+    /** Unique shard key */
+    unique?: boolean;
+}
+/**
+ * DynamoDB Global Secondary Index definition
+ */
+export interface IDynamoGSI {
+    /** Index name */
+    name: string;
+    /** Partition key */
+    partitionKey: {
+        name: string;
+        type: 'S' | 'N' | 'B';
+    };
+    /** Sort key */
+    sortKey?: {
+        name: string;
+        type: 'S' | 'N' | 'B';
+    };
+    /** Projection type */
+    projection: 'ALL' | 'KEYS_ONLY' | {
+        type: 'INCLUDE';
+        attributes: string[];
+    };
+    /** Read capacity */
+    readCapacity?: number;
+    /** Write capacity */
+    writeCapacity?: number;
+}
+/**
+ * DynamoDB Local Secondary Index definition
+ */
+export interface IDynamoLSI {
+    /** Index name */
+    name: string;
+    /** Sort key (partition key inherited from table) */
+    sortKey: {
+        name: string;
+        type: 'S' | 'N' | 'B';
+    };
+    /** Projection type */
+    projection: 'ALL' | 'KEYS_ONLY' | {
+        type: 'INCLUDE';
+        attributes: string[];
+    };
+}
+/**
+ * Create DynamoDB table (alternative to createCollection for more control)
+ */
+export interface ICreateDynamoTableMigration {
+    type: 'createDynamoTable';
+    /** Table name */
+    name: string;
+    /** Partition key */
+    partitionKey: {
+        name: string;
+        type: 'S' | 'N' | 'B';
+    };
+    /** Sort key */
+    sortKey?: {
+        name: string;
+        type: 'S' | 'N' | 'B';
+    };
+    /** Billing mode */
+    billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST';
+    /** Read capacity units */
+    readCapacity?: number;
+    /** Write capacity units */
+    writeCapacity?: number;
+    /** Global secondary indexes */
+    globalSecondaryIndexes?: IDynamoGSI[];
+    /** Local secondary indexes */
+    localSecondaryIndexes?: IDynamoLSI[];
+    /** Enable streams */
+    streamEnabled?: boolean;
+    /** Stream view type */
+    streamViewType?: 'KEYS_ONLY' | 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES';
+    /** Enable point-in-time recovery */
+    pointInTimeRecovery?: boolean;
+    /** Server-side encryption */
+    sseEnabled?: boolean;
+}
+/**
+ * Update DynamoDB table throughput
+ */
+export interface IUpdateDynamoThroughputMigration {
+    type: 'updateDynamoThroughput';
+    /** Table name */
+    name: string;
+    /** New read capacity */
+    readCapacity?: number;
+    /** New write capacity */
+    writeCapacity?: number;
+    /** Switch to on-demand */
+    billingMode?: 'PROVISIONED' | 'PAY_PER_REQUEST';
+}
+/**
+ * Add DynamoDB Global Secondary Index
+ */
+export interface IAddDynamoGSIMigration {
+    type: 'addDynamoGSI';
+    /** Table name */
+    tableName: string;
+    /** GSI definition */
+    gsi: IDynamoGSI;
+}
+/**
+ * Remove DynamoDB Global Secondary Index
+ */
+export interface IRemoveDynamoGSIMigration {
+    type: 'removeDynamoGSI';
+    /** Table name */
+    tableName: string;
+    /** GSI name */
+    gsiName: string;
+}
+/**
+ * Enable DynamoDB Streams
+ */
+export interface IEnableDynamoStreamMigration {
+    type: 'enableDynamoStream';
+    /** Table name */
+    tableName: string;
+    /** Stream view type */
+    streamViewType: 'KEYS_ONLY' | 'NEW_IMAGE' | 'OLD_IMAGE' | 'NEW_AND_OLD_IMAGES';
+}
+/**
+ * Enable DynamoDB TTL
+ */
+export interface IEnableDynamoTTLMigration {
+    type: 'enableDynamoTTL';
+    /** Table name */
+    tableName: string;
+    /** TTL attribute name */
+    attributeName: string;
+    /** Enable or disable */
+    enabled: boolean;
+}
+/**
+ * Alter Cassandra table options
+ */
+export interface IAlterCassandraTableMigration {
+    type: 'alterCassandraTable';
+    /** Table name */
+    name: string;
+    /** New options */
+    options: {
+        /** Default TTL */
+        defaultTTL?: number;
+        /** Compaction options */
+        compaction?: object;
+        /** Compression options */
+        compression?: object;
+        /** Caching options */
+        caching?: object;
+        /** GC grace seconds */
+        gcGraceSeconds?: number;
+    };
+}
+/**
+ * Create Cassandra materialized view
+ */
+export interface ICreateCassandraMaterializedViewMigration {
+    type: 'createCassandraMaterializedView';
+    /** View name */
+    name: string;
+    /** Base table */
+    baseTable: string;
+    /** Selected columns */
+    columns: string[];
+    /** Where clause (required for MV) */
+    where: string;
+    /** Partition key */
+    partitionKey: string[];
+    /** Clustering columns */
+    clusteringColumns?: string[];
+}
+/**
+ * Drop Cassandra materialized view
+ */
+export interface IDropCassandraMaterializedViewMigration {
+    type: 'dropCassandraMaterializedView';
+    /** View name */
+    name: string;
+    /** Only drop if exists */
+    ifExists?: boolean;
+}
+/**
+ * Raw operation for database-specific commands
+ * Use sparingly - prefer platform-independent operations
+ */
+export interface IRawOperationMigration {
+    type: 'raw';
+    /** Target database types (leave empty for all) */
+    databases?: ('postgresql' | 'mysql' | 'mariadb' | 'mongodb' | 'dynamodb' | 'cassandra')[];
+    /** Operations per database type */
+    operations: {
+        /** PostgreSQL raw SQL */
+        postgresql?: {
+            sql: string;
+            params?: any[];
+        };
+        /** MySQL raw SQL */
+        mysql?: {
+            sql: string;
+            params?: any[];
+        };
+        /** MariaDB raw SQL */
+        mariadb?: {
+            sql: string;
+            params?: any[];
+        };
+        /** MongoDB command */
+        mongodb?: {
+            command: object;
+        };
+        /** DynamoDB operation */
+        dynamodb?: {
+            operation: string;
+            params: object;
+        };
+        /** Cassandra CQL */
+        cassandra?: {
+            cql: string;
+            params?: any[];
+        };
+    };
+}
+/**
+ * Migration history entry
+ */
+export interface IMigrationHistory {
+    /** Migration tag */
+    tag: string;
+    /** Migration name */
+    name: string;
+    /** When migration was applied */
+    appliedAt: Date;
+    /** Who applied the migration */
+    appliedBy?: string;
+    /** Checksum for verification */
+    checksum?: string;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+    /** Environment where applied */
+    environment?: string;
+}
+/**
+ * Options for getting migration status
+ */
+export interface IMigrationStatusOptions extends IConnectionConfig {
+    /** All defined migrations to check against */
+    definedMigrations: IMigration[];
+}
+/**
+ * Migration status result
+ */
+export interface IMigrationStatusResult {
+    /** Total number of defined migrations */
+    total: number;
+    /** Number of applied migrations */
+    completed: number;
+    /** Number of pending migrations */
+    pending: number;
+    /** Last applied migration */
+    lastApplied?: IMigrationHistory;
+    /** List of pending migration tags */
+    pendingMigrations: string[];
+    /** List of applied migration tags */
+    appliedMigrations: string[];
+}
+/**
+ * Result of running a migration
+ */
+export interface IMigrationResult {
+    /** Whether migration was successful */
+    success: boolean;
+    /** Operations executed */
+    operations: string[];
+    /** Error message if failed */
+    error?: string;
+    /** Execution time in milliseconds */
+    executionTime?: number;
+}
+/** @deprecated Use ICreateCollectionMigration */
+export type ICreateTableMigration = ICreateCollectionMigration;
+/** @deprecated Use IDropCollectionMigration */
+export type IDropTableMigration = IDropCollectionMigration;
+/** @deprecated Use IAddFieldMigration */
+export type IAddColumnMigration = IAddFieldMigration;
+/** @deprecated Use IDropFieldMigration */
+export type IDropColumnMigration = IDropFieldMigration;
+/** @deprecated Use IRenameFieldMigration */
+export type IRenameColumnMigration = IRenameFieldMigration;
+/** @deprecated Use IModifyFieldMigration with collection instead */
+export interface IAlterTableMigration {
+    type: 'alterTable';
+    tableName: string;
+    operations: IAlterTableOperation[];
+}
+/** @deprecated Use IRawOperationMigration */
+export interface IRawSqlMigration {
+    type: 'rawSql';
+    sql: string;
+    params?: any[];
+}
+/**
+ * Helper function signatures for creating migrations
+ */
+export interface IMigrationHelpers {
+    /** Create a collection/table migration */
+    createCollectionMigration(tag: string, name: string, fields: IFieldDefinition[]): IMigration;
+    /** Create an add field migration */
+    addFieldMigration(tag: string, collection: string, field: IFieldDefinition): IMigration;
+    /** Create an add index migration */
+    addIndexMigration(tag: string, collection: string, indexName: string, fields: string[], unique?: boolean): IMigration;
+    /** Generate a migration tag with timestamp */
+    generateMigrationTag(name: string): string;
+}

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

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Migration-related type definitions
+ *
+ * Platform-independent migrations that work across SQL and NoSQL databases.
+ * Migrations are translated to database-specific operations by adapters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=migration.interface.js.map

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

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