kysely 0.19.8 → 0.19.11

package/dist/esm/query-executor/query-executor-base.js

@@ -1,5 +1,6 @@
 /// <reference types="./query-executor-base.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { Deferred } from '../util/deferred.js';
 const NO_PLUGINS = freeze([]);
 export class QueryExecutorBase {
     #plugins;
@@ -34,6 +35,24 @@ export class QueryExecutorBase {
             return this.#transformResult(result, queryId);
         });
     }
+    async *stream(compiledQuery, chunkSize, queryId) {
+        const connectionDefer = new Deferred();
+        const connectionReleaseDefer = new Deferred();
+        this.provideConnection(async (connection) => {
+            connectionDefer.resolve(connection);
+            // Lets wait until we don't need connection before returning here (returning releases connection)
+            return await connectionReleaseDefer.promise;
+        }).catch((ex) => connectionDefer.reject(ex));
+        const connection = await connectionDefer.promise;
+        try {
+            for await (const result of connection.streamQuery(compiledQuery, chunkSize)) {
+                yield await this.#transformResult(result, queryId);
+            }
+        }
+        finally {
+            connectionReleaseDefer.resolve();
+        }
+    }
     async #transformResult(result, queryId) {
         for (const plugin of this.#plugins) {
             result = await plugin.transformResult({ result, queryId });

package/dist/esm/query-executor/query-executor.d.ts

@@ -37,6 +37,17 @@ export interface QueryExecutor extends ConnectionProvider {
      * `transformResult` method.
      */
     executeQuery<R>(compiledQuery: CompiledQuery, queryId: QueryId): Promise<QueryResult<R>>;
+    /**
+     * Executes a compiled query and runs the result through all plugins'
+     * `transformResult` method. Results are streamead instead of loaded
+     * at once.
+     */
+    stream<R>(compiledQuery: CompiledQuery, 
+    /**
+     * How many rows should be pulled from the database at once. Supported
+     * only by the postgres driver.
+     */
+    chunkSize: number, queryId: QueryId): AsyncIterableIterator<QueryResult<R>>;
     /**
      * Returns a copy of this executor with a new connection provider.
      */

package/dist/esm/schema/create-table-builder.d.ts

@@ -47,17 +47,17 @@ export declare class CreateTableBuilder<TB extends string, C extends string = ne
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', sql`customtype`)
+     *   .addColumn('data', sql`some_type`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
      * ```
      *
-     * With this method, it's once again good to remember that Kysely just builds the query
-     * and doesn't provide the same API for all databses. For example, some databases like
-     * older MySQL don't support `references` statement in the column definition. Instead
-     * foreign key constraints need to be defined in at the level of the `create table`
-     * query. See the next example:
+     * With this method, it's once again good to remember that Kysely just builds the
+     * query and doesn't provide the same API for all databses. For example, some
+     * databases like older MySQL don't support the `references` statement in the
+     * column definition. Instead foreign key constraints need to be defined in the
+     * `create table` query. See the next example:
      *
      * ```ts
      *   .addColumn('parent_id', 'integer')

package/dist/esm/schema/create-table-builder.js

@@ -74,17 +74,17 @@ export class CreateTableBuilder {
      *   .addColumn('first_name', 'varchar(50)', (col) => col.notNull())
      *   .addColumn('last_name', 'varchar(255)')
      *   .addColumn('bank_balance', 'numeric(8, 2)')
-     *   .addColumn('data', sql`customtype`)
+     *   .addColumn('data', sql`some_type`)
      *   .addColumn('parent_id', 'integer', (col) =>
      *     col.references('person.id').onDelete('cascade'))
      *   )
      * ```
      *
-     * With this method, it's once again good to remember that Kysely just builds the query
-     * and doesn't provide the same API for all databses. For example, some databases like
-     * older MySQL don't support `references` statement in the column definition. Instead
-     * foreign key constraints need to be defined in at the level of the `create table`
-     * query. See the next example:
+     * With this method, it's once again good to remember that Kysely just builds the
+     * query and doesn't provide the same API for all databses. For example, some
+     * databases like older MySQL don't support the `references` statement in the
+     * column definition. Instead foreign key constraints need to be defined in the
+     * `create table` query. See the next example:
      *
      * ```ts
      *   .addColumn('parent_id', 'integer')

package/dist/esm/schema/create-type-builder.d.ts

@@ -0,0 +1,28 @@
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+export declare class CreateTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: CreateTypeBuilderProps);
+    toOperationNode(): CreateTypeNode;
+    /**
+     * Creates an anum type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createType('species').asEnum(['cat', 'dog', 'frog'])
+     * ```
+     */
+    asEnum(values: string[]): CreateTypeBuilder;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface CreateTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly createTypeNode: CreateTypeNode;
+}

package/dist/esm/schema/create-type-builder.js

@@ -0,0 +1,35 @@
+/// <reference types="./create-type-builder.d.ts" />
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+export class CreateTypeBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.createTypeNode, this.#props.queryId);
+    }
+    /**
+     * Creates an anum type.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema.createType('species').asEnum(['cat', 'dog', 'frog'])
+     * ```
+     */
+    asEnum(values) {
+        return new CreateTypeBuilder({
+            ...this.#props,
+            createTypeNode: CreateTypeNode.cloneWithEnum(this.#props.createTypeNode, values),
+        });
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+preventAwait(CreateTypeBuilder, "don't await CreateTypeBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/drop-type-builder.d.ts

@@ -0,0 +1,19 @@
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { OperationNodeSource } from '../operation-node/operation-node-source.js';
+import { CompiledQuery } from '../query-compiler/compiled-query.js';
+import { Compilable } from '../util/compilable.js';
+import { QueryExecutor } from '../query-executor/query-executor.js';
+import { QueryId } from '../util/query-id.js';
+export declare class DropTypeBuilder implements OperationNodeSource, Compilable {
+    #private;
+    constructor(props: DropTypeBuilderProps);
+    ifExists(): DropTypeBuilder;
+    toOperationNode(): DropTypeNode;
+    compile(): CompiledQuery;
+    execute(): Promise<void>;
+}
+export interface DropTypeBuilderProps {
+    readonly queryId: QueryId;
+    readonly executor: QueryExecutor;
+    readonly dropTypeNode: DropTypeNode;
+}

package/dist/esm/schema/drop-type-builder.js

@@ -0,0 +1,28 @@
+/// <reference types="./drop-type-builder.d.ts" />
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
+import { preventAwait } from '../util/prevent-await.js';
+import { freeze } from '../util/object-utils.js';
+export class DropTypeBuilder {
+    #props;
+    constructor(props) {
+        this.#props = freeze(props);
+    }
+    ifExists() {
+        return new DropTypeBuilder({
+            ...this.#props,
+            dropTypeNode: DropTypeNode.cloneWith(this.#props.dropTypeNode, {
+                ifExists: true,
+            }),
+        });
+    }
+    toOperationNode() {
+        return this.#props.executor.transformQuery(this.#props.dropTypeNode, this.#props.queryId);
+    }
+    compile() {
+        return this.#props.executor.compileQuery(this.toOperationNode(), this.#props.queryId);
+    }
+    async execute() {
+        await this.#props.executor.executeQuery(this.compile(), this.#props.queryId);
+    }
+}
+preventAwait(DropTypeBuilder, "don't await DropTypeBuilder instances directly. To execute the query you need to call `execute`");

package/dist/esm/schema/schema.d.ts

@@ -9,6 +9,8 @@ import { DropTableBuilder } from './drop-table-builder.js';
 import { CreateViewBuilder } from './create-view-builder.js';
 import { DropViewBuilder } from './drop-view-builder.js';
 import { KyselyPlugin } from '../plugin/kysely-plugin.js';
+import { CreateTypeBuilder } from './create-type-builder.js';
+import { DropTypeBuilder } from './drop-type-builder.js';
 /**
  * Provides methods for building database schema.
  */
@@ -170,6 +172,36 @@ export declare class SchemaModule {
      * ```
      */
     dropView(viewName: string): DropViewBuilder;
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName: string): CreateTypeBuilder;
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName: string): DropTypeBuilder;
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/esm/schema/schema.js

@@ -20,6 +20,10 @@ import { CreateViewBuilder } from './create-view-builder.js';
 import { CreateViewNode } from '../operation-node/create-view-node.js';
 import { DropViewBuilder } from './drop-view-builder.js';
 import { DropViewNode } from '../operation-node/drop-view-node.js';
+import { CreateTypeBuilder } from './create-type-builder.js';
+import { DropTypeBuilder } from './drop-type-builder.js';
+import { CreateTypeNode } from '../operation-node/create-type-node.js';
+import { DropTypeNode } from '../operation-node/drop-type-node.js';
 /**
  * Provides methods for building database schema.
  */
@@ -237,6 +241,48 @@ export class SchemaModule {
             dropViewNode: DropViewNode.create(viewName),
         });
     }
+    /**
+     * Create a new type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .createType('species')
+     *   .asEnum(['dog', 'cat', 'frog'])
+     *   .execute()
+     * ```
+     */
+    createType(viewName) {
+        return new CreateTypeBuilder({
+            queryId: createQueryId(),
+            executor: this.#executor,
+            createTypeNode: CreateTypeNode.create(viewName),
+        });
+    }
+    /**
+     * Drop a type.
+     *
+     * Only some dialects like PostgreSQL have user-defined types.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db.schema
+     *   .dropType('species')
+     *   .ifExists()
+     *   .execute()
+     * ```
+     */
+    dropType(viewName) {
+        return new DropTypeBuilder({
+            queryId: createQueryId(),
+            executor: this.#executor,
+            dropTypeNode: DropTypeNode.create(viewName),
+        });
+    }
     /**
      * Returns a copy of this schema module with the given plugin installed.
      */

package/dist/esm/util/deferred.d.ts

@@ -0,0 +1,7 @@
+export declare class Deferred<T> {
+    #private;
+    constructor();
+    get promise(): Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+}

package/dist/esm/util/deferred.js

@@ -0,0 +1,25 @@
+/// <reference types="./deferred.d.ts" />
+export class Deferred {
+    #promise;
+    #resolve;
+    #reject;
+    constructor() {
+        this.#promise = new Promise((resolve, reject) => {
+            this.#reject = reject;
+            this.#resolve = resolve;
+        });
+    }
+    get promise() {
+        return this.#promise;
+    }
+    resolve = (value) => {
+        if (this.#resolve) {
+            this.#resolve(value);
+        }
+    };
+    reject = (reason) => {
+        if (this.#reject) {
+            this.#reject(reason);
+        }
+    };
+}

package/dist/esm/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/esm/util/require-all-props.js

@@ -0,0 +1,37 @@
+/// <reference types="./require-all-props.d.ts" />
+/**
+ * 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 function requireAllProps(obj) {
+    return obj;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.19.8",
+  "version": "0.19.11",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",
@@ -44,20 +44,23 @@
   "devDependencies": {
     "@types/better-sqlite3": "^7.5.0",
     "@types/chai": "^4.3.1",
+    "@types/chai-as-promised": "^7.1.5",
     "@types/chai-subset": "^1.3.3",
     "@types/mocha": "^9.1.1",
     "@types/pg": "^8.6.5",
     "better-sqlite3": "^7.5.3",
     "chai": "^4.3.6",
+    "chai-as-promised": "^7.1.1",
     "chai-subset": "^1.6.0",
     "esbuild": "^0.14.47",
     "mocha": "^10.0.0",
     "mysql2": "^2.3.3",
     "pg": "^8.7.3",
+    "pg-cursor": "^2.7.3",
     "playwright": "^1.22.2",
     "prettier": "^2.7.1",
     "tsd": "^0.21.0",
-    "typedoc": "^0.22.18",
+    "typedoc": "^0.23.6",
     "typescript": "4.7.4"
   }
 }