@dbsp/core 1.0.3 → 1.0.4

package/dist/index.d.ts

@@ -2573,15 +2573,20 @@ declare function notExists(relation: string, options?: {
  * Accepts a SubqueryBuilder (must have `.build()`) or any builder
  * exposing `buildIntent(): QueryIntent` (e.g. QueryBuilder).
  *
+ * **Limitation:** correlated subqueries (using `outerRef()` inside the inner WHERE)
+ * are NOT supported and will throw at compile time. For correlated EXISTS over an
+ * FK-declared relation, use `exists('relation', { where: ... outerRef(...) })` instead.
+ *
  * @param subquery - A SubqueryBuilder or any object with buildIntent()
  *
  * @example
- * // EXISTS (SELECT 1 FROM audit_log WHERE audit_log.entity_id = users.id)
- * rawExists(subquery('audit_log').select('id').where(eq('entityId', outerRef('id'))))
+ * // EXISTS (SELECT 1 FROM audit_log WHERE audit_log.entity_type = 'login')
+ * // Uncorrelated: no reference to the outer row — inner filter is a plain value.
+ * rawExists(subquery('audit_log').select('id').where(eq('entityType', 'login')))
  *
  * @example
- * // EXISTS with a full query builder
- * rawExists(orm.select('sessions').where(and(eq('userId', outerRef('id')), gt('expiresAt', new Date()))))
+ * // EXISTS with a full query builder — polymorphic table, no FK to source
+ * rawExists(orm.select('sessions').where(and(eq('status', 'active'), gt('expiresAt', new Date()))))
  */
 declare function rawExists(sq: SubqueryBuilder | {
     buildIntent(): QueryIntent;
@@ -2593,11 +2598,16 @@ declare function rawExists(sq: SubqueryBuilder | {
  * Accepts a SubqueryBuilder (must have `.build()`) or any builder
  * exposing `buildIntent(): QueryIntent` (e.g. QueryBuilder).
  *
+ * **Limitation:** correlated subqueries (using `outerRef()` inside the inner WHERE)
+ * are NOT supported and will throw at compile time. For correlated NOT EXISTS over an
+ * FK-declared relation, use `notExists('relation', { where: ... outerRef(...) })` instead.
+ *
  * @param subquery - A SubqueryBuilder or any object with buildIntent()
  *
  * @example
- * // NOT EXISTS (SELECT 1 FROM bans WHERE bans.user_id = users.id)
- * rawNotExists(subquery('bans').select('id').where(eq('userId', outerRef('id'))))
+ * // NOT EXISTS (SELECT 1 FROM bans WHERE bans.reason = 'spam')
+ * // Uncorrelated: inner filter is a plain value, no reference to the outer row.
+ * rawNotExists(subquery('bans').select('id').where(eq('reason', 'spam')))
  */
 declare function rawNotExists(sq: SubqueryBuilder | {
     buildIntent(): QueryIntent;

package/dist/index.js

@@ -2146,6 +2146,7 @@ function plan(intent, model, options = {}) {
     throw new Error(`Unknown table: ${intent.from}`);
   }
   const optimizedWhere = intent.where ? optimizeInToExists(intent.where, intent.from, model) : void 0;
+  const plannedIntent = optimizedWhere !== void 0 && optimizedWhere !== intent.where ? { ...intent, where: optimizedWhere } : intent;
   if (optimizedWhere) {
     processWhere(optimizedWhere, intent.from, model, state, opts, "where");
   }
@@ -2188,7 +2189,13 @@ function plan(intent, model, options = {}) {
     decisions: Object.freeze(state.decisions.slice()),
     warnings: Object.freeze(state.warnings.slice()),
     ctes: Object.freeze(state.ctes.slice()),
+    // intent is ALWAYS the original submitted intent (contract: observable via dump()).
+    // executableIntent carries the optimized WHERE (e.g. IN→EXISTS) when the
+    // optimizer rewrote it, so the adapter compiles the correct SQL from that field.
+    // When no optimization applies, executableIntent is left undefined and the
+    // adapter falls back to intent.
     intent,
+    ...plannedIntent !== intent && { executableIntent: plannedIntent },
     metadata
   };
   return Object.freeze(report);
@@ -2326,11 +2333,15 @@ function isSubquerySelectedColumnNonNullable(existsIntent, sourceTable, model) {
   if (!column) return false;
   return !column.nullable;
 }
-function optimizeInToExists(where, sourceTable, model) {
+function optimizeInToExists(where, sourceTable, model, negated = false) {
   switch (where.kind) {
     case "in": {
       const inWhere = where;
       if (!inWhere.subquery) return where;
+      const sq = inWhere.subquery;
+      if (sq.limit != null || sq.orderBy?.length || sq.offset != null || sq.groupBy?.length || sq.having != null || sq.distinct || sq.distinctOn?.length || sq.joins?.length || sq.include?.length || sq.batchValuesSource != null || sq.existsWrap || sq.lock != null || sq.select != null && sq.select.type !== "fields") {
+        return where;
+      }
       const subSelect = inWhere.subquery.select;
       if (!subSelect || subSelect.type !== "fields") return where;
       const fields = "fields" in subSelect ? subSelect.fields : void 0;
@@ -2350,18 +2361,24 @@ function optimizeInToExists(where, sourceTable, model) {
         }
       }
       if (!matchedRelation) return where;
-      const existsWhere = {
-        kind: "exists",
+      const effectiveNegated = negated !== Boolean(inWhere.not);
+      if (effectiveNegated) {
+        const existsIntent = { relation: matchedRelation };
+        if (!isSubquerySelectedColumnNonNullable(existsIntent, sourceTable, model)) {
+          return where;
+        }
+      }
+      const targetKind = inWhere.not ? "notExists" : "exists";
+      return {
+        kind: targetKind,
         relation: matchedRelation,
-        // Forward the subquery's inner WHERE conditions
         ...inWhere.subquery.where && { where: inWhere.subquery.where }
       };
-      return existsWhere;
     }
     case "and": {
       const andWhere = where;
       const optimized = andWhere.conditions.map(
-        (c) => optimizeInToExists(c, sourceTable, model)
+        (c) => optimizeInToExists(c, sourceTable, model, negated)
       );
       if (optimized.every((c, i) => c === andWhere.conditions[i])) return where;
       return { kind: "and", conditions: optimized };
@@ -2369,7 +2386,7 @@ function optimizeInToExists(where, sourceTable, model) {
     case "or": {
       const orWhere = where;
       const optimized = orWhere.conditions.map(
-        (c) => optimizeInToExists(c, sourceTable, model)
+        (c) => optimizeInToExists(c, sourceTable, model, negated)
       );
       if (optimized.every((c, i) => c === orWhere.conditions[i])) return where;
       return { kind: "or", conditions: optimized };
@@ -2379,22 +2396,10 @@ function optimizeInToExists(where, sourceTable, model) {
       const optimized = optimizeInToExists(
         notWhere.condition,
         sourceTable,
-        model
+        model,
+        !negated
       );
       if (optimized === notWhere.condition) return where;
-      if (optimized.kind === "exists") {
-        if (!isSubquerySelectedColumnNonNullable(
-          optimized,
-          sourceTable,
-          model
-        )) {
-          return where;
-        }
-        return {
-          ...optimized,
-          kind: "notExists"
-        };
-      }
       return { kind: "not", condition: optimized };
     }
     default:
@@ -2476,6 +2481,26 @@ function processWhere(where, sourceTable, model, state, opts, intentPath) {
       break;
     case "expression":
       break;
+    // Custom expression — no relation analysis, pass through
+    // Adapter-only kinds: planner records no decisions; the adapter compiles
+    // them directly from the intent. Explicit cases here prevent silent
+    // fallthrough and keep the switch exhaustive.
+    case "rawExists":
+    case "rawNotExists":
+      break;
+    case "subquery":
+      break;
+    case "range":
+      break;
+    case "jsonContains":
+    case "jsonExists":
+      break;
+    default: {
+      const _exhaustive = where;
+      throw new Error(
+        `processWhere: unhandled WhereIntent kind '${_exhaustive.kind}'`
+      );
+    }
   }
 }
 function processRelationFilter(relationPath, sourceTable, model, state, opts, intentPath, nestedWhere, mode) {
@@ -3012,6 +3037,60 @@ function assertCapability(adapter, capability, operation) {
 }
 
 // src/dx/batch-values.ts
+var MULTIWORD_BASE_TYPES = [
+  "timestamp with time zone",
+  "timestamp without time zone",
+  "time with time zone",
+  "time without time zone",
+  "double precision",
+  "character varying",
+  "bit varying"
+];
+var IDENT_RE = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function validateTypeName(typeName) {
+  const raw2 = typeName.trim();
+  if (raw2.length === 0) {
+    throw new Error(
+      `batchValues: invalid type name '${typeName}'. Type names must not be empty.`
+    );
+  }
+  let rest = raw2;
+  if (rest.endsWith("[]")) {
+    rest = rest.slice(0, -2);
+    if (rest.endsWith("[]")) {
+      throw new Error(
+        `batchValues: invalid type name '${typeName}'. At most one array suffix "[]" is allowed as a raw type-name input. Use "int4[]" not "int4[][]".`
+      );
+    }
+  }
+  const modifierMatch = rest.match(/\(([^)]*)\)$/);
+  if (modifierMatch) {
+    const inner = modifierMatch[1] ?? "";
+    if (!/^\d+(?:,\d+)?$/.test(inner)) {
+      throw new Error(
+        `batchValues: invalid type name '${typeName}'. Type modifier must be "(N)" or "(N,M)" with digits only; got "(${inner})".`
+      );
+    }
+    rest = rest.slice(0, rest.length - modifierMatch[0].length).trimEnd();
+  }
+  const baseLower = rest.toLowerCase();
+  if (MULTIWORD_BASE_TYPES.includes(baseLower)) {
+    return;
+  }
+  const parts = rest.split(".");
+  if (parts.length > 2) {
+    throw new Error(
+      `batchValues: invalid type name '${typeName}'. Schema-qualified types allow at most one dot (schema.type).`
+    );
+  }
+  for (const part of parts) {
+    if (!IDENT_RE.test(part)) {
+      throw new Error(
+        `batchValues: invalid type name '${typeName}'. Base type "${part}" is not a valid SQL identifier ([A-Za-z_][A-Za-z0-9_]*) and is not in the multi-word type allowlist.`
+      );
+    }
+  }
+}
 function isBatchValuesRef(value) {
   return typeof value === "object" && value !== null && "__kind" in value && value.__kind === "batchValues";
 }
@@ -3024,20 +3103,28 @@ function batchValues(data, columns, types, opts) {
   if (columns.length === 0) {
     throw new Error("batchValues: at least one column is required");
   }
-  const invalidType = types.find((t) => !/^[a-zA-Z0-9_]+$/.test(t));
-  if (invalidType !== void 0) {
-    throw new Error(
-      `batchValues: invalid type name '${invalidType}'. Type names must contain only letters, digits, and underscores.`
-    );
+  const normalizedTypes = types.map((t) => t.trim());
+  for (const t of normalizedTypes) {
+    validateTypeName(t);
   }
-  return {
+  const alias = opts?.alias ?? "batch";
+  validateIdentifier(alias, "alias");
+  for (const col2 of columns) {
+    validateIdentifier(col2, "column");
+  }
+  const frozenData = Object.freeze(
+    data.map((row) => Object.freeze([...row]))
+  );
+  const frozenColumns = Object.freeze([...columns]);
+  const frozenTypes = Object.freeze([...normalizedTypes]);
+  return Object.freeze({
     __kind: "batchValues",
-    data,
-    columns,
-    types,
-    alias: opts?.alias ?? "batch",
+    data: frozenData,
+    columns: frozenColumns,
+    types: frozenTypes,
+    alias,
     ordinality: opts?.ordinality ?? false
-  };
+  });
 }
 
 // src/dx/expressions.ts
@@ -4018,36 +4105,31 @@ function coalesce(fields, as) {
   };
 }
 function raw(sqlFragment, as) {
-  if (!as || as.trim() === "") {
-    throw new Error("raw() requires a non-empty alias");
-  }
+  validateIdentifier(as, "column");
   return {
     __expr: true,
     intent: { kind: "raw", sql: sqlFragment, as }
   };
 }
 function col(column, alias) {
-  if (!column || column.trim() === "") {
-    throw new Error("col() requires a non-empty column name");
-  }
-  if (!alias || alias.trim() === "") {
-    throw new Error("col() requires a non-empty alias");
-  }
+  validateIdentifier(column, "column");
+  validateIdentifier(alias, "column");
   return {
     __expr: true,
     intent: { kind: "columnAlias", column, alias }
   };
 }
 function relationColumn(relation, column, as) {
-  if (!relation || relation.trim() === "") {
+  if (!relation) {
     throw new Error("relationColumn() requires a non-empty relation path");
   }
-  if (!column || column.trim() === "") {
-    throw new Error("relationColumn() requires a non-empty column name");
+  for (const segment of relation.split(".")) {
+    validateIdentifier(segment, "relation");
   }
-  if (!as || as.trim() === "") {
-    throw new Error("relationColumn() requires a non-empty alias");
+  if (column !== "*") {
+    validateIdentifier(column, "column");
   }
+  validateIdentifier(as, "column");
   return {
     __expr: true,
     intent: { kind: "relationColumn", relation, column, as }
@@ -4406,7 +4488,7 @@ async function runAfterMutationHooks(hooks, ctx, result, onHookError) {
           error,
           hook.name || "anonymous",
           frozen,
-          "beforeMutation"
+          "afterMutation"
         );
         if (action === "continue") continue;
       }
@@ -4619,7 +4701,8 @@ function subquery(table) {
 function outerRef(column) {
   return {
     kind: "ref",
-    column
+    column,
+    outer: true
   };
 }
 function isSubqueryExpression(value) {
@@ -7056,10 +7139,9 @@ function stream(builder, options) {
           };
           let hookIntent = rawIntent;
           try {
-            const afterHookCtx = await runBeforeQueryHooks(
-              hookStore.beforeQuery,
-              ctx,
-              onHookError
+            const afterHookCtx = await withReentrancyGuard(
+              hookStore,
+              (s) => runBeforeQueryHooks(s.beforeQuery, ctx, onHookError)
             );
             hookIntent = afterHookCtx.intent;
           } catch (error) {
@@ -7515,6 +7597,13 @@ var QueryBuilderImpl = class _QueryBuilderImpl {
           "join(batchValuesRef): an `on` condition is required for BatchValues joins"
         );
       }
+      validateIdentifier(bv.alias, "alias");
+      for (const col2 of bv.columns) {
+        validateIdentifier(col2, "column");
+      }
+      if (opts.as !== void 0) {
+        validateIdentifier(opts.as, "alias");
+      }
       const joinIntent = {
         batchValues: {
           data: bv.data,
@@ -7530,6 +7619,9 @@ var QueryBuilderImpl = class _QueryBuilderImpl {
       builder.joinIntents.push(joinIntent);
     } else {
       validateIdentifier(relationOrTableOrBatch, "table");
+      if (opts?.as !== void 0) {
+        validateIdentifier(opts.as, "alias");
+      }
       const joinIntent = opts?.on ? {
         table: relationOrTableOrBatch,
         on: opts.on,