kysely 0.19.7 → 0.19.10

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
+As shown 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
@@ -208,10 +213,11 @@ export async function down(db: Kysely<any>): Promise<void> {
 }
 ```
 
-The `up` function is called when you update your database schema to next version and `down`
+The `up` function is called when you update your database schema to the next version and `down`
 when you go back to previous version. The only argument for the functions is an instance of
-`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. Migrations
-should never depend on the current code of your app because they need to work even when the app
+`Kysely<any>`. It's important to use `Kysely<any>` and not `Kysely<YourDatabase>`. 
+
+Migrations should never depend on the current code of your app because they need to work even when the app
 changes. Migrations need to be "frozen in time".
 
 The migrations can use the [Kysely.schema](https://koskimas.github.io/kysely/classes/SchemaModule.html)

package/dist/cjs/dialect/sqlite/sqlite-introspector.js

@@ -58,7 +58,7 @@ class SqliteIntrospector {
                 dataType: col.type,
                 isNullable: !col.notnull,
                 isAutoIncrementing: col.name === autoIncrementCol,
-                hasDefaultValue: !!col.dflt_value,
+                hasDefaultValue: col.dflt_value != null,
             })),
         };
     }

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

@@ -0,0 +1,17 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+import { ValueListNode } from './value-list-node.js';
+export declare type CreateTypeNodeParams = Omit<Partial<CreateTypeNode>, 'kind'>;
+export interface CreateTypeNode extends OperationNode {
+    readonly kind: 'CreateTypeNode';
+    readonly name: IdentifierNode;
+    readonly enum?: ValueListNode;
+}
+/**
+ * @internal
+ */
+export declare const CreateTypeNode: Readonly<{
+    is(node: OperationNode): node is CreateTypeNode;
+    create(name: string): CreateTypeNode;
+    cloneWithEnum(createType: CreateTypeNode, values: string[]): CreateTypeNode;
+}>;

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CreateTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+const value_list_node_js_1 = require("./value-list-node.js");
+const value_node_js_1 = require("./value-node.js");
+/**
+ * @internal
+ */
+exports.CreateTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'CreateTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'CreateTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWithEnum(createType, values) {
+        return (0, object_utils_js_1.freeze)({
+            ...createType,
+            enum: value_list_node_js_1.ValueListNode.create(values.map((value) => value_node_js_1.ValueNode.createImmediate(value))),
+        });
+    },
+});

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

@@ -0,0 +1,16 @@
+import { IdentifierNode } from './identifier-node.js';
+import { OperationNode } from './operation-node.js';
+export declare type DropTypeNodeParams = Omit<Partial<DropTypeNode>, 'kind' | 'name'>;
+export interface DropTypeNode extends OperationNode {
+    readonly kind: 'DropTypeNode';
+    readonly name: IdentifierNode;
+    readonly ifExists?: boolean;
+}
+/**
+ * @internal
+ */
+export declare const DropTypeNode: Readonly<{
+    is(node: OperationNode): node is DropTypeNode;
+    create(name: string): DropTypeNode;
+    cloneWith(dropType: DropTypeNode, params: DropTypeNodeParams): DropTypeNode;
+}>;

package/dist/cjs/operation-node/drop-type-node.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DropTypeNode = void 0;
+const object_utils_js_1 = require("../util/object-utils.js");
+const identifier_node_js_1 = require("./identifier-node.js");
+/**
+ * @internal
+ */
+exports.DropTypeNode = (0, object_utils_js_1.freeze)({
+    is(node) {
+        return node.kind === 'DropTypeNode';
+    },
+    create(name) {
+        return (0, object_utils_js_1.freeze)({
+            kind: 'DropTypeNode',
+            name: identifier_node_js_1.IdentifierNode.create(name),
+        });
+    },
+    cloneWith(dropType, params) {
+        return (0, object_utils_js_1.freeze)({
+            ...dropType,
+            ...params,
+        });
+    },
+});

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

@@ -65,6 +65,9 @@ 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';
+import { CreateTypeNode } from './create-type-node.js';
+import { DropTypeNode } from './drop-type-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -97,8 +100,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 +163,9 @@ 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 transformCreateType(node: CreateTypeNode): CreateTypeNode;
+    protected transformDropType(node: DropTypeNode): DropTypeNode;
     protected transformDataType(node: DataTypeNode): DataTypeNode;
     protected transformSelectAll(node: SelectAllNode): SelectAllNode;
     protected transformIdentifier(node: IdentifierNode): IdentifierNode;