kysely 0.19.8 → 0.19.9

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

@@ -65,6 +65,7 @@ import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
+import { SelectModifierNode } from './select-modifier-node.js';
 export declare abstract class OperationNodeVisitor {
     #private;
     protected readonly nodeStack: OperationNode[];
@@ -136,4 +137,5 @@ export declare abstract class OperationNodeVisitor {
     protected abstract visitDefaultValue(node: DefaultValueNode): void;
     protected abstract visitOn(node: OnNode): void;
     protected abstract visitValues(node: ValuesNode): void;
+    protected abstract visitSelectModifier(node: SelectModifierNode): void;
 }

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

@@ -74,6 +74,7 @@ class OperationNodeVisitor {
         DefaultValueNode: this.visitDefaultValue.bind(this),
         OnNode: this.visitOn.bind(this),
         ValuesNode: this.visitValues.bind(this),
+        SelectModifierNode: this.visitSelectModifier.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' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode';
+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' | 'GeneratedNode' | 'DefaultValueNode' | 'OnNode' | 'ValuesNode' | 'CommonTableExpressionNameNode' | 'SelectModifierNode';
 export interface OperationNode {
     readonly kind: OperationNodeKind;
 }

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

@@ -0,0 +1,16 @@
+import { OperationNode } from './operation-node.js';
+import { RawNode } from './raw-node.js';
+export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked' | 'Distinct';
+export interface SelectModifierNode extends OperationNode {
+    readonly kind: 'SelectModifierNode';
+    readonly modifier?: SelectModifier;
+    readonly rawModifier?: RawNode;
+}
+/**
+ * @internal
+ */
+export declare const SelectModifierNode: Readonly<{
+    is(node: OperationNode): node is SelectModifierNode;
+    create(modifier: SelectModifier): SelectModifierNode;
+    createWithRaw(modifier: RawNode): SelectModifierNode;
+}>;

package/dist/cjs/operation-node/select-modifier-node.js

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

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

@@ -13,18 +13,18 @@ import { SelectionNode } from './selection-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
 import { UnionNode } from './union-node.js';
-export declare type SelectModifier = 'ForUpdate' | 'ForNoKeyUpdate' | 'ForShare' | 'ForKeyShare' | 'NoWait' | 'SkipLocked';
+import { SelectModifierNode } from './select-modifier-node.js';
 export interface SelectQueryNode extends OperationNode {
     readonly kind: 'SelectQueryNode';
     readonly from: FromNode;
     readonly selections?: ReadonlyArray<SelectionNode>;
     readonly distinctOnSelections?: ReadonlyArray<SelectionNode>;
-    readonly distinct?: boolean;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly groupBy?: GroupByNode;
     readonly orderBy?: OrderByNode;
     readonly where?: WhereNode;
-    readonly modifiers?: ReadonlyArray<SelectModifier>;
+    readonly frontModifiers?: ReadonlyArray<SelectModifierNode>;
+    readonly endModifiers?: ReadonlyArray<SelectModifierNode>;
     readonly limit?: LimitNode;
     readonly offset?: OffsetNode;
     readonly with?: WithNode;
@@ -39,13 +39,13 @@ export declare const SelectQueryNode: Readonly<{
     create(fromItems: ReadonlyArray<TableExpressionNode>, withNode?: WithNode): SelectQueryNode;
     cloneWithSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
     cloneWithDistinctOnSelections(select: SelectQueryNode, selections: ReadonlyArray<SelectionNode>): SelectQueryNode;
-    cloneWithModifier(select: SelectQueryNode, modifier: SelectModifier): SelectQueryNode;
+    cloneWithFrontModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
+    cloneWithEndModifier(select: SelectQueryNode, modifier: SelectModifierNode): SelectQueryNode;
     cloneWithOrderByItem(selectNode: SelectQueryNode, item: OrderByItemNode): SelectQueryNode;
     cloneWithGroupByItems(selectNode: SelectQueryNode, items: ReadonlyArray<GroupByItemNode>): SelectQueryNode;
     cloneWithLimit(selectNode: SelectQueryNode, limit: LimitNode): SelectQueryNode;
     cloneWithOffset(selectNode: SelectQueryNode, offset: OffsetNode): SelectQueryNode;
     cloneWithHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
     cloneWithOrHaving(selectNode: SelectQueryNode, filter: FilterExpressionNode): SelectQueryNode;
-    cloneWithDistinct(selectNode: SelectQueryNode): SelectQueryNode;
     cloneWithUnion(selectNode: SelectQueryNode, union: UnionNode): SelectQueryNode;
 }>;

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

@@ -36,11 +36,19 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : (0, object_utils_js_1.freeze)(selections),
         });
     },
