@dbsp/core 1.0.2 → 1.0.4

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
@@ -3662,6 +3749,23 @@ var DEFAULT_FEATURE_CHECKERS = Object.freeze([
       }
       return usages;
     }
+  },
+  // -----------------------------------------------------------------------
+  // Row-Level Security
+  // -----------------------------------------------------------------------
+  {
+    capability: "supportsDDLRowLevelSecurity",
+    feature: "rowLevelSecurity",
+    detectUsage(model) {
+      if (!model.tables) return [];
+      const usages = [];
+      for (const [tableName, table] of model.tables) {
+        if (table.rlsEnabled || table.policies?.length) {
+          usages.push({ table: tableName, detail: tableName });
+        }
+      }
+      return usages;
+    }
   }
 ]);
 
@@ -3772,11 +3876,12 @@ var WindowBuilder = class _WindowBuilder {
     };
   }
   /**
-   * Convert builder state to WindowIntent
+   * Convert builder state to WindowIntent — produces the correct discriminated branch.
+   * - ranking → RankingWindowIntent (no field)
+   * - aggregate → AggregateWindowIntent (field required; COUNT uses '*' when omitted)
+   * - offset → OffsetWindowIntent (field required)
    */
   toWindowIntent(alias) {
-    const fn2 = this.fnKind.fn;
-    const field = this.fnKind.type === "aggregate" || this.fnKind.type === "offset" ? this.fnKind.field : void 0;
     const over = {};
     if (this.partitions.length > 0) {
       over.partitionBy = this.partitions;
@@ -3784,16 +3889,31 @@ var WindowBuilder = class _WindowBuilder {
     if (this.orders.length > 0) {
       over.orderBy = this.orders;
     }
-    const intent = {
+    if (this.fnKind.type === "ranking") {
+      return {
+        kind: "window",
+        function: this.fnKind.fn,
+        alias,
+        over
+      };
+    }
+    if (this.fnKind.type === "offset") {
+      return {
+        kind: "window",
+        function: this.fnKind.fn,
+        field: this.fnKind.field,
+        alias,
+        over
+      };
+    }
+    const { field } = this.fnKind;
+    return {
       kind: "window",
-      function: fn2,
+      function: this.fnKind.fn,
+      ...field !== void 0 && { field },
       alias,
       over
     };
-    if (field !== void 0) {
-      return { ...intent, field };
-    }
-    return intent;
   }
 };
 function rowNumber() {
@@ -3871,7 +3991,6 @@ function inSubquery(field, query) {
   return {
     kind: "in",
     field: getColumnName(field),
-    values: [],
     subquery: expr.toIntent()
   };
 }
@@ -3986,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 }
@@ -4374,7 +4488,7 @@ async function runAfterMutationHooks(hooks, ctx, result, onHookError) {
           error,
           hook.name || "anonymous",
           frozen,
-          "beforeMutation"
+          "afterMutation"
         );
         if (action === "continue") continue;
       }
@@ -4587,7 +4701,8 @@ function subquery(table) {
 function outerRef(column) {
   return {
     kind: "ref",
-    column
+    column,
+    outer: true
   };
 }
 function isSubqueryExpression(value) {
@@ -4901,17 +5016,24 @@ var IntentBuilder = class _IntentBuilder {
    * DX-034: Now supports distinct flag for COUNT(DISTINCT field), etc.
    */
   addAggregate(func, field, options) {
-    const agg = { function: func };
-    if (field !== void 0) {
-      agg.field = field;
-    } else if (options?.field !== void 0) {
-      agg.field = options.field;
-    }
-    if (options?.as !== void 0) {
-      agg.as = options.as;
-    }
-    if (options?.distinct) {
-      agg.distinct = true;
+    const resolvedField = field ?? options?.field;
+    const as = options?.as;
+    const distinct2 = options?.distinct ? true : void 0;
+    let agg;
+    if (func === "count") {
+      agg = {
+        function: "count",
+        ...resolvedField !== void 0 && { field: resolvedField },
+        ...as !== void 0 && { as },
+        ...distinct2 !== void 0 && { distinct: distinct2 }
+      };
+    } else {
+      agg = {
+        function: func,
+        field: resolvedField ?? "",
+        ...as !== void 0 && { as },
+        ...distinct2 !== void 0 && { distinct: distinct2 }
+      };
     }
     this.state.aggregates.push(agg);
   }
@@ -5956,7 +6078,20 @@ var UpsertBuilder = class _UpsertBuilder extends MutationBuilderBase {
 };
 
 // src/dx/negotiate-features.ts
-import { UnsupportedFeatureError } from "@dbsp/types";
+var UnsupportedFeatureError = class extends Error {
+  constructor(feature, adapter, element) {
+    super(
+      `Unsupported feature "${feature}" on adapter "${adapter}" for "${element}"`
+    );
+    this.feature = feature;
+    this.adapter = adapter;
+    this.element = element;
+    this.name = "UnsupportedFeatureError";
+  }
+  feature;
+  adapter;
+  element;
+};
 function resolveBehavior(feature, config) {
   if (typeof config === "string") return config;
   return config.overrides?.[feature] ?? config.default;
@@ -7004,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) {
@@ -7210,27 +7344,25 @@ var QueryBuilderImpl = class _QueryBuilderImpl {
   }
   count(fieldOrOptions, as) {
     const builder = this.clone();
-    const agg = { function: "count" };
+    let field;
+    let alias = as;
+    let distinct2;
     if (fieldOrOptions === void 0) {
     } else if (typeof fieldOrOptions === "string") {
-      agg.field = fieldOrOptions;
-      if (as !== void 0) {
-        agg.as = as;
-      }
+      field = fieldOrOptions;
     } else if (isDistinctField(fieldOrOptions)) {
-      agg.field = fieldOrOptions.field;
-      agg.distinct = true;
-      if (as !== void 0) {
-        agg.as = as;
-      }
+      field = fieldOrOptions.field;
+      distinct2 = true;
     } else {
-      if (fieldOrOptions.field !== void 0) {
-        agg.field = fieldOrOptions.field;
-      }
-      if (fieldOrOptions.as !== void 0) {
-        agg.as = fieldOrOptions.as;
-      }
-    }
+      field = fieldOrOptions.field;
+      alias = fieldOrOptions.as ?? as;
+    }
+    const agg = {
+      function: "count",
+      ...field !== void 0 && { field },
+      ...alias !== void 0 && { as: alias },
+      ...distinct2 !== void 0 && { distinct: distinct2 }
+    };
     builder.aggregates.push(agg);
     return builder;
   }
@@ -7238,13 +7370,12 @@ var QueryBuilderImpl = class _QueryBuilderImpl {
     const builder = this.clone();
     const isDistinct = isDistinctField(field);
     const fieldName = isDistinct ? field.field : field;
-    const agg = { function: "sum", field: fieldName };
-    if (isDistinct) {
-      agg.distinct = true;
-    }
-    if (as !== void 0) {
-      agg.as = as;
-    }
+    const agg = {
+      function: "sum",
+      field: fieldName,
+      ...isDistinct && { distinct: true },
+      ...as !== void 0 && { as }
+    };
     builder.aggregates.push(agg);
     return builder;
   }
@@ -7252,31 +7383,32 @@ var QueryBuilderImpl = class _QueryBuilderImpl {
     const builder = this.clone();
     const isDistinct = isDistinctField(field);
     const fieldName = isDistinct ? field.field : field;
-    const agg = { function: "avg", field: fieldName };
-    if (isDistinct) {
-      agg.distinct = true;
-    }
-    if (as !== void 0) {
-      agg.as = as;
-    }
+    const agg = {
+      function: "avg",
+      field: fieldName,
+      ...isDistinct && { distinct: true },
+      ...as !== void 0 && { as }
+    };
     builder.aggregates.push(agg);
     return builder;
   }
   min(field, as) {
     const builder = this.clone();
-    const agg = { function: "min", field };
-    if (as !== void 0) {
-      agg.as = as;
-    }
+    const agg = {
+      function: "min",
+      field,
+      ...as !== void 0 && { as }
+    };
     builder.aggregates.push(agg);
     return builder;
   }
   max(field, as) {
     const builder = this.clone();
-    const agg = { function: "max", field };
-    if (as !== void 0) {
-      agg.as = as;
-    }
+    const agg = {
+      function: "max",
+      field,
+      ...as !== void 0 && { as }
+    };
     builder.aggregates.push(agg);
     return builder;
   }
@@ -7465,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,
@@ -7480,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,
@@ -8281,7 +8423,9 @@ var QueryBuilderImpl = class _QueryBuilderImpl {
     const builder = new _QueryBuilderImpl(
       { ...this.ctx, ...ctxOverride },
       this.from,
-      { ...this.relationHints }
+      {
+        ...this.relationHints
+      }
     );
     builder.includes.push(...this.includes);
     builder.recursiveIncludes.push(...this.recursiveIncludes);
@@ -9255,6 +9399,7 @@ function rangeOverlaps(fieldOrColumn, valueOrRange, rangeType = "daterange") {
     kind: "range",
     field: fieldOrColumn,
     operator: "overlaps",
+    // Cast: non-array branch is RangeOperand (tuple path already returned above)
     value: valueOrRange
   };
 }
@@ -10064,7 +10209,8 @@ var FEATURE_TO_FLAG = {
   indexOpclass: "supportsDDLIndexOpclass",
   indexInclude: "supportsDDLIndexInclude",
   partialIndex: "supportsDDLPartialIndexes",
-  expressionIndex: "supportsDDLExpressionIndexes"
+  expressionIndex: "supportsDDLExpressionIndexes",
+  rowLevelSecurity: "supportsDDLRowLevelSecurity"
 };
 function createDialectCapabilities(overrides, options) {
   const result = {
@@ -11278,6 +11424,7 @@ export {
   UnknownDialectError,
   UnsafeOperationError,
   UnsupportedCapabilityError,
+  UnsupportedFeatureError,
   UnsupportedStrategyError,
   UpdateBuilder,
   UpsertBuilder,