kysely 0.17.2 → 0.18.1

package/dist/esm/migration/migrator.js

@@ -1,7 +1,9 @@
 /// <reference types="./migrator.d.ts" />
+import { NoopPlugin } from '../plugin/noop-plugin.js';
+import { WithSchemaPlugin } from '../plugin/with-schema/with-schema-plugin.js';
 import { freeze, getLast } from '../util/object-utils.js';
-export const MIGRATION_TABLE = 'kysely_migration';
-export const MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
+export const DEFAULT_MIGRATION_TABLE = 'kysely_migration';
+export const DEFAULT_MIGRATION_LOCK_TABLE = 'kysely_migration_lock';
 export const MIGRATION_LOCK_ID = 'migration_lock';
 export const NO_MIGRATIONS = freeze({ __noMigrations__: true });
 /**
@@ -35,9 +37,10 @@ export class Migrator {
      * The returned array is sorted by migration name.
      */
     async getMigrations() {
-        const executedMigrations = (await this.#doesTableExists(MIGRATION_TABLE))
+        const executedMigrations = (await this.#doesTableExists(this.#migrationTable))
             ? await this.#props.db
-                .selectFrom(MIGRATION_TABLE)
+                .withPlugin(this.#schemaPlugin)
+                .selectFrom(this.#migrationTable)
                 .select(['name', 'timestamp'])
                 .execute()
             : [];
@@ -182,16 +185,61 @@ export class Migrator {
             return { error };
         }
     }
+    get #migrationTableSchema() {
+        return this.#props.migrationTableSchema;
+    }
+    get #migrationTable() {
+        return this.#props.migrationTableName ?? DEFAULT_MIGRATION_TABLE;
+    }
+    get #migrationLockTable() {
+        return this.#props.migrationLockTableName ?? DEFAULT_MIGRATION_LOCK_TABLE;
+    }
+    get #schemaPlugin() {
+        if (this.#migrationTableSchema) {
+            return new WithSchemaPlugin(this.#migrationTableSchema);
+        }
+        return new NoopPlugin();
+    }
     async #ensureMigrationTablesExists() {
+        await this.#ensureMigrationTableSchemaExists();
         await this.#ensureMigrationTableExists();
         await this.#ensureMigrationLockTableExists();
         await this.#ensureLockRowExists();
     }
