ts-prorm-orm 1.1.0

package/dist/streams/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Stream utilities for ORM operations
+ * Provides transform streams for streaming data processing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamIterator = exports.BatchTransform = exports.FilterTransform = exports.MapTransform = void 0;
+var transforms_1 = require("./transforms");
+Object.defineProperty(exports, "MapTransform", { enumerable: true, get: function () { return transforms_1.MapTransform; } });
+Object.defineProperty(exports, "FilterTransform", { enumerable: true, get: function () { return transforms_1.FilterTransform; } });
+Object.defineProperty(exports, "BatchTransform", { enumerable: true, get: function () { return transforms_1.BatchTransform; } });
+Object.defineProperty(exports, "StreamIterator", { enumerable: true, get: function () { return transforms_1.StreamIterator; } });

package/dist/streams/transforms.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * Transform streams for ORM operations
+ * Provides MapTransform and FilterTransform for streaming data processing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamIterator = exports.BatchTransform = exports.FilterTransform = exports.MapTransform = void 0;
+const stream_1 = require("stream");
+/**
+ * Transform stream that maps each record through a transform function
+ * Supports both synchronous and asynchronous transform functions
+ */
+class MapTransform extends stream_1.Transform {
+    constructor(options) {
+        super({
+            objectMode: true,
+            highWaterMark: options.highWaterMark || 1000,
+        });
+        this.mapFn = options.mapFn;
+    }
+    /**
+     * Transform a chunk (record)
+     */
+    async _transform(record, encoding, callback) {
+        try {
+            const result = await this.mapFn(record);
+            callback(null, result);
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+}
+exports.MapTransform = MapTransform;
+/**
+ * Transform stream that filters records based on a predicate function
+ * Supports both synchronous and asynchronous filter functions
+ */
+class FilterTransform extends stream_1.Transform {
+    constructor(options) {
+        super({
+            objectMode: true,
+            highWaterMark: options.highWaterMark || 1000,
+        });
+        this.filterFn = options.filterFn;
+    }
+    /**
+     * Transform and filter a chunk (record)
+     */
+    async _transform(record, encoding, callback) {
+        try {
+            const shouldInclude = await this.filterFn(record);
+            if (shouldInclude) {
+                callback(null, record);
+            }
+            else {
+                // Skip this record but don't end the stream
+                callback(null);
+            }
+        }
+        catch (error) {
+            callback(error);
+        }
+    }
+}
+exports.FilterTransform = FilterTransform;
+/**
+ * Transform stream that batches records into arrays
+ */
+class BatchTransform extends stream_1.Transform {
+    constructor(options) {
+        super({
+            objectMode: true,
+            highWaterMark: options.highWaterMark || 1000,
+        });
+        this.buffer = [];
+        this.batchSize = options.batchSize;
+    }
+    /**
+     * Transform - batch records
+     */
+    _transform(record, encoding, callback) {
+        this.buffer.push(record);
+        if (this.buffer.length >= this.batchSize) {
+            const batch = this.buffer.slice();
+            this.buffer = [];
+            callback(null, batch);
+        }
+        else {
+            callback(null);
+        }
+    }
+    /**
+     * Flush remaining records in buffer
+     */
+    _flush(callback) {
+        if (this.buffer.length > 0) {
+            callback(null, this.buffer.slice());
+        }
+        else {
+            callback(null);
+        }
+    }
+}
+exports.BatchTransform = BatchTransform;
+/**
+ * Transform stream that converts a readable stream into an async iterator
+ * Allows using stream.pipe(new StreamIterator()) and then for await...of
+ */
+class StreamIterator extends stream_1.Transform {
+    constructor(options) {
+        super({
+            objectMode: true,
+            highWaterMark: options?.highWaterMark || 1000,
+        });
+        this.buffer = [];
+        this.waiting = [];
+        this.ended = false;
+        this.error = null;
+    }
+    /**
+     * Transform a chunk
+     */
+    _transform(chunk, encoding, callback) {
+        const record = chunk;
+        this.buffer.push(record);
+        this._processWaiting();
+        callback(null);
+    }
+    /**
+     * Handle stream end
+     */
+    _flush(callback) {
+        this.ended = true;
+        this._processWaiting();
+        callback(null);
+    }
+    /**
+     * Process waiting promises
+     */
+    _processWaiting() {
+        while (this.waiting.length > 0 && this.buffer.length > 0) {
+            const record = this.buffer.shift();
+            const waiter = this.waiting.shift();
+            waiter({ value: record, done: false });
+        }
+        // If stream ended and no more data
+        if (this.ended && this.buffer.length === 0) {
+            while (this.waiting.length > 0) {
+                const waiter = this.waiting.shift();
+                waiter({ value: undefined, done: true });
+            }
+        }
+    }
+    /**
+     * Create async iterator from this transform stream
+     */
+    [Symbol.asyncIterator]() {
+        const self = this;
+        return {
+            next() {
+                return new Promise((resolve) => {
+                    if (self.buffer.length > 0) {
+                        const record = self.buffer.shift();
+                        resolve({ value: record, done: false });
+                    }
+                    else if (self.ended) {
+                        resolve({ value: undefined, done: true });
+                    }
+                    else {
+                        self.waiting.push(resolve);
+                    }
+                });
+            },
+        };
+    }
+}
+exports.StreamIterator = StreamIterator;

package/dist/transaction.js

@@ -0,0 +1,456 @@
+"use strict";
+/**
+ * Transaction Support
+ * Provides transaction management with commit and rollback functionality
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TransactionWrapper = exports.TransactionManager = exports.Transaction = exports.defaultTransactionOptions = exports.IsolationLevels = exports.TransactionState = void 0;
+exports.createTransaction = createTransaction;
+exports.createTransactionManager = createTransactionManager;
+/**
+ * Transaction states
+ */
+var TransactionState;
+(function (TransactionState) {
+    /** Transaction has not started yet */
+    TransactionState["STARTED"] = "started";
+    /** Transaction is currently active */
+    TransactionState["ACTIVE"] = "active";
+    /** Transaction has been committed */
+    TransactionState["COMMITTED"] = "committed";
+    /** Transaction has been rolled back */
+    TransactionState["ROLLED_BACK"] = "rolled_back";
+})(TransactionState || (exports.TransactionState = TransactionState = {}));
+/**
+ * Transaction isolation levels with their SQL representations
+ */
+exports.IsolationLevels = {
+    'READ UNCOMMITTED': 'READ UNCOMMITTED',
+    'READ COMMITTED': 'READ COMMITTED',
+    'REPEATABLE READ': 'REPEATABLE READ',
+    SERIALIZABLE: 'SERIALIZABLE',
+};
+/**
+ * Default transaction options
+ */
+exports.defaultTransactionOptions = {
+    autocommit: true,
+    isolationLevel: 'REPEATABLE READ',
+    type: 'DEFERRED',
+    deferrable: '',
+    lock: false,
+};
+/**
+ * Savepoint naming strategy
+ */
+let savepointCounter = 0;
+/**
+ * Generate a unique savepoint name
+ */
+function generateSavepointName() {
+    return `sp_${Date.now()}_${++savepointCounter}`;
+}
+/**
+ * Transaction class for managing database transactions
+ * Supports savepoints, commit, rollback, and isolation levels
+ */
+class Transaction {
+    /**
+     * Create a new transaction
+     * @param options - Transaction configuration options
+     */
+    constructor(options = {}) {
+        /** Current state of the transaction */
+        this.state = TransactionState.STARTED;
+        /** Parent transaction (for nested transactions/savepoints) */
+        this.parent = null;
+        /** Child transactions/savepoints */
+        this.children = [];
+        this.id = `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        this.startedAt = new Date();
+        this.options = {
+            ...exports.defaultTransactionOptions,
+            ...options,
+        };
+        this.savepointName = generateSavepointName();
+        this.isSavepoint = false;
+        this.depth = 0;
+    }
+    /**
+     * Private constructor for creating savepoints
+     */
+    static createSavepoint(parent, options) {
+        const savepoint = Object.create(Transaction.prototype);
+        savepoint.id = `txn_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+        savepoint.startedAt = new Date();
+        savepoint.options = {
+            ...exports.defaultTransactionOptions,
+            ...options,
+        };
+        savepoint.savepointName = generateSavepointName();
+        savepoint.parent = parent;
+        savepoint.isSavepoint = true;
+        savepoint.depth = parent.depth + 1;
+        savepoint.state = TransactionState.STARTED;
+        savepoint.children = [];
+        savepoint.id = `${parent.id}.${savepoint.depth}`;
+        savepoint.finishedAt = undefined;
+        parent.children.push(savepoint);
+        return savepoint;
+    }
+    /**
+     * Check if the transaction is active
+     */
+    get isActive() {
+        return this.state === TransactionState.STARTED || this.state === TransactionState.ACTIVE;
+    }
+    /**
+     * Check if the transaction is finished (committed or rolled back)
+     */
+    get isFinished() {
+        return this.state === TransactionState.COMMITTED || this.state === TransactionState.ROLLED_BACK;
+    }
+    /**
+     * Check if the transaction was committed
+     */
+    get isCommitted() {
+        return this.state === TransactionState.COMMITTED;
+    }
+    /**
+     * Check if the transaction was rolled back
+     */
+    get isRolledBack() {
+        return this.state === TransactionState.ROLLED_BACK;
+    }
+    /**
+     * Get the isolation level SQL
+     */
+    getIsolationLevelSql() {
+        const level = this.options.isolationLevel
+            ? exports.IsolationLevels[this.options.isolationLevel]
+            : undefined;
+        return level ? `ISOLATION LEVEL ${level}` : '';
+    }
+    /**
+     * Get the transaction type SQL
+     */
+    getTransactionTypeSql() {
+        if (this.options.type) {
+            return this.options.type;
+        }
+        return '';
+    }
+    /**
+     * Create a savepoint within the transaction
+     * @param options - Savepoint options
+     */
+    createSavepoint(options) {
+        if (!this.isActive) {
+            throw new Error(`Cannot create savepoint: Transaction is ${this.state}`);
+        }
+        return Transaction.createSavepoint(this, options);
+    }
+    /**
+     * Create a named savepoint and return its name
+     * @param name - Optional custom savepoint name
+     * @returns The savepoint name
+     */
+    savepoint(name) {
+        if (!this.isActive) {
+            throw new Error(`Cannot create savepoint: Transaction is ${this.state}`);
+        }
+        const savepointName = name || generateSavepointName();
+        return savepointName;
+    }
+    /**
+     * Release a savepoint
+     * @param name - The savepoint name to release
+     */
+    async releaseSavepoint(name) {
+        if (!this.isActive) {
+            throw new Error(`Cannot release savepoint: Transaction is ${this.state}`);
+        }
+        // Savepoint release is handled at the database level
+        // This is a placeholder for database-specific implementation
+    }
+    /**
+     * Rollback to a savepoint
+     * @param name - The savepoint name to rollback to
+     */
+    async rollbackToSavepoint(name) {
+        if (!this.isActive) {
+            throw new Error(`Cannot rollback to savepoint: Transaction is ${this.state}`);
+        }
+        // Savepoint rollback is handled at the database level
+        // This is a placeholder for database-specific implementation
+    }
+    /**
+     * Mark the transaction as started
+     */
+    start() {
+        this.state = TransactionState.ACTIVE;
+    }
+    /**
+     * Commit the transaction
+     * @throws Error if transaction is not active
+     */
+    async commit() {
+        if (!this.isActive) {
+            throw new Error(`Cannot commit: Transaction is ${this.state}`);
+        }
+        this.state = TransactionState.COMMITTED;
+        this.finishedAt = new Date();
+        // Commit all child savepoints first
+        for (const child of this.children) {
+            if (child.isActive) {
+                await child.commit();
+            }
+        }
+    }
+    /**
+     * Rollback the transaction
+     * @param savepoint - Optional savepoint to rollback to
+     * @throws Error if transaction is not active
+     */
+    async rollback(savepoint) {
+        if (!this.isActive) {
+            throw new Error(`Cannot rollback: Transaction is ${this.state}`);
+        }
+        // If a specific savepoint is provided, rollback to it
+        if (savepoint) {
+            if (!this.children.includes(savepoint)) {
+                throw new Error('Savepoint does not belong to this transaction');
+            }
+            // Rollback all children after the savepoint
+            const savepointIndex = this.children.indexOf(savepoint);
+            for (let i = this.children.length - 1; i >= savepointIndex; i--) {
+                const child = this.children[i];
+                if (child.isActive) {
+                    await child.rollback();
+                }
+            }
+            return;
+        }
+        // Rollback all child savepoints
+        for (const child of this.children) {
+            if (child.isActive) {
+                await child.rollback();
+            }
+        }
+        this.state = TransactionState.ROLLED_BACK;
+        this.finishedAt = new Date();
+    }
+    /**
+     * Get the duration of the transaction
+     */
+    getDuration() {
+        const endTime = this.finishedAt || new Date();
+        return endTime.getTime() - this.startedAt.getTime();
+    }
+    /**
+     * Convert to a plain object for serialization
+     */
+    toJSON() {
+        return {
+            id: this.id,
+            state: this.state,
+            options: this.options,
+            depth: this.depth,
+            isSavepoint: this.isSavepoint,
+            startedAt: this.startedAt,
+            finishedAt: this.finishedAt,
+            duration: this.getDuration(),
+        };
+    }
+}
+exports.Transaction = Transaction;
+/**
+ * Transaction manager for handling multiple transactions
+ */
+class TransactionManager {
+    constructor() {
+        this.currentTransaction = null;
+        this.transactionCount = 0;
+    }
+    /**
+     * Get the current active transaction
+     */
+    getActiveTransaction() {
+        return this.currentTransaction;
+    }
+    /**
+     * Check if there's an active transaction
+     */
+    hasActiveTransaction() {
+        return this.currentTransaction !== null && this.currentTransaction.isActive;
+    }
+    /**
+     * Start a new transaction
+     * @param options - Transaction options
+     */
+    startTransaction(options) {
+        const transaction = new Transaction(options);
+        this.currentTransaction = transaction;
+        this.transactionCount++;
+        transaction.start();
+        return transaction;
+    }
+    /**
+     * Commit the current transaction
+     */
+    async commitTransaction() {
+        if (!this.currentTransaction) {
+            throw new Error('No active transaction to commit');
+        }
+        await this.currentTransaction.commit();
+        if (!this.currentTransaction.isSavepoint) {
+            this.currentTransaction = null;
+        }
+        else {
+            // For savepoints, go back to parent
+            this.currentTransaction = this.currentTransaction.parent;
+        }
+    }
+    /**
+     * Rollback the current transaction
+     * @param savepoint - Optional savepoint to rollback to
+     */
+    async rollbackTransaction(savepoint) {
+        if (!this.currentTransaction) {
+            throw new Error('No active transaction to rollback');
+        }
+        await this.currentTransaction.rollback(savepoint);
+        if (!this.currentTransaction.isSavepoint) {
+            this.currentTransaction = null;
+        }
+        else {
+            // For savepoints, go back to parent
+            this.currentTransaction = this.currentTransaction.parent;
+        }
+    }
+    /**
+     * Get transaction count
+     */
+    getTransactionCount() {
+        return this.transactionCount;
+    }
+    /**
+     * Run a function within a transaction
+     * Automatically commits on success, rolls back on error
+     * @param fn - Function to run within the transaction
+     * @param options - Transaction options
+     */
+    async runInTransaction(fn, options) {
+        const transaction = this.startTransaction(options);
+        try {
+            const result = await fn(transaction);
+            await this.commitTransaction();
+            return result;
+        }
+        catch (error) {
+            await this.rollbackTransaction();
+            throw error;
+        }
+    }
+    /**
+     * Run a function within a savepoint
+     * @param fn - Function to run within the savepoint
+     * @param options - Savepoint options
+     */
+    async runInSavepoint(fn, options) {
+        if (!this.currentTransaction || !this.currentTransaction.isActive) {
+            throw new Error('No active transaction to create savepoint in');
+        }
+        const savepoint = this.currentTransaction.createSavepoint(options);
+        try {
+            const result = await fn(savepoint);
+            await savepoint.commit();
+            return result;
+        }
+        catch (error) {
+            await savepoint.rollback();
+            throw error;
+        }
+    }
+}
+exports.TransactionManager = TransactionManager;
+/**
+ * Transaction wrapper for automatic cleanup
+ * Ensures transaction is properly committed or rolled back
+ */
+class TransactionWrapper {
+    /**
+     * Create a transaction wrapper
+     * @param transaction - The transaction to wrap
+     */
+    constructor(transaction) {
+        this.transaction = null;
+        this.committed = false;
+        this.transaction = transaction;
+    }
+    /**
+     * Get the wrapped transaction
+     */
+    getTransaction() {
+        return this.transaction;
+    }
+    /**
+     * Commit the transaction
+     */
+    async commit() {
+        if (this.transaction && !this.committed) {
+            await this.transaction.commit();
+            this.committed = true;
+        }
+    }
+    /**
+     * Rollback the transaction
+     */
+    async rollback() {
+        if (this.transaction && this.transaction.isActive) {
+            await this.transaction.rollback();
+        }
+    }
+    /**
+     * Ensure the transaction is properly cleaned up
+     * Call this in a finally block or use the static helper
+     */
+    async ensureCleanup() {
+        if (!this.committed && this.transaction?.isActive) {
+            await this.rollback();
+        }
+    }
+    /**
+     * Static helper to run a function with automatic cleanup
+     * @param transaction - The transaction to wrap
+     * @param fn - Function to run
+     */
+    static async withCleanup(transaction, fn) {
+        const wrapper = new TransactionWrapper(transaction);
+        try {
+            return await fn();
+        }
+        catch (error) {
+            await wrapper.rollback();
+            throw error;
+        }
+        finally {
+            await wrapper.ensureCleanup();
+        }
+    }
+}
+exports.TransactionWrapper = TransactionWrapper;
+/**
+ * Create a new transaction
+ * @param options - Transaction options
+ */
+function createTransaction(options) {
+    return new Transaction(options);
+}
+/**
+ * Create a new transaction manager
+ */
+function createTransactionManager() {
+    return new TransactionManager();
+}
+exports.default = Transaction;