kysely 0.26.1 → 0.26.2

package/dist/esm/helpers/sqlite.d.ts

@@ -0,0 +1,164 @@
+import { Expression } from '../expression/expression.js';
+import { SelectQueryBuilder } from '../query-builder/select-query-builder.js';
+import { RawBuilder } from '../raw-builder/raw-builder.js';
+import { Simplify } from '../util/type-utils.js';
+/**
+ * A SQLite helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new SqliteDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(json_group_array(json_object(
+ *     'pet_id', "agg"."pet_id",
+ *     'name', "agg"."name"
+ *   )), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as "agg"
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export declare function jsonArrayFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O>[]>;
+/**
+ * A SQLite helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new SqliteDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "id", (
+ *   select json_object(
+ *     'pet_id', "obj"."pet_id",
+ *     'name', "obj"."name"
+ *   ) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = ?
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person";
+ * ```
+ */
+export declare function jsonObjectFrom<O>(expr: SelectQueryBuilder<any, any, O>): RawBuilder<Simplify<O> | null>;
+/**
+ * The SQLite `json_object` function.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new SqliteDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "id", json_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', "first_name" || ' ' || "last_name"
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export declare function jsonBuildObject<O extends Record<string, Expression<unknown>>>(obj: O): RawBuilder<Simplify<{
+    [K in keyof O]: O[K] extends Expression<infer V> ? V : never;
+}>>;

package/dist/esm/helpers/sqlite.js

@@ -0,0 +1,175 @@
+/// <reference types="./sqlite.d.ts" />
+import { sql } from '../raw-builder/sql.js';
+import { getJsonObjectArgs } from '../util/json-object-args.js';
+/**
+ * A SQLite helper for aggregating a subquery into a JSON array.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new SqliteDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonArrayFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .orderBy('pet.name')
+ *     ).as('pets')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].pets[0].pet_id
+ * result[0].pets[0].name
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "id", (
+ *   select coalesce(json_group_array(json_object(
+ *     'pet_id', "agg"."pet_id",
+ *     'name', "agg"."name"
+ *   )), '[]') from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     order by "pet"."name"
+ *   ) as "agg"
+ * ) as "pets"
+ * from "person"
+ * ```
+ */
+export function jsonArrayFrom(expr) {
+    return sql `(select coalesce(json_group_array(json_object(${sql.join(getSqliteJsonObjectArgs(expr.toOperationNode(), 'agg'))})), '[]') from ${expr} as agg)`;
+}
+/**
+ * A SQLite helper for turning a subquery into a JSON object.
+ *
+ * The subquery must only return one row.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new SqliteDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonObjectFrom(
+ *       eb.selectFrom('pet')
+ *         .select(['pet.id as pet_id', 'pet.name'])
+ *         .whereRef('pet.owner_id', '=', 'person.id')
+ *         .where('pet.is_favorite', '=', true)
+ *     ).as('favorite_pet')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].favorite_pet.pet_id
+ * result[0].favorite_pet.name
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "id", (
+ *   select json_object(
+ *     'pet_id', "obj"."pet_id",
+ *     'name', "obj"."name"
+ *   ) from (
+ *     select "pet"."id" as "pet_id", "pet"."name"
+ *     from "pet"
+ *     where "pet"."owner_id" = "person"."id"
+ *     and "pet"."is_favorite" = ?
+ *   ) as obj
+ * ) as "favorite_pet"
+ * from "person";
+ * ```
+ */
+export function jsonObjectFrom(expr) {
+    return sql `(select json_object(${sql.join(getSqliteJsonObjectArgs(expr.toOperationNode(), 'obj'))}) from ${expr} as obj)`;
+}
+/**
+ * The SQLite `json_object` function.
+ *
+ * NOTE: This helper only works correctly if you've installed the `ParseJSONResultsPlugin`.
+ * Otherwise the nested selections will be returned as JSON strings.
+ *
+ * The plugin can be installed like this:
+ *
+ * ```ts
+ * const db = new Kysely({
+ *   dialect: new SqliteDialect(config),
+ *   plugins: [new ParseJSONResultsPlugin()]
+ * })
+ * ```
+ *
+ * ### Examples
+ *
+ * ```ts
+ * const result = await db
+ *   .selectFrom('person')
+ *   .select((eb) => [
+ *     'id',
+ *     jsonBuildObject({
+ *       first: eb.ref('first_name'),
+ *       last: eb.ref('last_name'),
+ *       full: sql<string>`first_name || ' ' || last_name`
+ *     }).as('name')
+ *   ])
+ *   .execute()
+ *
+ * result[0].id
+ * result[0].name.first
+ * result[0].name.last
+ * result[0].name.full
+ * ```
+ *
+ * The generated SQL (SQLite):
+ *
+ * ```sql
+ * select "id", json_object(
+ *   'first', first_name,
+ *   'last', last_name,
+ *   'full', "first_name" || ' ' || "last_name"
+ * ) as "name"
+ * from "person"
+ * ```
+ */
+export function jsonBuildObject(obj) {
+    return sql `json_object(${sql.join(Object.keys(obj).flatMap((k) => [sql.lit(k), obj[k]]))})`;
+}
+function getSqliteJsonObjectArgs(node, table) {
+    try {
+        return getJsonObjectArgs(node, table);
+    }
+    catch {
+        throw new Error('SQLite jsonArrayFrom and jsonObjectFrom functions can only handle explicit selections due to limitations of the json_object function. selectAll() is not allowed in the subquery.');
+    }
+}

