kysely 0.11.3 → 0.12.2

package/dist/esm/kysely.d.ts

@@ -17,7 +17,8 @@ import { LogConfig } from './util/log.js';
  * You should create one instance of `Kysely` per database using the {@link Kysely}
  * constructor. Each `Kysely` instance maintains it's own connection pool.
  *
- * @example
+ * ### Examples
+ *
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
@@ -31,7 +32,7 @@ import { LogConfig } from './util/log.js';
  *   id: number
  *   owner_id: number
  *   name: string
- *   species 'cat' | 'dog'
+ *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
@@ -78,10 +79,11 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * A value to be used in place of columns that are generated in the database
      * when inserting rows.
      *
-     * @example
+     * ### Examples
+     *
      * In this example the `Person` table has non-null properties `id` and `created_at`
      * which are both automatically genereted by the database. Since their types are
-     * `number` and `string` respectively instead of `number | null` and `string | null`
+     * `number` and `string` respectively instead of `number | null` and `string | null`
      * the `values` method requires you to give a value for them. the `generated`
      * placeholder can be used in these cases.
      *
@@ -136,12 +138,13 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * transaction. If the function throws, the transaction is rolled back. Otherwise
      * the transaction is committed.
      *
-     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
      * method gets the transaction object as its only argument. The transaction is
      * of type {@link Transaction} which inherits {@link Kysely}. Any query
      * started through the transaction object is executed inside the transaction.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -167,8 +170,7 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * })
      * ```
      *
-     * @example
-     * Setting the isolation level.
+     * Setting the isolation level:
      *
      * ```ts
      * await db
@@ -183,7 +185,8 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
     /**
      * Provides a kysely instance bound to a single database connection.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db
      *   .connection()
@@ -204,6 +207,38 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
      * Returns a copy of this Kysely instance without any plugins.
      */
     withoutPlugins(): Kysely<DB>;
+    /**
+     * Returns a copy of this Kysely instance with tables added to its
+     * database type.
+     *
+     * This method only modifies the types and doesn't affect any of the
+     * executed queries in any way.
+     *
+     * ### Examples
+     *
+     * The following example adds and uses a temporary table:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('temp_table')
+     *   .temporary()
+     *   .addColumn('some_column', 'integer')
+     *   .execute()
+     *
+     * const tempDb = db.withTables<{
+     *   temp_table: {
+     *     some_column: number
+     *   }
+     * }>()
+     *
+     * await tempDb
+     *   .insertInto('temp_table')
+     *   .values({ some_column: 100 })
+     *   .execute()
+     * ```
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): Kysely<DB & T>;
     /**
      * Releases all resources and disconnects from the database.
      *
@@ -218,10 +253,134 @@ export declare class Kysely<DB> extends QueryCreator<DB> {
     get isTransaction(): boolean;
 }
 export declare class Transaction<DB> extends Kysely<DB> {
+    #private;
+    constructor(props: KyselyProps);
+    /**
+     * Returns true if this `Kysely` instance is a transaction.
+     *
+     * You can also use `db instanceof Transaction`.
+     */
     get isTransaction(): true;
+    /**
+     * Returns the {@link MigrationModule} module for managing and running migrations.
+     */
     get migration(): MigrationModule;
