@dbsp/nql 1.4.0 → 1.6.0

package/dist/index.js

@@ -1,5 +1,5 @@
-import { NQL_INTERNAL_COMPILER_OPTIONS, createNqlBindingRef, isNqlBindingRef, getNqlBindingRefName } from '@dbsp/types/internal';
-import { NQL_SELECT_AGGREGATE_FUNCTIONS, NQL_SELECT_VALUE_FUNCTIONS, NQL_SELECT_JSON_FUNCTIONS, NQL_SELECT_SCALAR_FUNCTIONS, isNqlSelectWindowFunctionAllowed, isRankingWindowFunction, isParamIntent } from '@dbsp/types';
+import { NQL_INTERNAL_COMPILER_OPTIONS, explainUnsupportedNqlBindingIncludeHop, markNqlTrustedRelationFilter, createNqlBindingRef, isNqlBindingRef, getNqlBindingRefName } from '@dbsp/types/internal';
+import { NQL_SELECT_AGGREGATE_FUNCTIONS, NQL_SELECT_VALUE_FUNCTIONS, NQL_SELECT_JSON_FUNCTIONS, NQL_SELECT_SCALAR_FUNCTIONS, toColumnList, isNqlSelectWindowFunctionAllowed, isRankingWindowFunction, isParamIntent } from '@dbsp/types';
 import { createToken, Lexer, CstParser } from 'chevrotain';
 
 // src/compiler/index.ts
@@ -43,8 +43,6 @@ var NqlSemanticException = class extends Error {
     this.relatedSymbol = relatedSymbol;
   }
 };
