kysely 0.11.4 → 0.13.0

package/dist/cjs/operation-node/column-definition-node.js

@@ -15,10 +15,6 @@ exports.ColumnDefinitionNode = (0, object_utils_js_1.freeze)({
             kind: 'ColumnDefinitionNode',
             column: column_node_js_1.ColumnNode.create(column),
             dataType,
-            primaryKey: false,
-            autoIncrement: false,
-            unique: false,
-            nullable: true,
         });
     },
     cloneWith(node, props) {

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

@@ -0,0 +1,15 @@
+import { ColumnNode } from './column-node.js';
+import { OperationNode } from './operation-node.js';
+import { TableNode } from './table-node.js';
+export interface CommonTableExpressionNameNode extends OperationNode {
+    readonly kind: 'CommonTableExpressionNameNode';
+    readonly table: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+}
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNameNode: Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: readonly string[] | undefined): CommonTableExpressionNameNode;
+}>;

package/dist/cjs/operation-node/common-table-expression-name-node.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommonTableExpressionNameNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const column_node_js_1 = require("./column-node.js");
+const table_node_js_1 = require("./table-node.js");
+/**
+ * @internal
+ */
+exports.CommonTableExpressionNameNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNameNode';
+    },
+    create(tableName, columnNames) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CommonTableExpressionNameNode',
+            table: table_node_js_1.TableNode.create(tableName),
+            columns: columnNames
+                ? (0, object_utils_js_1.freeze)(columnNames.map(column_node_js_1.ColumnNode.create))
+                : undefined,
+        });
+    },
+});

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

@@ -1,10 +1,10 @@
-import { IdentifierNode } from './identifier-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { OperationNode } from './operation-node.js';
 import { QueryNode } from './query-node.js';
 import { RawNode } from './raw-node.js';
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
-    readonly name: IdentifierNode;
+    readonly name: CommonTableExpressionNameNode;
     readonly expression: QueryNode | RawNode;
 }
 /**
@@ -12,5 +12,5 @@ export interface CommonTableExpressionNode extends OperationNode {
  */
 export declare const CommonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: IdentifierNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
 }>;

package/dist/cjs/operation-node/create-table-node.d.ts

@@ -2,12 +2,16 @@ import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
+export declare type OnCommitAction = 'preserve rows' | 'delete rows' | 'drop';
+export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints'>;
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnDefinitionNode>;
-    readonly ifNotExists?: boolean;
     readonly constraints?: ReadonlyArray<ConstraintNode>;
