@leuduan/block 3.0.0 → 3.1.0

package/README.md

@@ -12,7 +12,10 @@ renderer (`l`, 120 columns by default) and the builders on top of it: `p` (pipes
 helpers), `q` (queries), `t` (table expressions) and the `sql` tag, with `from` exported at the root. Every function
 has one name and one home; the namespaces export factories, not the concrete classes behind them. A pipe is applied
 one way: `pipe(query, p.where(...), ...)`. Pipe syntax is GoogleSQL's, so the result is a `GoogleSqlQuery`; applying
-pipes to one extends its own pipe list instead of nesting (reusable steps are a `Pipe[]` to spread into the call).
+pipes to one extends its own pipe list instead of nesting. A step can also be a function from the query built so far
+to the next query, for what `|>` cannot express (the input on the right of a join, inside a subquery, or rewritten);
+later steps apply to what it returns. Reusable steps are a `Pipe[]` to spread into the call, or such a function, with
+any inputs taken as arguments of the function that makes them.
 Deliberate nesting is `q.googleQuery({ queryExpression, pipes })`. Pipes that take a list take an array. String
 literals (`e.literalString`, the typed date and time literals) and quoted identifiers (`e.ident`, `t.path(id, true)`)
 are escaped with GoogleSQL's backslash escapes.

package/dist/index.d.ts

@@ -6,7 +6,7 @@ export * as q from './query.js';
 export * as t from './t.js';
 export type { Line, LineOrStr, Options } from './line.js';
 export { DEFAULT_OPTIONS } from './line.js';
-export type { SqlSegment, Pipe, TableExpression, GoogleSqlQuery } from './sql.js';
+export type { SqlSegment, Pipe, PipeStep, TableExpression, GoogleSqlQuery } from './sql.js';
 export { QueryExpression, from, pipe, sql } from './sql.js';
 export { define } from './define.js';
 export { Dataset, PARAM_TYPES } from './descriptor.js';

package/dist/sql.d.ts

@@ -53,12 +53,15 @@ export declare class GoogleSqlQuery extends QueryExpression {
     constructor({ ctes, queryExpression, orderByLine, limitOffset, pipes }: GoogleSqlQueryProps);
     toLine(): Line;
 }
+/** A step of `pipe`: a `|>` operator, or a function from the query built so far to the next query. */
+export type PipeStep = Pipe | ((query: QueryExpression) => QueryExpression);
 /**
- * Apply `|>` steps to a query. Pipe syntax is GoogleSQL's, so the result is a GoogleSqlQuery. A GoogleSqlQuery takes
- * the steps on its own pipe list (only its outer wrapper is flattened); anything else is wrapped. The input is not
- * changed.
+ * Apply steps to a query, left to right. `|>` operators are GoogleSQL's pipe syntax, so a call of only those returns a
+ * GoogleSqlQuery; a function step gets the query built so far and its result is what later steps apply to. The input
+ * is not changed.
  */
 export declare function pipe(query: QueryExpression, ...steps: Pipe[]): GoogleSqlQuery;
+export declare function pipe(query: QueryExpression, ...steps: PipeStep[]): QueryExpression;
 type SqlInterp = string | number | Line | SqlSegment;
 /**
  * Tagged template for raw SQL fragments.

package/dist/sql.js

@@ -119,22 +119,32 @@ export class GoogleSqlQuery extends QueryExpression {
         ]);
     }
 }
-/**
- * Apply `|>` steps to a query. Pipe syntax is GoogleSQL's, so the result is a GoogleSqlQuery. A GoogleSqlQuery takes
- * the steps on its own pipe list (only its outer wrapper is flattened); anything else is wrapped. The input is not
- * changed.
- */
-export function pipe(query, ...steps) {
+/** A GoogleSqlQuery takes the pipes on its own pipe list (only its outer wrapper is flattened); anything else is wrapped. */
+function appendPipes(query, pipes) {
     if (query instanceof GoogleSqlQuery) {
         return new GoogleSqlQuery({
             ctes: query.ctes,
             queryExpression: query.queryExpression,
             orderByLine: query.orderByLine,
             limitOffset: query.limitOffset,
-            pipes: [...query.pipes, ...steps],
+            pipes: [...query.pipes, ...pipes],
         });
     }
-    return new GoogleSqlQuery({ queryExpression: query, pipes: steps });
+    return new GoogleSqlQuery({ queryExpression: query, pipes });
+}
+export function pipe(query, ...steps) {
+    let result = query;
+    let pending = [];
+    for (const step of steps) {
+        if (step instanceof Pipe) {
+            pending.push(step);
+            continue;
+        }
+        result = step(pending.length > 0 ? appendPipes(result, pending) : result);
+        pending = [];
+    }
+    const endsWithFunction = steps.length > 0 && !(steps[steps.length - 1] instanceof Pipe);
+    return endsWithFunction ? result : appendPipes(result, pending);
 }
 /**
  * Tagged template for raw SQL fragments.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leuduan/block",
-  "version": "3.0.0",
+  "version": "3.1.0",
   "description": "SQL builder and renderer for GoogleSQL",
   "license": "ISC",
   "author": "Duan Leu",