-
-// src/compiler/column-validator.ts
 var ColumnValidator = class _ColumnValidator {
   constructor(schema) {
     this.schema = schema;
@@ -52,6 +50,7 @@ var ColumnValidator = class _ColumnValidator {
   schema;
   knownCteTables = /* @__PURE__ */ new Set();
   virtualBindingTables = /* @__PURE__ */ new Map();
+  virtualBindingRelationFilters = /* @__PURE__ */ new Map();
   /**
    * Register CTE names so validateTable() skips validation for them.
    * CTE names are not physical tables in the schema, but are valid FROM targets.
@@ -69,12 +68,16 @@ var ColumnValidator = class _ColumnValidator {
    * Register an NQL binding as a virtual table with a concrete output schema.
    * Binding columns are logical output names, so matching is exact.
    */
-  addVirtualBindingTable(name, columns) {
+  addVirtualBindingTable(name, columns, relationFilters) {
     this.virtualBindingTables.set(name, columns);
+    if (relationFilters) {
+      this.virtualBindingRelationFilters.set(name, relationFilters);
+    }
   }
   /** Clear all registered virtual binding tables (used between compilations). */
   clearVirtualBindingTables() {
     this.virtualBindingTables.clear();
+    this.virtualBindingRelationFilters.clear();
   }
   isVirtualBindingTable(name) {
     return name !== void 0 && this.virtualBindingTables.has(name);
@@ -87,6 +90,173 @@ var ColumnValidator = class _ColumnValidator {
     if (virtualColumns) return virtualColumns;
     return this.schema.getTable(name)?.columns.map((column) => column.name);
   }
+  hasPhysicalTable(name) {
+    return !this.virtualBindingTables.has(name) && !!this.schema.getTable(name);
+  }
+  hasQualifiedRelationLookup() {
+    return typeof this.schema.getRelation === "function";
+  }
+  getRelation(sourceTable, relationName) {
+    return this.schema.getRelation?.(`${sourceTable}.${relationName}`) ?? this.schema.getRelationsFrom(sourceTable).find((relation) => relation.name === relationName);
+  }
+  getRelationsFrom(sourceTable) {
+    return this.schema.getRelationsFrom(sourceTable);
+  }
+  getVirtualBindingRelation(bindingName, relationName) {
+    return this.virtualBindingRelationFilters.get(bindingName)?.relations.find((relation) => relation.relation === relationName);
+  }
+  getVirtualBindingScalarRelation(bindingName, relationName) {
+    return this.virtualBindingRelationFilters.get(bindingName)?.scalarRelations?.find((relation) => relation.relation === relationName);
+  }
+  static virtualRelationIncludeShape(relation) {
+    const relationType = relation.relationType;
+    const foreignKey = relationType === "belongsTo" ? relation.sourceColumn : relation.targetColumn;
+    return {
+      type: relationType,
+      foreignKey,
+      source: relation.sourceTable,
+      target: relation.targetTable
+    };
+  }
+  resolveVirtualBindingScalarRelationForInclude(bindingName, relationPath) {
+    const relationName = relationPath.join(".");
+    if (relationPath.length < 1) {
+      throw new NqlSemanticException(
+        NqlErrorCodes.SEM_INVALID_SYNTAX,
+        `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relationName}' (ref-#192): the relation path must name a source-table relation.`
+      );
+    }
+    const relation = relationPath[0];
+    if (!relation) {
+      throw new NqlSemanticException(
+        NqlErrorCodes.SEM_INVALID_SYNTAX,
+        `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relationName}' (ref-#192): the relation path must name a source-table relation.`
+      );
+    }
+    const virtualRelation = this.getVirtualBindingScalarRelation(
+      bindingName,
+      relation
+    );
+    if (virtualRelation) {
+      const resolvedFirstHop = this.getRelation(virtualRelation.sourceTable, relation) ?? _ColumnValidator.virtualRelationIncludeShape(virtualRelation);
+      const unsupportedFirstHopReason = explainUnsupportedNqlBindingIncludeHop(
+        relation,
+        resolvedFirstHop,
+        { relation }
+      );
+      if (unsupportedFirstHopReason) {
+        throw new NqlSemanticException(
+          NqlErrorCodes.SEM_INVALID_SYNTAX,
+          `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relationName}' (ref-#192): ${unsupportedFirstHopReason}.`
+        );
+      }
+      let sourceTable = virtualRelation.targetTable;
+      for (let i = 1; i < relationPath.length; i++) {
+        const tailRelation = relationPath[i];
+        if (!tailRelation) {
+          throw new NqlSemanticException(
+            NqlErrorCodes.SEM_INVALID_SYNTAX,
+            `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relationName}' (ref-#192): relation path segment ${i + 1} is empty.`
+          );
+        }
+        const resolvedTail = this.getRelation(sourceTable, tailRelation);
+        if (!resolvedTail) {
+          throw new NqlSemanticException(
+            NqlErrorCodes.SEM_INVALID_SYNTAX,
+            `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relationName}' (ref-#192): tail relation '${tailRelation}' is not declared on table '${sourceTable}'.`
+          );
+        }
+        const unsupportedReason = explainUnsupportedNqlBindingIncludeHop(
+          tailRelation,
+          resolvedTail,
+          { relation: tailRelation }
+        );
+        if (unsupportedReason) {
+          throw new NqlSemanticException(
+            NqlErrorCodes.SEM_INVALID_SYNTAX,
+            `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relationName}' (ref-#192): tail ${unsupportedReason}.`
+          );
+        }
+        sourceTable = resolvedTail.target;
+      }
+      return virtualRelation;
+    }
+    const reason = this.explainVirtualBindingScalarRelationRejection(
+      bindingName,
+      relation
+    );
+    throw new NqlSemanticException(
+      NqlErrorCodes.SEM_INVALID_SYNTAX,
+      `Query '${bindingName}' reads from an NQL binding and cannot use relation include '${relation}' (ref-#192): ${reason}.`
+    );
+  }
+  explainVirtualBindingRelationRejection(bindingName, relationName) {
+    const metadata = this.virtualBindingRelationFilters.get(bindingName);
+    if (!metadata) {
+      return "no binding relation-filter metadata is available";
+    }
+    if (metadata.unsafeReason) return metadata.unsafeReason;
+    const sourceTable = metadata.sourceTable;
+    if (!sourceTable) {
+      return "the binding source table could not be proven";
+    }
+    const relation = this.getRelation(sourceTable, relationName);
+    if (!relation) {
+      return `relation '${relationName}' is not declared on source table '${sourceTable}'`;
+    }
+    const fkColumns = toColumnList(relation.foreignKey);
+    if (relation.type !== "belongsTo") {
+      return `relation '${relationName}' is '${relation.type ?? "unknown"}'; A-lite only supports relations whose FK column is on the binding source table`;
+    }
+    if (fkColumns.length === 0) {
+      return `relation '${relationName}' must have at least one FK column for A-lite binding relation filters`;
+    }
+    for (const fkColumn of fkColumns) {
+      const directProjection = metadata.directProjectionLineage?.find(
+        (projection) => projection.sourceTable === sourceTable && _ColumnValidator.columnsMatch(projection.sourceColumn, fkColumn)
+      );
+      if (!directProjection) {
+        const available2 = this.virtualBindingTables.get(bindingName)?.join(", ");
+        return `relation '${relationName}' FK column '${fkColumn}' is not projected as a direct source-column projection by binding '${bindingName}'${available2 ? ` (available columns: ${available2})` : ""}`;
+      }
+    }
+    const available = this.virtualBindingTables.get(bindingName)?.join(", ");
+    return `relation '${relationName}' FK columns '${fkColumns.join(", ")}' are not available through binding '${bindingName}'${available ? ` (available columns: ${available})` : ""}`;
+  }
+  explainVirtualBindingScalarRelationRejection(bindingName, relationName) {
+    const metadata = this.virtualBindingRelationFilters.get(bindingName);
+    if (!metadata) {
+      return "no binding relation metadata is available";
+    }
+    if (metadata.unsafeReason) return metadata.unsafeReason;
+    const sourceTable = metadata.sourceTable;
+    if (!sourceTable) {
+      return "the binding source table could not be proven";
+    }
+    const relation = this.getRelation(sourceTable, relationName);
+    if (!relation) {
+      return `relation '${relationName}' is not declared on source table '${sourceTable}'`;
+    }
+    const unsupportedReason = explainUnsupportedNqlBindingIncludeHop(
+      relationName,
+      relation
+    );
+    if (unsupportedReason) return unsupportedReason;
+    const fkColumns = toColumnList(relation.foreignKey);
+    const sourceColumns = relation.type === "belongsTo" ? fkColumns : toColumnList(relation.sourceKey).length > 0 ? toColumnList(relation.sourceKey) : ["id"];
+    for (const sourceColumn of sourceColumns) {
+      const directProjection = metadata.directProjectionLineage?.find(
+        (projection) => projection.sourceTable === sourceTable && _ColumnValidator.columnsMatch(projection.sourceColumn, sourceColumn)
+      );
+      if (!directProjection) {
+        const available2 = this.virtualBindingTables.get(bindingName)?.join(", ");
+        const sourceColumnLabel = relation.type === "belongsTo" ? "FK column" : "source key column";
+        return `relation '${relationName}' ${sourceColumnLabel} '${sourceColumn}' is not projected as a direct source-column projection by binding '${bindingName}'${available2 ? ` (available columns: ${available2})` : ""}`;
+      }
+    }
+    const available = this.virtualBindingTables.get(bindingName)?.join(", ");
+    return `relation '${relationName}' source columns '${sourceColumns.join(", ")}' are not available through binding '${bindingName}'${available ? ` (available columns: ${available})` : ""}`;
+  }
   /**
    * Convert camelCase to snake_case for column name matching.
    * NQL queries may use either form (e.g., viewCount or view_count).
@@ -156,13 +326,17 @@ var ColumnValidator = class _ColumnValidator {
   }
   resolveRelationTarget(sourceTable, relationName) {
     if (this.virtualBindingTables.has(sourceTable)) {
+      const virtualRelation = this.getVirtualBindingRelation(
+        sourceTable,
+        relationName
+      );
+      if (virtualRelation) return virtualRelation.targetTable;
       throw new NqlSemanticException(
         NqlErrorCodes.SEM_INVALID_SYNTAX,
-        `Query '${sourceTable}' reads from an NQL binding and cannot use relation filters (${relationName}). Relation constructs require a physical model table, not a CTE binding.`
+        `Query '${sourceTable}' reads from an NQL binding and cannot use relation filters (${relationName}) under A-lite (ref-#182): ${this.explainVirtualBindingRelationRejection(sourceTable, relationName)}.`
       );
     }
-    const relations = this.schema.getRelationsFrom(sourceTable);
-    const rel = relations.find((r) => r.name === relationName);
+    const rel = this.getRelation(sourceTable, relationName);
     return rel?.target;
   }
   assertNoBindingRelationConstruct(bindingName, construct, detail) {
@@ -180,6 +354,28 @@ var ColumnValidator = class _ColumnValidator {
     );
   }
 };
+var DEFAULT_RELATION_TARGET_COLUMN = "id";
+function relationForeignKeys(relation) {
+  if (!relation) return void 0;
+  const columns = toColumnList(relation.foreignKey);
+  return columns.length > 0 ? columns : void 0;
+}
+function relationCardinality(relation) {
+  return relation?.type === "hasMany" || relation?.type === "belongsToMany" ? "many" : "one";
+}
+function scalarRelationJoinColumns(relation) {
+  if (!relation) return void 0;
+  if (relation.type !== "belongsTo" && relation.type !== "hasOne" && relation.type !== "hasMany") {
+    return void 0;
+  }
+  const fkColumns = relationForeignKeys(relation);
+  if (!fkColumns) return void 0;
+  const sourceKeys = toColumnList(relation.sourceKey);
+  const targetKeys = toColumnList(relation.targetKey);
+  const sourceJoinColumn = relation.type === "belongsTo" ? fkColumns : sourceKeys.length > 0 ? sourceKeys : [DEFAULT_RELATION_TARGET_COLUMN];
+  const targetJoinColumn = relation.type === "belongsTo" ? targetKeys.length > 0 ? targetKeys : [DEFAULT_RELATION_TARGET_COLUMN] : fkColumns;
+  return { sourceJoinColumn, targetJoinColumn };
+}
 var FORBIDDEN_PARAM_NAMES = /* @__PURE__ */ new Set([
   "__proto__",
   "constructor",
@@ -288,6 +484,174 @@ function assertNoBindingRelationConstruct(ctx, bindingName, construct, detail) {
     `Query '${bindingName}' reads from an NQL binding and cannot ${construct} (${detail}). Relation constructs require a physical model table, not a CTE binding.`
   );
 }
+function throwBindingRelationFilter182(bindingName, relationName, reason) {
+  throw new NqlSemanticException(
+    NqlErrorCodes.SEM_INVALID_SYNTAX,
+    `Query '${bindingName}' reads from an NQL binding and cannot use relation filters (${relationName}) under A-lite (ref-#182): ${reason}.`
+  );
+}
+function throwBindingRelationColumn182(bindingName, relationName, reason) {
+  throw new NqlSemanticException(
+    NqlErrorCodes.SEM_INVALID_SYNTAX,
+    `Query '${bindingName}' reads from an NQL binding and cannot select relation column '${relationName}' under A-full (ref-#182): ${reason}.`
+  );
+}
+function bindingRelationColumnUnsupportedReason(relationName, relation) {
+  const unsupportedReason = explainUnsupportedNqlBindingIncludeHop(
+    relationName,
+    relation
+  );
+  if (unsupportedReason) return unsupportedReason;
+  if (relationCardinality(relation) !== "one") {
+    return `relation '${relationName}' is '${relation.type ?? "unknown"}'; scalar binding relation columns require every hop to be to-one (belongsTo/hasOne) (ref-#192)`;
+  }
+  return void 0;
+}
+function resolveBindingRelationFilter(ctx, bindingName, relationPath) {
+  if (!isBindingTable(ctx, bindingName)) return void 0;
+  const actualBindingName = bindingName;
+  const relationName = relationPath.join(".");
+  if (relationPath.length !== 1) {
+    throwBindingRelationFilter182(
+      actualBindingName,
+      relationName,
+      "multi-hop binding relation filters are not supported; the relation path must be a single source-table relation"
+    );
+  }
+  const relation = relationPath[0];
+  if (!relation) {
+    throwBindingRelationFilter182(
+      actualBindingName,
+      relationName,
+      "the relation path must name a source-table relation"
+    );
+  }
+  const virtualRelation = ctx.validator?.getVirtualBindingRelation(
+    actualBindingName,
+    relation
+  );
+  if (virtualRelation) return virtualRelation;
+  const reason = ctx.validator?.explainVirtualBindingRelationRejection(
+    actualBindingName,
+    relation
+  ) ?? "model metadata is not available";
+  throwBindingRelationFilter182(actualBindingName, relation, reason);
+}
+function resolveBindingRelationColumn(ctx, bindingName, relationPath, selectedColumn) {
+  if (!isBindingTable(ctx, bindingName)) return void 0;
+  const actualBindingName = bindingName;
+  const relationName = relationPath.join(".");
+  const relation = relationPath[0];
+  if (!relation) {
+    throwBindingRelationColumn182(
+      actualBindingName,
+      relationName,
+      "the relation path must name a source-table relation"
+    );
+  }
+  if (!ctx.validator) {
+    throwBindingRelationColumn182(
+      actualBindingName,
+      relationName,
+      "model metadata is not available"
+    );
+  }
+  const virtualRelation = ctx.validator?.getVirtualBindingScalarRelation(
+    actualBindingName,
+    relation
+  );
+  if (!virtualRelation) {
+    const reason = ctx.validator?.explainVirtualBindingScalarRelationRejection(
+      actualBindingName,
+      relation
+    ) ?? "model metadata is not available";
+    throwBindingRelationColumn182(actualBindingName, relationName, reason);
+  }
+  if (relationPath.length === 1) {
+    ctx.validator.validateColumn(virtualRelation.targetTable, selectedColumn);
+    return virtualRelation;
+  }
+  const firstHop = ctx.validator.getRelation(
+    virtualRelation.sourceTable,
+    relation
+  );
+  if (!firstHop) {
+    throwBindingRelationColumn182(
+      actualBindingName,
+      relationName,
+      `relation '${relation}' is not declared on source table '${virtualRelation.sourceTable}'`
+    );
+  }
+  const firstHopReason = bindingRelationColumnUnsupportedReason(
+    relation,
+    firstHop
+  );
+  if (firstHopReason) {
+    throwBindingRelationColumn182(
+      actualBindingName,
+      relationName,
+      firstHopReason
+    );
+  }
+  let sourceTable = virtualRelation.targetTable;
+  const hops = [];
+  for (let i = 1; i < relationPath.length; i++) {
+    const tailRelation = relationPath[i];
+    if (!tailRelation) {
+      throwBindingRelationColumn182(
+        actualBindingName,
+        relationName,
+        `relation path segment ${i + 1} is empty (ref-#192)`
+      );
+    }
+    const resolvedTail = ctx.validator.getRelation(sourceTable, tailRelation);
+    if (!resolvedTail) {
+      throwBindingRelationColumn182(
+        actualBindingName,
+        relationName,
+        `tail relation '${tailRelation}' is not declared on table '${sourceTable}' (ref-#192)`
+      );
+    }
+    const tailReason = bindingRelationColumnUnsupportedReason(
+      tailRelation,
+      resolvedTail
+    );
+    if (tailReason) {
+      throwBindingRelationColumn182(
+        actualBindingName,
+        relationName,
+        `tail ${tailReason}`
+      );
+    }
+    const joinColumns = scalarRelationJoinColumns(resolvedTail);
+    if (!joinColumns) {
+      throwBindingRelationColumn182(
+        actualBindingName,
+        relationName,
+        `tail relation '${tailRelation}' cannot be resolved to a scalar join (ref-#192)`
+      );
+    }
+    if (joinColumns.sourceJoinColumn.length !== joinColumns.targetJoinColumn.length) {
+      throwBindingRelationColumn182(
+        actualBindingName,
+        relationName,
+        `tail relation '${tailRelation}' has mismatched join column counts (${joinColumns.sourceJoinColumn.length} source, ${joinColumns.targetJoinColumn.length} target) (ref-#179)`
+      );
+    }
+    hops.push({
+      target: resolvedTail.target,
+      fkColumn: joinColumns.sourceJoinColumn,
+      joinColumn: joinColumns.targetJoinColumn
+    });
+    sourceTable = resolvedTail.target;
+  }
+  ctx.validator.validateColumn(sourceTable, selectedColumn);
+  return {
+    ...virtualRelation,
+    relation: relationName,
+    hops
+  };
+}
 function assertNoBindingRelationPath(ctx, bindingName, path) {
   if (!isBindingTable(ctx, bindingName)) return;
   throw new NqlSemanticException(
@@ -518,6 +882,10 @@ function validateWhereField(ctx, field, aliasContext, originalExpr) {
       `HAVING cannot reference SELECT alias '${field}'. PostgreSQL does not allow SELECT aliases in HAVING; repeat the aggregate expression or filter the result in an outer query.`
     );
   }
+  if (!aliasContext && ctx.currentRelationTarget && !field.includes(".")) {
+    ctx.validator?.validateColumn(ctx.currentRelationTarget, field);
+    return;
+  }
   if (!aliasContext && ctx.currentFromTable && isBindingTable(ctx, ctx.currentFromTable)) {
     if (field.includes(".")) {
       assertNoBindingRelationPath(ctx, ctx.currentFromTable, field);
@@ -540,10 +908,6 @@ function validateWhereField(ctx, field, aliasContext, originalExpr) {
     }
     return;
   }
-  if (ctx.currentRelationTarget && !field.includes(".")) {
-    ctx.validator.validateColumn(ctx.currentRelationTarget, field);
-    return;
-  }
   if (ctx.currentFromTable && field.includes(".")) {
     if (isBindingTable(ctx, ctx.currentFromTable)) {
       assertNoBindingRelationPath(ctx, ctx.currentFromTable, field);
@@ -975,6 +1339,180 @@ function throwUnsupportedBindingFinal(bindingName, feature) {
     `Query '${bindingName}' reads from an NQL binding and cannot use ${feature} in a binding-final query (#183). Binding-final queries are restricted to portable common-ground SQL over projected binding columns: SELECT (including plain DISTINCT), WHERE, GROUP BY, HAVING, ORDER BY, LIMIT, OFFSET, and UNION/INTERSECT/EXCEPT.`
   );
 }
+function toSnakeCase(name) {
+  return name.replace(/[A-Z]/g, (ch) => `_${ch.toLowerCase()}`);
+}
+function columnsMatch(left, right) {
+  return left === right || toSnakeCase(left) === toSnakeCase(right);
+}
+function expressionIntentContainsAggregate(value) {
+  if (!value || typeof value !== "object") return false;
+  const record = value;
+  if (record.kind === "aggregate") return true;
+  for (const child of Object.values(record)) {
+    if (Array.isArray(child)) {
+      if (child.some((item) => expressionIntentContainsAggregate(item))) {
+        return true;
+      }
+    } else if (expressionIntentContainsAggregate(child)) {
+      return true;
+    }
+  }
+  return false;
+}
+function selectContainsAggregate(select) {
+  if (!select) return false;
+  if (select.type === "aggregate") return true;
+  if (select.type !== "expressions") return false;
+  return select.columns.some(
+    (column) => expressionIntentContainsAggregate(column)
+  );
+}
+function relationForeignKeysOnSource(relation) {
+  if (relation?.type !== "belongsTo") return void 0;
+  const fkColumns = toColumnList(relation.foreignKey);
+  return fkColumns.length > 0 ? fkColumns : void 0;
+}
+function unsafeBindingRelationReason(intent, ctx, bindingDependencies) {
+  if (!ctx.validator) return "model metadata is not available";
+  if (!ctx.validator.hasQualifiedRelationLookup()) {
+    return "model.getRelation metadata is not available";
+  }
+  if (bindingDependencies.length > 0 || isBindingTable(ctx, intent.from)) {
+    return "the binding body reads from another NQL binding";
+  }
+  if (!ctx.validator.hasPhysicalTable(intent.from)) {
+    return `the binding source '${intent.from}' is not a single real model table`;
+  }
+  if (intent.batchValuesSource) {
+    return "the binding body reads from a batch-values source";
+  }
+  if ((intent.joins?.length ?? 0) > 0) {
+    return "the binding body uses joins";
+  }
+  if ((intent.include?.length ?? 0) > 0) {
+    return "the binding body uses relation includes";
+  }
+  if ((intent.groupBy?.length ?? 0) > 0 || intent.having) {
+    return "the binding body uses GROUP BY or HAVING";
+  }
+  if (selectContainsAggregate(intent.select)) {
+    return "the binding body uses aggregate projections";
+  }
+  return void 0;
+}
+function findDirectSourceProjection(sourceTable, sourceColumn, directProjectionLineage) {
+  return directProjectionLineage.find(
+    (projection) => projection.sourceTable === sourceTable && columnsMatch(projection.sourceColumn, sourceColumn)
+  );
+}
+function findDirectSourceProjections(sourceTable, sourceColumns, directProjectionLineage) {
+  const projections = [];
+  for (const sourceColumn of sourceColumns) {
+    const projection = findDirectSourceProjection(
+      sourceTable,
+      sourceColumn,
+      directProjectionLineage
+    );
+    if (!projection) return void 0;
+    projections.push(projection);
+  }
+  return projections;
+}
+function virtualRelationForBinding(relation, sourceTable, directProjectionLineage) {
+  const fkColumns = relationForeignKeysOnSource(relation);
+  if (!relation || !fkColumns) return void 0;
+  const sourceProjections = findDirectSourceProjections(
+    sourceTable,
+    fkColumns,
+    directProjectionLineage
+  );
+  if (!sourceProjections) return void 0;
+  const targetKey = toColumnList(relation.targetKey);
+  const targetColumns = targetKey.length > 0 ? targetKey : [DEFAULT_RELATION_TARGET_COLUMN];
+  if (targetColumns.length !== fkColumns.length) return void 0;
+  return {
+    relation: relation.name,
+    sourceTable,
+    targetTable: relation.target,
+    sourceColumn: sourceProjections.map(
+      (projection) => projection.outputColumn
+    ),
+    targetColumn: targetColumns,
+    hops: [],
+    cardinality: "one"
+  };
+}
+function scalarVirtualRelationForBinding(relation, sourceTable, directProjectionLineage) {
+  if (!relation) return void 0;
+  if (relation.type !== "belongsTo" && relation.type !== "hasOne" && relation.type !== "hasMany") {
+    return void 0;
+  }
+  const joinColumns = scalarRelationJoinColumns(relation);
+  if (!joinColumns) return void 0;
+  if (joinColumns.sourceJoinColumn.length !== joinColumns.targetJoinColumn.length) {
+    return void 0;
+  }
+  const sourceProjections = findDirectSourceProjections(
+    sourceTable,
+    joinColumns.sourceJoinColumn,
+    directProjectionLineage
+  );
+  if (!sourceProjections) return void 0;
+  return {
+    relation: relation.name,
+    sourceTable,
+    targetTable: relation.target,
+    sourceColumn: sourceProjections.map(
+      (projection) => projection.outputColumn
+    ),
+    targetColumn: joinColumns.targetJoinColumn,
+    hops: [],
+    cardinality: relationCardinality(relation),
+    relationType: relation.type
+  };
+}
+function getBindingRelationFilterMetadata(intent, ctx, outputSchema, bindingDependencies) {
+  const unsafeReason = unsafeBindingRelationReason(
+    intent,
+    ctx,
+    bindingDependencies
+  );
+  if (unsafeReason) {
+    return {
+      unsafeReason,
+      directProjectionLineage: outputSchema.directProjectionLineage,
+      relations: []
+    };
+  }
+  const sourceTable = intent.from;
+  const relations = [];
+  const scalarRelations = [];
+  const relationNames = new Set(
+    ctx.validator?.getRelationsFrom(sourceTable).map((relation) => relation.name)
+  );
+  for (const relationName of relationNames ?? []) {
+    const relation = ctx.validator?.getRelation(sourceTable, relationName);
+    const virtualRelation = virtualRelationForBinding(
+      relation,
+      sourceTable,
+      outputSchema.directProjectionLineage ?? []
+    );
+    if (virtualRelation) relations.push(virtualRelation);
+    const scalarRelation = scalarVirtualRelationForBinding(
+      relation,
+      sourceTable,
+      outputSchema.directProjectionLineage ?? []
+    );
+    if (scalarRelation) scalarRelations.push(scalarRelation);
+  }
+  return {
+    sourceTable,
+    directProjectionLineage: outputSchema.directProjectionLineage,
+    relations,
+    scalarRelations
+  };
+}
 function validateBindingFinalPath(expr, ctx, bindingName) {
   const { segments } = expr;
   if (segments.length === 1) {
@@ -999,63 +1537,164 @@ function validateBindingFinalPath(expr, ctx, bindingName) {
   }
   assertNoBindingRelationPath(ctx, bindingName, segments.join("."));
 }
-function validateBindingFinalFunction(expr, ctx, bindingName) {
+function resolveBindingRelationInclude(ctx, bindingName, relationPath) {
+  if (!isBindingTable(ctx, bindingName)) return void 0;
+  if (!bindingName || !ctx.validator) {
+    throw new NqlSemanticException(
+      NqlErrorCodes.SEM_INVALID_SYNTAX,
+      `Query '${bindingName ?? "<unknown>"}' reads from an NQL binding and cannot use relation include '${relationPath.join(".")}' (ref-#192): model metadata is not available.`
+    );
+  }
+  return ctx.validator.resolveVirtualBindingScalarRelationForInclude(
+    bindingName,
+    relationPath
+  );
+}
+function validateBindingFinalFunction(expr, ctx, bindingName, allowRelationFilters) {
   const fn = expr.name.toLowerCase();
   if (!PORTABLE_BINDING_FINAL_FUNCTIONS.has(fn)) {
     throwUnsupportedBindingFinal(bindingName, `function ${expr.name}()`);
   }
   for (const arg of expr.args) {
-    validateBindingFinalExpression(arg, ctx, bindingName);
+    validateBindingFinalExpression(arg, ctx, bindingName, allowRelationFilters);
   }
 }
-function validateBindingFinalExpression(expr, ctx, bindingName) {
+function validateBindingFinalExpression(expr, ctx, bindingName, allowRelationFilters = false) {
   switch (expr.type) {
     case "path":
       validateBindingFinalPath(expr, ctx, bindingName);
       break;
     case "binary":
-      validateBindingFinalExpression(expr.left, ctx, bindingName);
-      validateBindingFinalExpression(expr.right, ctx, bindingName);
+      validateBindingFinalExpression(
+        expr.left,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
+      validateBindingFinalExpression(
+        expr.right,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       break;
     case "unary":
-      validateBindingFinalExpression(expr.operand, ctx, bindingName);
+      validateBindingFinalExpression(
+        expr.operand,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       break;
     case "comparison":
-      validateBindingFinalExpression(expr.left, ctx, bindingName);
-      validateBindingFinalExpression(expr.right, ctx, bindingName);
+      validateBindingFinalExpression(
+        expr.left,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
+      validateBindingFinalExpression(
+        expr.right,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       break;
     case "in":
-      validateBindingFinalExpression(expr.expression, ctx, bindingName);
+      validateBindingFinalExpression(
+        expr.expression,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       if (Array.isArray(expr.values)) {
         for (const value of expr.values) {
-          validateBindingFinalExpression(value, ctx, bindingName);
+          validateBindingFinalExpression(
+            value,
+            ctx,
+            bindingName,
+            allowRelationFilters
+          );
         }
       } else if (expr.values.type === "dateRange") ; else ;
       break;
     case "between":
-      validateBindingFinalExpression(expr.expression, ctx, bindingName);
-      validateBindingFinalExpression(expr.low, ctx, bindingName);
-      validateBindingFinalExpression(expr.high, ctx, bindingName);
+      validateBindingFinalExpression(
+        expr.expression,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
+      validateBindingFinalExpression(
+        expr.low,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
+      validateBindingFinalExpression(
+        expr.high,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       break;
     case "isNull":
-      validateBindingFinalExpression(expr.expression, ctx, bindingName);
+      validateBindingFinalExpression(
+        expr.expression,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       break;
     case "function":
-      validateBindingFinalFunction(expr, ctx, bindingName);
+      validateBindingFinalFunction(
+        expr,
+        ctx,
+        bindingName,
+        allowRelationFilters
+      );
       break;
     case "case":
       if (expr.subject) {
-        validateBindingFinalExpression(expr.subject, ctx, bindingName);
+        validateBindingFinalExpression(
+          expr.subject,
+          ctx,
+          bindingName,
+          allowRelationFilters
+        );
       }
       for (const when of expr.whenClauses) {
-        validateBindingFinalExpression(when.condition, ctx, bindingName);
-        validateBindingFinalExpression(when.result, ctx, bindingName);
+        validateBindingFinalExpression(
+          when.condition,
+          ctx,
+          bindingName,
+          allowRelationFilters
+        );
+        validateBindingFinalExpression(
+          when.result,
+          ctx,
+          bindingName,
+          allowRelationFilters
+        );
       }
       if (expr.elseClause) {
-        validateBindingFinalExpression(expr.elseClause, ctx, bindingName);
+        validateBindingFinalExpression(
+          expr.elseClause,
+          ctx,
+          bindingName,
+          allowRelationFilters
+        );
       }
       break;
     case "relationFilter":
+      if (allowRelationFilters) {
+        resolveBindingRelationFilter(
+          ctx,
+          bindingName,
+          expr.relation
+        );
+        break;
+      }
       assertNoBindingRelationConstruct(
         ctx,
         bindingName,
@@ -1111,12 +1750,7 @@ function validateBindingFinalSelectClause(clause, ctx, bindingName) {
       case "star":
         break;
       case "relationStar":
-        assertNoBindingRelationConstruct(
-          ctx,
-          bindingName,
-          "select relation columns",
-          item.relation.join(".")
-        );
+        resolveBindingRelationInclude(ctx, bindingName, item.relation);
         break;
       case "expression":
         if (item.expression.type === "path" && item.expression.segments.length > 1) {
@@ -1130,11 +1764,11 @@ function validateBindingFinalSelectClause(clause, ctx, bindingName) {
               firstSegment
             );
           } else {
-            assertNoBindingRelationConstruct(
+            resolveBindingRelationColumn(
               ctx,
               bindingName,
-              "select relation columns",
-              segments.slice(0, -1).join(".")
+              segments.slice(0, -1),
+              segments.at(-1)
             );
           }
         } else {
@@ -1166,7 +1800,12 @@ function validateBindingFinalQuery(query, ctx) {
             ctx.currentHavingAliases = previousHavingAliases;
           }
         } else {
-          validateBindingFinalExpression(clause.condition, ctx, query.table);
+          validateBindingFinalExpression(
+            clause.condition,
+            ctx,
+            query.table,
+            true
+          );
         }
         break;
       }
@@ -1351,17 +1990,34 @@ function compileQueryInternal(query, ctx, fns, bindings) {
     const relationPaths = /* @__PURE__ */ new Set();
     for (const expr of select.columns) {
       if (expr.kind === "relationColumn") {
-        relationPaths.add(expr.relation);
+        if (!isBindingSource || expr.column === "*") {
+          relationPaths.add(expr.relation);
+        }
       }
     }
     if (relationPaths.size > 0) {
-      const nestedIncludes = buildNestedIncludes(relationPaths, flatMode);
-      for (const inc of nestedIncludes) {
-        const exists = allIncludes.some(
-          (existing) => existing.relation === inc.relation
-        );
-        if (!exists) {
-          allIncludes.push(inc);
+      if (isBindingSource) {
+        for (const relation of relationPaths) {
+          resolveBindingRelationInclude(ctx, query.table, relation.split("."));
+        }
+        const nestedIncludes = buildNestedIncludes(relationPaths, flatMode);
+        for (const inc of nestedIncludes) {
+          const exists = allIncludes.some(
+            (existing) => existing.relation === inc.relation
+          );
+          if (!exists) {
+            allIncludes.push(inc);
+          }
+        }
+      } else {
+        const nestedIncludes = buildNestedIncludes(relationPaths, flatMode);
+        for (const inc of nestedIncludes) {
+          const exists = allIncludes.some(
+            (existing) => existing.relation === inc.relation
+          );
+          if (!exists) {
+            allIncludes.push(inc);
+          }
         }
       }
     }
@@ -1489,9 +2145,10 @@ function expressionOutputColumn(expr) {
   }
 }
 function addUnique(columns, seen, column) {
-  if (seen.has(column)) return;
+  if (seen.has(column)) return false;
   seen.add(column);
   columns.push(column);
+  return true;
 }
 function resolveSourceOutputColumns(intent, ctx, bindingName) {
   const bindingColumns2 = getKnownBindingColumns(ctx, intent.from);
@@ -1503,33 +2160,62 @@ function resolveSourceOutputColumns(intent, ctx, bindingName) {
     `Cannot compute output schema for NQL binding '${bindingName}' from SELECT * on '${intent.from}' without a concrete table schema.`
   );
 }
-function getQueryOutputSchema(intent, ctx, bindingName) {
+function getQueryOutputSchema(intent, ctx, bindingName, bindingDependencies = []) {
   const columns = [];
   const seen = /* @__PURE__ */ new Set();
+  const directProjectionLineage = [];
   const addColumn = (column) => addUnique(columns, seen, column);
+  const resolveSourceColumn = (column) => ctx.validator?.resolveColumnName(intent.from, column) ?? column;
+  const addDirectProjection = (outputColumn, sourceColumn) => {
+    if (!addColumn(outputColumn)) return;
+    directProjectionLineage.push({
+      kind: "directProjection",
+      sourceTable: intent.from,
+      sourceColumn: resolveSourceColumn(sourceColumn),
+      outputColumn
+    });
+  };
   const addSourceColumns = () => {
     for (const column of resolveSourceOutputColumns(intent, ctx, bindingName)) {
-      addColumn(column);
+      addDirectProjection(column, column);
     }
   };
   const { select } = intent;
   if (!select || select.type === "all") {
     addSourceColumns();
-    return { columns };
+    const outputSchema2 = { columns, directProjectionLineage };
+    return {
+      columns: outputSchema2.columns,
+      relationFilters: getBindingRelationFilterMetadata(
+        intent,
+        ctx,
+        outputSchema2,
+        bindingDependencies
+      )
+    };
   }
   if (select.type === "fields") {
     for (const field of select.fields) {
       if (field === "*") {
         addSourceColumns();
       } else {
-        addColumn(field);
+        addDirectProjection(field, field);
       }
     }
-    return { columns };
+    const outputSchema2 = { columns, directProjectionLineage };
+    return {
+      columns: outputSchema2.columns,
+      relationFilters: getBindingRelationFilterMetadata(
+        intent,
+        ctx,
+        outputSchema2,
+        bindingDependencies
+      )
+    };
   }
   if (select.type === "aggregate") {
     for (const field of select.fields ?? []) {
-      addColumn(field);
+      addDirectProjection(field, field);
     }
     for (const aggregate of select.aggregates) {
       if (!aggregate.as) {
@@ -1540,7 +2226,16 @@ function getQueryOutputSchema(intent, ctx, bindingName) {
       }
       addColumn(aggregate.as);
     }
-    return { columns };
+    const outputSchema2 = { columns, directProjectionLineage };
+    return {
+      columns: outputSchema2.columns,
+      relationFilters: getBindingRelationFilterMetadata(
+        intent,
+        ctx,
+        outputSchema2,
+        bindingDependencies
+      )
+    };
   }
   for (const expr of select.columns) {
     if (expr.kind === "column" && expr.column === "*") {
@@ -1560,9 +2255,24 @@ function getQueryOutputSchema(intent, ctx, bindingName) {
         `Cannot compute output schema for NQL binding '${bindingName}': selected expression must use an alias.`
       );
     }
-    addColumn(outputColumn);
+    if (expr.kind === "column") {
+      addDirectProjection(outputColumn, expr.column);
+    } else if (expr.kind === "columnAlias") {
+      addDirectProjection(outputColumn, expr.column);
+    } else {
+      addColumn(outputColumn);
+    }
   }
-  return { columns };
+  const outputSchema = { columns, directProjectionLineage };
+  return {
+    columns: outputSchema.columns,
+    relationFilters: getBindingRelationFilterMetadata(
+      intent,
+      ctx,
+      outputSchema,
+      bindingDependencies
+    )
+  };
 }
 function validateNqlExpressionPaths(expr, ctx) {
   switch (expr.type) {
@@ -2334,13 +3044,12 @@ function compileRelationFilter(expr, ctx, fns, aliasContext, outerAliases) {
   const relFilter = expr;
   const nestedOuterAliases = aliasContext ? [...outerAliases ?? [], aliasContext] : outerAliases ?? [];
   const prevRelationTarget = ctx.currentRelationTarget;
+  const bindingRelation = ctx.currentFromTable && relFilter.relation[0] ? resolveBindingRelationFilter(
+    ctx,
+    ctx.currentFromTable,
+    relFilter.relation
+  ) : void 0;
   if (ctx.currentFromTable && relFilter.relation[0]) {
-    assertNoBindingRelationConstruct(
-      ctx,
-      ctx.currentFromTable,
-      "use relation filters",
-      relFilter.relation.join(".")
-    );
     if (ctx.validator) {
       ctx.currentRelationTarget = ctx.validator.resolveRelationTarget(
         ctx.currentFromTable,
@@ -2356,13 +3065,28 @@ function compileRelationFilter(expr, ctx, fns, aliasContext, outerAliases) {
     nestedOuterAliases
   );
   ctx.currentRelationTarget = prevRelationTarget;
-  return {
+  const relationFilterIntent = {
     kind: "relationFilter",
     relation: relFilter.relation,
     where,
     mode: relFilter.mode,
-    ...relFilter.alias !== void 0 && { alias: relFilter.alias }
+    ...relFilter.alias !== void 0 && { alias: relFilter.alias },
+    ...bindingRelation !== void 0 && {
+      targetTable: bindingRelation.targetTable,
+      sourceColumn: bindingRelation.sourceColumn,
+      targetColumn: bindingRelation.targetColumn
+    }
   };
+  return bindingRelation ? markNqlTrustedRelationFilter(relationFilterIntent, {
+    relation: bindingRelation.relation,
+    targetTable: bindingRelation.targetTable,
+    sourceColumn: bindingRelation.sourceColumn,
+    targetColumn: bindingRelation.targetColumn,
+    hops: bindingRelation.hops,
+    ...bindingRelation.cardinality !== void 0 && {
+      cardinality: bindingRelation.cardinality
+    }
+  }) : relationFilterIntent;
 }
 function expandDateRangeList(field, patterns, negated) {
   const conditions = patterns.map((pattern) => {
@@ -2468,6 +3192,20 @@ var SELECT_SCALAR_FUNCTION_NAMES = /* @__PURE__ */ new Set([
   ...NQL_SELECT_JSON_FUNCTIONS,
   ...NQL_SELECT_SCALAR_FUNCTIONS
 ]);
+function resolveBindingRelationInclude2(ctx, bindingName, relationPath) {
+  if (!isBindingTable(ctx, bindingName)) return false;
+  if (!bindingName || !ctx.validator) {
+    throw new NqlSemanticException(
+      NqlErrorCodes.SEM_INVALID_SYNTAX,
+      `Query '${bindingName ?? "<unknown>"}' reads from an NQL binding and cannot use relation include '${relationPath.join(".")}' (ref-#192): model metadata is not available.`
+    );
+  }
+  ctx.validator.resolveVirtualBindingScalarRelationForInclude(
+    bindingName,
+    relationPath
+  );
+  return true;
+}
 function validateSelectPathExpression(expr, ctx) {
   if (!ctx.currentFromTable) return;
   const { segments } = expr;
@@ -2523,12 +3261,14 @@ function compileSelectClause(clause, ctx, fns) {
     } else if (item.type === "relationStar") {
       hasExpressions = true;
       const relation = item.relation.join(".");
-      assertNoBindingRelationConstruct(
-        ctx,
-        ctx.currentFromTable,
-        "select relation columns",
-        relation
-      );
+      if (!resolveBindingRelationInclude2(ctx, ctx.currentFromTable, item.relation)) {
+        assertNoBindingRelationConstruct(
+          ctx,
+          ctx.currentFromTable,
+          "select relation columns",
+          relation
+        );
+      }
       expressions.push({
         kind: "relationColumn",
         relation,
@@ -2854,27 +3594,47 @@ function compileMultiSegmentPath(expr, item, ctx) {
   }
   const column = segments[segments.length - 1];
   const relation = segments.slice(0, -1).join(".");
-  assertNoBindingRelationConstruct(
+  const bindingRelation = resolveBindingRelationColumn(
     ctx,
     ctx.currentFromTable,
-    "select relation columns",
-    relation
+    segments.slice(0, -1),
+    column
   );
-  if (ctx.currentFromTable && ctx.validator) {
-    const targetTable = ctx.validator.resolveRelationTarget(
+  if (!bindingRelation) {
+    assertNoBindingRelationConstruct(
+      ctx,
       ctx.currentFromTable,
-      segments[0]
+      "select relation columns",
+      relation
     );
+  }
+  if (ctx.currentFromTable && ctx.validator) {
+    const lastBindingHop = bindingRelation?.hops[bindingRelation.hops.length - 1];
+    const targetTable = lastBindingHop?.target ?? bindingRelation?.targetTable ?? ctx.validator.resolveRelationTarget(ctx.currentFromTable, segments[0]);
     if (targetTable) {
       ctx.validator.validateColumn(targetTable, column);
     }
   }
-  return {
+  const relationColumnIntent = {
     kind: "relationColumn",
     relation,
     column,
     as: item.alias ?? `${relation}.${column}`
   };
+  return bindingRelation ? markNqlTrustedRelationFilter(relationColumnIntent, {
+    relation: bindingRelation.relation,
+    targetTable: bindingRelation.targetTable,
+    sourceColumn: bindingRelation.sourceColumn,
+    targetColumn: bindingRelation.targetColumn,
+    hops: bindingRelation.hops,
+    selectedColumn: column,
+    ...bindingRelation.cardinality !== void 0 && {
+      cardinality: bindingRelation.cardinality
+    },
+    ...bindingRelation.relationType !== void 0 && {
+      relationType: bindingRelation.relationType
+    }
+  }) : relationColumnIntent;
 }
 function compileCaseExpression(caseExpr, item, ctx, fns) {
   if (caseExpr.subject) {
@@ -3262,6 +4022,7 @@ var NqlCompiler = class {
       recursiveKeywords,
       validator,
       bindingOutputColumns: /* @__PURE__ */ new Map(),
+      bindingRelationFilters: /* @__PURE__ */ new Map(),
       params,
       maxAnyItems: maxAnyItemsRaw ?? MAX_ANY_ITEMS,
       allowUnfilteredMutations: options?.allowUnfilteredMutations ?? false,
@@ -3281,6 +4042,7 @@ var NqlCompiler = class {
       return this.compileProgram(program);
     } finally {
       this.ctx.bindingOutputColumns.clear();
+      this.ctx.bindingRelationFilters.clear();
       this.ctx.validator?.clearVirtualBindingTables();
     }
   }
@@ -3364,13 +4126,15 @@ var NqlCompiler = class {
           const outputSchema = this.registerQueryBindingOutputSchema(
             bindName,
             lastResult.query,
-            bindingOutputSchemas
+            bindingOutputSchemas,
+            statementBindingDependencies
           );
           bindings.set(bindName, lastResult.query);
           if (outputSchema) {
             this.ctx.validator?.addVirtualBindingTable(
               bindName,
-              outputSchema.columns
+              outputSchema.columns,
+              outputSchema.relationFilters
             );
           }
           materializedBindStatements.add(i);
@@ -3399,7 +4163,8 @@ var NqlCompiler = class {
             bindingOutputSchemas.set(bindName, outputSchema);
             this.ctx.validator?.addVirtualBindingTable(
               bindName,
-              outputSchema.columns
+              outputSchema.columns,
+              outputSchema.relationFilters
             );
           }
           materializedBindStatements.add(i);
@@ -3439,11 +4204,22 @@ var NqlCompiler = class {
     }
     return lastResult;
   }
-  registerQueryBindingOutputSchema(bindName, query, bindingOutputSchemas) {
+  registerQueryBindingOutputSchema(bindName, query, bindingOutputSchemas, bindingDependencies) {
     try {
-      const outputSchema = getQueryOutputSchema(query, this.ctx, bindName);
+      const outputSchema = getQueryOutputSchema(
+        query,
+        this.ctx,
+        bindName,
+        bindingDependencies
+      );
       bindingOutputSchemas.set(bindName, outputSchema);
       this.ctx.bindingOutputColumns.set(bindName, outputSchema.columns);
+      if (outputSchema.relationFilters) {
+        this.ctx.bindingRelationFilters.set(
+          bindName,
+          outputSchema.relationFilters
+        );
+      }
       return outputSchema;
     } catch (error) {
       if (!this.ctx.validator && isUnresolvedSelectAllOutputSchemaError(error)) {