kysely 0.11.4 → 0.13.0

package/dist/cjs/query-executor/noop-query-executor.d.ts

@@ -8,10 +8,29 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
  * other needed things to actually execute queries.
  */
 export declare class NoopQueryExecutor extends QueryExecutor {
+    /**
+     * Compiles the transformed query into SQL. You usually want to pass
+     * the output of {@link transformQuery} into this method but you can
+     * compile any query using this method.
+     */
     compileQuery(): CompiledQuery;
     protected executeQueryImpl<R>(): Promise<QueryResult<R>>;
+    /**
+     * Returns a copy of this executor with a new connection provider.
+     */
     withConnectionProvider(): QueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * last plugin.
+     */
     withPlugin(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor with a plugin added as the
+     * first plugin.
+     */
     withPluginAtFront(plugin: KyselyPlugin): NoopQueryExecutor;
+    /**
+     * Returns a copy of this executor without any plugins.
+     */
     withoutPlugins(): QueryExecutor;
 }

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

@@ -6,7 +6,7 @@ import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 import { QueryId } from '../util/query-id.js';
 /**
  * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link QueryBuilder}
+ * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */

package/dist/cjs/query-executor/query-executor.js

@@ -4,7 +4,7 @@ exports.QueryExecutor = void 0;
 const object_utils_js_1 = require("../util/object-utils.js");
 /**
  * This class abstracts away the details of how to compile a query into SQL
- * and execute it. Instead of passing around all those details, {@link QueryBuilder}
+ * and execute it. Instead of passing around all those details, {@link SelectQueryBuilder}
  * and other classes that execute queries can just pass around and instance of
  * `QueryExecutor`.
  */

package/dist/cjs/raw-builder/raw-builder.d.ts

@@ -5,6 +5,7 @@ import { RawNode } from '../operation-node/raw-node.js';
 import { CompiledQuery } from '../query-compiler/compiled-query.js';
 import { QueryExecutor } from '../query-executor/query-executor.js';
 import { QueryId } from '../util/query-id.js';
+import { KyselyPlugin } from '../plugin/kysely-plugin.js';
 export declare class RawBuilder<O = unknown> implements OperationNodeSource {
     #private;
     constructor(props: RawBuilderProps);
@@ -16,6 +17,7 @@ export declare class RawBuilder<O = unknown> implements OperationNodeSource {
      * of this `RawBuilder` with a new output type.
      */
     castTo<T>(): RawBuilder<T>;
+    withPlugin(plugin: KyselyPlugin): RawBuilder<O>;
     toOperationNode(): RawNode;
     compile(): CompiledQuery;
     execute(): Promise<QueryResult<O>>;

package/dist/cjs/raw-builder/raw-builder.js

@@ -27,6 +27,12 @@ class RawBuilder {
             ...this.#props,
         });
     }
+    withPlugin(plugin) {
+        return new RawBuilder({
+            ...this.#props,
+            executor: this.#props.executor.withPlugin(plugin),
+        });
+    }
     toOperationNode() {
         const parameterPlaceholderRegex = /(\?\??)/g;
         const sql = this.#props.sql;
@@ -44,7 +50,7 @@ class RawBuilder {
             if (match.index > 0 && sql[match.index - 1] === '\\') {
                 continue;
             }
-            sqlFragments.push(sql.slice(sqlIdx, match.index).replaceAll('\\?', '?'));
+            sqlFragments.push(sql.slice(sqlIdx, match.index).replace(/\\\?/g, '?'));
             argNodes.push(parseRawArg(str, parameters[paramIdx]));
             sqlIdx = match.index + str.length;
             ++paramIdx;

package/dist/cjs/schema/alter-table-builder.d.ts

@@ -60,19 +60,133 @@ export declare class AlterTableExecutor implements OperationNodeSource, Compilab
 }
 export interface AlterTableExecutorProps extends AlterTableBuilderProps {
 }
-export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableAddColumnBuilder>, OperationNodeSource, Compilable {
+export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableAddColumnBuilderProps);
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement(): AlterTableAddColumnBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref: string): AlterTableAddColumnBuilder;
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onDelete: OnModifyForeignAction): AlterTableAddColumnBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): AlterTableAddColumnBuilder;
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     */
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableAddColumnBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .execute()
+     * ```
+     */
     check(sql: string): AlterTableAddColumnBuilder;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(sql: string): AlterTableAddColumnBuilder;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored(): AlterTableAddColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;
@@ -81,19 +195,133 @@ export declare class AlterTableAddColumnBuilder implements ColumnDefinitionBuild
 export interface AlterTableAddColumnBuilderProps extends AlterTableBuilderProps {
     readonly columnBuilder: ColumnDefinitionBuilder;
 }
-export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface<AlterTableModifyColumnBuilder>, OperationNodeSource, Compilable {
+export declare class AlterTableModifyColumnBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource, Compilable {
     #private;
     constructor(props: AlterTableModifyColumnBuilderProps);
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement(): AlterTableModifyColumnBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref: string): AlterTableModifyColumnBuilder;
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onUpdate: OnModifyForeignAction): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     */
     defaultTo(value: PrimitiveValue | AnyRawBuilder): AlterTableModifyColumnBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .execute()
+     * ```
+     */
     check(sql: string): AlterTableModifyColumnBuilder;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(sql: string): AlterTableModifyColumnBuilder;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored(): AlterTableModifyColumnBuilder;
     toOperationNode(): AlterTableNode;
     compile(): CompiledQuery;