package/dist/esm/index.d.ts

@@ -170,6 +170,7 @@ export * from './operation-node/json-reference-node.js';
 export * from './operation-node/json-path-leg-node.js';
 export * from './operation-node/json-path-node.js';
 export * from './operation-node/json-operator-chain-node.js';
+export * from './operation-node/tuple-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';
@@ -186,5 +187,6 @@ export { JoinReferenceExpression, JoinCallbackExpression, } from './parser/join-
 export { InsertObject } from './parser/insert-values-parser.js';
 export { UpdateObject } from './parser/update-set-parser.js';
 export { OrderByExpression, OrderByDirectionExpression, } from './parser/order-by-parser.js';
-export { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, } from './parser/binary-operation-parser.js';
+export { ComparisonOperatorExpression, OperandValueExpression, OperandValueExpressionOrList, FilterObject, } from './parser/binary-operation-parser.js';
 export { ExistsExpression } from './parser/unary-operation-parser.js';
+export { OperandExpression, ExpressionOrFactory, } from './parser/expression-parser.js';

package/dist/esm/index.js

@@ -171,6 +171,7 @@ export * from './operation-node/json-reference-node.js';
 export * from './operation-node/json-path-leg-node.js';
 export * from './operation-node/json-path-node.js';
 export * from './operation-node/json-operator-chain-node.js';
+export * from './operation-node/tuple-node.js';
 export * from './util/column-type.js';
 export * from './util/compilable.js';
 export * from './util/explainable.js';

package/dist/esm/kysely.d.ts

@@ -15,6 +15,7 @@ import { QueryId } from './util/query-id.js';
 import { Compilable } from './util/compilable.js';
 import { CaseBuilder } from './query-builder/case-builder.js';
 import { Expression } from './expression/expression.js';
+import { DrainOuterGeneric } from './util/type-utils.js';
 /**
  * The main Kysely class.
  *
@@ -38,7 +39,7 @@ import { Expression } from './expression/expression.js';
  *   id: Generated<number>
  *   owner_id: number
  *   name: string
- *   species 'cat' | 'dog'
+ *   species: 'cat' | 'dog'
  * }
  *
  * interface Database {
@@ -228,7 +229,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> implements QueryExecuto
      *   .execute()
      * ```
      */
-    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
+    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DrainOuterGeneric<DB & T>>;
     /**
      * Releases all resources and disconnects from the database.
      *
@@ -385,7 +386,7 @@ export declare class Transaction<DB> extends Kysely<DB> {
      *   .execute()
      * ```
      */