+    async #ensureMigrationTableSchemaExists() {
+        if (!this.#migrationTableSchema) {
+            // Use default schema. Nothing to do.
+            return;
+        }
+        if (!(await this.#doesSchemaExists())) {
+            try {
+                await this.#props.db.schema
+                    .createSchema(this.#migrationTableSchema)
+                    .ifNotExists()
+                    .execute();
+            }
+            catch (error) {
+                // At least on PostgreSQL, `if not exists` doesn't guarantee the `create schema`
+                // query doesn't throw if the schema already exits. That's why we check if
+                // the schema exist here and ignore the error if it does.
+                if (!(await this.#doesSchemaExists())) {
+                    throw error;
+                }
+            }
+        }
+    }
     async #ensureMigrationTableExists() {
-        if (!(await this.#doesTableExists(MIGRATION_TABLE))) {
+        if (!(await this.#doesTableExists(this.#migrationTable))) {
             try {
+                if (this.#migrationTableSchema) {
+                    await this.#props.db.schema
+                        .createSchema(this.#migrationTableSchema)
+                        .ifNotExists()
+                        .execute();
+                }
                 await this.#props.db.schema
-                    .createTable(MIGRATION_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .createTable(this.#migrationTable)
                     .ifNotExists()
                     .addColumn('name', 'varchar(255)', (col) => col.notNull().primaryKey())
                     // The migration run time as ISO string. This is not a real date type as we
@@ -203,17 +251,18 @@ export class Migrator {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
                 // query doesn't throw if the table already exits. That's why we check if
                 // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(MIGRATION_TABLE))) {
+                if (!(await this.#doesTableExists(this.#migrationTable))) {
                     throw error;
                 }
             }
         }
     }
     async #ensureMigrationLockTableExists() {
-        if (!(await this.#doesTableExists(MIGRATION_LOCK_TABLE))) {
+        if (!(await this.#doesTableExists(this.#migrationLockTable))) {
             try {
                 await this.#props.db.schema
-                    .createTable(MIGRATION_LOCK_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .createTable(this.#migrationLockTable)
                     .ifNotExists()
                     .addColumn('id', 'varchar(255)', (col) => col.notNull().primaryKey())
                     .addColumn('is_locked', 'integer', (col) => col.notNull().defaultTo(0))
@@ -223,7 +272,7 @@ export class Migrator {
                 // At least on PostgreSQL, `if not exists` doesn't guarantee the `create table`
                 // query doesn't throw if the table already exits. That's why we check if
                 // the table exist here and ignore the error if it does.
-                if (!(await this.#doesTableExists(MIGRATION_LOCK_TABLE))) {
+                if (!(await this.#doesTableExists(this.#migrationLockTable))) {
                     throw error;
                 }
             }
@@ -233,7 +282,8 @@ export class Migrator {
         if (!(await this.#doesLockRowExists())) {
             try {
                 await this.#props.db
-                    .insertInto(MIGRATION_LOCK_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .insertInto(this.#migrationLockTable)
                     .values({ id: MIGRATION_LOCK_ID, is_locked: 0 })
                     .execute();
             }
@@ -244,15 +294,21 @@ export class Migrator {
             }
         }
     }
+    async #doesSchemaExists() {
+        const schemas = await this.#props.db.introspection.getSchemas();
+        return schemas.some((it) => it.name === this.#migrationTableSchema);
+    }
     async #doesTableExists(tableName) {
-        const metadata = await this.#props.db.introspection.getMetadata({
+        const schema = this.#migrationTableSchema;
+        const tables = await this.#props.db.introspection.getTables({
             withInternalKyselyTables: true,
         });
-        return !!metadata.tables.find((it) => it.name === tableName);
+        return tables.some((it) => it.name === tableName && (!schema || it.schema === schema));
     }
     async #doesLockRowExists() {
         const lockRow = await this.#props.db
-            .selectFrom(MIGRATION_LOCK_TABLE)
+            .withPlugin(this.#schemaPlugin)
+            .selectFrom(this.#migrationLockTable)
             .where('id', '=', MIGRATION_LOCK_ID)
             .select('id')
             .executeTakeFirst();
@@ -310,7 +366,8 @@ export class Migrator {
     }
     async #getExecutedMigrations(db) {
         const executedMigrations = await db
-            .selectFrom(MIGRATION_TABLE)
+            .withPlugin(this.#schemaPlugin)
+            .selectFrom(this.#migrationTable)
             .select('name')
             .orderBy('name')
             .execute();
@@ -346,7 +403,8 @@ export class Migrator {
                 if (migration.down) {
                     await migration.down(db);
                     await db
-                        .deleteFrom(MIGRATION_TABLE)
+                        .withPlugin(this.#schemaPlugin)
+                        .deleteFrom(this.#migrationTable)
                         .where('name', '=', migration.name)
                         .execute();
                     results[i] = {
@@ -384,7 +442,8 @@ export class Migrator {
             try {
                 await migration.up(db);
                 await db
-                    .insertInto(MIGRATION_TABLE)
+                    .withPlugin(this.#schemaPlugin)
+                    .insertInto(this.#migrationTable)
                     .values({
                     name: migration.name,
                     timestamp: new Date().toISOString(),

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

@@ -9,12 +9,12 @@ export declare type AliasNodeChild = ColumnNode | ReferenceNode | TableNode | Se
 export interface AliasNode extends OperationNode {
     readonly kind: 'AliasNode';
     readonly node: AliasNodeChild;
-    readonly alias: IdentifierNode;
+    readonly alias: IdentifierNode | RawNode;
 }
 /**
  * @internal
  */
 export declare const AliasNode: Readonly<{
     is(node: OperationNode): node is AliasNode;
-    create(node: AliasNodeChild, alias: string): AliasNode;
+    create(node: AliasNodeChild, alias: IdentifierNode | RawNode): AliasNode;
 }>;

package/dist/esm/operation-node/alias-node.js

@@ -1,6 +1,5 @@
 /// <reference types="./alias-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
-import { IdentifierNode } from './identifier-node.js';
 /**
  * @internal
  */
@@ -12,7 +11,7 @@ export const AliasNode = freeze({
         return freeze({
             kind: 'AliasNode',
             node,
-            alias: IdentifierNode.create(alias),
+            alias,
         });
     },
 });

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

@@ -331,6 +331,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'UpdateQueryNode',
             table: this.transformNode(node.table),
+            from: this.transformNode(node.from),
             joins: this.transformNodeList(node.joins),
             where: this.transformNode(node.where),
             updates: this.transformNodeList(node.updates),

package/dist/esm/operation-node/update-query-node.d.ts

@@ -7,10 +7,12 @@ import { ReturningNode } from './returning-node.js';
 import { ValueListNode } from './value-list-node.js';
 import { WhereNode } from './where-node.js';
 import { WithNode } from './with-node.js';
+import { FromNode } from './from-node.js';
 export declare type UpdateValuesNode = ValueListNode | PrimitiveValueListNode;
 export interface UpdateQueryNode extends OperationNode {
     readonly kind: 'UpdateQueryNode';
     readonly table: TableExpressionNode;
+    readonly from?: FromNode;
     readonly joins?: ReadonlyArray<JoinNode>;
     readonly where?: WhereNode;
     readonly updates?: ReadonlyArray<ColumnUpdateNode>;
@@ -23,5 +25,6 @@ export interface UpdateQueryNode extends OperationNode {
 export declare const UpdateQueryNode: Readonly<{
     is(node: OperationNode): node is UpdateQueryNode;
     create(table: TableExpressionNode, withNode?: WithNode | undefined): UpdateQueryNode;
+    cloneWithFromItems(updateQuery: UpdateQueryNode, fromItems: ReadonlyArray<TableExpressionNode>): UpdateQueryNode;
     cloneWithUpdates(updateQuery: UpdateQueryNode, updates: ReadonlyArray<ColumnUpdateNode>): UpdateQueryNode;
 }>;

package/dist/esm/operation-node/update-query-node.js

@@ -1,5 +1,6 @@
 /// <reference types="./update-query-node.d.ts" />
 import { freeze } from '../util/object-utils.js';
+import { FromNode } from './from-node.js';
 /**
  * @internal
  */
@@ -8,11 +9,19 @@ export const UpdateQueryNode = freeze({
         return node.kind === 'UpdateQueryNode';
     },
     create(table, withNode) {
-        return {
+        return freeze({
             kind: 'UpdateQueryNode',
             table,
             ...(withNode && { with: withNode }),
-        };
+        });
+    },
+    cloneWithFromItems(updateQuery, fromItems) {
+        return freeze({
+            ...updateQuery,
+            from: updateQuery.from
+                ? FromNode.cloneWithFroms(updateQuery.from, fromItems)
+                : FromNode.create(fromItems),
+        });
     },
     cloneWithUpdates(updateQuery, updates) {
         return freeze({

package/dist/esm/parser/reference-parser.js

@@ -6,6 +6,7 @@ import { TableNode } from '../operation-node/table-node.js';
 import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { parseComplexExpression, } from './complex-expression-parser.js';
 import { isDynamicReferenceBuilder, } from '../dynamic/dynamic-reference-builder.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseReferenceExpressionOrList(arg) {
     if (isReadonlyArray(arg)) {
         return arg.map((it) => parseReferenceExpression(it));
@@ -45,7 +46,7 @@ export function parseAliasedStringReference(ref) {
     const ALIAS_SEPARATOR = ' as ';
     if (ref.includes(ALIAS_SEPARATOR)) {
         const [columnRef, alias] = ref.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseStringReference(columnRef), alias);
+        return AliasNode.create(parseStringReference(columnRef), IdentifierNode.create(alias));
     }
     else {
         return parseStringReference(ref);

package/dist/esm/parser/table-parser.js

@@ -3,6 +3,7 @@ import { isReadonlyArray, isString } from '../util/object-utils.js';
 import { AliasNode } from '../operation-node/alias-node.js';
 import { TableNode } from '../operation-node/table-node.js';
 import { parseAliasedComplexExpression, } from './complex-expression-parser.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export function parseTableExpressionOrList(table) {
     if (isReadonlyArray(table)) {
         return table.map((it) => parseTableExpression(it));
@@ -23,7 +24,7 @@ export function parseAliasedTable(from) {
     const ALIAS_SEPARATOR = ' as ';
     if (from.includes(ALIAS_SEPARATOR)) {
         const [table, alias] = from.split(ALIAS_SEPARATOR).map(trim);
-        return AliasNode.create(parseTable(table), alias);
+        return AliasNode.create(parseTable(table), IdentifierNode.create(alias));
     }
     else {
         return parseTable(from);

package/dist/esm/parser/update-set-parser.d.ts

@@ -1,7 +1,7 @@
 import { ColumnUpdateNode } from '../operation-node/column-update-node.js';
 import { UpdateKeys, UpdateType } from '../util/column-type.js';
 import { ValueExpression } from './value-parser.js';
-export declare type MutationObject<DB, TB extends keyof DB> = {
-    [C in UpdateKeys<DB[TB]>]?: ValueExpression<DB, TB, UpdateType<DB[TB][C]>>;
+export declare type MutationObject<DB, TB extends keyof DB, TM extends keyof DB> = {
+    [C in UpdateKeys<DB[TM]>]?: ValueExpression<DB, TB, UpdateType<DB[TM][C]>>;
 };
-export declare function parseUpdateObject(row: MutationObject<any, any>): ReadonlyArray<ColumnUpdateNode>;
+export declare function parseUpdateObject(row: MutationObject<any, any, any>): ReadonlyArray<ColumnUpdateNode>;

package/dist/esm/parser/with-parser.d.ts

@@ -8,14 +8,14 @@ import { RawBuilder } from '../raw-builder/raw-builder.js';
 export declare type CommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB>) => CommonTableExpressionOutput<DB, CN>;
 export declare type RecursiveCommonTableExpression<DB, CN extends string> = (creator: QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpressionName<CN>>>) => CommonTableExpressionOutput<DB, CN>;
 export declare type QueryCreatorWithCommonTableExpression<DB, CN extends string, CTE> = QueryCreator<DB & Record<ExtractTableFromCommonTableExpressionName<CN>, ExtractRowFromCommonTableExpression<CTE>>>;
-declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
+declare type CommonTableExpressionOutput<DB, CN extends string> = SelectQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | InsertQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | UpdateQueryBuilder<DB, any, any, ExtractRowFromCommonTableExpressionName<CN>> | DeleteQueryBuilder<DB, any, ExtractRowFromCommonTableExpressionName<CN>> | RawBuilder<ExtractRowFromCommonTableExpressionName<CN>>;
 /**
  * Given a common CommonTableExpression CTE extracts the row type from it.
  *
  * For example a CTE `(db) => db.selectFrom('person').select(['id', 'first_name'])`
  * would result in `Pick<Person, 'id' | 'first_name'>`.
  */
-declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
+declare type ExtractRowFromCommonTableExpression<CTE> = CTE extends (creator: QueryCreator<any>) => infer Q ? Q extends SelectQueryBuilder<any, any, infer QO> ? QO : Q extends InsertQueryBuilder<any, any, infer QO> ? QO : Q extends UpdateQueryBuilder<any, any, any, infer QO> ? QO : Q extends DeleteQueryBuilder<any, any, infer QO> ? QO : Q extends RawBuilder<infer RO> ? RO : never : never;
 /**
  * Extracts 'person' from a string like 'person(id, first_name)'.
  */

package/dist/esm/plugin/noop-plugin.d.ts

@@ -0,0 +1,42 @@
+import { QueryResult } from '../driver/database-connection.js';
+import { UnknownRow } from '../index-nodeless.js';
+import { RootOperationNode } from '../query-compiler/query-compiler.js';
+import { KyselyPlugin, PluginTransformQueryArgs, PluginTransformResultArgs } from './kysely-plugin.js';
+export declare class NoopPlugin implements KyselyPlugin {
+    /**
+     * This is called for each query before it is executed. You can modify the query by
+     * transforming its {@link OperationNode} tree provided in {@link PluginTransformQueryArgs.node | args.node}
+     * and returning the transformed tree. You'd usually want to use an {@link OperationNodeTransformer}
+     * for this.
+     *
+     * If you need to pass some query-related data between this method and `transformResult` you
+     * can use a `WeakMap` with {@link PluginTransformQueryArgs.queryId | args.queryId} as the key:
+     *
+     * ```ts
+     * const plugin = {
+     *   data: new WeakMap<QueryId, SomeData>(),
+     *
+     *   transformQuery(args: PluginTransformQueryArgs): RootOperationNode {
+     *     this.data.set(args.queryId, something)
+     *     return args.node
+     *   },
+     *
+     *   transformResult(args: PluginTransformResultArgs): QueryResult<UnknownRow> {
+     *     const data = this.data.get(args.queryId)
+     *     return args.result
+     *   }
+     * }
+     * ```
+     *
+     * You should use a `WeakMap` instead of a `Map` or some other strong references because `transformQuery`
+     * is not always matched by a call to `transformResult` which would leave orphaned items in the map
+     * and cause a memory leak.
+     */
+    transformQuery(args: PluginTransformQueryArgs): RootOperationNode;
+    /**
+     * This method is called for each query after it has been executed. The result
+     * of the query can be accessed through {@link PluginTransformResultArgs.result | args.result}.
+     * You can modify the result and return the modifier result.
+     */
+    transformResult(args: PluginTransformResultArgs): Promise<QueryResult<UnknownRow>>;
+}

package/dist/esm/plugin/noop-plugin.js

@@ -0,0 +1,9 @@
+/// <reference types="./noop-plugin.d.ts" />
+export class NoopPlugin {
+    transformQuery(args) {
+        return args.node;
+    }
+    async transformResult(args) {
+        return args.result;
+    }
+}

package/dist/esm/query-builder/insert-query-builder.d.ts

@@ -382,7 +382,7 @@ export declare class InsertQueryBuilder<DB, TB extends keyof DB, O> implements R
      *   .onDuplicateKeyUpdate({ species: 'hamster' })
      * ```
      */
-    onDuplicateKeyUpdate(updates: MutationObject<DB, TB>): InsertQueryBuilder<DB, TB, O>;
+    onDuplicateKeyUpdate(updates: MutationObject<DB, TB, TB>): InsertQueryBuilder<DB, TB, O>;
     /**
      * Allows you to return data from modified rows.
      *

package/dist/esm/query-builder/on-conflict-builder.d.ts

@@ -386,7 +386,7 @@ export declare class OnConflictBuilder<DB, TB extends keyof DB> implements Where
      * do update set "first_name" = $3
      * ```
      */
-    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
+    doUpdateSet(updates: MutationObject<OnConflictDatabase<DB, TB>, OnConflictTables<TB>, OnConflictTables<TB>>): OnConflictUpdateBuilder<OnConflictDatabase<DB, TB>, OnConflictTables<TB>>;
 }
 export interface OnConflictBuilderProps {
     readonly onConflictNode: OnConflictNode;

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

@@ -1212,7 +1212,7 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -1221,6 +1221,8 @@ export declare class SelectQueryBuilder<DB, TB extends keyof DB, O> implements W
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as<A extends string>(alias: A): AliasedQueryBuilder<DB, TB, O, A>;

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

@@ -13,6 +13,7 @@ import { freeze } from '../util/object-utils.js';
 import { parseGroupBy } from '../parser/group-by-parser.js';
 import { parseUnion } from '../parser/union-parser.js';
 import { NoResultError } from './no-result-error.js';
+import { IdentifierNode } from '../operation-node/identifier-node.js';
 export class SelectQueryBuilder {
     #props;
     constructor(props) {
@@ -513,7 +514,7 @@ export class SelectQueryBuilder {
      * ### Examples
      *
      * ```ts
-     * await db.selectFrom('pet')
+     * const pets = await db.selectFrom('pet')
      *   .selectAll('pet')
      *   .select(
      *     (qb) => qb.selectFrom('person')
@@ -522,6 +523,8 @@ export class SelectQueryBuilder {
      *       .as('owner_first_name')
      *   )
      *   .execute()
+     *
+     * pets[0].owner_first_name
      * ```
      */
     as(alias) {
@@ -610,9 +613,6 @@ export class AliasedQueryBuilder {
     }
     toOperationNode() {
         const node = this.#queryBuilder.toOperationNode();
-        if (SelectQueryNode.is(node)) {
-            return AliasNode.create(node, this.#alias);
-        }
-        throw new Error('only select queries can be aliased');
+        return AliasNode.create(node, IdentifierNode.create(this.#alias));
     }
 }