package/dist/cjs/schema/alter-table-builder.js

@@ -232,6 +232,12 @@ class AlterTableAddColumnBuilder {
             columnBuilder: this.#props.columnBuilder.notNull(),
         });
     }
+    unsigned() {
+        return new AlterTableAddColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.unsigned(),
+        });
+    }
     defaultTo(value) {
         return new AlterTableAddColumnBuilder({
             ...this.#props,
@@ -316,6 +322,12 @@ class AlterTableModifyColumnBuilder {
             columnBuilder: this.#props.columnBuilder.notNull(),
         });
     }
+    unsigned() {
+        return new AlterTableModifyColumnBuilder({
+            ...this.#props,
+            columnBuilder: this.#props.columnBuilder.unsigned(),
+        });
+    }
     defaultTo(value) {
         return new AlterTableModifyColumnBuilder({
             ...this.#props,

package/dist/cjs/schema/column-definition-builder.d.ts

@@ -4,7 +4,7 @@ import { PrimitiveValue } from '../util/object-utils.js';
 import { ColumnDefinitionNode } from '../operation-node/column-definition-node.js';
 import { AnyRawBuilder } from '../util/type-utils.js';
 import { DefaultValueExpression } from '../parser/default-value-parser.js';
-export interface ColumnDefinitionBuilderInterface<R> {
+export interface ColumnDefinitionBuilderInterface {
     /**
      * Adds `auto_increment` or `autoincrement` to the column definition
      * depending on the dialect.
@@ -12,14 +12,14 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * Some dialects like PostgreSQL don't support this. On PostgreSQL
      * you can use the `serial` or `bigserial` data type instead.
      */
-    autoIncrement(): R;
+    autoIncrement(): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column the primary key.
      *
      * If you want to specify a composite primary key use the
      * {@link TableBuilder.addPrimaryKeyConstraint} method.
      */
-    primaryKey(): R;
+    primaryKey(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a foreign key constraint for the column.
      *
@@ -27,12 +27,13 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id')
      * ```
      */
-    references(ref: string): R;
+    references(ref: string): ColumnDefinitionBuilderInterface;
     /**
      * Adds an `on delete` constraint for the foreign key column.
      *
@@ -40,33 +41,42 @@ export interface ColumnDefinitionBuilderInterface<R> {
      * column definition (like MySQL 5) you need to call the table level
      * {@link TableBuilder.addForeignKeyConstraint} method instead.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id').onDelete('cascade')
      * ```
      */
-    onDelete(onDelete: OnModifyForeignAction): R;
+    onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
     /**
      * Adds an `on update` constraint for the foreign key column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * col.references('person.id').onUpdate('cascade')
      * ```
      */
-    onUpdate(onUpdate: OnModifyForeignAction): R;
+    onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilderInterface;
     /**
      * Adds a unique constraint for the column.
      */
-    unique(): R;
+    unique(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a `not null` constraint for the column.
      */
-    notNull(): R;
+    notNull(): ColumnDefinitionBuilderInterface;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): ColumnDefinitionBuilderInterface;
     /**
      * Adds a default value constraint for the column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('pet')
@@ -74,11 +84,12 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    defaultTo(value: PrimitiveValue | AnyRawBuilder): R;
+    defaultTo(value: PrimitiveValue | AnyRawBuilder): ColumnDefinitionBuilderInterface;
     /**
      * Adds a check constraint for the column.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('pet')
@@ -86,11 +97,12 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    check(sql: string): R;
+    check(sql: string): ColumnDefinitionBuilderInterface;
     /**
      * Makes the column a generated column using a `generated always as` statement.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('person')
@@ -100,12 +112,13 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    generatedAlwaysAs(sql: string): R;
+    generatedAlwaysAs(sql: string): ColumnDefinitionBuilderInterface;
     /**
      * Makes a generated column stored instead of virtual. This method can only
      * be used with {@link generatedAlwaysAs}
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * db.schema
      *   .createTable('person')
@@ -116,21 +129,135 @@ export interface ColumnDefinitionBuilderInterface<R> {
      *   .execute()
      * ```
      */
-    stored(): R;
+    stored(): ColumnDefinitionBuilderInterface;
 }
-export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface<ColumnDefinitionBuilder>, OperationNodeSource {
+export declare class ColumnDefinitionBuilder implements ColumnDefinitionBuilderInterface, OperationNodeSource {
     #private;
     constructor(node: ColumnDefinitionNode);
+    /**
+     * Adds `auto_increment` or `autoincrement` to the column definition
+     * depending on the dialect.
+     *
+     * Some dialects like PostgreSQL don't support this. On PostgreSQL
+     * you can use the `serial` or `bigserial` data type instead.
+     */
     autoIncrement(): ColumnDefinitionBuilder;
+    /**
+     * Makes the column the primary key.
+     *
+     * If you want to specify a composite primary key use the
+     * {@link TableBuilder.addPrimaryKeyConstraint} method.
+     */
     primaryKey(): ColumnDefinitionBuilder;
+    /**
+     * Adds a foreign key constraint for the column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id')
+     * ```
+     */
     references(ref: string): ColumnDefinitionBuilder;
+    /**
+     * Adds an `on delete` constraint for the foreign key column.
+     *
+     * If your database engine doesn't support foreign key constraints in the
+     * column definition (like MySQL 5) you need to call the table level
+     * {@link TableBuilder.addForeignKeyConstraint} method instead.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onDelete('cascade')
+     * ```
+     */
     onDelete(onDelete: OnModifyForeignAction): ColumnDefinitionBuilder;
+    /**
+     * Adds an `on update` constraint for the foreign key column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * col.references('person.id').onUpdate('cascade')
+     * ```
+     */
     onUpdate(onUpdate: OnModifyForeignAction): ColumnDefinitionBuilder;
+    /**
+     * Adds a unique constraint for the column.
+     */
     unique(): ColumnDefinitionBuilder;
+    /**
+     * Adds a `not null` constraint for the column.
+     */
     notNull(): ColumnDefinitionBuilder;
+    /**
+     * Adds a `unsigned` modifier for the column.
+     *
+     * This only works on some dialects like MySQL.
+     */
+    unsigned(): ColumnDefinitionBuilder;
+    /**
+     * Adds a default value constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.defaultTo(4))
+     *   .execute()
+     * ```
+     */
     defaultTo(value: DefaultValueExpression): ColumnDefinitionBuilder;
+    /**
+     * Adds a check constraint for the column.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('pet')
+     *   .addColumn('number_of_legs', 'integer', (col) => col.check('number_of_legs < 5'))
+     *   .execute()
+     * ```
+     */
     check(sql: string): ColumnDefinitionBuilder;
+    /**
+     * Makes the column a generated column using a `generated always as` statement.
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)',
+     *     (col) => col.generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *   )
+     *   .execute()
+     * ```
+     */
     generatedAlwaysAs(sql: string): ColumnDefinitionBuilder;
+    /**
+     * Makes a generated column stored instead of virtual. This method can only
+     * be used with {@link generatedAlwaysAs}
+     *
+     * ### Examples
+     *
+     * ```ts
+     * db.schema
+     *   .createTable('person')
+     *   .addColumn('full_name', 'varchar(255)', (col) => col
+     *     .generatedAlwaysAs("concat(first_name, ' ', last_name)")
+     *     .stored()
+     *   )
+     *   .execute()
+     * ```
+     */
     stored(): ColumnDefinitionBuilder;
     toOperationNode(): ColumnDefinitionNode;
 }

package/dist/cjs/schema/column-definition-builder.js

@@ -53,7 +53,10 @@ class ColumnDefinitionBuilder {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unique: true }));
     }
     notNull() {
-        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { nullable: false }));
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { notNull: true }));
+    }
+    unsigned() {
+        return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, { unsigned: true }));
     }
     defaultTo(value) {
         return new ColumnDefinitionBuilder(column_definition_node_js_1.ColumnDefinitionNode.cloneWith(this.#node, {

package/dist/cjs/schema/create-index-builder.d.ts

@@ -30,7 +30,8 @@ export declare class CreateIndexBuilder implements OperationNodeSource, Compilab
     /**
      * Specifies an arbitrary expression for the index.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createIndex('person_first_name_index')

package/dist/cjs/schema/create-index-builder.js

@@ -64,7 +64,8 @@ class CreateIndexBuilder {
     /**
      * Specifies an arbitrary expression for the index.
      *
-     * @example
+     * ### Examples
+     *
      * ```ts
      * await db.schema
      *   .createIndex('person_first_name_index')