+    /**
+     * Creates a {@link TransactionBuilder} that can be used to run queries inside a transaction.
+     *
+     * The returned {@link TransactionBuilder} can be used to configure the transaction. The
+     * {@link TransactionBuilder.execute} method can then be called to run the transaction.
+     * {@link TransactionBuilder.execute} takes a function that is run inside the
+     * transaction. If the function throws, the transaction is rolled back. Otherwise
+     * the transaction is committed.
+     *
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * method gets the transaction object as its only argument. The transaction is
+     * of type {@link Transaction} which inherits {@link Kysely}. Any query
+     * started through the transaction object is executed inside the transaction.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * const catto = await db.transaction().execute(async (trx) => {
+     *   const jennifer = await trx.insertInto('person')
+     *     .values({
+     *       id: db.generated,
+     *       first_name: 'Jennifer',
+     *       last_name: 'Aniston',
+     *     })
+     *     .returning('id')
+     *     .executeTakeFirstOrThrow()
+     *
+     *   await someFunction(trx, jennifer)
+     *
+     *   return await trx.insertInto('pet')
+     *     .values({
+     *       id: db.generated,
+     *       user_id: jennifer.id,
+     *       name: 'Catto',
+     *       species: 'cat'
+     *     })
+     *     .returning('*')
+     *     .executeTakeFirst()
+     * })
+     * ```
+     *
+     * Setting the isolation level:
+     *
+     * ```ts
+     * await db
+     *   .transaction()
+     *   .setIsolationLevel('serializable')
+     *   .execute(async (trx) => {
+     *     await doStuff(trx)
+     *   })
+     * ```
+     */
     transaction(): TransactionBuilder<DB>;
+    /**
+     * Provides a kysely instance bound to a single database connection.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * await db
+     *   .connection()
+     *   .execute(async (db) => {
+     *     // `db` is an instance of `Kysely` that's bound to a single
+     *     // database connection. All queries executed through `db` use
+     *     // the same connection.
+     *     await doStuff(db)
+     *   })
+     * ```
+     */
+    connection(): ConnectionBuilder<DB>;
+    /**
+     * Releases all resources and disconnects from the database.
+     *
+     * You need to call this when you are done using the `Kysely` instance.
+     */
     destroy(): Promise<void>;