-    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
+    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DrainOuterGeneric<DB & T>>;
 }
 export interface KyselyProps {
     readonly config: KyselyConfig;

package/dist/esm/kysely.js

@@ -40,7 +40,7 @@ import { WithSchemaPlugin } from './plugin/with-schema/with-schema-plugin.js';
  *   id: Generated<number>
  *   owner_id: number
  *   name: string
- *   species 'cat' | 'dog'
+ *   species: 'cat' | 'dog'
  * }
  *
  * interface Database {

package/dist/esm/operation-node/common-table-expression-node.d.ts

@@ -1,8 +1,10 @@
 import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { OperationNode } from './operation-node.js';
+type CommonTableExpressionNodeProps = Pick<CommonTableExpressionNode, 'materialized'>;
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
     readonly name: CommonTableExpressionNameNode;
+    readonly materialized?: boolean;
     readonly expression: OperationNode;
 }
 /**
@@ -11,4 +13,6 @@ export interface CommonTableExpressionNode extends OperationNode {
 export declare const CommonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
     create(name: CommonTableExpressionNameNode, expression: OperationNode): CommonTableExpressionNode;
+    cloneWith(node: CommonTableExpressionNode, props: CommonTableExpressionNodeProps): CommonTableExpressionNode;
 }>;
+export {};

package/dist/esm/operation-node/common-table-expression-node.js

@@ -14,4 +14,10 @@ export const CommonTableExpressionNode = freeze({
             expression,
         });
     },
+    cloneWith(node, props) {
+        return freeze({
+            ...node,
+            ...props,
+        });
+    },
 });

package/dist/esm/operation-node/delete-query-node.d.ts

@@ -27,7 +27,7 @@ export interface DeleteQueryNode extends OperationNode {
 export declare const DeleteQueryNode: Readonly<{
     is(node: OperationNode): node is DeleteQueryNode;
     create(fromItems: OperationNode[], withNode?: WithNode): DeleteQueryNode;
-    cloneWithOrderByItem(deleteNode: DeleteQueryNode, item: OrderByItemNode): DeleteQueryNode;
+    cloneWithOrderByItems(deleteNode: DeleteQueryNode, items: ReadonlyArray<OrderByItemNode>): DeleteQueryNode;
     cloneWithLimit(deleteNode: DeleteQueryNode, limit: LimitNode): DeleteQueryNode;
     cloneWithUsing(deleteNode: DeleteQueryNode, tables: OperationNode[]): DeleteQueryNode;
 }>;

package/dist/esm/operation-node/delete-query-node.js

@@ -17,12 +17,12 @@ export const DeleteQueryNode = freeze({
             ...(withNode && { with: withNode }),
         });
     },
-    cloneWithOrderByItem(deleteNode, item) {
+    cloneWithOrderByItems(deleteNode, items) {
         return freeze({
             ...deleteNode,
             orderBy: deleteNode.orderBy
-                ? OrderByNode.cloneWithItem(deleteNode.orderBy, item)
-                : OrderByNode.create(item),
+                ? OrderByNode.cloneWithItems(deleteNode.orderBy, items)
+                : OrderByNode.create(items),
         });
     },
     cloneWithLimit(deleteNode, limit) {

package/dist/esm/operation-node/operation-node-transformer.d.ts

@@ -84,6 +84,7 @@ import { JSONReferenceNode } from './json-reference-node.js';
 import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import { TupleNode } from './tuple-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -197,6 +198,7 @@ export declare class OperationNodeTransformer {
     protected transformJSONPath(node: JSONPathNode): JSONPathNode;
     protected transformJSONPathLeg(node: JSONPathLegNode): JSONPathLegNode;
     protected transformJSONOperatorChain(node: JSONOperatorChainNode): JSONOperatorChainNode;
+    protected transformTuple(node: TupleNode): TupleNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;

package/dist/esm/operation-node/operation-node-transformer.js

@@ -118,6 +118,7 @@ export class OperationNodeTransformer {
         JSONPathNode: this.transformJSONPath.bind(this),
         JSONPathLegNode: this.transformJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.transformJSONOperatorChain.bind(this),
+        TupleNode: this.transformTuple.bind(this),
     });
     transformNode(node) {
         if (!node) {
@@ -489,6 +490,7 @@ export class OperationNodeTransformer {
         return requireAllProps({
             kind: 'CommonTableExpressionNode',
             name: this.transformNode(node.name),
+            materialized: node.materialized,
             expression: this.transformNode(node.expression),
         });
     }
@@ -755,6 +757,12 @@ export class OperationNodeTransformer {
             values: this.transformNodeList(node.values),
         });
     }
+    transformTuple(node) {
+        return requireAllProps({
+            kind: 'TupleNode',
+            values: this.transformNodeList(node.values),
+        });
+    }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.
         return node;

package/dist/esm/operation-node/operation-node-visitor.d.ts

@@ -84,6 +84,7 @@ import { JSONReferenceNode } from './json-reference-node.js';
 import { JSONPathNode } from './json-path-node.js';
 import { JSONPathLegNode } from './json-path-leg-node.js';
 import { JSONOperatorChainNode } from './json-operator-chain-node.js';
+import { TupleNode } from './tuple-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -174,4 +175,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitJSONPath(node: JSONPathNode): void;
     protected abstract visitJSONPathLeg(node: JSONPathLegNode): void;
     protected abstract visitJSONOperatorChain(node: JSONOperatorChainNode): void;
+    protected abstract visitTuple(node: TupleNode): void;
 }

package/dist/esm/operation-node/operation-node-visitor.js

@@ -91,6 +91,7 @@ export class OperationNodeVisitor {
         JSONPathNode: this.visitJSONPath.bind(this),
         JSONPathLegNode: this.visitJSONPathLeg.bind(this),
         JSONOperatorChainNode: this.visitJSONOperatorChain.bind(this),
+        TupleNode: this.visitTuple.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

package/dist/esm/operation-node/operation-node.d.ts

@@ -1,4 +1,4 @@
-export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode';
+export type OperationNodeKind = 'IdentifierNode' | 'SchemableIdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'AndNode' | 'OrNode' | 'ParensNode' | 'ValueNode' | 'ValueListNode' | 'PrimitiveValueListNode' | 'JoinNode' | 'OperatorNode' | 'WhereNode' | 'InsertQueryNode' | 'DeleteQueryNode' | 'ReturningNode' | 'CreateTableNode' | 'ColumnDefinitionNode' | 'AddColumnNode' | 'DropTableNode' | 'DataTypeNode' | 'OrderByNode' | 'OrderByItemNode' | 'GroupByNode' | 'GroupByItemNode' | 'UpdateQueryNode' | 'ColumnUpdateNode' | 'LimitNode' | 'OffsetNode' | 'OnConflictNode' | 'OnDuplicateKeyNode' | 'CreateIndexNode' | 'DropIndexNode' | 'ListNode' | 'ReferencesNode' | 'PrimaryKeyConstraintNode' | 'UniqueConstraintNode' | 'CheckConstraintNode' | 'ForeignKeyConstraintNode' | 'WithNode' | 'CommonTableExpressionNode' | 'HavingNode' | 'CreateSchemaNode' | 'DropSchemaNode' | 'AlterTableNode' | 'ModifyColumnNode' | 'DropColumnNode' | 'RenameColumnNode' | 'AlterColumnNode' | 'AddConstraintNode' | 'DropConstraintNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode' | 'CreateTypeNode' | 'DropTypeNode' | 'ExplainNode' | 'DefaultInsertValueNode' | 'AggregateFunctionNode' | 'OverNode' | 'PartitionByNode' | 'PartitionByItemNode' | 'SetOperationNode' | 'BinaryOperationNode' | 'UnaryOperationNode' | 'UsingNode' | 'FunctionNode' | 'CaseNode' | 'WhenNode' | 'JSONReferenceNode' | 'JSONPathNode' | 'JSONPathLegNode' | 'JSONOperatorChainNode' | 'TupleNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/esm/operation-node/operator-node.d.ts

@@ -1,11 +1,11 @@
 import { OperationNode } from './operation-node.js';
-export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
+export declare const COMPARISON_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp"];
 export declare const ARITHMETIC_OPERATORS: readonly ["+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>"];
 export declare const JSON_OPERATORS: readonly ["->", "->>"];
-export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
+export declare const BINARY_OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||"];
 export declare const UNARY_FILTER_OPERATORS: readonly ["exists", "not exists"];
 export declare const UNARY_OPERATORS: readonly ["not", "-", "exists", "not exists"];
-export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists"];
+export declare const OPERATORS: readonly ["=", "==", "!=", "<>", ">", ">=", "<", "<=", "in", "not in", "is", "is not", "like", "not like", "match", "ilike", "not ilike", "@>", "<@", "&&", "?", "?&", "!<", "!>", "<=>", "!~", "~", "~*", "!~*", "@@", "@@@", "!!", "<->", "regexp", "+", "-", "*", "/", "%", "^", "&", "|", "#", "<<", ">>", "&&", "||", "->", "->>", "not", "-", "exists", "not exists", "between", "between symmetric"];
 export type ComparisonOperator = (typeof COMPARISON_OPERATORS)[number];
 export type ArithmeticOperator = (typeof ARITHMETIC_OPERATORS)[number];
 export type JSONOperator = (typeof JSON_OPERATORS)[number];

package/dist/esm/operation-node/operator-node.js

@@ -20,6 +20,7 @@ export const COMPARISON_OPERATORS = [
     'not ilike',
     '@>',
     '<@',
+    '&&',
     '?',
     '?&',
     '!<',
@@ -61,6 +62,8 @@ export const OPERATORS = [
     ...BINARY_OPERATORS,
     ...JSON_OPERATORS,
     ...UNARY_OPERATORS,
+    'between',
+    'between symmetric',
 ];
 /**
  * @internal

package/dist/esm/operation-node/order-by-node.d.ts

@@ -9,6 +9,6 @@ export interface OrderByNode extends OperationNode {
  */
 export declare const OrderByNode: Readonly<{
     is(node: OperationNode): node is OrderByNode;
-    create(item: OrderByItemNode): OrderByNode;
-    cloneWithItem(orderBy: OrderByNode, item: OrderByItemNode): OrderByNode;
+    create(items: ReadonlyArray<OrderByItemNode>): OrderByNode;
+    cloneWithItems(orderBy: OrderByNode, items: ReadonlyArray<OrderByItemNode>): OrderByNode;
 }>;

