@dbsp/core 1.9.0 → 1.10.1

package/dist/index.js

@@ -60,6 +60,7 @@ import * as types_star from "@dbsp/types";
 // src/model-impl.ts
 var ModelIRImpl = class {
   tables;
+  externalTables;
   relations;
   enums;
   extensions;
@@ -67,8 +68,11 @@ var ModelIRImpl = class {
   // Pre-computed indexes for efficient lookups
   relationsBySource;
   relationsByTarget;
-  constructor(tables, relations, enums, extensions, sequences) {
+  constructor(tables, relations, enums, extensions, sequences, externalTables) {
     this.tables = Object.freeze(new Map(tables));
+    this.externalTables = Object.freeze(
+      new Set(externalTables)
+    );
     this.relations = Object.freeze(new Map(relations));
     if (enums) {
       this.enums = Object.freeze(new Map(enums));
@@ -156,6 +160,11 @@ var ModelIRImpl = class {
   validate() {
     const errors = [];
     for (const table of this.tables.values()) {
+      if (this.externalTables.has(table.name)) {
+        errors.push(
+          `Table "${table.name}" cannot be both managed and external`
+        );
+      }
       if (table.primaryKey) {
         const pkCols = Array.isArray(table.primaryKey) ? table.primaryKey : [table.primaryKey];
         for (const pk of pkCols) {
@@ -169,7 +178,7 @@ var ModelIRImpl = class {
     }
     for (const table of this.tables.values()) {
       for (const fk of table.foreignKeys) {
-        if (!this.tables.has(fk.references.table)) {
+        if (!this.tables.has(fk.references.table) && !this.externalTables.has(fk.references.table)) {
           errors.push(
             `Table "${table.name}" has FK referencing non-existent table "${fk.references.table}"`
           );
@@ -3210,144 +3219,554 @@ function batchValues(data, columns, types, opts) {
   });
 }
 
-// src/dx/expressions.ts
-var OPERATOR_PATTERN = /^[a-zA-Z_<>=!@#%^&|~*+\-/.]+$/;
-var FUNCTION_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
-var TYPE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\[\])?$/;
-function toExpressionIntent(input) {
-  if (input instanceof ExpressionRef) return input.intent;
-  if (typeof input === "object" && input !== null && "__expr" in input && input.__expr === true && "intent" in input) {
-    return input.intent;
+// src/dx/column-utils.ts
+function getColumnName(field) {
+  if (typeof field === "string") {
+    return field;
   }
-  if (typeof input === "string") {
-    return { kind: "ref", column: input };
+  const colName = field[COLUMN_META];
+  if (colName === void 0) {
+    throw new Error("Invalid ColumnRef: missing COLUMN_META");
   }
-  return { kind: "param", value: input };
+  return colName;
 }
-var ExpressionRef = class _ExpressionRef {
-  __expr = true;
-  intent;
-  constructor(intent) {
-    this.intent = intent;
+
+// src/dx/window-functions.ts
+var WindowBuilder = class _WindowBuilder {
+  constructor(fnKind, partitions = [], orders = []) {
+    this.fnKind = fnKind;
+    this.partitions = partitions;
+    this.orders = orders;
   }
+  fnKind;
+  partitions;
+  orders;
   /**
-   * Set an alias for this expression in SELECT.
-   * Returns a new ExpressionRef — does not mutate.
+   * Create a ranking window builder (row_number, rank, dense_rank)
+   * @internal Use factory functions instead: rowNumber(), rank(), denseRank()
    */
-  as(alias) {
-    return new _ExpressionRef({
-      ...this.intent,
-      as: alias
-    });
-  }
-  /** WHERE: expr = value */
-  eq(value) {
-    return { kind: "expression", expr: this.intent, operator: "eq", value };
-  }
-  /** WHERE: expr != value */
-  neq(value) {
-    return { kind: "expression", expr: this.intent, operator: "neq", value };
+  static ranking(fn2) {
+    return new _WindowBuilder({ type: "ranking", fn: fn2 });
   }
-  /** WHERE: expr > value */
-  gt(value) {
-    return { kind: "expression", expr: this.intent, operator: "gt", value };
+  /**
+   * Create an aggregate window builder (sum, avg, count, min, max)
+   * @internal Use factory functions instead: sum(field), avg(field), etc.
+   */
+  static aggregate(fn2, field) {
+    return new _WindowBuilder({
+      type: "aggregate",
+      fn: fn2,
+      ...field !== void 0 ? { field } : {}
+    });
   }
-  /** WHERE: expr >= value */
-  gte(value) {
-    return { kind: "expression", expr: this.intent, operator: "gte", value };
+  /**
+   * Create an offset window builder (lag, lead)
+   * @internal Use factory functions instead: lag(field), lead(field)
+   */
+  static offset(fn2, field) {
+    return new _WindowBuilder({ type: "offset", fn: fn2, field });
   }
-  /** WHERE: expr < value */
-  lt(value) {
-    return { kind: "expression", expr: this.intent, operator: "lt", value };
+  /**
+   * Add partition field(s) to the OVER clause.
+   * Multiple calls APPEND fields (not replace).
+   * Supports both string field names and ColumnRef (DX-040).
+   *
+   * @example
+   * sum('amount').partitionBy('user_id').partitionBy('category')
+   * // → PARTITION BY "user_id", "category"
+   *
+   * @example DX-040 with ColumnRef
+   * rank().partitionBy(users.dept).orderBy(users.salary, 'desc')
+   */
+  partitionBy(...fields) {
+    const fieldNames = fields.map(
+      (f) => typeof f === "string" ? f : getColumnName(f)
+    );
+    return new _WindowBuilder(
+      this.fnKind,
+      [...this.partitions, ...fieldNames],
+      this.orders
+    );
   }
-  /** WHERE: expr <= value */
-  lte(value) {
-    return { kind: "expression", expr: this.intent, operator: "lte", value };
+  /**
+   * Add order field to the OVER clause.
+   * Multiple calls APPEND fields (not replace).
+   * Supports both string field names and ColumnRef (DX-040).
+   *
+   * @param field - Column name or ColumnRef to order by
+   * @param direction - Sort direction: 'asc' (default) or 'desc'
+   *
+   * @example
+   * rowNumber().orderBy('created_at').orderBy('id', 'desc')
+   * // → ORDER BY "created_at" ASC, "id" DESC
+   *
+   * @example DX-040 with ColumnRef
+   * rank().partitionBy(users.dept).orderBy(users.salary, 'desc')
+   */
+  orderBy(field, direction = "asc") {
+    const fieldName = typeof field === "string" ? field : getColumnName(field);
+    return new _WindowBuilder(this.fnKind, this.partitions, [
+      ...this.orders,
+      { field: fieldName, direction }
+    ]);
   }
   /**
-   * Add a FILTER (WHERE ...) clause to this function expression.
-   * Only valid on `fn()` expressions (customFn kind).
-   * Returns a new ExpressionRef — does not mutate.
+   * Finalize the window expression with an alias.
+   * Returns ExpressionSpec for use in columns().
    *
-   * @example fn('array_agg', ref('name')).filter(eq('active', true))
-   *          → array_agg("name") FILTER (WHERE "active" = $1)
-   * @throws Error if called on non-customFn expressions
+   * @param alias - Required alias for the result column
+   *
+   * @example
+   * columns(['id', rowNumber().orderBy('date').as('rn')])
    */
-  filter(condition) {
-    if (this.intent.kind !== "customFn") {
-      throw new Error(
-        `filter() can only be used on function expressions created with fn(). Got kind: '${this.intent.kind}'`
-      );
+  as(alias) {
+    return {
+      __expr: true,
+      intent: this.toWindowIntent(alias)
+    };
+  }
+  /**
+   * 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 over = {};
+    if (this.partitions.length > 0) {
+      over.partitionBy = this.partitions;
     }
-    return new _ExpressionRef({
-      ...this.intent,
-      filter: condition
-    });
+    if (this.orders.length > 0) {
+      over.orderBy = this.orders;
+    }
+    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: this.fnKind.fn,
+      ...field !== void 0 && { field },
+      alias,
+      over
+    };
   }
 };
-function ref2(column) {
-  return new ExpressionRef({
-    kind: "ref",
-    column
-  });
+function rowNumber() {
+  return WindowBuilder.ranking("row_number");
 }
-function param(value) {
-  return new ExpressionRef({
-    kind: "param",
-    value
-  });
+function rank() {
+  return WindowBuilder.ranking("rank");
 }
-function cast(expr, typeName) {
-  if (!TYPE_NAME_PATTERN.test(typeName)) {
-    throw new Error(`Invalid type name: ${typeName}`);
-  }
-  return new ExpressionRef({
-    kind: "cast",
-    expr: expr.intent,
-    typeName
-  });
+function denseRank() {
+  return WindowBuilder.ranking("dense_rank");
 }
-function op(operator, left, right) {
-  if (!operator || !OPERATOR_PATTERN.test(operator)) {
-    throw new Error(`Invalid operator: ${operator}`);
-  }
-  return new ExpressionRef({
-    kind: "customOp",
-    operator,
-    left: toExpressionIntent(left),
-    right: toExpressionIntent(right)
-  });
+function wSum(field) {
+  return WindowBuilder.aggregate("sum", field);
 }
-function fn(name, ...args) {
-  if (!name || !FUNCTION_NAME_PATTERN.test(name)) {
-    throw new Error(`Invalid function name: ${name}`);
-  }
-  const regularArgs = [];
-  const orderByArgs = [];
-  for (const arg of args) {
-    if (isAggOrderByArg(arg)) {
-      orderByArgs.push(arg);
-    } else {
-      regularArgs.push(toExpressionIntent(arg));
-    }
-  }
-  const intent = {
-    kind: "customFn",
-    name,
-    args: regularArgs,
-    ...orderByArgs.length > 0 ? { aggOrderBy: orderByArgs } : {}
-  };
-  return new ExpressionRef(intent);
+function wAvg(field) {
+  return WindowBuilder.aggregate("avg", field);
 }
-function literal(value) {
-  return new ExpressionRef({
-    kind: "literal",
-    value
-  });
+function wCount(field) {
+  return WindowBuilder.aggregate("count", field);
 }
-function unary(operator, expr) {
-  if (!operator || !OPERATOR_PATTERN.test(operator)) {
-    throw new Error(`Invalid operator: ${operator}`);
+function wMin(field) {
+  return WindowBuilder.aggregate("min", field);
+}
+function wMax(field) {
+  return WindowBuilder.aggregate("max", field);
+}
+function lag(field) {
+  return WindowBuilder.offset("lag", field);
+}
+function lead(field) {
+  return WindowBuilder.offset("lead", field);
+}
+
+// src/dx/filters.ts
+function distinct(field) {
+  return { field, distinct: true };
+}
+function isDistinctField(value) {
+  return typeof value === "object" && value !== null && "field" in value && typeof value.field === "string" && "distinct" in value && value.distinct === true;
+}
+function createComparisonFilter(operator) {
+  return (field, value) => ({
+    kind: "comparison",
+    field: getColumnName(field),
+    operator,
+    value
+  });
+}
+var eq = createComparisonFilter("eq");
+var neq = createComparisonFilter("neq");
+var gt = createComparisonFilter("gt");
+var gte = createComparisonFilter("gte");
+var lt = createComparisonFilter("lt");
+var lte = createComparisonFilter("lte");
+var isDistinctFrom = createComparisonFilter("isDistinctFrom");
+function like(field, pattern, options) {
+  const caseInsensitive = typeof options === "boolean" ? options : options?.caseInsensitive;
+  const escapeChar = typeof options === "object" ? options.escape : void 0;
+  const intent = {
+    kind: "like",
+    field: getColumnName(field),
+    pattern
+  };
+  const withCi = caseInsensitive !== void 0 ? { ...intent, caseInsensitive } : intent;
+  if (escapeChar !== void 0) {
+    return { ...withCi, escape: escapeChar };
+  }
+  return withCi;
+}
+function inArray(field, values) {
+  return { kind: "in", field: getColumnName(field), values };
+}
+function inSubquery(field, query) {
+  const expr = "build" in query ? query.build() : query;
+  return {
+    kind: "in",
+    field: getColumnName(field),
+    subquery: expr.toIntent()
+  };
+}
+function any(field, values) {
+  return { kind: "any", field: getColumnName(field), values };
+}
+function isNull(field) {
+  return { kind: "null", field: getColumnName(field), operator: "isNull" };
+}
+function isNotNull(field) {
+  return { kind: "null", field: getColumnName(field), operator: "isNotNull" };
+}
+function and(...conditions) {
+  const flatConditions = conditions.length === 1 && Array.isArray(conditions[0]) ? conditions[0] : conditions;
+  return { kind: "and", conditions: flatConditions };
+}
+function or(...conditions) {
+  const flatConditions = conditions.length === 1 && Array.isArray(conditions[0]) ? conditions[0] : conditions;
+  return { kind: "or", conditions: flatConditions };
+}
+function not(condition) {
+  return { kind: "not", condition };
+}
+function exists(relation, options) {
+  const result = { kind: "exists", relation };
+  if (options?.where !== void 0) {
+    result.where = options.where;
+  }
+  if (options?.recursive !== void 0) {
+    result.recursive = options.recursive;
+  }
+  if (options?.include !== void 0) {
+    result.include = options.include;
+  }
+  return result;
+}
+function notExists(relation, options) {
+  const result = {
+    kind: "notExists",
+    relation
+  };
+  if (options?.where !== void 0) {
+    result.where = options.where;
+  }
+  if (options?.recursive !== void 0) {
+    result.recursive = options.recursive;
+  }
+  if (options?.include !== void 0) {
+    result.include = options.include;
+  }
+  return result;
+}
+function rawExists(sq) {
+  const intent = "buildIntent" in sq ? sq.buildIntent() : sq.build().toIntent();
+  return { kind: "rawExists", subquery: intent };
+}
+function rawNotExists(sq) {
+  const intent = "buildIntent" in sq ? sq.buildIntent() : sq.build().toIntent();
+  return { kind: "rawNotExists", subquery: intent };
+}
+function getRelationName(rel) {
+  const meta = rel[RELATION_META];
+  if (!meta) {
+    throw new Error("Invalid RelationRef: missing RELATION_META");
+  }
+  return meta.target;
+}
+function every(relation, filter) {
+  const relationName = getRelationName(relation);
+  const where = filter(relation);
+  return {
+    kind: "relationFilter",
+    relation: relationName,
+    where,
+    mode: "every"
+  };
+}
+function none(relation, filter) {
+  const relationName = getRelationName(relation);
+  const where = filter(relation);
+  return {
+    kind: "relationFilter",
+    relation: relationName,
+    where,
+    mode: "none"
+  };
+}
+function some(relation, filter) {
+  const relationName = getRelationName(relation);
+  const where = filter(relation);
+  return {
+    kind: "relationFilter",
+    relation: relationName,
+    where,
+    mode: "some"
+  };
+}
+function coalesce(fields, as) {
+  if (fields.length === 0) {
+    throw new Error("coalesce() requires at least one field");
+  }
+  if (!as || as.trim() === "") {
+    throw new Error("coalesce() requires a non-empty alias");
+  }
+  for (const f of fields) {
+    validateIdentifier(f, "column");
+  }
+  validateIdentifier(as, "column");
+  return {
+    __expr: true,
+    intent: { kind: "coalesce", fields, as }
+  };
+}
+function raw(sqlFragment, as) {
+  if (typeof as !== "string" || as.trim().length === 0) {
+    throw new InvalidOperationError(
+      "raw",
+      "raw() requires an alias as second argument, e.g. raw('COUNT(*)', 'count')"
+    );
+  }
+  validateIdentifier(as, "column");
+  return {
+    __expr: true,
+    intent: { kind: "raw", sql: sqlFragment, as }
+  };
+}
+function col(column, alias) {
+  validateIdentifier(column, "column");
+  validateIdentifier(alias, "column");
+  return {
+    __expr: true,
+    intent: { kind: "columnAlias", column, alias }
+  };
+}
+function relationColumn(relation, column, as) {
+  if (!relation) {
+    throw new Error("relationColumn() requires a non-empty relation path");
+  }
+  for (const segment of relation.split(".")) {
+    validateIdentifier(segment, "relation");
+  }
+  if (column !== "*") {
+    validateIdentifier(column, "column");
+  }
+  validateIdentifier(as, "column");
+  return {
+    __expr: true,
+    intent: { kind: "relationColumn", relation, column, as }
+  };
+}
+var SQL_RAW_MARKER = /* @__PURE__ */ Symbol.for("dbsp:raw-sql");
+function sql(sqlFragment) {
+  if (!sqlFragment || sqlFragment.trim() === "") {
+    throw new Error("sql() requires a non-empty SQL fragment");
+  }
+  return { [SQL_RAW_MARKER]: true, sql: sqlFragment };
+}
+function isSqlRaw(value) {
+  return typeof value === "object" && value !== null && SQL_RAW_MARKER in value && value[SQL_RAW_MARKER] === true;
+}
+
+// src/dx/expressions.ts
+var OPERATOR_PATTERN = /^[a-zA-Z_<>=!@#%^&|~*+\-/.]+$/;
+var FUNCTION_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/;
+var TYPE_NAME_PATTERN = /^[a-zA-Z_][a-zA-Z0-9_ ]*(\[\])?$/;
+function toExpressionIntent(input) {
+  if (input instanceof ExpressionRef) return input.intent;
+  if (typeof input === "object" && input !== null && "__expr" in input && input.__expr === true && "intent" in input) {
+    return input.intent;
+  }
+  if (typeof input === "string") {
+    return { kind: "ref", column: input };
+  }
+  return { kind: "param", value: input };
+}
+var ExpressionRef = class _ExpressionRef {
+  __expr = true;
+  intent;
+  constructor(intent) {
+    this.intent = intent;
+  }
+  /**
+   * Set an alias for this expression in SELECT.
+   * Returns a new ExpressionRef — does not mutate.
+   */
+  as(alias) {
+    return new _ExpressionRef({
+      ...this.intent,
+      as: alias
+    });
+  }
+  /** WHERE: expr = value */
+  eq(value) {
+    return { kind: "expression", expr: this.intent, operator: "eq", value };
+  }
+  /** WHERE: expr != value */
+  neq(value) {
+    return { kind: "expression", expr: this.intent, operator: "neq", value };
+  }
+  /** WHERE: expr > value */
+  gt(value) {
+    return { kind: "expression", expr: this.intent, operator: "gt", value };
+  }
+  /** WHERE: expr >= value */
+  gte(value) {
+    return { kind: "expression", expr: this.intent, operator: "gte", value };
+  }
+  /** WHERE: expr < value */
+  lt(value) {
+    return { kind: "expression", expr: this.intent, operator: "lt", value };
+  }
+  /** WHERE: expr <= value */
+  lte(value) {
+    return { kind: "expression", expr: this.intent, operator: "lte", value };
+  }
+  /**
+   * Add a FILTER (WHERE ...) clause to this function expression.
+   * Valid on `fn()` expressions (customFn kind), including DISTINCT calls
+   * produced by `fn(aggName, distinct(field))` (still customFn kind).
+   * Returns a new ExpressionRef — does not mutate.
+   *
+   * NOTE: the FILTER clause is only emitted when the expression is used in
+   * column position (`.columns([...])`) — the adapter patches it in at that
+   * one SELECT-list branch (compiler.ts). Using `.filter()` inside
+   * `.orderBy()`, `.having()`, `cast()`, or any other nested context compiles
+   * successfully but silently drops the FILTER clause (tracked separately,
+   * not specific to DISTINCT).
+   *
+   * @example fn('array_agg', ref('name')).filter(eq('active', true))
+   *          → array_agg("name") FILTER (WHERE "active" = $1)   // in .columns()
+   * @example fn('count', distinct('id')).filter(eq('active', true))
+   *          → count(DISTINCT id) FILTER (WHERE "active" = $1)  // in .columns()
+   * @throws Error if called on any other expression kind
+   */
+  filter(condition) {
+    if (this.intent.kind !== "customFn") {
+      throw new Error(
+        `filter() can only be used on function expressions created with fn(). Got kind: '${this.intent.kind}'`
+      );
+    }
+    return new _ExpressionRef({
+      ...this.intent,
+      filter: condition
+    });
+  }
+};
+function ref2(column) {
+  return new ExpressionRef({
+    kind: "ref",
+    column
+  });
+}
+function param(value) {
+  return new ExpressionRef({
+    kind: "param",
+    value
+  });
+}
+function cast(expr, typeName) {
+  if (!TYPE_NAME_PATTERN.test(typeName)) {
+    throw new Error(`Invalid type name: ${typeName}`);
+  }
+  return new ExpressionRef({
+    kind: "cast",
+    expr: expr.intent,
+    typeName
+  });
+}
+function op(operator, left, right) {
+  if (!operator || !OPERATOR_PATTERN.test(operator)) {
+    throw new Error(`Invalid operator: ${operator}`);
+  }
+  return new ExpressionRef({
+    kind: "customOp",
+    operator,
+    left: toExpressionIntent(left),
+    right: toExpressionIntent(right)
+  });
+}
+function fn(name, ...args) {
+  if (!name || !FUNCTION_NAME_PATTERN.test(name)) {
+    throw new Error(`Invalid function name: ${name}`);
+  }
+  const regularArgs = [];
+  const orderByArgs = [];
+  let distinct2 = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (isDistinctField2(arg)) {
+      if (i !== 0) {
+        throw new Error(
+          `fn('${name}', ...): distinct() is only supported as the first argument \u2014 SQL DISTINCT applies to the whole argument list, not a single position.`
+        );
+      }
+      const field = arg.field;
+      if (field === "*") {
+        throw new Error(
+          `fn('${name}', distinct('*')): DISTINCT on '*' is not valid SQL \u2014 '*' has no columns to deduplicate on. Provide a specific column, or omit distinct() (e.g. fn('${name}', star())) for a plain star call.`
+        );
+      }
+      distinct2 = true;
+      regularArgs.push(toExpressionIntent(field));
+    } else if (isAggOrderByArg(arg)) {
+      orderByArgs.push(arg);
+    } else {
+      regularArgs.push(toExpressionIntent(arg));
+    }
+  }
+  const intent = {
+    kind: "customFn",
+    name,
+    args: regularArgs,
+    ...distinct2 ? { distinct: true } : {},
+    ...orderByArgs.length > 0 ? { aggOrderBy: orderByArgs } : {}
+  };
+  return new ExpressionRef(intent);
+}
+function literal(value) {
+  return new ExpressionRef({
+    kind: "literal",
+    value
+  });
+}
+function unary(operator, expr) {
+  if (!operator || !OPERATOR_PATTERN.test(operator)) {
+    throw new Error(`Invalid operator: ${operator}`);
   }
   return new ExpressionRef({
     kind: "unary",
@@ -3374,6 +3793,9 @@ function array(...items) {
     elements: items.map(toExpressionIntent)
   });
 }
+function isDistinctField2(input) {
+  return !Array.isArray(input) && !(input instanceof ExpressionRef) && isDistinctField(input);
+}
 function isAggOrderByArg(input) {
   return typeof input === "object" && input !== null && !Array.isArray(input) && !(input instanceof ExpressionRef) && "__aggOrderBy" in input && input.__aggOrderBy === true;
 }
@@ -3837,403 +4259,20 @@ var DEFAULT_FEATURE_CHECKERS = Object.freeze([
   // 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;
-    }
-  }
-]);
-
-// src/dx/column-utils.ts
-function getColumnName(field) {
-  if (typeof field === "string") {
-    return field;
-  }
-  const colName = field[COLUMN_META];
-  if (colName === void 0) {
-    throw new Error("Invalid ColumnRef: missing COLUMN_META");
-  }
-  return colName;
-}
-
-// src/dx/window-functions.ts
-var WindowBuilder = class _WindowBuilder {
-  constructor(fnKind, partitions = [], orders = []) {
-    this.fnKind = fnKind;
-    this.partitions = partitions;
-    this.orders = orders;
-  }
-  fnKind;
-  partitions;
-  orders;
-  /**
-   * Create a ranking window builder (row_number, rank, dense_rank)
-   * @internal Use factory functions instead: rowNumber(), rank(), denseRank()
-   */
-  static ranking(fn2) {
-    return new _WindowBuilder({ type: "ranking", fn: fn2 });
-  }
-  /**
-   * Create an aggregate window builder (sum, avg, count, min, max)
-   * @internal Use factory functions instead: sum(field), avg(field), etc.
-   */
-  static aggregate(fn2, field) {
-    return new _WindowBuilder({
-      type: "aggregate",
-      fn: fn2,
-      ...field !== void 0 ? { field } : {}
-    });
-  }
-  /**
-   * Create an offset window builder (lag, lead)
-   * @internal Use factory functions instead: lag(field), lead(field)
-   */
-  static offset(fn2, field) {
-    return new _WindowBuilder({ type: "offset", fn: fn2, field });
-  }
-  /**
-   * Add partition field(s) to the OVER clause.
-   * Multiple calls APPEND fields (not replace).
-   * Supports both string field names and ColumnRef (DX-040).
-   *
-   * @example
-   * sum('amount').partitionBy('user_id').partitionBy('category')
-   * // → PARTITION BY "user_id", "category"
-   *
-   * @example DX-040 with ColumnRef
-   * rank().partitionBy(users.dept).orderBy(users.salary, 'desc')
-   */
-  partitionBy(...fields) {
-    const fieldNames = fields.map(
-      (f) => typeof f === "string" ? f : getColumnName(f)
-    );
-    return new _WindowBuilder(
-      this.fnKind,
-      [...this.partitions, ...fieldNames],
-      this.orders
-    );
-  }
-  /**
-   * Add order field to the OVER clause.
-   * Multiple calls APPEND fields (not replace).
-   * Supports both string field names and ColumnRef (DX-040).
-   *
-   * @param field - Column name or ColumnRef to order by
-   * @param direction - Sort direction: 'asc' (default) or 'desc'
-   *
-   * @example
-   * rowNumber().orderBy('created_at').orderBy('id', 'desc')
-   * // → ORDER BY "created_at" ASC, "id" DESC
-   *
-   * @example DX-040 with ColumnRef
-   * rank().partitionBy(users.dept).orderBy(users.salary, 'desc')
-   */
-  orderBy(field, direction = "asc") {
-    const fieldName = typeof field === "string" ? field : getColumnName(field);
-    return new _WindowBuilder(this.fnKind, this.partitions, [
-      ...this.orders,
-      { field: fieldName, direction }
-    ]);
-  }
-  /**
-   * Finalize the window expression with an alias.
-   * Returns ExpressionSpec for use in columns().
-   *
-   * @param alias - Required alias for the result column
-   *
-   * @example
-   * columns(['id', rowNumber().orderBy('date').as('rn')])
-   */
-  as(alias) {
-    return {
-      __expr: true,
-      intent: this.toWindowIntent(alias)
-    };
-  }
-  /**
-   * 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 over = {};
-    if (this.partitions.length > 0) {
-      over.partitionBy = this.partitions;
-    }
-    if (this.orders.length > 0) {
-      over.orderBy = this.orders;
-    }
-    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
-      };
+    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;
     }
-    const { field } = this.fnKind;
-    return {
-      kind: "window",
-      function: this.fnKind.fn,
-      ...field !== void 0 && { field },
-      alias,
-      over
-    };
-  }
-};
-function rowNumber() {
-  return WindowBuilder.ranking("row_number");
-}
-function rank() {
-  return WindowBuilder.ranking("rank");
-}
-function denseRank() {
-  return WindowBuilder.ranking("dense_rank");
-}
-function wSum(field) {
-  return WindowBuilder.aggregate("sum", field);
-}
-function wAvg(field) {
-  return WindowBuilder.aggregate("avg", field);
-}
-function wCount(field) {
-  return WindowBuilder.aggregate("count", field);
-}
-function wMin(field) {
-  return WindowBuilder.aggregate("min", field);
-}
-function wMax(field) {
-  return WindowBuilder.aggregate("max", field);
-}
-function lag(field) {
-  return WindowBuilder.offset("lag", field);
-}
-function lead(field) {
-  return WindowBuilder.offset("lead", field);
-}
-
-// src/dx/filters.ts
-function distinct(field) {
-  return { field, distinct: true };
-}
-function isDistinctField(value) {
-  return typeof value === "object" && value !== null && "field" in value && "distinct" in value && value.distinct === true;
-}
-function createComparisonFilter(operator) {
-  return (field, value) => ({
-    kind: "comparison",
-    field: getColumnName(field),
-    operator,
-    value
-  });
-}
-var eq = createComparisonFilter("eq");
-var neq = createComparisonFilter("neq");
-var gt = createComparisonFilter("gt");
-var gte = createComparisonFilter("gte");
-var lt = createComparisonFilter("lt");
-var lte = createComparisonFilter("lte");
-var isDistinctFrom = createComparisonFilter("isDistinctFrom");
-function like(field, pattern, options) {
-  const caseInsensitive = typeof options === "boolean" ? options : options?.caseInsensitive;
-  const escapeChar = typeof options === "object" ? options.escape : void 0;
-  const intent = {
-    kind: "like",
-    field: getColumnName(field),
-    pattern
-  };
-  const withCi = caseInsensitive !== void 0 ? { ...intent, caseInsensitive } : intent;
-  if (escapeChar !== void 0) {
-    return { ...withCi, escape: escapeChar };
-  }
-  return withCi;
-}
-function inArray(field, values) {
-  return { kind: "in", field: getColumnName(field), values };
-}
-function inSubquery(field, query) {
-  const expr = "build" in query ? query.build() : query;
-  return {
-    kind: "in",
-    field: getColumnName(field),
-    subquery: expr.toIntent()
-  };
-}
-function any(field, values) {
-  return { kind: "any", field: getColumnName(field), values };
-}
-function isNull(field) {
-  return { kind: "null", field: getColumnName(field), operator: "isNull" };
-}
-function isNotNull(field) {
-  return { kind: "null", field: getColumnName(field), operator: "isNotNull" };
-}
-function and(...conditions) {
-  const flatConditions = conditions.length === 1 && Array.isArray(conditions[0]) ? conditions[0] : conditions;
-  return { kind: "and", conditions: flatConditions };
-}
-function or(...conditions) {
-  const flatConditions = conditions.length === 1 && Array.isArray(conditions[0]) ? conditions[0] : conditions;
-  return { kind: "or", conditions: flatConditions };
-}
-function not(condition) {
-  return { kind: "not", condition };
-}
-function exists(relation, options) {
-  const result = { kind: "exists", relation };
-  if (options?.where !== void 0) {
-    result.where = options.where;
-  }
-  if (options?.recursive !== void 0) {
-    result.recursive = options.recursive;
-  }
-  if (options?.include !== void 0) {
-    result.include = options.include;
   }
-  return result;
-}
-function notExists(relation, options) {
-  const result = {
-    kind: "notExists",
-    relation
-  };
-  if (options?.where !== void 0) {
-    result.where = options.where;
-  }
-  if (options?.recursive !== void 0) {
-    result.recursive = options.recursive;
-  }
-  if (options?.include !== void 0) {
-    result.include = options.include;
-  }
-  return result;
-}
-function rawExists(sq) {
-  const intent = "buildIntent" in sq ? sq.buildIntent() : sq.build().toIntent();
-  return { kind: "rawExists", subquery: intent };
-}
-function rawNotExists(sq) {
-  const intent = "buildIntent" in sq ? sq.buildIntent() : sq.build().toIntent();
-  return { kind: "rawNotExists", subquery: intent };
-}
-function getRelationName(rel) {
-  const meta = rel[RELATION_META];
-  if (!meta) {
-    throw new Error("Invalid RelationRef: missing RELATION_META");
-  }
-  return meta.target;
-}
-function every(relation, filter) {
-  const relationName = getRelationName(relation);
-  const where = filter(relation);
-  return {
-    kind: "relationFilter",
-    relation: relationName,
-    where,
-    mode: "every"
-  };
-}
-function none(relation, filter) {
-  const relationName = getRelationName(relation);
-  const where = filter(relation);
-  return {
-    kind: "relationFilter",
-    relation: relationName,
-    where,
-    mode: "none"
-  };
-}
-function some(relation, filter) {
-  const relationName = getRelationName(relation);
-  const where = filter(relation);
-  return {
-    kind: "relationFilter",
-    relation: relationName,
-    where,
-    mode: "some"
-  };
-}
-function coalesce(fields, as) {
-  if (fields.length === 0) {
-    throw new Error("coalesce() requires at least one field");
-  }
-  if (!as || as.trim() === "") {
-    throw new Error("coalesce() requires a non-empty alias");
-  }
-  for (const f of fields) {
-    validateIdentifier(f, "column");
-  }
-  validateIdentifier(as, "column");
-  return {
-    __expr: true,
-    intent: { kind: "coalesce", fields, as }
-  };
-}
-function raw(sqlFragment, as) {
-  if (typeof as !== "string" || as.trim().length === 0) {
-    throw new InvalidOperationError(
-      "raw",
-      "raw() requires an alias as second argument, e.g. raw('COUNT(*)', 'count')"
-    );
-  }
-  validateIdentifier(as, "column");
-  return {
-    __expr: true,
-    intent: { kind: "raw", sql: sqlFragment, as }
-  };
-}
-function col(column, alias) {
-  validateIdentifier(column, "column");
-  validateIdentifier(alias, "column");
-  return {
-    __expr: true,
-    intent: { kind: "columnAlias", column, alias }
-  };
-}
-function relationColumn(relation, column, as) {
-  if (!relation) {
-    throw new Error("relationColumn() requires a non-empty relation path");
-  }
-  for (const segment of relation.split(".")) {
-    validateIdentifier(segment, "relation");
-  }
-  if (column !== "*") {
-    validateIdentifier(column, "column");
-  }
-  validateIdentifier(as, "column");
-  return {
-    __expr: true,
-    intent: { kind: "relationColumn", relation, column, as }
-  };
-}
-var SQL_RAW_MARKER = /* @__PURE__ */ Symbol.for("dbsp:raw-sql");
-function sql(sqlFragment) {
-  if (!sqlFragment || sqlFragment.trim() === "") {
-    throw new Error("sql() requires a non-empty SQL fragment");
-  }
-  return { [SQL_RAW_MARKER]: true, sql: sqlFragment };
-}
-function isSqlRaw(value) {
-  return typeof value === "object" && value !== null && SQL_RAW_MARKER in value && value[SQL_RAW_MARKER] === true;
-}
+]);
 
 // src/dx/full-text-search.ts
 function fullTextSearch({
@@ -10240,6 +10279,9 @@ function generateCreateIndexSQL(tableName, schemaName, opts) {
       `INCLUDE (${opts.include.map((c) => quoteIdent(c)).join(", ")})`
     );
   }
+  if (opts.unique && opts.nullsNotDistinct) {
+    parts.push("NULLS NOT DISTINCT");
+  }
   if (opts.with && Object.keys(opts.with).length > 0) {
     const withClauses = Object.entries(opts.with).map(([k, v2]) => `${k} = ${v2}`).join(", ");
     parts.push(`WITH (${withClauses})`);