@dbsp/nql 1.0.4 → 1.1.0

package/dist/index.d.ts

@@ -440,6 +440,8 @@ interface NqlCompilerOptions {
     readonly params?: Readonly<Record<string, unknown>>;
     /** Maximum number of items allowed in an ANY(:param) array. Defaults to MAX_ANY_ITEMS (10000). */
     readonly maxAnyItems?: number;
+    /** Permit a where-less update/delete to compile to an unfiltered, all-rows mutation. Default false — a where-less mutation throws unless this is set. */
+    readonly allowUnfilteredMutations?: boolean;
 }
 
 /**

package/dist/index.js

@@ -387,6 +387,21 @@ function applyIncludeLimit(includes, path, limit) {
 }
 
 // src/compiler/compile-query.ts
+function compileNestedQuery(query, ctx, fns, bindings) {
+  const savedContext = {
+    currentFromTable: ctx.currentFromTable,
+    currentRelationTarget: ctx.currentRelationTarget
+  };
+  try {
+    if (bindings) {
+      return compileQuery(query, ctx, fns, bindings);
+    }
+    return fns.compileQuery(query, ctx);
+  } finally {
+    ctx.currentFromTable = savedContext.currentFromTable;
+    ctx.currentRelationTarget = savedContext.currentRelationTarget;
+  }
+}
 function compileQuery(query, ctx, fns, bindings) {
   const setClauseIndex = query.clauses.findIndex(
     (c) => c.type === "setOperation"
@@ -569,6 +584,12 @@ function getExplicitColumnCount(intent) {
 }
 function compileSetOperation(query, setClauseIndex, ctx, fns, bindings) {
   const setClause = query.clauses[setClauseIndex];
+  if (setClauseIndex < query.clauses.length - 1) {
+    const trailingTypes = query.clauses.slice(setClauseIndex + 1).map((c) => c.type).join(", ");
+    throw new Error(
+      `Clauses after a set operation are not supported (found: ${trailingTypes}). Wrap the set operation in a subquery or move the clause before the set operation.`
+    );
+  }
   const leftQuery = {
     table: query.table,
     clauses: query.clauses.slice(0, setClauseIndex)
@@ -576,7 +597,7 @@ function compileSetOperation(query, setClauseIndex, ctx, fns, bindings) {
   const left = compileQuery(leftQuery, ctx, fns, bindings);
   let right;
   if (setClause.right) {
-    right = compileQuery(setClause.right, ctx, fns, bindings);
+    right = compileNestedQuery(setClause.right, ctx, fns, bindings);
   } else if (setClause.boundName) {
     const bound = bindings?.get(setClause.boundName);
     if (!bound) {
@@ -646,7 +667,7 @@ function compileWithQuery(astNode, ctx, fns) {
   try {
     const ctes = [];
     for (const cte of astNode.ctes) {
-      const bodyResult = compileQuery(cte.query, ctx, fns);
+      const bodyResult = compileNestedQuery(cte.query, ctx, fns);
       if ("kind" in bodyResult && bodyResult.kind === "setOperation") {
         throw new NqlSemanticException(
           NqlErrorCodes.SEM_UNKNOWN_TABLE,
@@ -1005,7 +1026,11 @@ function compileMembership(expr, ctx, fns, aliasContext, outerAliases) {
       return expandDateRangeList(field, dateRangeValues, inExpr.negated);
     }
   } else if ("type" in inExpr.values && inExpr.values.type === "subquery") {
-    const subquery = fns.compileQuery(inExpr.values.query, ctx);
+    const subquery = compileNestedQuery(
+      inExpr.values.query,
+      ctx,
+      fns
+    );
     const result2 = {
       kind: "in",
       field,
@@ -1331,7 +1356,11 @@ function compileInsert(insert, ctx) {
   };
 }
 function compileInsertFrom(insertFrom, ctx, fns, bindings) {
+  ctx.validator?.validateTable(insertFrom.table);
   const sourceQuery = bindings?.get(insertFrom.source);
+  if (!sourceQuery) {
+    ctx.validator?.validateTable(insertFrom.source);
+  }
   ctx.currentFromTable = insertFrom.source;
   return {
     type: "insert_from",
@@ -1365,6 +1394,11 @@ function compileUpdate(update, ctx, fns, bindings) {
       )
     };
   }
+  if (!ctx.allowUnfilteredMutations) {
+    throw new Error(
+      "update without a where clause would affect all rows; pass { allowUnfilteredMutations: true } to the compiler to allow an unfiltered update"
+    );
+  }
   return {
     type: "update",
     table: update.table,
@@ -1385,6 +1419,11 @@ function compileDelete(del, ctx, fns, bindings) {
       )
     };
   }
+  if (!ctx.allowUnfilteredMutations) {
+    throw new Error(
+      "delete without a where clause would affect all rows; pass { allowUnfilteredMutations: true } to the compiler to allow an unfiltered delete"
+    );
+  }
   return {
     type: "delete",
     table: del.table,
@@ -1401,6 +1440,11 @@ function compileUpsert(upsert, ctx) {
   for (const col of upsert.conflictColumns) {
     ctx.validator?.validateColumn(upsert.table, col);
   }
+  if (upsert.where) {
+    throw new Error(
+      "conditional upsert is not yet supported: a WHERE clause on `upsert` (ON CONFLICT DO UPDATE ... WHERE) is parsed but cannot be honored by the SQL generator yet. Remove the WHERE, or use a plain conditional update. Tracked for a future release."
+    );
+  }
   return {
     type: "upsert",
     table: upsert.table,
@@ -1410,7 +1454,14 @@ function compileUpsert(upsert, ctx) {
   };
 }
 function compileUpsertFrom(upsertFrom, ctx, fns, bindings) {
+  ctx.validator?.validateTable(upsertFrom.table);
   const sourceQuery = bindings?.get(upsertFrom.source);
+  if (!sourceQuery) {
+    ctx.validator?.validateTable(upsertFrom.source);
+  }
+  for (const col of upsertFrom.conflictColumns) {
+    ctx.validator?.validateColumn(upsertFrom.table, col);
+  }
   ctx.currentFromTable = upsertFrom.source;
   return {
     type: "upsert_from",
@@ -1666,7 +1717,7 @@ function compileSelectExpression(item, ctx, fns) {
   if (expr.type === "subquery") {
     return {
       kind: "subquery",
-      query: fns.compileQuery(expr.query, ctx),
+      query: compileNestedQuery(expr.query, ctx, fns),
       ...exprItem.alias !== void 0 && { as: exprItem.alias }
     };
   }
@@ -1945,7 +1996,8 @@ var NqlCompiler = class {
       recursiveKeywords,
       validator,
       params: options?.params ?? {},
-      maxAnyItems: maxAnyItemsRaw ?? MAX_ANY_ITEMS
+      maxAnyItems: maxAnyItemsRaw ?? MAX_ANY_ITEMS,
+      allowUnfilteredMutations: options?.allowUnfilteredMutations ?? false
     };
     this.fns = {
       compileQuery: (query, ctx) => compileQuery(query, ctx, this.fns),
@@ -1963,15 +2015,27 @@ var NqlCompiler = class {
     if (program.statements.length === 1) {
       return this.compileSingleStatement(program.statements[0]);
     }
+    for (let i = 0; i < program.statements.length - 1; i++) {
+      const stmt = program.statements[i];
+      const bindName = extractBindName(stmt);
+      if (!bindName) {
+        throw new Error(
+          `Multiple statements require explicit binding: statement ${i + 1} of ${program.statements.length} has no '| bind <name>' clause. Add a \`| bind <name>\` clause to each statement except the last, or pass a single statement.`
+        );
+      }
+    }
     const bindings = /* @__PURE__ */ new Map();
     const mutationBindings = /* @__PURE__ */ new Map();