+    readonly temporary?: boolean;
+    readonly ifNotExists?: boolean;
+    readonly onCommit?: OnCommitAction;
 }
 /**
  * @internal
@@ -16,6 +20,6 @@ export declare const CreateTableNode: Readonly<{
     is(node: OperationNode): node is CreateTableNode;
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
-    cloneWithIfNotExists(createTable: CreateTableNode, ifNotExists: boolean): CreateTableNode;
     cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
+    cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): CreateTableNode;
 }>;

package/dist/cjs/operation-node/create-table-node.js

@@ -22,12 +22,6 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
             columns: (0, object_utils_js_1.freeze)([...createTable.columns, column]),
         });
     },
-    cloneWithIfNotExists(createTable, ifNotExists) {
-        return (0, object_utils_js_1.freeze)({
-            ...createTable,
-            ifNotExists,
-        });
-    },
     cloneWithConstraint(createTable, constraint) {
         return (0, object_utils_js_1.freeze)({
             ...createTable,
@@ -36,4 +30,10 @@ exports.CreateTableNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)([constraint]),
         });
     },
+    cloneWith(createTable, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...createTable,
+            ...params,
+        });
+    },
 });

package/dist/cjs/operation-node/create-view-node.d.ts

@@ -7,6 +7,7 @@ export declare type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind'
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
     readonly name: IdentifierNode;
+    readonly temporary?: boolean;
     readonly materialized?: boolean;
     readonly orReplace?: boolean;
     readonly ifNotExists?: boolean;

package/dist/cjs/operation-node/insert-query-node.d.ts

@@ -2,18 +2,18 @@ import { ColumnNode } from './column-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
-import { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import { RawNode } from './raw-node.js';
 import { ReturningNode } from './returning-node.js';
+import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
-import { ValueListNode } from './value-list-node.js';
+import { ValuesNode } from './values-node.js';
 import { WithNode } from './with-node.js';
-export declare type InsertValuesNode = ValueListNode | PrimitiveValueListNode;
 export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
-    readonly values?: ReadonlyArray<InsertValuesNode>;
+    readonly values?: ValuesNode | SelectQueryNode | RawNode;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;

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

@@ -44,6 +44,7 @@ import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { WithNode } from './with-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { HavingNode } from './having-node.js';
 import { CreateSchemaNode } from './create-schema-node.js';
 import { DropSchemaNode } from './drop-schema-node.js';
@@ -63,6 +64,7 @@ import { DropViewNode } from './drop-view-node.js';
 import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
+import { ValuesNode } from './values-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -113,6 +115,7 @@ export declare class OperationNodeTransformer {
     protected transformRaw(node: RawNode): RawNode;
     protected transformWhere(node: WhereNode): WhereNode;
     protected transformInsertQuery(node: InsertQueryNode): InsertQueryNode;
+    protected transformValues(node: ValuesNode): ValuesNode;
     protected transformDeleteQuery(node: DeleteQueryNode): DeleteQueryNode;
     protected transformReturning(node: ReturningNode): ReturningNode;
     protected transformCreateTable(node: CreateTableNode): CreateTableNode;
@@ -140,6 +143,7 @@ export declare class OperationNodeTransformer {
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;
     protected transformCommonTableExpression(node: CommonTableExpressionNode): CommonTableExpressionNode;
+    protected transformCommonTableExpressionName(node: CommonTableExpressionNameNode): CommonTableExpressionNameNode;
     protected transformHaving(node: HavingNode): HavingNode;
     protected transformCreateSchema(node: CreateSchemaNode): CreateSchemaNode;
     protected transformDropSchema(node: DropSchemaNode): DropSchemaNode;

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

@@ -81,6 +81,7 @@ class OperationNodeTransformer {
         CheckConstraintNode: this.transformCheckConstraint.bind(this),
         WithNode: this.transformWith.bind(this),
         CommonTableExpressionNode: this.transformCommonTableExpression.bind(this),
+        CommonTableExpressionNameNode: this.transformCommonTableExpressionName.bind(this),
         HavingNode: this.transformHaving.bind(this),
         CreateSchemaNode: this.transformCreateSchema.bind(this),
         DropSchemaNode: this.transformDropSchema.bind(this),
@@ -98,6 +99,7 @@ class OperationNodeTransformer {
         GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
         DefaultValueNode: this.transformDefaultValue.bind(this),
         OnNode: this.transformOn.bind(this),
+        ValuesNode: this.transformValues.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -232,7 +234,7 @@ class OperationNodeTransformer {
             kind: 'InsertQueryNode',
             into: this.transformNode(node.into),
             columns: this.transformNodeList(node.columns),
-            values: this.transformNodeList(node.values),
+            values: this.transformNode(node.values),
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
@@ -240,6 +242,12 @@ class OperationNodeTransformer {
             ignore: node.ignore,
         };
     }
+    transformValues(node) {
+        return {
+            kind: 'ValuesNode',
+            values: this.transformNodeList(node.values),
+        };
+    }
     transformDeleteQuery(node) {
         return {
             kind: 'DeleteQueryNode',
@@ -262,7 +270,9 @@ class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             constraints: this.transformNodeList(node.constraints),
+            temporary: node.temporary,
             ifNotExists: node.ifNotExists,
+            onCommit: node.onCommit,
         };
     }
     transformColumnDefinition(node) {
@@ -274,7 +284,8 @@ class OperationNodeTransformer {
             primaryKey: node.primaryKey,
             autoIncrement: node.autoIncrement,
             unique: node.unique,
-            nullable: node.nullable,
+            notNull: node.notNull,
+            unsigned: node.unsigned,
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
             generatedAlwaysAs: this.transformNode(node.generatedAlwaysAs),
@@ -438,6 +449,7 @@ class OperationNodeTransformer {
         return {
             kind: 'WithNode',
             expressions: this.transformNodeList(node.expressions),
+            recursive: node.recursive,
         };
     }
     transformCommonTableExpression(node) {
@@ -447,6 +459,13 @@ class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
         };
     }
+    transformCommonTableExpressionName(node) {
+        return {
+            kind: 'CommonTableExpressionNameNode',
+            table: this.transformNode(node.table),
+            columns: this.transformNodeList(node.columns),
+        };
+    }
     transformHaving(node) {
         return {
             kind: 'HavingNode',
@@ -528,6 +547,7 @@ class OperationNodeTransformer {
         return {
             kind: 'CreateViewNode',
             name: this.transformNode(node.name),
+            temporary: node.temporary,
             orReplace: node.orReplace,
             ifNotExists: node.ifNotExists,
             materialized: node.materialized,

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

@@ -44,6 +44,7 @@ import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { WithNode } from './with-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { HavingNode } from './having-node.js';
 import { CreateSchemaNode } from './create-schema-node.js';
 import { DropSchemaNode } from './drop-schema-node.js';
@@ -63,6 +64,7 @@ import { DropViewNode } from './drop-view-node.js';
 import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
+import { ValuesNode } from './values-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -109,6 +111,7 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitCheckConstraint(node: CheckConstraintNode): void;
     protected abstract visitWith(node: WithNode): void;
     protected abstract visitCommonTableExpression(node: CommonTableExpressionNode): void;
+    protected abstract visitCommonTableExpressionName(node: CommonTableExpressionNameNode): void;
     protected abstract visitHaving(node: HavingNode): void;
     protected abstract visitCreateSchema(node: CreateSchemaNode): void;
     protected abstract visitDropSchema(node: DropSchemaNode): void;
@@ -132,4 +135,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitGeneratedAlwaysAs(node: GeneratedAlwaysAsNode): void;
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
     protected abstract visitOn(node: OnNode): void;
+    protected abstract visitValues(node: ValuesNode): void;
 }

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

@@ -55,6 +55,7 @@ class OperationNodeVisitor {
         CheckConstraintNode: this.visitCheckConstraint.bind(this),
         WithNode: this.visitWith.bind(this),
         CommonTableExpressionNode: this.visitCommonTableExpression.bind(this),
+        CommonTableExpressionNameNode: this.visitCommonTableExpressionName.bind(this),
         HavingNode: this.visitHaving.bind(this),
         CreateSchemaNode: this.visitCreateSchema.bind(this),
         DropSchemaNode: this.visitDropSchema.bind(this),
@@ -72,6 +73,7 @@ class OperationNodeVisitor {
         GeneratedAlwaysAsNode: this.visitGeneratedAlwaysAs.bind(this),
         DefaultValueNode: this.visitDefaultValue.bind(this),
         OnNode: this.visitOn.bind(this),
+        ValuesNode: this.visitValues.bind(this),
     });
     visitNode = (node) => {
         this.nodeStack.push(node);

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

@@ -1,4 +1,4 @@
-export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode';
+export declare type OperationNodeKind = 'IdentifierNode' | 'RawNode' | 'SelectQueryNode' | 'SelectionNode' | 'ReferenceNode' | 'ColumnNode' | 'TableNode' | 'AliasNode' | 'FromNode' | 'SelectAllNode' | 'FilterNode' | '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' | 'UnionNode' | 'CreateViewNode' | 'DropViewNode' | 'GeneratedAlwaysAsNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

package/dist/cjs/operation-node/query-node.d.ts

@@ -14,8 +14,6 @@ export declare type FilterableQueryNode = SelectQueryNode | DeleteQueryNode | Up
  */
 export declare const QueryNode: Readonly<{
     is(node: OperationNode): node is QueryNode;
-    isMutating(node: OperationNode): node is MutatingQueryNode;
-    isFilterable(node: OperationNode): node is FilterableQueryNode;
     cloneWithWhere<T extends FilterableQueryNode>(node: T, filter: FilterExpressionNode): T;
     cloneWithOrWhere<T_1 extends FilterableQueryNode>(node: T_1, filter: FilterExpressionNode): T_1;
     cloneWithJoin<T_2 extends FilterableQueryNode>(node: T_2, join: JoinNode): T_2;

package/dist/cjs/operation-node/query-node.js

@@ -18,16 +18,6 @@ exports.QueryNode = (0, object_utils_js_1.freeze)({
             update_query_node_js_1.UpdateQueryNode.is(node) ||
             select_query_node_js_1.SelectQueryNode.is(node));
     },
-    isMutating(node) {
-        return (delete_query_node_js_1.DeleteQueryNode.is(node) ||
-            insert_query_node_js_1.InsertQueryNode.is(node) ||
-            update_query_node_js_1.UpdateQueryNode.is(node));
-    },
-    isFilterable(node) {
-        return (select_query_node_js_1.SelectQueryNode.is(node) ||
-            delete_query_node_js_1.DeleteQueryNode.is(node) ||
-            update_query_node_js_1.UpdateQueryNode.is(node));
-    },
     cloneWithWhere(node, filter) {
         return (0, object_utils_js_1.freeze)({
             ...node,

package/dist/cjs/operation-node/values-node.d.ts

@@ -0,0 +1,15 @@
+import { OperationNode } from './operation-node.js';
+import { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type ValuesItemNode = ValueListNode | PrimitiveValueListNode;
+export interface ValuesNode extends OperationNode {
+    readonly kind: 'ValuesNode';
+    readonly values: ReadonlyArray<ValuesItemNode>;
+}
+/**
+ * @internal
+ */
+export declare const ValuesNode: Readonly<{
+    is(node: OperationNode): node is ValuesNode;
+    create(values: ReadonlyArray<ValuesItemNode>): ValuesNode;
+}>;

package/dist/cjs/operation-node/values-node.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValuesNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+/**
+ * @internal
+ */
+exports.ValuesNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'ValuesNode';
+    },
+    create(values) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'ValuesNode',
+            values: (0, object_utils_js_1.freeze)(values),
+        });
+    },
+});