package/dist/esm/operation-node/order-by-node.js

@@ -7,16 +7,16 @@ export const OrderByNode = freeze({
     is(node) {
         return node.kind === 'OrderByNode';
     },
-    create(item) {
+    create(items) {
         return freeze({
             kind: 'OrderByNode',
-            items: freeze([item]),
+            items: freeze([...items]),
         });
     },
-    cloneWithItem(orderBy, item) {
+    cloneWithItems(orderBy, items) {
         return freeze({
             ...orderBy,
-            items: freeze([...orderBy.items, item]),
+            items: freeze([...orderBy.items, ...items]),
         });
     },
 });

package/dist/esm/operation-node/over-node.d.ts

@@ -14,6 +14,6 @@ export interface OverNode extends OperationNode {
 export declare const OverNode: Readonly<{
     is(node: OperationNode): node is OverNode;
     create(): OverNode;
-    cloneWithOrderByItem(overNode: OverNode, item: OrderByItemNode): OverNode;
+    cloneWithOrderByItems(overNode: OverNode, items: ReadonlyArray<OrderByItemNode>): OverNode;
     cloneWithPartitionByItems(overNode: OverNode, items: ReadonlyArray<PartitionByItemNode>): OverNode;
 }>;

package/dist/esm/operation-node/over-node.js

@@ -14,12 +14,12 @@ export const OverNode = freeze({
             kind: 'OverNode',
         });
     },
-    cloneWithOrderByItem(overNode, item) {
+    cloneWithOrderByItems(overNode, items) {
         return freeze({
             ...overNode,
             orderBy: overNode.orderBy
-                ? OrderByNode.cloneWithItem(overNode.orderBy, item)
-                : OrderByNode.create(item),
+                ? OrderByNode.cloneWithItems(overNode.orderBy, items)
+                : OrderByNode.create(items),
         });
     },
     cloneWithPartitionByItems(overNode, items) {