@dbsp/core 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -1726,6 +1726,36 @@ declare class ModelIRImpl implements ModelIR {
     private detectCircularRelations;
 }
 
+/**
+ * Validate a PostgreSQL type name for use in CAST($N AS type[]).
+ *
+ * Accepted grammar (structured, not a broad character-class):
+ *   typeName = trim(base [modifier] [arraySuffix])
+ *
+ *   arraySuffix = "[]"          — at most ONE level; "int4[][]" is rejected as a
+ *                                  raw type-name input (array-ness is handled by the
+ *                                  batch-values layer which appends its own "[]").
+ *   modifier    = "(" digits ")" | "(" digits "," digits ")"
+ *                                — e.g. "(255)", "(10,2)"; any other parenthesised
+ *                                  content is rejected.
+ *   base        = multiWordType | ident | ident "." ident
+ *   multiWordType = one of: "timestamp with time zone",
+ *                           "timestamp without time zone",
+ *                           "time with time zone",
+ *                           "time without time zone",
+ *                           "double precision",
+ *                           "character varying",
+ *                           "bit varying"
+ *   ident       = [A-Za-z_][A-Za-z0-9_]*
+ *
+ * Examples that pass: int4, text, uuid, numeric(10,2), varchar(255),
+ *   timestamp with time zone, myschema.myenum, int4[].
+ * Examples that throw: empty string, int4[][], int4) ; DROP TABLE x; --,
+ *   foo'bar, int4)); JOIN users ON true.
+ *
+ * @internal — exported for adapter compile-time revalidation only.
+ */
+declare function validateTypeName(typeName: string): void;
 /**
  * BatchValuesRef — a virtual batch data source backed by unnest($1::type[], ...).
  *
@@ -2573,15 +2603,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 +2628,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;
@@ -8144,4 +8184,4 @@ declare const assertIntentHasOrderBy: (result: AssertionQueryResult, expected: b
  */
 declare function runAssertions(blocks: AssertionBlock[], results: AssertionQueryResult[], queries: string[], hasDb?: boolean): AssertionSummary;
 
