@ductape/sdk 0.4.5 → 0.4.6

package/dist/database/databases.service.js

@@ -41,12 +41,26 @@ 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");
@@ -1364,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();
@@ -1868,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)();
@@ -3580,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 }));
     }