@ductape/sdk 0.4.4 → 0.4.6

package/dist/database/databases.service.js

@@ -41,17 +41,38 @@ var __importStar = (this && this.__importStar) || (function () {
         return result;
     };
 })();
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.databaseService = exports.DatabaseConnection = exports.DatabaseService = void 0;
 const enums_1 = require("./types/enums");
+const pipeline_interface_1 = require("./types/pipeline.interface");
+const atomic_pipeline_1 = require("./atomic-pipeline");
+const sql_context_1 = require("./sql-context");
 const presave_processor_1 = require("./presave/presave-processor");
+const atomic_batch_1 = require("./atomic-batch");
+const dynamodb_adapter_1 = require("./adapters/dynamodb.adapter");
+const transaction_manager_1 = require("./transactions/transaction-manager");
+const mongodb_adapter_1 = require("./adapters/mongodb.adapter");
+const postgresql_adapter_1 = require("./adapters/postgresql.adapter");
+const mysql_adapter_1 = require("./adapters/mysql.adapter");
+const context_1 = require("../context");
 const adapter_factory_1 = require("./adapters/adapter.factory");
 const query_builder_1 = require("./operators/query-builder");
 const aggregation_builder_1 = require("./operators/aggregation-builder");
-const transaction_manager_1 = require("./transactions/transaction-manager");
+const transaction_manager_2 = require("./transactions/transaction-manager");
 const schema_manager_1 = require("./schema/schema-manager");
 const migration_engine_1 = require("./migrations/migration-engine");
 const action_manager_1 = require("./actions/action-manager");