-export { ASSERTION_TYPES, AdapterRequiredError, type AdjacencyOptions, type AfterMutationHook, type AfterQueryHook, type AggregateOptions, type AliasedColumn, type AliasedExprColumn, type AllColumns, AmbiguousPlanError, AmbiguousRelationError, type Assertion, type AssertionBlock, type AssertionOutcome, type AssertionQueryResult, type AssertionSummary, type AssertionType, BRAND, type BatchValuesOptions, type BatchValuesRef, type BeforeMutationHook, type BeforeQueryHook, type BrandKey, COLUMN_META, type CardinalityShorthand, CaseBuilder, type CaseValue, type ColumnDef, type ColumnMetaKey, ColumnNotFoundError, type ColumnRef, type ColumnSpec, type ColumnTypeToTS, CteBuilder, type CteDump, CteQueryBuilder, type CursorPaginateOptions, type CursorPaginatedResult, DEFAULT_CONVENTIONS, DEFAULT_FEATURE_CHECKERS, DUCKDB_CAPABILITIES, type DefaultFilters, type DefineModelOptions, DeleteBuilder, type DistinctField, type DumpMetaInput, type EdgeTableOptions, ErrorCode, type ErrorHookContext, Errors, ExecutionError, type ExprInput, ExpressionRef, type ExpressionSpec, type FeatureChecker, type FeatureUsage, type FilterOperators, type FilterValue, type FullTextSearchField, type FullTextSearchOptions, type GeneratedBelongsTo, type GeneratedColumn, type GeneratedColumnType, type GeneratedConventions, type GeneratedHasMany, type GeneratedHint, type GeneratedManyToMany, type GeneratedRelation, type GeneratedRelationKind, type GeneratedSchema, type GeneratedTable, type GetSchemaFromDbOptions, type HierarchyOptions, type HookErrorHandler, type HookManager, type HookPriority, type HydrateOptions, IRREGULAR_PLURALS, type IncludeOptions, type IncludeOptionsWithRecursive, type InferColumn, type InferColumnType, type InferColumnTypes, type InferDB, type InferDBFromSchema, type InferRefColumn, type InferRow, type InferRowType, type InferSchemaDB, type InferTableRow, type InferTables, type InferredRangeValue, InsertBuilder, IntentBuilder, type IntentBuilderState, type IntentSummary, InvalidOperationError, InvalidRelationDefinitionError, type JoinOptions, type JsonValue, type LightweightRelationsDef, type ListHierarchyOptions, type ListIndexOptions, type Logger, MSSQL_CAPABILITIES, MYSQL_CAPABILITIES, ModelIRImpl, type MutationDump, type MutationHookContext, type MutationOperation, NamingConventionMismatchError, type NegotiationResult, type NestedInclude, type SchemaColumnType$1 as NewSchemaColumnType, NotFoundError, type NqlBuilder, type NqlTag, type OnErrorHook, type OrderByInput, type OrderByRecord, type OrderBySpec, type OrmInstance, type OrmOf, type OrmOptions, type OrmOptionsWithAdapter, type OrmOptionsWithModel, type OrmOptionsWithSchema, POSTGRESQL_CAPABILITIES, type PaginateOptions, type PaginatedResult, type ParseError, type ParseResult, type ParsedRelationDef, type ParsedRelationKey, type PathOptions, type PrioritizedHook, type QueryAssertionResult, type QueryBuilder, type QueryHookContext, type QueryResultType, RELATION_META, type RangeType, RawCteQueryBuilder, type RecursiveDump, type RecursiveIncludeConfig, type RecursiveOptions, RecursiveShapeMismatchError, type RefDefinition, type RefOptions, type RelationHints, type RelationKey, type RelationMetaKey, RelationNotFoundError, type RelationObjectDef, type RelationRef, type RelationShorthand, type RelationTupleDef, type ResolvedSchema, ResolvedSchemaValidation, ResultHydrator, SQLITE_CAPABILITIES, SQL_RAW_MARKER, type Schema, type SchemaBelongsToRelation, type SchemaCardinality, type SchemaColumnDefinition, type SchemaColumnType, type SchemaConfigInput, type SchemaConstraints, type SchemaConventionsDefinition, type SchemaConversionResult, type SchemaDefinition, type SchemaDefinitionInput, SchemaValidationError$1 as SchemaError, type SchemaExtras, type SchemaFilterStrategy, type SchemaForeignKeyReference, type SchemaHasManyRelation, type SchemaHintDefinition, type SchemaHintsDefinition, type SchemaIndexDefinition, type SchemaIndexOptions, type SchemaIndexesDefinition, type SchemaManyToManyRelation, type SchemaOnDeleteAction, type SchemaOptions, type SchemaRelationDefinition, type SchemaRelationKind, type SchemaRelationsDefinition, type SchemaTableDefinition, type SchemaTableOptions, type SchemaTablesDefinition, SchemaValidationError, type SelectField, type SelfRefRoles, type SetOperationBuilder, type SimplifiedOrmOptions, type SqlRawExpression, type StreamOptions, SubqueryBuilder, SubqueryExpression, TABLE_META, type TableAssertionData, type TableDDL, type TableDef, type TableIndexes, type TableMetaKey, TableNotFoundError, type TableRef, type TraversalDirection, UnhandledTypeInDialect, UnknownDialectError, UnsafeOperationError, UnsupportedCapabilityError, UnsupportedFeatureError, UnsupportedStrategyError, UpdateBuilder, UpsertBuilder, type ValidatedResolvedSchema, type WhereFilter, WindowBuilder, aggOrderBy, and, any, array, arrayAgg, assertCapability, assertContains, assertDbColumnExists, assertDbOutput, assertDbRowsEquals, assertDbRowsMax, assertDbRowsMin, assertDbValueEquals, assertEquals, assertIntentHasGroupBy, assertIntentHasOrderBy, assertIntentHasWhere, assertIntentTable, assertIntentType, assertIntentWith, assertMatches, assertParamsEquals, assertParamsLength, assertParamsType, assertParamsValue, assertResolvedSchemaToGeneratedSchema, assertSQLColumn, assertSQLEquals, assertSQLJoin, assertSQLTable, assertSuccess, assertTypeSupported, batchValues, buildModelFromResolvedSchema, buildModelFromSchema, capitalize, caseWhen, cast, coalesce, col, composeAfterMutationHooks, composeAfterQueryHooks, composeBeforeMutationHooks, composeBeforeQueryHooks, composeOnErrorHooks, createDialectCapabilities, createHookManager, createNqlTag, createOrm, createPseudoColumnMetadata, createRawCteBuilder, createRecursiveMetadata, decapitalize, defaultLogger, defineModel, defineSchema, denseRank, detectForeignKeys, detectManyToMany, distinct, eq, every, exists, ref as exprRef, extendDialect, extractPseudoColumnKeywords, findClosestMatch, fn, fullTextSearch, getAvailableDialects, getDialectCapabilities, getLogger, getRelationKind, getSchemaFromDb, gt, gte, inArray, inSubquery, inferForeignKey, inferRelationsFromSchema, isAliasedColumn, isAllColumns, isBatchValuesRef, isBelongsTo, isCardinalityShorthand, isColumnRef, isDistinctField, isDistinctFrom, isExpressionSpec, isGeneratedSchema, isHasMany, isKnownDialect, isManyToMany, isNotNull, isNull, isOverallSuccess, isRecursiveIncludeOptions, isRecursiveRelation, isRef, isRelationObjectDef, isRelationRef, isRelationTupleDef, isResolvedSchema, isSelfReferential, isSqlRaw, isSubqueryExpression, isTableRef, isWhereIntent, lag, lead, like, literal, lt, lte, namedArg, negotiateFeatures, neq, none, normalizeSQL, normalizeSchema, not, notExists, objectToWhereIntent, op, or, outerRef, param, parseAssertionFile, parseRelationDef, parseRelationKey, pipeAfterMutationHooks, pipeAfterQueryHooks, pipeBeforeMutationHooks, pipeBeforeQueryHooks, pipeOnErrorHooks, plan, planRecursive, pluralize, rangeContainedBy, rangeContains, rangeOverlaps, rank, raw, rawExists, rawNotExists, ref$1 as ref, registerDialect, relationColumn, requiresDatabase, resetLogger, resolveQueryIndex, resolvedSchemaToGeneratedSchema, rowNumber, runAssertions, schema, schemaToModelIR, setLogger, silentLogger, singularize, some, sortByPriority, sql, star, stringAgg, subquery, supportsDDLGeneration, supportsExecution, supportsIntrospection, supportsRawSql, supportsStreaming, supportsTransactions, textScore, unary, validateAssertionBlocks, validateRecursiveInclude, validateRecursiveShape, wAvg, wCount, wMax, wMin, wSum, withPriority };
+export { ASSERTION_TYPES, AdapterRequiredError, type AdjacencyOptions, type AfterMutationHook, type AfterQueryHook, type AggregateOptions, type AliasedColumn, type AliasedExprColumn, type AllColumns, AmbiguousPlanError, AmbiguousRelationError, type Assertion, type AssertionBlock, type AssertionOutcome, type AssertionQueryResult, type AssertionSummary, type AssertionType, BRAND, type BatchValuesOptions, type BatchValuesRef, type BeforeMutationHook, type BeforeQueryHook, type BrandKey, COLUMN_META, type CardinalityShorthand, CaseBuilder, type CaseValue, type ColumnDef, type ColumnMetaKey, ColumnNotFoundError, type ColumnRef, type ColumnSpec, type ColumnTypeToTS, CteBuilder, type CteDump, CteQueryBuilder, type CursorPaginateOptions, type CursorPaginatedResult, DEFAULT_CONVENTIONS, DEFAULT_FEATURE_CHECKERS, DUCKDB_CAPABILITIES, type DefaultFilters, type DefineModelOptions, DeleteBuilder, type DistinctField, type DumpMetaInput, type EdgeTableOptions, ErrorCode, type ErrorHookContext, Errors, ExecutionError, type ExprInput, ExpressionRef, type ExpressionSpec, type FeatureChecker, type FeatureUsage, type FilterOperators, type FilterValue, type FullTextSearchField, type FullTextSearchOptions, type GeneratedBelongsTo, type GeneratedColumn, type GeneratedColumnType, type GeneratedConventions, type GeneratedHasMany, type GeneratedHint, type GeneratedManyToMany, type GeneratedRelation, type GeneratedRelationKind, type GeneratedSchema, type GeneratedTable, type GetSchemaFromDbOptions, type HierarchyOptions, type HookErrorHandler, type HookManager, type HookPriority, type HydrateOptions, IRREGULAR_PLURALS, type IncludeOptions, type IncludeOptionsWithRecursive, type InferColumn, type InferColumnType, type InferColumnTypes, type InferDB, type InferDBFromSchema, type InferRefColumn, type InferRow, type InferRowType, type InferSchemaDB, type InferTableRow, type InferTables, type InferredRangeValue, InsertBuilder, IntentBuilder, type IntentBuilderState, type IntentSummary, InvalidOperationError, InvalidRelationDefinitionError, type JoinOptions, type JsonValue, type LightweightRelationsDef, type ListHierarchyOptions, type ListIndexOptions, type Logger, MSSQL_CAPABILITIES, MYSQL_CAPABILITIES, ModelIRImpl, type MutationDump, type MutationHookContext, type MutationOperation, NamingConventionMismatchError, type NegotiationResult, type NestedInclude, type SchemaColumnType$1 as NewSchemaColumnType, NotFoundError, type NqlBuilder, type NqlTag, type OnErrorHook, type OrderByInput, type OrderByRecord, type OrderBySpec, type OrmInstance, type OrmOf, type OrmOptions, type OrmOptionsWithAdapter, type OrmOptionsWithModel, type OrmOptionsWithSchema, POSTGRESQL_CAPABILITIES, type PaginateOptions, type PaginatedResult, type ParseError, type ParseResult, type ParsedRelationDef, type ParsedRelationKey, type PathOptions, type PrioritizedHook, type QueryAssertionResult, type QueryBuilder, type QueryHookContext, type QueryResultType, RELATION_META, type RangeType, RawCteQueryBuilder, type RecursiveDump, type RecursiveIncludeConfig, type RecursiveOptions, RecursiveShapeMismatchError, type RefDefinition, type RefOptions, type RelationHints, type RelationKey, type RelationMetaKey, RelationNotFoundError, type RelationObjectDef, type RelationRef, type RelationShorthand, type RelationTupleDef, type ResolvedSchema, ResolvedSchemaValidation, ResultHydrator, SQLITE_CAPABILITIES, SQL_RAW_MARKER, type Schema, type SchemaBelongsToRelation, type SchemaCardinality, type SchemaColumnDefinition, type SchemaColumnType, type SchemaConfigInput, type SchemaConstraints, type SchemaConventionsDefinition, type SchemaConversionResult, type SchemaDefinition, type SchemaDefinitionInput, SchemaValidationError$1 as SchemaError, type SchemaExtras, type SchemaFilterStrategy, type SchemaForeignKeyReference, type SchemaHasManyRelation, type SchemaHintDefinition, type SchemaHintsDefinition, type SchemaIndexDefinition, type SchemaIndexOptions, type SchemaIndexesDefinition, type SchemaManyToManyRelation, type SchemaOnDeleteAction, type SchemaOptions, type SchemaRelationDefinition, type SchemaRelationKind, type SchemaRelationsDefinition, type SchemaTableDefinition, type SchemaTableOptions, type SchemaTablesDefinition, SchemaValidationError, type SelectField, type SelfRefRoles, type SetOperationBuilder, type SimplifiedOrmOptions, type SqlRawExpression, type StreamOptions, SubqueryBuilder, SubqueryExpression, TABLE_META, type TableAssertionData, type TableDDL, type TableDef, type TableIndexes, type TableMetaKey, TableNotFoundError, type TableRef, type TraversalDirection, UnhandledTypeInDialect, UnknownDialectError, UnsafeOperationError, UnsupportedCapabilityError, UnsupportedFeatureError, UnsupportedStrategyError, UpdateBuilder, UpsertBuilder, type ValidatedResolvedSchema, type WhereFilter, WindowBuilder, aggOrderBy, and, any, array, arrayAgg, assertCapability, assertContains, assertDbColumnExists, assertDbOutput, assertDbRowsEquals, assertDbRowsMax, assertDbRowsMin, assertDbValueEquals, assertEquals, assertIntentHasGroupBy, assertIntentHasOrderBy, assertIntentHasWhere, assertIntentTable, assertIntentType, assertIntentWith, assertMatches, assertParamsEquals, assertParamsLength, assertParamsType, assertParamsValue, assertResolvedSchemaToGeneratedSchema, assertSQLColumn, assertSQLEquals, assertSQLJoin, assertSQLTable, assertSuccess, assertTypeSupported, batchValues, buildModelFromResolvedSchema, buildModelFromSchema, capitalize, caseWhen, cast, coalesce, col, composeAfterMutationHooks, composeAfterQueryHooks, composeBeforeMutationHooks, composeBeforeQueryHooks, composeOnErrorHooks, createDialectCapabilities, createHookManager, createNqlTag, createOrm, createPseudoColumnMetadata, createRawCteBuilder, createRecursiveMetadata, decapitalize, defaultLogger, defineModel, defineSchema, denseRank, detectForeignKeys, detectManyToMany, distinct, eq, every, exists, ref as exprRef, extendDialect, extractPseudoColumnKeywords, findClosestMatch, fn, fullTextSearch, getAvailableDialects, getDialectCapabilities, getLogger, getRelationKind, getSchemaFromDb, gt, gte, inArray, inSubquery, inferForeignKey, inferRelationsFromSchema, isAliasedColumn, isAllColumns, isBatchValuesRef, isBelongsTo, isCardinalityShorthand, isColumnRef, isDistinctField, isDistinctFrom, isExpressionSpec, isGeneratedSchema, isHasMany, isKnownDialect, isManyToMany, isNotNull, isNull, isOverallSuccess, isRecursiveIncludeOptions, isRecursiveRelation, isRef, isRelationObjectDef, isRelationRef, isRelationTupleDef, isResolvedSchema, isSelfReferential, isSqlRaw, isSubqueryExpression, isTableRef, isWhereIntent, lag, lead, like, literal, lt, lte, namedArg, negotiateFeatures, neq, none, normalizeSQL, normalizeSchema, not, notExists, objectToWhereIntent, op, or, outerRef, param, parseAssertionFile, parseRelationDef, parseRelationKey, pipeAfterMutationHooks, pipeAfterQueryHooks, pipeBeforeMutationHooks, pipeBeforeQueryHooks, pipeOnErrorHooks, plan, planRecursive, pluralize, rangeContainedBy, rangeContains, rangeOverlaps, rank, raw, rawExists, rawNotExists, ref$1 as ref, registerDialect, relationColumn, requiresDatabase, resetLogger, resolveQueryIndex, resolvedSchemaToGeneratedSchema, rowNumber, runAssertions, schema, schemaToModelIR, setLogger, silentLogger, singularize, some, sortByPriority, sql, star, stringAgg, subquery, supportsDDLGeneration, supportsExecution, supportsIntrospection, supportsRawSql, supportsStreaming, supportsTransactions, textScore, unary, validateAssertionBlocks, validateRecursiveInclude, validateRecursiveShape, validateTypeName, wAvg, wCount, wMax, wMin, wSum, withPriority };

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,
@@ -11550,6 +11642,7 @@ export {
   validateAssertionBlocks,
   validateRecursiveInclude,
   validateRecursiveShape,
+  validateTypeName,
   wAvg,
   wCount,
   wMax,