package/dist/cjs/operation-node/with-node.d.ts

@@ -1,14 +1,16 @@
 import { OperationNode } from './operation-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+export declare type WithNodeParams = Omit<WithNode, 'kind' | 'expressions'>;
 export interface WithNode extends OperationNode {
     readonly kind: 'WithNode';
     readonly expressions: ReadonlyArray<CommonTableExpressionNode>;
+    readonly recursive?: boolean;
 }
 /**
  * @internal
  */
 export declare const WithNode: Readonly<{
     is(node: OperationNode): node is WithNode;
-    create(expression: CommonTableExpressionNode): WithNode;
+    create(expression: CommonTableExpressionNode, params?: WithNodeParams | undefined): WithNode;
     cloneWithExpression(withNode: WithNode, expression: CommonTableExpressionNode): WithNode;
 }>;

package/dist/cjs/operation-node/with-node.js

@@ -9,10 +9,11 @@ exports.WithNode = (0, object_utils_js_1.freeze)({
     is(node) {
         return node.kind === 'WithNode';
     },
-    create(expression) {
+    create(expression, params) {
         return (0, object_utils_js_1.freeze)({
             kind: 'WithNode',
             expressions: (0, object_utils_js_1.freeze)([expression]),
+            ...params,
         });
     },
     cloneWithExpression(withNode, expression) {

package/dist/cjs/package.json

@@ -1,3 +1 @@
-{
-    "type": "commonjs"
-}
+{"type":"commonjs"}

package/dist/cjs/parser/complex-expression-parser.d.ts

@@ -0,0 +1,9 @@
+import { AliasNode } from '../operation-node/alias-node.js';
+import { RawNode } from '../operation-node/raw-node.js';
+import { SelectQueryNode } from '../operation-node/select-query-node.js';
+import { AliasedQueryBuilderFactory, AliasedRawBuilderFactory, AnyAliasedQueryBuilder, AnyAliasedRawBuilder, AnySelectQueryBuilder, AnyRawBuilder, SelectQueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
+import { ParseContext } from './parse-context.js';
+export declare type ComplexExpression<DB, TB extends keyof DB> = AnySelectQueryBuilder | SelectQueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+export declare type AliasedComplexExpression<DB, TB extends keyof DB> = AnyAliasedQueryBuilder | AliasedQueryBuilderFactory<DB, TB> | AnyAliasedRawBuilder | AliasedRawBuilderFactory<DB, TB>;
+export declare function parseComplexExpression(ctx: ParseContext, exp: ComplexExpression<any, any>): SelectQueryNode | RawNode;
+export declare function parseAliasedComplexExpression(ctx: ParseContext, exp: AliasedComplexExpression<any, any>): AliasNode;

package/dist/cjs/parser/complex-expression-parser.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAliasedComplexExpression = exports.parseComplexExpression = void 0;
+const operation_node_source_js_1 = require("../operation-node/operation-node-source.js");
+const object_utils_js_1 = require("../util/object-utils.js");
+function parseComplexExpression(ctx, exp) {
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
+        return exp.toOperationNode();
+    }
+    else if ((0, object_utils_js_1.isFunction)(exp)) {
+        return exp(ctx.createExpressionBuilder()).toOperationNode();
+    }
+    throw new Error(`invalid expression: ${JSON.stringify(exp)}`);
+}
+exports.parseComplexExpression = parseComplexExpression;
+function parseAliasedComplexExpression(ctx, exp) {
+    if ((0, operation_node_source_js_1.isOperationNodeSource)(exp)) {
+        return exp.toOperationNode();
+    }
+    else if ((0, object_utils_js_1.isFunction)(exp)) {
+        return exp(ctx.createExpressionBuilder()).toOperationNode();
+    }
+    throw new Error(`invalid aliased expression: ${JSON.stringify(exp)}`);
+}
+exports.parseAliasedComplexExpression = parseAliasedComplexExpression;

package/dist/cjs/parser/filter-parser.d.ts

@@ -1,15 +1,24 @@
 import { FilterNode } from '../operation-node/filter-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
+import { AnyRawBuilder } from '../util/type-utils.js';
 import { Operator } from '../operation-node/operator-node.js';
-import { ReferenceExpression } from './reference-parser.js';
+import { ExtractTypeFromReferenceExpression, ReferenceExpression } from './reference-parser.js';
+import { ValueExpression, ValueExpressionOrList } from './value-parser.js';
 import { FilterExpressionNode } from '../operation-node/operation-node-utils.js';
 import { ParseContext } from './parse-context.js';
-export declare type ExistsExpression<DB, TB extends keyof DB> = AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB>;
+import { WhereInterface } from '../query-builder/where-interface.js';
+import { HavingInterface } from '../query-builder/having-interface.js';
+export declare type FilterValueExpression<DB, TB extends keyof DB, RE> = ValueExpression<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type FilterValueExpressionOrList<DB, TB extends keyof DB, RE> = ValueExpressionOrList<DB, TB, ExtractTypeFromReferenceExpression<DB, TB, RE>>;
+export declare type ExistsExpression<DB, TB extends keyof DB> = ValueExpression<DB, TB, never>;
+export declare type WhereGrouper<DB, TB extends keyof DB> = (qb: WhereInterface<DB, TB>) => WhereInterface<DB, TB>;
+export declare type HavingGrouper<DB, TB extends keyof DB> = (qb: HavingInterface<DB, TB>) => HavingInterface<DB, TB>;
 export declare type FilterOperator = Operator | AnyRawBuilder;
+declare type FilterType = 'where' | 'having' | 'on';
 export declare function parseWhereFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseHavingFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseOnFilter(ctx: ParseContext, args: any[]): FilterExpressionNode;
 export declare function parseReferenceFilter(ctx: ParseContext, lhs: ReferenceExpression<any, any>, op: FilterOperator, rhs: ReferenceExpression<any, any>): FilterNode;
 export declare function parseExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
 export declare function parseNotExistFilter(ctx: ParseContext, arg: ExistsExpression<any, any>): FilterNode;
-export declare function parseFilter(ctx: ParseContext, type: 'where' | 'having' | 'on', args: any[]): FilterExpressionNode;
+export declare function parseFilter(ctx: ParseContext, type: FilterType, args: any[]): FilterExpressionNode;
+export {};

package/dist/cjs/parser/filter-parser.js

@@ -9,7 +9,6 @@ const operator_node_js_1 = require("../operation-node/operator-node.js");
 const parens_node_js_1 = require("../operation-node/parens-node.js");
 const reference_parser_js_1 = require("./reference-parser.js");
 const value_parser_js_1 = require("./value-parser.js");
-const select_query_node_js_1 = require("../operation-node/select-query-node.js");
 const value_node_js_1 = require("../operation-node/value-node.js");
 function parseWhereFilter(ctx, args) {
     return parseFilter(ctx, 'where', args);
@@ -40,18 +39,9 @@ function parseFilter(ctx, type, args) {
         return parseThreeArgFilter(ctx, args[0], args[1], args[2]);
     }
     else if (args.length === 1) {
-        const arg = args[0];
-        if ((0, object_utils_js_1.isFunction)(arg)) {
-            return GROUP_PARSERS[type](ctx, arg);
-        }
-        else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
-            const node = arg.toOperationNode();
-            if (raw_node_js_1.RawNode.is(node)) {
-                return node;
-            }
-        }
+        return parseOneArgFilter(ctx, type, args[0]);
     }
-    throw new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
+    throw createFilterError(type, args);
 }
 exports.parseFilter = parseFilter;
 function parseThreeArgFilter(ctx, left, op, right) {
@@ -64,10 +54,8 @@ function parseIsFilter(ctx, left, op, right) {
     return filter_node_js_1.FilterNode.create((0, reference_parser_js_1.parseReferenceExpression)(ctx, left), parseFilterOperator(op), value_node_js_1.ValueNode.createImmediate(right));
 }
 function parseFilterOperator(op) {
-    if ((0, object_utils_js_1.isString)(op)) {
-        if (operator_node_js_1.OPERATORS.includes(op)) {
-            return operator_node_js_1.OperatorNode.create(op);
-        }
+    if ((0, object_utils_js_1.isString)(op) && operator_node_js_1.OPERATORS.includes(op)) {
+        return operator_node_js_1.OperatorNode.create(op);
     }
     else if ((0, operation_node_source_js_1.isOperationNodeSource)(op)) {
         return op.toOperationNode();
@@ -75,17 +63,26 @@ function parseFilterOperator(op) {
     throw new Error(`invalid comparison operator ${JSON.stringify(op)} passed to a filter method`);
 }
 function parseExistExpression(ctx, type, arg) {
-    const node = (0, object_utils_js_1.isFunction)(arg)
-        ? arg(ctx.createExpressionBuilder()).toOperationNode()
-        : arg.toOperationNode();
-    if (!select_query_node_js_1.SelectQueryNode.is(node) && !raw_node_js_1.RawNode.is(node)) {
-        throw new Error('invalid where exists arg');
+    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), (0, value_parser_js_1.parseValueExpressionOrList)(ctx, arg));
+}
+function parseOneArgFilter(ctx, type, arg) {
+    if ((0, object_utils_js_1.isFunction)(arg)) {
+        return GROUP_PARSERS[type](ctx, arg);
     }
-    return filter_node_js_1.FilterNode.create(undefined, operator_node_js_1.OperatorNode.create(type), node);
+    else if ((0, operation_node_source_js_1.isOperationNodeSource)(arg)) {
+        const node = arg.toOperationNode();
+        if (raw_node_js_1.RawNode.is(node)) {
+            return node;
+        }
+    }
+    throw createFilterError(type, arg);
+}
+function createFilterError(type, args) {
+    return new Error(`invalid arguments passed to a '${type}' method: ${JSON.stringify(args)}`);
 }
 const GROUP_PARSERS = (0, object_utils_js_1.freeze)({
     where(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder([]));
+        const query = callback(ctx.createSelectQueryBuilder());
         const queryNode = query.toOperationNode();
         if (!queryNode.where) {
             throw new Error('no `where` methods called insided a group callback');
@@ -93,7 +90,7 @@ const GROUP_PARSERS = (0, object_utils_js_1.freeze)({
         return parens_node_js_1.ParensNode.create(queryNode.where.where);
     },
     having(ctx, callback) {
-        const query = callback(ctx.createSelectQueryBuilder([]));
+        const query = callback(ctx.createSelectQueryBuilder());
         const queryNode = query.toOperationNode();
         if (!queryNode.having) {
             throw new Error('no `having` methods called insided a group callback');

package/dist/cjs/parser/insert-values-parser.d.ts

@@ -1,16 +1,12 @@
 import { ColumnNode } from '../operation-node/column-node.js';
-import { InsertValuesNode } from '../operation-node/insert-query-node.js';
-import { RawNode } from '../operation-node/raw-node.js';
-import { SelectQueryNode } from '../operation-node/select-query-node.js';
-import { ValueNode } from '../operation-node/value-node.js';
-import { AnyQueryBuilder, AnyRawBuilder, GeneratedPlaceholder, QueryBuilderFactory, RawBuilderFactory } from '../util/type-utils.js';
-import { PrimitiveValue } from '../util/object-utils.js';
+import { GeneratedPlaceholder } from '../util/type-utils.js';
 import { ParseContext } from './parse-context.js';
+import { ValueExpression } from './value-parser.js';
+import { ValuesNode } from '../operation-node/values-node.js';
 export declare type InsertObject<DB, TB extends keyof DB> = {
     [C in keyof DB[TB]]: InsertValueExpression<DB, TB, DB[TB][C]>;
 };
 export declare type InsertObjectOrList<DB, TB extends keyof DB> = InsertObject<DB, TB> | ReadonlyArray<InsertObject<DB, TB>>;
-declare type InsertValueExpression<DB, TB extends keyof DB, T> = T | AnyQueryBuilder | QueryBuilderFactory<DB, TB> | AnyRawBuilder | RawBuilderFactory<DB, TB> | GeneratedPlaceholder;
-export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ReadonlyArray<InsertValuesNode>];
-export declare function parseInsertValueExpression(ctx: ParseContext, value: InsertValueExpression<any, any, PrimitiveValue>): ValueNode | RawNode | SelectQueryNode;
+declare type InsertValueExpression<DB, TB extends keyof DB, T> = ValueExpression<DB, TB, T> | GeneratedPlaceholder;
+export declare function parseInsertObjectOrList(ctx: ParseContext, args: InsertObjectOrList<any, any>): [ReadonlyArray<ColumnNode>, ValuesNode];
 export {};