@@ -94,6 +115,7 @@ class DatabaseService {
         this.adapters = new Map();
         this.connectionContexts = new Map();
         this.currentContext = null;
+        this.transactionScopes = new WeakMap();
         this.schemaManagers = new Map();
         this.migrationEngines = new Map();
         /** Service configuration */
@@ -116,7 +138,7 @@ class DatabaseService {
         this.config = config || null;
         this.preInitializedProductBuilder = config === null || config === void 0 ? void 0 : config.preInitializedProductBuilder;
         this.adapterFactory = new adapter_factory_1.AdapterFactory();
-        this.transactionManager = new transaction_manager_1.TransactionManager();
+        this.transactionManager = new transaction_manager_2.TransactionManager();
         this.actionManager = new action_manager_1.ActionManager(this);
         this._privateKey = (config === null || config === void 0 ? void 0 : config.private_key) || '';
         if ((config === null || config === void 0 ? void 0 : config.default_product) || (config === null || config === void 0 ? void 0 : config.default_env)) {
@@ -1356,6 +1378,9 @@ class DatabaseService {
      */
     async raw(options) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        // A cached response cannot represent this transaction's snapshot or own writes.
+        if (options.transaction && options.cache)
+            options = Object.assign(Object.assign({}, options), { cache: undefined });
         const process_id = (0, processor_utils_1.generateObjectId)();
         const start = Date.now();
         this.initializeLogService();
@@ -1860,6 +1885,104 @@ class DatabaseService {
      *   where: { status: 'completed' },
      * });
      */
+    async atomicPipeline(options) {
+        const { context: _context } = options, batchInput = __rest(options, ["context"]);
+        (0, atomic_batch_1.validateAtomicBatch)(batchInput);
+        // Retain only the opaque session and transaction by identity across awaits.
+        options = Object.assign(Object.assign({}, options), { context: JSON.parse(JSON.stringify(options.context)), operations: JSON.parse(JSON.stringify(options.operations)) });
+        return (0, atomic_pipeline_1.executeAtomicPipeline)(options, {
+            preflight: async (scope) => {
+                try {
+                    await this.ensureAdapterFor(scope);
+                    const adapter = this.getAdapter(scope);
+                    if (!(adapter instanceof mongodb_adapter_1.MongoDBAdapter || adapter instanceof postgresql_adapter_1.PostgreSQLAdapter || adapter instanceof mysql_adapter_1.MySQLAdapter))
+                        throw new Error('Adapter cannot provide a transactional context pipeline');
+                    if ((adapter instanceof mongodb_adapter_1.MongoDBAdapter) === !!scope.context.sql)
+                        throw new Error('Context dialect does not match adapter');
+                    if (scope.transaction && (!(scope.transaction instanceof transaction_manager_1.Transaction) || !scope.transaction.belongsTo(adapter)
+                        || !scope.transaction.isActive() || this.transactionScopes.get(scope.transaction) !== JSON.stringify([scope.product, scope.env, scope.database])))
+                        throw new Error('Transaction scope mismatch');
+                    if (adapter instanceof mongodb_adapter_1.MongoDBAdapter)
+                        await adapter.assertAtomicBatchSupport([...new Set([scope.context.table, ...scope.operations.map(op => op.table)])]);
+                    else if (scope.transaction && scope.transaction.isolationLevel !== enums_1.IsolationLevel.SERIALIZABLE)
+                        throw new Error('SQL pipeline requires SERIALIZABLE isolation');
+                }
+                catch (_a) {
+                    throw new atomic_batch_1.AtomicBatchError('BATCH_PREFLIGHT_FAILED', 'not_started');
+                }
+            },
+            begin: () => this.beginTransaction({ product: options.product, env: options.env, database: options.database, isolationLevel: enums_1.IsolationLevel.SERIALIZABLE }),
+            read: async (transaction) => {
+                if (!options.context.sql)
+                    return this.aggregatePipeline({ product: options.product, env: options.env, database: options.database,
+                        session: options.session, transaction, table: options.context.table, pipeline: options.context.pipeline, maxTimeMS: options.context.maxTimeMS });
+                const adapter = this.getAdapter(options);
+                await adapter.assertAtomicBatchSupport([...new Set([options.context.table, ...(options.context.sql.joins || []).map(join => join.table), ...options.operations.map(op => op.table)])], transaction);
+                let context = options.context.sql;
+                if (options.session) {
+                    const builder = await this.getProductBuilder(options.product);
+                    const key = builder.fetchPrivateKey();
+                    if (!key)
+                        throw new Error('Cannot verify pipeline session');
+                    const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                    const result = await processSessionForExecution(options.session, key, context, options.env, { fetchSessionSelector: async (tag) => { var _a; return (_a = (await builder.fetchSession(tag))) === null || _a === void 0 ? void 0 : _a.selector; } });
+                    if (result.error)
+                        throw new Error('Pipeline session validation failed');
+                    context = result.input;
+                }
+                const query = (0, sql_context_1.compileSqlContext)(options.context.table, context, adapter instanceof postgresql_adapter_1.PostgreSQLAdapter);
+                return adapter.raw(Object.assign(Object.assign({}, query), { table: options.context.table, transaction }));
+            },
+            write: batch => this.atomicBatch(batch),
+        });
+    }
+    async aggregatePipeline(options) {
+        var _a, _b, _c;
+        for (const key of ['product', 'env', 'database', 'table']) {
+            if (typeof options[key] !== 'string' || !options[key].trim())
+                throw new Error(`aggregatePipeline requires ${key}`);
+        }
+        (0, pipeline_interface_1.validateReadPipeline)(options.pipeline);
+        await this.ensureAdapterFor(options);
+        const adapter = this.getAdapter(options);
+        if (!(adapter instanceof mongodb_adapter_1.MongoDBAdapter))
+            throw new Error('aggregatePipeline requires MongoDB');
+        const transaction = options.transaction;
+        if (transaction && (!(transaction instanceof transaction_manager_1.Transaction) || !transaction.belongsTo(adapter) || !transaction.isActive()
+            || this.transactionScopes.get(transaction) !== JSON.stringify([options.product, options.env, options.database]))) {
+            throw new Error('Pipeline transaction does not belong to this product/environment/database');
+        }
+        let resolved = options;
+        let sessionLogFields = {};
+        if (options.session) {
+            const builder = await this.getProductBuilder(options.product);
+            const privateKey = builder.fetchPrivateKey();
+            if (!privateKey)
+                throw new Error('Cannot verify pipeline session');
+            const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+            // Never recursively transform the driver session or replace the original opaque token.
+            const { transaction: _transaction } = options, input = __rest(options, ["transaction"]);
+            const result = await processSessionForExecution(options.session, privateKey, input, options.env, {
+                fetchSessionSelector: async (tag) => { var _a; return (_a = (await builder.fetchSession(tag))) === null || _a === void 0 ? void 0 : _a.selector; },
+            });
+            if (result.error)
+                throw new Error('Pipeline session validation failed');
+            resolved = Object.assign(Object.assign({}, options), { pipeline: result.input.pipeline, transaction, session: options.session });
+            sessionLogFields = result.logFields;
+        }
+        this.initializeLogService();
+        const start = Date.now();
+        let successful = false;
+        try {
+            const result = await adapter.aggregatePipeline(resolved);
+            successful = true;
+            return result;
+        }
+        finally {
+            (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign(Object.assign({ product_tag: options.product, workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '', env: options.env, app_env: options.env, process_id: (0, processor_utils_1.generateObjectId)(), type: logs_types_1.LogEventTypes.DATABASE, parent_tag: options.database, child_tag: 'aggregatePipeline' }, sessionLogFields), { start, end: Date.now(), message: `Database pipeline - ${successful ? 'success' : 'failed'}`, status: successful ? logs_types_1.LogEventStatus.SUCCESS : logs_types_1.LogEventStatus.FAIL, successful_execution: successful, failed_execution: !successful, data: { table: options.table, stages: options.pipeline.length } }));
+            void ((_c = this.logService) === null || _c === void 0 ? void 0 : _c.publish().catch(() => { }));
+        }
+    }
     async aggregate(options) {
         var _a, _b, _c, _d, _e, _f, _g, _h;
         const process_id = (0, processor_utils_1.generateObjectId)();
@@ -1973,7 +2096,109 @@ class DatabaseService {
     async beginTransaction(options) {
         await this.ensureAdapterFor(options);
         const adapter = this.getAdapter(options);
-        return this.transactionManager.beginTransaction(adapter, options);
+        const transaction = await this.transactionManager.beginTransaction(adapter, options);
+        this.transactionScopes.set(transaction, JSON.stringify([options.product, options.env, options.database]));
+        return transaction;
+    }
+    /** Bounded ACID batch. Unsupported adapters and configured triggers fail closed. */
+    async atomicBatch(options) {
+        var _a;
+        const logs = [];
+        const batch = { id: (0, processor_utils_1.generateObjectId)(), logs, system: !!options.system };
+        let outcome = 'not_started';
+        try {
+            const result = await (0, context_1.runWithExecutionContext)((0, context_1.createExecutionContext)({ database_batch: batch }), () => (0, atomic_batch_1.executeAtomicBatch)({
+                preflight: async (scope) => {
+                    var _a;
+                    await this.ensureAdapterFor(scope);
+                    if (((_a = this.currentContext) === null || _a === void 0 ? void 0 : _a.product) && this.currentContext.product !== scope.product) {
+                        throw new Error('Atomic batch product must match the active database context');
+                    }
+                    if (scope.session && !(await this.getProductBuilder(scope.product)).fetchPrivateKey()) {
+                        throw new Error('Atomic batch cannot verify the provided user session');
+                    }
+                    const adapter = this.getAdapter(scope);
+                    if (!(adapter instanceof mongodb_adapter_1.MongoDBAdapter || adapter instanceof postgresql_adapter_1.PostgreSQLAdapter || adapter instanceof mysql_adapter_1.MySQLAdapter || adapter instanceof dynamodb_adapter_1.DynamoDBAdapter)) {
+                        throw new Error('This adapter cannot provide the required multi-table ACID contract; Cassandra logged batches are not a substitute');
+                    }
+                    if (scope.transaction && (!(scope.transaction instanceof transaction_manager_1.Transaction) || !scope.transaction.belongsTo(adapter) || !scope.transaction.isActive()
+                        || this.transactionScopes.get(scope.transaction) !== JSON.stringify([scope.product, scope.env, scope.database]))) {
+                        throw new Error('Atomic batch transaction does not belong to the active database connection');
+                    }
+                    if (scope.transaction && (adapter instanceof postgresql_adapter_1.PostgreSQLAdapter || adapter instanceof mysql_adapter_1.MySQLAdapter)
+                        && scope.transaction.isolationLevel !== enums_1.IsolationLevel.SERIALIZABLE) {
+                        throw new Error('Borrowed SQL batch transactions must use SERIALIZABLE isolation');
+                    }
+                    const triggers = await this.fetchTriggers(scope.product, scope.database);
+                    if (triggers.length)
+                        throw new Error('Atomic batch does not yet support configured triggers; use a transaction-local outbox');
+                    if (adapter instanceof mongodb_adapter_1.MongoDBAdapter)
+                        await adapter.assertAtomicBatchSupport([...new Set(scope.operations.map(op => op.table))]);
+                },
+                executeNative: async (scope) => {
+                    var _a, _b, _c, _d;
+                    const adapter = this.getAdapter(scope);
+                    if (!(adapter instanceof dynamodb_adapter_1.DynamoDBAdapter))
+                        return undefined;
+                    let resolved = scope;
+                    let sessionLogFields = {};
+                    if (scope.session) {
+                        const builder = await this.getProductBuilder(scope.product);
+                        const { processSessionForExecution } = await Promise.resolve().then(() => __importStar(require('../sessions')));
+                        const result = await processSessionForExecution(scope.session, builder.fetchPrivateKey(), scope, scope.env, {
+                            fetchSessionSelector: async (tag) => { var _a; return (_a = (await builder.fetchSession(tag))) === null || _a === void 0 ? void 0 : _a.selector; },
+                        });
+                        if (result.error)
+                            throw new atomic_batch_1.AtomicBatchError('BATCH_VALIDATION', 'not_started');
+                        resolved = Object.assign(Object.assign({}, scope), { operations: result.input.operations });
+                        sessionLogFields = result.logFields;
+                    }
+                    this.initializeLogService();
+                    const start = Date.now();
+                    try {
+                        const result = await adapter.atomicBatch(resolved);
+                        (_a = this.logService) === null || _a === void 0 ? void 0 : _a.add(Object.assign({ product_tag: scope.product, workspace_id: ((_b = this.config) === null || _b === void 0 ? void 0 : _b.workspace_id) || '', env: scope.env, app_env: scope.env, process_id: result.transactionId, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: scope.database, child_tag: 'atomicBatch', start, end: Date.now(), message: 'Database atomic batch - success', status: logs_types_1.LogEventStatus.SUCCESS, successful_execution: true, data: { operations: scope.operations.map(op => ({ name: op.name, operation: op.operation, table: op.table })) } }, sessionLogFields));
+                        return result;
+                    }
+                    catch (error) {
+                        (_c = this.logService) === null || _c === void 0 ? void 0 : _c.add(Object.assign({ product_tag: scope.product, workspace_id: ((_d = this.config) === null || _d === void 0 ? void 0 : _d.workspace_id) || '', env: scope.env, app_env: scope.env, process_id: batch.id, type: logs_types_1.LogEventTypes.DATABASE, parent_tag: scope.database, child_tag: 'atomicBatch', start, end: Date.now(), message: 'Database atomic batch - failed', status: logs_types_1.LogEventStatus.FAIL, failed_execution: true, data: { outcome: error instanceof atomic_batch_1.AtomicBatchError ? error.outcome : 'not_started' } }, sessionLogFields));
+                        throw error;
+                    }
+                },
+                validateTransaction: async (scope, transaction) => {
+                    const adapter = this.getAdapter(scope);
+                    if (adapter instanceof postgresql_adapter_1.PostgreSQLAdapter || adapter instanceof mysql_adapter_1.MySQLAdapter) {
+                        await adapter.assertAtomicBatchSupport([...new Set(scope.operations.map(op => op.table))], transaction);
+                    }
+                },
+                begin: (scope) => this.beginTransaction({ product: scope.product, env: scope.env, database: scope.database, isolationLevel: enums_1.IsolationLevel.SERIALIZABLE }),
+                execute: async (op, scope, transaction) => {
+                    const input = { product: scope.product, env: scope.env, database: scope.database, session: scope.session,
+                        table: op.table, transaction, returning: op.returning };
+                    switch (op.operation) {
+                        case 'insert': return this.insert(Object.assign(Object.assign({}, input), { data: op.data }));
+                        case 'update': return this.update(Object.assign(Object.assign({}, input), { where: op.where, data: op.data }));
+                        case 'delete': return this.delete(Object.assign(Object.assign({}, input), { where: op.where }));
+                        case 'upsert': return this.upsert(Object.assign(Object.assign({}, input), { data: op.data, conflictKeys: op.conflictKeys }));
+                    }
+                },
+            }, options));
+            outcome = result.status;
+            return result;
+        }
+        catch (error) {
+            outcome = error instanceof atomic_batch_1.AtomicBatchError ? error.outcome : 'not_started';
+            throw error;
+        }
+        finally {
+            for (const emit of logs) {
+                try {
+                    emit(outcome);
+                }
+                catch ( /* Telemetry cannot change transaction outcome. */_b) { /* Telemetry cannot change transaction outcome. */ }
+            }
+            void ((_a = this.logService) === null || _a === void 0 ? void 0 : _a.publish().catch(() => { }));
+        }
     }
     // ==================== SCHEMA OPERATIONS ====================
     /**
@@ -2839,6 +3064,9 @@ class DatabaseService {
             return await fn(adapter);
         }
         catch (error) {
+            // An uncertain transactional write must never be replayed on a fresh connection.
+            if (options.transaction)
+                throw error;
             if (!this.isConnectionError(error))
                 throw error;
             await this.connect({
@@ -3467,6 +3695,9 @@ class DatabaseConnection {
     aggregate(options) {
         return this.service.aggregate(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
     }
+    aggregatePipeline(options) {
+        return this.service.aggregatePipeline(Object.assign(Object.assign({}, options), { product: this._product, database: this._database, env: this._env }));
+    }
     groupBy(options) {
         return this.service.groupBy(Object.assign(Object.assign({}, options), { database: this._database, env: this._env }));
     }