+    /**
+     * Returns a copy of this Kysely instance with the given plugin installed.
+     */
+    withPlugin(plugin: KyselyPlugin): Transaction<DB>;
+    /**
+     * Returns a copy of this Kysely instance without any plugins.
+     */
+    withoutPlugins(): Transaction<DB>;
+    /**
+     * Returns a copy of this Kysely instance with tables added to its
+     * database type.
+     *
+     * This method only modifies the types and doesn't affect any of the
+     * executed queries in any way.
+     *
+     * ### Examples
+     *
+     * The following example adds and uses a temporary table:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('temp_table')
+     *   .temporary()
+     *   .addColumn('some_column', 'integer')
+     *   .execute()
+     *
+     * const tempDb = db.withTables<{
+     *   temp_table: {
+     *     some_column: number
+     *   }
+     * }>()
+     *
+     * await tempDb
+     *   .insertInto('temp_table')
+     *   .values({ some_column: 100 })
+     *   .execute()
+     * ```
+     */
+    withTables<T extends Record<string, Record<string, any>>>(): Transaction<DB & T>;
 }
 export interface KyselyProps {
     readonly config: KyselyConfig;
@@ -240,7 +399,8 @@ export interface KyselyConfig {
      * Currently there's only two levels: `query` and `error`.
      * This will be expanded based on user feedback later.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const db = new Kysely<Database>({
      *   dialect: new PostgresDialect(postgresConfig),
@@ -248,7 +408,6 @@ export interface KyselyConfig {
      * })
      * ```
      *
-     * @example
      * ```ts
      * const db = new Kysely<Database>({
      *   dialect: new PostgresDialect(postgresConfig),

package/dist/esm/kysely.js

@@ -19,7 +19,8 @@ import { Log } from './util/log.js';
  * You should create one instance of `Kysely` per database using the {@link Kysely}
  * constructor. Each `Kysely` instance maintains it's own connection pool.
  *
- * @example
+ * ### Examples
+ *
  * This example assumes your database has tables `person` and `pet`:
  *
  * ```ts
@@ -33,7 +34,7 @@ import { Log } from './util/log.js';
  *   id: number
  *   owner_id: number
  *   name: string
- *   species 'cat' | 'dog'
+ *   species 'cat' | 'dog'
  * }
  *
  * interface Database {
@@ -111,10 +112,11 @@ export class Kysely extends QueryCreator {
      * A value to be used in place of columns that are generated in the database
      * when inserting rows.
      *
-     * @example
+     * ### Examples
+     *
      * In this example the `Person` table has non-null properties `id` and `created_at`
      * which are both automatically genereted by the database. Since their types are
-     * `number` and `string` respectively instead of `number | null` and `string | null`
+     * `number` and `string` respectively instead of `number | null` and `string | null`
      * the `values` method requires you to give a value for them. the `generated`
      * placeholder can be used in these cases.
      *
@@ -173,12 +175,13 @@ export class Kysely extends QueryCreator {
      * transaction. If the function throws, the transaction is rolled back. Otherwise
      * the transaction is committed.
      *
-     * The callback function passed to the {@link TransactionBuilder.execute | execute}
+     * The callback function passed to the {@link TransactionBuilder.execute | execute}
      * method gets the transaction object as its only argument. The transaction is
      * of type {@link Transaction} which inherits {@link Kysely}. Any query
      * started through the transaction object is executed inside the transaction.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * const catto = await db.transaction().execute(async (trx) => {
      *   const jennifer = await trx.insertInto('person')
@@ -204,8 +207,7 @@ export class Kysely extends QueryCreator {
      * })
      * ```
      *
-     * @example
-     * Setting the isolation level.
+     * Setting the isolation level:
      *
      * ```ts
      * await db
@@ -222,7 +224,8 @@ export class Kysely extends QueryCreator {
     /**
      * Provides a kysely instance bound to a single database connection.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db
      *   .connection()
@@ -255,6 +258,40 @@ export class Kysely extends QueryCreator {
             executor: this.#props.executor.withoutPlugins(),
         });
     }
+    /**
+     * Returns a copy of this Kysely instance with tables added to its
+     * database type.
+     *
+     * This method only modifies the types and doesn't affect any of the
+     * executed queries in any way.
+     *
+     * ### Examples
+     *
+     * The following example adds and uses a temporary table:
+     *
+     * @example
+     * ```ts
+     * await db.schema
+     *   .createTable('temp_table')
+     *   .temporary()
+     *   .addColumn('some_column', 'integer')
+     *   .execute()
+     *
+     * const tempDb = db.withTables<{
+     *   temp_table: {
+     *     some_column: number
+     *   }
+     * }>()
+     *
+     * await tempDb
+     *   .insertInto('temp_table')
+     *   .values({ some_column: 100 })
+     *   .execute()
+     * ```
+     */
+    withTables() {
+        return new Kysely({ ...this.#props });
+    }
     /**
      * Releases all resources and disconnects from the database.
      *
@@ -273,6 +310,11 @@ export class Kysely extends QueryCreator {
     }
 }
 export class Transaction extends Kysely {
+    #props;
+    constructor(props) {
+        super(props);
+        this.#props = props;
+    }
     // The return type is `true` instead of `boolean` to make Kysely<DB>
     // unassignable to Transaction<DB> while allowing assignment the
     // other way around.
@@ -285,9 +327,27 @@ export class Transaction extends Kysely {
     transaction() {
         throw new Error('calling the transaction method for a Transaction is not supported');
     }
+    connection() {
+        throw new Error('calling the connection method for a Transaction is not supported');
+    }
     async destroy() {
         throw new Error('calling the destroy method for a Transaction is not supported');
     }
+    withPlugin(plugin) {
+        return new Transaction({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
+    withoutPlugins() {
+        return new Transaction({
+            ...this.#props,
+            executor: this.#props.executor.withoutPlugins(),
+        });
+    }
+    withTables() {
+        return new Transaction({ ...this.#props });
+    }
 }
 export function isKyselyProps(obj) {
     return (isObject(obj) &&

package/dist/esm/migration/migration.d.ts

@@ -18,7 +18,8 @@ export declare class MigrationModule {
      * list of executed migrations doesn't match the list of possible migrations, and error
      * is thrown.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.migration.migrateToLatest(
      *   path.join(__dirname, 'migrations')
@@ -30,7 +31,6 @@ export declare class MigrationModule {
      * the migrations is determined based on the alphabetical order of the keys in the record.
      * This can be useful if you are using a bundler like webpack or esbuild.
      *
-     * @example
      * ```ts
      * await db.migration.migrateToLatest({
      *   migration1: {

package/dist/esm/operation-node/common-table-expression-name-node.d.ts

@@ -0,0 +1,15 @@
+import { ColumnNode } from './column-node.js';
+import { OperationNode } from './operation-node.js';
+import { TableNode } from './table-node.js';
+export interface CommonTableExpressionNameNode extends OperationNode {
+    readonly kind: 'CommonTableExpressionNameNode';
+    readonly table: TableNode;
+    readonly columns?: ReadonlyArray<ColumnNode>;
+}
+/**
+ * @internal
+ */
+export declare const CommonTableExpressionNameNode: Readonly<{
+    is(node: OperationNode): node is CommonTableExpressionNameNode;
+    create(tableName: string, columnNames?: readonly string[] | undefined): CommonTableExpressionNameNode;
+}>;

package/dist/esm/operation-node/common-table-expression-name-node.js

@@ -0,0 +1,20 @@
+import { freeze } from '../util/object-utils.js';
+import { ColumnNode } from './column-node.js';
+import { TableNode } from './table-node.js';
+/**
+ * @internal
+ */
+export const CommonTableExpressionNameNode = freeze({
+    is(node) {
+        return node.kind === 'CommonTableExpressionNameNode';
+    },
+    create(tableName, columnNames) {
+        return freeze({
+            kind: 'CommonTableExpressionNameNode',
+            table: TableNode.create(tableName),
+            columns: columnNames
+                ? freeze(columnNames.map(ColumnNode.create))
+                : undefined,
+        });
+    },
+});

package/dist/esm/operation-node/common-table-expression-node.d.ts

@@ -1,10 +1,10 @@
-import { IdentifierNode } from './identifier-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { OperationNode } from './operation-node.js';
 import { QueryNode } from './query-node.js';
 import { RawNode } from './raw-node.js';
 export interface CommonTableExpressionNode extends OperationNode {
     readonly kind: 'CommonTableExpressionNode';
-    readonly name: IdentifierNode;
+    readonly name: CommonTableExpressionNameNode;
     readonly expression: QueryNode | RawNode;
 }
 /**
@@ -12,5 +12,5 @@ export interface CommonTableExpressionNode extends OperationNode {
  */
 export declare const CommonTableExpressionNode: Readonly<{
     is(node: OperationNode): node is CommonTableExpressionNode;
-    create(name: IdentifierNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
+    create(name: CommonTableExpressionNameNode, expression: QueryNode | RawNode): CommonTableExpressionNode;
 }>;

package/dist/esm/operation-node/create-table-node.d.ts

@@ -2,12 +2,16 @@ import { OperationNode } from './operation-node.js';
 import { TableNode } from './table-node.js';
 import { ConstraintNode } from './constraint-node.js';
 import { ColumnDefinitionNode } from './column-definition-node.js';
+export declare type OnCommitAction = 'preserve rows' | 'delete rows' | 'drop';
+export declare type CreateTableNodeParams = Omit<CreateTableNode, 'kind' | 'table' | 'columns' | 'constraints'>;
 export interface CreateTableNode extends OperationNode {
     readonly kind: 'CreateTableNode';
     readonly table: TableNode;
     readonly columns: ReadonlyArray<ColumnDefinitionNode>;
-    readonly ifNotExists?: boolean;
     readonly constraints?: ReadonlyArray<ConstraintNode>;
+    readonly temporary?: boolean;
+    readonly ifNotExists?: boolean;
+    readonly onCommit?: OnCommitAction;
 }
 /**
  * @internal
@@ -16,6 +20,6 @@ export declare const CreateTableNode: Readonly<{
     is(node: OperationNode): node is CreateTableNode;
     create(table: TableNode): CreateTableNode;
     cloneWithColumn(createTable: CreateTableNode, column: ColumnDefinitionNode): CreateTableNode;
-    cloneWithIfNotExists(createTable: CreateTableNode, ifNotExists: boolean): CreateTableNode;
     cloneWithConstraint(createTable: CreateTableNode, constraint: ConstraintNode): CreateTableNode;
+    cloneWith(createTable: CreateTableNode, params: CreateTableNodeParams): CreateTableNode;
 }>;

package/dist/esm/operation-node/create-table-node.js

@@ -19,12 +19,6 @@ export const CreateTableNode = freeze({
             columns: freeze([...createTable.columns, column]),
         });
     },
-    cloneWithIfNotExists(createTable, ifNotExists) {
-        return freeze({
-            ...createTable,
-            ifNotExists,
-        });
-    },
     cloneWithConstraint(createTable, constraint) {
         return freeze({
             ...createTable,
@@ -33,4 +27,10 @@ export const CreateTableNode = freeze({
                 : freeze([constraint]),
         });
     },
+    cloneWith(createTable, params) {
+        return freeze({
+            ...createTable,
+            ...params,
+        });
+    },
 });

package/dist/esm/operation-node/create-view-node.d.ts

@@ -7,6 +7,7 @@ export declare type CreateViewNodeParams = Omit<Partial<CreateViewNode>, 'kind'
 export interface CreateViewNode extends OperationNode {
     readonly kind: 'CreateViewNode';
     readonly name: IdentifierNode;
+    readonly temporary?: boolean;
     readonly materialized?: boolean;
     readonly orReplace?: boolean;
     readonly ifNotExists?: boolean;

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

@@ -2,18 +2,18 @@ import { ColumnNode } from './column-node.js';
 import { OnConflictNode } from './on-conflict-node.js';
 import { OnDuplicateKeyNode } from './on-duplicate-key-node.js';
 import { OperationNode } from './operation-node.js';
-import { PrimitiveValueListNode } from './primitive-value-list-node.js';
+import { RawNode } from './raw-node.js';
 import { ReturningNode } from './returning-node.js';
+import { SelectQueryNode } from './select-query-node.js';
 import { TableNode } from './table-node.js';
-import { ValueListNode } from './value-list-node.js';
+import { ValuesNode } from './values-node.js';
 import { WithNode } from './with-node.js';
-export declare type InsertValuesNode = ValueListNode | PrimitiveValueListNode;
 export declare type InsertQueryNodeProps = Omit<InsertQueryNode, 'kind' | 'into'>;
 export interface InsertQueryNode extends OperationNode {
     readonly kind: 'InsertQueryNode';
     readonly into: TableNode;
     readonly columns?: ReadonlyArray<ColumnNode>;
-    readonly values?: ReadonlyArray<InsertValuesNode>;
+    readonly values?: ValuesNode | SelectQueryNode | RawNode;
     readonly returning?: ReturningNode;
     readonly onConflict?: OnConflictNode;
     readonly onDuplicateKey?: OnDuplicateKeyNode;

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

@@ -44,6 +44,7 @@ import { ReferencesNode } from './references-node.js';
 import { CheckConstraintNode } from './check-constraint-node.js';
 import { WithNode } from './with-node.js';
 import { CommonTableExpressionNode } from './common-table-expression-node.js';
+import { CommonTableExpressionNameNode } from './common-table-expression-name-node.js';
 import { HavingNode } from './having-node.js';
 import { CreateSchemaNode } from './create-schema-node.js';
 import { DropSchemaNode } from './drop-schema-node.js';
@@ -63,6 +64,7 @@ import { DropViewNode } from './drop-view-node.js';
 import { GeneratedAlwaysAsNode } from './generated-always-as-node.js';
 import { DefaultValueNode } from './default-value-node.js';
 import { OnNode } from './on-node.js';
+import { ValuesNode } from './values-node.js';
 /**
  * Transforms an operation node tree into another one.
  *
@@ -113,6 +115,7 @@ export declare class OperationNodeTransformer {
     protected transformRaw(node: RawNode): RawNode;
     protected transformWhere(node: WhereNode): WhereNode;
     protected transformInsertQuery(node: InsertQueryNode): InsertQueryNode;
+    protected transformValues(node: ValuesNode): ValuesNode;
     protected transformDeleteQuery(node: DeleteQueryNode): DeleteQueryNode;
     protected transformReturning(node: ReturningNode): ReturningNode;
     protected transformCreateTable(node: CreateTableNode): CreateTableNode;
@@ -140,6 +143,7 @@ export declare class OperationNodeTransformer {
     protected transformCheckConstraint(node: CheckConstraintNode): CheckConstraintNode;
     protected transformWith(node: WithNode): WithNode;
     protected transformCommonTableExpression(node: CommonTableExpressionNode): CommonTableExpressionNode;
+    protected transformCommonTableExpressionName(node: CommonTableExpressionNameNode): CommonTableExpressionNameNode;
     protected transformHaving(node: HavingNode): HavingNode;
     protected transformCreateSchema(node: CreateSchemaNode): CreateSchemaNode;
     protected transformDropSchema(node: DropSchemaNode): DropSchemaNode;

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

@@ -78,6 +78,7 @@ export class OperationNodeTransformer {
         CheckConstraintNode: this.transformCheckConstraint.bind(this),
         WithNode: this.transformWith.bind(this),
         CommonTableExpressionNode: this.transformCommonTableExpression.bind(this),
+        CommonTableExpressionNameNode: this.transformCommonTableExpressionName.bind(this),
         HavingNode: this.transformHaving.bind(this),
         CreateSchemaNode: this.transformCreateSchema.bind(this),
         DropSchemaNode: this.transformDropSchema.bind(this),
@@ -95,6 +96,7 @@ export class OperationNodeTransformer {
         GeneratedAlwaysAsNode: this.transformGeneratedAlwaysAs.bind(this),
         DefaultValueNode: this.transformDefaultValue.bind(this),
         OnNode: this.transformOn.bind(this),
+        ValuesNode: this.transformValues.bind(this),
     });
     transformNode = (node) => {
         if (!node) {
@@ -229,7 +231,7 @@ export class OperationNodeTransformer {
             kind: 'InsertQueryNode',
             into: this.transformNode(node.into),
             columns: this.transformNodeList(node.columns),
-            values: this.transformNodeList(node.values),
+            values: this.transformNode(node.values),
             returning: this.transformNode(node.returning),
             onConflict: this.transformNode(node.onConflict),
             onDuplicateKey: this.transformNode(node.onDuplicateKey),
@@ -237,6 +239,12 @@ export class OperationNodeTransformer {
             ignore: node.ignore,
         };
     }
+    transformValues(node) {
+        return {
+            kind: 'ValuesNode',
+            values: this.transformNodeList(node.values),
+        };
+    }
     transformDeleteQuery(node) {
         return {
             kind: 'DeleteQueryNode',
@@ -259,7 +267,9 @@ export class OperationNodeTransformer {
             table: this.transformNode(node.table),
             columns: this.transformNodeList(node.columns),
             constraints: this.transformNodeList(node.constraints),
+            temporary: node.temporary,
             ifNotExists: node.ifNotExists,
+            onCommit: node.onCommit,
         };
     }
     transformColumnDefinition(node) {
@@ -435,6 +445,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'WithNode',
             expressions: this.transformNodeList(node.expressions),
+            recursive: node.recursive,
         };
     }
     transformCommonTableExpression(node) {
@@ -444,6 +455,13 @@ export class OperationNodeTransformer {
             expression: this.transformNode(node.expression),
         };
     }
+    transformCommonTableExpressionName(node) {
+        return {
+            kind: 'CommonTableExpressionNameNode',
+            table: this.transformNode(node.table),
+            columns: this.transformNodeList(node.columns),
+        };
+    }
     transformHaving(node) {
         return {
             kind: 'HavingNode',
@@ -525,6 +543,7 @@ export class OperationNodeTransformer {
         return {
             kind: 'CreateViewNode',
             name: this.transformNode(node.name),
+            temporary: node.temporary,
             orReplace: node.orReplace,
             ifNotExists: node.ifNotExists,
             materialized: node.materialized,