raw expressions in schema module now need to be RawBuilder instances …

…for consistency

package.json

@@ -1,6 +1,6 @@
 {
   "name": "kysely",
-  "version": "0.13.0",
+  "version": "0.14.0",
   "description": "Type safe SQL query builder",
   "repository": {
     "type": "git",

src/operation-node/check-constraint-node.ts

@@ -17,10 +17,10 @@ export const CheckConstraintNode = freeze({
     return node.kind === 'CheckConstraintNode'
   },
 
-  create(expressionSql: string, constraintName?: string): CheckConstraintNode {
+  create(expression: RawNode, constraintName?: string): CheckConstraintNode {
     return freeze({
       kind: 'CheckConstraintNode',
-      expression: RawNode.createWithSql(expressionSql),
+      expression,
       name: constraintName ? IdentifierNode.create(constraintName) : undefined,
     })
   },

src/operation-node/create-index-node.ts

@@ -15,7 +15,8 @@ export interface CreateIndexNode extends OperationNode {
   readonly table?: TableNode
   readonly expression?: ColumnNode | ListNode | RawNode
   readonly unique?: boolean
-  // TODO(samiko): Implemented as a raw node because I'm lazy today.
+  // TODO(samiko): Do we need to add an `IndexTypeNode` for consistency?
+  //               This would then be of type `IndexTypeNode | RawNode`.
   readonly using?: RawNode
 }
 

src/operation-node/generated-node.ts

@@ -28,11 +28,11 @@ export const GeneratedNode = freeze({
     })
   },
 
-  createWithExpression(expression: string): GeneratedNode {
+  createWithExpression(expression: RawNode): GeneratedNode {
     return freeze({
       kind: 'GeneratedNode',
       always: true,
-      expression: RawNode.createWithSql(expression),
+      expression,
     })
   },
 

src/operation-node/order-by-item-node.ts

@@ -6,6 +6,8 @@ import { RawNode } from './raw-node.js'
 export interface OrderByItemNode extends OperationNode {
   readonly kind: 'OrderByItemNode'
   readonly orderBy: ReferenceExpressionNode
+  // TODO(samiko): Do we need an OrderByDirectionNode for consistency?
+  //               This would then be of type `OrderByDirectionNode | RawNode`
   readonly direction?: RawNode
 }
 

src/query-builder/on-conflict-builder.ts

@@ -96,7 +96,7 @@ export class OnConflictBuilder<DB, TB extends keyof DB>
    * Also see the {@link column}, {@link columns} and {@link constraint}
    * methods for alternative ways to specify the conflict target.
    */
-  expression(expression: RawBuilder<any>): OnConflictBuilder<DB, TB> {
+  expression(expression: AnyRawBuilder): OnConflictBuilder<DB, TB> {
     return new OnConflictBuilder({
       ...this.#props,
       onConflictNode: OnConflictNode.cloneWith(this.#props.onConflictNode, {

src/schema/alter-table-builder.ts

@@ -146,13 +146,16 @@ export class AlterTableBuilder {
 
   addCheckConstraint(
     constraintName: string,
-    checkExpression: string
+    checkExpression: AnyRawBuilder
   ): AlterTableExecutor {
     return new AlterTableExecutor({
       ...this.#props,
       alterTableNode: AlterTableNode.cloneWith(this.#props.alterTableNode, {
         addConstraint: AddConstraintNode.create(
-          CheckConstraintNode.create(checkExpression, constraintName)
+          CheckConstraintNode.create(
+            checkExpression.toOperationNode(),
+            constraintName
+          )
         ),
       }),
     })
@@ -353,17 +356,17 @@ export class AlterTableAddColumnBuilder
     })
   }
 
-  check(sql: string): AlterTableAddColumnBuilder {
+  check(expression: AnyRawBuilder): AlterTableAddColumnBuilder {
     return new AlterTableAddColumnBuilder({
       ...this.#props,
-      columnBuilder: this.#props.columnBuilder.check(sql),
+      columnBuilder: this.#props.columnBuilder.check(expression),
     })
   }
 
-  generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder {
+  generatedAlwaysAs(expression: AnyRawBuilder): AlterTableAddColumnBuilder {
     return new AlterTableAddColumnBuilder({
       ...this.#props,
-      columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+      columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(expression),
     })
   }
 
@@ -490,17 +493,17 @@ export class AlterTableModifyColumnBuilder
     })
   }
 
-  check(sql: string): AlterTableModifyColumnBuilder {
+  check(expression: AnyRawBuilder): AlterTableModifyColumnBuilder {
     return new AlterTableModifyColumnBuilder({
       ...this.#props,
-      columnBuilder: this.#props.columnBuilder.check(sql),
+      columnBuilder: this.#props.columnBuilder.check(expression),
     })
   }
 
-  generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder {
+  generatedAlwaysAs(expression: AnyRawBuilder): AlterTableModifyColumnBuilder {
     return new AlterTableModifyColumnBuilder({
       ...this.#props,
-      columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(sql),
+      columnBuilder: this.#props.columnBuilder.generatedAlwaysAs(expression),
     })
   }
 

src/schema/column-definition-builder.ts

@@ -118,11 +118,13 @@ export interface ColumnDefinitionBuilderInterface {
    * ```ts
    * db.schema
    *   .createTable('pet')
-   *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+   *   .addColumn('number_of_legs', 'integer', (col) =>
+   *     col.check(db.raw('number_of_legs < 5'))
+   *   )
    *   .execute()
    * ```
    */
-  check(sql: string): ColumnDefinitionBuilderInterface
+  check(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface
 
   /**
    * Makes the column a generated column using a `generated always as` statement.
@@ -133,12 +135,12 @@ export interface ColumnDefinitionBuilderInterface {
    * db.schema
    *   .createTable('person')
    *   .addColumn('full_name', 'varchar(255)',
-   *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+   *     (col) => col.generatedAlwaysAs(db.raw("concat(first_name, ' ', last_name)"))
    *   )
    *   .execute()
    * ```
    */
-  generatedAlwaysAs(sql: string): ColumnDefinitionBuilderInterface
+  generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilderInterface
 
   /**
    * Adds the `generated always as identity` specifier on supported dialects.
@@ -264,18 +266,20 @@ export class ColumnDefinitionBuilder
     )
   }
 
-  check(sql: string): ColumnDefinitionBuilder {
+  check(expression: AnyRawBuilder): ColumnDefinitionBuilder {
     return new ColumnDefinitionBuilder(
       ColumnDefinitionNode.cloneWith(this.#node, {
-        check: CheckConstraintNode.create(sql),
+        check: CheckConstraintNode.create(expression.toOperationNode()),
       })
     )
   }
 
-  generatedAlwaysAs(sql: string): ColumnDefinitionBuilder {
+  generatedAlwaysAs(expression: AnyRawBuilder): ColumnDefinitionBuilder {
     return new ColumnDefinitionBuilder(
       ColumnDefinitionNode.cloneWith(this.#node, {
-        generated: GeneratedNode.createWithExpression(sql),
+        generated: GeneratedNode.createWithExpression(
+          expression.toOperationNode()
+        ),
       })
     )
   }

src/schema/create-index-builder.ts

@@ -13,6 +13,7 @@ import { preventAwait } from '../util/prevent-await.js'
 import { QueryExecutor } from '../query-executor/query-executor.js'
 import { QueryId } from '../util/query-id.js'
 import { freeze } from '../util/object-utils.js'
+import { AnyRawBuilder } from '../util/type-utils.js'
 
 export class CreateIndexBuilder implements OperationNodeSource, Compilable {
   readonly #props: CreateIndexBuilderProps
@@ -82,15 +83,15 @@ export class CreateIndexBuilder implements OperationNodeSource, Compilable {
    * await db.schema
    *   .createIndex('person_first_name_index')
    *   .on('person')
-   *   .expression('first_name COLLATE "fi_FI"')
+   *   .expression(db.raw('first_name COLLATE "fi_FI"'))
    *   .execute()
    * ```
    */
-  expression(expression: string): CreateIndexBuilder {
+  expression(expression: AnyRawBuilder): CreateIndexBuilder {
     return new CreateIndexBuilder({
       ...this.#props,
       createIndexNode: CreateIndexNode.cloneWith(this.#props.createIndexNode, {
-        expression: RawNode.createWithSql(expression),
+        expression: expression.toOperationNode(),
       }),
     })
   }

src/schema/create-table-builder.ts

@@ -22,6 +22,7 @@ import {
 import { PrimaryConstraintNode } from '../operation-node/primary-constraint-node.js'
 import { UniqueConstraintNode } from '../operation-node/unique-constraint-node.js'
 import { CheckConstraintNode } from '../operation-node/check-constraint-node.js'
+import { AnyRawBuilder } from '../util/type-utils.js'
 
 /**
  * This builder can be used to create a `create table` query.
@@ -202,18 +203,21 @@ export class CreateTableBuilder<TB extends string, C extends string = never>
    * ### Examples
    *
    * ```ts
-   * addCheckConstraint('check_legs', 'number_of_legs < 5')
+   * addCheckConstraint('check_legs', db.raw('number_of_legs < 5'))
    * ```
    */
   addCheckConstraint(
     constraintName: string,
-    checkExpression: string
+    checkExpression: AnyRawBuilder
   ): CreateTableBuilder<TB, C> {
     return new CreateTableBuilder({
       ...this.#props,
       createTableNode: CreateTableNode.cloneWithConstraint(
         this.#props.createTableNode,
-        CheckConstraintNode.create(checkExpression, constraintName)
+        CheckConstraintNode.create(
+          checkExpression.toOperationNode(),
+          constraintName
+        )
       ),
     })
   }

test/src/schema.test.ts

@@ -42,7 +42,7 @@ for (const dialect of BUILT_IN_DIALECTS) {
                 .references('test.a')
                 .onDelete('cascade')
                 .onUpdate('restrict')
-                .check('b < a')
+                .check(ctx.db.raw('b < a'))
             )
             .addColumn('c', 'varchar')
             .addColumn('d', 'varchar(10)')
@@ -63,7 +63,7 @@ for (const dialect of BUILT_IN_DIALECTS) {
             .addColumn('q', 'int4')
             .addColumn('r', 'int8')
             .addColumn('s', 'double precision', (col) =>
-              col.generatedAlwaysAs('f + g').stored().notNull()
+              col.generatedAlwaysAs(ctx.db.raw('f + g')).stored().notNull()
             )
 
           testSql(builder, dialect, {
@@ -124,7 +124,7 @@ for (const dialect of BUILT_IN_DIALECTS) {
             .addColumn('n', 'datetime')
             .addColumn('o', 'timestamp')
             .addColumn('p', 'double precision', (col) =>
-              col.generatedAlwaysAs('e + f').stored().notNull()
+              col.generatedAlwaysAs(ctx.db.raw('e + f')).stored().notNull()
             )
 
           testSql(builder, dialect, {
@@ -166,7 +166,7 @@ for (const dialect of BUILT_IN_DIALECTS) {
                 .references('test.a')
                 .onDelete('cascade')
                 .onUpdate('restrict')
-                .check('b < a')
+                .check(ctx.db.raw('b < a'))
             )
             .addColumn('c', 'varchar')
             .addColumn('d', 'varchar(10)')
@@ -184,7 +184,7 @@ for (const dialect of BUILT_IN_DIALECTS) {
             .addColumn('p', 'int4')
             .addColumn('q', 'int8')
             .addColumn('r', 'double precision', (col) =>
-              col.generatedAlwaysAs('f + g').stored().notNull()
+              col.generatedAlwaysAs(ctx.db.raw('f + g')).stored().notNull()
             )
             .addColumn('s', 'blob')
 
@@ -255,8 +255,8 @@ for (const dialect of BUILT_IN_DIALECTS) {
           .addColumn('a', 'integer')
           .addColumn('b', 'integer')
           .addColumn('c', 'integer')
-          .addCheckConstraint('check_a', 'a > 1')
-          .addCheckConstraint('check_b', 'b < c')
+          .addCheckConstraint('check_a', ctx.db.raw('a > 1'))
+          .addCheckConstraint('check_b', ctx.db.raw('b < c'))
 
         testSql(builder, dialect, {
           postgres: {
@@ -673,7 +673,7 @@ for (const dialect of BUILT_IN_DIALECTS) {
         const builder = ctx.db.schema
           .createIndex('test_first_name_index')
           .on('test')
-          .expression(`first_name < 'Sami'`)
+          .expression(ctx.db.raw(`first_name < 'Sami'`))
 
         testSql(builder, dialect, {
           postgres: {
@@ -1349,7 +1349,10 @@ for (const dialect of BUILT_IN_DIALECTS) {
           it('should add a check constraint', async () => {
             const builder = ctx.db.schema
               .alterTable('test')
-              .addCheckConstraint('some_constraint', 'integer_col > 0')
+              .addCheckConstraint(
+                'some_constraint',
+                ctx.db.raw('integer_col > 0')
+              )
 
             testSql(builder, dialect, {
               postgres: {