-    cloneWithModifier(select, modifier) {
+    cloneWithFrontModifier(select, modifier) {
         return (0, object_utils_js_1.freeze)({
             ...select,
-            modifiers: select.modifiers
-                ? (0, object_utils_js_1.freeze)([...select.modifiers, modifier])
+            frontModifiers: select.frontModifiers
+                ? (0, object_utils_js_1.freeze)([...select.frontModifiers, modifier])
+                : (0, object_utils_js_1.freeze)([modifier]),
+        });
+    },
+    cloneWithEndModifier(select, modifier) {
+        return (0, object_utils_js_1.freeze)({
+            ...select,
+            endModifiers: select.endModifiers
+                ? (0, object_utils_js_1.freeze)([...select.endModifiers, modifier])
                 : (0, object_utils_js_1.freeze)([modifier]),
         });
     },
@@ -88,12 +96,6 @@ exports.SelectQueryNode = (0, object_utils_js_1.freeze)({
                 : having_node_js_1.HavingNode.create(filter),
         });
     },
-    cloneWithDistinct(selectNode) {
-        return (0, object_utils_js_1.freeze)({
-            ...selectNode,
-            distinct: true,
-        });
-    },
     cloneWithUnion(selectNode, union) {
         return (0, object_utils_js_1.freeze)({
             ...selectNode,

package/dist/cjs/query-builder/select-query-builder.d.ts

@@ -653,6 +653,50 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     distinctOn<SE extends SelectExpression<DB, TB>>(selections: ReadonlyArray<SE>): SelectQueryBuilder<DB, TB, O>;
     distinctOn<SE extends SelectExpression<DB, TB>>(selection: SE): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .modifyFront(sql`sql_no_cache`)
+     *   .select('first_name')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select sql_no_cache `first_name`
+     * from `person`
+     * ```
+     */
+    modifyFront(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link forUpdate}, {@link forShare}, {@link forKeyShare}, {@link forNoKeyUpdate}
+     * {@link skipLocked} and  {@link noWait}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select('first_name')
+     *   .modifyEnd(sql`for update`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name"
+     * from "person"
+     * for update
+     * ```
+     */
+    modifyEnd(modifier: AnyRawBuilder): SelectQueryBuilder<DB, TB, O>;
     /**
      * Makes the selection distinct.
      *
@@ -673,27 +717,27 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      */
     distinct(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for update` option to a select query on supported databases.
+     * Adds the `for update` modifier to a select query on supported databases.
      */
     forUpdate(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for share` option to a select query on supported databases.
+     * Adds the `for share` modifier to a select query on supported databases.
      */
     forShare(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for key share` option to a select query on supported databases.
+     * Adds the `for key share` modifier to a select query on supported databases.
      */
     forKeyShare(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `for no key update` option to a select query on supported databases.
+     * Adds the `for no key update` modifier to a select query on supported databases.
      */
     forNoKeyUpdate(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `skip locked` option to a select query on supported databases.
+     * Adds the `skip locked` modifier to a select query on supported databases.
      */
     skipLocked(): SelectQueryBuilder<DB, TB, O>;
     /**
-     * Adds the `nowait` option to a select query on supported databases.
+     * Adds the `nowait` modifier to a select query on supported databases.
      */
     noWait(): SelectQueryBuilder<DB, TB, O>;
     /**

package/dist/cjs/query-builder/select-query-builder.js

@@ -16,6 +16,7 @@ const group_by_parser_js_1 = require("../parser/group-by-parser.js");
 const union_parser_js_1 = require("../parser/union-parser.js");
 const no_result_error_js_1 = require("./no-result-error.js");
 const identifier_node_js_1 = require("../operation-node/identifier-node.js");
+const select_modifier_node_js_1 = require("../operation-node/select-modifier-node.js");
 class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -129,6 +130,60 @@ class SelectQueryBuilder {
             queryNode: select_query_node_js_1.SelectQueryNode.cloneWithDistinctOnSelections(this.#props.queryNode, (0, select_parser_js_1.parseSelectExpressionOrList)(selection)),
         });
     }
+    /**
+     * This can be used to add any additional SQL to the front of the query __after__ the `select` keyword.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .modifyFront(sql`sql_no_cache`)
+     *   .select('first_name')
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (MySQL):
+     *
+     * ```sql
+     * select sql_no_cache `first_name`
+     * from `person`
+     * ```
+     */
+    modifyFront(modifier) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.createWithRaw(modifier.toOperationNode())),
+        });
+    }
+    /**
+     * This can be used to add any additional SQL to the end of the query.
+     *
+     * Also see {@link forUpdate}, {@link forShare}, {@link forKeyShare}, {@link forNoKeyUpdate}
+     * {@link skipLocked} and  {@link noWait}.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.selectFrom('person')
+     *   .select('first_name')
+     *   .modifyEnd(sql`for update`)
+     *   .execute()
+     * ```
+     *
+     * The generated SQL (PostgreSQL):
+     *
+     * ```sql
+     * select "first_name"
+     * from "person"
+     * for update
+     * ```
+     */
+    modifyEnd(modifier) {
+        return new SelectQueryBuilder({
+            ...this.#props,
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.createWithRaw(modifier.toOperationNode())),
+        });
+    }
     /**
      * Makes the selection distinct.
      *
@@ -150,61 +205,61 @@ class SelectQueryBuilder {
     distinct() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithDistinct(this.#props.queryNode),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithFrontModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('Distinct')),
         });
     }
     /**
-     * Adds the `for update` option to a select query on supported databases.
+     * Adds the `for update` modifier to a select query on supported databases.
      */
     forUpdate() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForUpdate'),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForUpdate')),
         });
     }
     /**
-     * Adds the `for share` option to a select query on supported databases.
+     * Adds the `for share` modifier to a select query on supported databases.
      */
     forShare() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForShare'),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForShare')),
         });
     }
     /**
-     * Adds the `for key share` option to a select query on supported databases.
+     * Adds the `for key share` modifier to a select query on supported databases.
      */
     forKeyShare() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForKeyShare'),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForKeyShare')),
         });
     }
     /**
-     * Adds the `for no key update` option to a select query on supported databases.
+     * Adds the `for no key update` modifier to a select query on supported databases.
      */
     forNoKeyUpdate() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'ForNoKeyUpdate'),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('ForNoKeyUpdate')),
         });
     }
     /**
-     * Adds the `skip locked` option to a select query on supported databases.
+     * Adds the `skip locked` modifier to a select query on supported databases.
      */
     skipLocked() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'SkipLocked'),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('SkipLocked')),
         });
     }
     /**
-     * Adds the `nowait` option to a select query on supported databases.
+     * Adds the `nowait` modifier to a select query on supported databases.
      */
     noWait() {
         return new SelectQueryBuilder({
             ...this.#props,
-            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithModifier(this.#props.queryNode, 'NoWait'),
+            queryNode: select_query_node_js_1.SelectQueryNode.cloneWithEndModifier(this.#props.queryNode, select_modifier_node_js_1.SelectModifierNode.create('NoWait')),
         });
     }
     selectAll(table) {

package/dist/cjs/query-compiler/default-query-compiler.d.ts

@@ -68,6 +68,7 @@ import { DefaultValueNode } from '../operation-node/default-value-node.js';
 import { OnNode } from '../operation-node/on-node.js';
 import { ValuesNode } from '../operation-node/values-node.js';
 import { CommonTableExpressionNameNode } from '../operation-node/common-table-expression-name-node.js';
+import { SelectModifierNode } from '../operation-node/select-modifier-node.js';
 export declare class DefaultQueryCompiler extends OperationNodeVisitor implements QueryCompiler {
     #private;
     protected get numParameters(): number;
@@ -143,6 +144,7 @@ export declare class DefaultQueryCompiler extends OperationNodeVisitor implement
     protected visitDropView(node: DropViewNode): void;
     protected visitGenerated(node: GeneratedNode): void;
     protected visitDefaultValue(node: DefaultValueNode): void;
+    protected visitSelectModifier(node: SelectModifierNode): void;
     protected append(str: string): void;
     protected appendValue(parameter: unknown): void;
     protected getLeftIdentifierWrapper(): string;

package/dist/cjs/query-compiler/default-query-compiler.js

@@ -44,8 +44,8 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.compileDistinctOn(node.distinctOnSelections);
             this.append(' ');
         }
-        if (node.distinct) {
-            this.append('distinct');
+        if (node.frontModifiers && node.frontModifiers.length > 0) {
+            this.compileList(node.frontModifiers, ' ');
             this.append(' ');
         }
         if (node.selections) {
@@ -85,11 +85,9 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
             this.append(' ');
             this.visitNode(node.offset);
         }
-        if (node.modifiers) {
-            node.modifiers.forEach((modifier) => {
-                this.append(' ');
-                this.append(SELECT_MODIFIER_SQL[modifier]);
-            });
+        if (node.endModifiers && node.endModifiers.length > 0) {
+            this.append(' ');
+            this.compileList(node.endModifiers, ' ');
         }
         if (wrapInParens) {
             this.append(')');
@@ -785,6 +783,14 @@ class DefaultQueryCompiler extends operation_node_visitor_js_1.OperationNodeVisi
         this.append('default ');
         this.visitNode(node.defaultValue);
     }
+    visitSelectModifier(node) {
+        if (node.rawModifier) {
+            this.visitNode(node.rawModifier);
+        }
+        else {
+            this.append(SELECT_MODIFIER_SQL[node.modifier]);
+        }
+    }
     append(str) {
         this.#sql += str;
     }
@@ -833,6 +839,7 @@ const SELECT_MODIFIER_SQL = (0, object_utils_js_1.freeze)({
     ForShare: 'for share',
     NoWait: 'nowait',
     SkipLocked: 'skip locked',
+    Distinct: 'distinct',
 });
 const JOIN_TYPE_SQL = (0, object_utils_js_1.freeze)({
     InnerJoin: 'inner join',

package/dist/cjs/util/require-all-props.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Utility type to force use of all properties of T.
+ *
+ * Similar to Required<T> build-in type, but allows `undefined` values.
+ */
+declare type AllProps<T> = T & {
+    [P in keyof T]-?: unknown;
+};
+/**
+ * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
+ *
+ * Example use:
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ *
+ * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
+ * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ *
+ * // checked type is implicit for variable.
+ * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ * ```
+ *
+ * Wrong use of this helper:
+ *
+ * 1. Omit checked type - all checked properties will be expect as of type never
+ *
+ * ```ts
+ * const z: SomeType = requireAllProps({ propC: "no type will work" });
+ * ```
+ *
+ * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
+ *
+ * ```ts
+ * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
+ * const x = requireAllProps<SomeType>( { ... y } );
+ * ```
+ *
+ * @param obj object to check if all properties has been used
+ * @returns untouched obj parameter is returned
+ */
+export declare function requireAllProps<T>(obj: AllProps<T>): T;
+export {};

package/dist/cjs/util/require-all-props.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.requireAllProps = void 0;
+/**
+ * Helper function to check listed properties according to given type. Check if all properties has been used when object is initialised.
+ *
+ * Example use:
+ *
+ * ```ts
+ * type SomeType = { propA: string; propB?: number; }
+ *
+ * // propB has to be mentioned even it is optional. It still should be initialized with undefined.
+ * const a: SomeType = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ *
+ * // checked type is implicit for variable.
+ * const b = requireAllProps<SomeType>({ propA: "value A", propB: undefined });
+ * ```
+ *
+ * Wrong use of this helper:
+ *
+ * 1. Omit checked type - all checked properties will be expect as of type never
+ *
+ * ```ts
+ * const z: SomeType = requireAllProps({ propC: "no type will work" });
+ * ```
+ *
+ * 2. Apply to spreaded object - there is no way how to check in compile time if spreaded object contains all properties
+ *
+ * ```ts
+ * const y: SomeType = { propA: "" }; // valid object according to SomeType declaration
+ * const x = requireAllProps<SomeType>( { ... y } );
+ * ```
+ *
+ * @param obj object to check if all properties has been used
+ * @returns untouched obj parameter is returned
+ */
+function requireAllProps(obj) {
+    return obj;
+}
+exports.requireAllProps = requireAllProps;

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

@@ -65,6 +65,7 @@ import { GeneratedNode } from './generated-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
 import { ValuesNode } from './values-node.js';
+import { SelectModifierNode } from './select-modifier-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -97,8 +98,9 @@ import { ValuesNode } from './values-node.js';
 export declare class OperationNodeTransformer {
     #private;
     protected readonly nodeStack: OperationNode[];
-    readonly transformNode: <T extends OperationNode | undefined>(node: OperationNode | undefined) => T;
-    protected transformNodeList<T extends OperationNode>(list: readonly T[] | undefined): readonly T[];
+    readonly transformNode: <T extends OperationNode | undefined, U extends T | undefined = T>(node: U) => T;
+    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[]): readonly T[];
+    protected transformNodeList<T extends OperationNode, U extends T = T>(list: readonly U[] | undefined): readonly T[] | undefined;
     protected transformSelectQuery(node: SelectQueryNode): SelectQueryNode;
     protected transformSelection(node: SelectionNode): SelectionNode;
     protected transformColumn(node: ColumnNode): ColumnNode;
@@ -159,6 +161,7 @@ export declare class OperationNodeTransformer {
     protected transformGenerated(node: GeneratedNode): GeneratedNode;
     protected transformDefaultValue(node: DefaultValueNode): DefaultValueNode;
     protected transformOn(node: OnNode): OnNode;
+    protected transformSelectModifier(node: SelectModifierNode): SelectModifierNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;