+    const materializedBindStatements = /* @__PURE__ */ new Set();
     let lastResult = {};
-    for (const stmt of program.statements) {
+    for (let i = 0; i < program.statements.length; i++) {
+      const stmt = program.statements[i];
       lastResult = this.compileSingleStatement(stmt, bindings);
       const bindName = extractBindName(stmt);
       if (bindName) {
         if (lastResult.query) {
           bindings.set(bindName, lastResult.query);
+          materializedBindStatements.add(i);
         } else if (lastResult.mutation?.returning?.length) {
           mutationBindings.set(bindName, lastResult.mutation);
           bindings.set(bindName, {
@@ -1982,9 +2046,18 @@ var NqlCompiler = class {
               fields: [...lastResult.mutation.returning]
             }
           });
+          materializedBindStatements.add(i);
         }
       }
     }
+    for (let i = 0; i < program.statements.length - 1; i++) {
+      const bindName = extractBindName(program.statements[i]);
+      if (bindName && !materializedBindStatements.has(i)) {
+        throw new Error(
+          `statement ${i + 1} of ${program.statements.length} binds '${bindName}' but produces no referenceable result \u2014 a mutation used as a binding must include a \`returning\` clause.`
+        );
+      }
+    }
     const hasMutationBindings = mutationBindings.size > 0;
     if (bindings.size > 0) {
       return {