@dbsp/adapter-pgsql 1.2.0 → 1.2.1

package/dist/index.d.ts

@@ -282,6 +282,7 @@ declare class PlanCompiler {
     private joinAliasMap;
     /**
      * Tracks all join aliases in use for the current query.
+     * Entries are stored in emitted database-alias space, after naming.toDatabase().
      * Ensures no two JOINs share the same alias (DOUBLE-ALIAS prevention).
      */
     private usedJoinAliases;
@@ -289,6 +290,8 @@ declare class PlanCompiler {
     /** Build immutable context for handler-based WHERE compilation */
     private handlerCtx;
     private findAliasForLegacySourceTable;
+    private emittedJoinAlias;
+    private resolvedJoinAliases;
     /**
      * Dispatch a PlanDecision through the unified WHERE handler system.
      * Bridges PlanCompiler's state to handler types, calls dispatcher, syncs back.
@@ -340,7 +343,9 @@ declare class PlanCompiler {
      * Compile an includeStrategy decision and register its results.
      * Pushes targets onto targetList, raw joins / CTEs onto instance collections.
      */
+    private registerIncludeCompilationResult;
     private compileIncludeDecision;
+    private compileJoinIncludeAllocationPass;
     /**
      * Fold a WHERE-family decision into an existing where expression.
      * Returns the updated (or new) where node.
@@ -362,6 +367,7 @@ declare class PlanCompiler {
      * column refs like `project_id` resolve against the joined table, not root.
      */
     private compileIncludeWhereConditions;
+    private reserveManualJoinAliases;
     /**
      * Apply a single join decision to the FROM clause in-place.
      * Chains multiple joins by wrapping from[0] as the left-arg each time.
@@ -1042,6 +1048,8 @@ interface CompilerContext {
     readonly rootTable: string;
     /** Current table alias (for JOINs) */
     readonly currentAlias?: string;
+    /** Final relation path/name → SQL join alias map for relation-aware expression contexts */
+    readonly aliases?: ReadonlyMap<string, string>;
     /** Maximum recursive depth (default: 100) */
     readonly maxRecursiveDepth: number;
     /** Optional callback for raw SQL audit trail */

package/dist/index.js

@@ -1355,7 +1355,9 @@ function compileExpressionIntent(intent, ctx, state) {
     }
     case "relationColumn": {
       const rc = intent;
-      const alias = state.aliases.get(rc.relation) ?? rc.relation;
+      const relationSegments = rc.relation.split(".");
+      const leaf = relationSegments[relationSegments.length - 1] ?? rc.relation;
+      const alias = state.aliases.get(rc.relation) ?? state.aliases.get(leaf) ?? leaf;
       return columnRef(rc.column, alias, void 0, ctx.naming);
     }
     case "case": {
@@ -2814,8 +2816,9 @@ var init_param_intent = __esm({
 import { isFieldRef, isParamIntent as isParamIntent3 } from "@dbsp/types";
 function buildColumnRef(column, ctx) {
   if (column.includes(".")) {
-    const dotIndex = column.indexOf(".");
-    const table = column.substring(0, dotIndex);
+    const dotIndex = column.lastIndexOf(".");
+    const relation = column.substring(0, dotIndex);
+    const table = ctx.aliases?.get(relation) ?? relation;
     const col = column.substring(dotIndex + 1);
     return columnRef(col, table, void 0, ctx.naming);
   }
@@ -6685,7 +6688,7 @@ var init_relation = __esm({
         if (relation.includes(".")) {
           const segments = relation.split(".");
           const leaf = segments[segments.length - 1];
-          alias = state.aliases.get(leaf) ?? state.aliases.get(relation) ?? leaf;
+          alias = state.aliases.get(relation) ?? state.aliases.get(leaf) ?? leaf;
         } else {
           alias = state.aliases.get(relation) ?? relation;
         }
@@ -8357,6 +8360,7 @@ var PlanCompiler = class _PlanCompiler {
   joinAliasMap = /* @__PURE__ */ new Map();
   /**
    * Tracks all join aliases in use for the current query.
+   * Entries are stored in emitted database-alias space, after naming.toDatabase().
    * Ensures no two JOINs share the same alias (DOUBLE-ALIAS prevention).
    */
   usedJoinAliases = /* @__PURE__ */ new Set();
@@ -8372,6 +8376,7 @@ var PlanCompiler = class _PlanCompiler {
     return {
       naming: this.naming,
       rootTable: this.currentRootTable,
+      aliases: this.resolvedJoinAliases(),
       maxRecursiveDepth: 100,
       defaultPkColumnName: this.defaultPk,
       deriveFkColumnName: this.deriveFk,
@@ -8386,6 +8391,24 @@ var PlanCompiler = class _PlanCompiler {
     }
     return alias;
   }
+  emittedJoinAlias(alias) {
+    const dbAlias = this.naming.toDatabase(alias);
+    validateIdentifier(dbAlias, "alias");
+    return dbAlias;
+  }
+  resolvedJoinAliases() {
+    const aliases = /* @__PURE__ */ new Map();
+    for (const [relationPath, entry] of this.joinAliasMap) {
+      const isLegacyPath = relationPath.startsWith("__legacy__:");
+      if (!isLegacyPath) {
+        aliases.set(relationPath, entry.alias);
+      }
+      if (entry.relationName && (isLegacyPath || relationPath === entry.relationName)) {
+        aliases.set(entry.relationName, entry.alias);
+      }
+    }
+    return aliases;
+  }
   /**
    * Dispatch a PlanDecision through the unified WHERE handler system.
    * Bridges PlanCompiler's state to handler types, calls dispatcher, syncs back.
@@ -8567,12 +8590,13 @@ var PlanCompiler = class _PlanCompiler {
       const candidateAlias = handlerDecision.relation ?? handlerDecision.targetTable ?? handlerDecision.relationName;
       if (candidateAlias) {
         let alias = candidateAlias;
+        let emittedAlias = this.emittedJoinAlias(alias);
         let counter = 1;
-        while (this.usedJoinAliases.has(alias)) {
+        while (this.usedJoinAliases.has(emittedAlias)) {
           alias = `${candidateAlias}_${counter++}`;
+          emittedAlias = this.emittedJoinAlias(alias);
         }
-        validateIdentifier(alias, "alias");
-        this.usedJoinAliases.add(alias);
+        this.usedJoinAliases.add(emittedAlias);
         finalJoinAlias = alias;
         if (alias !== candidateAlias) {
           handlerDecision.relation = alias;
@@ -8585,7 +8609,10 @@ var PlanCompiler = class _PlanCompiler {
       this.joinAliasMap.set(relationIdentityPath, {
         alias: finalJoinAlias,
         joinType: requestedJoinType,
-        ...decision.targetTable && { targetTable: decision.targetTable }
+        ...decision.targetTable && { targetTable: decision.targetTable },
+        ...(decision.relationName ?? decision.relation) && {
+          relationName: decision.relationName ?? decision.relation
+        }
       });
     }
     const out = {};
@@ -8658,6 +8685,7 @@ var PlanCompiler = class _PlanCompiler {
       naming: this.naming,
       rootTable: plan.rootTable,
       currentAlias: currentAlias ?? plan.rootTable,
+      aliases: this.resolvedJoinAliases(),
       maxRecursiveDepth: 100,
       defaultPkColumnName: this.defaultPk,
       deriveFkColumnName: this.deriveFk,
@@ -8673,7 +8701,7 @@ var PlanCompiler = class _PlanCompiler {
       parameters: this.state.parameters,
       paramIndex: this.state.paramIndex,
       ctes: /* @__PURE__ */ new Map(),
-      aliases: /* @__PURE__ */ new Map(),
+      aliases: this.resolvedJoinAliases(),
       joins: []
     };
   }
@@ -9131,11 +9159,7 @@ var PlanCompiler = class _PlanCompiler {
    * Compile an includeStrategy decision and register its results.
    * Pushes targets onto targetList, raw joins / CTEs onto instance collections.
    */
-  compileIncludeDecision(decision, plan, targetList) {
-    const includeResult = this.compileIncludeViaHandler(decision, plan);
-    if (includeResult.targets) {
-      targetList.push(...includeResult.targets);
-    }
+  registerIncludeCompilationResult(includeResult) {
     if (includeResult.rawJoin) {
       this.rawJoins.push(includeResult.rawJoin);
     }
@@ -9146,6 +9170,27 @@ var PlanCompiler = class _PlanCompiler {
       this.pendingCtes.push(includeResult.cte);
     }
   }
+  compileIncludeDecision(decision, plan, targetList, precompiled) {
+    const includeResult = precompiled ?? this.compileIncludeViaHandler(decision, plan);
+    if (includeResult.targets) {
+      targetList.push(...includeResult.targets);
+    }
+    if (!precompiled) {
+      this.registerIncludeCompilationResult(includeResult);
+    }
+  }
+  compileJoinIncludeAllocationPass(decisions, plan) {
+    const includeResults = /* @__PURE__ */ new Map();
+    for (const decision of decisions) {
+      if (decision.type !== "includeStrategy" || decision.choice !== "join") {
+        continue;
+      }
+      const includeResult = this.compileIncludeViaHandler(decision, plan);
+      includeResults.set(decision, includeResult);
+      this.registerIncludeCompilationResult(includeResult);
+    }
+    return includeResults;
+  }
   /**
    * Fold a WHERE-family decision into an existing where expression.
    * Returns the updated (or new) where node.
@@ -9279,6 +9324,14 @@ var PlanCompiler = class _PlanCompiler {
     }
     return where;
   }
+  reserveManualJoinAliases(decisions) {
+    for (const decision of decisions) {
+      if (decision.type !== "join") continue;
+      const alias = decision.alias ?? decision.targetTable;
+      if (!alias) continue;
+      this.usedJoinAliases.add(this.emittedJoinAlias(alias));
+    }
+  }
   /**
    * Apply a single join decision to the FROM clause in-place.
    * Chains multiple joins by wrapping from[0] as the left-arg each time.
@@ -9343,14 +9396,11 @@ var PlanCompiler = class _PlanCompiler {
    */
   compileGroupByDecision(decision) {
     const gbCol = decision.column;
-    const gbDot = gbCol.indexOf(".");
+    const gbDot = gbCol.lastIndexOf(".");
     if (gbDot !== -1) {
-      return columnRef(
-        gbCol.slice(gbDot + 1),
-        gbCol.slice(0, gbDot),
-        void 0,
-        this.naming
-      );
+      const relation = gbCol.slice(0, gbDot);
+      const alias = this.resolvedJoinAliases().get(relation) ?? relation;
+      return columnRef(gbCol.slice(gbDot + 1), alias, void 0, this.naming);
     }
     return columnRef(gbCol, decision.table, void 0, this.naming);
   }
@@ -9400,10 +9450,17 @@ var PlanCompiler = class _PlanCompiler {
       plan.decisions,
       plan.rootTable
     );
+    this.reserveManualJoinAliases(decisions);
+    const includeJoinResults = this.compileJoinIncludeAllocationPass(
+      decisions,
+      plan
+    );
+    this.state.aliases = this.resolvedJoinAliases();
     const targetList = [];
     const from = this.compileFromClause(plan);
     let where;
     const orderBy = [];
+    const orderByDecisions = [];
     const groupBy = [];
     let having;
     let limit;
@@ -9423,7 +9480,12 @@ var PlanCompiler = class _PlanCompiler {
           this.compileSelectTarget(decision, plan, targetList);
           break;
         case "includeStrategy":
-          this.compileIncludeDecision(decision, plan, targetList);
+          this.compileIncludeDecision(
+            decision,
+            plan,
+            targetList,
+            includeJoinResults.get(decision)
+          );
           where = this.compileIncludeWhereConditions(decision, where);
           break;
         case "where":
@@ -9436,8 +9498,7 @@ var PlanCompiler = class _PlanCompiler {
           this.compileJoinDecision(decision, plan, from);
           break;
         case "orderBy": {
-          const obNode = this.compileOrderByDecision(decision, plan);
-          if (obNode) orderBy.push(obNode);
+          orderByDecisions.push(decision);
           break;
         }
         case "groupBy":
@@ -9484,6 +9545,10 @@ var PlanCompiler = class _PlanCompiler {
           break;
       }
     }
+    for (const decision of orderByDecisions) {
+      const obNode = this.compileOrderByDecision(decision, plan);
+      if (obNode) orderBy.push(obNode);
+    }
     this.flushPendingJoins(from, plan);
     return this.buildSelectStmt(
       targetList,