@uwdata/mosaic-sql 0.12.2 → 0.13.0

package/README.md

@@ -2,6 +2,6 @@
 
 [![npm version](https://img.shields.io/npm/v/@uwdata/mosaic-sql.svg)](https://www.npmjs.com/package/@uwdata/mosaic-sql)
 
-An API for convenient construction and analysis of SQL queries. Query objects then coerce to SQL query strings.
+An API for convenient construction and analysis of SQL queries. Constructed `Query` objects coerce to SQL query strings.
 
 Many `mosaic-sql` utilities are included as part of the [vgplot](https://github.com/uwdata/mosaic/tree/main/packages/vgplot) API.

package/dist/types/ast/query.d.ts

@@ -17,6 +17,12 @@ export function isSelectQuery(value: any): value is SelectQuery;
  */
 export function isDescribeQuery(value: any): value is DescribeQuery;
 export class Query extends ExprNode {
+    /**
+     * Create a new WITH clause with the given CTE queries.
+     * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
+     * @returns {WithClause}
+     */
+    static with(...expr: import("../types.js").WithExpr[]): WithClause;
     /**
      * Create a new select query with the given SELECT expressions.
      * @param {...import('../types.js').SelectExpr} expr The SELECT expressions.
@@ -29,12 +35,6 @@ export class Query extends ExprNode {
      * @returns {SelectQuery}
      */
     static from(...expr: import("../types.js").FromExpr[]): SelectQuery;
-    /**
-     * Create a new select query with the given WITH CTE queries.
-     * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
-     * @returns {SelectQuery}
-     */
-    static with(...expr: import("../types.js").WithExpr[]): SelectQuery;
     /**
      * Create a new UNION set operation over the given queries.
      * @param {...Query} queries The queries.
@@ -69,6 +69,8 @@ export class Query extends ExprNode {
      * Instantiate a new query.
      */
     constructor(type: any);
+    /** @type {WithClauseNode[]} */
+    _with: WithClauseNode[];
     /** @type {ExprNode[]} */
     _orderby: ExprNode[];
     /** @type {number} */
@@ -87,6 +89,12 @@ export class Query extends ExprNode {
      * @returns {Query}
      */
     clone(): Query;
+    /**
+     * Add WITH common table expressions (CTEs).
+     * @param  {...import('../types.js').WithExpr} expr Expressions to add.
+     * @returns {this}
+     */
+    with(...expr: import("../types.js").WithExpr[]): this;
     /**
      * Add ORDER BY expressions.
      * @param  {...import('../types.js').OrderByExpr} expr Expressions to add.
@@ -111,8 +119,6 @@ export class SelectQuery extends Query {
      * Instantiate a new select query.
      */
     constructor();
-    /** @type {WithClauseNode[]} */
-    _with: WithClauseNode[];
     /** @type {SelectClauseNode[]} */
     _select: SelectClauseNode[];
     /** @type {FromClauseNode[]} */
@@ -134,12 +140,6 @@ export class SelectQuery extends Query {
      * @returns {SelectQuery}
      */
     clone(): SelectQuery;
-    /**
-     * Add WITH common table expressions (CTEs).
-     * @param  {...import('../types.js').WithExpr} expr Expressions to add.
-     * @returns {this}
-     */
-    with(...expr: import("../types.js").WithExpr[]): this;
     /**
      * Add SELECT expressions.
      * @param {...import('../types.js').SelectExpr} expr Expressions to add.
@@ -261,8 +261,53 @@ export class SetOperation extends Query {
 }
 import { ExprNode } from './node.js';
 import { WithClauseNode } from './with.js';
+declare class WithClause {
+    /**
+     * Instantiate a new WITH clause instance.
+     * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
+     */
+    constructor(...expr: import("../types.js").WithExpr[]);
+    _with: import("../types.js").WithExpr[];
+    /**
+     * Create a new select query with the given SELECT expressions.
+     * @param {...import('../types.js').SelectExpr} expr The SELECT expressions.
+     * @returns {SelectQuery}
+     */
+    select(...expr: import("../types.js").SelectExpr[]): SelectQuery;
+    /**
+     * Create a new select query with the given FROM expressions.
+     * @param {...import('../types.js').FromExpr} expr The FROM expressions.
+     * @returns {SelectQuery}
+     */
+    from(...expr: import("../types.js").FromExpr[]): SelectQuery;
+    /**
+     * Create a new UNION set operation over the given queries.
+     * @param {...Query} queries The queries.
+     * @returns {SetOperation}
+     */
+    union(...queries: Query[]): SetOperation;
+    /**
+     * Create a new UNION ALL set operation over the given queries.
+     * @param {...Query} queries The queries.
+     * @returns {SetOperation}
+     */
+    unionAll(...queries: Query[]): SetOperation;
+    /**
+     * Create a new INTERSECT set operation over the given queries.
+     * @param {...Query} queries The queries.
+     * @returns {SetOperation}
+     */
+    intersect(...queries: Query[]): SetOperation;
+    /**
+     * Create a new EXCEPT set operation over the given queries.
+     * @param {...Query} queries The queries.
+     * @returns {SetOperation}
+     */
+    except(...queries: Query[]): SetOperation;
+}
 import { SelectClauseNode } from './select.js';
 import { FromClauseNode } from './from.js';
 import { SampleClauseNode } from './sample.js';
 import { WindowClauseNode } from './window.js';
 import { SQLNode } from './node.js';
+export {};

package/dist/types/ast/with.d.ts

@@ -3,8 +3,12 @@ export class WithClauseNode extends SQLNode {
      * Instantiate a with clause node for a common table expression (CTE).
      * @param {string} name The common table expression (CTE) name.
      * @param {Query} query The common table expression (CTE) query.
+     * @param {boolean | null} [materialized] The common table expression (CTE)
+     *  materialization flag. If `true`, forces materialization of the CTE.
+     *  If `false`, materialization is not performed. Otherwise (for example, if
+     *  `undefined` or `null`), materialization is decided by the database.
      */
-    constructor(name: string, query: Query);
+    constructor(name: string, query: Query, materialized?: boolean | null);
     /**
      * The common table expression (CTE) name.
      * @type {string}
@@ -17,6 +21,12 @@ export class WithClauseNode extends SQLNode {
      * @readonly
      */
     readonly query: Query;
+    /**
+     * The common table expression (CTE) materialization flag.
+     * @type {boolean | null}
+     * @readonly
+     */
+    readonly materialized: boolean | null;
 }
 import { SQLNode } from './node.js';
 import { Query } from './query.js';

package/dist/types/functions/aggregate.d.ts

@@ -65,6 +65,12 @@ export function entropy(expr: import("../types.js").ExprValue): AggregateNode;
  * @returns {AggregateNode} A SQL aggregate function call.
  */
 export function first(expr: import("../types.js").ExprValue): AggregateNode;
+/**
+ * Compute a geomean aggregate.
+ * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @returns {AggregateNode} A SQL aggregate function call.
+ */
+export function geomean(expr: import("../types.js").ExprValue): AggregateNode;
 /**
  * Compute a sample kurtosis aggregate.
  * @param {import('../types.js').ExprValue} expr The expression to aggregate.

package/dist/types/functions/cte.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Create a common table expression (CTE) to include within a WITH clause.
+ * @param {string} name The common table expression (CTE) name.
+ * @param {Query} query The common table expression (CTE) query.
+ * @param {boolean | null} [materialized] The common table expression (CTE)
+ *  materialization flag. If `true`, forces materialization of the CTE.
+ *  If `false`, materialization is not performed. Otherwise (for example, if
+ *  `undefined` or `null`), materialization is decided by the database.
+ * @returns {WithClauseNode}
+ */
+export function cte(name: string, query: Query, materialized?: boolean | null): WithClauseNode;
+import { Query } from '../ast/query.js';
+import { WithClauseNode } from '../ast/with.js';

package/dist/types/index.d.ts

@@ -15,6 +15,7 @@ export { VerbatimNode } from "./ast/verbatim.js";
 export { WithClauseNode } from "./ast/with.js";
 export { cond } from "./functions/case.js";
 export { column } from "./functions/column.js";
+export { cte } from "./functions/cte.js";
 export { literal } from "./functions/literal.js";
 export { sql } from "./functions/sql-template-tag.js";
 export { rewrite } from "./visit/rewrite.js";
@@ -38,7 +39,7 @@ export { DescribeQuery, Query, SelectQuery, SetOperation, isDescribeQuery, isQue
 export { TableRefNode, isTableRef } from "./ast/table-ref.js";
 export { UnaryOpNode, UnaryPosftixOpNode } from "./ast/unary-op.js";
 export { WindowClauseNode, WindowDefNode, WindowFrameNode, WindowFunctionNode, WindowNode } from "./ast/window.js";
-export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, kurtosis, mad, max, median, min, mode, last, product, quantile, regrAvgX, regrAvgY, regrCount, regrIntercept, regrR2, regrSXX, regrSXY, regrSYY, regrSlope, skewness, stddev, stddevPop, stringAgg, sum, variance, varPop } from "./functions/aggregate.js";
+export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, geomean, kurtosis, mad, max, median, min, mode, last, product, quantile, regrAvgX, regrAvgY, regrCount, regrIntercept, regrR2, regrSXX, regrSXY, regrSYY, regrSlope, skewness, stddev, stddevPop, stringAgg, sum, variance, varPop } from "./functions/aggregate.js";
 export { cast, float32, float64, int32 } from "./functions/cast.js";
 export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms, interval } from "./functions/datetime.js";
 export { abs, ceil, exp, floor, greatest, isFinite, isInfinite, isNaN, least, ln, log, round, sign, sqrt, trunc } from "./functions/numeric.js";

package/dist/types/types.d.ts

@@ -2,6 +2,7 @@ import { ColumnRefNode } from './ast/column-ref.js';
 import { ExprNode, SQLNode } from './ast/node.js';
 import { TableRefNode } from './ast/table-ref.js';
 import { Query } from './ast/query.js';
+import { WithClauseNode } from './ast/with.js';
 /**
  * Interface representing a dynamic parameter value.
  */
@@ -51,7 +52,8 @@ export type WindowFunctionName = 'cume_dist' | 'dense_rank' | 'first_value' | 'l
 export type MaybeArray<T> = T | T[];
 export type SelectEntry = string | ColumnRefNode | [string, ExprNode] | Record<string, ExprValue>;
 export type SelectExpr = MaybeArray<SelectEntry>;
-export type WithExpr = MaybeArray<Record<string, Query>>;
+export type WithEntry = WithClauseNode | Record<string, Query>;
+export type WithExpr = MaybeArray<WithEntry>;
 export type FromEntry = string | TableRefNode | SQLNode | [string, SQLNode] | Record<string, string | SQLNode>;
 export type FromExpr = MaybeArray<FromEntry>;
 export type FilterExpr = MaybeArray<string | ExprNode>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uwdata/mosaic-sql",
-  "version": "0.12.2",
+  "version": "0.13.0",
   "description": "SQL query construction and analysis.",
   "keywords": [
     "sql",
@@ -10,22 +10,22 @@
   "license": "BSD-3-Clause",
   "author": "Jeffrey Heer (https://idl.uw.edu)",
   "type": "module",
-  "main": "src/index.js",
-  "module": "src/index.js",
-  "jsdelivr": "dist/mosaic-sql.min.js",
-  "unpkg": "dist/mosaic-sql.min.js",
-  "types": "dist/types/index-types.d.ts",
+  "exports": {
+    "types": "./dist/types/index-types.d.ts",
+    "default": "./src/index.js"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/uwdata/mosaic.git"
   },
   "scripts": {
     "prebuild": "rimraf dist && mkdir dist",
-    "build": "npm run types && node ../../esbuild.js mosaic-sql",
+    "build": "npm run types",
     "types": "tsc",
     "lint": "eslint src test",
-    "test": "vitest run && tsc -p jsconfig.json",
+    "test": "vitest run && npm run tsc",
+    "tsc": "tsc -p jsconfig.json",
     "prepublishOnly": "npm run test && npm run lint && npm run build"
   },
-  "gitHead": "0ca741d840b98039255f26a5ceedf10be66f790e"
+  "gitHead": "b5a0e03e200c0f04c46562a288f084ffc9f6ad55"
 }

package/src/ast/literal.js

@@ -30,7 +30,7 @@ export function literalToSQL(value) {
     case 'number':
       return Number.isFinite(value) ? `${value}` : 'NULL';
     case 'string':
-      return `'${value.replace(`'`, `''`)}'`;
+      return `'${value.replaceAll(`'`, `''`)}'`;
     case 'boolean':
       return value ? 'TRUE' : 'FALSE';
     default:

package/src/ast/query.js

@@ -40,6 +40,15 @@ export function isDescribeQuery(value) {
 }
 
 export class Query extends ExprNode {
+  /**
+   * Create a new WITH clause with the given CTE queries.
+   * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
+   * @returns {WithClause}
+   */
+  static with(...expr) {
+    return new WithClause(...expr);
+  }
+
   /**
    * Create a new select query with the given SELECT expressions.
    * @param {...import('../types.js').SelectExpr} expr The SELECT expressions.
@@ -58,15 +67,6 @@ export class Query extends ExprNode {
     return new SelectQuery().from(...expr);
   }
 
-  /**
-   * Create a new select query with the given WITH CTE queries.
-   * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
-   * @returns {SelectQuery}
-   */
-  static with(...expr) {
-    return new SelectQuery().with(...expr);
-  }
-
   /**
    * Create a new UNION set operation over the given queries.
    * @param {...Query} queries The queries.
@@ -117,6 +117,8 @@ export class Query extends ExprNode {
    */
   constructor(type) {
     super(type);
+    /** @type {WithClauseNode[]} */
+    this._with = [];
     /** @type {ExprNode[]} */
     this._orderby = [];
     /** @type {number} */
@@ -143,6 +145,27 @@ export class Query extends ExprNode {
     return this;
   }
 
+  /**
+   * Add WITH common table expressions (CTEs).
+   * @param  {...import('../types.js').WithExpr} expr Expressions to add.
+   * @returns {this}
+   */
+  with(...expr) {
+    /** @type {WithClauseNode[]} */
+    const list = [];
+    const add = (name, q) => {
+      const query = q.clone();
+      query.cteFor = this;
+      list.push(new WithClauseNode(name, query));
+    };
+    expr.flat().forEach(e => {
+      if (e instanceof WithClauseNode) list.push(e);
+      else if (e != null) for (const name in e) add(name, e[name]);
+    });
+    this._with = this._with.concat(list);
+    return this;
+  }
+
   /**
    * Add ORDER BY expressions.
    * @param  {...import('../types.js').OrderByExpr} expr Expressions to add.
@@ -180,8 +203,6 @@ export class SelectQuery extends Query {
    */
   constructor() {
     super(SELECT_QUERY);
-    /** @type {WithClauseNode[]} */
-    this._with = [];
     /** @type {SelectClauseNode[]} */
     this._select = [];
     /** @type {FromClauseNode[]} */
@@ -232,26 +253,6 @@ export class SelectQuery extends Query {
     return Object.assign(new SelectQuery(), this);
   }
 
-  /**
-   * Add WITH common table expressions (CTEs).
-   * @param  {...import('../types.js').WithExpr} expr Expressions to add.
-   * @returns {this}
-   */
-  with(...expr) {
-    /** @type {WithClauseNode[]} */
-    const list = [];
-    const add = (name, q) => {
-      const query = q.clone();
-      query.cteFor = this;
-      list.push(new WithClauseNode(name, query));
-    };
-    expr.flat().forEach(e => {
-      if (e != null) for (const name in e) add(name, e[name]);
-    });
-    this._with = this._with.concat(list);
-    return this;
-  }
-
   /**
    * Add SELECT expressions.
    * @param {...import('../types.js').SelectExpr} expr Expressions to add.
@@ -559,10 +560,14 @@ export class SetOperation extends Query {
    * @returns {string}
    */
   toString() {
-    const { op, queries, _orderby, _limit, _offset } = this;
+    const { op, queries, _with, _orderby, _limit, _offset } = this;
+    const sql = [];
+
+    // WITH
+    if (_with.length) sql.push(`WITH ${_with.join(', ')}`);
 
     // SUBQUERIES
-    const sql = [ queries.join(` ${op} `) ];
+    sql.push(queries.join(` ${op} `));
 
     // ORDER BY
     if (_orderby.length) sql.push(`ORDER BY ${_orderby.join(', ')}`);
@@ -576,3 +581,67 @@ export class SetOperation extends Query {
     return sql.join(' ');
   }
 }
+
+class WithClause {
+  /**
+   * Instantiate a new WITH clause instance.
+   * @param {...import('../types.js').WithExpr} expr The WITH CTE queries.
+   */
+  constructor(...expr) {
+    this._with = expr;
+  }
+
+  /**
+   * Create a new select query with the given SELECT expressions.
+   * @param {...import('../types.js').SelectExpr} expr The SELECT expressions.
+   * @returns {SelectQuery}
+   */
+  select(...expr) {
+    return Query.select(...expr).with(...this._with);
+  }
+
+  /**
+   * Create a new select query with the given FROM expressions.
+   * @param {...import('../types.js').FromExpr} expr The FROM expressions.
+   * @returns {SelectQuery}
+   */
+  from(...expr) {
+    return Query.from(...expr).with(...this._with);
+  }
+
+  /**
+   * Create a new UNION set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  union(...queries) {
+    return Query.union(...queries).with(...this._with);
+  }
+
+  /**
+   * Create a new UNION ALL set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  unionAll(...queries) {
+    return Query.unionAll(...queries).with(...this._with);
+  }
+
+  /**
+   * Create a new INTERSECT set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  intersect(...queries) {
+    return Query.intersect(...queries).with(...this._with);
+  }
+
+  /**
+   * Create a new EXCEPT set operation over the given queries.
+   * @param {...Query} queries The queries.
+   * @returns {SetOperation}
+   */
+  except(...queries) {
+    return Query.except(...queries).with(...this._with);
+  }
+}

package/src/ast/with.js

@@ -7,8 +7,12 @@ export class WithClauseNode extends SQLNode {
    * Instantiate a with clause node for a common table expression (CTE).
    * @param {string} name The common table expression (CTE) name.
    * @param {Query} query The common table expression (CTE) query.
+   * @param {boolean | null} [materialized] The common table expression (CTE)
+   *  materialization flag. If `true`, forces materialization of the CTE.
+   *  If `false`, materialization is not performed. Otherwise (for example, if
+   *  `undefined` or `null`), materialization is decided by the database.
    */
-  constructor(name, query) {
+  constructor(name, query, materialized = undefined) {
     super(WITH_CLAUSE);
     /**
      * The common table expression (CTE) name.
@@ -22,9 +26,19 @@ export class WithClauseNode extends SQLNode {
      * @readonly
      */
     this.query = query;
+    /**
+     * The common table expression (CTE) materialization flag.
+     * @type {boolean | null}
+     * @readonly
+     */
+    this.materialized = materialized;
   }
 
   toString() {
-    return `"${this.name}" AS (${this.query})`;
+    const flag = this.materialized;
+    const mat = flag === true ? ' MATERIALIZED'
+      : flag === false ? ' NOT MATERIALIZED'
+      : '';
+    return `"${this.name}" AS${mat} (${this.query})`;
   }
 }

package/src/functions/aggregate.js

@@ -98,6 +98,15 @@ export function first(expr) {
   return aggFn('first', expr);
 }
 
+/**
+ * Compute a geomean aggregate.
+ * @param {import('../types.js').ExprValue} expr The expression to aggregate.
+ * @returns {AggregateNode} A SQL aggregate function call.
+ */
+export function geomean(expr) {
+  return aggFn('geomean', expr);
+}
+
 /**
  * Compute a sample kurtosis aggregate.
  * @param {import('../types.js').ExprValue} expr The expression to aggregate.

package/src/functions/cte.js

@@ -0,0 +1,16 @@
+import { Query } from '../ast/query.js';
+import { WithClauseNode } from '../ast/with.js';
+
+/**
+ * Create a common table expression (CTE) to include within a WITH clause.
+ * @param {string} name The common table expression (CTE) name.
+ * @param {Query} query The common table expression (CTE) query.
+ * @param {boolean | null} [materialized] The common table expression (CTE)
+ *  materialization flag. If `true`, forces materialization of the CTE.
+ *  If `false`, materialization is not performed. Otherwise (for example, if
+ *  `undefined` or `null`), materialization is decided by the database.
+ * @returns {WithClauseNode}
+ */
+export function cte(name, query, materialized) {
+  return new WithClauseNode(name, query, materialized);
+}

package/src/index.js

@@ -24,10 +24,11 @@ export { VerbatimNode } from './ast/verbatim.js';
 export { WindowClauseNode, WindowDefNode, WindowFrameNode, WindowFunctionNode, WindowNode } from './ast/window.js';
 export { WithClauseNode } from './ast/with.js';
 
-export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, kurtosis, mad, max, median, min, mode, last, product, quantile, regrAvgX, regrAvgY, regrCount, regrIntercept, regrR2, regrSXX, regrSXY, regrSYY, regrSlope, skewness, stddev, stddevPop, stringAgg, sum, variance, varPop } from './functions/aggregate.js';
+export { argmax, argmin, arrayAgg, avg, corr, count, covariance, covarPop, entropy, first, geomean, kurtosis, mad, max, median, min, mode, last, product, quantile, regrAvgX, regrAvgY, regrCount, regrIntercept, regrR2, regrSXX, regrSXY, regrSYY, regrSlope, skewness, stddev, stddevPop, stringAgg, sum, variance, varPop } from './functions/aggregate.js';
 export { cond } from './functions/case.js';
 export { cast, float32, float64, int32 } from './functions/cast.js';
 export { column } from './functions/column.js';
+export { cte } from './functions/cte.js';
 export { dateBin, dateMonth, dateMonthDay, dateDay, epoch_ms, interval } from './functions/datetime.js';
 export { literal } from './functions/literal.js';
 export { abs, ceil, exp, floor, greatest, isFinite, isInfinite, isNaN, least, ln, log, round, sign, sqrt, trunc } from './functions/numeric.js';

package/src/transforms/m4.js

@@ -1,6 +1,7 @@
-import { Query } from '../ast/query.js';
+import { Query, isQuery } from '../ast/query.js';
 import { argmax, argmin, max, min } from '../functions/aggregate.js';
 import { int32 } from '../functions/cast.js';
+import { cte } from '../functions/cte.js';
 import { floor } from '../functions/numeric.js';
 
 /**
@@ -22,12 +23,20 @@ import { floor } from '../functions/numeric.js';
 export function m4(input, bin, x, y, groups = []) {
   const pixel = int32(floor(bin));
 
+  // Below, we treat input as a CTE when it is a query. In this case,
+  // we also request that the CTE be explicitly materialized.
+  const useCTE = isQuery(input);
+  const from = useCTE ? 'input' : input;
+  const query = useCTE
+    ? Query.with(cte(/** @type {string} */(from), input, true))
+    : Query;
+
   const q = (sel) => Query
-    .from(input)
+    .from(from)
     .select(sel)
     .groupby(pixel, groups);
 
-  return Query
+  return query
     .union(
       q([{ [x]: min(x), [y]: argmin(y, x) }, ...groups]),
       q([{ [x]: max(x), [y]: argmax(y, x) }, ...groups]),

package/src/types.ts

@@ -2,6 +2,7 @@ import { ColumnRefNode } from './ast/column-ref.js';
 import { ExprNode, SQLNode } from './ast/node.js';
 import { TableRefNode } from './ast/table-ref.js';
 import { Query } from './ast/query.js';
+import { WithClauseNode } from './ast/with.js';
 
 /**
  * Interface representing a dynamic parameter value.
@@ -80,7 +81,11 @@ export type SelectEntry =
 
 export type SelectExpr = MaybeArray<SelectEntry>;
 
-export type WithExpr = MaybeArray<Record<string, Query>>;
+export type WithEntry =
+  | WithClauseNode
+  | Record<string, Query>;
+
+export type WithExpr = MaybeArray<WithEntry>;
 
 export type FromEntry =
   | string

package/vitest.config.ts

@@ -0,0 +1,3 @@
+import { defineConfig } from 'vite';
+
+export default defineConfig({});