@dbsp/core 2.0.0 → 3.0.0

package/dist/index.js

@@ -2946,13 +2946,13 @@ function supportsExecution(adapter) {
   return "execute" in adapter && "executeOne" in adapter && typeof adapter.execute === "function";
 }
 function supportsStreaming(adapter) {
-  return "stream" in adapter && typeof adapter.stream === "function";
+  return adapter.capabilities?.supportsStreaming === true && "stream" in adapter && typeof adapter.stream === "function";
 }
 function supportsIntrospection(adapter) {
   return "introspect" in adapter && typeof adapter.introspect === "function";
 }
 function supportsTransactions(adapter) {
-  return "transaction" in adapter && "withSchema" in adapter && typeof adapter.transaction === "function";
+  return adapter.capabilities?.supportsTransactions === true && "transaction" in adapter && "withSchema" in adapter && typeof adapter.transaction === "function";
 }
 function supportsRawSql(adapter) {
   return "executeRaw" in adapter && typeof adapter.executeRaw === "function";
@@ -8518,6 +8518,13 @@ function buildSetOperationIntent(op2, all, left, right) {
 }
 
 // src/dx/stream-impl.ts
+function createUnsupportedStreamingError() {
+  return new ExecutionError({
+    operation: "stream()",
+    reason: "The adapter declares supportsStreaming: false for this ORM instance.",
+    fix: "Use an adapter configuration that supports streaming."
+  });
+}
 function stream(builder, options) {
   const adapter = builder.getConfiguredAdapter();
   const adapterOptions = options?.chunkSize !== void 0 ? { chunkSize: options.chunkSize } : void 0;
@@ -8537,6 +8544,9 @@ function stream(builder, options) {
       return this;
     },
     async next() {
+      if (!supportsStreaming(adapter)) {
+        throw createUnsupportedStreamingError();
+      }
       if (!hooksFired) {
         hooksFired = true;
         if (hookStore && hasHooks(hookStore)) {
@@ -10078,6 +10088,31 @@ function generateVacuumSQL(tableName, schemaName, options) {
   const mod = modifiers.length > 0 ? `(${modifiers.join(", ")}) ` : "";
   return `VACUUM ${mod}${buildQualifiedTable(tableName, schemaName)}`;
 }
+function createUnsupportedTransactionError() {
+  return new ExecutionError({
+    operation: "transaction()",
+    reason: "The adapter does not declare capabilities.supportsTransactions: true for this ORM instance.",
+    fix: "Use an adapter that implements transaction() and withSchema(), and declare adapter.capabilities.supportsTransactions: true."
+  });
+}
+function adapterTransactionState(adapter, operation, statement) {
+  const inTransaction = adapter.inTransaction;
+  if (typeof inTransaction !== "boolean") {
+    throw new InvalidOperationError(
+      operation,
+      `${statement} requires an adapter that exposes inTransaction: boolean; dbsp refuses to run it when transaction state is unknown.`
+    );
+  }
+  return inTransaction;
+}
+function assertOutsideTransaction(adapter, operation, statement) {
+  if (adapterTransactionState(adapter, operation, statement)) {
+    throw new InvalidOperationError(
+      operation,
+      `${statement} cannot run inside a transaction block`
+    );
+  }
+}
 function generateAlterColumnSQL(tableName, column, schemaName, options) {
   const tbl = buildQualifiedTable(tableName, schemaName);
   const col2 = quoteIdent(column);
@@ -10156,24 +10191,19 @@ function buildIndexAPI(tableName, schemaName, adapter, requireAdapter2) {
   return {
     async create(opts) {
       const a = requireAdapter2();
-      if (opts.concurrently && a.inTransaction) {
-        throw new InvalidOperationError(
-          "createIndex",
-          "CREATE INDEX CONCURRENTLY cannot run inside a transaction block"
-        );
+      if (opts.concurrently) {
+        assertOutsideTransaction(a, "createIndex", "CREATE INDEX CONCURRENTLY");
       }
       const sql2 = a.generateCreateIndex ? a.generateCreateIndex(tableName, opts, schemaName) : generateCreateIndexSQL(tableName, schemaName, opts);
       await a.executeDDL?.(sql2);
     },
     async drop(name, options) {
       const a = requireAdapter2();
-      if (options?.concurrently && a.inTransaction) {
-        throw new InvalidOperationError(
-          "dropIndex",
-          "DROP INDEX CONCURRENTLY cannot run inside a transaction block"
-        );
+      if (options?.concurrently) {
+        assertOutsideTransaction(a, "dropIndex", "DROP INDEX CONCURRENTLY");
       }
-      const sql2 = a.generateDropIndex ? a.generateDropIndex(name, options) : generateDropIndexSQL(name, schemaName, options);
+      const scopedOptions = schemaName ? { ...options, schema: options?.schema ?? schemaName } : options;
+      const sql2 = a.generateDropIndex ? a.generateDropIndex(name, scopedOptions) : generateDropIndexSQL(name, schemaName, options);
       await a.executeDDL?.(sql2);
     },
     async list(options) {
@@ -10226,12 +10256,7 @@ function buildTableDDL(tableName, schemaName, adapter) {
     },
     async vacuum(options) {
       const a = requireAdapter2();
-      if (a.inTransaction) {
-        throw new InvalidOperationError(
-          "vacuum",
-          "VACUUM cannot run inside a transaction block"
-        );
-      }
+      assertOutsideTransaction(a, "vacuum", "VACUUM");
       const sql2 = a.generateVacuum ? a.generateVacuum(tableName, schemaName, options) : generateVacuumSQL(tableName, schemaName, options);
       await a.executeDDL?.(sql2);
     },
@@ -10563,31 +10588,47 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
     // =====================================================================
     // Transaction Methods (DX-025)
     // =====================================================================
-    async transaction(fn2) {
+    // NOT `async`, and that is load-bearing. An async method awaits whatever it
+    // returns and re-wraps it in a fresh Promise — which would mean the language
+    // itself attaches to the adapter's promise, and an adapter that needs to know
+    // whether the CALLER awaited a nested transaction would see every one of them
+    // as awaited, by core, before the caller ever touched it. So the adapter's
+    // promise is passed through untouched. The guards still reject rather than
+    // throwing synchronously, because that is what callers already rely on.
+    transaction(fn2) {
       if (!adapter) {
-        throw new Error(
-          "transaction() requires an adapter. Pass an adapter when creating the ORM."
+        return Promise.reject(
+          new Error(
+            "transaction() requires an adapter. Pass an adapter when creating the ORM."
+          )
         );
       }
-      return adapter.transaction(async (txAdapter) => {
-        const txOrm = createOrmInstance(
-          model,
-          strictMode,
-          relationHints,
-          txAdapter,
-          schemaName,
-          dialectCapabilities,
-          schemaDefinition,
-          globalPlanOptions,
-          defaultFilters,
-          hookStore,
-          onHookError,
-          true,
-          // inTransaction
-          tablesProxy
-        );
-        return fn2(txOrm);
-      });
+      if (!supportsTransactions(adapter)) {
+        return Promise.reject(createUnsupportedTransactionError());
+      }
+      try {
+        return adapter.transaction(async (txAdapter) => {
+          const txOrm = createOrmInstance(
+            model,
+            strictMode,
+            relationHints,
+            txAdapter,
+            schemaName,
+            dialectCapabilities,
+            schemaDefinition,
+            globalPlanOptions,
+            defaultFilters,
+            hookStore,
+            onHookError,
+            true,
+            // inTransaction
+            tablesProxy
+          );
+          return fn2(txOrm);
+        });
+      } catch (error) {
+        return Promise.reject(error);
+      }
     },
     // =====================================================================
     // Raw SQL Execution (DX-027)
@@ -10666,12 +10707,20 @@ function createOrmInstance(model, strictMode, relationHints, adapter, schemaName
             "executeDDL() requires an adapter that supports DDL execution."
           );
         }
+        if (options?.concurrently) {
+          assertOutsideTransaction(
+            adapter,
+            "dropIndex",
+            "DROP INDEX CONCURRENTLY"
+          );
+        }
         validateIdentifier(name, "index");
         const sc = options?.schema ?? schemaName;
         if (sc) {
           validateIdentifier(sc, "schema");
         }
-        const sql2 = adapter.generateDropIndex ? adapter.generateDropIndex(name, options) : (() => {
+        const scopedOptions = sc ? { ...options, schema: sc } : options;
+        const sql2 = adapter.generateDropIndex ? adapter.generateDropIndex(name, scopedOptions) : (() => {
           const parts = ["DROP INDEX"];
           if (options?.concurrently) parts.push("CONCURRENTLY");
           if (options?.ifExists) parts.push("IF EXISTS");