kysely 0.19.8 → 0.19.9

package/README.md

@@ -5,21 +5,20 @@
 
 # [Kysely](https://koskimas.github.io/kysely/index.html)
 
-A type-safe and autocompletion-friendly typescript SQL query builder. Inspired by [knex](http://knexjs.org/).
-Mainly developed for [node.js](https://nodejs.org/en/) but also runs on [deno](https://deno.land/) and
-in the browser.
+Kysely (pronounce “Key-Seh-Lee”) is a type-safe and autocompletion-friendly typescript SQL query builder. Inspired by
+[knex](http://knexjs.org/). Mainly developed for [node.js](https://nodejs.org/en/) but also runs on [deno](https://deno.land/)
+and in the browser.
 
 ![](https://github.com/koskimas/kysely/blob/master/assets/demo.gif)
 
 Kysely makes sure you only refer to tables and columns that are visible to the part of the query
-you are writing. The result type only has the selected columns with correct types and aliases. As an
+you're writing. The result type only has the selected columns with correct types and aliases. As an
 added bonus you get autocompletion for all that stuff.
 
 As you can see in the gif above, through the pure magic of modern typescript, Kysely is even able to parse
 the alias given to `pet.name` and add the `pet_name` column to the result row type. Kysely is able to infer
 column names, aliases and types from selected subqueries, joined subqueries, `with` statements and pretty
-much anything you can think of. Typescript is always there for you offering completions and making sure
-you build a valid query.
+much anything you can think of.
 
 Of course there are cases where things cannot be typed at compile time, and Kysely offers escape
 hatches for these situations. See the [sql template tag](https://koskimas.github.io/kysely/modules.html#sql) 
@@ -34,6 +33,7 @@ You can find a more thorough introduction [here](https://www.jakso.me/blog/kysel
 
 - [Installation](#installation)
 - [Minimal example](#minimal-example)
+- [Generating types](#generating-types)
 - [Query examples](#query-examples)
 - [Recipes](https://github.com/koskimas/kysely/tree/master/recipes)
 - [Migrations](#migrations)
@@ -166,6 +166,11 @@ type InsertablePerson = Insertable<PersonTable>
 type UpdateablePerson = Updateable<PersonTable>
 ```
 
+# Generating types
+
+If you want to generate the table types automatically from the database schema please
+check out [this awesome project](https://github.com/RobinBlomberg/kysely-codegen).
+
 # Query examples
 
 ## Select queries

package/dist/cjs/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;

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OperationNodeTransformer = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
+const require_all_props_js_1 = require("../util/require-all-props.js");
 /**
  * Transforms an operation node tree into another one.
  *
@@ -100,6 +101,7 @@ class OperationNodeTransformer {
         DefaultValueNode: this.transformDefaultValue.bind(this),
         OnNode: this.transformOn.bind(this),
         ValuesNode: this.transformValues.bind(this),
+        SelectModifierNode: this.transformSelectModifier.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -117,120 +119,120 @@ class OperationNodeTransformer {
         return (0, object_utils_js_1.freeze)(list.map(this.transformNode));
     }
     transformSelectQuery(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'SelectQueryNode',
             from: this.transformNode(node.from),
             selections: this.transformNodeList(node.selections),
             distinctOnSelections: this.transformNodeList(node.distinctOnSelections),
-            distinct: node.distinct,
             joins: this.transformNodeList(node.joins),
             groupBy: this.transformNode(node.groupBy),
             orderBy: this.transformNode(node.orderBy),
             where: this.transformNode(node.where),
-            modifiers: node.modifiers,
+            frontModifiers: this.transformNodeList(node.frontModifiers),
+            endModifiers: this.transformNodeList(node.endModifiers),
             limit: this.transformNode(node.limit),
             offset: this.transformNode(node.offset),
             with: this.transformNode(node.with),
             having: this.transformNode(node.having),
             union: this.transformNodeList(node.union),
-        };
+        });
     }
     transformSelection(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'SelectionNode',
             selection: this.transformNode(node.selection),
-        };
+        });
     }
     transformColumn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformAlias(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AliasNode',
             node: this.transformNode(node.node),
             alias: this.transformNode(node.alias),
-        };
+        });
     }
     transformTable(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'TableNode',
             schema: this.transformNode(node.schema),
             table: this.transformNode(node.table),
-        };
+        });
     }
     transformFrom(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'FromNode',
             froms: this.transformNodeList(node.froms),
-        };
+        });
     }
     transformReference(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ReferenceNode',
             table: this.transformNode(node.table),
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformFilter(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'FilterNode',
             left: this.transformNode(node.left),
             op: this.transformNode(node.op),
             right: this.transformNode(node.right),
-        };
+        });
     }
     transformAnd(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AndNode',
             left: this.transformNode(node.left),
             right: this.transformNode(node.right),
-        };
+        });
     }
     transformOr(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OrNode',
             left: this.transformNode(node.left),
             right: this.transformNode(node.right),
-        };
+        });
     }
     transformValueList(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ValueListNode',
             values: this.transformNodeList(node.values),
-        };
+        });
     }
     transformParens(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ParensNode',
             node: this.transformNode(node.node),
-        };
+        });
     }
     transformJoin(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'JoinNode',
             joinType: node.joinType,
             table: this.transformNode(node.table),
             on: this.transformNode(node.on),
-        };
+        });
     }
     transformRaw(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'RawNode',
             sqlFragments: (0, object_utils_js_1.freeze)([...node.sqlFragments]),
             parameters: this.transformNodeList(node.parameters),
-        };
+        });
     }
     transformWhere(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'WhereNode',
             where: this.transformNode(node.where),
-        };
+        });
     }
     transformInsertQuery(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'InsertQueryNode',
             into: this.transformNode(node.into),
             columns: this.transformNodeList(node.columns),
@@ -240,16 +242,16 @@ class OperationNodeTransformer {
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
             with: this.transformNode(node.with),
             ignore: node.ignore,
-        };
+        });
     }
     transformValues(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ValuesNode',
             values: this.transformNodeList(node.values),
-        };
+        });
     }
     transformDeleteQuery(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DeleteQueryNode',
             from: this.transformNode(node.from),
             joins: this.transformNodeList(node.joins),
@@ -258,16 +260,16 @@ class OperationNodeTransformer {
             with: this.transformNode(node.with),
             orderBy: this.transformNode(node.orderBy),
             limit: this.transformNode(node.limit),
-        };
+        });
     }
     transformReturning(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ReturningNode',
             selections: this.transformNodeList(node.selections),
-        };
+        });
     }
     transformCreateTable(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CreateTableNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
@@ -275,10 +277,10 @@ class OperationNodeTransformer {
             temporary: node.temporary,
             ifNotExists: node.ifNotExists,
             onCommit: node.onCommit,
-        };
+        });
     }
     transformColumnDefinition(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ColumnDefinitionNode',
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
@@ -291,48 +293,48 @@ class OperationNodeTransformer {
             defaultTo: this.transformNode(node.defaultTo),
             check: this.transformNode(node.check),
             generated: this.transformNode(node.generated),
-        };
+        });
     }
     transformAddColumn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AddColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformDropTable(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DropTableNode',
             table: this.transformNode(node.table),
             ifExists: node.ifExists,
-        };
+        });
     }
     transformOrderBy(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OrderByNode',
             items: this.transformNodeList(node.items),
-        };
+        });
     }
     transformOrderByItem(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OrderByItemNode',
             orderBy: this.transformNode(node.orderBy),
             direction: this.transformNode(node.direction),
-        };
+        });
     }
     transformGroupBy(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'GroupByNode',
             items: this.transformNodeList(node.items),
-        };
+        });
     }
     transformGroupByItem(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'GroupByItemNode',
             groupBy: this.transformNode(node.groupBy),
-        };
+        });
     }
     transformUpdateQuery(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'UpdateQueryNode',
             table: this.transformNode(node.table),
             from: this.transformNode(node.from),
@@ -341,29 +343,29 @@ class OperationNodeTransformer {
             updates: this.transformNodeList(node.updates),
             returning: this.transformNode(node.returning),
             with: this.transformNode(node.with),
-        };
+        });
     }
     transformColumnUpdate(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ColumnUpdateNode',
             column: this.transformNode(node.column),
             value: this.transformNode(node.value),
-        };
+        });
     }
     transformLimit(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'LimitNode',
             limit: this.transformNode(node.limit),
-        };
+        });
     }
     transformOffset(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OffsetNode',
             offset: this.transformNode(node.offset),
-        };
+        });
     }
     transformOnConflict(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OnConflictNode',
             columns: this.transformNodeList(node.columns),
             constraint: this.transformNode(node.constraint),
@@ -372,128 +374,128 @@ class OperationNodeTransformer {
             updates: this.transformNodeList(node.updates),
             updateWhere: this.transformNode(node.updateWhere),
             doNothing: node.doNothing,
-        };
+        });
     }
     transformOnDuplicateKey(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OnDuplicateKeyNode',
             updates: this.transformNodeList(node.updates),
-        };
+        });
     }
     transformCreateIndex(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CreateIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
             expression: this.transformNode(node.expression),
             unique: node.unique,
             using: this.transformNode(node.using),
-        };
+        });
     }
     transformList(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ListNode',
             items: this.transformNodeList(node.items),
-        };
+        });
     }
     transformDropIndex(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DropIndexNode',
             name: this.transformNode(node.name),
             table: this.transformNode(node.table),
             ifExists: node.ifExists,
-        };
+        });
     }
     transformPrimaryKeyConstraint(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'PrimaryKeyConstraintNode',
             columns: this.transformNodeList(node.columns),
             name: this.transformNode(node.name),
-        };
+        });
     }
     transformUniqueConstraint(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'UniqueConstraintNode',
             columns: this.transformNodeList(node.columns),
             name: this.transformNode(node.name),
-        };
+        });
     }
     transformForeignKeyConstraint(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ForeignKeyConstraintNode',
             columns: this.transformNodeList(node.columns),
             references: this.transformNode(node.references),
             name: this.transformNode(node.name),
             onDelete: node.onDelete,
             onUpdate: node.onUpdate,
-        };
+        });
     }
     transformUnion(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'UnionNode',
             union: this.transformNode(node.union),
             all: node.all,
-        };
+        });
     }
     transformReferences(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ReferencesNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             onDelete: node.onDelete,
             onUpdate: node.onUpdate,
-        };
+        });
     }
     transformCheckConstraint(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CheckConstraintNode',
             expression: this.transformNode(node.expression),
             name: this.transformNode(node.name),
-        };
+        });
     }
     transformWith(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'WithNode',
             expressions: this.transformNodeList(node.expressions),
             recursive: node.recursive,
-        };
+        });
     }
     transformCommonTableExpression(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CommonTableExpressionNode',
             name: this.transformNode(node.name),
             expression: this.transformNode(node.expression),
-        };
+        });
     }
     transformCommonTableExpressionName(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CommonTableExpressionNameNode',
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
-        };
+        });
     }
     transformHaving(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'HavingNode',
             having: this.transformNode(node.having),
-        };
+        });
     }
     transformCreateSchema(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CreateSchemaNode',
             schema: this.transformNode(node.schema),
             ifNotExists: node.ifNotExists,
-        };
+        });
     }
     transformDropSchema(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DropSchemaNode',
             schema: this.transformNode(node.schema),
             ifExists: node.ifExists,
-        };
+        });
     }
     transformAlterTable(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AlterTableNode',
             table: this.transformNode(node.table),
             renameTo: this.transformNode(node.renameTo),
@@ -505,23 +507,23 @@ class OperationNodeTransformer {
             modifyColumn: this.transformNode(node.modifyColumn),
             addConstraint: this.transformNode(node.addConstraint),
             dropConstraint: this.transformNode(node.dropConstraint),
-        };
+        });
     }
     transformDropColumn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DropColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformRenameColumn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'RenameColumnNode',
             column: this.transformNode(node.column),
             renameTo: this.transformNode(node.renameTo),
-        };
+        });
     }
     transformAlterColumn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AlterColumnNode',
             column: this.transformNode(node.column),
             dataType: this.transformNode(node.dataType),
@@ -530,30 +532,30 @@ class OperationNodeTransformer {
             dropDefault: node.dropDefault,
             setNotNull: node.setNotNull,
             dropNotNull: node.dropNotNull,
-        };
+        });
     }
     transformModifyColumn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'ModifyColumnNode',
             column: this.transformNode(node.column),
-        };
+        });
     }
     transformAddConstraint(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'AddConstraintNode',
             constraint: this.transformNode(node.constraint),
-        };
+        });
     }
     transformDropConstraint(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DropConstraintNode',
             constraintName: this.transformNode(node.constraintName),
             ifExists: node.ifExists,
             modifier: node.modifier,
-        };
+        });
     }
     transformCreateView(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'CreateViewNode',
             name: this.transformNode(node.name),
             temporary: node.temporary,
@@ -562,37 +564,44 @@ class OperationNodeTransformer {
             materialized: node.materialized,
             columns: this.transformNodeList(node.columns),
             as: this.transformNode(node.as),
-        };
+        });
     }
     transformDropView(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DropViewNode',
             name: this.transformNode(node.name),
             ifExists: node.ifExists,
             materialized: node.materialized,
-        };
+        });
     }
     transformGenerated(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'GeneratedNode',
             byDefault: node.byDefault,
             always: node.always,
             identity: node.identity,
             stored: node.stored,
             expression: this.transformNode(node.expression),
-        };
+        });
     }
     transformDefaultValue(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'DefaultValueNode',
             defaultValue: this.transformNode(node.defaultValue),
-        };
+        });
     }
     transformOn(node) {
-        return {
+        return (0, require_all_props_js_1.requireAllProps)({
             kind: 'OnNode',
             on: this.transformNode(node.on),
-        };
+        });
+    }
+    transformSelectModifier(node) {
+        return (0, require_all_props_js_1.requireAllProps)({
+            kind: 'SelectModifierNode',
+            modifier: node.modifier,
+            rawModifier: this.transformNode(node.rawModifier),
+        });
     }
     transformDataType(node) {
         // An Object.freezed leaf node. No need to clone.