@dbsp/nql 1.8.0 → 1.9.0

package/dist/index.d.ts

@@ -532,8 +532,8 @@ declare class NqlCompiler {
      * binding. #213 B2: detection consumes `ctx.lastMutationReturningItems`
      * (alias-aware, positional) — NEVER the collapsed `columns` names — so an
      * alias colliding with a real column (`returning email as name`) is
-     * flagged 'aliased-returning' rather than silently mistyped as the
-     * colliding column's type.
+     * typed by its physical source column rather than silently mistyped as the
+     * colliding output column's type.
      */
     private buildMutationReturningColumnTypes;
     private compileSingleStatement;

package/dist/index.js

@@ -1176,6 +1176,7 @@ function assignMutationValue(target, column, value, ctx) {
 function compileMutationPipeline(pipeline, ctx, fns, bindings) {
   ctx.currentFromTable = pipeline.mutation.table;
   const mutation = compileMutation(pipeline.mutation, ctx, fns, bindings);
+  ctx.currentFromTable = pipeline.mutation.table;
   let returning;
   let returningItems;
   for (const clause of pipeline.clauses) {
@@ -1186,8 +1187,18 @@ function compileMutationPipeline(pipeline, ctx, fns, bindings) {
   }
   ctx.lastMutationReturningItems = returningItems;
   if (returning) {
+    const aliasAwareReturningItems = returningItems !== void 0 && returningItems !== "star" && returningItems.some((item) => item.aliased) ? returningItems.map((item) => ({
+      source: item.source,
+      output: item.output
+    })) : void 0;
     return {
-      mutation: { ...mutation, returning }
+      mutation: {
+        ...mutation,
+        returning,
+        ...aliasAwareReturningItems !== void 0 && {
+          returningItems: aliasAwareReturningItems
+        }
+      }
     };
   }
   return { mutation };
@@ -1374,19 +1385,42 @@ function compileUpsertFrom(upsertFrom, ctx, fns, bindings) {
 }
 function extractReturningItems(clause, ctx) {
   const items = [];
+  const outputs = /* @__PURE__ */ new Set();
   for (const item of clause.items) {
     if (item.type === "star") {
+      if (clause.items.length > 1) {
+        throw new NqlSemanticException(
+          NqlErrorCodes.SEM_INVALID_SYNTAX,
+          "Mutation RETURNING cannot mix `select *` with explicit projection items."
+        );
+      }
       return "star";
     }
     if (item.type === "expression") {
       const field = expressionToField(item.expression);
       if (field) {
+        const aliased = item.alias !== void 0;
+        if (aliased && field.includes(".")) {
+          throw new NqlSemanticException(
+            NqlErrorCodes.SEM_INVALID_SYNTAX,
+            `Mutation RETURNING alias cannot use dotted source '${field}'.`
+          );
+        }
         if (ctx.currentFromTable && !field.includes(".")) {
           ctx.validator?.validateColumn(ctx.currentFromTable, field);
         }
+        const output = item.alias ?? field;
+        if (outputs.has(output)) {
+          throw new NqlSemanticException(
+            NqlErrorCodes.SEM_INVALID_SYNTAX,
+            `Mutation RETURNING has duplicate output name '${output}'.`
+          );
+        }
+        outputs.add(output);
         items.push({
-          output: item.alias ?? field,
-          aliased: item.alias !== void 0
+          source: field,
+          output,
+          aliased
         });
       }
     }
@@ -4243,6 +4277,9 @@ function programSequenceStepFromResult(result, bindName, final, bindingDependenc
 function stringArraysEqual(left, right) {
   return left.length === right.length && left.every((value, index) => value === right[index]);
 }
+function mutationReturningItemsMatchReturning(returning, returningItems) {
+  return returningItems.length === returning.length && returningItems.every((item, index) => item.output === returning[index]);
+}
 function isNqlAstRecord(value) {
   return typeof value === "object" && value !== null;
 }
@@ -4733,7 +4770,50 @@ var NqlCompiler = class {
       mutation
     );
     const returning = mutation.returning;
-    if (returning === void 0 || returning.length === 0 || returning.includes("*") || outputSchema === void 0 || stringArraysEqual(returning, outputSchema.columns)) {
+    const returningItems = mutation.returningItems;
+    if (returning === void 0 || returning.length === 0 || returning.includes("*") || outputSchema === void 0) {
+      return { mutation, outputSchema };
+    }
+    const seenOutputs = /* @__PURE__ */ new Set();
+    for (const column of outputSchema.columns) {
+      if (seenOutputs.has(column)) {
+        throw new NqlSemanticException(
+          NqlErrorCodes.SEM_INVALID_SYNTAX,
+          `Mutation RETURNING resolves to duplicate output name '${column}' after column canonicalization for binding '${bindName}'.`
+        );
+      }
+      seenOutputs.add(column);
+    }
+    if (returningItems !== void 0) {
+      const internalItems = this.ctx.lastMutationReturningItems !== void 0 && this.ctx.lastMutationReturningItems !== "star" ? this.ctx.lastMutationReturningItems : void 0;
+      const canonicalItems = returningItems.map((item, index) => {
+        const source = this.ctx.validator?.resolveColumnName(mutation.table, item.source) ?? item.source;
+        const internalItem = internalItems?.[index];
+        const output = internalItem?.aliased ? item.output : source;
+        return source === item.source && output === item.output ? item : { source, output };
+      });
+      if (!mutationReturningItemsMatchReturning(
+        outputSchema.columns,
+        canonicalItems
+      )) {
+        throw new NqlSemanticException(
+          NqlErrorCodes.SEM_INVALID_SYNTAX,
+          `Mutation RETURNING item outputs drifted during canonicalization for binding '${bindName}'.`
+        );
+      }
+      if (stringArraysEqual(returning, outputSchema.columns) && canonicalItems.every((item, index) => item === returningItems[index])) {
+        return { mutation, outputSchema };
+      }
+      return {
+        mutation: {
+          ...mutation,
+          returning: outputSchema.columns,
+          returningItems: canonicalItems
+        },
+        outputSchema
+      };
+    }
+    if (stringArraysEqual(returning, outputSchema.columns)) {
       return { mutation, outputSchema };
     }
     return {
@@ -4764,6 +4844,18 @@ var NqlCompiler = class {
     const columns = returning.map(
       (column) => this.ctx.validator?.resolveColumnName(mutation.table, column) ?? column
     );
+    const returningItems = mutation.returningItems;
+    if (returningItems !== void 0) {
+      const internalItems = this.ctx.lastMutationReturningItems !== void 0 && this.ctx.lastMutationReturningItems !== "star" ? this.ctx.lastMutationReturningItems : void 0;
+      const columns2 = returningItems.map((item, index) => {
+        const source = this.ctx.validator?.resolveColumnName(mutation.table, item.source) ?? item.source;
+        return internalItems?.[index]?.aliased ? item.output : source;
+      });
+      return {
+        columns: columns2,
+        ...this.buildMutationReturningColumnTypes(mutation.table, columns2)
+      };
+    }
     return {
       columns,
       ...this.buildMutationReturningColumnTypes(mutation.table, columns)
@@ -4774,8 +4866,8 @@ var NqlCompiler = class {
    * binding. #213 B2: detection consumes `ctx.lastMutationReturningItems`
    * (alias-aware, positional) — NEVER the collapsed `columns` names — so an
    * alias colliding with a real column (`returning email as name`) is
-   * flagged 'aliased-returning' rather than silently mistyped as the
-   * colliding column's type.
+   * typed by its physical source column rather than silently mistyped as the
+   * colliding output column's type.
    */
   buildMutationReturningColumnTypes(table, columns) {
     const items = this.ctx.lastMutationReturningItems;
@@ -4783,7 +4875,11 @@ var NqlCompiler = class {
       (column, index) => {
         const item = items !== void 0 && items !== "star" ? items[index] : void 0;
         if (item?.aliased) {
-          return { column, untypeable: "aliased-returning" };
+          const typeInfo2 = this.ctx.validator?.getTableColumnType(
+            table,
+            item.source
+          );
+          return typeInfo2 !== void 0 ? { column, typed: typeInfo2 } : { column, untypeable: "unresolvable-source" };
         }
         const typeInfo = this.ctx.validator?.getTableColumnType(table, column);
         return typeInfo !== void 0 ? { column, typed: typeInfo } : { column, untypeable: "unresolvable-source" };